def setUp(self): super(TestSSOClaims, self).setUp() config_folder = sgtk.util.ShotgunPath.from_current_os_path( os.path.join(self.tank_temp, str(uuid.uuid4()))) self._configuration = CachedConfiguration( config_folder, self.mockgun, sgtk.descriptor.create_descriptor( self.mockgun, sgtk.descriptor.Descriptor.CONFIG, "sgtk:descriptor:path?path={0}".format(self.fixtures_root)), self.project["id"], "basic.dcc", None, []) self._mock_return_value( "tank.pipelineconfig_utils.get_core_python_path_for_config", return_value=os.path.join(REPO_ROOT, "python")) # Do not waste time copying files around or core swapping. Also, deactivate # thread startup and shutdown, we only want to ensure they are invoked. for mocked_method in [ "tank.bootstrap.import_handler.CoreImportHandler.swap_core", "tank.bootstrap.configuration_writer.ConfigurationWriter.install_core", "tank.bootstrap.configuration_writer.ConfigurationWriter.create_tank_command", ]: self._mock_return_value(mocked_method, return_value=None) self._start_claims_mock = self._mock_return_value( "tank.authentication.user.ShotgunSamlUser.start_claims_renewal", return_value=None) self._stop_claims_mock = self._mock_return_value( "tank.authentication.user.ShotgunSamlUser.stop_claims_renewal", return_value=None)
def setUp(self): super(TestCachedConfiguration, self).setUp() # Reset the tank_name and create a storage named after the one in the config. self.mockgun.update("Project", self.project["id"], {"tank_name": None}) self.mockgun.create("LocalStorage", {"code": "primary"}) # Initialize a cached configuration pointing to the config. config_root = os.path.join(self.fixtures_root, "bootstrap_tests", "config") self._temp_config_root = os.path.join(self.tank_temp, self.short_test_name) self._cached_config = CachedConfiguration( sgtk.util.ShotgunPath.from_current_os_path(self._temp_config_root), self.mockgun, sgtk.descriptor.create_descriptor( self.mockgun, sgtk.descriptor.Descriptor.CONFIG, "sgtk:descriptor:path?path={0}".format(config_root) ), self.project["id"], "basic.*", None, [] ) # Due to this being a test that runs offline, we can't use anything other than a # path descriptor, which means that it is mutable. Because LOCAL_CFG_DIFFERENT # is actually returned by three different code paths, the only way to ensure that # we are indeed in the up to date state, which means everything is ready to do, is # to cheat and make the descriptor immutable by monkey-patching it. self._cached_config._descriptor.is_immutable = lambda: True # Seems up the test tremendously since installing core becomes a noop. self._cached_config._config_writer.install_core = lambda _: None self._cached_config._config_writer.create_tank_command = lambda: None
def test_verifies_tank_name(self): """ Ensures that missing tank name on project is detected when using roots. """ # Reset the tank_name and create a storage named after the one in the config. self.mockgun.update("Project", self.project["id"], {"tank_name": None}) self.mockgun.create("LocalStorage", {"code": "primary"}) # Initialize a cached configuration pointing to the config. config_root = os.path.join(self.fixtures_root, "bootstrap_tests", "config") cached_config = CachedConfiguration( self.tank_temp, self.mockgun, sgtk.descriptor.create_descriptor( self.mockgun, sgtk.descriptor.Descriptor.CONFIG, "sgtk:descriptor:path?path={0}".format(config_root) ), self.project["id"], "basic.*", None, [] ) # Make sure that the missing tank name is detected. with self.assertRaises(sgtk.bootstrap.TankMissingTankNameError): cached_config.verify_required_shotgun_fields() # Ensure our change is backwards compatible. with self.assertRaises(sgtk.bootstrap.TankBootstrapError): cached_config.verify_required_shotgun_fields()
def setUp(self): super(TestSSOClaims, self).setUp() config_folder = sgtk.util.ShotgunPath.from_current_os_path( os.path.join(self.tank_temp, str(uuid.uuid4())) ) self._configuration = CachedConfiguration( config_folder, self.mockgun, sgtk.descriptor.create_descriptor( self.mockgun, sgtk.descriptor.Descriptor.CONFIG, "sgtk:descriptor:path?path={0}".format(self.fixtures_root) ), self.project["id"], "basic.dcc", None, [] ) self._mock_return_value( "tank.pipelineconfig_utils.get_core_python_path_for_config", return_value=os.path.join(REPO_ROOT, "python") ) # Do not waste time copying files around or core swapping. Also, deactivate # thread startup and shutdown, we only want to ensure they are invoked. for mocked_method in [ "tank.bootstrap.import_handler.CoreImportHandler.swap_core", "tank.bootstrap.cached_configuration.CachedConfiguration._ensure_core_local", "tank.bootstrap.configuration_writer.ConfigurationWriter.install_core", "tank.bootstrap.configuration_writer.ConfigurationWriter.create_tank_command", ]: self._mock_return_value(mocked_method, return_value=None) self._start_claims_mock = self._mock_return_value( "tank.authentication.user.ShotgunSamlUser.start_claims_renewal", return_value=None ) self._stop_claims_mock = self._mock_return_value( "tank.authentication.user.ShotgunSamlUser.stop_claims_renewal", return_value=None )
class TestSSOClaims(TestConfigurationBase): def setUp(self): super(TestSSOClaims, self).setUp() config_folder = sgtk.util.ShotgunPath.from_current_os_path( os.path.join(self.tank_temp, str(uuid.uuid4())) ) self._configuration = CachedConfiguration( config_folder, self.mockgun, sgtk.descriptor.create_descriptor( self.mockgun, sgtk.descriptor.Descriptor.CONFIG, "sgtk:descriptor:path?path={0}".format(self.fixtures_root) ), self.project["id"], "basic.dcc", None, [] ) self._mock_return_value( "tank.pipelineconfig_utils.get_core_python_path_for_config", return_value=os.path.join(REPO_ROOT, "python") ) # Do not waste time copying files around or core swapping. Also, deactivate # thread startup and shutdown, we only want to ensure they are invoked. for mocked_method in [ "tank.bootstrap.import_handler.CoreImportHandler.swap_core", "tank.bootstrap.configuration_writer.ConfigurationWriter.install_core", "tank.bootstrap.configuration_writer.ConfigurationWriter.create_tank_command", ]: self._mock_return_value(mocked_method, return_value=None) self._start_claims_mock = self._mock_return_value( "tank.authentication.user.ShotgunSamlUser.start_claims_renewal", return_value=None ) self._stop_claims_mock = self._mock_return_value( "tank.authentication.user.ShotgunSamlUser.stop_claims_renewal", return_value=None ) def test_claims_renewal_inactive(self): """ Checks that is the claims renewal loop is not running it will not be restarted after core swap. """ bootstrap_user = self._create_sso_user("bootstrap_user") project_user = self._create_sso_user("bootstrap_user") self._configuration.update_configuration() # Create a default user. with patch( "tank.authentication.ShotgunAuthenticator.get_default_user", return_value=project_user ): _, swapped_user = self._configuration.get_tk_instance(bootstrap_user) self.assertIsInstance(swapped_user, ShotgunSamlUser) self.assertEqual(self._start_claims_mock.called, False) self.assertEqual(self._stop_claims_mock.called, False) def test_claims_renewal_active(self): """ Checks that claims renewal is stopped and restarted. """ bootstrap_user = self._create_sso_user("bootstrap_user") project_user = self._create_sso_user("bootstrap_user") self._configuration.update_configuration() bootstrap_user.is_claims_renewal_active = lambda: True # Create a default user. with patch( "tank.authentication.ShotgunAuthenticator.get_default_user", return_value=project_user ): self.assertEqual(self._start_claims_mock.called, False) self.assertEqual(self._stop_claims_mock.called, False) _, swapped_user = self._configuration.get_tk_instance(bootstrap_user) self.assertIsInstance(swapped_user, ShotgunSamlUser) self.assertEqual(self._start_claims_mock.called, True) self.assertEqual(self._stop_claims_mock.called, True) def test_claims_to_script(self): """ Checks that claims renewal is stopped and restarted. """ bootstrap_user = self._create_sso_user("bootstrap_user") script_user = self._create_script_user("script_user") self._configuration.update_configuration() bootstrap_user.is_claims_renewal_active = lambda: True # Create a default user. with patch( "tank.authentication.ShotgunAuthenticator.get_default_user", return_value=script_user ): self.assertEqual(self._start_claims_mock.called, False) self.assertEqual(self._stop_claims_mock.called, False) _, swapped_user = self._configuration.get_tk_instance(bootstrap_user) self.assertEqual(self._stop_claims_mock.called, True) self.assertEqual(self._start_claims_mock.called, False) self.assertIsNone(swapped_user.login)
class TestCachedConfiguration(ShotgunTestBase): def setUp(self): super(TestCachedConfiguration, self).setUp() # Reset the tank_name and create a storage named after the one in the config. self.mockgun.update("Project", self.project["id"], {"tank_name": None}) self.mockgun.create("LocalStorage", {"code": "primary"}) # Initialize a cached configuration pointing to the config. config_root = os.path.join(self.fixtures_root, "bootstrap_tests", "config") self._temp_config_root = os.path.join(self.tank_temp, self.short_test_name) self._cached_config = CachedConfiguration( sgtk.util.ShotgunPath.from_current_os_path(self._temp_config_root), self.mockgun, sgtk.descriptor.create_descriptor( self.mockgun, sgtk.descriptor.Descriptor.CONFIG, "sgtk:descriptor:path?path={0}".format(config_root), ), self.project["id"], "basic.*", None, [], ) # Due to this being a test that runs offline, we can't use anything other than a # path descriptor, which means that it is mutable. Because LOCAL_CFG_DIFFERENT # is actually returned by three different code paths, the only way to ensure that # we are indeed in the up to date state, which means everything is ready to do, is # to cheat and make the descriptor immutable by monkey-patching it. self._cached_config._descriptor.is_immutable = lambda: True # Seems up the test tremendously since installing core becomes a noop. self._cached_config._config_writer.install_core = lambda _: None self._cached_config._config_writer.create_tank_command = lambda: None def test_verifies_tank_name(self): """ Ensures that missing tank name on project is detected when using roots. """ # Make sure that the missing tank name is detected. with self.assertRaises(sgtk.bootstrap.TankMissingTankNameError): self._cached_config.verify_required_shotgun_fields() # Ensure our change is backwards compatible. with self.assertRaises(sgtk.bootstrap.TankBootstrapError): self._cached_config.verify_required_shotgun_fields() def test_ensure_config_not_missing_after_update(self): """ Ensures once a configuration is written that is ready. """ self.assertEqual(self._cached_config.status(), self._cached_config.LOCAL_CFG_MISSING) self._cached_config.update_configuration() self.assertEqual(self._cached_config.status(), self._cached_config.LOCAL_CFG_UP_TO_DATE) def test_ensure_config_half_written_is_invalid(self): """ Ensures a failure during bootstrap is detected and renders the configuration invalid. """ self.assertEqual(self._cached_config.status(), self._cached_config.LOCAL_CFG_MISSING) # Force put the configuration in an inconsistent state. self._cached_config._config_writer.start_transaction() # Create the config folder so it isn't barely missing. os.makedirs(os.path.join(self._temp_config_root, "config")) self.assertEqual(self._cached_config.status(), self._cached_config.LOCAL_CFG_INVALID) def test_missing_deployment_file(self): """ Ensures a missing deployment file results in an invalid config status. """ self._cached_config.update_configuration() # Using a path descriptor will always give different. self.assertEqual(self._cached_config.status(), self._cached_config.LOCAL_CFG_UP_TO_DATE) os.remove( self._cached_config._config_writer.get_descriptor_metadata_file()) self.assertEqual(self._cached_config.status(), self._cached_config.LOCAL_CFG_INVALID) def test_generation_number_mismatch(self): """ Ensures a generation number mismatch will generate a different config status. """ self._cached_config.update_configuration() # Using a path descriptor will always give different. self.assertEqual(self._cached_config.status(), self._cached_config.LOCAL_CFG_UP_TO_DATE) self._update_deploy_file(generation=9999999) self.assertEqual(self._cached_config.status(), self._cached_config.LOCAL_CFG_DIFFERENT) def test_different_descriptor(self): """ Ensures a descriptor mismatch will generate a different config status. """ self._cached_config.update_configuration() # Using a path descriptor will always give different. self.assertEqual(self._cached_config.status(), self._cached_config.LOCAL_CFG_UP_TO_DATE) self._update_deploy_file(descriptor={ "type": "app_store", "name": "tk-config-basic", "version": "v1.0.0", }) self.assertEqual(self._cached_config.status(), self._cached_config.LOCAL_CFG_DIFFERENT) def test_corrupted_file(self): """ Ensures a corrupted deploy file will generates an invalid status. """ self._cached_config.update_configuration() # Using a path descriptor will always give different. self.assertEqual(self._cached_config.status(), self._cached_config.LOCAL_CFG_UP_TO_DATE) self._update_deploy_file(corrupt=True) self.assertEqual(self._cached_config.status(), self._cached_config.LOCAL_CFG_INVALID) def test_mutable_descriptors(self): """ Ensures a mutable descriptor will yield a different config status. """ self._cached_config.update_configuration() self.assertEqual(self._cached_config.status(), self._cached_config.LOCAL_CFG_UP_TO_DATE) # Now force the descriptor to report that is is not immutable, the status will then be considered # as different since we can't assume everything has stayed the same. self._cached_config._descriptor.is_immutable = lambda: False self.assertEqual(self._cached_config.status(), self._cached_config.LOCAL_CFG_DIFFERENT) def _update_deploy_file(self, generation=None, descriptor=None, corrupt=False): """ Updates the deploy file. :param generation: If set, will update the generation number of the config. :param descriptor: If set, will update the descriptor of the config. :param corrupt: If set, will corrupt the configuration file. """ path = self._cached_config._config_writer.get_descriptor_metadata_file( ) if corrupt: data = "corrupted" else: with open(path, "rt") as fh: data = yaml.load(fh, Loader=yaml.FullLoader) if generation is not None: data["deploy_generation"] = generation if descriptor is not None: data["config_descriptor"] = descriptor with open(path, "wt") as fh: yaml.dump(data, fh)
class TestCachedConfiguration(ShotgunTestBase): def setUp(self): super(TestCachedConfiguration, self).setUp() # Reset the tank_name and create a storage named after the one in the config. self.mockgun.update("Project", self.project["id"], {"tank_name": None}) self.mockgun.create("LocalStorage", {"code": "primary"}) # Initialize a cached configuration pointing to the config. config_root = os.path.join(self.fixtures_root, "bootstrap_tests", "config") self._temp_config_root = os.path.join(self.tank_temp, self.short_test_name) self._cached_config = CachedConfiguration( sgtk.util.ShotgunPath.from_current_os_path(self._temp_config_root), self.mockgun, sgtk.descriptor.create_descriptor( self.mockgun, sgtk.descriptor.Descriptor.CONFIG, "sgtk:descriptor:path?path={0}".format(config_root) ), self.project["id"], "basic.*", None, [] ) # Due to this being a test that runs offline, we can't use anything other than a # path descriptor, which means that it is mutable. Because LOCAL_CFG_DIFFERENT # is actually returned by three different code paths, the only way to ensure that # we are indeed in the up to date state, which means everything is ready to do, is # to cheat and make the descriptor immutable by monkey-patching it. self._cached_config._descriptor.is_immutable = lambda: True # Seems up the test tremendously since installing core becomes a noop. self._cached_config._config_writer.install_core = lambda _: None self._cached_config._config_writer.create_tank_command = lambda: None def test_verifies_tank_name(self): """ Ensures that missing tank name on project is detected when using roots. """ # Make sure that the missing tank name is detected. with self.assertRaises(sgtk.bootstrap.TankMissingTankNameError): self._cached_config.verify_required_shotgun_fields() # Ensure our change is backwards compatible. with self.assertRaises(sgtk.bootstrap.TankBootstrapError): self._cached_config.verify_required_shotgun_fields() def test_ensure_config_not_missing_after_update(self): """ Ensures once a configuration is written that is ready. """ self.assertEqual(self._cached_config.status(), self._cached_config.LOCAL_CFG_MISSING) self._cached_config.update_configuration() self.assertEqual(self._cached_config.status(), self._cached_config.LOCAL_CFG_UP_TO_DATE) def test_ensure_config_half_written_is_invalid(self): """ Ensures a failure during bootstrap is detected and renders the configuration invalid. """ self.assertEqual(self._cached_config.status(), self._cached_config.LOCAL_CFG_MISSING) # Force put the configuration in an inconsistent state. self._cached_config._config_writer.start_transaction() # Create the config folder so it isn't barely missing. os.makedirs(os.path.join(self._temp_config_root, "config")) self.assertEqual(self._cached_config.status(), self._cached_config.LOCAL_CFG_INVALID) def test_missing_deployment_file(self): """ Ensures a missing deployment file results in an invalid config status. """ self._cached_config.update_configuration() # Using a path descriptor will always give different. self.assertEqual(self._cached_config.status(), self._cached_config.LOCAL_CFG_UP_TO_DATE) os.remove(self._cached_config._config_writer.get_descriptor_metadata_file()) self.assertEqual(self._cached_config.status(), self._cached_config.LOCAL_CFG_INVALID) def test_generation_number_mismatch(self): """ Ensures a generation number mismatch will generate a different config status. """ self._cached_config.update_configuration() # Using a path descriptor will always give different. self.assertEqual(self._cached_config.status(), self._cached_config.LOCAL_CFG_UP_TO_DATE) self._update_deploy_file(generation=9999999) self.assertEqual(self._cached_config.status(), self._cached_config.LOCAL_CFG_DIFFERENT) def test_different_descriptor(self): """ Ensures a descriptor mismatch will generate a different config status. """ self._cached_config.update_configuration() # Using a path descriptor will always give different. self.assertEqual(self._cached_config.status(), self._cached_config.LOCAL_CFG_UP_TO_DATE) self._update_deploy_file(descriptor={"type": "app_store", "name": "tk-config-basic", "version": "v1.0.0"}) self.assertEqual(self._cached_config.status(), self._cached_config.LOCAL_CFG_DIFFERENT) def test_corrupted_file(self): """ Ensures a corrupted deploy file will generates an invalid status. """ self._cached_config.update_configuration() # Using a path descriptor will always give different. self.assertEqual(self._cached_config.status(), self._cached_config.LOCAL_CFG_UP_TO_DATE) self._update_deploy_file(corrupt=True) self.assertEqual(self._cached_config.status(), self._cached_config.LOCAL_CFG_INVALID) def test_mutable_descriptors(self): """ Ensures a mutable descriptor will yield a different config status. """ self._cached_config.update_configuration() self.assertEqual(self._cached_config.status(), self._cached_config.LOCAL_CFG_UP_TO_DATE) # Now force the descriptor to report that is is not immutable, the status will then be considered # as different since we can't assume everything has stayed the same. self._cached_config._descriptor.is_immutable = lambda: False self.assertEqual(self._cached_config.status(), self._cached_config.LOCAL_CFG_DIFFERENT) def _update_deploy_file(self, generation=None, descriptor=None, corrupt=False): """ Updates the deploy file. :param generation: If set, will update the generation number of the config. :param descriptor: If set, will update the descriptor of the config. :param corrupt: If set, will corrupt the configuration file. """ path = self._cached_config._config_writer.get_descriptor_metadata_file() if corrupt: data = "corrupted" else: with open(path, "rt") as fh: data = yaml.load(fh) if generation is not None: data["deploy_generation"] = generation if descriptor is not None: data["config_descriptor"] = descriptor with open(path, "wt") as fh: yaml.dump(data, fh)