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_rtc10064_health_check_dp_components(): config_info = get_configInfo() vmr_pods = get_pod_details(constants.Component.VMR) running_pods = list() unavailable_pods = list() mandatory_pods = [ 'a8-updater', 'archive-agent', 'api', 'dash-origin', 'health-agent', 'health-monitor', 'manifest-agent', 'nsa', 'reconstitution-agent', 'recorder-manager', 'segment-recorder', 'ui', 'zookeeper', 'bmw', 'sats-server' ] for i in vmr_pods.items: pod_name = i.metadata.name running_pods.append(pod_name) LOGGER.debug("%s\t%s\t%s" % (i.status.pod_ip, pod_name, i.status.phase)) if i.status.phase not in ["Succeeded", "Running"]: raise Exception( "Testcase failed: Some of the pods in VMR are not in running state." ) for pod in mandatory_pods: verification_data = ','.join(rp for rp in running_pods if pod in rp) if len(verification_data) == 0: msg = '%s pod is unavailable' % pod LOGGER.error(msg) unavailable_pods.append(pod) if len(unavailable_pods) > 0: raise Exception('Following pods are unavailable: %s' % ','.join(unavailable_pods)) # Check the status of MCE pods: mce_confg = get_spec_config(Component.MCE) mce_username = mce_confg[Component.MCE_USERNAME] if is_standalone(Component.MCE): mce_ip = mce_confg['node1']['ip'] mce_key = mce_confg['sshkey'] ssh_client = get_custom_ssh_client(ip=mce_ip, username=mce_username, key_path=mce_key) stdin, stdout, stderr = ssh_client.exec_command( "/sbin/service mce-app status", get_pty=False) data = stdout.readlines() ssh_client.close() for line in data: LOGGER.debug(line) each_service = line.split() if len(each_service) > 2: if each_service[0] == 'asperacentral': continue assert 'RUNNING' == str( each_service[1]), 'ERROR: %s service is in %s state' % ( each_service[0], each_service[1]) LOGGER.debug('MCE IP: ' + str(mce_ip)) LOGGER.debug('MCE is up and running...') LOGGER.debug("EXIT CODE: " + str(stdout.channel.recv_exit_status())) if is_v2pc(Component.MCE): mce_ip = mce_confg[Component.VIRTUAL_IP] ssh_client = get_ssh_client(Component.MCE, mce_username) stdin, stdout, stderr = ssh_client.exec_command( "/sbin/service mce-app status", get_pty=False) data = stdout.readlines() ssh_client.close() for line in data: LOGGER.debug(line) each_service = line.split() if len(each_service) > 2: if each_service[0] == 'asperacentral': continue assert 'RUNNING' == str( each_service[1]), 'ERROR: %s service is in %s state' % ( each_service[0], each_service[1]) LOGGER.debug('MCE IP: ' + str(mce_ip)) LOGGER.debug('MCE is up and running...') LOGGER.debug("EXIT CODE: " + str(stdout.channel.recv_exit_status())) # Check the status of MPE pods: mpe_confg = get_spec_config(Component.MPE) if is_standalone(Component.MPE): # namespace mpe_pods = get_pod_details(mpe_confg[Component.NAMESPACE]) running_pods = list() unavailable_pods = list() mandatory_pods = [ 'mpe', ] for i in mpe_pods.items: pod_name = i.metadata.name running_pods.append(pod_name) LOGGER.debug("%s\t%s\t%s" % (i.status.pod_ip, pod_name, i.status.phase)) if i.status.phase not in ["Succeeded", "Running"]: raise Exception( "Testcase failed: Some of the pods in VMR are not in running state." ) for pod in mandatory_pods: verification_data = ','.join(rp for rp in running_pods if pod in rp) if len(verification_data) == 0: msg = '%s pod is unavailable' % pod LOGGER.error(msg) unavailable_pods.append(pod) if len(unavailable_pods) > 0: raise Exception('Following pods are unavailable: %s' % ','.join(unavailable_pods)) if is_v2pc(Component.MPE): mpe_ip = mpe_confg['node1'][Component.IP] mpe_username = mpe_confg[Component.MPE_USERNAME] ssh_client = get_custom_ssh_client( mpe_ip, username=mpe_username, key_path=mpe_confg[Component.SSH_KEY]) stdin, stdout, stderr = ssh_client.exec_command( "systemctl status mpe.service", get_pty=False) data = stdout.read() ssh_client.close() LOGGER.debug(str(data)) if 'active' in str(data) and 'running' in str(data): LOGGER.debug('MPE service is up and running...') else: raise Exception('ERROR: MPE service is not up and running...') LOGGER.debug('MPE IP:' + str(mpe_ip)) LOGGER.debug("EXIT CODE: " + str(stdout.channel.recv_exit_status())) # Check COS - CLM and Cassandra service: cos_confg = get_spec_config(Component.COS) cos_ip = cos_confg['node1']['ip'] cos_username = cos_confg['user'] cos_password = cos_confg['pass'] ssh_client = get_custom_ssh_client(ip=cos_ip, username=cos_username, password=cos_password) stdin, stdout, stderr = ssh_client.exec_command("/sbin/service clm status", get_pty=True) data = stdout.read() ssh_client.close() LOGGER.debug(str(data)) if 'passing' in str(data): LOGGER.debug('COS: CLM service is running...') else: raise Exception('ERROR: COS: CLM service is not up and running...') LOGGER.debug('COS IP:' + str(cos_ip)) LOGGER.debug("EXIT CODE: " + str(stdout.channel.recv_exit_status())) # Check CMC service: cmc_confg = get_spec_config(Component.CMC) cmc_ip = cmc_confg['ip'] cmc_username = cmc_confg['user'] cmc_password = cmc_confg['pass'] ssh_client = get_custom_ssh_client(ip=cmc_ip, username=cmc_username, password=cmc_password) stdin, stdout, stderr = ssh_client.exec_command( "/sbin/service cmc_aicc status", get_pty=True) data = stdout.read() ssh_client.close() LOGGER.debug(str(data)) if 'cmc_aicc is running' in str(data): LOGGER.debug('CMC_AICC service is up and running...') else: raise Exception('ERROR: CMC_AICC service is not up and running...') LOGGER.debug('CMC IP: ' + str(cmc_ip)) LOGGER.debug("EXIT CODE: " + str(stdout.channel.recv_exit_status())) # Check MEMSQL service: memsql_ip = config_info[Component.MEMSQL]['ip'] memsql_username = config_info[Component.MEMSQL]['user'] memsql_password = config_info[Component.MEMSQL]['pass'] ssh_client = get_custom_ssh_client(ip=memsql_ip, username=memsql_username, password=memsql_password) stdin, stdout, stderr = ssh_client.exec_command("memsql-ops status", get_pty=True) data = stdout.read() ssh_client.close() if 'MemSQL Ops is running' in str(data): LOGGER.debug('MEMSQL-OPS is up and running...') else: raise Exception('ERROR: MEMSQL-OPS is not up and running...') LOGGER.debug(str(data)) LOGGER.debug('MEMSQL IP: ' + str(memsql_ip)) LOGGER.debug("EXIT CODE: " + str(stdout.channel.recv_exit_status()))
from helpers.constants import TestLog from helpers.constants import TimeFormat from helpers.constants import ValidationError from helpers.constants import RecordingAttribute from helpers.constants import V2pc from helpers.constants import Component from helpers.utils import cleanup from helpers.vmr.vmr_helper import v2pc_edit_manifest_config from helpers.vmr.vmr_helper import redeploy_config_map from helpers.vmr.vmr_helper import verify_batch_size_update pytestmark = pytest.mark.recording LOGGER = logging.getLogger(TestLog.TEST_LOGGER) # CONFIG_INFO = yaml.load(pytest.config.getoption(constants.GLOBAL_CONFIG_INFO)) generic_conf = utils.get_spec_config() private_copy_stream = generic_conf[Component.PRIVATE_COPY_STREAM][Component.STREAM_1][Component.ID] if generic_conf.get( Component.PRIVATE_COPY_STREAM) else None TC_ER_018_DATA = [("bulk_recordings_common", RecordingAttribute.COPY_TYPE_COMMON), ("bulk_recordings_unique", RecordingAttribute.COPY_TYPE_UNIQUE)] @utils.test_case_logger @pytest.mark.parametrize("name, copy_type", TC_ER_018_DATA, ids=[x[0] for x in TC_ER_018_DATA]) @pytest.mark.skipif(not generic_conf.get( Component.PRIVATE_COPY_STREAM), reason = "Configuration doesn't have private copy stream") def test_rtc9726_tc_er_018_private_copy(stream, name, copy_type): """ Schedule UNIQUE copy recording (20 - 10 same start/end time, 10 different start/end times), batch size 4. """
def test_rtc10602_tc_launch_delete(stream): """ TC10602: test module for the longevity delete recordings test suite # delete recording as per the configuration for number of deletion and duration for deletion """ longevity_confg = utils.get_spec_config() # no need for this numofaccts usage with state 3 dataplane # numofaccts = longevity_confg['systemvalues']['numberofaccounts'] deletespermin = longevity_confg['recording']['recordingspermin'] test_dur_in_min = longevity_confg['recording']['testdurationinmins'] try: json_file = "recording_list" temp_dir = os.path.join(utils.get_base_dir_path(), TestDirectory.TEMP_DIR) rec_list_json_file = os.path.join(temp_dir, json_file + '.json') assert os.path.exists(rec_list_json_file), ValidationError.FILE_UNAVAILABLE.format(rec_list_json_file) with open(rec_list_json_file) as rec_json_file: rec_dict = json.load(rec_json_file) print rec_dict assert rec_dict, ValidationError.FILE_UNAVAILABLE.format(rec_dict) # convert yaml parameters to minutes and seconds if isinstance(test_dur_in_min, int): test_duration_in_seconds = test_dur_in_min * constants.SECONDS_IN_MINUTE if isinstance(deletespermin, int): # two different scenarios # 1: deletion count is lesser than the 60. sleep time will be more than a second. # 2: deletion count is more than 60. More than 1 deletion per second. deletions_per_sec_rounded = float(deletespermin) / float(test_duration_in_seconds) sleep_duration = 1 if 0.0 < deletions_per_sec_rounded and 1.0 > deletions_per_sec_rounded: deletions_per_sec_rounded = 1 sleep_duration = constants.SECONDS_IN_MINUTE / deletespermin total_test_loop_counts = test_duration_in_seconds / sleep_duration elif 1 <= int(round(deletions_per_sec_rounded)): deletions_per_sec_rounded = int(round(deletions_per_sec_rounded)) sleep_duration = 1 total_test_loop_counts = test_duration_in_seconds print print "[INFO: ] total_test_loop_counts ", total_test_loop_counts print "[INFO: ] deletions_per_sec_rounded ", deletions_per_sec_rounded print "[INFO: ] sleep duration ", sleep_duration print rec_list = rec_dict.get('rec_ids') for i in range(total_test_loop_counts): rec_list, rec_dict = delete_recordings(deletions_per_sec_rounded, rec_list, rec_dict) time.sleep(sleep_duration) else: assert False, ValidationError.TYPE_MISMATCH.format('deletespermin is not a number: {0}'.format(deletespermin)) else: assert False, ValidationError.TYPE_MISMATCH.format('testduration is not a number: {0}'.format(testduration)) finally: if rec_list_json_file: with open(rec_list_json_file, 'w') as rec_json_file: json.dump(rec_dict, rec_json_file) print rec_dict
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
from helpers.constants import Component from helpers.constants import TestLog from helpers.constants import TimeFormat from helpers.constants import Archive from helpers.constants import ValidationError from helpers.constants import RecordingAttribute from helpers.constants import VMR_SERVICES_RESTART LOGGER = logging.getLogger(os.environ.get("PYTEST_XDIST_WORKER", TestLog.TEST_LOGGER)) CONFIG_INFO = utils.get_configInfo() V2PC_EXIST = (CONFIG_INFO[Component.GENERIC_CONFIG][Component.ENABLE] == "v2pc") streams_info = utils.get_source_streams(constants.Stream_tags.MULTIPLE_AUDIO_CODEC) channels = streams_info[Component.STREAMS] gen_config = utils.get_spec_config() mpe_config = utils.get_spec_config(Component.MPE) @utils.test_case_logger @pytest.mark.parametrize("channel", channels) @pytest.mark.skipif(V2PC_EXIST is False, reason="V2PC Doesn't Exist") def test_HLS_Verify_codec_based_audio_filtering_V2PC_ipdvrtests_46(channel): """ JIRA ID : IPDVRTESTS-46 TITLE : "HLS : Verify codec based audio filtering" STEPS : Create a 30mins recording with future start time. Playback using the HLS publish template configured to filter based on audio codecs. Verify output of manifest curl to match the filtering configured in publish template """ stream = channel web_service_obj = None
def test_modify_channel_ipdvrtests_57(stream): """ JIRA_URL: https://jira01.engit.synamedia.com/browse/IPDVRTESTS-57 DESCRIPTION: Modify existing Channels in channel lineup recording the with updated channel and validating playback """ recording = None web_service_obj = None active_chl_lineup = None try: generic_confg = utils.get_spec_config() workflow = generic_confg[Component.WORK_FLOW][Component.WORKFLOW_NAME] response = v2pc_api.get_workflow(workflow) workflow_dict = json.loads(response.content) LOGGER.debug("[INFO:] workflow_dict %s", workflow_dict) assert workflow_dict.get( "properties") and workflow_dict["properties"].get( "mediaServiceEndpoints"), Feed.CHANNEL_DETAILS_UNAVAILABLE for media_service in workflow_dict["properties"][ "mediaServiceEndpoints"]: if media_service.get( "endpointType") == "MEDIASOURCE" and media_service.get( "properties" ) and "assetLineupRef" in media_service["properties"]: active_chl_lineup = media_service["properties"][ "assetLineupRef"].split(".")[-1] break assert active_chl_lineup, Feed.CHANNEL_DETAILS_UNAVAILABLE LOGGER.debug("[INFO:] active channel lineup detail %s", active_chl_lineup) response = v2pc_api.get_channel_line_up(active_chl_lineup) LOGGER.debug("[DEBUG:] response %s", response) response.raise_for_status() LOGGER.debug("[DEBUG:] response content %s", response.content) avail_chanl_lineup_dict = json.loads(response.content) start_stamp = datetime.utcnow().strftime(TimeFormat.TIME_FORMAT_LOG) # Remove the Channel from Lineup LOGGER.info("Step 1: Remove existing channel from line up") response = v2pc_api.remove_channel_from_channel_line_up( stream, avail_chanl_lineup_dict) LOGGER.debug("[DEBUG:] response %s", response) assert response, ValidationError.INCORRECT_HTTP_RESPONSE_STATUS_CODE.format( response.status_code, response.reason, response.url) LOGGER.debug("[DEBUG:] response content %s", response.content) original_lineup = json.loads(response.content) LOGGER.info("Step 1.1: Validate MCE for Core dump") is_valid, msg = utils.core_dump("mce") assert is_valid, msg LOGGER.info("Step 2: Verify Channel not being captured") is_avail = v2pc.is_channel_available(stream) assert not is_avail, ValidationError.CHANNEL_EXIST.format(stream) # Get the channel details to update original_channel_details = v2pc_api.get_channel_source(stream) LOGGER.debug("Channel Info : %s", original_channel_details.content) LOGGER.info("Step 2.1: Adding channel back to channel line up") update_lineup = v2pc_api.add_channel_to_channel_line_up( stream, avail_chanl_lineup_dict) assert update_lineup, ValidationError.INCORRECT_HTTP_RESPONSE_STATUS_CODE.format( update_lineup.status_code, update_lineup.reason, update_lineup.url) LOGGER.info("Step 3: Verify channel is being moving to Capture State") LOGGER.info("[INFO:] Waits till stream to move to capture state ") is_valid, error = v2pc.waits_till_channel_capture(stream) assert is_valid, error result, response = v2pc.restart_media_workflow( generic_conf[Component.WORK_FLOW][Component.WORKFLOW_NAME]) assert result, response result, response = v2pc.waits_till_workflow_active( generic_conf[Component.WORK_FLOW][Component.WORKFLOW_NAME]) assert result, response end_stamp = datetime.utcnow().strftime(TimeFormat.TIME_FORMAT_LOG) 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.SHORT_REC_LEN_IN_SEC) start_time = utils.get_formatted_time( (constants.SECONDS * rec_buffer_time), TimeFormat.TIME_FORMAT_MS) end_time = utils.get_formatted_time( (constants.SECONDS * (rec_buffer_time + rec_duration)), TimeFormat.TIME_FORMAT_MS) 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("Second Recording Id :%s", recording_id) LOGGER.info("STEP 3.1: NO ERROR IN MCE LOGS") is_valid, error = v2pc.collect_error_log(start_stamp, end_stamp, TestLog.MCE_ERROR_LOG_PATH, recording_id, component=Component.MCE, is_error=True) assert is_valid, error LOGGER.info("Step 3.2: Validate MCE for Core dump") is_valid, msg = utils.core_dump("mce") assert is_valid, msg # 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()) LOGGER.info( "Step 4: Create recording on the updated channel and verify its completed" ) 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 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) if active_chl_lineup: response = v2pc_api.get_channel_line_up(active_chl_lineup) assert response, 'unable to fetch channel line up detail' avail_chanl_lineup_dict = json.loads(response.content) update_lineup = v2pc_api.add_channel_to_channel_line_up( stream, avail_chanl_lineup_dict) assert update_lineup, 'unable to revert the channel line up'
def setup(request): """ Set up the environment for the test run. This will be executed by default automatically before every test run. :param request: the incoming context """ def teardown(): """ Clean up the environment post the test run. This will be executed when all the tests are executed. """ test_setup.prepare_test_summary(request) request.addfinalizer(teardown) base_path = os.path.join(utils.get_base_dir_path(), TestDirectory.CONFIG_DIR) kubeconfig_path = os.path.join(base_path, VMR_KUBECONFIG) config.load_kube_config(os.path.join(os.environ["HOME"], kubeconfig_path)) # to cleanup log and change vle_default.conf file interface value based upon the system interface name" utils.vle_log_cleanup() utils.vle_default_config_interface_change() times_are_synchronized, error = test_setup.are_times_synchronized() if not times_are_synchronized: pytest.fail(error) LOGGER.info( "All components including the test machine are time synchronized as required" ) playback_host_resolved, error = test_setup.is_playback_host_resolved() if not playback_host_resolved: pytest.fail(error) streams_info, drift_avail, stream_drift_info, drift_applicable = test_setup.find_live_point_drift( ) generic_direct_config = utils.get_direct_config() generic_config = utils.get_spec_config() if not drift_applicable: warnings.warn( UserWarning(stream_drift_info + 'Not applicable drift streams removed.')) # Fail if time drift present in stream, but drift handle is False if not (generic_direct_config.get(Component.DRIFT_HANDLE, False)) and drift_avail: message = stream_drift_info + " stream has drift but drift handle is set to False, hence failing the test execution" LOGGER.error("Stream -> drift: %s" % stream_drift_info) LOGGER.error(message) pytest.exit(message) # Expose the stream details as environment variable if generic_direct_config.get(Component.DRIFT_HANDLE, False): status = utils.set_pytest_stream_info(streams_info) if utils.is_v2pc(): v2pc_auth_token = utils.get_v2pc_api_auth_token() if not v2pc_auth_token: pytest.fail("Unable to fetch V2PC authorization token") constants.V2pc.auth_token = v2pc_auth_token