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)
