def setUp(self): super(ScrapeVideoThumbnailsTestCase, self).setUp() course_ids = [unicode(self.course.id)] profiles = ['youtube'] created = datetime.now(pytz.utc) previous_uploads = [ { 'edx_video_id': 'test1', 'client_video_id': 'test1.mp4', 'duration': 42.0, 'status': 'upload', 'courses': course_ids, 'encoded_videos': [], 'created': created }, { 'edx_video_id': 'test-youtube-video-1', 'client_video_id': 'test-youtube-id.mp4', 'duration': 128.0, 'status': 'file_complete', 'courses': course_ids, 'created': created, 'encoded_videos': [ { 'profile': 'youtube', 'url': '3_yD_cEKoCk', 'file_size': 1600, 'bitrate': 100, } ], }, { 'edx_video_id': 'test-youtube-video-2', 'client_video_id': 'test-youtube-id.mp4', 'image': 'image2.jpg', 'duration': 128.0, 'status': 'file_complete', 'courses': course_ids, 'created': created, 'encoded_videos': [ { 'profile': 'youtube', 'url': '3_yD_cEKoCk', 'file_size': 1600, 'bitrate': 100, } ], }, ] for profile in profiles: create_profile(profile) for video in previous_uploads: create_video(video) # Create video images. with make_image_file() as image_file: update_video_image( 'test-youtube-video-2', unicode(self.course.id), image_file, 'image.jpg' )
def test_export_val_data(self): self.descriptor.edx_video_id = "test_edx_video_id" create_profile("mobile") create_video( { "edx_video_id": self.descriptor.edx_video_id, "client_video_id": "test_client_video_id", "duration": 111, "status": "dummy", "encoded_videos": [ {"profile": "mobile", "url": "http://example.com/video", "file_size": 222, "bitrate": 333} ], } ) actual = self.descriptor.definition_to_xml(resource_fs=None) expected_str = """ <video download_video="false" url_name="SampleProblem"> <video_asset client_video_id="test_client_video_id" duration="111.0"> <encoded_video profile="mobile" url="http://example.com/video" file_size="222" bitrate="333"/> </video_asset> </video> """ parser = etree.XMLParser(remove_blank_text=True) expected = etree.XML(expected_str, parser=parser) self.assertXmlEqual(expected, actual)
def test_export_val_data(self): self.descriptor.edx_video_id = 'test_edx_video_id' create_profile('mobile') create_video({ 'edx_video_id': self.descriptor.edx_video_id, 'client_video_id': 'test_client_video_id', 'duration': 111, 'status': 'dummy', 'encoded_videos': [{ 'profile': 'mobile', 'url': 'http://example.com/video', 'file_size': 222, 'bitrate': 333, }], }) actual = self.descriptor.definition_to_xml(resource_fs=None) expected_str = """ <video download_video="false" url_name="SampleProblem"> <video_asset client_video_id="test_client_video_id" duration="111.0"> <encoded_video profile="mobile" url="http://example.com/video" file_size="222" bitrate="333"/> </video_asset> </video> """ parser = etree.XMLParser(remove_blank_text=True) expected = etree.XML(expected_str, parser=parser) self.assertXmlEqual(expected, actual)
def test_import_val_data(self): create_profile('mobile') module_system = DummySystem(load_error_modules=True) xml_data = """ <video edx_video_id="test_edx_video_id"> <video_asset client_video_id="test_client_video_id" duration="111.0"> <encoded_video profile="mobile" url="http://example.com/video" file_size="222" bitrate="333"/> </video_asset> </video> """ id_generator = Mock() id_generator.target_course_id = "test_course_id" video = VideoDescriptor.from_xml(xml_data, module_system, id_generator) self.assertEqual(video.edx_video_id, 'test_edx_video_id') video_data = get_video_info(video.edx_video_id) self.assertEqual(video_data['client_video_id'], 'test_client_video_id') self.assertEqual(video_data['duration'], 111) self.assertEqual(video_data['status'], 'imported') self.assertEqual(video_data['courses'], [id_generator.target_course_id]) self.assertEqual(video_data['encoded_videos'][0]['profile'], 'mobile') self.assertEqual(video_data['encoded_videos'][0]['url'], 'http://example.com/video') self.assertEqual(video_data['encoded_videos'][0]['file_size'], 222) self.assertEqual(video_data['encoded_videos'][0]['bitrate'], 333)
def test_create_profile(self): """ Tests the creation of a profile """ api.create_profile(constants.PROFILE_DESKTOP) profiles = list(Profile.objects.all()) self.assertEqual(len(profiles), 6) self.assertIn(constants.PROFILE_DESKTOP, [unicode(profile) for profile in profiles]) self.assertEqual(len(profiles), 6)
def setUp(self): """ Creation of Video object that will be used to test video update Creation of Profile objects that will be used to test video update """ api.create_profile(constants.PROFILE_DESKTOP) api.create_profile(constants.PROFILE_MOBILE) video_data = dict( encoded_videos=[constants.ENCODED_VIDEO_DICT_FISH_MOBILE], **constants.VIDEO_DICT_FISH) api.create_video(video_data)
def test_create_profile(self): """ Tests the creation of a profile """ api.create_profile(constants.PROFILE_DESKTOP) profiles = list(Profile.objects.all()) profile_names = [unicode(profile) for profile in profiles] self.assertEqual(len(profiles), 7) self.assertIn(constants.PROFILE_DESKTOP, profile_names) self.assertIn(constants.PROFILE_HLS, profile_names) self.assertEqual(len(profiles), 7)
def setUp(self): super(TestVideoOutline, self).setUp() self.user = UserFactory.create() self.course = CourseFactory.create(mobile_available=True) self.section = ItemFactory.create( parent_location=self.course.location, category="chapter", display_name=u"test factory section omega \u03a9" ) self.sub_section = ItemFactory.create( parent_location=self.section.location, category="sequential", display_name=u"test subsection omega \u03a9" ) self.unit = ItemFactory.create( parent_location=self.sub_section.location, category="vertical", metadata={"graded": True, "format": "Homework"}, display_name=u"test unit omega \u03a9", ) self.other_unit = ItemFactory.create( parent_location=self.sub_section.location, category="vertical", metadata={"graded": True, "format": "Homework"}, display_name=u"test unit omega 2 \u03a9", ) self.nameless_unit = ItemFactory.create( parent_location=self.sub_section.location, category="vertical", metadata={"graded": True, "format": "Homework"}, display_name=None, ) self.edx_video_id = "testing-123" self.video_url = "http://val.edx.org/val/video.mp4" self.html5_video_url = "http://video.edx.org/html5/video.mp4" api.create_profile({"profile_name": "youtube", "extension": "mp4", "width": 1280, "height": 720}) api.create_profile({"profile_name": "mobile_low", "extension": "mp4", "width": 640, "height": 480}) # create the video in VAL api.create_video( { "edx_video_id": self.edx_video_id, "client_video_id": u"test video omega \u03a9", "duration": 12, "courses": [unicode(self.course.id)], "encoded_videos": [ {"profile": "youtube", "url": "xyz123", "file_size": 0, "bitrate": 1500}, {"profile": "mobile_low", "url": self.video_url, "file_size": 12345, "bitrate": 250}, ], } ) self.client.login(username=self.user.username, password="******")
def test_import_val_data_invalid(self): create_profile('mobile') module_system = DummySystem(load_error_modules=True) # Negative file_size is invalid xml_data = """ <video edx_video_id="test_edx_video_id"> <video_asset client_video_id="test_client_video_id" duration="111.0"> <encoded_video profile="mobile" url="http://example.com/video" file_size="-222" bitrate="333"/> </video_asset> </video> """ with self.assertRaises(ValCannotCreateError): VideoDescriptor.from_xml(xml_data, module_system, id_generator=Mock()) with self.assertRaises(ValVideoNotFoundError): get_video_info("test_edx_video_id")
def setup_val_video(self, associate_course_in_val=False): """ Creates a video entry in VAL. Arguments: associate_course - If True, associates the test course with the video in VAL. """ create_profile('mobile') create_video({ 'edx_video_id': self.TEST_EDX_VIDEO_ID, 'client_video_id': 'test_client_video_id', 'duration': self.TEST_DURATION, 'status': 'dummy', 'encoded_videos': [self.TEST_ENCODED_VIDEO], 'courses': [self.video.location.course_key] if associate_course_in_val else [], }) self.val_video = get_video_info(self.TEST_EDX_VIDEO_ID) # pylint: disable=attribute-defined-outside-init
def test_import_val_data(self): create_profile('mobile') module_system = DummySystem(load_error_modules=True) xml_data = """ <video edx_video_id="test_edx_video_id"> <video_asset client_video_id="test_client_video_id" duration="111.0"> <encoded_video profile="mobile" url="http://example.com/video" file_size="222" bitrate="333"/> </video_asset> </video> """ video = VideoDescriptor.from_xml(xml_data, module_system, id_generator=Mock()) self.assertEqual(video.edx_video_id, 'test_edx_video_id') video_data = get_video_info(video.edx_video_id) self.assertEqual(video_data['client_video_id'], 'test_client_video_id') self.assertEqual(video_data['duration'], 111) self.assertEqual(video_data['status'], 'imported') self.assertEqual(video_data['courses'], []) self.assertEqual(video_data['encoded_videos'][0]['profile'], 'mobile') self.assertEqual(video_data['encoded_videos'][0]['url'], 'http://example.com/video') self.assertEqual(video_data['encoded_videos'][0]['file_size'], 222) self.assertEqual(video_data['encoded_videos'][0]['bitrate'], 333)
def test_create_profile(self): """ Tests the creation of a profile """ result = api.create_profile(constants.PROFILE_DICT_DESKTOP) profiles = list(Profile.objects.all()) self.assertEqual(len(profiles), 6) self.assertEqual( profiles[-1].profile_name, constants.PROFILE_DICT_DESKTOP.get('profile_name') ) self.assertEqual(len(profiles), 6) self.assertEqual("desktop", result)
def setUp(self): super(TestVideoAPITestCase, self).setUp() self.section = ItemFactory.create( parent=self.course, category="chapter", display_name=u"test factory section omega \u03a9" ) self.sub_section = ItemFactory.create( parent=self.section, category="sequential", display_name=u"test subsection omega \u03a9" ) self.unit = ItemFactory.create( parent=self.sub_section, category="vertical", metadata={"graded": True, "format": "Homework"}, display_name=u"test unit omega \u03a9", ) self.other_unit = ItemFactory.create( parent=self.sub_section, category="vertical", metadata={"graded": True, "format": "Homework"}, display_name=u"test unit omega 2 \u03a9", ) self.nameless_unit = ItemFactory.create( parent=self.sub_section, category="vertical", metadata={"graded": True, "format": "Homework"}, display_name=None, ) self.edx_video_id = "testing-123" self.video_url = "http://val.edx.org/val/video.mp4" self.video_url_high = "http://val.edx.org/val/video_high.mp4" self.youtube_url = "http://val.edx.org/val/youtube.mp4" self.html5_video_url = "http://video.edx.org/html5/video.mp4" api.create_profile("youtube") api.create_profile("mobile_high") api.create_profile("mobile_low") # create the video in VAL api.create_video( { "edx_video_id": self.edx_video_id, "status": "test", "client_video_id": u"test video omega \u03a9", "duration": 12, "courses": [unicode(self.course.id)], "encoded_videos": [ {"profile": "youtube", "url": "xyz123", "file_size": 0, "bitrate": 1500}, {"profile": "mobile_low", "url": self.video_url, "file_size": 12345, "bitrate": 250}, {"profile": "mobile_high", "url": self.video_url_high, "file_size": 99999, "bitrate": 250}, ], } ) # Set requested profiles MobileApiConfig(video_profiles="mobile_low,mobile_high,youtube").save()
def test_import_val_data(self): create_profile("mobile") module_system = DummySystem(load_error_modules=True) xml_data = """ <video edx_video_id="test_edx_video_id"> <video_asset client_video_id="test_client_video_id" duration="111.0"> <encoded_video profile="mobile" url="http://example.com/video" file_size="222" bitrate="333"/> </video_asset> </video> """ id_generator = Mock() id_generator.target_course_id = "test_course_id" video = VideoDescriptor.from_xml(xml_data, module_system, id_generator) self.assertEqual(video.edx_video_id, "test_edx_video_id") video_data = get_video_info(video.edx_video_id) self.assertEqual(video_data["client_video_id"], "test_client_video_id") self.assertEqual(video_data["duration"], 111) self.assertEqual(video_data["status"], "imported") self.assertEqual(video_data["courses"], [id_generator.target_course_id]) self.assertEqual(video_data["encoded_videos"][0]["profile"], "mobile") self.assertEqual(video_data["encoded_videos"][0]["url"], "http://example.com/video") self.assertEqual(video_data["encoded_videos"][0]["file_size"], 222) self.assertEqual(video_data["encoded_videos"][0]["bitrate"], 333)
def test_get_html_with_existing_edx_video_id(self): # create test profiles and their encodings encoded_videos = [] for profile, extension in [("desktop_webm", "webm"), ("desktop_mp4", "mp4")]: create_profile(profile) encoded_videos.append( dict( url=u"http://fake-video.edx.org/thundercats.{}".format(extension), file_size=9000, bitrate=42, profile=profile, ) ) result = create_video( dict( client_video_id="Thunder Cats", duration=111, edx_video_id="thundercats", status="test", encoded_videos=encoded_videos, ) ) self.assertEqual(result, "thundercats") SOURCE_XML = """ <video show_captions="true" display_name="A Name" sub="a_sub_file.srt.sjson" source="{source}" download_video="{download_video}" start_time="01:00:03" end_time="01:00:10" edx_video_id="{edx_video_id}" > {sources} </video> """ data = { "download_video": "true", "source": "example_source.mp4", "sources": """ <source src="example.mp4"/> <source src="example.webm"/> """, "edx_video_id": "thundercats", "result": { "download_video_link": u"http://fake-video.edx.org/thundercats.mp4", # make sure the urls for the various encodings are included as part of the alternative sources. "sources": [u"example.mp4", u"example.webm"] + [video["url"] for video in encoded_videos], }, } # Video found for edx_video_id metadata = self.default_metadata_dict metadata["sources"] = "" initial_context = { "branding_info": None, "license": None, "bumper_metadata": "null", "cdn_eval": False, "cdn_exp_group": None, "display_name": u"A Name", "download_video_link": u"example.mp4", "handout": None, "id": self.item_descriptor.location.html_id(), "track": None, "transcript_download_format": "srt", "transcript_download_formats_list": [ {"display_name": "SubRip (.srt) file", "value": "srt"}, {"display_name": "Text (.txt) file", "value": "txt"}, ], "poster": "null", "metadata": metadata, } DATA = SOURCE_XML.format( download_video=data["download_video"], source=data["source"], sources=data["sources"], edx_video_id=data["edx_video_id"], ) self.initialize_module(data=DATA) context = self.item_descriptor.render(STUDENT_VIEW).content expected_context = dict(initial_context) expected_context["metadata"].update( { "transcriptTranslationUrl": self.item_descriptor.xmodule_runtime.handler_url( self.item_descriptor, "transcript", "translation/__lang__" ).rstrip("/?"), "transcriptAvailableTranslationsUrl": self.item_descriptor.xmodule_runtime.handler_url( self.item_descriptor, "transcript", "available_translations" ).rstrip("/?"), "saveStateUrl": self.item_descriptor.xmodule_runtime.ajax_url + "/save_user_state", "sources": data["result"]["sources"], } ) expected_context.update( { "id": self.item_descriptor.location.html_id(), "download_video_link": data["result"]["download_video_link"], "metadata": json.dumps(expected_context["metadata"]), } ) self.assertEqual(context, self.item_descriptor.xmodule_runtime.render_template("video.html", expected_context))
def setUp(self): super(VideoUploadTestMixin, self).setUp() self.url = self.get_url_for_course_key(self.course.id) self.test_token = "test_token" self.course.video_upload_pipeline = { "course_video_upload_token": self.test_token, } self.save_course() self.profiles = [ { "profile_name": "profile1", "extension": "mp4", "width": 640, "height": 480, }, { "profile_name": "profile2", "extension": "mp4", "width": 1920, "height": 1080, }, ] self.previous_uploads = [ { "edx_video_id": "test1", "client_video_id": "test1.mp4", "duration": 42.0, "status": "upload", "encoded_videos": [], }, { "edx_video_id": "test2", "client_video_id": "test2.mp4", "duration": 128.0, "status": "file_complete", "encoded_videos": [ { "profile": "profile1", "url": "http://example.com/profile1/test2.mp4", "file_size": 1600, "bitrate": 100, }, { "profile": "profile2", "url": "http://example.com/profile2/test2.mov", "file_size": 16000, "bitrate": 1000, }, ], }, { "edx_video_id": "non-ascii", "client_video_id": u"nón-ascii-näme.mp4", "duration": 256.0, "status": "transcode_active", "encoded_videos": [ { "profile": "profile1", "url": u"http://example.com/profile1/nón-ascii-näme.mp4", "file_size": 3200, "bitrate": 100, }, ] }, ] for profile in self.profiles: create_profile(profile) for video in self.previous_uploads: create_video(video) modulestore().save_asset_metadata( AssetMetadata( self.course.id.make_asset_key(VIDEO_ASSET_TYPE, video["edx_video_id"])), self.user.id)
def setUp(self): super(VideoUploadTestMixin, self).setUp() self.url = self.get_url_for_course_key(self.course.id) self.test_token = "test_token" self.course.video_upload_pipeline = { "course_video_upload_token": self.test_token, } self.save_course() # create another course for videos belonging to multiple courses self.course2 = CourseFactory.create() self.course2.video_upload_pipeline = { "course_video_upload_token": self.test_token, } self.course2.save() self.store.update_item(self.course2, self.user.id) # course ids for videos course_ids = [unicode(self.course.id), unicode(self.course2.id)] self.profiles = ["profile1", "profile2"] self.previous_uploads = [ { "edx_video_id": "test1", "client_video_id": "test1.mp4", "duration": 42.0, "status": "upload", "courses": course_ids, "encoded_videos": [], }, { "edx_video_id": "test2", "client_video_id": "test2.mp4", "duration": 128.0, "status": "file_complete", "courses": course_ids, "encoded_videos": [ { "profile": "profile1", "url": "http://example.com/profile1/test2.mp4", "file_size": 1600, "bitrate": 100, }, { "profile": "profile2", "url": "http://example.com/profile2/test2.mov", "file_size": 16000, "bitrate": 1000, }, ], }, { "edx_video_id": "non-ascii", "client_video_id": u"nón-ascii-näme.mp4", "duration": 256.0, "status": "transcode_active", "courses": course_ids, "encoded_videos": [ { "profile": "profile1", "url": u"http://example.com/profile1/nón-ascii-näme.mp4", "file_size": 3200, "bitrate": 100, }, ] }, ] # Ensure every status string is tested self.previous_uploads += [ { "edx_video_id": "status_test_{}".format(status), "client_video_id": "status_test.mp4", "duration": 3.14, "status": status, "courses": course_ids, "encoded_videos": [], } for status in ( StatusDisplayStrings._STATUS_MAP.keys() + # pylint:disable=protected-access ["non_existent_status"] ) ] for profile in self.profiles: create_profile(profile) for video in self.previous_uploads: create_video(video)
def setUp(self): super(VideoUploadTestMixin, self).setUp() self.url = self.get_url_for_course_key(self.course.id) self.test_token = "test_token" self.course.video_upload_pipeline = { "course_video_upload_token": self.test_token, } self.save_course() self.profiles = [ { "profile_name": "profile1", "extension": "mp4", "width": 640, "height": 480, }, { "profile_name": "profile2", "extension": "mp4", "width": 1920, "height": 1080, }, ] self.previous_uploads = [ { "edx_video_id": "test1", "client_video_id": "test1.mp4", "duration": 42.0, "status": "upload", "encoded_videos": [], }, { "edx_video_id": "test2", "client_video_id": "test2.mp4", "duration": 128.0, "status": "file_complete", "encoded_videos": [ { "profile": "profile1", "url": "http://example.com/profile1/test2.mp4", "file_size": 1600, "bitrate": 100, }, { "profile": "profile2", "url": "http://example.com/profile2/test2.mov", "file_size": 16000, "bitrate": 1000, }, ], }, { "edx_video_id": "non-ascii", "client_video_id": u"nón-ascii-näme.mp4", "duration": 256.0, "status": "transcode_active", "encoded_videos": [ { "profile": "profile1", "url": u"http://example.com/profile1/nón-ascii-näme.mp4", "file_size": 3200, "bitrate": 100, }, ] }, ] for profile in self.profiles: create_profile(profile) for video in self.previous_uploads: create_video(video) modulestore().save_asset_metadata( AssetMetadata( self.course.id.make_asset_key(VIDEO_ASSET_TYPE, video["edx_video_id"]) ), self.user.id )
def test_get_html_with_existing_edx_video_id(self): # create test profiles and their encodings encoded_videos = [] for profile, extension in [("desktop_webm", "webm"), ("desktop_mp4", "mp4")]: result = create_profile(dict(profile_name=profile, extension=extension, width=200, height=2001)) self.assertEqual(result, profile) encoded_videos.append( dict( url=u"http://fake-video.edx.org/thundercats.{}".format(extension), file_size=9000, bitrate=42, profile=profile, ) ) result = create_video( dict( client_video_id="Thunder Cats", duration=111, edx_video_id="thundercats", status="test", encoded_videos=encoded_videos, ) ) self.assertEqual(result, "thundercats") SOURCE_XML = """ <video show_captions="true" display_name="A Name" sub="a_sub_file.srt.sjson" source="{source}" download_video="{download_video}" start_time="01:00:03" end_time="01:00:10" edx_video_id="{edx_video_id}" > {sources} </video> """ data = { "download_video": "true", "source": "example_source.mp4", "sources": """ <source src="example.mp4"/> <source src="example.webm"/> """, "edx_video_id": "thundercats", "result": { "download_video_link": u"http://fake-video.edx.org/thundercats.mp4", # make sure the urls for the various encodings are included as part of the alternative sources. "sources": json.dumps([u"example.mp4", u"example.webm"] + [video["url"] for video in encoded_videos]), }, } # Video found for edx_video_id initial_context = { "data_dir": getattr(self, "data_dir", None), "show_captions": "true", "handout": None, "display_name": u"A Name", "download_video_link": None, "end": 3610.0, "id": None, "sources": "[]", "speed": "null", "general_speed": 1.0, "start": 3603.0, "saved_video_position": 0.0, "sub": u"a_sub_file.srt.sjson", "track": None, "youtube_streams": "1.00:OEoXaMPEzfM", "autoplay": settings.FEATURES.get("AUTOPLAY_VIDEOS", True), "yt_test_timeout": 1500, "yt_api_url": "www.youtube.com/iframe_api", "yt_test_url": "gdata.youtube.com/feeds/api/videos/", "transcript_download_format": "srt", "transcript_download_formats_list": [ {"display_name": "SubRip (.srt) file", "value": "srt"}, {"display_name": "Text (.txt) file", "value": "txt"}, ], "transcript_language": u"en", "transcript_languages": '{"en": "English"}', } DATA = SOURCE_XML.format( download_video=data["download_video"], source=data["source"], sources=data["sources"], edx_video_id=data["edx_video_id"], ) self.initialize_module(data=DATA) context = self.item_descriptor.render(STUDENT_VIEW).content expected_context = dict(initial_context) expected_context.update( { "transcript_translation_url": self.item_descriptor.xmodule_runtime.handler_url( self.item_descriptor, "transcript", "translation" ).rstrip("/?"), "transcript_available_translations_url": self.item_descriptor.xmodule_runtime.handler_url( self.item_descriptor, "transcript", "available_translations" ).rstrip("/?"), "ajax_url": self.item_descriptor.xmodule_runtime.ajax_url + "/save_user_state", "id": self.item_descriptor.location.html_id(), } ) expected_context.update(data["result"]) self.assertEqual(context, self.item_descriptor.xmodule_runtime.render_template("video.html", expected_context))
def setUp(self): super(TestVideoAPITestCase, self).setUp() self.section = ItemFactory.create( parent_location=self.course.location, category="chapter", display_name=u"test factory section omega \u03a9", ) self.sub_section = ItemFactory.create( parent_location=self.section.location, category="sequential", display_name=u"test subsection omega \u03a9", ) self.unit = ItemFactory.create( parent_location=self.sub_section.location, category="vertical", metadata={ 'graded': True, 'format': 'Homework' }, display_name=u"test unit omega \u03a9", ) self.other_unit = ItemFactory.create( parent_location=self.sub_section.location, category="vertical", metadata={ 'graded': True, 'format': 'Homework' }, display_name=u"test unit omega 2 \u03a9", ) self.nameless_unit = ItemFactory.create( parent_location=self.sub_section.location, category="vertical", metadata={ 'graded': True, 'format': 'Homework' }, display_name=None, ) self.split_unit = ItemFactory.create( parent_location=self.sub_section.location, category="vertical", display_name=u"split test vertical\u03a9", ) self.split_test = ItemFactory.create( parent_location=self.split_unit.location, category="split_test", display_name=u"split test unit") self.edx_video_id = 'testing-123' self.video_url = 'http://val.edx.org/val/video.mp4' self.html5_video_url = 'http://video.edx.org/html5/video.mp4' api.create_profile({ 'profile_name': 'youtube', 'extension': 'mp4', 'width': 1280, 'height': 720 }) api.create_profile({ 'profile_name': 'mobile_low', 'extension': 'mp4', 'width': 640, 'height': 480 }) # create the video in VAL api.create_video({ 'edx_video_id': self.edx_video_id, 'status': 'test', 'client_video_id': u"test video omega \u03a9", 'duration': 12, 'courses': [unicode(self.course.id)], 'encoded_videos': [{ 'profile': 'youtube', 'url': 'xyz123', 'file_size': 0, 'bitrate': 1500 }, { 'profile': 'mobile_low', 'url': self.video_url, 'file_size': 12345, 'bitrate': 250 }] })
def setUp(self): super(TestVideoAPITestCase, self).setUp() self.section = ItemFactory.create( parent=self.course, category="chapter", display_name=u"test factory section omega \u03a9", ) self.sub_section = ItemFactory.create( parent=self.section, category="sequential", display_name=u"test subsection omega \u03a9", ) self.unit = ItemFactory.create( parent=self.sub_section, category="vertical", metadata={'graded': True, 'format': 'Homework'}, display_name=u"test unit omega \u03a9", ) self.other_unit = ItemFactory.create( parent=self.sub_section, category="vertical", metadata={'graded': True, 'format': 'Homework'}, display_name=u"test unit omega 2 \u03a9", ) self.nameless_unit = ItemFactory.create( parent=self.sub_section, category="vertical", metadata={'graded': True, 'format': 'Homework'}, display_name=None, ) self.edx_video_id = 'testing-123' self.video_url = 'http://val.edx.org/val/video.mp4' self.video_url_high = 'http://val.edx.org/val/video_high.mp4' self.youtube_url = 'http://val.edx.org/val/youtube.mp4' self.html5_video_url = 'http://video.edx.org/html5/video.mp4' api.create_profile('youtube') api.create_profile('mobile_high') api.create_profile('mobile_low') # create the video in VAL api.create_video({ 'edx_video_id': self.edx_video_id, 'status': 'test', 'client_video_id': u"test video omega \u03a9", 'duration': 12, 'courses': [unicode(self.course.id)], 'encoded_videos': [ { 'profile': 'youtube', 'url': 'xyz123', 'file_size': 0, 'bitrate': 1500 }, { 'profile': 'mobile_low', 'url': self.video_url, 'file_size': 12345, 'bitrate': 250 }, { 'profile': 'mobile_high', 'url': self.video_url_high, 'file_size': 99999, 'bitrate': 250 }, ]}) # Set requested profiles MobileApiConfig(video_profiles="mobile_low,mobile_high,youtube").save()
def setUp(self): super(VideoUploadTestMixin, self).setUp() self.url = self.get_url_for_course_key(self.course.id) self.test_token = "test_token" self.course.video_upload_pipeline = { "course_video_upload_token": self.test_token, } self.save_course() self.profiles = ["profile1", "profile2"] self.previous_uploads = [ { "edx_video_id": "test1", "client_video_id": "test1.mp4", "duration": 42.0, "status": "upload", "encoded_videos": [], }, { "edx_video_id": "test2", "client_video_id": "test2.mp4", "duration": 128.0, "status": "file_complete", "encoded_videos": [ { "profile": "profile1", "url": "http://example.com/profile1/test2.mp4", "file_size": 1600, "bitrate": 100, }, { "profile": "profile2", "url": "http://example.com/profile2/test2.mov", "file_size": 16000, "bitrate": 1000, }, ], }, { "edx_video_id": "non-ascii", "client_video_id": u"nón-ascii-näme.mp4", "duration": 256.0, "status": "transcode_active", "encoded_videos": [ { "profile": "profile1", "url": u"http://example.com/profile1/nón-ascii-näme.mp4", "file_size": 3200, "bitrate": 100, }, ] }, ] # Ensure every status string is tested self.previous_uploads += [ { "edx_video_id": "status_test_{}".format(status), "client_video_id": "status_test.mp4", "duration": 3.14, "status": status, "encoded_videos": [], } for status in ( StatusDisplayStrings._STATUS_MAP.keys() + # pylint:disable=protected-access ["non_existent_status"] ) ] for profile in self.profiles: create_profile(profile) for video in self.previous_uploads: create_video(video) modulestore().save_asset_metadata( AssetMetadata( self.course.id.make_asset_key(VIDEO_ASSET_TYPE, video["edx_video_id"]) ), self.user.id )
def setUp(self): super(TestVideoOutline, self).setUp() self.user = UserFactory.create() self.course = CourseFactory.create(mobile_available=True) self.section = ItemFactory.create( parent_location=self.course.location, category="chapter", display_name=u"test factory section omega \u03a9", ) self.sub_section = ItemFactory.create( parent_location=self.section.location, category="sequential", display_name=u"test subsection omega \u03a9", ) self.unit = ItemFactory.create( parent_location=self.sub_section.location, category="vertical", metadata={'graded': True, 'format': 'Homework'}, display_name=u"test unit omega \u03a9", ) self.other_unit = ItemFactory.create( parent_location=self.sub_section.location, category="vertical", metadata={'graded': True, 'format': 'Homework'}, display_name=u"test unit omega 2 \u03a9", ) self.nameless_unit = ItemFactory.create( parent_location=self.sub_section.location, category="vertical", metadata={'graded': True, 'format': 'Homework'}, display_name=None, ) self.edx_video_id = 'testing-123' self.video_url = 'http://val.edx.org/val/video.mp4' self.html5_video_url = 'http://video.edx.org/html5/video.mp4' api.create_profile({ 'profile_name': 'youtube', 'extension': 'mp4', 'width': 1280, 'height': 720 }) api.create_profile({ 'profile_name': 'mobile_low', 'extension': 'mp4', 'width': 640, 'height': 480 }) # create the video in VAL api.create_video({ 'edx_video_id': self.edx_video_id, 'client_video_id': u"test video omega \u03a9", 'duration': 12, 'courses': [unicode(self.course.id)], 'encoded_videos': [ { 'profile': 'youtube', 'url': 'xyz123', 'file_size': 0, 'bitrate': 1500 }, { 'profile': 'mobile_low', 'url': self.video_url, 'file_size': 12345, 'bitrate': 250 } ]}) self.client.login(username=self.user.username, password='******')
def test_create_profile_duplicate(self): api.create_profile(constants.PROFILE_DESKTOP) with self.assertRaises(ValCannotCreateError): api.create_profile(constants.PROFILE_DESKTOP)
def test_invalid_create_profile(self, data): # pylint: disable=W0621 """ Tests the creation of invalid profile data """ with self.assertRaises(ValCannotCreateError): api.create_profile(data)
def setUp(self): super(VideoUploadTestMixin, self).setUp() self.url = self.get_url_for_course_key(self.course.id) self.test_token = "test_token" self.course.video_upload_pipeline = { "course_video_upload_token": self.test_token, } self.save_course() self.profiles = ["profile1", "profile2"] self.previous_uploads = [ { "edx_video_id": "test1", "client_video_id": "test1.mp4", "duration": 42.0, "status": "upload", "encoded_videos": [], }, { "edx_video_id": "test2", "client_video_id": "test2.mp4", "duration": 128.0, "status": "file_complete", "encoded_videos": [ { "profile": "profile1", "url": "http://example.com/profile1/test2.mp4", "file_size": 1600, "bitrate": 100, }, { "profile": "profile2", "url": "http://example.com/profile2/test2.mov", "file_size": 16000, "bitrate": 1000, }, ], }, { "edx_video_id": "non-ascii", "client_video_id": u"nón-ascii-näme.mp4", "duration": 256.0, "status": "transcode_active", "encoded_videos": [ { "profile": "profile1", "url": u"http://example.com/profile1/nón-ascii-näme.mp4", "file_size": 3200, "bitrate": 100, }, ] }, ] # Ensure every status string is tested self.previous_uploads += [ { "edx_video_id": "status_test_{}".format(status), "client_video_id": "status_test.mp4", "duration": 3.14, "status": status, "encoded_videos": [], } for status in (StatusDisplayStrings._STATUS_MAP.keys() + # pylint:disable=protected-access ["non_existent_status"]) ] for profile in self.profiles: create_profile(profile) for video in self.previous_uploads: create_video(video) modulestore().save_asset_metadata( AssetMetadata( self.course.id.make_asset_key(VIDEO_ASSET_TYPE, video["edx_video_id"])), self.user.id)
def test_get_html_with_existing_edx_video_id(self): # create test profiles and their encodings encoded_videos = [] for profile, extension in [("desktop_webm", "webm"), ("desktop_mp4", "mp4")]: create_profile(profile) encoded_videos.append( dict( url=u"http://fake-video.edx.org/thundercats.{}".format(extension), file_size=9000, bitrate=42, profile=profile, ) ) result = create_video( dict( client_video_id="Thunder Cats", duration=111, edx_video_id="thundercats", status='test', encoded_videos=encoded_videos ) ) self.assertEqual(result, "thundercats") SOURCE_XML = """ <video show_captions="true" display_name="A Name" sub="a_sub_file.srt.sjson" source="{source}" download_video="{download_video}" start_time="01:00:03" end_time="01:00:10" edx_video_id="{edx_video_id}" > {sources} </video> """ data = { 'download_video': 'true', 'source': 'example_source.mp4', 'sources': """ <source src="example.mp4"/> <source src="example.webm"/> """, 'edx_video_id': "thundercats", 'result': { 'download_video_link': u'http://fake-video.edx.org/thundercats.mp4', # make sure the urls for the various encodings are included as part of the alternative sources. 'sources': [u'example.mp4', u'example.webm'] + [video['url'] for video in encoded_videos], } } # Video found for edx_video_id metadata = self.default_metadata_dict metadata['sources'] = "" initial_context = { 'branding_info': None, 'license': None, 'bumper_metadata': 'null', 'cdn_eval': False, 'cdn_exp_group': None, 'display_name': u'A Name', 'download_video_link': u'example.mp4', 'handout': None, 'id': self.item_descriptor.location.html_id(), 'track': None, 'transcript_download_format': 'srt', 'transcript_download_formats_list': [ {'display_name': 'SubRip (.srt) file', 'value': 'srt'}, {'display_name': 'Text (.txt) file', 'value': 'txt'} ], 'poster': 'null', 'metadata': metadata, } DATA = SOURCE_XML.format( download_video=data['download_video'], source=data['source'], sources=data['sources'], edx_video_id=data['edx_video_id'] ) self.initialize_module(data=DATA) context = self.item_descriptor.render(STUDENT_VIEW).content expected_context = dict(initial_context) expected_context['metadata'].update({ 'transcriptTranslationUrl': self.item_descriptor.xmodule_runtime.handler_url( self.item_descriptor, 'transcript', 'translation/__lang__' ).rstrip('/?'), 'transcriptAvailableTranslationsUrl': self.item_descriptor.xmodule_runtime.handler_url( self.item_descriptor, 'transcript', 'available_translations' ).rstrip('/?'), 'saveStateUrl': self.item_descriptor.xmodule_runtime.ajax_url + '/save_user_state', 'sources': data['result']['sources'], }) expected_context.update({ 'id': self.item_descriptor.location.html_id(), 'download_video_link': data['result']['download_video_link'], 'metadata': json.dumps(expected_context['metadata']) }) self.assertEqual( context, self.item_descriptor.xmodule_runtime.render_template('video.html', expected_context) )
def setUp(self): super(TestVideoOutline, self).setUp() self.user = UserFactory.create() self.course = CourseFactory.create(mobile_available=True) section = ItemFactory.create( parent_location=self.course.location, category="chapter", display_name=u"test factory section omega \u03a9", ) self.sub_section = ItemFactory.create( parent_location=section.location, category="sequential", display_name=u"test subsection omega \u03a9", ) self.unit = ItemFactory.create( parent_location=self.sub_section.location, category="vertical", metadata={'graded': True, 'format': 'Homework'}, display_name=u"test unit omega \u03a9", ) self.other_unit = ItemFactory.create( parent_location=self.sub_section.location, category="vertical", metadata={'graded': True, 'format': 'Homework'}, display_name=u"test unit omega 2 \u03a9", ) self.edx_video_id = 'testing-123' self.video_url = 'http://val.edx.org/val/video.mp4' self.html5_video_url = 'http://video.edx.org/html5/video.mp4' api.create_profile({ 'profile_name': 'youtube', 'extension': 'mp4', 'width': 1280, 'height': 720 }) api.create_profile({ 'profile_name': 'mobile_low', 'extension': 'mp4', 'width': 640, 'height': 480 }) val_video = api.create_video({ 'edx_video_id': self.edx_video_id, 'client_video_id': u"test video omega \u03a9", 'duration': 12, 'courses': [unicode(self.course.id)], 'encoded_videos': [ { 'profile': 'youtube', 'url': 'xyz123', 'file_size': 0, 'bitrate': 1500 }, { 'profile': 'mobile_low', 'url': self.video_url, 'file_size': 12345, 'bitrate': 250 } ]}) subid = uuid4().hex self.video = ItemFactory.create( parent_location=self.unit.location, category="video", edx_video_id=self.edx_video_id, display_name=u"test video omega \u03a9", sub=subid ) result_location = transcripts_utils.save_subs_to_store({ 'start': [100, 200, 240, 390, 1000], 'end': [200, 240, 380, 1000, 1500], 'text': [ 'subs #1', 'subs #2', 'subs #3', 'subs #4', 'subs #5' ]}, subid, self.course) self.client.login(username=self.user.username, password='******')
def test_get_html_with_existing_edx_video_id(self): # create test profiles and their encodings encoded_videos = [] for profile, extension in [("desktop_webm", "webm"), ("desktop_mp4", "mp4")]: create_profile(profile) encoded_videos.append( dict( url=u"http://fake-video.edx.org/thundercats.{}".format(extension), file_size=9000, bitrate=42, profile=profile, ) ) result = create_video( dict( client_video_id="Thunder Cats", duration=111, edx_video_id="thundercats", status='test', encoded_videos=encoded_videos ) ) self.assertEqual(result, "thundercats") SOURCE_XML = """ <video show_captions="true" display_name="A Name" sub="a_sub_file.srt.sjson" source="{source}" download_video="{download_video}" start_time="01:00:03" end_time="01:00:10" edx_video_id="{edx_video_id}" > {sources} </video> """ data = { 'download_video': 'true', 'source': 'example_source.mp4', 'sources': """ <source src="example.mp4"/> <source src="example.webm"/> """, 'edx_video_id': "thundercats", 'result': { 'download_video_link': u'http://fake-video.edx.org/thundercats.mp4', # make sure the urls for the various encodings are included as part of the alternative sources. 'sources': json.dumps( [u'example.mp4', u'example.webm'] + [video['url'] for video in encoded_videos] ), } } # Video found for edx_video_id initial_context = { 'branding_info': None, 'cdn_eval': False, 'cdn_exp_group': None, 'data_dir': getattr(self, 'data_dir', None), 'show_captions': 'true', 'handout': None, 'display_name': u'A Name', 'download_video_link': None, 'end': 3610.0, 'id': None, 'sources': '[]', 'speed': 'null', 'general_speed': 1.0, 'start': 3603.0, 'saved_video_position': 0.0, 'sub': u'a_sub_file.srt.sjson', 'track': None, 'youtube_streams': '1.00:3_yD_cEKoCk', 'autoplay': settings.FEATURES.get('AUTOPLAY_VIDEOS', True), 'yt_test_timeout': 1500, 'yt_api_url': 'www.youtube.com/iframe_api', 'yt_test_url': 'gdata.youtube.com/feeds/api/videos/', 'transcript_download_format': 'srt', 'transcript_download_formats_list': [{'display_name': 'SubRip (.srt) file', 'value': 'srt'}, {'display_name': 'Text (.txt) file', 'value': 'txt'}], 'transcript_language': u'en', 'transcript_languages': '{"en": "English"}', } DATA = SOURCE_XML.format( download_video=data['download_video'], source=data['source'], sources=data['sources'], edx_video_id=data['edx_video_id'] ) self.initialize_module(data=DATA) context = self.item_descriptor.render(STUDENT_VIEW).content expected_context = dict(initial_context) expected_context.update({ 'transcript_translation_url': self.item_descriptor.xmodule_runtime.handler_url( self.item_descriptor, 'transcript', 'translation' ).rstrip('/?'), 'transcript_available_translations_url': self.item_descriptor.xmodule_runtime.handler_url( self.item_descriptor, 'transcript', 'available_translations' ).rstrip('/?'), 'ajax_url': self.item_descriptor.xmodule_runtime.ajax_url + '/save_user_state', 'id': self.item_descriptor.location.html_id(), }) expected_context.update(data['result']) self.assertEqual( context, self.item_descriptor.xmodule_runtime.render_template('video.html', expected_context) )
def test_invalid_create_profile(self): """ Tests the creation of invalid profile data """ with self.assertRaises(ValCannotCreateError): api.create_profile(constants.PROFILE_INVALID_NAME)
def setUp(self): super(TestVideoOutline, self).setUp() self.user = UserFactory.create() self.course = CourseFactory.create(mobile_available=True) section = ItemFactory.create( parent_location=self.course.location, category="chapter", display_name=u"test factory section omega \u03a9", ) self.sub_section = ItemFactory.create( parent_location=section.location, category="sequential", display_name=u"test subsection omega \u03a9", ) self.unit = ItemFactory.create( parent_location=self.sub_section.location, category="vertical", metadata={'graded': True, 'format': 'Homework'}, display_name=u"test unit omega \u03a9", ) self.other_unit = ItemFactory.create( parent_location=self.sub_section.location, category="vertical", metadata={'graded': True, 'format': 'Homework'}, display_name=u"test unit omega 2 \u03a9", ) self.edx_video_id = 'testing-123' self.video_url = 'http://val.edx.org/val/video.mp4' self.html5_video_url = 'http://video.edx.org/html5/video.mp4' api.create_profile({ 'profile_name': 'youtube', 'extension': 'mp4', 'width': 1280, 'height': 720 }) api.create_profile({ 'profile_name': 'mobile_low', 'extension': 'mp4', 'width': 640, 'height': 480 }) # create the video in VAL api.create_video({ 'edx_video_id': self.edx_video_id, 'client_video_id': u"test video omega \u03a9", 'duration': 12, 'courses': [unicode(self.course.id)], 'encoded_videos': [ { 'profile': 'youtube', 'url': 'xyz123', 'file_size': 0, 'bitrate': 1500 }, { 'profile': 'mobile_low', 'url': self.video_url, 'file_size': 12345, 'bitrate': 250 } ]}) subid = uuid4().hex self.video = ItemFactory.create( parent_location=self.unit.location, category="video", edx_video_id=self.edx_video_id, display_name=u"test video omega \u03a9", sub=subid ) transcripts_utils.save_subs_to_store({ 'start': [100, 200, 240, 390, 1000], 'end': [200, 240, 380, 1000, 1500], 'text': [ 'subs #1', 'subs #2', 'subs #3', 'subs #4', 'subs #5' ]}, subid, self.course) self.client.login(username=self.user.username, password='******')
def test_get_html_with_existing_edx_video_id(self): # create test profiles and their encodings encoded_videos = [] for profile, extension in [("desktop_webm", "webm"), ("desktop_mp4", "mp4")]: create_profile(profile) encoded_videos.append( dict( url=u"http://fake-video.edx.org/thundercats.{}".format( extension), file_size=9000, bitrate=42, profile=profile, )) result = create_video( dict(client_video_id="Thunder Cats", duration=111, edx_video_id="thundercats", status='test', encoded_videos=encoded_videos)) self.assertEqual(result, "thundercats") SOURCE_XML = """ <video show_captions="true" display_name="A Name" sub="a_sub_file.srt.sjson" source="{source}" download_video="{download_video}" start_time="01:00:03" end_time="01:00:10" edx_video_id="{edx_video_id}" > {sources} </video> """ data = { 'download_video': 'true', 'source': 'example_source.mp4', 'sources': """ <source src="example.mp4"/> <source src="example.webm"/> """, 'edx_video_id': "thundercats", 'result': { 'download_video_link': u'http://fake-video.edx.org/thundercats.mp4', # make sure the urls for the various encodings are included as part of the alternative sources. 'sources': json.dumps([u'example.mp4', u'example.webm'] + [video['url'] for video in encoded_videos]), } } # Video found for edx_video_id initial_context = { 'branding_info': None, 'cdn_eval': False, 'cdn_exp_group': None, 'data_dir': getattr(self, 'data_dir', None), 'show_captions': 'true', 'handout': None, 'display_name': u'A Name', 'download_video_link': None, 'end': 3610.0, 'id': None, 'sources': '[]', 'speed': 'null', 'general_speed': 1.0, 'start': 3603.0, 'saved_video_position': 0.0, 'sub': u'a_sub_file.srt.sjson', 'track': None, 'youtube_streams': '1.00:3_yD_cEKoCk', 'autoplay': settings.FEATURES.get('AUTOPLAY_VIDEOS', True), 'yt_test_timeout': 1500, 'yt_api_url': 'www.youtube.com/iframe_api', 'yt_test_url': 'gdata.youtube.com/feeds/api/videos/', 'transcript_download_format': 'srt', 'transcript_download_formats_list': [{ 'display_name': 'SubRip (.srt) file', 'value': 'srt' }, { 'display_name': 'Text (.txt) file', 'value': 'txt' }], 'transcript_language': u'en', 'transcript_languages': '{"en": "English"}', } DATA = SOURCE_XML.format(download_video=data['download_video'], source=data['source'], sources=data['sources'], edx_video_id=data['edx_video_id']) self.initialize_module(data=DATA) context = self.item_descriptor.render(STUDENT_VIEW).content expected_context = dict(initial_context) expected_context.update({ 'transcript_translation_url': self.item_descriptor.xmodule_runtime.handler_url( self.item_descriptor, 'transcript', 'translation').rstrip('/?'), 'transcript_available_translations_url': self.item_descriptor.xmodule_runtime.handler_url( self.item_descriptor, 'transcript', 'available_translations').rstrip('/?'), 'ajax_url': self.item_descriptor.xmodule_runtime.ajax_url + '/save_user_state', 'id': self.item_descriptor.location.html_id(), }) expected_context.update(data['result']) self.assertEqual( context, self.item_descriptor.xmodule_runtime.render_template( 'video.html', expected_context))
def setUp(self): super(TestVideoAPITestCase, self).setUp() self.section = ItemFactory.create( parent=self.course, category="chapter", display_name=u"test factory section omega \u03a9", ) self.sub_section = ItemFactory.create( parent=self.section, category="sequential", display_name=u"test subsection omega \u03a9", ) self.unit = ItemFactory.create( parent=self.sub_section, category="vertical", metadata={ 'graded': True, 'format': 'Homework' }, display_name=u"test unit omega \u03a9", ) self.other_unit = ItemFactory.create( parent=self.sub_section, category="vertical", metadata={ 'graded': True, 'format': 'Homework' }, display_name=u"test unit omega 2 \u03a9", ) self.nameless_unit = ItemFactory.create( parent=self.sub_section, category="vertical", metadata={ 'graded': True, 'format': 'Homework' }, display_name=None, ) self.edx_video_id = 'testing-123' self.video_url = 'http://val.edx.org/val/video.mp4' self.video_url_high = 'http://val.edx.org/val/video_high.mp4' self.youtube_url = 'http://val.edx.org/val/youtube.mp4' self.html5_video_url = 'http://video.edx.org/html5/video.mp4' api.create_profile('youtube') api.create_profile('mobile_high') api.create_profile('mobile_low') # create the video in VAL api.create_video({ 'edx_video_id': self.edx_video_id, 'status': 'test', 'client_video_id': u"test video omega \u03a9", 'duration': 12, 'courses': [unicode(self.course.id)], 'encoded_videos': [ { 'profile': 'youtube', 'url': 'xyz123', 'file_size': 0, 'bitrate': 1500 }, { 'profile': 'mobile_low', 'url': self.video_url, 'file_size': 12345, 'bitrate': 250 }, { 'profile': 'mobile_high', 'url': self.video_url_high, 'file_size': 99999, 'bitrate': 250 }, ] }) # Set requested profiles MobileApiConfig(video_profiles="mobile_low,mobile_high,youtube").save()
def setUp(self): """ Creation of Profile objects that will be used to test video creation """ api.create_profile(constants.PROFILE_DESKTOP) api.create_profile(constants.PROFILE_MOBILE)
def setUp(self): super(VideoUploadTestBase, self).setUp() self.url = self.get_url_for_course_key(self.course.id) self.test_token = "test_token" self.course.video_upload_pipeline = { "course_video_upload_token": self.test_token, } self.save_course() # create another course for videos belonging to multiple courses self.course2 = CourseFactory.create() self.course2.video_upload_pipeline = { "course_video_upload_token": self.test_token, } self.course2.save() self.store.update_item(self.course2, self.user.id) # course ids for videos course_ids = [unicode(self.course.id), unicode(self.course2.id)] created = datetime.now(pytz.utc) self.profiles = ["profile1", "profile2"] self.previous_uploads = [ { "edx_video_id": "test1", "client_video_id": "test1.mp4", "duration": 42.0, "status": "upload", "courses": course_ids, "encoded_videos": [], "created": created }, { "edx_video_id": "test2", "client_video_id": "test2.mp4", "duration": 128.0, "status": "file_complete", "courses": course_ids, "created": created, "encoded_videos": [ { "profile": "profile1", "url": "http://example.com/profile1/test2.mp4", "file_size": 1600, "bitrate": 100, }, { "profile": "profile2", "url": "http://example.com/profile2/test2.mov", "file_size": 16000, "bitrate": 1000, }, ], }, { "edx_video_id": "non-ascii", "client_video_id": u"nón-ascii-näme.mp4", "duration": 256.0, "status": "transcode_active", "courses": course_ids, "created": created, "encoded_videos": [ { "profile": "profile1", "url": u"http://example.com/profile1/nón-ascii-näme.mp4", "file_size": 3200, "bitrate": 100, }, ] }, ] # Ensure every status string is tested self.previous_uploads += [ { "edx_video_id": "status_test_{}".format(status), "client_video_id": "status_test.mp4", "duration": 3.14, "status": status, "courses": course_ids, "created": created, "encoded_videos": [], } for status in (StatusDisplayStrings._STATUS_MAP.keys() + # pylint:disable=protected-access ["non_existent_status"]) ] for profile in self.profiles: create_profile(profile) for video in self.previous_uploads: create_video(video)