Example #1
0
    def test_storage_roots_roots_file(self):
        """Test the roots_file property."""

        relative_roots_path = os.path.join("core", "roots.yml")

        single_root = StorageRoots.from_config(self._single_root_config_folder)
        self.assertEqual(
            single_root.roots_file,
            os.path.join(self._single_root_config_folder, relative_roots_path))

        multiple_roots = StorageRoots.from_config(
            self._multiple_roots_config_folder)
        self.assertEqual(
            multiple_roots.roots_file,
            os.path.join(self._multiple_roots_config_folder,
                         relative_roots_path))

        empty_roots = StorageRoots.from_config(self._empty_roots_config_folder)
        self.assertEqual(
            empty_roots.roots_file,
            os.path.join(self._empty_roots_config_folder, relative_roots_path))

        no_roots = StorageRoots.from_config(self._no_roots_config_folder)
        self.assertEqual(
            no_roots.roots_file,
            os.path.join(self._no_roots_config_folder, relative_roots_path))
    def test_storage_roots_roots_file(self):
        """Test the roots_file property."""

        relative_roots_path = os.path.join("core", "roots.yml")

        single_root = StorageRoots.from_config(self._single_root_config_folder)
        self.assertEqual(
            single_root.roots_file,
            os.path.join(self._single_root_config_folder, relative_roots_path)
        )

        multiple_roots = StorageRoots.from_config(self._multiple_roots_config_folder)
        self.assertEqual(
            multiple_roots.roots_file,
            os.path.join(self._multiple_roots_config_folder, relative_roots_path)
        )

        empty_roots = StorageRoots.from_config(self._empty_roots_config_folder)
        self.assertEqual(
            empty_roots.roots_file,
            os.path.join(self._empty_roots_config_folder, relative_roots_path)
        )

        no_roots = StorageRoots.from_config(self._no_roots_config_folder)
        self.assertEqual(
            no_roots.roots_file,
            os.path.join(self._no_roots_config_folder, relative_roots_path)
        )
Example #3
0
    def test_storage_roots_default(self):
        """Test the default property."""

        single_root = StorageRoots.from_config(self._single_root_config_folder)
        self.assertEqual(single_root.default, "primary")

        multiple_roots = StorageRoots.from_config(
            self._multiple_roots_config_folder)
        self.assertEqual(multiple_roots.default, "work")

        no_roots = StorageRoots.from_config(self._no_roots_config_folder)
        self.assertEqual(no_roots.default, None)
    def test_storage_roots_default(self):
        """Test the default property."""

        single_root = StorageRoots.from_config(self._single_root_config_folder)
        self.assertEqual(single_root.default, "primary")

        multiple_roots = StorageRoots.from_config(self._multiple_roots_config_folder)
        self.assertEqual(multiple_roots.default, "work")

        empty_roots = StorageRoots.from_config(self._empty_roots_config_folder)
        self.assertEqual(empty_roots.default, None)

        no_roots = StorageRoots.from_config(self._no_roots_config_folder)
        self.assertEqual(no_roots.default, None)
    def test_storage_roots_write(self):
        """Test the write class method."""

        config_root_folders = [
            self._single_root_config_folder,
            self._multiple_roots_config_folder,
            self._empty_roots_config_folder,
            self._no_roots_config_folder
        ]

        for config_root_folder in config_root_folders:

            storage_roots_A = StorageRoots.from_config(config_root_folder)

            out_roots_folder = os.path.join(
                self._config_folder,
                "core",
            )
            if not os.path.exists(out_roots_folder):
                os.makedirs(out_roots_folder)

            if config_root_folder == self._multiple_roots_config_folder:
                # this should raise because there is an unmapped storage (foobar)
                with self.assertRaises(TankError):
                    StorageRoots.write(self.mockgun, self._config_folder, storage_roots_A)
                continue
            else:
                # all others should without issue
                StorageRoots.write(self.mockgun, self._config_folder, storage_roots_A)

            roots_file = os.path.join(out_roots_folder, "roots.yml")
            self.assertTrue(os.path.exists(roots_file))

            storage_roots_B = StorageRoots.from_config(self._config_folder)

            self.assertEqual(storage_roots_B.roots_file, roots_file)

            self.assertEqual(
                sorted(storage_roots_A.required_roots),
                sorted(storage_roots_B.required_roots)
            )

            for root_name in storage_roots_A.required_roots:
                self.assertEqual(
                    storage_roots_A.metadata[root_name],
                    storage_roots_B.metadata[root_name],
                )

            # clean up the file written to disk
            os.remove(storage_roots_B.roots_file)
Example #6
0
    def test_storage_roots_write(self):
        """Test the write class method."""

        config_root_folders = [
            self._single_root_config_folder,
            self._multiple_roots_config_folder,
            self._empty_roots_config_folder, self._no_roots_config_folder
        ]

        for config_root_folder in config_root_folders:

            storage_roots_A = StorageRoots.from_config(config_root_folder)

            out_roots_folder = os.path.join(
                self._config_folder,
                "core",
            )
            if not os.path.exists(out_roots_folder):
                os.makedirs(out_roots_folder)

            if config_root_folder == self._multiple_roots_config_folder:
                # this should raise because there is an unmapped storage (foobar)
                with self.assertRaises(TankError):
                    StorageRoots.write(self.mockgun, self._config_folder,
                                       storage_roots_A)
                continue
            else:
                # all others should without issue
                StorageRoots.write(self.mockgun, self._config_folder,
                                   storage_roots_A)

            roots_file = os.path.join(out_roots_folder, "roots.yml")
            self.assertTrue(os.path.exists(roots_file))

            storage_roots_B = StorageRoots.from_config(self._config_folder)

            self.assertEqual(storage_roots_B.roots_file, roots_file)

            self.assertEqual(sorted(storage_roots_A.required_roots),
                             sorted(storage_roots_B.required_roots))

            for root_name in storage_roots_A.required_roots:
                self.assertEqual(
                    storage_roots_A.metadata[root_name],
                    storage_roots_B.metadata[root_name],
                )

            # clean up the file written to disk
            os.remove(storage_roots_B.roots_file)
Example #7
0
    def test_storage_roots_from_config(self):
        """Test the from_config factory class method."""

        single_root = StorageRoots.from_config(self._single_root_config_folder)
        self.assertIsInstance(single_root, StorageRoots)

        multiple_roots = StorageRoots.from_config(
            self._multiple_roots_config_folder)
        self.assertIsInstance(multiple_roots, StorageRoots)

        no_roots = StorageRoots.from_config(self._no_roots_config_folder)
        self.assertIsInstance(no_roots, StorageRoots)

        with self.assertRaises(TankError):
            StorageRoots.from_config(self._corrupt_roots_config_folder)
Example #8
0
    def test_storage_roots_required_roots(self):
        """Test the required_roots property."""

        single_root = StorageRoots.from_config(self._single_root_config_folder)
        single_root_required_storage_names = single_root.required_roots
        for root_name in self._single_root_metadata:
            self.assertTrue(root_name in single_root_required_storage_names)

        multiple_roots = StorageRoots.from_config(
            self._multiple_roots_config_folder)
        multiple_roots_required_storage_names = multiple_roots.required_roots
        for root_name in self._multiple_roots_metadata:
            self.assertTrue(root_name in multiple_roots_required_storage_names)

        no_roots = StorageRoots.from_config(self._no_roots_config_folder)
        self.assertEqual(no_roots.required_roots, [])
Example #9
0
    def test_storage_roots_default_path(self):
        """Test the default_path property."""

        single_root = StorageRoots.from_config(self._single_root_config_folder)
        single_root_default_path = ShotgunPath.from_shotgun_dict(
            self._single_root_metadata["primary"])
        self.assertTrue(single_root.default_path, single_root_default_path)

        multiple_roots = StorageRoots.from_config(
            self._multiple_roots_config_folder)
        multiple_roots_default_path = ShotgunPath.from_shotgun_dict(
            self._multiple_roots_metadata["work"])
        self.assertTrue(multiple_roots.default_path,
                        multiple_roots_default_path)

        no_roots = StorageRoots.from_config(self._no_roots_config_folder)
        self.assertEqual(no_roots.default_path, None)
Example #10
0
    def test_storage_roots_required_roots(self):
        """Test the required_roots property."""

        single_root = StorageRoots.from_config(self._single_root_config_folder)
        single_root_required_storage_names = single_root.required_roots
        for root_name in self._single_root_metadata:
            self.assertTrue(root_name in single_root_required_storage_names)

        multiple_roots = StorageRoots.from_config(self._multiple_roots_config_folder)
        multiple_roots_required_storage_names = multiple_roots.required_roots
        for root_name in self._multiple_roots_metadata:
            self.assertTrue(root_name in multiple_roots_required_storage_names)

        empty_roots = StorageRoots.from_config(self._empty_roots_config_folder)
        self.assertEqual(empty_roots.required_roots, [])

        no_roots = StorageRoots.from_config(self._no_roots_config_folder)
        self.assertEqual(no_roots.required_roots, [])
Example #11
0
    def test_storage_roots_default_path(self):
        """Test the default_path property."""

        single_root = StorageRoots.from_config(self._single_root_config_folder)
        single_root_default_path = ShotgunPath.from_shotgun_dict(
            self._single_root_metadata["primary"])
        self.assertTrue(single_root.default_path, single_root_default_path)

        multiple_roots = StorageRoots.from_config(self._multiple_roots_config_folder)
        multiple_roots_default_path = ShotgunPath.from_shotgun_dict(
            self._multiple_roots_metadata["work"])
        self.assertTrue(multiple_roots.default_path, multiple_roots_default_path)

        empty_roots = StorageRoots.from_config(self._empty_roots_config_folder)
        self.assertEqual(empty_roots.default_path, None)

        no_roots = StorageRoots.from_config(self._no_roots_config_folder)
        self.assertEqual(no_roots.default_path, None)
Example #12
0
    def test_storage_roots_as_shotgun_paths(self):
        """Test the as_shotgun_paths property."""

        config_root_folders = [
            self._single_root_config_folder,
            self._multiple_roots_config_folder, self._no_roots_config_folder
        ]

        for config_root_folder in config_root_folders:
            storage_roots = StorageRoots.from_config(config_root_folder)
            for root_name, sg_path in storage_roots.as_shotgun_paths.iteritems(
            ):
                self.assertIsInstance(sg_path, ShotgunPath)
Example #13
0
    def test_storage_roots_as_shotgun_paths(self):
        """Test the as_shotgun_paths property."""

        config_root_folders = [
            self._single_root_config_folder,
            self._multiple_roots_config_folder,
            self._empty_roots_config_folder,
            self._no_roots_config_folder
        ]

        for config_root_folder in config_root_folders:
            storage_roots = StorageRoots.from_config(config_root_folder)
            for root_name, sg_path in storage_roots.as_shotgun_paths.iteritems():
                self.assertIsInstance(sg_path, ShotgunPath)
Example #14
0
    def test_storage_roots_from_config(self):
        """Test the from_config factory class method."""

        single_root = StorageRoots.from_config(self._single_root_config_folder)
        self.assertIsInstance(single_root, StorageRoots)

        multiple_roots = StorageRoots.from_config(self._multiple_roots_config_folder)
        self.assertIsInstance(multiple_roots, StorageRoots)

        empty_roots = StorageRoots.from_config(self._empty_roots_config_folder)
        self.assertIsInstance(empty_roots, StorageRoots)

        no_roots = StorageRoots.from_config(self._no_roots_config_folder)
        self.assertIsInstance(no_roots, StorageRoots)

        with self.assertRaises(TankError):
            StorageRoots.from_config(self._corrupt_roots_config_folder)