def test_pipeline_config_id_env_var(self, _):
"""
Tests the SHOTGUN_PIPELINE_CONFIGURATION_ID being picked up at init
"""
mgr = ToolkitManager()
self.assertEqual(mgr.pipeline_configuration, None)
with temp_env_var(SHOTGUN_PIPELINE_CONFIGURATION_ID="123"):
mgr = ToolkitManager()
self.assertEqual(mgr.pipeline_configuration, 123)
with temp_env_var(SHOTGUN_PIPELINE_CONFIGURATION_ID="invalid"):
mgr = ToolkitManager()
self.assertEqual(mgr.pipeline_configuration, None)
def test_serialization(self, _):
"""
Ensures we're serializing the manager properly.
"""
# Make sure nobody has added new parameters that need to be serialized.
class_attrs = set(dir(ToolkitManager))
instance_attrs = set(dir(ToolkitManager()))
unserializable_attrs = set([
"_sg_connection", "_sg_user", "_pre_engine_start_callback",
"_progress_cb"
])
# Through this operation, we're taking all the symbols that are defined from an instance,
# we then remove everything that is defined also in the class, which means we're left
# with what was added during __init__, and then we remove the parameters we know can't
# be serialized. We're left with a small list of values that can be serialized.
instance_data_members = instance_attrs - class_attrs - unserializable_attrs
self.assertEqual(len(instance_data_members), 7)
# Create a manager that hasn't been updated yet.
clean_mgr = ToolkitManager()
clean_settings = clean_mgr.extract_settings()
# Now create one where we modify everything.
modified_mgr = ToolkitManager()
modified_mgr.bundle_cache_fallback_paths = ["/a/b/c"]
modified_mgr.caching_policy = ToolkitManager.CACHE_FULL
modified_mgr.pipeline_configuration = "Primary"
modified_mgr.base_configuration = (
"sgtk:descriptor:app_store?"
"version=v0.18.91&name=tk-config-basic")
modified_mgr.do_shotgun_config_lookup = False
modified_mgr.plugin_id = "basic.default"
modified_mgr.allow_config_overrides = False
# Extract settings and make sure the implementation still stores dictionaries.
modified_settings = modified_mgr.extract_settings()
self.assertIsInstance(modified_settings, dict)
# Make sure the unit test properly changes all the settings from their default values.
for k, v in modified_settings.items():
self.assertNotEqual(v, clean_settings[k])
# Restore the settings from the manager.
restored_mgr = ToolkitManager()
restored_mgr.restore_settings(modified_settings)
# Extract the settings back from the restored manager to make sure everything was written
# back correctly.
self.assertEqual(restored_mgr.extract_settings(), modified_settings)
def test_shotgun_bundle_cache(self, _):
"""
Ensures ToolkitManager deals property with bundle cache from the user and from
environment variables.
"""
# Ensure the list is empty by default.
mgr = ToolkitManager()
self.assertEqual(mgr._get_bundle_cache_fallback_paths(), [])
# If the user bundle cache is set, we should see it in the results.
mgr.bundle_cache_fallback_paths = ["/a/b/c", "/d/e/f"]
self.assertEqual(set(mgr._get_bundle_cache_fallback_paths()),
set(["/a/b/c", "/d/e/f"]))
# Reset the user bundle cache.
mgr.bundle_cache_fallback_paths = []
self.assertEqual(mgr._get_bundle_cache_fallback_paths(), [])
# Set the environment variable which allows to inherit paths from another process.
with temp_env_var(SHOTGUN_BUNDLE_CACHE_FALLBACK_PATHS=os.pathsep.join(
["/g/h/i", "/j/k/l", "/a/b/c"])):
# Should see the content from the environment variable.
self.assertEqual(set(mgr._get_bundle_cache_fallback_paths()),
set(["/g/h/i", "/j/k/l", "/a/b/c"]))
# Add a few user specified folders.
mgr.bundle_cache_fallback_paths = ["/a/b/c", "/d/e/f"]
self.assertEqual(set(mgr._get_bundle_cache_fallback_paths()),
set(["/a/b/c", "/d/e/f", "/g/h/i", "/j/k/l"]))
# Now that the env var is not set anymore we should see its bundle caches.
self.assertEqual(set(mgr._get_bundle_cache_fallback_paths()),
set(["/a/b/c", "/d/e/f"]))
def test_get_entity_from_environment(self, _):
"""
Ensure the ToolkitManager can extract the entities from the environment
"""
# no env set
mgr = ToolkitManager()
self.assertEqual(mgr.get_entity_from_environment(), None)
# std case
with temp_env_var(SHOTGUN_ENTITY_TYPE="Shot", SHOTGUN_ENTITY_ID="123"):
self.assertEqual(mgr.get_entity_from_environment(), {
"type": "Shot",
"id": 123
})
# site mismatch
with temp_env_var(SHOTGUN_SITE="https://some.other.site",
SHOTGUN_ENTITY_TYPE="Shot",
SHOTGUN_ENTITY_ID="123"):
self.assertEqual(mgr.get_entity_from_environment(), None)
# invalid data case
with temp_env_var(SHOTGUN_ENTITY_TYPE="Shot",
SHOTGUN_ENTITY_ID="invalid"):
self.assertEqual(mgr.get_entity_from_environment(), None)
def test_override_logic(self):
"""
Tests that paths override descriptors
"""
self.mockgun.create(
"PipelineConfiguration",
dict(
code="Primary",
project=self._project,
users=[],
windows_path="/path",
mac_path="/path",
linux_path="/path",
plugin_ids="basic.*",
descriptor=
"sgtk:descriptor:app_store?name=tk-config-basic&version=v1.2.3",
uploaded_config=None,
))
mgr = ToolkitManager(self._mocked_sg_user)
mgr.plugin_id = "basic.test"
configs = mgr.get_pipeline_configurations(self._project)
config = configs[0]
self.assertEqual(
config["descriptor"].get_uri(),
"sgtk:descriptor:path?linux_path=/path&mac_path=/path&windows_path=\\path"
)
self.assertEqual(config["descriptor_source_uri"], None)
def test_latest_tracking_descriptor(self, _):
"""
Test descriptors tracking latest
"""
self.mockgun.create(
"PipelineConfiguration",
dict(
code="Primary",
project=self._project,
users=[],
windows_path=None,
mac_path=None,
linux_path=None,
plugin_ids="basic.*",
descriptor="sgtk:descriptor:app_store?name=tk-config-basic",
uploaded_config=None,
))
mgr = ToolkitManager(self._mocked_sg_user)
mgr.plugin_id = "basic.test"
configs = mgr.get_pipeline_configurations(self._project)
config = configs[0]
self.assertTrue(isinstance(config["descriptor"], Mock))
self.assertEqual(config["descriptor_source_uri"],
"sgtk:descriptor:app_store?name=tk-config-basic")
def test_prepare_engine(self):
"""
Makes sure that prepare engine works.
"""
mgr = ToolkitManager(_MockedShotgunUser(self.mockgun, "larry"))
mgr.do_shotgun_config_lookup = False
mgr.base_configuration = {
"type": "path",
"path": os.path.join(self.fixtures_root, "bootstrap_tests",
"config")
}
def progress_cb(progress_value, message):
self.assertLess(progress_cb.previous_progress, progress_value)
progress_cb.previous_progress = progress_value
if message.startswith("Checking"):
progress_cb.nb_exists_locally += 1
progress_cb.nb_exists_locally = 0
progress_cb.previous_progress = -1
mgr.progress_callback = progress_cb
path, desc = mgr.prepare_engine("test_engine", self.project)
self.assertEqual(desc.get_dict(), mgr.base_configuration)
self.assertEqual(
path, os.path.join(self.tank_temp, "unit_test_mock_sg", "p1",
"cfg"))
self.assertEqual(progress_cb.nb_exists_locally, 3)
def find_mock_impl(*args, **kwargs):
mgr = ToolkitManager()
mgr.pipeline_configuration = 1
with self.assertRaisesRegexp(
sgtk.bootstrap.TankBootstrapError,
"Can't enumerate pipeline configurations matching a specific id."
):
mgr.get_pipeline_configurations(None)
def test_basic_execution(self):
"""
Test basic execution and return value structure
"""
cc = self.mockgun.create(
"PipelineConfiguration",
dict(
code="Primary",
project=self._project,
users=[],
windows_path=None,
mac_path=None,
linux_path=None,
plugin_ids="basic.*",
descriptor=
"sgtk:descriptor:app_store?name=tk-config-basic&version=v1.2.3",
uploaded_config=None,
),
)
mgr = ToolkitManager(self._mocked_sg_user)
mgr.plugin_id = "basic.test"
configs = mgr.get_pipeline_configurations(self._project)
expected_fields = [
"descriptor_source_uri",
"name",
"project",
"descriptor",
"type",
"id",
]
self.assertEqual(len(configs), 1)
config = configs[0]
self.assertEqual(sorted(expected_fields), sorted(config.keys()))
self.assertEqual(config["id"], cc["id"])
self.assertEqual(config["type"], "PipelineConfiguration")
self.assertEqual(config["name"], "Primary")
self.assertEqual(config["project"], self._project)
self.assertEqual(
config["descriptor"].get_uri(),
"sgtk:descriptor:app_store?name=tk-config-basic&version=v1.2.3",
)
self.assertEqual(
config["descriptor_source_uri"],
"sgtk:descriptor:app_store?name=tk-config-basic&version=v1.2.3",
)
# with a different plugin id we won't get anything
mgr.plugin_id = "something.else"
configs = mgr.get_pipeline_configurations(self._project)
self.assertEqual(len(configs), 0)
def test_get_configs(self):
"""
Make sure we get the right config data from Shotgun.
"""
ec = self.external_config_loader
res_project_id, res_hash, res_pcs = ec._execute_get_configurations(
self._project["id"],
"123",
toolkit_manager=ToolkitManager(self._mocked_sg_user),
)
self.assertEqual(res_project_id, self._project["id"])
self.assertEqual(res_hash, "123")
self.assertEqual(len(res_pcs), 1)
self.assertEqual(res_pcs[0]["id"], self._pc["id"])
def test_user_filters(self):
"""
Test user based sandboxes
"""
self.mockgun.create(
"PipelineConfiguration",
dict(
code="Doe Dev",
project=self._project,
users=[self._john_doe],
windows_path=None,
mac_path=None,
linux_path=None,
plugin_ids="basic.*",
descriptor=
"sgtk:descriptor:app_store?name=tk-config-basic&version=v1.2.3",
uploaded_config=None,
),
)
self.mockgun.create(
"PipelineConfiguration",
dict(
code="Smith Dev",
project=self._project,
users=[self._john_smith],
windows_path=None,
mac_path=None,
linux_path=None,
plugin_ids="basic.*",
descriptor=
"sgtk:descriptor:app_store?name=tk-config-basic&version=v1.2.3",
uploaded_config=None,
),
)
mgr = ToolkitManager(self._mocked_sg_user)
mgr.plugin_id = "basic.test"
configs = mgr.get_pipeline_configurations(self._project)
self.assertEqual(len(configs), 1)
config = configs[0]
self.assertEqual(config["name"], "Doe Dev")
def test_task_completed(self):
"""
Make sure the right signal is emitted with the correct data when
configs are successfully retrieved from Shotgun.
"""
ec = self.external_config_loader
ec.configurations_loaded = _MockedSignal()
software_hash = "123"
result = ec._execute_get_configurations(
self._project["id"],
software_hash,
toolkit_manager=ToolkitManager(self._mocked_sg_user),
)
# If given a bogus task id it doesn't emit.
ec._task_completed("9876", "test", [])
ec.configurations_loaded.emit.assert_not_called()
# If the task id is legit, then we should see an emit.
ec._task_ids["1234"] = "test"
ec._task_completed("1234", "test", result)
ec.configurations_loaded.emit.assert_called_once()
# Make sure it was called with what we expect.
project_id, configs = ec.configurations_loaded.emit.call_args[0]
self.assertEqual(project_id, (self._project["id"]))
self.assertEqual(len(configs), 1)
config = configs[0]
self.assertTrue(
isinstance(config, self.external_config.ExternalConfiguration))
self.assertTrue(config.is_valid)
self.assertEqual(config.plugin_id, self._plugin_id)
self.assertEqual(config.engine_name, self._engine_name)
self.assertTrue(config.is_primary)
self.assertEqual(config.pipeline_configuration_id, self._pc["id"])
self.assertEqual(config.descriptor_uri, self._descriptor)
self.assertEqual(config.pipeline_configuration_name, "Primary")
self.assertEqual(config.interpreter, sys.executable)