def setUp(self): # Makes sure every unit test run in its own sandbox. super(TestInterpreterFilesWriter, self).setUp() self._root = os.path.join(self.tank_temp, self.short_test_name) os.makedirs(self._root) self._cw = ConfigurationWriter( ShotgunPath.from_current_os_path(self._root), self.mockgun)
def _create_test_data(self, create_project): """ Creates test data, including - __pipeline_configuration, a shotgun entity dict. - optional __project entity dict, linked from the pipeline configuration - __descriptor, a sgtk.descriptor.Descriptor refering to a config on disk. - __cw, a ConfigurationWriter """ if create_project: self.__project = self.mockgun.create("Project", { "code": "TestWritePipelineConfigFile", "tank_name": "pc_tank_name" }) else: self.__project = None self.__pipeline_configuration = self.mockgun.create( "PipelineConfiguration", { "code": "PC_TestWritePipelineConfigFile", "project": self.__project }) self.__descriptor = sgtk.descriptor.create_descriptor( self.mockgun, sgtk.descriptor.Descriptor.CONFIG, dict(type="dev", path="/a/b/c")) config_root = os.path.join(self.tank_temp, self.id()) self.__cw = ConfigurationWriter( ShotgunPath.from_current_os_path(config_root), self.mockgun) os.makedirs(os.path.join(config_root, "config", "core"))
def _create_configuration_writer(self): """ Creates a configuration writer that will write to a unique folder for this test. """ new_config_root = os.path.join(self.tank_temp, "new_configuration", self.short_test_name) shotgun_yml_root = os.path.join(new_config_root, "config", "core") # Ensures the location for the shotgun.yml exists. os.makedirs(shotgun_yml_root) writer = ConfigurationWriter( ShotgunPath.from_current_os_path(new_config_root), self.mockgun) writer.ensure_project_scaffold() return writer
def _create_configuration_writer(self): """ Creates a configuration writer that will write to a unique folder for this test. """ new_config_root = os.path.join(self.tank_temp, "new_configuration", self.short_test_name) shotgun_yml_root = os.path.join(new_config_root, "config", "core") # Ensures the location for the shotgun.yml exists. os.makedirs(shotgun_yml_root) writer = ConfigurationWriter( ShotgunPath.from_current_os_path(new_config_root), self.mockgun ) writer.ensure_project_scaffold() return writer
def setUp(self): # Makes sure every unit test run in its own sandbox. super(TestInterpreterFilesWriter, self).setUp() self._root = os.path.join(self.tank_temp, self.short_test_name) os.makedirs(self._root) self._cw = ConfigurationWriter( ShotgunPath.from_current_os_path(self._root), self.mockgun )
def _create_test_data(self, create_project): """ Creates test data, including - __site_configuration, a shotgun entity dict. - optional __project entity dict, linked from the pipeline configuration - __descriptor, a sgtk.descriptor.Descriptor refering to a config on disk. - __cw, a ConfigurationWriter """ if create_project: self.__project = self.mockgun.create( "Project", { "code": "TestWritePipelineConfigFile", "tank_name": "pc_tank_name" } ) else: self.__project = None self.__site_configuration = self.mockgun.create( "PipelineConfiguration", { "code": "PC_TestWritePipelineConfigFile", "project": None } ) self.__project_configuration = self.mockgun.create( "PipelineConfiguration", { "code": "PC_TestWritePipelineConfigFile", "project": self.__project } ) self.__descriptor = sgtk.descriptor.create_descriptor( self.mockgun, sgtk.descriptor.Descriptor.CONFIG, dict(type="dev", path="/a/b/c") ) config_root = os.path.join(self.tank_temp, self.short_test_name) self.__cw = ConfigurationWriter( ShotgunPath.from_current_os_path(config_root), self.mockgun ) os.makedirs( os.path.join( config_root, "config", "core" ) )
def test_character_escaping(self): """ Ensure that the ' characte is properly escaped when writing out install_location.yml """ new_config_root = os.path.join(self.tank_temp, self.short_test_name, "O'Connell") writer = ConfigurationWriter( ShotgunPath.from_current_os_path(new_config_root), self.mockgun) install_location_path = os.path.join(new_config_root, "config", "core", "install_location.yml") os.makedirs(os.path.dirname(install_location_path)) writer.write_install_location_file() with open(install_location_path, "rt") as f: paths = yaml.safe_load(f) path = ShotgunPath(paths["Windows"], paths["Linux"], paths["Darwin"]) assert path.current_os == new_config_root
def test_transactions(self): """ Ensures the transaction flags are properly handled for a config. """ new_config_root = os.path.join(self.tank_temp, self.short_test_name) writer = ConfigurationWriter( ShotgunPath.from_current_os_path(new_config_root), self.mockgun ) # Test standard transaction flow. # Non pending -> Pending -> Non pending self.assertEqual(False, writer.is_transaction_pending()) writer.start_transaction() self.assertEqual(True, writer.is_transaction_pending()) writer.end_transaction() self.assertEqual(False, writer.is_transaction_pending()) # Remove the transaction folder writer._delete_state_file(writer._TRANSACTION_START_FILE) writer._delete_state_file(writer._TRANSACTION_END_FILE) # Even if the marker is missing, the API should report no pending transactions since the # transaction folder doesn't even exist, which will happen for configurations written # with a previous version of core. self.assertEqual(False, writer.is_transaction_pending()) # We've deleted both the transaction files and now we're writing the end transaction file. # If we're in that state, we'll assume something is broken and say its pending since the # config was tinkered with. writer.end_transaction() self.assertEqual(True, writer.is_transaction_pending())
class TestWritePipelineConfigFile(ShotgunTestBase): FALLBACK_PATHS = ["/bundle/cache", "/fallback/paths"] def _create_test_data(self, create_project): """ Creates test data, including - __site_configuration, a shotgun entity dict. - optional __project entity dict, linked from the pipeline configuration - __descriptor, a sgtk.descriptor.Descriptor refering to a config on disk. - __cw, a ConfigurationWriter """ if create_project: self.__project = self.mockgun.create( "Project", { "code": "TestWritePipelineConfigFile", "tank_name": "pc_tank_name" } ) else: self.__project = None self.__site_configuration = self.mockgun.create( "PipelineConfiguration", { "code": "PC_TestWritePipelineConfigFile", "project": None } ) self.__project_configuration = self.mockgun.create( "PipelineConfiguration", { "code": "PC_TestWritePipelineConfigFile", "project": self.__project } ) self.__descriptor = sgtk.descriptor.create_descriptor( self.mockgun, sgtk.descriptor.Descriptor.CONFIG, dict(type="dev", path="/a/b/c") ) config_root = os.path.join(self.tank_temp, self.short_test_name) self.__cw = ConfigurationWriter( ShotgunPath.from_current_os_path(config_root), self.mockgun ) os.makedirs( os.path.join( config_root, "config", "core" ) ) def test_write_site_config(self): """ Expects site configurations are written out properly. """ self._create_test_data(create_project=False) path = self.__cw.write_pipeline_config_file( None, None, "basic.plugin", self.FALLBACK_PATHS, self.__descriptor ) with open(path, "r") as fh: config_info = yaml.safe_load(fh) self.assertDictEqual( config_info, { "pc_id": None, "pc_name": "Unmanaged", "project_id": None, "project_name": "Site", "plugin_id": "basic.plugin", "published_file_entity_type": "PublishedFile", "use_bundle_cache": True, "bundle_cache_fallback_roots": self.FALLBACK_PATHS, "use_shotgun_path_cache": True, "source_descriptor": self.__descriptor.get_dict() } ) def test_write_site_sandbox_config(self): """ Expects site configuration sanboxes are written out properly. """ self._create_test_data(create_project=False) path = self.__cw.write_pipeline_config_file( self.__site_configuration["id"], None, "basic.plugin", self.FALLBACK_PATHS, self.__descriptor ) with open(path, "r") as fh: config_info = yaml.safe_load(fh) self.assertDictEqual( config_info, { "pc_id": self.__site_configuration["id"], "pc_name": self.__site_configuration["code"], "project_id": None, "project_name": "unnamed", "plugin_id": "basic.plugin", "published_file_entity_type": "PublishedFile", "use_bundle_cache": True, "bundle_cache_fallback_roots": self.FALLBACK_PATHS, "use_shotgun_path_cache": True, "source_descriptor": self.__descriptor.get_dict() } ) def test_write_site_sandbox_config_using_project(self): """ Expects site configuration sanboxes that are used with a project are written correctly. """ self._create_test_data(create_project=True) path = self.__cw.write_pipeline_config_file( self.__site_configuration["id"], self.__project["id"], "basic.plugin", self.FALLBACK_PATHS, self.__descriptor ) with open(path, "r") as fh: config_info = yaml.safe_load(fh) self.assertDictEqual( config_info, { "pc_id": self.__site_configuration["id"], "pc_name": self.__site_configuration["code"], "project_id": 2, "project_name": "pc_tank_name", "plugin_id": "basic.plugin", "published_file_entity_type": "PublishedFile", "use_bundle_cache": True, "bundle_cache_fallback_roots": self.FALLBACK_PATHS, "use_shotgun_path_cache": True, "source_descriptor": self.__descriptor.get_dict() } ) def test_write_project_config(self): """ Expects project configurations are written out properly. """ self._create_test_data(create_project=True) path = self.__cw.write_pipeline_config_file( None, self.__project["id"], "basic.plugin", self.FALLBACK_PATHS, self.__descriptor ) with open(path, "r") as fh: config_info = yaml.safe_load(fh) self.assertDictEqual( config_info, { "pc_id": None, "pc_name": "Unmanaged", "project_id": self.__project["id"], "project_name": "pc_tank_name", "plugin_id": "basic.plugin", "published_file_entity_type": "PublishedFile", "use_bundle_cache": True, "bundle_cache_fallback_roots": self.FALLBACK_PATHS, "use_shotgun_path_cache": True, "source_descriptor": self.__descriptor.get_dict() } ) def test_write_project_sandbox_config(self): """ Expects project configuration sandboxes are written out properly. """ self._create_test_data(create_project=True) path = self.__cw.write_pipeline_config_file( self.__project_configuration["id"], self.__project["id"], "basic.plugin", self.FALLBACK_PATHS, self.__descriptor ) with open(path, "r") as fh: config_info = yaml.safe_load(fh) self.assertDictEqual( config_info, { "pc_id": self.__project_configuration["id"], "pc_name": self.__project_configuration["code"], "project_id": self.__project["id"], "project_name": self.__project["tank_name"], "plugin_id": "basic.plugin", "published_file_entity_type": "PublishedFile", "use_bundle_cache": True, "bundle_cache_fallback_roots": self.FALLBACK_PATHS, "use_shotgun_path_cache": True, "source_descriptor": self.__descriptor.get_dict() } )
class TestInterpreterFilesWriter(TestConfigurationWriterBase): """ Ensures interpreter files are written out correctly. """ def setUp(self): # Makes sure every unit test run in its own sandbox. super(TestInterpreterFilesWriter, self).setUp() self._root = os.path.join(self.tank_temp, self.short_test_name) os.makedirs(self._root) self._cw = ConfigurationWriter( ShotgunPath.from_current_os_path(self._root), self.mockgun ) def _get_default_intepreters(self): """ Gets the default interpreter values for the Shotgun Desktop. """ return ShotgunPath( r"C:\Program Files\Shotgun\Python\python.exe", "/opt/Shotgun/Python/bin/python", "/Applications/Shotgun.app/Contents/Resources/Python/bin/python" ) def test_existing_files_not_overwritten(self): """ Ensures that if there were already interpreter files present in the config that they won't be overwritten. """ descriptor = self._write_mock_config() interpreter_yml_path = ShotgunPath.get_file_name_from_template( os.path.join(descriptor.get_path(), "core", "interpreter_%s.cfg") ) # Do not write sys.executable in this file, otherwise we won't know if we're reading our value # or the default value. This means however that we'll have to present the file exists when # os.path.exists is called. os.makedirs(os.path.dirname(interpreter_yml_path)) path = os.path.join("a", "b", "c") with open(interpreter_yml_path, "w") as fh: fh.write(path) # We're going to pretend the interpreter location exists with patch("os.path.exists", return_value=True): # Check that our descriptors sees the value we just wrote to disk self.assertEqual( descriptor.python_interpreter, path ) # Copy the descriptor to its location. descriptor.copy(os.path.join(self._cw.path.current_os, "config")) # have the interpreter files be written out by the writer. The interpreter file we just # wrote should have been left alone. self.assertEqual( self._write_interpreter_file().current_os, path ) def test_desktop_interpreter(self): """ Checks that if we're running in the Shotgun Desktop we're writing the correct interpreter. """ expected_interpreters = self._get_default_intepreters() if sys.platform == "win32": sys_prefix = r"C:\Program Files\Shotgun.v1.4.3\Python" sys_executable = r"C:\Program Files\Shotgun_v1.4.3\Shotgun.exe" python_exe = os.path.join(sys_prefix, "python.exe") elif sys.platform == "darwin": sys_prefix = "/Applications/Shotgun.v1.4.3.app/Contents/Resources/Python" sys_executable = "/Applications/Shotgun.v1.4.3.app/Contents/MacOS/Shotgun" python_exe = os.path.join(sys_prefix, "bin", "python") else: sys_prefix = "/opt/Shotgun.v.1.4.3/Python" sys_executable = "/opt/Shotgun.v.1.4.3/Shotgun" python_exe = os.path.join(sys_prefix, "bin", "python") expected_interpreters.current_os = python_exe interpreters = self._write_interpreter_file(sys_executable, sys_prefix) self.assertEqual(interpreters, expected_interpreters) def test_python_interpreter(self): """ Checks that if we're running inside a real interpreter we reuse it. """ expected_interpreters = self._get_default_intepreters() expected_interpreters.current_os = sys.executable interpreters = self._write_interpreter_file(sys.executable, sys.prefix) self.assertEqual(interpreters, expected_interpreters) def test_unknown_interpreter(self): """ Checks that we default to the default desktop locations when we can't guess the interpreter location. """ interpreters = self._write_interpreter_file(r"C:\Program Files\Autodesk\Maya2017\bin\maya.exe", r"C:\whatever") self.assertEqual(interpreters, self._get_default_intepreters()) def _write_interpreter_file(self, executable=sys.executable, prefix=sys.prefix): """ Writes the interpreter file to disk based on an executable and prefix. :returns: Path that was written in each interpreter file. :rtype: sgtk.util.ShotgunPath """ core_folder = os.path.join(self._root, "config", "core") if not os.path.exists(core_folder): os.makedirs(core_folder) os.makedirs(os.path.join(self._root, "install", "core", "setup", "root_binaries")) self._cw.create_tank_command(executable, prefix) interpreters = [] for platform in ["Windows", "Linux", "Darwin"]: file_name = os.path.join(self._root, "config", "core", "interpreter_%s.cfg" % platform) with open(file_name, "r") as w: interpreters.append(w.read()) return ShotgunPath(*interpreters)
def test_transactions(self): """ Ensures the transaction flags are properly handled for a config. """ new_config_root = os.path.join(self.tank_temp, self.short_test_name) writer = ConfigurationWriter( ShotgunPath.from_current_os_path(new_config_root), self.mockgun) # Test standard transaction flow. # Non pending -> Pending -> Non pending self.assertEqual(False, writer.is_transaction_pending()) writer.start_transaction() self.assertEqual(True, writer.is_transaction_pending()) writer.end_transaction() self.assertEqual(False, writer.is_transaction_pending()) # Remove the transaction folder writer._delete_state_file(writer._TRANSACTION_START_FILE) writer._delete_state_file(writer._TRANSACTION_END_FILE) # Even if the marker is missing, the API should report no pending transactions since the # transaction folder doesn't even exist, which will happen for configurations written # with a previous version of core. self.assertEqual(False, writer.is_transaction_pending()) # We've deleted both the transaction files and now we're writing the end transaction file. # If we're in that state, we'll assume something is broken and say its pending since the # config was tinkered with. writer.end_transaction() self.assertEqual(True, writer.is_transaction_pending())
class TestWritePipelineConfigFile(ShotgunTestBase): FALLBACK_PATHS = ["/bundle/cache", "/fallback/paths"] def _create_test_data(self, create_project): """ Creates test data, including - __site_configuration, a shotgun entity dict. - optional __project entity dict, linked from the pipeline configuration - __descriptor, a sgtk.descriptor.Descriptor refering to a config on disk. - __cw, a ConfigurationWriter """ if create_project: self.__project = self.mockgun.create("Project", { "code": "TestWritePipelineConfigFile", "tank_name": "pc_tank_name" }) else: self.__project = None self.__site_configuration = self.mockgun.create( "PipelineConfiguration", { "code": "PC_TestWritePipelineConfigFile", "project": None }) self.__project_configuration = self.mockgun.create( "PipelineConfiguration", { "code": "PC_TestWritePipelineConfigFile", "project": self.__project }) self.__descriptor = sgtk.descriptor.create_descriptor( self.mockgun, sgtk.descriptor.Descriptor.CONFIG, dict(type="dev", path="/a/b/c")) config_root = os.path.join(self.tank_temp, self.short_test_name) self.__cw = ConfigurationWriter( ShotgunPath.from_current_os_path(config_root), self.mockgun) os.makedirs(os.path.join(config_root, "config", "core")) def test_write_site_config(self): """ Expects site configurations are written out properly. """ self._create_test_data(create_project=False) path = self.__cw.write_pipeline_config_file(None, None, "basic.plugin", self.FALLBACK_PATHS, self.__descriptor) with open(path, "r") as fh: config_info = yaml.safe_load(fh) self.assertDictEqual( config_info, { "pc_id": None, "pc_name": "Unmanaged", "project_id": None, "project_name": "Site", "plugin_id": "basic.plugin", "published_file_entity_type": "PublishedFile", "use_bundle_cache": True, "bundle_cache_fallback_roots": self.FALLBACK_PATHS, "use_shotgun_path_cache": True, "source_descriptor": self.__descriptor.get_dict() }) def test_write_site_sandbox_config(self): """ Expects site configuration sanboxes are written out properly. """ self._create_test_data(create_project=False) path = self.__cw.write_pipeline_config_file( self.__site_configuration["id"], None, "basic.plugin", self.FALLBACK_PATHS, self.__descriptor) with open(path, "r") as fh: config_info = yaml.safe_load(fh) self.assertDictEqual( config_info, { "pc_id": self.__site_configuration["id"], "pc_name": self.__site_configuration["code"], "project_id": None, "project_name": "unnamed", "plugin_id": "basic.plugin", "published_file_entity_type": "PublishedFile", "use_bundle_cache": True, "bundle_cache_fallback_roots": self.FALLBACK_PATHS, "use_shotgun_path_cache": True, "source_descriptor": self.__descriptor.get_dict() }) def test_write_site_sandbox_config_using_project(self): """ Expects site configuration sanboxes that are used with a project are written correctly. """ self._create_test_data(create_project=True) path = self.__cw.write_pipeline_config_file( self.__site_configuration["id"], self.__project["id"], "basic.plugin", self.FALLBACK_PATHS, self.__descriptor) with open(path, "r") as fh: config_info = yaml.safe_load(fh) self.assertDictEqual( config_info, { "pc_id": self.__site_configuration["id"], "pc_name": self.__site_configuration["code"], "project_id": 2, "project_name": "pc_tank_name", "plugin_id": "basic.plugin", "published_file_entity_type": "PublishedFile", "use_bundle_cache": True, "bundle_cache_fallback_roots": self.FALLBACK_PATHS, "use_shotgun_path_cache": True, "source_descriptor": self.__descriptor.get_dict() }) def test_write_project_config(self): """ Expects project configurations are written out properly. """ self._create_test_data(create_project=True) path = self.__cw.write_pipeline_config_file(None, self.__project["id"], "basic.plugin", self.FALLBACK_PATHS, self.__descriptor) with open(path, "r") as fh: config_info = yaml.safe_load(fh) self.assertDictEqual( config_info, { "pc_id": None, "pc_name": "Unmanaged", "project_id": self.__project["id"], "project_name": "pc_tank_name", "plugin_id": "basic.plugin", "published_file_entity_type": "PublishedFile", "use_bundle_cache": True, "bundle_cache_fallback_roots": self.FALLBACK_PATHS, "use_shotgun_path_cache": True, "source_descriptor": self.__descriptor.get_dict() }) def test_write_project_sandbox_config(self): """ Expects project configuration sandboxes are written out properly. """ self._create_test_data(create_project=True) path = self.__cw.write_pipeline_config_file( self.__project_configuration["id"], self.__project["id"], "basic.plugin", self.FALLBACK_PATHS, self.__descriptor) with open(path, "r") as fh: config_info = yaml.safe_load(fh) self.assertDictEqual( config_info, { "pc_id": self.__project_configuration["id"], "pc_name": self.__project_configuration["code"], "project_id": self.__project["id"], "project_name": self.__project["tank_name"], "plugin_id": "basic.plugin", "published_file_entity_type": "PublishedFile", "use_bundle_cache": True, "bundle_cache_fallback_roots": self.FALLBACK_PATHS, "use_shotgun_path_cache": True, "source_descriptor": self.__descriptor.get_dict() })
class TestInterpreterFilesWriter(TestConfigurationWriterBase): """ Ensures interpreter files are written out correctly. """ def setUp(self): # Makes sure every unit test run in its own sandbox. super(TestInterpreterFilesWriter, self).setUp() self._root = os.path.join(self.tank_temp, self.short_test_name) os.makedirs(self._root) self._cw = ConfigurationWriter( ShotgunPath.from_current_os_path(self._root), self.mockgun) def _get_default_intepreters(self): """ Gets the default interpreter values for the Shotgun Desktop. """ return ShotgunPath( r"C:\Program Files\Shotgun\Python\python.exe", "/opt/Shotgun/Python/bin/python", "/Applications/Shotgun.app/Contents/Resources/Python/bin/python") def test_existing_files_not_overwritten(self): """ Ensures that if there were already interpreter files present in the config that they won't be overwritten. """ descriptor = self._write_mock_config() interpreter_yml_path = ShotgunPath.get_file_name_from_template( os.path.join(descriptor.get_path(), "core", "interpreter_%s.cfg")) # Do not write sys.executable in this file, otherwise we won't know if we're reading our value # or the default value. This means however that we'll have to present the file exists when # os.path.exists is called. os.makedirs(os.path.dirname(interpreter_yml_path)) path = os.path.join("a", "b", "c") with open(interpreter_yml_path, "w") as fh: fh.write(path) # We're going to pretend the interpreter location exists with patch("os.path.exists", return_value=True): # Check that our descriptors sees the value we just wrote to disk self.assertEqual(descriptor.python_interpreter, path) # Copy the descriptor to its location. descriptor.copy(os.path.join(self._cw.path.current_os, "config")) # have the interpreter files be written out by the writer. The interpreter file we just # wrote should have been left alone. self.assertEqual(self._write_interpreter_file().current_os, path) def test_desktop_interpreter(self): """ Checks that if we're running in the Shotgun Desktop we're writing the correct interpreter. """ expected_interpreters = self._get_default_intepreters() if sys.platform == "win32": sys_prefix = r"C:\Program Files\Shotgun.v1.4.3\Python" sys_executable = r"C:\Program Files\Shotgun_v1.4.3\Shotgun.exe" python_exe = os.path.join(sys_prefix, "python.exe") elif sys.platform == "darwin": sys_prefix = "/Applications/Shotgun.v1.4.3.app/Contents/Resources/Python" sys_executable = "/Applications/Shotgun.v1.4.3.app/Contents/MacOS/Shotgun" python_exe = os.path.join(sys_prefix, "bin", "python") else: sys_prefix = "/opt/Shotgun.v.1.4.3/Python" sys_executable = "/opt/Shotgun.v.1.4.3/Shotgun" python_exe = os.path.join(sys_prefix, "bin", "python") expected_interpreters.current_os = python_exe interpreters = self._write_interpreter_file(sys_executable, sys_prefix) self.assertEqual(interpreters, expected_interpreters) def test_python_interpreter(self): """ Checks that if we're running inside a real interpreter we reuse it. """ expected_interpreters = self._get_default_intepreters() expected_interpreters.current_os = sys.executable interpreters = self._write_interpreter_file(sys.executable, sys.prefix) self.assertEqual(interpreters, expected_interpreters) def test_unknown_interpreter(self): """ Checks that we default to the default desktop locations when we can't guess the interpreter location. """ interpreters = self._write_interpreter_file( r"C:\Program Files\Autodesk\Maya2017\bin\maya.exe", r"C:\whatever") self.assertEqual(interpreters, self._get_default_intepreters()) def _write_interpreter_file(self, executable=sys.executable, prefix=sys.prefix): """ Writes the interpreter file to disk based on an executable and prefix. :returns: Path that was written in each interpreter file. :rtype: sgtk.util.ShotgunPath """ core_folder = os.path.join(self._root, "config", "core") if not os.path.exists(core_folder): os.makedirs(core_folder) os.makedirs( os.path.join(self._root, "install", "core", "setup", "root_binaries")) self._cw.create_tank_command(executable, prefix) interpreters = [] for platform in ["Windows", "Linux", "Darwin"]: file_name = os.path.join(self._root, "config", "core", "interpreter_%s.cfg" % platform) with open(file_name, "r") as w: interpreters.append(w.read()) return ShotgunPath(*interpreters)
class TestWritePipelineConfigFile(ShotgunTestBase): FALLBACK_PATHS = ["/bundle/cache", "/fallback/paths"] def _create_test_data(self, create_project): """ Creates test data, including - __pipeline_configuration, a shotgun entity dict. - optional __project entity dict, linked from the pipeline configuration - __descriptor, a sgtk.descriptor.Descriptor refering to a config on disk. - __cw, a ConfigurationWriter """ if create_project: self.__project = self.mockgun.create("Project", { "code": "TestWritePipelineConfigFile", "tank_name": "pc_tank_name" }) else: self.__project = None self.__pipeline_configuration = self.mockgun.create( "PipelineConfiguration", { "code": "PC_TestWritePipelineConfigFile", "project": self.__project }) self.__descriptor = sgtk.descriptor.create_descriptor( self.mockgun, sgtk.descriptor.Descriptor.CONFIG, dict(type="dev", path="/a/b/c")) config_root = os.path.join(self.tank_temp, self.id()) self.__cw = ConfigurationWriter( ShotgunPath.from_current_os_path(config_root), self.mockgun) os.makedirs(os.path.join(config_root, "config", "core")) def test_write_site_config(self): """ Expects site configurations are written out properly. """ self._create_test_data(create_project=False) path = self.__cw.write_pipeline_config_file(None, None, "basic.plugin", self.FALLBACK_PATHS, self.__descriptor) with open(path, "r") as fh: config_info = yaml.safe_load(fh) self.assertDictEqual( config_info, { "pc_id": None, "pc_name": "Unmanaged", "project_id": None, "project_name": "Site", "plugin_id": "basic.plugin", "published_file_entity_type": "PublishedFile", "use_bundle_cache": True, "bundle_cache_fallback_roots": self.FALLBACK_PATHS, "use_shotgun_path_cache": True, "source_descriptor": self.__descriptor.get_dict() }) def test_write_site_sandbox_config(self): """ Expects site configuration sanboxes are written out properly. """ self._create_test_data(create_project=False) with self._fixme_find_one(): path = self.__cw.write_pipeline_config_file( self.__pipeline_configuration["id"], None, "basic.plugin", self.FALLBACK_PATHS, self.__descriptor) with open(path, "r") as fh: config_info = yaml.safe_load(fh) self.assertDictEqual( config_info, { "pc_id": self.__pipeline_configuration["id"], "pc_name": self.__pipeline_configuration["code"], "project_id": None, "project_name": "unnamed", "plugin_id": "basic.plugin", "published_file_entity_type": "PublishedFile", "use_bundle_cache": True, "bundle_cache_fallback_roots": self.FALLBACK_PATHS, "use_shotgun_path_cache": True, "source_descriptor": self.__descriptor.get_dict() }) def test_write_project_config(self): """ Expects project configurations are written out properly. """ self._create_test_data(create_project=True) path = self.__cw.write_pipeline_config_file(None, self.__project["id"], "basic.plugin", self.FALLBACK_PATHS, self.__descriptor) with open(path, "r") as fh: config_info = yaml.safe_load(fh) self.assertDictEqual( config_info, { "pc_id": None, "pc_name": "Unmanaged", "project_id": self.__project["id"], "project_name": "pc_tank_name", "plugin_id": "basic.plugin", "published_file_entity_type": "PublishedFile", "use_bundle_cache": True, "bundle_cache_fallback_roots": self.FALLBACK_PATHS, "use_shotgun_path_cache": True, "source_descriptor": self.__descriptor.get_dict() }) @contextlib.contextmanager def _fixme_find_one(self): """ Workaround for a bug in Mockgun. """ # FIXME: There's a bug in Mockgun when a linked field is set to None. A client fixed this # bug, we're only waiting for the PR to be merged. with patch( "tank_vendor.shotgun_api3.lib.mockgun.mockgun.Shotgun.find_one" ) as p: def mocked_find_one(entity_type, filters, *args): # Make sure we're being queried for the pipeline configuration we are expecting. self.assertEqual(entity_type, "PipelineConfiguration") self.assertEqual( filters, [["id", "is", self.__pipeline_configuration["id"]]]) # Make sure we are mocking the call for the project which is None. self.assertIsNone(self.__pipeline_configuration["project"]) result = {"project.Project.tank_name": None} result.update(self.__pipeline_configuration) return result p.side_effect = mocked_find_one yield def test_write_project_sandbox_config(self): """ Expects project configuration sandboxes are written out properly. """ self._create_test_data(create_project=True) path = self.__cw.write_pipeline_config_file( self.__pipeline_configuration["id"], self.__project["id"], "basic.plugin", self.FALLBACK_PATHS, self.__descriptor) with open(path, "r") as fh: config_info = yaml.safe_load(fh) self.assertDictEqual( config_info, { "pc_id": self.__pipeline_configuration["id"], "pc_name": self.__pipeline_configuration["code"], "project_id": self.__project["id"], "project_name": self.__project["tank_name"], "plugin_id": "basic.plugin", "published_file_entity_type": "PublishedFile", "use_bundle_cache": True, "bundle_cache_fallback_roots": self.FALLBACK_PATHS, "use_shotgun_path_cache": True, "source_descriptor": self.__descriptor.get_dict() })
class TestWritePipelineConfigFile(TankTestBase): FALLBACK_PATHS = ["/bundle/cache", "/fallback/paths"] def _create_test_data(self, create_project): """ Creates test data, including - __pipeline_configuration, a shotgun entity dict. - optional __project entity dict, linked from the pipeline configuration - __descriptor, a sgtk.descriptor.Descriptor refering to a config on disk. - __cw, a ConfigurationWriter """ if create_project: self.__project = self.mockgun.create( "Project", { "code": "TestWritePipelineConfigFile", "tank_name": "pc_tank_name" } ) else: self.__project = None self.__pipeline_configuration = self.mockgun.create( "PipelineConfiguration", { "code": "PC_TestWritePipelineConfigFile", "project": self.__project } ) self.__descriptor = sgtk.descriptor.create_descriptor( self.mockgun, sgtk.descriptor.Descriptor.CONFIG, dict(type="dev", path="/a/b/c") ) config_root = os.path.join(self.tank_temp, self.id()) self.__cw = ConfigurationWriter( ShotgunPath.from_current_os_path(config_root), self.mockgun ) os.makedirs( os.path.join( config_root, "config", "core" ) ) def test_write_site_config(self): """ Expects site configurations are written out properly. """ self._create_test_data(create_project=False) path = self.__cw.write_pipeline_config_file( None, None, "basic.plugin", self.FALLBACK_PATHS, self.__descriptor ) with open(path, "r") as fh: config_info = yaml.safe_load(fh) self.assertDictEqual( config_info, { "pc_id": None, "pc_name": "Unmanaged", "project_id": None, "project_name": "Site", "plugin_id": "basic.plugin", "published_file_entity_type": "PublishedFile", "use_bundle_cache": True, "bundle_cache_fallback_roots": self.FALLBACK_PATHS, "use_shotgun_path_cache": True, "source_descriptor": self.__descriptor.get_dict() } ) def test_write_site_sandbox_config(self): """ Expects site configuration sanboxes are written out properly. """ self._create_test_data(create_project=False) with self._fixme_find_one(): path = self.__cw.write_pipeline_config_file( self.__pipeline_configuration["id"], None, "basic.plugin", self.FALLBACK_PATHS, self.__descriptor ) with open(path, "r") as fh: config_info = yaml.safe_load(fh) self.assertDictEqual( config_info, { "pc_id": self.__pipeline_configuration["id"], "pc_name": self.__pipeline_configuration["code"], "project_id": None, "project_name": "unnamed", "plugin_id": "basic.plugin", "published_file_entity_type": "PublishedFile", "use_bundle_cache": True, "bundle_cache_fallback_roots": self.FALLBACK_PATHS, "use_shotgun_path_cache": True, "source_descriptor": self.__descriptor.get_dict() } ) def test_write_project_config(self): """ Expects project configurations are written out properly. """ self._create_test_data(create_project=True) path = self.__cw.write_pipeline_config_file( None, self.__project["id"], "basic.plugin", self.FALLBACK_PATHS, self.__descriptor ) with open(path, "r") as fh: config_info = yaml.safe_load(fh) self.assertDictEqual( config_info, { "pc_id": None, "pc_name": "Unmanaged", "project_id": self.__project["id"], "project_name": "pc_tank_name", "plugin_id": "basic.plugin", "published_file_entity_type": "PublishedFile", "use_bundle_cache": True, "bundle_cache_fallback_roots": self.FALLBACK_PATHS, "use_shotgun_path_cache": True, "source_descriptor": self.__descriptor.get_dict() } ) @contextlib.contextmanager def _fixme_find_one(self): """ Workaround for a bug in Mockgun. """ # FIXME: There's a bug in Mockgun when a linked field is set to None. A client fixed this # bug, we're only waiting for the PR to be merged. with patch("tank_vendor.shotgun_api3.lib.mockgun.mockgun.Shotgun.find_one") as p: def mocked_find_one(entity_type, filters, *args): # Make sure we're being queried for the pipeline configuration we are expecting. self.assertEqual(entity_type, "PipelineConfiguration") self.assertEqual( filters, [["id", "is", self.__pipeline_configuration["id"]]] ) # Make sure we are mocking the call for the project which is None. self.assertIsNone(self.__pipeline_configuration["project"]) result = { "project.Project.tank_name": None } result.update(self.__pipeline_configuration) return result p.side_effect = mocked_find_one yield def test_write_project_sandbox_config(self): """ Expects project configuration sandboxes are written out properly. """ self._create_test_data(create_project=True) path = self.__cw.write_pipeline_config_file( self.__pipeline_configuration["id"], self.__project["id"], "basic.plugin", self.FALLBACK_PATHS, self.__descriptor ) with open(path, "r") as fh: config_info = yaml.safe_load(fh) self.assertDictEqual( config_info, { "pc_id": self.__pipeline_configuration["id"], "pc_name": self.__pipeline_configuration["code"], "project_id": self.__project["id"], "project_name": self.__project["tank_name"], "plugin_id": "basic.plugin", "published_file_entity_type": "PublishedFile", "use_bundle_cache": True, "bundle_cache_fallback_roots": self.FALLBACK_PATHS, "use_shotgun_path_cache": True, "source_descriptor": self.__descriptor.get_dict() } )