def test_parse_youtube_invalid(self):
        """Ensure that ids that are invalid return an empty dict"""

        # invalid id
        youtube_str = 'thisisaninvalidid'
        output = VideoDescriptor._parse_youtube(youtube_str)
        self.assertEqual(output, {'0.75': '',
                                  '1.00': '',
                                  '1.25': '',
                                  '1.50': ''})
        # another invalid id
        youtube_str = ',::,:,,'
        output = VideoDescriptor._parse_youtube(youtube_str)
        self.assertEqual(output, {'0.75': '',
                                  '1.00': '',
                                  '1.25': '',
                                  '1.50': ''})

        # and another one, partially invalid
        youtube_str = '0.75_BAD!!!,1.0:AXdE34_U,1.25:KLHF9K_Y,1.5:VO3SxfeD,'
        output = VideoDescriptor._parse_youtube(youtube_str)
        self.assertEqual(output, {'0.75': '',
                                  '1.00': 'AXdE34_U',
                                  '1.25': 'KLHF9K_Y',
                                  '1.50': 'VO3SxfeD'})

    def test_export_to_xml_empty_parameters(self):
        """Test XML export with defaults."""
        module_system = DummySystem(load_error_modules=True)
        desc = VideoDescriptor(module_system, DictFieldData({}), ScopeIds(None, None, self.location, self.location))

        xml = desc.definition_to_xml(None)
        expected = '<video url_name="SampleProblem1"/>\n'

        self.assertEquals(expected, etree.tostring(xml, pretty_print=True))

    def test_export_to_xml_empty_parameters(self):
        """Test XML export with defaults."""
        module_system = DummySystem(load_error_modules=True)
        location = Location(["i4x", "edX", "video", "default", "SampleProblem1"])
        desc = VideoDescriptor(module_system, {'location': location})

        xml = desc.export_to_xml(None)
        expected = '<video url_name="SampleProblem1"/>\n'

        self.assertEquals(expected, xml)

 def test_parse_youtube_key_format(self):
     """
     Make sure that inconsistent speed keys are parsed correctly.
     """
     youtube_str = '1.00:p2Q6BrNhdh8'
     youtube_str_hack = '1.0:p2Q6BrNhdh8'
     self.assertEqual(
         VideoDescriptor._parse_youtube(youtube_str),
         VideoDescriptor._parse_youtube(youtube_str_hack)
     )

    def create():
        """Method return Video Xmodule instance."""
        location = Location(["i4x", "edX", "video", "default",
                             "SampleProblem1"])
        field_data = {'data': VideoFactory.sample_problem_xml_youtube,
                      'location': location}

        system = get_test_descriptor_system()

        descriptor = VideoDescriptor(system, DictFieldData(field_data), ScopeIds(None, None, None, None))
        descriptor.xmodule_runtime = get_test_system()
        return descriptor

    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())

 def test_create_youtube_string_missing(self):
     """
     Test that Youtube IDs which aren't explicitly set aren't included
     in the output string.
     """
     system = DummySystem(load_error_modules=True)
     location = Location("edX", 'course', 'run', "video", "SampleProblem1", None)
     field_data = DictFieldData({'location': location})
     descriptor = VideoDescriptor(system, field_data, Mock())
     descriptor.youtube_id_0_75 = 'izygArpw-Qo'
     descriptor.youtube_id_1_0 = 'p2Q6BrNhdh8'
     descriptor.youtube_id_1_25 = '1EeWXzPdhSA'
     expected = "0.75:izygArpw-Qo,1.00:p2Q6BrNhdh8,1.25:1EeWXzPdhSA"
     self.assertEqual(create_youtube_string(descriptor), expected)

 def test_create_youtube_string_missing(self):
     """
     Test that Youtube IDs which aren't explicitly set aren't included
     in the output string.
     """
     system = DummySystem(load_error_modules=True)
     location = Location(["i4x", "edX", "video", "default", "SampleProblem1"])
     model_data = {'location': location}
     descriptor = VideoDescriptor(system, model_data)
     descriptor.youtube_id_0_75 = 'izygArpw-Qo'
     descriptor.youtube_id_1_0 = 'p2Q6BrNhdh8'
     descriptor.youtube_id_1_25 = '1EeWXzPdhSA'
     expected = "0.75:izygArpw-Qo,1.00:p2Q6BrNhdh8,1.25:1EeWXzPdhSA"
     self.assertEqual(_create_youtube_string(descriptor), expected)

 def test_create_youtube_string(self):
     """
     Test that Youtube ID strings are correctly created when writing
     back out to XML.
     """
     system = DummySystem(load_error_modules=True)
     location = Location("edX", 'course', 'run', "video", 'SampleProblem1', None)
     field_data = DictFieldData({'location': location})
     descriptor = VideoDescriptor(system, field_data, Mock())
     descriptor.youtube_id_0_75 = 'izygArpw-Qo'
     descriptor.youtube_id_1_0 = 'p2Q6BrNhdh8'
     descriptor.youtube_id_1_25 = '1EeWXzPdhSA'
     descriptor.youtube_id_1_5 = 'rABDYkeK0x8'
     expected = "0.75:izygArpw-Qo,1.00:p2Q6BrNhdh8,1.25:1EeWXzPdhSA,1.50:rABDYkeK0x8"
     self.assertEqual(create_youtube_string(descriptor), expected)

 def test_create_youtube_string(self):
     """
     Test that Youtube ID strings are correctly created when writing
     back out to XML.
     """
     system = DummySystem(load_error_modules=True)
     location = Location(["i4x", "edX", "video", "default", "SampleProblem1"])
     model_data = {'location': location}
     descriptor = VideoDescriptor(system, model_data)
     descriptor.youtube_id_0_75 = 'izygArpw-Qo'
     descriptor.youtube_id_1_0 = 'p2Q6BrNhdh8'
     descriptor.youtube_id_1_25 = '1EeWXzPdhSA'
     descriptor.youtube_id_1_5 = 'rABDYkeK0x8'
     expected = "0.75:izygArpw-Qo,1.00:p2Q6BrNhdh8,1.25:1EeWXzPdhSA,1.50:rABDYkeK0x8"
     self.assertEqual(_create_youtube_string(descriptor), expected)

    def create():
        """Method return Video Xmodule instance."""
        location = Location(["i4x", "edX", "video", "default",
                             "SampleProblem1"])
        model_data = {'data': VideoFactory.sample_problem_xml_youtube,
                      'location': location}

        system = get_test_system()
        system.render_template = lambda template, context: context

        descriptor = VideoDescriptor(system, model_data)

        module = descriptor.xmodule(system)

        return module

 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': ''
     })

    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'
        )

 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': ''
     })

 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': '',
     })

 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': ''
     })

 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'},
     })

 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': ''
     })

    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 test_parse_youtube(self):
     """Test parsing old-style Youtube ID strings into a dict."""
     youtube_str = '0.75:jNCf2gIqpeE,1.00:ZwkTiUPN0mg,1.25:rsq9auxASqI,1.50:kMyNdzVHHgg'
     output = VideoDescriptor._parse_youtube(youtube_str)
     self.assertEqual(output, {'0.75': 'jNCf2gIqpeE',
                               '1.00': 'ZwkTiUPN0mg',
                               '1.25': 'rsq9auxASqI',
                               '1.50': 'kMyNdzVHHgg'})