def test_rtc9752_tc_rec_004_past_start_time_current_end_time(stream): """ Create a recording with past start time and current end time """ recording = None web_service_obj = None try: start_time = utils.get_formatted_time(constants.SECONDS * -120, TimeFormat.TIME_FORMAT_MS, stream) recording = recording_model.Recording(StartTime=start_time, StreamId=stream) recording_id = recording.get_entry(0).RecordingId web_service_obj = notification_utils.get_web_service_object(recording_id) recording.get_entry(0).UpdateUrl = web_service_obj.get_url() LOGGER.debug("Recording instance created=%s", recording.serialize()) response = a8.create_recording(recording) minimum_start_time = datetime.datetime.utcnow() + datetime.timedelta(0, constants.MINIMUM_SEGMENT_TIME_DIFF) is_valid, error = validate_common.validate_http_response_status_code(response, requests.codes.no_content) assert is_valid, error is_valid, status = validate_recordings.validate_recording(recording_id, web_service_obj, minimum_start_time) assert is_valid, status if status == constants.RecordingStatus.COMPLETE: is_valid, error = validate_recordings.validate_playback(recording_id) assert is_valid, error finally: web_service_obj.stop_server() response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_rtc9734_tc_er_010_playback_redirect_mode(stream, name, copy_type): """ Playback of Active and Archive recording(UNIQUE and COMMON) with DO(Dash Origin) redirect enabled """ recording = None web_service_obj = None try: start_time = utils.get_formatted_time(constants.SECONDS * 30, TimeFormat.TIME_FORMAT_MS, stream) end_time = utils.get_formatted_time(constants.SECONDS * 60, TimeFormat.TIME_FORMAT_MS, stream) recording = recording_model.Recording(StartTime=start_time, EndTime=end_time, StreamId=stream, copyType=copy_type) recording_id = recording.get_entry(0).RecordingId web_service_obj = notification_utils.get_web_service_object( recording_id) recording.get_entry(0).UpdateUrl = web_service_obj.get_url() LOGGER.debug("Recording instance created=%s", recording.serialize()) response = a8.create_recording(recording) is_valid, error = validate_common.validate_http_response_status_code( response, requests.codes.no_content) assert is_valid, error is_valid, error = validate_recordings.validate_recording( recording_id, web_service_obj) assert is_valid, error response = rio.find_recording(recording_id).json() is_valid, error = validate_storage.validate_recording_in_storage( response, Cos.ACTIVE_STORAGE, Cos.RECORDING_STORED) assert is_valid, error is_valid, error = validate_recordings.validate_playback(recording_id) assert is_valid, error if copy_type == RecordingAttribute.COPY_TYPE_UNIQUE: archive_helper.wait_for_archival(stream, recording_id, Archive.ARCHIVE, Archive.IN_PROGRESS) response = rio.find_recording(recording_id).json() is_valid, error = validate_storage.validate_recording_in_storage( response, Cos.ARCHIVE_STORAGE, Cos.RECORDING_STORED) assert is_valid, error is_valid, error = validate_recordings.validate_playback( recording_id) assert is_valid, error finally: if web_service_obj: web_service_obj.stop_server() if recording: response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_rtc9818_tc_rec_029_end_time_before_start_time(stream): """ Create a unique copy recording with end time before start time """ recording = None web_service_obj = None try: start_time = utils.get_formatted_time(constants.SECONDS * 60, TimeFormat.TIME_FORMAT_MS, stream) end_time = utils.get_formatted_time(constants.SECONDS * 30, TimeFormat.TIME_FORMAT_MS, stream) recording = recording_model.Recording(StartTime=start_time, EndTime=end_time, StreamId=stream) recording_id = recording.get_entry(0).RecordingId web_service_obj = notification_utils.get_web_service_object( recording_id) recording.get_entry(0).UpdateUrl = web_service_obj.get_url() LOGGER.debug("Recording instance created=%s", recording.serialize()) response = a8.create_recording(recording) is_valid, error = validate_common.validate_http_response_status_code( response, requests.codes.no_content) assert is_valid, error is_valid, error = validate_recordings.validate_recording( recording_id, web_service_obj) assert not is_valid, error finally: web_service_obj.stop_server() response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_rtc9777_tc_arc_007_archive_playback_re_archive_unique(stream): """ Create a recording with copy type as UNIQUE, wait till archival completes, playback the recording and validate re-archival """ recording = None web_service_obj = None try: start_time = utils.get_formatted_time(constants.SECONDS * 30, TimeFormat.TIME_FORMAT_MS, stream) end_time = utils.get_formatted_time(constants.SECONDS * 60, TimeFormat.TIME_FORMAT_MS, stream) recording = recording_model.Recording(StartTime=start_time, EndTime=end_time, StreamId=stream) recording_id = recording.get_entry(0).RecordingId web_service_obj = notification_utils.get_web_service_object(recording_id) recording.get_entry(0).UpdateUrl = web_service_obj.get_url() LOGGER.debug("Recording instance created=%s", recording.serialize()) response = a8.create_recording(recording) is_valid, error = validate_common.validate_http_response_status_code(response, requests.codes.no_content) assert is_valid, error is_valid, error = validate_recordings.validate_recording(recording_id, web_service_obj) assert is_valid, error archive_helper.wait_for_archival(stream, recording_id, Archive.ARCHIVE, Archive.COMPLETE) response = rio.find_recording(recording_id).json() is_valid, error = validate_storage.validate_recording_in_storage(response, Cos.ARCHIVE_STORAGE, Cos.RECORDING_STORED) assert is_valid, error is_valid, error = validate_recordings.validate_playback_using_vle(recording_id) assert is_valid, error is_valid, error = validate_storage.validate_recording_in_storage(response, Cos.ARCHIVE_STORAGE, Cos.RECORDING_STORED) assert is_valid, error is_valid, error = validate_storage.validate_recording_in_storage(response, Cos.RECON_STORAGE, Cos.RECORDING_STORED) assert is_valid, error archive_helper.wait_for_archival(stream, recording_id, Archive.RE_ARCHIVE, Archive.COMPLETE) is_valid, error = validate_storage.validate_recording_in_storage(response, Cos.ARCHIVE_STORAGE, Cos.RECORDING_STORED) assert is_valid, error is_valid, error = validate_storage.validate_recording_in_storage(response, Cos.RECON_STORAGE, Cos.RECORDING_NOT_STORED) assert is_valid, error finally: web_service_obj.stop_server() response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_create_3hr_recording_ipdvrtests_64(channel, name, copy_type): """ JIRA_URL : https://jira01.engit.synamedia.com/browse/IPDVRTESTS-64 DESCRIPTION : Create 3 hr recording #Partially automated Skipped step(s) : Step 3 - No errors seen in MA/SR pods """ stream = channel web_service_obj = None recording = None stream_name = nsa.get_stream(stream).json()[0][constants.STREAM_NAME] try: #STEP 1 - Create UC and CC recording with longer duration ~3hr start_time = utils.get_formatted_time(constants.SECONDS * 30, TimeFormat.TIME_FORMAT_MS, stream) end_time = utils.get_formatted_time(constants.SECONDS * 10830, TimeFormat.TIME_FORMAT_MS, stream) recording = recording_model.Recording(StartTime=start_time, EndTime=end_time, copyType=copy_type, StreamId=stream) recording_id = recording.get_entry(0).RecordingId web_service_obj = notification_utils.get_web_service_object(recording_id) recording.get_entry(0).UpdateUrl = web_service_obj.get_url() LOGGER.debug("Recording instance created=%s", recording.serialize()) response = a8.create_recording(recording) is_valid, error = validate_common.validate_http_response_status_code(response, requests.codes.no_content) assert is_valid, error #STEP 2 - Verify recording state is complete is_valid, error = validate_recordings.validate_recording(recording_id, web_service_obj) assert is_valid, error #Find recording LOGGER.info("Find recording in rio") response = rio.find_recording(recording_id).json() if not response: return False, ValidationError.RECORDING_RESPONSE_EMPTY.format(recording_id) print "[INFO: ] Recording status in rio : ",response[0]['Status'] #Playback and Validate Playback LOGGER.info("Playback Recording") print "\nPlayback Recording" print "Recording ID :",recording.get_entry(0).RecordingId is_valid, error = validate_recordings.validate_playback(recording.get_entry(0).RecordingId) print "[INFO: ] ",is_valid assert is_valid, error #STEP 4 - memsql table has correct info for UC and CC LOGGER.info("Find recording in rio") response = rio.find_recording(recording_id).json() if not response: return False, ValidationError.RECORDING_RESPONSE_EMPTY.format(recording_id) print "[INFO: ] Recording status in rio : \n" pprint (response, width=1) finally: if web_service_obj: web_service_obj.stop_server() if recording: response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_rtc9816_tc_rec_007_update_stream_id_before_recording_start(stream): """ Create a recording and update the stream ID before the recording starts """ recording = None web_service_obj = None try: start_time = utils.get_formatted_time(constants.SECONDS * 120, TimeFormat.TIME_FORMAT_MS, stream) end_time = utils.get_formatted_time(constants.SECONDS * 150, TimeFormat.TIME_FORMAT_MS, stream) recording = recording_model.Recording(StartTime=start_time, EndTime=end_time, StreamId=stream) recording_id = recording.get_entry(0).RecordingId web_service_obj = notification_utils.get_web_service_object( recording_id) recording.get_entry(0).UpdateUrl = web_service_obj.get_url() LOGGER.debug("Recording instance created=%s", recording.serialize()) response = a8.create_recording(recording) is_valid, error = validate_common.validate_http_response_status_code( response, requests.codes.no_content) assert is_valid, error time.sleep(constants.SECONDS * 60) stream_list_rem = [x for x in STREAM_ID_LIST if x != stream] assert stream_list_rem, ValidationError.STREAM_NOT_CONFIGURED recording.get_entry(0).StreamId = stream_list_rem[0] # Update the previously created recording with the new stream ID response = a8.create_recording(recording) is_valid, error = validate_common.validate_http_response_status_code( response, requests.codes.no_content) assert is_valid, error is_valid, error = validate_streams.validate_stream_id( recording_id, stream_list_rem[0]) assert is_valid, error is_valid, error = validate_recordings.validate_recording( recording_id, web_service_obj) assert is_valid, error is_valid, error = validate_recordings.validate_playback(recording_id) assert is_valid, error finally: web_service_obj.stop_server() response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_tc_des_016_vmr_ntp_out_of_sync(): LOGGER.info("vmr_ntp_out_of_sync test case...") recording = None web_service_obj = None timeout = int(os.environ.get(STREAM_ID)) ntp_server_v2pc = CONFIG_INFO[Component.V2PC][Component.NTP] india_ntp = '1.in.pool.ntp.org' ntp_synchronization_time = 300 # Initiate the recording try: start_time = utils.get_formatted_time((constants.SECONDS * 30) + timeout, TimeFormat.TIME_FORMAT_MS, stream) end_time = utils.get_formatted_time((constants.SECONDS * 90) + timeout, TimeFormat.TIME_FORMAT_MS, stream) recording = recording_model.Recording(StartTime=start_time, EndTime=end_time, StreamId=STREAM_ID) recording_id = recording.get_entry(0).RecordingId web_service_obj = notification_utils.get_web_service_object(recording_id) recording.get_entry(0).UpdateUrl = web_service_obj.get_url() LOGGER.debug("Recording instance created=%s", recording.serialize()) response = a8.create_recording(recording) is_valid, error = validate_common.validate_http_response_status_code(response, requests.codes.no_content) assert is_valid, error time.sleep(40) # Configure to the right ntp server in VMR cmd = "sed -i -E 's/" + ntp_server_v2pc + "/" + india_ntp + "/g' /etc/ntp.conf" update_vmr_ntp_server(cmd) time.sleep(ntp_synchronization_time) # Validate recording is incomplete is_valid, error = validate_recordings.validate_recording(recording_id, web_service_obj) LOGGER.info(is_valid) LOGGER.info(error) assert is_valid, error response = rio.find_recording(recording_id).json() is_valid, error = validate_storage.validate_recording_in_storage(response, Cos.ACTIVE_STORAGE, Cos.RECORDING_STORED) assert is_valid, error is_valid, error = validate_recordings.validate_playback(recording_id) assert is_valid, error finally: # revert back the ntp to the original value in vmr cmd = "sed -i -E 's/" + india_ntp + "/" + ntp_server_v2pc + "/g' /etc/ntp.conf" update_vmr_ntp_server(cmd) time.sleep(ntp_synchronization_time) web_service_obj.stop_server() response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code) # Check whether all the components are synchronized. times_are_synchronized, error = test_setup.are_times_synchronized() if not times_are_synchronized: pytest.fail(error)
def test_rtc9750_tc_rec_002_future_start_time_future_end_time_common(stream): """ Create a recording with future start time, future end time and COMMON copy type """ recording = None web_service_obj = None try: start_time = utils.get_formatted_time(constants.SECONDS * 30, TimeFormat.TIME_FORMAT_MS, stream) end_time = utils.get_formatted_time(constants.SECONDS * 60, TimeFormat.TIME_FORMAT_MS, stream) copy_type = RecordingAttribute.COPY_TYPE_COMMON recording = recording_model.Recording(StartTime=start_time, EndTime=end_time, copyType=copy_type, StreamId=stream) recording_id = recording.get_entry(0).RecordingId web_service_obj = notification_utils.get_web_service_object( recording_id) recording.get_entry(0).UpdateUrl = web_service_obj.get_url() LOGGER.debug("Recording instance created=%s", recording.serialize()) response = a8.create_recording(recording) is_valid, error = validate_common.validate_http_response_status_code( response, requests.codes.no_content) assert is_valid, error is_valid, error = validate_recordings.validate_recording( recording_id, web_service_obj) assert is_valid, error response = rio.find_recording(recording_id).json() is_valid, error = validate_storage.validate_recording_in_storage( response, Cos.ACTIVE_STORAGE, Cos.RECORDING_STORED) assert is_valid, error is_valid, error = validate_storage.validate_recording_in_storage( response, Cos.ACTIVE_STORAGE, Cos.RECORDING_NOT_STORED, 1) assert is_valid, error is_valid, error = validate_recordings.validate_playback(recording_id) assert is_valid, error finally: web_service_obj.stop_server() response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_rtc9737_tc_er_013_vertical_grouping(stream, name, copy_type): """ Vertical Grouping - Enable vertical grouping on all profiles in MA. """ web_service_obj = None recording = None service_name = V2pc.MANIFEST_AGENT stream_name = nsa.get_stream(stream).json()[0][constants.STREAM_NAME] profile_data = v2pc.get_all_stream_profile_data(stream_name) assert len(profile_data)>=3, "Vertical grouping required minimum 3 profile for a stream" try: #Taking backup of v2pc pod config info and editing the config and then restarting the services is_valid, error = cleanup(redeploy_config_map, service_name, revert=True) assert is_valid, error is_valid, error = v2pc_edit_manifest_config(V2pc.MANIFEST_AGENT, vertical_grouping="*") assert is_valid, error start_time = utils.get_formatted_time(constants.SECONDS * 30, TimeFormat.TIME_FORMAT_MS, stream) end_time = utils.get_formatted_time(constants.SECONDS * 60, TimeFormat.TIME_FORMAT_MS, stream) recording = recording_model.Recording(StartTime=start_time, EndTime=end_time, copyType=copy_type, StreamId=stream) recording_id = recording.get_entry(0).RecordingId web_service_obj = notification_utils.get_web_service_object(recording_id) recording.get_entry(0).UpdateUrl = web_service_obj.get_url() LOGGER.debug("Recording instance created=%s", recording.serialize()) response = a8.create_recording(recording) is_valid, error = validate_common.validate_http_response_status_code(response, requests.codes.no_content) assert is_valid, error is_valid, error = validate_recordings.validate_recording(recording_id, web_service_obj) assert is_valid, error is_valid, error = verify_vertical_grouping(recording_id) assert is_valid, error is_valid, error = validate_recordings.validate_playback(recording_id) assert is_valid, error finally: #Revert back the v2pc config changes is_valid, error = cleanup(redeploy_config_map, service_name, revert=True) assert is_valid, error if web_service_obj: web_service_obj.stop_server() if recording: response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_tc10367_restart_channel_when_recording(channel): """ JIRA ID : IPDVRTESTS-58 JIRA Link : https://jira01.engit.synamedia.com/browse/IPDVRTESTS-58 TC10367: Restart the channel during recording and then playback """ stream = channel recording = None web_service_obj = None try: rec_buffer_time = utils.get_rec_duration( dur_confg_key=Component.REC_BUFFER_LEN_IN_SEC) rec_duration = utils.get_rec_duration() start_time = utils.get_formatted_time( (constants.SECONDS * rec_buffer_time), TimeFormat.TIME_FORMAT_MS, stream) end_time = utils.get_formatted_time( (constants.SECONDS * (rec_buffer_time + rec_duration)), TimeFormat.TIME_FORMAT_MS, stream) copy_type = RecordingAttribute.COPY_TYPE_UNIQUE LOGGER.debug("Stream Id : %s", stream) recording = recording_model.Recording(StartTime=start_time, EndTime=end_time, copyType=copy_type, StreamId=stream) recording_id = recording.get_entry(0).RecordingId LOGGER.info("Recording Id :%s", recording_id) web_service_obj = notification_utils.get_web_service_object( recording_id) recording.get_entry(0).UpdateUrl = web_service_obj.get_url() LOGGER.debug("Recording instance created=%s", recording.serialize()) response = a8.create_recording(recording) is_valid, error = validate_common.validate_http_response_status_code( response, requests.codes.no_content) assert is_valid, error LOGGER.info("Restart Channel : %s", stream) # Restart the stream is_valid, error = v2pc.restart_stream(stream, count=3) assert is_valid, error is_valid, error = validate_recordings.validate_recording( recording_id, web_service_obj) assert is_valid, error finally: if web_service_obj: web_service_obj.stop_server() response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_rtc9744_tc_er_018_private_copy(stream, name, copy_type): """ Private copy - Archive/Pre-gen """ web_service_obj = None recording = None stream = str(private_copy_stream) try: start_time = utils.get_formatted_time(constants.SECONDS * 30, TimeFormat.TIME_FORMAT_MS, stream) end_time = utils.get_formatted_time(constants.SECONDS * 80, TimeFormat.TIME_FORMAT_MS, stream) recording = recording_model.Recording(StartTime=start_time, EndTime=end_time, StreamId=stream) recording_id = recording.get_entry(0).RecordingId web_service_obj = notification_utils.get_web_service_object( recording_id) recording.get_entry(0).UpdateUrl = web_service_obj.get_url() LOGGER.debug("Recording instance created=%s", recording.serialize()) response = a8.create_recording(recording) is_valid, error = validate_common.validate_http_response_status_code( response, requests.codes.no_content) assert is_valid, error is_valid, error = validate_recordings.validate_recording( recording_id, web_service_obj) assert is_valid, error # wait for georbage collect archive_helper.wait_for_archival(stream, recording_id, Archive.ARCHIVE, Archive.COMPLETE) response = rio.find_recording(recording_id).json() is_valid, error = validate_storage.validate_recording_in_storage( response, Cos.ARCHIVE_STORAGE, Cos.RECORDING_STORED) assert is_valid, error finally: if web_service_obj: web_service_obj.stop_server() if recording: response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_rtc9773_tc_arc_003_common(stream): """ Create a recording with copy type as COMMON and check whether archival is happening or not """ recording = None web_service_obj = None try: start_time = utils.get_formatted_time(constants.SECONDS * 30, TimeFormat.TIME_FORMAT_MS, stream) end_time = utils.get_formatted_time(constants.SECONDS * 60, TimeFormat.TIME_FORMAT_MS, stream) copy_type = RecordingAttribute.COPY_TYPE_COMMON recording = recording_model.Recording(StartTime=start_time, EndTime=end_time, StreamId=stream, copyType=copy_type) recording_id = recording.get_entry(0).RecordingId web_service_obj = notification_utils.get_web_service_object( recording_id) recording.get_entry(0).UpdateUrl = web_service_obj.get_url() LOGGER.debug("Recording instance created=%s", recording.serialize()) response = a8.create_recording(recording) is_valid, error = validate_common.validate_http_response_status_code( response, requests.codes.no_content) assert is_valid, error is_valid, error = validate_recordings.validate_recording( recording_id, web_service_obj) assert is_valid, error archive_helper.wait_for_archival(stream, recording_id, Archive.ARCHIVE, Archive.IN_PROGRESS) response = rio.find_recording(recording_id).json() is_valid, error = validate_storage.validate_recording_in_storage( response, Cos.ARCHIVE_STORAGE, Cos.RECORDING_STORED) assert is_valid, error is_valid, error = validate_recordings.validate_playback(recording_id) assert is_valid, error finally: web_service_obj.stop_server() response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_rtc9775_tc_arc_005_playback_archive_in_progress(stream): """ Create a recording with copy type as UNIQUE and play it back when archival is in progress """ recording = None web_service_obj = None try: start_time = utils.get_formatted_time(constants.SECONDS * 30, TimeFormat.TIME_FORMAT_MS, stream) end_time = utils.get_formatted_time(constants.SECONDS * 90, TimeFormat.TIME_FORMAT_MS, stream) recording = recording_model.Recording(StartTime=start_time, EndTime=end_time, StreamId=stream) recording_id = recording.get_entry(0).RecordingId web_service_obj = notification_utils.get_web_service_object(recording_id) recording.get_entry(0).UpdateUrl = web_service_obj.get_url() LOGGER.debug("Recording instance created=%s", recording.serialize()) response = a8.create_recording(recording) is_valid, error = validate_common.validate_http_response_status_code(response, requests.codes.no_content) assert is_valid, error is_valid, error = validate_recordings.validate_recording(recording_id, web_service_obj) assert is_valid, error archive_helper.wait_for_archival(stream, recording_id, Archive.ARCHIVE, Archive.IN_PROGRESS) response = rio.find_recording(recording_id).json() is_valid, error = validate_storage.validate_recording_in_storage(response, Cos.ARCHIVE_STORAGE, [Cos.RECORDING_STORED, Cos.RECORDING_PARTIALLY_STORED]) assert is_valid, error is_valid, error = validate_recordings.validate_playback_using_vle(recording_id) assert is_valid, error # If we playback recording when archival is INPROGRESS, There is a chance of few segments being played from # Active storage. This means that only part of the segments would move from archive to recon. # The rest will move from active to archive. So both PARTIALLY_STORED and STORED are valid is_valid, error = validate_storage.validate_recording_in_storage(response, Cos.RECON_STORAGE, [Cos.RECORDING_STORED, Cos.RECORDING_PARTIALLY_STORED]) assert is_valid, ValidationError.SEGMENT_NOT_MOVED.format(Cos.RECON_STORAGE, recording_id) finally: web_service_obj.stop_server() response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_sanity_hybrid_copy(stream, name, copy_type): """ Schedule UNIQUE and COMMON copy on same channel and verify the recording and playback. """ recording = None web_service_obj = None try: start_time = utils.get_formatted_time(constants.SECONDS * 30, TimeFormat.TIME_FORMAT_MS, stream) end_time = utils.get_formatted_time(constants.SECONDS * 80, TimeFormat.TIME_FORMAT_MS, stream) recording = recording_model.Recording(StartTime=start_time, EndTime=end_time, StreamId=stream, copyType=copy_type) recording_id = recording.get_entry(0).RecordingId web_service_obj = notification_utils.get_web_service_object( recording_id) recording.get_entry(0).UpdateUrl = web_service_obj.get_url() LOGGER.debug("Recording instance created=%s", recording.serialize()) response = a8.create_recording(recording) is_valid, error = validate_common.validate_http_response_status_code( response, requests.codes.no_content) assert is_valid, error is_valid, error = validate_recordings.validate_recording( recording_id, web_service_obj) assert is_valid, error archive_helper.wait_for_archival(stream, recording_id, Archive.ARCHIVE, Archive.COMPLETE) response = rio.find_recording(recording_id).json() is_valid, error = validate_storage.validate_recording_in_storage( response, Cos.ACTIVE_STORAGE, Cos.RECORDING_NOT_STORED) assert is_valid, error is_valid, error = validate_storage.validate_recording_in_storage( response, Cos.ARCHIVE_STORAGE, Cos.RECORDING_STORED) assert is_valid, error is_valid, error = validate_recordings.validate_playback(recording_id) assert is_valid, error finally: web_service_obj.stop_server() response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_sanity_rtc10065_private_copy(stream): """ Schedule Private copy and verify the recording and playback. """ recording = None web_service_obj = None stream = str(private_copy_stream) try: start_time = utils.get_formatted_time(constants.SECONDS * 30, TimeFormat.TIME_FORMAT_MS, stream) end_time = utils.get_formatted_time(constants.SECONDS * 80, TimeFormat.TIME_FORMAT_MS, stream) recording = recording_model.Recording(StartTime=start_time, EndTime=end_time, StreamId=stream) recording_id = recording.get_entry(0).RecordingId web_service_obj = notification_utils.get_web_service_object( recording_id) recording.get_entry(0).UpdateUrl = web_service_obj.get_url() LOGGER.debug("Recording instance created=%s", recording.serialize()) response = a8.create_recording(recording) is_valid, error = validate_common.validate_http_response_status_code( response, requests.codes.no_content) assert is_valid, error is_valid, error = validate_recordings.validate_recording( recording_id, web_service_obj) assert is_valid, error response = rio.find_recording(recording_id).json() is_valid, error = validate_storage.validate_recording_in_storage( response, Cos.ACTIVE_STORAGE, Cos.RECORDING_STORED) assert is_valid, error is_valid, error = validate_recordings.validate_playback(recording_id) assert is_valid, error finally: if web_service_obj: web_service_obj.stop_server() if recording: response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_tc_ply_lang(name, stream, audio_lang): """ Playback recording using different audio languages like eng, fre and spa and validate playback """ recording = None web_service_obj = None try: start_time = utils.get_formatted_time(constants.SECONDS * 30, TimeFormat.TIME_FORMAT_MS, stream) end_time = utils.get_formatted_time(constants.SECONDS * 60, TimeFormat.TIME_FORMAT_MS, stream) copy_type = RecordingAttribute.COPY_TYPE_UNIQUE recording = recording_model.Recording(StartTime=start_time, EndTime=end_time, copyType=copy_type, StreamId=stream) recording_id = recording.get_entry(0).RecordingId web_service_obj = notification_utils.get_web_service_object( recording_id) recording.get_entry(0).UpdateUrl = web_service_obj.get_url() LOGGER.debug("Recording instance created=%s", recording.serialize()) response = a8.create_recording(recording) is_valid, error = validate_common.validate_http_response_status_code( response, requests.codes.no_content) assert is_valid, error is_valid, error = validate_recordings.validate_recording( recording_id, web_service_obj) assert is_valid, error vle_request_params = {} LOGGER.debug( "Configuring vle to playback with clients=%s and audio language=%s", 1, audio_lang) vle_request_params[Vle.CLIENTS_NUM_MAX] = 1 vle_request_params[Vle.AUDIO_LANGUAGE] = audio_lang is_valid, error = validate_recordings.validate_playback( recording_id, VLE_REQUEST_PARAMS=vle_request_params) assert is_valid, error finally: web_service_obj.stop_server() response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_tc_ply_stream_style(name, stream, stream_style): """ Playback vle using multiple/single bit rates and using different stream styles """ recording = None web_service_obj = None try: start_time = utils.get_formatted_time(constants.SECONDS * 30, TimeFormat.TIME_FORMAT_MS, stream) end_time = utils.get_formatted_time(constants.SECONDS * 60, TimeFormat.TIME_FORMAT_MS, stream) copy_type = RecordingAttribute.COPY_TYPE_UNIQUE recording = recording_model.Recording(StartTime=start_time, EndTime=end_time, copyType=copy_type, StreamId=stream) recording_id = recording.get_entry(0).RecordingId web_service_obj = notification_utils.get_web_service_object(recording_id) recording.get_entry(0).UpdateUrl = web_service_obj.get_url() LOGGER.debug("Recording instance created=%s", recording.serialize()) response = a8.create_recording(recording) is_valid, error = validate_common.validate_http_response_status_code(response, requests.codes.no_content) assert is_valid, error is_valid, error = validate_recordings.validate_recording(recording_id, web_service_obj) assert is_valid, error vle_request_params = {} LOGGER.debug("Configuring vle to playback with clients=%s and stream style=%s", 1, stream_style) vle_request_params[Vle.CLIENTS_NUM_MAX] = 1 vle_request_params[Vle.STREAM_STYLE] = stream_style if Vle.STREAM_STYLE_DEFAULT == stream_style: is_valid, msg = utils.get_video_profiles_from_m3u8(recording_id) assert is_valid, msg # If Valid, msg will contain the list of video profiles assert msg, ValidationError.VIDEO_PROFILES_NOT_FOUND.format(recording_id) vle_request_params[Vle.DOWNLOAD_BITRATE] = msg[0] is_valid, error = validate_recordings.validate_playback(recording_id, VLE_REQUEST_PARAMS=vle_request_params) assert is_valid, error finally: web_service_obj.stop_server() response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_rtc9771_tc_ply_009_playback_subtitles(stream): """ Playback recording with subtitles and validate playback in Direct Mode """ recording = None web_service_obj = None try: start_time = utils.get_formatted_time(constants.SECONDS * 30, TimeFormat.TIME_FORMAT_MS, stream) end_time = utils.get_formatted_time(constants.SECONDS * 60, TimeFormat.TIME_FORMAT_MS, stream) recording = recording_model.Recording(StartTime=start_time, EndTime=end_time, StreamId=stream) recording_id = recording.get_entry(0).RecordingId web_service_obj = notification_utils.get_web_service_object( recording_id) recording.get_entry(0).UpdateUrl = web_service_obj.get_url() LOGGER.debug("Recording instance created=%s", recording.serialize()) response = a8.create_recording(recording) is_valid, error = validate_common.validate_http_response_status_code( response, requests.codes.no_content) assert is_valid, error is_valid, error = validate_recordings.validate_recording( recording_id, web_service_obj) assert is_valid, error vle_request_params = {} LOGGER.debug( "Configuring vle to playback with subtitle in VMR direct mode") vle_request_params[Vle.VLE_CALL_FLOW_KEY] = Vle.VLE_CALL_FLOW_SUBTITLE is_valid, error = validate_recordings.validate_playback( recording_id, VLE_REQUEST_PARAMS=vle_request_params) assert is_valid, error finally: web_service_obj.stop_server() response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_deleted_recording_cannot_be_played_back_ipdvrtests_166( common_lib, stream): """ JIRA ID : IPDVRTESTS-166 JIRA LINK : https://jira01.engit.synamedia.com/browse/IPDVRTESTS-166 """ recording = None web_service_obj = None try: # Step1: Create a 30 minute recording recording, web_service_obj = common_lib.create_recording( stream, rec_duration=Component.LARGE_REC_LEN_IN_SEC) recording_id = recording.get_entry(0).RecordingId is_valid, error = validate_recordings.validate_recording( recording_id, web_service_obj) assert is_valid, error # Step2: Delete the recording response = a8.delete_recording(recording) is_valid, error = validate_common.validate_http_response_status_code( response, requests.codes.no_content) assert is_valid, error is_valid, error = validate_recordings.validate_recording_deletion( recording_id) assert is_valid, error # Step 3: Validating playback is_valid, error = validate_recordings.validate_playback_using_vle( recording_id) assert not is_valid, ValidationError.DELETED_RECORDING_PLAYED_BACK.format( recording_id) finally: if web_service_obj: web_service_obj.stop_server() if recording: response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_rtc9753_tc_rec_006_current_start_time_future_end_time(stream): """ Create a recording with current start time and future end time """ recording = None web_service_obj = None try: end_time = utils.get_formatted_time(constants.SECONDS * 60, TimeFormat.TIME_FORMAT_MS, stream) recording = recording_model.Recording(EndTime=end_time, StreamId=stream) recording_id = recording.get_entry(0).RecordingId web_service_obj = notification_utils.get_web_service_object( recording_id) recording.get_entry(0).UpdateUrl = web_service_obj.get_url() LOGGER.debug("Recording instance created=%s", recording.serialize()) response = a8.create_recording(recording) is_valid, error = validate_common.validate_http_response_status_code( response, requests.codes.no_content) assert is_valid, error is_valid, status = validate_recordings.validate_recording( recording_id, web_service_obj) assert is_valid, status if status == constants.RecordingStatus.COMPLETE: is_valid, error = validate_recordings.validate_playback( recording_id) assert is_valid, error finally: web_service_obj.stop_server() response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_dash_wv_pid_based_audio_filtering_ipdvrtests_143(channel): """ JIRA_URL: https://jira01.engit.synamedia.com/browse/IPDVRTESTS-143 DESCRIPTION: Filtering Audio PID in dash templated and playback with encryption """ package_format = '' key_profile_ref = '' template_name = None pubished_template_data = None generic_conf = utils.get_spec_config() web_service_obj = None recording = None metadata = None try: audio_pids = utils.get_audio_pids(channel, V2PC_EXIST) LOGGER.info("Available Audio PIDs : {0}".format(audio_pids)) assert len(audio_pids.keys()) >= 2, ValidationError.NO_AUDIO_PID filter_pids = audio_pids.items()[-1] LOGGER.info("filtered pids {0}".format(filter_pids)) filter_pid_payload = { 'action': 'disable', 'pid': str(filter_pids[0]), 'codec': 'DD/' + str(filter_pids[1]).upper(), 'type': 'audio' } LOGGER.info("filtering %s pid from audio pids " % (str(filter_pids[0]))) LOGGER.info("Audio pids that is available in manifest ") templates_list_resp = v2pc_api.get_all_v2pc_templates() assert templates_list_resp.status_code == requests.codes.ok, ValidationError.INCORRECT_HTTP_RESPONSE_STATUS_CODE.format( templates_list_resp.status_code, templates_list_resp.reason, templates_list_resp.url) templt_list = json.loads(templates_list_resp.content) for templt in templt_list: if templt.get('properties'): key_profile_ref = templt['properties'].get('keyProfileRef', '').split('.')[-1] package_format = templt['properties'].get('packageFormat', "") if (key_profile_ref == V2pc.DASH_TEMPLATE_KEY_PROFILE) and (package_format == V2pc.DASH_TEMPLATE_PACKAGE_FORMAT): template_name = templt['name'] pubished_template_data = templt break assert key_profile_ref and package_format, ValidationError.DASH_WV_TEMPLATE_UNAVAILABLE LOGGER.info("Published Template Data {0}".format(pubished_template_data)) keys_to_remove = ["externalId", "modified", "sysMeta", "transactionId", "type"] metadata = dict([(k, v) for k, v in pubished_template_data.items() if k not in keys_to_remove]) LOGGER.info("Modified metadata : {0}".format(metadata)) metadata_modified = metadata.copy() stream_config = metadata_modified['properties']['streamConfiguration'] metadata_modified['properties']['streamConfiguration'] = [] metadata_modified['properties']['streamConfiguration'].append(filter_pid_payload) # Filtering publish templated with PIDs LOGGER.info("Payload to publish template : {0}".format(metadata_modified)) update_template = v2pc_helper.put_publish_template(metadata_modified, template=template_name) assert update_template, "Unable to update the published template with renamed segment" # Restart the workflow result, response = v2pc_helper.restart_media_workflow(generic_conf[Component.WORK_FLOW][Component.WORKFLOW_NAME]) assert result, response result, response = v2pc_helper.waits_till_workflow_active(generic_conf[Component.WORK_FLOW][Component.WORKFLOW_NAME]) assert result, response # Step 1: Create a recording for 30 mins.. rec_buffer_time = utils.get_rec_duration(dur_confg_key=Component.REC_BUFFER_LEN_IN_SEC) rec_duration = utils.get_rec_duration(dur_confg_key=Component.LARGE_REC_LEN_IN_SEC) start_time = utils.get_formatted_time((constants.SECONDS * rec_buffer_time), TimeFormat.TIME_FORMAT_MS, channel) end_time = utils.get_formatted_time((constants.SECONDS * (rec_buffer_time + rec_duration)), TimeFormat.TIME_FORMAT_MS, channel) recording = recording_model.Recording(StartTime=start_time, EndTime=end_time, StreamId=channel) recording_id = recording.get_entry(0).RecordingId web_service_obj = notification_utils.get_web_service_object(recording_id) recording.get_entry(0).UpdateUrl = web_service_obj.get_url() LOGGER.debug("Recording instance created=%s", recording.serialize()) response = a8.create_recording(recording) is_valid, error = validate_common.validate_http_response_status_code(response, requests.codes.no_content) assert is_valid, error is_valid, error = validate_recordings.validate_recording(recording_id, web_service_obj) assert is_valid, error # Step 2: Playback using DASH publish template configured to filter based on audio PIDs LOGGER.info("Playback Recording with Dash Widevine") is_valid, error = validate_recordings.validate_playback(recording_id, playback_types=[PlaybackTypes.DASH_WV, ]) assert is_valid, error filtered_pids2 = [] result = True # Step 3: Verify output of manifest curl to match filtering configured in publish template playback_url = utils.get_mpe_playback_url(recording_id, playback_type=PlaybackTypes.DASH_WV) resp = requests.get(playback_url) xml_val = utils.xml_dict(resp.content) LOGGER.info("DASH WV MPD Manifest details : {0}".format(xml_val)) if xml_val["MPD"]["Period"]: for period in xml_val["MPD"]["Period"]: for adt_set in period["AdaptationSet"]: if adt_set.has_key('contentType') and adt_set['contentType'] == Feed.AUDIO: for rep in adt_set["Representation"]: LOGGER.info("representation list {0}".format(rep)) pids_picked = re.findall(re.compile('audio_\d*'),rep["id"])[-1].replace("audio_", '') if pids_picked: filtered_pids2.append(pids_picked) LOGGER.info("filtered_pids2 : {0}".format(filtered_pids2)) if filtered_pids2 and (len(filtered_pids2) < len(audio_pids)) and (str(filter_pids[0]) not in filtered_pids2): message = "audio pids filtered successfully" else: message = "filtering not happened properly" result = False assert result, message finally: if web_service_obj: web_service_obj.stop_server() if recording: a8.delete_recording(recording) LOGGER.info("recording details destroyed.. ") if metadata: update_template = v2pc_helper.put_publish_template(metadata, template=template_name) assert update_template, "Unable to revert the published template" result, response = v2pc_helper.restart_media_workflow(generic_conf[Component.WORK_FLOW][Component.WORKFLOW_NAME]) assert result, response
def test_rtc9804_tc_des_011_mce_ni_packet_latency(): """ Introduce the latency on each packet on the outgoing MCE Interface, trigger a recording and verify if the recording is successful """ ssh_client = None response = None web_service_obj = None start_duration = 30 try: rev_cmds = {} mce_nodes = v2pc.get_app_worker_nodes(MCE_INSTANCE, COMPONENT_NAME) for mce_node in mce_nodes: mce_data_out = mce_node[Interface.DATA_OUT] mce_ip = mce_node[Component.IP] ssh_client = utils.get_ssh_client(COMPONENT_NAME, COMPONENT_USERNAME, component_ip=mce_ip) # deleting the previously scheduled jobs by other test cases, in order not to tamper with the current test case destructive_utils.delete_scheduled_job(COMPONENT_NAME, ssh_client, mce_ip, destructive.MCE_JOB_IDS) rev_cmds[mce_ip] = destructive_utils.schedule_rev_cmd( ssh_client, mce_data_out, mce_ip, destructive.MCE_JOB_IDS, constants.MINUTES * 10) des_cmd = DestructiveTesting.PACKET_LATENCY_OUTGOING_INTERFACE.format( mce_data_out, DestructiveTesting.PACKET_LATENCY) des_cmd = destructive_utils.get_outgoing_tc_cmd( mce_data_out, des_cmd) # expected outcome after the destructive commands are run expected_result = { DestructiveTesting.DELAY: DestructiveTesting.PACKET_LATENCY, DestructiveTesting.DST: DestructiveTesting.NETWORK } is_des_effective, error = destructive_utils.exec_des_cmd( ssh_client, mce_data_out, des_cmd, expected_result) assert is_des_effective, error start_time = utils.get_formatted_time( constants.SECONDS * start_duration, TimeFormat.TIME_FORMAT_MS, STREAM_ID) end_time = utils.get_formatted_time(constants.SECONDS * 90, TimeFormat.TIME_FORMAT_MS, STREAM_ID) response = destructive_utils.create_recording_des(start_time, end_time) web_service_obj = response[RecordingAttribute.WEB_SERVICE_OBJECT] recording_id = response[RecordingAttribute.RECORDING_ID] is_valid, error = validate_recordings.validate_recording( recording_id, web_service_obj) assert is_valid, error is_valid, error = validate_recordings.validate_playback(recording_id) assert is_valid, error # executing the revert command to undo the destructive commands for mce_node in mce_nodes: mce_ip = mce_node[Component.IP] mce_data_out = mce_node[Interface.DATA_OUT] ssh_client = utils.get_ssh_client(COMPONENT_NAME, COMPONENT_USERNAME, component_ip=mce_ip) if rev_cmds[mce_ip]: rev_effective, error = destructive_utils.exec_rev_cmd( COMPONENT_NAME, ssh_client, mce_ip, rev_cmds[mce_ip], mce_data_out, destructive.MCE_JOB_IDS) else: rev_effective, error = destructive_utils.is_rev_effective( ssh_client, mce_data_out) assert rev_effective, error # running sanity test to check if the setup is back to normal after reverting the commands test_rtc9723_tc_rec_001_future_start_time_future_end_time(STREAM_ID) finally: if ssh_client: ssh_client.close() if web_service_obj: web_service_obj.stop_server() if response: response = a8.delete_recording( response[RecordingAttribute.RECORDING]) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_filter_video_based_on_rank_ipdvrtests_235(channel): """ JIRA ID : IPDVRTESTS-235 JIRA Link : https://jira01.engit.synamedia.com/browse/IPDVRTESTS-235 Description: DASH-Confirm MPE publish template to filter video based on rank """ stream = channel recording = None metadata = None web_service_obj = None try: source_xml = utils.get_source_mpd_content(stream) bit_res = utils.get_bitrates_resolutions(source_xml) bitrates = bit_res.keys() assert len(bitrates) >= 2, "Not enough video profiles in the selected stream to filter" # Step1: Configure Variants in MPE publish template to filter video based on rank push_payload = { "name": "default", "order": "rank", "selectivePublish": "true", "profileOrdering": [ { "rank": "1" }, { "rank": "2" } ] } generic_config = utils.get_spec_config() key_profile = generic_config[Component.WORK_FLOW][Component.KEY_PROFILE_DASH_WIDEVINE] response, published_template_data, template_name = v2pc_helper.get_publish_template_by_format(template_format=V2pc.DASH_TEMPLATE_PACKAGE_FORMAT, key_profile=key_profile) assert response, "Cannot find the template data for the given format/key profile" LOGGER.debug("Published Template Data : %s", published_template_data) keys_to_be_removed = V2pc.OTHER_KEYS metadata = dict([(key, value) for key, value in published_template_data.items() if key not in keys_to_be_removed]) LOGGER.debug("Modified metadata : %s", metadata) metadata_modified = metadata.copy() metadata_modified['properties']["variants"] = [push_payload, ] LOGGER.debug("modified publish template : %s", metadata_modified) update_template = v2pc.put_publish_template(metadata_modified, template=template_name) assert update_template, "Unable to update the published template with renamed segment" result, response = v2pc.restart_media_workflow(generic_config[Component.WORK_FLOW][Component.WORKFLOW_NAME]) assert result, response result, response = v2pc_helper.waits_till_workflow_active(generic_config[Component.WORK_FLOW][Component.WORKFLOW_NAME], 120) assert result, response # Step2: Create 30 minute recording LOGGER.info("Creating Recording") rec_buffer_time = utils.get_rec_duration(dur_confg_key=Component.REC_BUFFER_LEN_IN_SEC) rec_duration = utils.get_rec_duration(dur_confg_key=Component.LARGE_REC_LEN_IN_SEC) start_time = utils.get_formatted_time((constants.SECONDS * rec_buffer_time), TimeFormat.TIME_FORMAT_MS, stream) end_time = utils.get_formatted_time((constants.SECONDS * (rec_buffer_time + rec_duration)), TimeFormat.TIME_FORMAT_MS, stream) recording = recording_model.Recording(StartTime=start_time, EndTime=end_time, StreamId=stream) recording_id = recording.get_entry(0).RecordingId web_service_obj = notification_utils.get_web_service_object(recording_id) recording.get_entry(0).UpdateUrl = web_service_obj.get_url() LOGGER.debug("Recording instance created=%s", recording.serialize()) response = a8.create_recording(recording) is_valid, error = validate_common.validate_http_response_status_code(response, requests.codes.no_content) assert is_valid, error playback_url = utils.get_mpe_playback_url(recording_id, PlaybackTypes.DASH_WV) is_valid, error = validate_recordings.validate_recording(recording_id, web_service_obj) assert is_valid, error # step3: Check for manifest for the variants using curl mpd_res = requests.get(playback_url) res_bitrates = [] result_dict = utils.xml_dict(mpd_res.content) for repre in result_dict['MPD']['Period'][0]['AdaptationSet']: if repre.has_key("Representation") and repre.has_key("contentType") and repre["contentType"] == 'video': for rate in repre["Representation"]: if "video" in rate['id'] and int(rate['bandwidth']) not in res_bitrates: res_bitrates.append(int(rate['bandwidth'])) strip_value = len(push_payload["profileOrdering"]) - len(bitrates) if strip_value != 0: assert sorted(bitrates)[::-1][0:strip_value] == res_bitrates, "Video bitrates are not filtered based on rank given in publish template" else: assert sorted(bitrates)[::-1] == res_bitrates, "Video bitrates are not filtered based on rank given in publish template" finally: if metadata: LOGGER.info("Reverting the publish template changes") update_template = v2pc.put_publish_template(metadata, template=template_name) assert update_template, "Unable to update the publish template" result, response = v2pc.restart_media_workflow(generic_config[Component.WORK_FLOW][Component.WORKFLOW_NAME]) assert result, response result, response = v2pc_helper.waits_till_workflow_active(generic_config[Component.WORK_FLOW][Component.WORKFLOW_NAME],120) assert result, response if web_service_obj: web_service_obj.stop_server() if recording: response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_ipdvrtests59_restart_workflow_no_v2pc(channel): recording = None web_service_obj = None mce_wf_name = mpe_wf_name = None try: start_time = utils.get_formatted_time( (constants.SECONDS * 30), TimeFormat.TIME_FORMAT_MS, channel) end_time = utils.get_formatted_time((constants.SECONDS * 60), TimeFormat.TIME_FORMAT_MS, channel) copy_type = RecordingAttribute.COPY_TYPE_UNIQUE LOGGER.debug("Stream Id : %s", channel) recording = recording_model.Recording(StartTime=start_time, EndTime=end_time, copyType=copy_type, StreamId=channel) recording_id = recording.get_entry(0).RecordingId LOGGER.info("Recording Id :%s", recording_id) # Create a notification handler web_service_obj = notification_utils.get_web_service_object( recording_id) recording.get_entry(0).UpdateUrl = web_service_obj.get_url() LOGGER.debug("Recording instance created :%s", recording.serialize()) # Create a Recording response = a8.create_recording(recording) is_valid, error = validate_common.validate_http_response_status_code( response, requests.codes.no_content) assert is_valid, error is_valid, error = validate_recordings.validate_recording( recording_id, web_service_obj) assert is_valid, error # Get the Capture only [MCE] workflow mce_wf_name = \ CONFIG_INFO[Component.GENERIC_CONFIG][constants.Component.STANDALONE][constants.Component.WORK_FLOW][ constants.Component.CAPTURE_ONLY_WORKFLOW] LOGGER.info("MCE WorkFlow Name : %s", mce_wf_name) # Get the Playback only [MPE] workflow mpe_wf_name = \ CONFIG_INFO[Component.GENERIC_CONFIG][constants.Component.STANDALONE][constants.Component.WORK_FLOW][ constants.Component.WORKFLOW_NAME] LOGGER.info("MPE WorkFlow Name : %s", mpe_wf_name) # resp = v2pcapi.fetch_workflow_status(mce_wf_name) # LOGGER.info("MCE MediaWorkflow : %s", resp.content) # Verify Channel Capturing status channel_res, response = v2pcapi.verify_channel_state( channel, Stream.CAPTURING) assert channel_res, "Channel is in %s state" % response # Step 1: Disable a running Capture only [MCE] workflow. stop_mce_result, stop_mce_resp = v2pcapi.workflow_change_state( mce_wf_name, MediaWorkflow.DISABLE, time_out=120) assert stop_mce_result, stop_mce_resp # Verify Channel Capturing status is stopped channel_res, ch_response = v2pcapi.verify_channel_state( channel, Stream.CAPTURING) assert not channel_res, ch_response # Step 2: Enable the workflow again start_mce_rslt, start_mce_resp = v2pcapi.workflow_change_state( mce_wf_name, MediaWorkflow.ENABLE, time_out=120) assert start_mce_rslt, start_mce_resp # Check channel goes back to Capturing state channel_result1, ch_resp1 = v2pcapi.verify_channel_state( channel, Stream.CAPTURING) assert channel_result1, "Channel State : %s" % ch_resp1 # Step 2a: Restart the Playback only workflow # resp2 = v2pcapi.fetch_workflow_status(mpe_wf_name) # LOGGER.info("MPE MediaWorkflow : %s", resp2.content) # Disable a running Playback only [MPE] workflow. stop_mpe_wf_result, stop_resp2 = v2pcapi.workflow_change_state( mpe_wf_name, MediaWorkflow.DISABLE, time_out=120) assert stop_mpe_wf_result, stop_resp2 # Enable the MPE workflow again start_mpe_wf_result, stop_resp3 = v2pcapi.workflow_change_state( mpe_wf_name, MediaWorkflow.ENABLE, time_out=120) assert start_mpe_wf_result, stop_resp3 # Step 3: Validate the playback is_valid, error = validate_recordings.validate_playback_using_vle( recording_id) assert is_valid, error # Check MCE CoreDump LOGGER.debug("Validating MCE core dump") is_valid, error = core_dump("mce") assert is_valid, error # Check MPE Logs and CoreDump # It can not be automated - Can not get the core dump for standalone installation of MPE # Todo: Need to update this step once the MPE team provides support. finally: if mce_wf_name: v2pcapi.workflow_change_state(mce_wf_name, MediaWorkflow.ENABLE, time_out=120) if mpe_wf_name: v2pcapi.workflow_change_state(mpe_wf_name, MediaWorkflow.ENABLE, time_out=120) if web_service_obj: web_service_obj.stop_server() if recording: response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_tc_rec(name, stream, copy_type): """ Updating end time of shorter unique copy recording after shorter recording completed, and longer recording in progress. """ total_recordings = 2 validate_rec_wait_time = 240 recording = None web_service_objs = [] recording_pool = None try: queue = Queue.Queue() start_time = utils.get_formatted_time(constants.SECONDS * 30, TimeFormat.TIME_FORMAT_MS, stream) end_time = utils.get_formatted_time(constants.SECONDS * 60, TimeFormat.TIME_FORMAT_MS, stream) recording = recording_model.Recording( total_recordings=total_recordings, StartTime=start_time, EndTime=end_time, copyType=copy_type, StreamId=stream) for i in range(total_recordings): recording_id = recording.get_entry(i).RecordingId web_service_objs.append( notification_utils.get_web_service_object(recording_id)) recording.get_entry(i).UpdateUrl = web_service_objs[i].get_url() LOGGER.debug("Recording=%s, UpdateURL=%s", recording_id, web_service_objs[i].get_url()) recording.get_entry(1).EndTime = utils.get_formatted_time( constants.SECONDS * 80, TimeFormat.TIME_FORMAT_MS, stream) LOGGER.debug("Recording instance created=%s", recording.serialize()) response = a8.create_recording(recording) is_valid, error = validate_common.validate_http_response_status_code( response, requests.codes.no_content) assert is_valid, error # Validating longer recording parallel recording_id_1 = recording.get_entry(1).RecordingId # recording_pool = mp_pool.ThreadPool(processes=2) recording_pool = mp_pool.ThreadPool() recording_pool.apply_async(validate_recordings.validate_recording, (recording_id_1, web_service_objs[1]), callback=queue.put) # Validating shorter recording to complete recording_id_0 = recording.get_entry(0).RecordingId is_valid, error = validate_recordings.validate_recording( recording_id_0, web_service_objs[0]) assert is_valid, error shorter_recording_res = rio.find_recording(recording_id_0).json() # Validate the copy count for unique/common copy if RecordingAttribute.COPY_TYPE_UNIQUE == copy_type: is_valid, error = validate_storage.validate_copy_count( shorter_recording_res, Cos.ACTIVE_STORAGE, 2) elif RecordingAttribute.COPY_TYPE_COMMON == copy_type: is_valid, error = validate_storage.validate_copy_count( shorter_recording_res, Cos.ACTIVE_STORAGE, 1) assert is_valid, error LOGGER.debug(copy_type + " copy validation success") # Try to update the end time after shorter recording completes response = rio.find_recording(recording_id_0).json() print "[INFO: ] response json ", response updated_end_time = utils.get_formatted_time(constants.SECONDS * 30, TimeFormat.TIME_FORMAT_MS, stream) recording.get_entry(0).EndTime = updated_end_time shorter_recording_res = a8.create_recording(recording, recording_id_0) response = rio.find_recording(recording_id_0).json() print "[INFO: ] response json ", response is_valid, error = validate_common.validate_http_response_status_code( shorter_recording_res, requests.codes.bad_request) print "[INFO: ] update end time after recording complete message ", error # assert is_valid, "CSCvc21524: - "+error # Validating the updated end time in response, it should not be equal response = rio.find_recording(recording_id_0).json() is_valid, error = validate_recordings.validate_time( response, updated_end_time, RecordingAttribute.END_TIME) assert not is_valid, error print "[INFO: ] Validating the updated end time in response, it should not be equal " print "[INFO: ] async validate recording wait time ", time.sleep( validate_rec_wait_time) print "[INFO: ] queue list empty ", queue.empty() # Validating the longer recording is_valid, error = queue.get(timeout=7) print "[INFO: ] queue value 1 ", is_valid assert is_valid, error print "[INFO: ] Validating the longer recording " # Playback all recordings for i in range(total_recordings): recording_pool.apply_async(validate_recordings.validate_playback, (recording.get_entry(i).RecordingId, ), callback=queue.put) print "[INFO: ] Playback all recordings " # Validate playback recordings for i in range(total_recordings): is_valid, error = queue.get() print "[INFO: ] queue value 2 ", is_valid assert is_valid, error print "[INFO: ] Validate playback recordings" finally: if recording_pool: recording_pool.close() recording_pool.join() for web_service_obj in web_service_objs: web_service_obj.stop_server() response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_rtc9799_tc_ply_008_playback_pause_resume(stream): """ Create a recording, pause and resume during playback and verify if playback was successful """ recording = None web_service_obj = None pause_trigger = 2 pause_duration = 5 try: start_time = utils.get_formatted_time(constants.SECONDS * 30, TimeFormat.TIME_FORMAT_MS, stream) end_time = utils.get_formatted_time(constants.SECONDS * 60, TimeFormat.TIME_FORMAT_MS, stream) copy_type = RecordingAttribute.COPY_TYPE_COMMON recording = recording_model.Recording(StartTime=start_time, EndTime=end_time, copyType=copy_type, StreamId=stream) recording_id = recording.get_entry(0).RecordingId web_service_obj = notification_utils.get_web_service_object( recording_id) recording.get_entry(0).UpdateUrl = web_service_obj.get_url() LOGGER.debug("Recording instance created=%s", recording.serialize()) response = a8.create_recording(recording) is_valid, error = validate_common.validate_http_response_status_code( response, requests.codes.no_content) assert is_valid, error is_valid, error = validate_recordings.validate_recording( recording_id, web_service_obj) assert is_valid, error response = rio.find_recording(recording_id).json() is_valid, error = validate_storage.validate_recording_in_storage( response, Cos.ACTIVE_STORAGE, Cos.RECORDING_STORED) assert is_valid, error is_valid, error = validate_storage.validate_recording_in_storage( response, Cos.ACTIVE_STORAGE, Cos.RECORDING_NOT_STORED, 1) assert is_valid, error vle_request_params = { Vle.TRICKMODES: '{0},{1},{2},{3}'.format(Vle.TRICKMODE_PAUSE, pause_trigger, pause_duration, Vle.PAUSE_WRT_SEGMENT) } is_valid, error = validate_recordings.validate_playback( recording_id, VLE_REQUEST_PARAMS=vle_request_params, VALIDATOR_TYPE=vle_validators_configuration. PLAYBACK_VALIDATION_TRICKMODE) assert is_valid, error finally: web_service_obj.stop_server() response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_ipdvrtests59_restart_workflow(channel): recording = None web_service_obj = None wf_name = None try: start_time = utils.get_formatted_time( (constants.SECONDS * 30), TimeFormat.TIME_FORMAT_MS, channel) end_time = utils.get_formatted_time((constants.SECONDS * 60), TimeFormat.TIME_FORMAT_MS, channel) copy_type = RecordingAttribute.COPY_TYPE_UNIQUE LOGGER.debug("Stream Id : %s", channel) recording = recording_model.Recording(StartTime=start_time, EndTime=end_time, copyType=copy_type, StreamId=channel) recording_id = recording.get_entry(0).RecordingId LOGGER.info("Recording Id :%s", recording_id) # Create a notification handler web_service_obj = notification_utils.get_web_service_object( recording_id) recording.get_entry(0).UpdateUrl = web_service_obj.get_url() LOGGER.debug("Recording instance created :%s", recording.serialize()) # Create a Recording response = a8.create_recording(recording) is_valid, error = validate_common.validate_http_response_status_code( response, requests.codes.no_content) assert is_valid, error is_valid, error = validate_recordings.validate_recording( recording_id, web_service_obj) assert is_valid, error # Get the workflow wf_name = CONFIG_INFO[Component.GENERIC_CONFIG][ constants.Component.V2PC][constants.Component.WORK_FLOW][ constants.Component.WORKFLOW_NAME] LOGGER.info("WorkFlow Name : %s", wf_name) resp = v2pcapi.fetch_workflow_status(wf_name) LOGGER.info("Media Workflow before disable and enable: %s", resp.content) # Verify Channel Capturing status channel_res, response = v2pcapi.verify_channel_state( channel, Stream.CAPTURING) assert channel_res, response # Step 1: Disable a running workflow. stop_wf_result, stop_wf_resp = v2pcapi.workflow_change_state( wf_name, MediaWorkflow.DISABLE, time_out=120) assert stop_wf_result, stop_wf_resp # Verify Channel Capturing status is stopped channel_res, response = v2pcapi.verify_channel_state( channel, Stream.CAPTURING) assert not channel_res, response # Step 2: Enable the workflow again start_wf_result, start_wf_resp = v2pcapi.workflow_change_state( wf_name, MediaWorkflow.ENABLE, time_out=120) assert start_wf_result, start_wf_resp # Check channel goes back to Capturing state channel_result, ch_resp = v2pcapi.verify_channel_state( channel, Stream.CAPTURING) assert channel_result, "Channel State : %s" % ch_resp # Step 3: Validate the playback is_valid, error = validate_recordings.validate_playback_using_vle( recording_id) assert is_valid, error # Check MCE CoreDump LOGGER.debug("Validating MCE core dump") is_valid, error = core_dump("mce") assert is_valid, error # Check MPE Logs and CoreDump LOGGER.debug("Validating MPE core dump") is_valid, error = core_dump("mpe") assert is_valid, error finally: if wf_name: v2pcapi.workflow_change_state(wf_name, MediaWorkflow.ENABLE, time_out=120) if web_service_obj: web_service_obj.stop_server() if recording: response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_rtc9760_tc_rec_014_delete_playback_in_progress_recording(stream): """ Delete a recording while the playback is in progress and verify the playback """ recording = None playback_pool = None web_service_obj = None try: start_time = utils.get_formatted_time(constants.SECONDS * 30, TimeFormat.TIME_FORMAT_MS, stream) end_time = utils.get_formatted_time(constants.SECONDS * 150, TimeFormat.TIME_FORMAT_MS, stream) recording = recording_model.Recording(StartTime=start_time, EndTime=end_time, StreamId=stream) recording_id = recording.get_entry(0).RecordingId web_service_obj = notification_utils.get_web_service_object( recording_id) recording.get_entry(0).UpdateUrl = web_service_obj.get_url() LOGGER.debug("Recording instance created=%s", recording.serialize()) response = a8.create_recording(recording) is_valid, error = validate_common.validate_http_response_status_code( response, requests.codes.no_content) assert is_valid, error is_valid, error = validate_recordings.validate_recording( recording_id, web_service_obj) assert is_valid, error queue = Queue.Queue() playback_pool = mp_pool.ThreadPool(processes=1) playback_pool.apply_async( validate_recordings.validate_playback_using_vle, (recording_id, ), callback=queue.put) time.sleep(10 * constants.SECONDS) response = a8.delete_recording(recording) is_valid, error = validate_common.validate_http_response_status_code( response, requests.codes.no_content) assert is_valid, error is_valid, error = validate_recordings.validate_recording_deletion( recording_id) assert is_valid, error is_valid, error = queue.get() if is_valid: # verifying whether the playback fails now, even though it succeeded previously is_valid, error = validate_recordings.validate_playback_using_vle( recording_id) assert not is_valid, ValidationError.DELETED_RECORDING_PLAYED_BACK.format( recording_id) finally: if playback_pool: playback_pool.close() playback_pool.join() web_service_obj.stop_server() response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_rtc9782_tc_arc_012_playback_after_archival_delete_during_playback( stream): """ Create a recording with unique copy, wait until archiving completes, playback the recording and delete the recording during playback """ recording = None web_service_obj = None try: start_time = utils.get_formatted_time(constants.SECONDS * 30, TimeFormat.TIME_FORMAT_MS, stream) end_time = utils.get_formatted_time(constants.SECONDS * 60, TimeFormat.TIME_FORMAT_MS, stream) recording = recording_model.Recording(StartTime=start_time, EndTime=end_time, StreamId=stream) recording_id = recording.get_entry(0).RecordingId web_service_obj = notification_utils.get_web_service_object( recording_id) recording.get_entry(0).UpdateUrl = web_service_obj.get_url() LOGGER.debug("Recording instance created=%s", recording.serialize()) response = a8.create_recording(recording) is_valid, error = validate_common.validate_http_response_status_code( response, requests.codes.no_content) assert is_valid, error is_valid, error = validate_recordings.validate_recording( recording_id, web_service_obj) assert is_valid, error vmr_plybk_url = utils.get_vmr_playback_url(recording_id=recording_id) print "[INFO: ] vmr playback url ", vmr_plybk_url archive_helper.wait_for_archival(stream, recording_id, Archive.ARCHIVE, Archive.COMPLETE) response = rio.find_recording(recording_id).json() print "[INFO: ] recording details ", response is_valid, error = validate_storage.validate_recording_in_storage( response, Cos.ARCHIVE_STORAGE, Cos.RECORDING_STORED) assert is_valid, error queue = Queue.Queue() playback_pool = mp_pool.ThreadPool(processes=1) playback_pool.apply_async( validate_recordings.validate_playback_using_vle, (recording_id, ), callback=queue.put) #time.sleep(10 * constants.SECONDS) is_valid, error = validate_storage.validate_recording_in_storage( response, Cos.RECON_STORAGE, Cos.RECORDING_STORED) assert is_valid, ValidationError.SEGMENT_NOT_MOVED.format( Cos.RECON_STORAGE, response) del_resp = a8.delete_recording(recording) is_valid, error = validate_common.validate_http_response_status_code( del_resp, requests.codes.no_content) assert is_valid, error is_valid, error = validate_recordings.validate_recording_deletion( recording_id) assert is_valid, error is_valid, error = queue.get() assert is_valid, error if is_valid: # verifying whether the recording available in VMR vmr_plybk_url = utils.get_vmr_playback_url( recording_id=recording_id) resp = requests.get(vmr_plybk_url) assert not ( resp.status_code == requests.codes.ok ), ValidationError.INCORRECT_HTTP_RESPONSE_STATUS_CODE.format( resp.status_code, resp.reason, resp.url) finally: web_service_obj.stop_server() response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)
def test_update_recording_ipdvrtests_48(common_lib, stream): """ JIRA_URL : https://jira01.engit.synamedia.com/browse/IPDVRTESTS-48 DESCRIPTION : "Update Recording" """ recording = None web_service_obj = None try: #step 1:Create a recording and update the end time. Alternatively update start time if original start time is in future ##creating a recording recording, web_service_obj = common_lib.create_recording(stream) ##change the start time of the recording start_time_new = utils.get_formatted_time(constants.SECONDS * 80, TimeFormat.TIME_FORMAT_MS, stream) recording.get_entry(0).StartTime = start_time_new ##change the end time of the recording end_time_new = utils.get_formatted_time(constants.SECONDS * 110, TimeFormat.TIME_FORMAT_MS, stream) recording.get_entry(0).EndTime = end_time_new response = a8.create_recording(recording) recording_id = recording.get_entry(0).RecordingId is_valid, error = validate_common.validate_http_response_status_code( response, requests.codes.no_content) assert is_valid, error ##verify the recording complete is_valid, error = validate_recordings.validate_recording( recording_id, web_service_obj) assert is_valid, error #step 2:Verify memsql table is updated with new time using RIO API response = rio.find_recording(recording_id) resp = json.loads(response.content) is_valid, error = validate_recordings.validate_time( resp, start_time_new, RecordingAttribute.START_TIME) assert is_valid, error is_valid, error = validate_recordings.validate_time( resp, end_time_new, RecordingAttribute.END_TIME) assert is_valid, error #step 3:Check cos logs to see segments are written using COS API is_valid, error = validate_storage.validate_recording_in_storage( resp, Cos.ACTIVE_STORAGE, Cos.RECORDING_STORED) assert is_valid, error #step 4:Check MA/SR pod logs for any errors while recording s_time = utils.get_parsed_time(str(start_time_new)[:-1]) e_time = utils.get_parsed_time(str(end_time_new)[:-1]) is_valid, error = vmr_helper.verify_error_logs_in_vmr( stream, 'manifest-agent', 'vmr', search_string="ERROR", start_time=s_time, end_time=e_time) assert is_valid, error is_valid, error = vmr_helper.verify_error_logs_in_vmr( stream, 'segment-recorder', 'vmr', search_string="ERROR", start_time=s_time, end_time=e_time) assert is_valid, error #step 5:Check no discontinuity errors in MA is_valid, error = vmr_helper.verify_error_logs_in_vmr( stream, 'manifest-agent', 'vmr', search_string="discontinuity", start_time=s_time, end_time=e_time) assert is_valid, error finally: if web_service_obj: web_service_obj.stop_server() if recording: response = a8.delete_recording(recording) LOGGER.debug("Recording clean up status code=%s", response.status_code)