Python VideoDescriptor.from_xml方法代码示例

# 需要导入模块: from xmodule.video_module import VideoDescriptor [as 别名]
# 或者: from xmodule.video_module.VideoDescriptor import from_xml [as 别名]
    def test_import_val_data_invalid(self, mock_val_api):
        mock_val_api.ValCannotCreateError = _MockValCannotCreateError
        mock_val_api.import_from_xml = Mock(side_effect=mock_val_api.ValCannotCreateError)
        module_system = DummySystem(load_error_modules=True)

        # Negative duration is invalid
        xml_data = """
            <video edx_video_id="test_edx_video_id">
                <video_asset client_video_id="test_client_video_id" duration="-1"/>
            </video>
        """
        with self.assertRaises(mock_val_api.ValCannotCreateError):
            VideoDescriptor.from_xml(xml_data, module_system, id_generator=Mock())

# 需要导入模块: from xmodule.video_module import VideoDescriptor [as 别名]
# 或者: from xmodule.video_module.VideoDescriptor import from_xml [as 别名]
 def test_old_video_format(self):
     """
     Test backwards compatibility with VideoModule's XML format.
     """
     module_system = DummySystem(load_error_modules=True)
     xml_data = """
         <video display_name="Test Video"
                youtube="1.0:p2Q6BrNhdh8,0.75:izygArpw-Qo,1.25:1EeWXzPdhSA,1.5:rABDYkeK0x8"
                show_captions="false"
                source="http://www.example.com/source.mp4"
                from="00:00:01"
                to="00:01:00">
           <source src="http://www.example.com/source.mp4"/>
           <track src="http://www.example.com/track"/>
         </video>
     """
     output = VideoDescriptor.from_xml(xml_data, module_system, Mock())
     self.assert_attributes_equal(output, {
         'youtube_id_0_75': 'izygArpw-Qo',
         'youtube_id_1_0': 'p2Q6BrNhdh8',
         'youtube_id_1_25': '1EeWXzPdhSA',
         'youtube_id_1_5': 'rABDYkeK0x8',
         'show_captions': False,
         'start_time': datetime.timedelta(seconds=1),
         'end_time': datetime.timedelta(seconds=60),
         'track': 'http://www.example.com/track',
         # 'download_track': True,
         'html5_sources': ['http://www.example.com/source.mp4'],
         'data': '',
     })

# 需要导入模块: from xmodule.video_module import VideoDescriptor [as 别名]
# 或者: from xmodule.video_module.VideoDescriptor import from_xml [as 别名]
 def test_from_xml_double_quotes(self):
     """
     Make sure we can handle the double-quoted string format (which was used for exporting for
     a few weeks).
     """
     module_system = DummySystem(load_error_modules=True)
     xml_data = '''
         <video display_name="&quot;display_name&quot;"
             html5_sources="[&quot;source_1&quot;, &quot;source_2&quot;]"
             show_captions="false"
             download_video="true"
             sub="&quot;html5_subtitles&quot;"
             track="&quot;http://download_track&quot;"
             download_track="true"
             youtube_id_0_75="&quot;OEoXaMPEzf65&quot;"
             youtube_id_1_25="&quot;OEoXaMPEzf125&quot;"
             youtube_id_1_5="&quot;OEoXaMPEzf15&quot;"
             youtube_id_1_0="&quot;OEoXaMPEzf10&quot;"
             />
     '''
     output = VideoDescriptor.from_xml(xml_data, module_system, Mock())
     self.assert_attributes_equal(output, {
         'youtube_id_0_75': 'OEoXaMPEzf65',
         'youtube_id_1_0': 'OEoXaMPEzf10',
         'youtube_id_1_25': 'OEoXaMPEzf125',
         'youtube_id_1_5': 'OEoXaMPEzf15',
         'show_captions': False,
         'start_time': datetime.timedelta(seconds=0.0),
         'end_time': datetime.timedelta(seconds=0.0),
         'track': 'http://download_track',
         'download_track': True,
         'download_video': True,
         'html5_sources': ["source_1", "source_2"],
         'data': ''
     })

# 需要导入模块: from xmodule.video_module import VideoDescriptor [as 别名]
# 或者: from xmodule.video_module.VideoDescriptor import from_xml [as 别名]
    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")

# 需要导入模块: from xmodule.video_module import VideoDescriptor [as 别名]
# 或者: from xmodule.video_module.VideoDescriptor import from_xml [as 别名]
 def test_from_xml(self):
     module_system = DummySystem(load_error_modules=True)
     xml_data = '''
         <video display_name="Test Video"
                youtube="1.0:p2Q6BrNhdh8,0.75:izygArpw-Qo,1.25:1EeWXzPdhSA,1.5:rABDYkeK0x8"
                show_captions="false"
                start_time="00:00:01"
                end_time="00:01:00">
           <source src="http://www.example.com/source.mp4"/>
           <track src="http://www.example.com/track"/>
         </video>
     '''
     output = VideoDescriptor.from_xml(xml_data, module_system)
     self.assert_attributes_equal(output, {
         'youtube_id_0_75': 'izygArpw-Qo',
         'youtube_id_1_0': 'p2Q6BrNhdh8',
         'youtube_id_1_25': '1EeWXzPdhSA',
         'youtube_id_1_5': 'rABDYkeK0x8',
         'show_captions': False,
         'start_time': 1.0,
         'end_time': 60,
         'track': 'http://www.example.com/track',
         'source': 'http://www.example.com/source.mp4',
         'html5_sources': ['http://www.example.com/source.mp4'],
         'data': ''
     })

# 需要导入模块: from xmodule.video_module import VideoDescriptor [as 别名]
# 或者: from xmodule.video_module.VideoDescriptor import from_xml [as 别名]
    def test_import_val_data(self, mock_val_api):
        def mock_val_import(xml, edx_video_id, course_id):
            """Mock edxval.api.import_from_xml"""
            self.assertEqual(xml.tag, 'video_asset')
            self.assertEqual(dict(xml.items()), {'mock_attr': ''})
            self.assertEqual(edx_video_id, 'test_edx_video_id')
            self.assertEqual(course_id, 'test_course_id')

        mock_val_api.import_from_xml = Mock(wraps=mock_val_import)
        module_system = DummySystem(load_error_modules=True)

        # import new edx_video_id
        xml_data = """
            <video edx_video_id="test_edx_video_id">
                <video_asset mock_attr=""/>
            </video>
        """
        id_generator = Mock()
        id_generator.target_course_id = 'test_course_id'
        video = VideoDescriptor.from_xml(xml_data, module_system, id_generator)

        self.assert_attributes_equal(video, {'edx_video_id': 'test_edx_video_id'})
        mock_val_api.import_from_xml.assert_called_once_with(
            ANY,
            'test_edx_video_id',
            course_id='test_course_id'
        )

# 需要导入模块: from xmodule.video_module import VideoDescriptor [as 别名]
# 或者: from xmodule.video_module.VideoDescriptor import from_xml [as 别名]
 def test_from_xml_missing_attributes(self):
     """
     Ensure that attributes have the right values if they aren't
     explicitly set in XML.
     """
     module_system = DummySystem(load_error_modules=True)
     xml_data = '''
         <video display_name="Test Video"
                youtube="1.0:p2Q6BrNhdh8,1.25:1EeWXzPdhSA"
                show_captions="true">
           <source src="http://www.example.com/source.mp4"/>
           <track src="http://www.example.com/track"/>
         </video>
     '''
     output = VideoDescriptor.from_xml(xml_data, module_system)
     self.assert_attributes_equal(output, {
         'youtube_id_0_75': '',
         'youtube_id_1_0': 'p2Q6BrNhdh8',
         'youtube_id_1_25': '1EeWXzPdhSA',
         'youtube_id_1_5': '',
         'show_captions': True,
         'start_time': 0.0,
         'end_time': 0.0,
         'track': 'http://www.example.com/track',
         'source': 'http://www.example.com/source.mp4',
         'html5_sources': ['http://www.example.com/source.mp4'],
         'data': ''
     })

# 需要导入模块: from xmodule.video_module import VideoDescriptor [as 别名]
# 或者: from xmodule.video_module.VideoDescriptor import from_xml [as 别名]
 def test_from_xml(self):
     module_system = DummySystem(load_error_modules=True)
     xml_data = '''
         <video display_name="Test Video"
                youtube="1.0:p2Q6BrNhdh8,0.75:izygArpw-Qo,1.25:1EeWXzPdhSA,1.5:rABDYkeK0x8"
                show_captions="false"
                download_track="false"
                start_time="00:00:01"
                download_video="false"
                end_time="00:01:00">
           <source src="http://www.example.com/source.mp4"/>
           <track src="http://www.example.com/track"/>
           <handout src="http://www.example.com/handout"/>
           <transcript language="uk" src="ukrainian_translation.srt" />
           <transcript language="de" src="german_translation.srt" />
         </video>
     '''
     output = VideoDescriptor.from_xml(xml_data, module_system, Mock())
     self.assert_attributes_equal(output, {
         'youtube_id_0_75': 'izygArpw-Qo',
         'youtube_id_1_0': 'p2Q6BrNhdh8',
         'youtube_id_1_25': '1EeWXzPdhSA',
         'youtube_id_1_5': 'rABDYkeK0x8',
         'show_captions': False,
         'start_time': datetime.timedelta(seconds=1),
         'end_time': datetime.timedelta(seconds=60),
         'track': 'http://www.example.com/track',
         'handout': 'http://www.example.com/handout',
         'download_track': False,
         'download_video': False,
         'html5_sources': ['http://www.example.com/source.mp4'],
         'data': '',
         'transcripts': {'uk': 'ukrainian_translation.srt', 'de': 'german_translation.srt'},
     })

# 需要导入模块: from xmodule.video_module import VideoDescriptor [as 别名]
# 或者: from xmodule.video_module.VideoDescriptor import from_xml [as 别名]
 def test_old_video_data(self):
     """
     Ensure that Video is able to read VideoModule's model data.
     """
     module_system = DummySystem(load_error_modules=True)
     xml_data = """
         <video display_name="Test Video"
                youtube="1.0:p2Q6BrNhdh8,0.75:izygArpw-Qo,1.25:1EeWXzPdhSA,1.5:rABDYkeK0x8"
                show_captions="false"
                from="00:00:01"
                to="00:01:00">
           <source src="http://www.example.com/source.mp4"/>
           <track src="http://www.example.com/track"/>
         </video>
     """
     video = VideoDescriptor.from_xml(xml_data, module_system)
     self.assert_attributes_equal(video, {
         'youtube_id_0_75': 'izygArpw-Qo',
         'youtube_id_1_0': 'p2Q6BrNhdh8',
         'youtube_id_1_25': '1EeWXzPdhSA',
         'youtube_id_1_5': 'rABDYkeK0x8',
         'show_captions': False,
         'start_time': 1.0,
         'end_time': 60,
         'track': 'http://www.example.com/track',
         'html5_sources': ['http://www.example.com/source.mp4'],
         'data': ''
     })

# 需要导入模块: from xmodule.video_module import VideoDescriptor [as 别名]
# 或者: from xmodule.video_module.VideoDescriptor import from_xml [as 别名]
 def test_from_xml_no_attributes(self):
     """
     Make sure settings are correct if none are explicitly set in XML.
     """
     module_system = DummySystem(load_error_modules=True)
     xml_data = '<video></video>'
     output = VideoDescriptor.from_xml(xml_data, module_system)
     self.assertEquals(output.youtube_id_0_75, '')
     self.assertEquals(output.youtube_id_1_0, 'OEoXaMPEzfM')
     self.assertEquals(output.youtube_id_1_25, '')
     self.assertEquals(output.youtube_id_1_5, '')
     self.assertEquals(output.show_captions, True)
     self.assertEquals(output.start_time, 0.0)
     self.assertEquals(output.end_time, 0.0)
     self.assertEquals(output.track, '')
     self.assertEquals(output.source, '')

# 需要导入模块: from xmodule.video_module import VideoDescriptor [as 别名]
# 或者: from xmodule.video_module.VideoDescriptor import from_xml [as 别名]
 def test_from_xml_no_attributes(self):
     """
     Make sure settings are correct if none are explicitly set in XML.
     """
     module_system = DummySystem(load_error_modules=True)
     xml_data = '<video></video>'
     output = VideoDescriptor.from_xml(xml_data, module_system)
     self.assert_attributes_equal(output, {
         'youtube_id_0_75': '',
         'youtube_id_1_0': 'OEoXaMPEzfM',
         'youtube_id_1_25': '',
         'youtube_id_1_5': '',
         'show_captions': True,
         'start_time': 0.0,
         'end_time': 0.0,
         'track': '',
         'source': '',
         'html5_sources': [],
         'data': ''
     })

# 需要导入模块: from xmodule.video_module import VideoDescriptor [as 别名]
# 或者: from xmodule.video_module.VideoDescriptor import from_xml [as 别名]
    def test_from_xml_when_handout_is_course_asset(self, course_id_string, expected_handout_link):
        """
        Test that if handout link is course_asset then it will contain targeted course_id in handout link.
        """
        module_system = DummySystem(load_error_modules=True)
        course_id = CourseKey.from_string(course_id_string)
        xml_data = '''
            <video display_name="Test Video"
                   youtube="1.0:p2Q6BrNhdh8,0.75:izygArpw-Qo,1.25:1EeWXzPdhSA,1.5:rABDYkeK0x8"
                   show_captions="false"
                   download_track="false"
                   start_time="00:00:01"
                   download_video="false"
                   end_time="00:01:00">
              <source src="http://www.example.com/source.mp4"/>
              <track src="http://www.example.com/track"/>
              <handout src="/asset-v1:[email protected][email protected]"/>
              <transcript language="uk" src="ukrainian_translation.srt" />
              <transcript language="de" src="german_translation.srt" />
            </video>
        '''
        id_generator = Mock()
        id_generator.target_course_id = course_id

        output = VideoDescriptor.from_xml(xml_data, module_system, id_generator)
        self.assert_attributes_equal(output, {
            'youtube_id_0_75': 'izygArpw-Qo',
            'youtube_id_1_0': 'p2Q6BrNhdh8',
            'youtube_id_1_25': '1EeWXzPdhSA',
            'youtube_id_1_5': 'rABDYkeK0x8',
            'show_captions': False,
            'start_time': datetime.timedelta(seconds=1),
            'end_time': datetime.timedelta(seconds=60),
            'track': 'http://www.example.com/track',
            'handout': expected_handout_link,
            'download_track': False,
            'download_video': False,
            'html5_sources': ['http://www.example.com/source.mp4'],
            'data': '',
            'transcripts': {'uk': 'ukrainian_translation.srt', 'de': 'german_translation.srt'},
        })

# 需要导入模块: from xmodule.video_module import VideoDescriptor [as 别名]
# 或者: from xmodule.video_module.VideoDescriptor import from_xml [as 别名]
 def test_from_xml_double_quote_concatenated_youtube(self):
     module_system = DummySystem(load_error_modules=True)
     xml_data = '''
         <video display_name="Test Video"
                youtube="1.0:&quot;p2Q6BrNhdh8&quot;,1.25:&quot;1EeWXzPdhSA&quot;">
         </video>
     '''
     output = VideoDescriptor.from_xml(xml_data, module_system)
     self.assert_attributes_equal(output, {
         'youtube_id_0_75': '',
         'youtube_id_1_0': 'p2Q6BrNhdh8',
         'youtube_id_1_25': '1EeWXzPdhSA',
         'youtube_id_1_5': '',
         'show_captions': True,
         'start_time': 0.0,
         'end_time': 0.0,
         'track': '',
         'source': '',
         'html5_sources': [],
         'data': ''
     })

# 需要导入模块: from xmodule.video_module import VideoDescriptor [as 别名]
# 或者: from xmodule.video_module.VideoDescriptor import from_xml [as 别名]
    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)

# 需要导入模块: from xmodule.video_module import VideoDescriptor [as 别名]
# 或者: from xmodule.video_module.VideoDescriptor import from_xml [as 别名]
 def test_from_xml(self):
     module_system = DummySystem(load_error_modules=True)
     xml_data = '''
         <video display_name="Test Video"
                youtube="1.0:p2Q6BrNhdh8,0.75:izygArpw-Qo,1.25:1EeWXzPdhSA,1.5:rABDYkeK0x8"
                show_captions="false"
                from="00:00:01"
                to="00:01:00">
           <source src="http://www.example.com/source.mp4"/>
           <track src="http://www.example.com/track"/>
         </video>
     '''
     output = VideoDescriptor.from_xml(xml_data, module_system)
     self.assertEquals(output.youtube_id_0_75, 'izygArpw-Qo')
     self.assertEquals(output.youtube_id_1_0, 'p2Q6BrNhdh8')
     self.assertEquals(output.youtube_id_1_25, '1EeWXzPdhSA')
     self.assertEquals(output.youtube_id_1_5, 'rABDYkeK0x8')
     self.assertEquals(output.show_captions, False)
     self.assertEquals(output.start_time, 1.0)
     self.assertEquals(output.end_time, 60)
     self.assertEquals(output.track, 'http://www.example.com/track')
     self.assertEquals(output.source, 'http://www.example.com/source.mp4')