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)