Python locator.LibraryLocator类代码示例

    def test_for_branch(self):
        lib_key = LibraryLocator(org='TestX', library='test', branch='initial')

        branch2 = "br2"
        branch2_key = lib_key.for_branch(branch2)
        self.assertEqual(branch2_key.branch, branch2)  # pylint: disable=no-member

        normal_branch = lib_key.for_branch(None)
        self.assertEqual(normal_branch.branch, None)  # pylint: disable=no-member

 def test_lib_key_no_deprecated_support(self):
     lib_key = CourseKey.from_string('library-v1:TestX+lib1')
     with self.assertRaises(AttributeError):
         lib_key.to_deprecated_string()
     with self.assertRaises(NotImplementedError):
         lib_key._to_deprecated_string()  # pylint: disable=protected-access
     with self.assertRaises(NotImplementedError):
         LibraryLocator._from_deprecated_string('test/test/test')  # pylint: disable=protected-access
     with self.assertRaises(InvalidKeyError):
         LibraryLocator(org='org', library='code', deprecated=True)

 def test_from_json_studio_editor_style(self):
     """
     Test that LibraryList can parse raw libraries list as passed by studio editor
     """
     lib_list = LibraryList()
     lib1_key, lib1_version = u'library-v1:Org1+Lib1', '5436ffec56c02c13806a4c1b'
     lib2_key, lib2_version = u'library-v1:Org2+Lib2', '112dbaf312c0daa019ce9992'
     raw = [lib1_key + ',' + lib1_version, lib2_key + ',' + lib2_version]
     parsed = lib_list.from_json(raw)
     self.assertEqual(len(parsed), 2)
     self.assertEquals(parsed[0].library_id, LibraryLocator.from_string(lib1_key))
     self.assertEquals(parsed[0].version, ObjectId(lib1_version))
     self.assertEquals(parsed[1].library_id, LibraryLocator.from_string(lib2_key))
     self.assertEquals(parsed[1].version, ObjectId(lib2_version))

    def test_lib_key_constructor_version_guid(self, version_id):
        version_id_str = str(version_id)
        version_id_obj = ObjectId(version_id)

        lib_key = LibraryLocator(version_guid=version_id)
        self.assertEqual(lib_key.version_guid, version_id_obj)  # pylint: disable=no-member
        self.assertEqual(lib_key.org, None)
        self.assertEqual(lib_key.library, None)  # pylint: disable=no-member
        self.assertEqual(str(lib_key.version_guid), version_id_str)  # pylint: disable=no-member
        # Allow access to _to_string
        # pylint: disable=protected-access
        expected_str = u'@'.join((lib_key.VERSION_PREFIX, version_id_str))
        self.assertEqual(lib_key._to_string(), expected_str)
        self.assertEqual(str(lib_key), u'library-v1:' + expected_str)
        self.assertEqual(lib_key.html_id(), u'library-v1:' + expected_str)

    def _get_library(self, library_key):
        """
        Given a library key like "library-v1:ProblemX+PR0B", return the
        'library' XBlock with meta-information about the library.

        Returns None on error.
        """
        if not isinstance(library_key, LibraryLocator):
            library_key = LibraryLocator.from_string(library_key)
        assert library_key.version_guid is None

        try:
            return self.store.get_library(library_key, remove_version=False, remove_branch=False)
        except ItemNotFoundError:
            return None

 def __new__(cls, library_id, version=None):
     # pylint: disable=super-on-old-class
     if not isinstance(library_id, LibraryLocator):
         library_id = LibraryLocator.from_string(library_id)
     if library_id.version_guid:
         assert (version is None) or (version == library_id.version_guid)
         if not version:
             version = library_id.version_guid
         library_id = library_id.for_version(None)
     if version and not isinstance(version, ObjectId):
         try:
             version = ObjectId(version)
         except InvalidId:
             raise ValueError(version)
     return super(LibraryVersionReference, cls).__new__(cls, library_id, version)

 def source_library_key(self):
     """
     Convenience method to get the library ID as a LibraryLocator and not just a string
     """
     return LibraryLocator.from_string(self.source_library_id)

 def test_lib_key_with_trailing_whitespace(self, lib_id_fmt, whitespace):
     with self.assertRaises(InvalidKeyError):
         LibraryLocator.from_string(lib_id_fmt.format(whitespace))

 def test_lib_key_from_invalid_string(self, lib_id_str):
     with self.assertRaises(InvalidKeyError):
         LibraryLocator.from_string(lib_id_str)

 def test_changing_course(self):
     lib_key = LibraryLocator(org="TestX", library="test")
     with self.assertRaises(AttributeError):
         lib_key.course = "PHYS"
     with self.assertRaises(KeyError):
         lib_key.replace(course="PHYS")

 def test_version_only_lib_key(self):
     version_only_lib_key = LibraryLocator(version_guid=ObjectId('519665f6223ebd6980884f2b'))
     self.assertEqual(version_only_lib_key.org, None)
     self.assertEqual(version_only_lib_key.library, None)  # pylint: disable=no-member
     with self.assertRaises(InvalidKeyError):
         version_only_lib_key.for_branch("test")