def test_product_supported(self):
launcher = create_engine_launcher(self.tk, self.context, self.engine_name)
# all should pass since no product constrain
self.assertEqual(launcher._is_product_supported("asfasdfakj"), True)
self.assertEqual(launcher._is_product_supported("asfa sdfakj"), True)
self.assertEqual(launcher._is_product_supported("asfa sdf akj"), True)
self.assertEqual(launcher._is_product_supported("asfas1 124 1231 dfakj"), True)
self.assertEqual(launcher._is_product_supported("111 1 1asfasdfakj"), True)
products_list = [
"A B C",
"DEF",
"G HI",
]
launcher = create_engine_launcher(self.tk, self.context, self.engine_name, products=products_list)
self.assertEqual(launcher._is_product_supported("A B C"), True)
self.assertEqual(launcher._is_product_supported("A B c"), True)
self.assertEqual(launcher._is_product_supported("ABC"), False)
self.assertEqual(launcher._is_product_supported("DEF"), True)
self.assertEqual(launcher._is_product_supported("def"), True)
self.assertEqual(launcher._is_product_supported("D E F"), False)
self.assertEqual(launcher._is_product_supported("G HI"), True)
self.assertEqual(launcher._is_product_supported("g HI"), True)
self.assertEqual(launcher._is_product_supported(" G HI "), False)
def test_product_supported(self):
launcher = create_engine_launcher(self.tk, self.context,
self.engine_name)
# all should pass since no product constrain
self.assertEqual(launcher._is_product_supported("asfasdfakj"), True)
self.assertEqual(launcher._is_product_supported("asfa sdfakj"), True)
self.assertEqual(launcher._is_product_supported("asfa sdf akj"), True)
self.assertEqual(
launcher._is_product_supported("asfas1 124 1231 dfakj"), True)
self.assertEqual(launcher._is_product_supported("111 1 1asfasdfakj"),
True)
products_list = [
"A B C",
"DEF",
"G HI",
]
launcher = create_engine_launcher(self.tk,
self.context,
self.engine_name,
products=products_list)
self.assertEqual(launcher._is_product_supported("A B C"), True)
self.assertEqual(launcher._is_product_supported("A B c"), True)
self.assertEqual(launcher._is_product_supported("ABC"), False)
self.assertEqual(launcher._is_product_supported("DEF"), True)
self.assertEqual(launcher._is_product_supported("def"), True)
self.assertEqual(launcher._is_product_supported("D E F"), False)
self.assertEqual(launcher._is_product_supported("G HI"), True)
self.assertEqual(launcher._is_product_supported("g HI"), True)
self.assertEqual(launcher._is_product_supported(" G HI "), False)
def test_launcher_scan_software(self):
# test engine launcher hardcoded to return 10 paths
launcher = create_engine_launcher(self.tk, self.context, self.engine_name)
sw_versions = launcher.scan_software()
self.assertEqual(len(sw_versions), 10)
launcher = create_engine_launcher(self.tk, self.context, self.engine_name)
sw_versions = launcher.scan_software()
self.assertIsInstance(sw_versions, list)
for i, swv in enumerate(sw_versions):
self.assertIsInstance(swv, SoftwareVersion)
def test_version_supported(self):
launcher = create_engine_launcher(self.tk, self.context,
self.engine_name)
# all should pass since no version constraint
self.assertEqual(launcher._is_version_supported("2017"), True)
self.assertEqual(launcher._is_version_supported("2018"), True)
self.assertEqual(launcher._is_version_supported("2019"), True)
self.assertEqual(launcher._is_version_supported("2019v0"), True)
self.assertEqual(launcher._is_version_supported("2019v0.1"), True)
self.assertEqual(launcher._is_version_supported("2020.1"), True)
self.assertEqual(launcher._is_version_supported("2020"), True)
self.assertEqual(launcher._is_version_supported("v0.1.2"), True)
self.assertEqual(launcher._is_version_supported("v0.1"), True)
versions_list = ["2018", "2019v0.1", "2020.1", "v0.1.2"]
launcher = create_engine_launcher(self.tk,
self.context,
self.engine_name,
versions=versions_list)
min_version_method = (
"sgtk.platform.software_launcher.SoftwareLauncher.minimum_supported_version"
)
with patch(min_version_method,
new_callable=PropertyMock) as min_version_mock:
min_version_mock.return_value = "2019"
self.assertEqual(launcher._is_version_supported("2017"),
False) # should fail min version
self.assertEqual(launcher._is_version_supported("2018"),
False) # should fail min version
self.assertEqual(launcher._is_version_supported("2019"),
False) # not in version list
self.assertEqual(launcher._is_version_supported("2019v0"),
False) # not in version list
self.assertEqual(launcher._is_version_supported("2019v0.1"),
True) # in version list
self.assertEqual(launcher._is_version_supported("2020.1"),
True) # in version list
self.assertEqual(launcher._is_version_supported("2020"),
False) # not in version list
self.assertEqual(launcher._is_version_supported("v0.1.2"),
False) # fails min version
self.assertEqual(launcher._is_version_supported("v0.1"),
False) # fails min version and not in list
def test_create_launcher(self):
"""
Makes sure a valid SoftwareLauncher instance gets created
by the platform public factory method create_engine_launcher()
"""
# Verify the create method raises TankEngineInitError for
# engines that cannot be found
self.assertRaises(
TankEngineInitError,
create_engine_launcher,
self.tk,
self.context,
"not an engine",
)
# Verify that engines without startup.py files will return None
startup_plugin = os.path.join(self.pipeline_config_root, "config",
"bundles", "test_engine", "startup.py")
startup_copy = startup_plugin.replace("startup.py", "startup_copy.py")
os.rename(startup_plugin, startup_copy)
launcher = create_engine_launcher(self.tk, self.context,
self.engine_name)
self.assertEqual(launcher, None)
# Verify valid input results in a valid SoftwareLauncher
expected_disk_location = os.path.join(self.pipeline_config_root,
"config", "bundles",
"test_engine")
os.rename(startup_copy, startup_plugin)
versions_list = [1, 2, 3, 4]
products_list = ["A", "B", "C"]
launcher = create_engine_launcher(self.tk,
self.context,
self.engine_name,
versions=versions_list,
products=products_list)
self.assertIsInstance(launcher, SoftwareLauncher)
self.assertIsInstance(launcher.logger, logging.Logger)
self.assertEqual(self.engine_name, launcher.engine_name)
self.assertEqual(self.tk, launcher.sgtk)
self.assertEqual(self.context, launcher.context)
self.assertEqual(versions_list, launcher.versions)
self.assertEqual(products_list, launcher.products)
self.assertEqual("%s Startup" % self.engine_name,
launcher.display_name)
self.assertEqual(expected_disk_location, launcher.disk_location)
def test_minimum_version(self):
launcher = create_engine_launcher(self.tk, self.context, self.engine_name)
# if no version has been set, anything goes
self.assertEqual(launcher._is_version_supported("foo"), True)
self.assertEqual(launcher._is_version_supported("v1204"), True)
self.assertEqual(launcher.minimum_supported_version, None)
# mock the property
min_version_method = "sgtk.platform.software_launcher.SoftwareLauncher.minimum_supported_version"
with patch(min_version_method, new_callable=PropertyMock) as min_version_mock:
min_version_mock.return_value = "2017.2"
self.assertEqual(launcher.minimum_supported_version, "2017.2")
self.assertEqual(launcher._is_version_supported("2017"), False)
self.assertEqual(launcher._is_version_supported("2017.2"), True)
self.assertEqual(launcher._is_version_supported("2017.2.sp1"), True)
self.assertEqual(launcher._is_version_supported("2017.2sp1"), True)
self.assertEqual(launcher._is_version_supported("2017.3"), True)
self.assertEqual(launcher._is_version_supported("2018"), True)
self.assertEqual(launcher._is_version_supported("2018.1"), True)
min_version_mock.return_value = "2017.2sp1"
self.assertEqual(launcher.minimum_supported_version, "2017.2sp1")
self.assertEqual(launcher._is_version_supported("2017"), False)
self.assertEqual(launcher._is_version_supported("2017.2"), False)
self.assertEqual(launcher._is_version_supported("2017.2sp1"), True)
self.assertEqual(launcher._is_version_supported("2017.3"), True)
self.assertEqual(launcher._is_version_supported("2018"), True)
self.assertEqual(launcher._is_version_supported("2018.1"), True)
def test_get_standard_plugin_environment(self):
"""
Ensures get_standard_plugin_environment sets all expected environment variables.
"""
MOCKED_FALLBACKS = ["/a/b/c", "/d/e/f"]
for entity in [self.shot, self.project, self.task]:
ctx = self.tk.context_from_entity(entity["type"], entity["id"])
# Monkey patch the pipeline configuration object to provide a set of bundle cache
# fallback paths to serialize into environment variables.
self.tk.pipeline_configuration.get_bundle_cache_fallback_paths = (
lambda: MOCKED_FALLBACKS)
launcher = create_engine_launcher(self.tk, ctx, self.engine_name)
env = launcher.get_standard_plugin_environment()
expected_env = {
"SHOTGUN_PIPELINE_CONFIGURATION_ID":
"123",
"SHOTGUN_SITE":
"http://unit_test_mock_sg",
"SHOTGUN_ENTITY_TYPE":
entity["type"],
"SHOTGUN_ENTITY_ID":
str(entity["id"]),
"SHOTGUN_ENTITY_ID":
str(entity["id"]),
"SHOTGUN_BUNDLE_CACHE_FALLBACK_PATHS":
os.pathsep.join(MOCKED_FALLBACKS),
}
self.assertDictEqual(expected_env, env)
def test_glob_and_match(self):
"""
Ensures we are globbing and matching files regardless of the orientation of the slashes.
"""
pattern_template = os.path.join(self.fixtures_root, "misc", "glob_and_match", "maya{version}")
launcher = create_engine_launcher(self.tk, self.context, self.engine_name)
# regardless of the platform, the path orientation should not be an issue
for template in [pattern_template.replace("/", "\\"), pattern_template.replace("\\", "/")]:
matches = launcher._glob_and_match(template, {"version": "\d+"})
# Sort alphabetically so we can more easily validate the result.
matches = sorted(matches, key=lambda x: x[0])
self.assertEqual(
matches,
[
(
os.path.join(self.fixtures_root, "misc", "glob_and_match", "maya2014"),
{"version": "2014"}
),
(
os.path.join(self.fixtures_root, "misc", "glob_and_match", "maya2015"),
{"version": "2015"}
),
(
os.path.join(self.fixtures_root, "misc", "glob_and_match", "maya2016"),
{"version": "2016"}
),
]
)
def test_glob_and_match(self):
"""
Ensures we are globbing and matching files regardless of the orientation of the slashes.
"""
pattern_template = os.path.join(self.fixtures_root, "misc",
"glob_and_match", "maya{version}")
launcher = create_engine_launcher(self.tk, self.context,
self.engine_name)
# regardless of the platform, the path orientation should not be an issue
for template in [
pattern_template.replace("/", "\\"),
pattern_template.replace("\\", "/")
]:
matches = launcher._glob_and_match(template, {"version": "\d+"})
# Sort alphabetically so we can more easily validate the result.
matches = sorted(matches, key=lambda x: x[0])
self.assertEqual(matches, [
(os.path.join(self.fixtures_root, "misc", "glob_and_match",
"maya2014"), {
"version": "2014"
}),
(os.path.join(self.fixtures_root, "misc", "glob_and_match",
"maya2015"), {
"version": "2015"
}),
(os.path.join(self.fixtures_root, "misc", "glob_and_match",
"maya2016"), {
"version": "2016"
}),
])
def test_create_launcher(self):
"""
Makes sure a valid SoftwareLauncher instance gets created
by the platform public factory method create_engine_launcher()
"""
# Verify the create method raises TankEngineInitError for
# engines that cannot be found
self.assertRaises(
TankEngineInitError,
create_engine_launcher,
self.tk, self.context, "not an engine",
)
# Verify that engines without startup.py files will return None
startup_plugin = os.path.join(
self.pipeline_config_root, "config", "bundles", "test_engine", "startup.py"
)
startup_copy = startup_plugin.replace("startup.py", "startup_copy.py")
os.rename(startup_plugin, startup_copy)
launcher = create_engine_launcher(self.tk, self.context, self.engine_name)
self.assertEqual(launcher, None)
# Verify valid input results in a valid SoftwareLauncher
expected_disk_location = os.path.join(
self.pipeline_config_root, "config", "bundles", "test_engine"
)
os.rename(startup_copy, startup_plugin)
versions_list = [1, 2, 3, 4]
products_list = ["A", "B", "C"]
launcher = create_engine_launcher(
self.tk,
self.context,
self.engine_name,
versions=versions_list,
products=products_list
)
self.assertIsInstance(launcher, SoftwareLauncher)
self.assertIsInstance(launcher.logger, logging.Logger)
self.assertEqual(self.engine_name, launcher.engine_name)
self.assertEqual(self.tk, launcher.sgtk)
self.assertEqual(self.context, launcher.context)
self.assertEqual(versions_list, launcher.versions)
self.assertEqual(products_list, launcher.products)
self.assertEqual("%s Startup" % self.engine_name, launcher.display_name)
self.assertEqual(expected_disk_location, launcher.disk_location)
def test_get_standard_plugin_environment_empty(self):
ctx = self.tk.context_empty()
launcher = create_engine_launcher(self.tk, ctx, self.engine_name)
env = launcher.get_standard_plugin_environment()
self.assertEqual(env["SHOTGUN_PIPELINE_CONFIGURATION_ID"], "123")
self.assertEqual(env["SHOTGUN_SITE"], "http://unit_test_mock_sg")
self.assertTrue("SHOTGUN_ENTITY_TYPE" not in env)
self.assertTrue("SHOTGUN_ENTITY_ID" not in env)
def test_get_standard_plugin_environment(self):
for entity in [self.shot, self.project, self.task]:
ctx = self.tk.context_from_entity(entity["type"], entity["id"])
launcher = create_engine_launcher(self.tk, ctx, self.engine_name)
env = launcher.get_standard_plugin_environment()
self.assertEqual(env["SHOTGUN_PIPELINE_CONFIGURATION_ID"], "123")
self.assertEqual(env["SHOTGUN_SITE"], "http://unit_test_mock_sg")
self.assertEqual(env["SHOTGUN_ENTITY_TYPE"], entity["type"])
self.assertEqual(env["SHOTGUN_ENTITY_ID"], str(entity["id"]))
def test_get_standard_plugin_environment_empty(self):
"""
Ensures only site and pc id are set when we have an empty context.
"""
ctx = self.tk.context_empty()
launcher = create_engine_launcher(self.tk, ctx, self.engine_name)
env = launcher.get_standard_plugin_environment()
expected_env = {
"SHOTGUN_PIPELINE_CONFIGURATION_ID": "123",
"SHOTGUN_SITE": "http://unit_test_mock_sg"
}
self.assertDictEqual(expected_env, env)
def test_version_supported(self):
launcher = create_engine_launcher(self.tk, self.context, self.engine_name)
# all should pass since no version constraint
self.assertEqual(launcher._is_version_supported("2017"), True)
self.assertEqual(launcher._is_version_supported("2018"), True)
self.assertEqual(launcher._is_version_supported("2019"), True)
self.assertEqual(launcher._is_version_supported("2019v0"), True)
self.assertEqual(launcher._is_version_supported("2019v0.1"), True)
self.assertEqual(launcher._is_version_supported("2020.1"), True)
self.assertEqual(launcher._is_version_supported("2020"), True)
self.assertEqual(launcher._is_version_supported("v0.1.2"), True)
self.assertEqual(launcher._is_version_supported("v0.1"), True)
versions_list = [
"2018",
"2019v0.1",
"2020.1",
"v0.1.2"
]
launcher = create_engine_launcher(self.tk, self.context, self.engine_name, versions=versions_list)
min_version_method = "sgtk.platform.software_launcher.SoftwareLauncher.minimum_supported_version"
with patch(min_version_method, new_callable=PropertyMock) as min_version_mock:
min_version_mock.return_value = "2019"
self.assertEqual(launcher._is_version_supported("2017"), False) # should fail min version
self.assertEqual(launcher._is_version_supported("2018"), False) # should fail min version
self.assertEqual(launcher._is_version_supported("2019"), False) # not in version list
self.assertEqual(launcher._is_version_supported("2019v0"), False) # not in version list
self.assertEqual(launcher._is_version_supported("2019v0.1"), True) # in version list
self.assertEqual(launcher._is_version_supported("2020.1"), True) # in version list
self.assertEqual(launcher._is_version_supported("2020"), False) # not in version list
self.assertEqual(launcher._is_version_supported("v0.1.2"), False) # fails min version
self.assertEqual(launcher._is_version_supported("v0.1"), False) # fails min version and not in list
def test_is_supported(self):
# versions returned are range(0, 10)
versions_list = [2, 3, 4]
launcher = create_engine_launcher(self.tk,
self.context,
self.engine_name,
versions=versions_list)
sw_versions = launcher.scan_software()
for sw_version in sw_versions:
(supported, reason) = launcher._is_supported(sw_version)
if sw_version.version in [2, 3, 4]:
self.assertEqual(supported, True)
self.assertEqual(reason, "")
else:
self.assertEqual(supported, False)
self.assertIsInstance(reason, six.string_types)
def test_is_supported(self):
# versions returned are range(0, 10)
versions_list = [2, 3, 4]
launcher = create_engine_launcher(
self.tk,
self.context,
self.engine_name,
versions=versions_list,
)
sw_versions = launcher.scan_software()
for sw_version in sw_versions:
(supported, reason) = launcher._is_supported(sw_version)
if sw_version.version in [2, 3, 4]:
self.assertEqual(supported, True)
self.assertEqual(reason, "")
else:
self.assertEqual(supported, False)
self.assertIsInstance(reason, basestring)
def test_launcher_prepare_launch(self):
prep_path = "/some/path/to/an/executable"
prep_args = "-t 1-20 --show_all -v --select parts"
open_file = "open_this_file.ext"
startup_path = os.path.join(self.pipeline_config_root, "config",
"bundles", "test_engine", "startup")
launcher = create_engine_launcher(self.tk, self.context,
self.engine_name)
launch_info = launcher.prepare_launch(prep_path, prep_args)
self.assertIsInstance(launch_info, LaunchInformation)
self.assertEqual(prep_path, launch_info.path)
self.assertEqual(prep_args, launch_info.args)
self.assertTrue("PYTHONPATH" in launch_info.environment)
self.assertTrue(startup_path in launch_info.environment["PYTHONPATH"])
self.assertFalse("FILE_TO_OPEN" in launch_info.environment)
launch_info = launcher.prepare_launch(prep_path, prep_args, open_file)
self.assertTrue("FILE_TO_OPEN" in launch_info.environment)
self.assertTrue(open_file in launch_info.environment["FILE_TO_OPEN"])
def test_launcher_prepare_launch(self):
prep_path = "/some/path/to/an/executable"
prep_args = "-t 1-20 --show_all -v --select parts"
open_file = "open_this_file.ext"
startup_path = os.path.join(
self.pipeline_config_root, "config", "bundles", "test_engine", "startup"
)
launcher = create_engine_launcher(self.tk, self.context, self.engine_name)
launch_info = launcher.prepare_launch(prep_path, prep_args)
self.assertIsInstance(launch_info, LaunchInformation)
self.assertEqual(prep_path, launch_info.path)
self.assertEqual(prep_args, launch_info.args)
self.assertTrue("PYTHONPATH" in launch_info.environment)
self.assertTrue(startup_path in launch_info.environment["PYTHONPATH"])
self.assertFalse("FILE_TO_OPEN" in launch_info.environment)
launch_info = launcher.prepare_launch(prep_path, prep_args, open_file)
self.assertTrue("FILE_TO_OPEN" in launch_info.environment)
self.assertTrue(open_file in launch_info.environment["FILE_TO_OPEN"])
def test_get_standard_plugin_environment(self):
"""
Ensures get_standard_plugin_environment sets all expected environment variables.
"""
MOCKED_FALLBACKS = ["/a/b/c", "/d/e/f"]
for entity in [self.shot, self.project, self.task]:
ctx = self.tk.context_from_entity(entity["type"], entity["id"])
# Monkey patch the pipeline configuration object to provide a set of bundle cache
# fallback paths to serialize into environment variables.
self.tk.pipeline_configuration.get_bundle_cache_fallback_paths = \
lambda: MOCKED_FALLBACKS
launcher = create_engine_launcher(self.tk, ctx, self.engine_name)
env = launcher.get_standard_plugin_environment()
expected_env = {
"SHOTGUN_PIPELINE_CONFIGURATION_ID": "123",
"SHOTGUN_SITE": "http://unit_test_mock_sg",
"SHOTGUN_ENTITY_TYPE": entity["type"],
"SHOTGUN_ENTITY_ID": str(entity["id"]),
"SHOTGUN_ENTITY_ID": str(entity["id"]),
"SHOTGUN_BUNDLE_CACHE_FALLBACK_PATHS": os.pathsep.join(MOCKED_FALLBACKS)
}
self.assertDictEqual(expected_env, env)
