def clear_cache(cls): """Clears the cache of .cached(). So the next call to .cached() returns the fresh instance from ndb. """ if cls._config_fetcher: utils.clear_cache(cls._config_fetcher)
def test_cache_with_expiration(self): ran = [] self.mock(utils, 'time_time', lambda: 1000) @utils.cache_with_expiration(30) def do_work(): ran.append(1) return len(ran) self.assertEqual(30, do_work.__parent_cache__.expiration_sec) self.assertEqual(None, do_work.__parent_cache__.expires) self.assertEqual(1, do_work()) self.assertEqual(1, do_work()) self.assertEqual(1, len(ran)) self.assertEqual(1030, do_work.__parent_cache__.expires) utils.clear_cache(do_work) self.assertEqual(2, do_work()) self.assertEqual(2, len(ran)) self.assertEqual(1030, do_work.__parent_cache__.expires) self.mock(utils, 'time_time', lambda: 1029) self.assertEqual(2, do_work()) self.assertEqual(2, do_work()) self.assertEqual(2, len(ran)) self.mock(utils, 'time_time', lambda: 1030) self.assertEqual(3, do_work()) self.assertEqual(3, do_work()) self.assertEqual(3, len(ran)) self.assertEqual(1060, do_work.__parent_cache__.expires)
def mock_config(self, cfg): def get_self_config_mock(path, cls, **_kwargs): self.assertEquals('bots.cfg', path) self.assertEquals(cls, bots_pb2.BotsCfg) return None, cfg self.mock(config, 'get_self_config', get_self_config_mock) utils.clear_cache(bot_groups_config._fetch_bot_groups)
def mock_config(self, cfg): def get_self_config_mock(path, cls=None, **kwargs): self.assertEqual({'store_last_good': True}, kwargs) self.assertEqual('pools.cfg', path) self.assertEqual(cls, pools_pb2.PoolsCfg) return 'rev', cfg self.mock(config, 'get_self_config', get_self_config_mock) utils.clear_cache(pools_config._fetch_pools_config)
def setUp(self): super(RealmsTest, self).setUp() self._has_permission_mock = mock.Mock() self._has_permission_dryrun_mock = mock.Mock() self.mock(auth, 'has_permission', self._has_permission_mock) self.mock(auth, 'has_permission_dryrun', self._has_permission_dryrun_mock) self.mock(service_accounts, 'has_token_server', lambda: True) utils.clear_cache(config.settings)
def reset(): """To be used in tests only.""" global _TEMPLATE_PATHS global _GLOBAL_ENV global _GLOBAL_FILTERS _TEMPLATE_PATHS = {} _GLOBAL_ENV = {} _GLOBAL_FILTERS = _DEFAULT_GLOBAL_FILTERS.copy() utils.clear_cache(get_jinja_env)
def test_clear_cache(self): calls = [] @utils.cache def get_me(): calls.append(1) return len(calls) self.assertEqual(1, get_me()) utils.clear_cache(get_me) self.assertEqual(2, get_me()) self.assertEqual(2, len(calls))
def test_get_delegation_config(self): # Missing -> returns empty proto. proto = config.get_delegation_config() self.assertFalse(proto.rules) # Add some. body = """rules { user_id: "service:abc" target_service: "*" max_validity_duration: 3600 }""" config._update_service_config( 'delegation.cfg', config.Revision('rev', 'url'), body) utils.clear_cache(config.get_delegation_config) proto = config.get_delegation_config() self.assertEqual(1, len(proto.rules))
def test_get_delegation_config(self): # Missing -> returns empty proto. proto = config.get_delegation_config() self.assertFalse(proto.rules) # Add some. body = """rules { user_id: "service:abc" target_service: "*" max_validity_duration: 3600 }""" config._update_service_config('delegation.cfg', config.Revision('rev', 'url'), body) utils.clear_cache(config.get_delegation_config) proto = config.get_delegation_config() self.assertEqual(1, len(proto.rules))
def bootstrap(paths, global_env=None, filters=None): """Resets cached Jinja2 env to pick up new template paths. This is purely additive and idempotent. So consecutive calls to this functions with different arguments is fine. Args: paths: dict {prefix -> template_dir}, templates under template_dir would be accessible as <prefix>/<path relative to template_dir>. global_env: dict with variables to add to global template environment. filters: dict with filters to add to global filter list. """ assert isinstance(paths, dict), paths assert all( _TEMPLATE_PATHS.get(k, v) == v for k, v in paths.items()), paths assert all(os.path.isabs(p) for p in paths.values()), paths assert all(os.path.isdir(p) for p in paths.values()), paths if global_env is not None: assert isinstance(global_env, dict), global_env assert all(isinstance(k, str) for k in global_env), global_env assert all( _GLOBAL_ENV.get(k, v) == v for k, v in global_env.items()), global_env if filters is not None: assert isinstance(filters, dict), filters assert all( isinstance(k, str) and callable(v) for k, v in filters.items()), filters assert all( _GLOBAL_FILTERS.get(k, v) == v for k, v in filters.items()), filters _TEMPLATE_PATHS.update(paths) if global_env: _GLOBAL_ENV.update(global_env) # These are immutable. _GLOBAL_ENV.setdefault('app_id', app_identity.get_application_id()) _GLOBAL_ENV.setdefault('app_version', utils.get_app_version()) _GLOBAL_ENV.setdefault('app_revision_url', utils.get_app_revision_url()) if filters: _GLOBAL_FILTERS.update(filters) utils.clear_cache(get_jinja_env)
def bootstrap(paths, global_env=None, filters=None): """Resets cached Jinja2 env to pick up new template paths. This is purely additive and idempotent. So consecutive calls to this functions with different arguments is fine. Args: paths: dict {prefix -> template_dir}, templates under template_dir would be accessible as <prefix>/<path relative to template_dir>. global_env: dict with variables to add to global template environment. filters: dict with filters to add to global filter list. """ assert isinstance(paths, dict), paths assert all( _TEMPLATE_PATHS.get(k, v) == v for k, v in paths.iteritems()), paths assert all(os.path.isabs(p) for p in paths.itervalues()), paths assert all(os.path.isdir(p) for p in paths.itervalues()), paths if global_env is not None: assert isinstance(global_env, dict), global_env assert all(isinstance(k, str) for k in global_env), global_env assert all( _GLOBAL_ENV.get(k, v) == v for k, v in global_env.iteritems()), global_env if filters is not None: assert isinstance(filters, dict), filters assert all( isinstance(k, str) and callable(v) for k, v in filters.iteritems()), filters assert all( _GLOBAL_FILTERS.get(k, v) == v for k, v in filters.iteritems()), filters _TEMPLATE_PATHS.update(paths) if global_env: _GLOBAL_ENV.update(global_env) _GLOBAL_ENV.setdefault('app_version', utils.get_app_version()) _GLOBAL_ENV.setdefault('app_revision_url', utils.get_app_revision_url()) if filters: _GLOBAL_FILTERS.update(filters) utils.clear_cache(get_jinja_env)
def setUp(self): super(AppTestBase, self).setUp() self.bot_version = None self.source_ip = '192.168.2.2' self.testbed.init_user_stub() gae_ts_mon.reset_for_unittest(disable=True) event_mon_metrics.initialize() # By default requests in tests are coming from bot with fake IP. # WSGI app that implements auth REST API. self.auth_app = webtest.TestApp( auth.create_wsgi_application(debug=True), extra_environ={ 'REMOTE_ADDR': self.source_ip, 'SERVER_SOFTWARE': os.environ['SERVER_SOFTWARE'], }) admins_group = 'test_admins_group' priv_users_group = 'test_priv_users_group' users_group = 'test_users_group' cfg = config_pb2.SettingsCfg(auth=config_pb2.AuthSettings( admins_group=admins_group, privileged_users_group=priv_users_group, users_group=users_group, )) self.mock(config, '_get_settings', lambda: ('test_rev', cfg)) utils.clear_cache(config.settings) # Note that auth.ADMIN_GROUP != admins_group. auth.bootstrap_group( auth.ADMIN_GROUP, [auth.Identity(auth.IDENTITY_USER, '*****@*****.**')]) auth.bootstrap_group( admins_group, [auth.Identity(auth.IDENTITY_USER, '*****@*****.**')]) auth.bootstrap_group( priv_users_group, [auth.Identity(auth.IDENTITY_USER, '*****@*****.**')]) auth.bootstrap_group( users_group, [auth.Identity(auth.IDENTITY_USER, '*****@*****.**')])
def test_settings_updates(self): # Fetch only settings.cfg in this test case. self.mock(config, 'is_remote_configured', lambda: True) self.mock(config, '_CONFIG_SCHEMAS', { 'settings.cfg': config._CONFIG_SCHEMAS['settings.cfg'], }) # Default settings. self.assertEqual(config_pb2.SettingsCfg(), config.get_settings()) # Mock new settings value in luci-config. settings_cfg_text = 'enable_ts_monitoring: true' self.mock( config, '_fetch_configs', lambda _: { 'settings.cfg': (config.Revision('rev', 'url'), settings_cfg_text), }) # Fetch them. config.refetch_config() # Verify they are used now. utils.clear_cache(config.get_settings) self.assertEqual(config_pb2.SettingsCfg(enable_ts_monitoring=True), config.get_settings()) # "Delete" them from luci-config. self.mock( config, '_fetch_configs', lambda _: { 'settings.cfg': (config.Revision('0' * 40, 'url'), ''), }) # Fetch them. config.refetch_config() # Verify defaults are restored. utils.clear_cache(config.get_settings) self.assertEqual(config_pb2.SettingsCfg(), config.get_settings())
def test_works(self): utils.clear_cache(api.get_web_client_id) self.assertEqual('', api.get_web_client_id_uncached()) api.set_web_client_id('zzz') self.assertEqual('zzz', api.get_web_client_id_uncached()) self.assertEqual('zzz', api.get_web_client_id())
def tearDown(self): super(RealmsTest, self).tearDown() utils.clear_cache(config.settings)
def setUp(self): super(ConfigTest, self).setUp() utils.clear_cache(config.settings)
def setUp(self): super(ConfigTest, self).setUp() utils.clear_cache(config.get_delegation_config)
def setUp(self): super(ConfigTest, self).setUp() utils.clear_cache(config._get_settings_cached) config.GlobalConfig.clear_cache()