def account_read_only(self, req, account): """ Returns None if X-Account-Sysmeta-Read-Only is not set. Returns True or False otherwise. """ info = get_info(self.app, req.environ, account, swift_source='RO') read_only = info.get('sysmeta', {}).get('read-only', '') if read_only == '': return None return config_true_value(read_only)
def account_read_only(self, req, account): """ Check whether an account should be read-only. This considers both the cluster-wide config value as well as the per-account override in X-Account-Sysmeta-Read-Only. """ info = get_info(self.app, req.environ, account, swift_source='RO') read_only = info.get('sysmeta', {}).get('read-only', '') if not read_only: return self.read_only return config_true_value(read_only)
def test_get_info(self): app = FakeApp() # Do a non cached call to account env = {} info_a = get_info(app, env, 'a') # Check that you got proper info self.assertEqual(info_a['status'], 200) self.assertEqual(info_a['bytes'], 6666) self.assertEqual(info_a['total_object_count'], 1000) # Make sure the app was called self.assertEqual(app.responses.stats['account'], 1) # Make sure the return value matches get_account_info account_info = get_account_info({'PATH_INFO': '/v1/a'}, app) self.assertEqual(info_a, account_info) # Do an env cached call to account app.responses.stats['account'] = 0 app.responses.stats['container'] = 0 info_a = get_info(app, env, 'a') # Check that you got proper info self.assertEqual(info_a['status'], 200) self.assertEqual(info_a['bytes'], 6666) self.assertEqual(info_a['total_object_count'], 1000) # Make sure the app was NOT called AGAIN self.assertEqual(app.responses.stats['account'], 0) # This time do env cached call to account and non cached to container app.responses.stats['account'] = 0 app.responses.stats['container'] = 0 info_c = get_info(app, env, 'a', 'c') # Check that you got proper info self.assertEqual(info_c['status'], 200) self.assertEqual(info_c['bytes'], 6666) self.assertEqual(info_c['object_count'], 1000) # Make sure the app was called for container but not account self.assertEqual(app.responses.stats['account'], 0) self.assertEqual(app.responses.stats['container'], 1) # This time do a non-cached call to account then non-cached to # container app.responses.stats['account'] = 0 app.responses.stats['container'] = 0 app = FakeApp() env = {} # abandon previous call to env info_c = get_info(app, env, 'a', 'c') # Check that you got proper info self.assertEqual(info_c['status'], 200) self.assertEqual(info_c['bytes'], 6666) self.assertEqual(info_c['object_count'], 1000) # check app calls both account and container self.assertEqual(app.responses.stats['account'], 1) self.assertEqual(app.responses.stats['container'], 1) # This time do an env-cached call to container while account is not # cached app.responses.stats['account'] = 0 app.responses.stats['container'] = 0 info_c = get_info(app, env, 'a', 'c') # Check that you got proper info self.assertEqual(info_a['status'], 200) self.assertEqual(info_c['bytes'], 6666) self.assertEqual(info_c['object_count'], 1000) # no additional calls were made self.assertEqual(app.responses.stats['account'], 0) self.assertEqual(app.responses.stats['container'], 0)
def test_get_info_zero_recheck(self): mock_cache = mock.Mock() mock_cache.get.return_value = None app = FakeApp(ZeroCacheDynamicResponseFactory()) env = {'swift.cache': mock_cache} info_a = get_info(app, env, 'a') # Check that you got proper info self.assertEqual(info_a['status'], 200) self.assertEqual(info_a['bytes'], 6666) self.assertEqual(info_a['total_object_count'], 1000) self.assertEqual(info_a['container_count'], 333) # Make sure the env cache is set exp_cached_info_a = { k: str(v) if k in ( 'bytes', 'container_count', 'total_object_count') else v for k, v in info_a.items()} self.assertEqual(env['swift.infocache'].get('account/a'), exp_cached_info_a) # Make sure the app was called self.assertEqual(app.responses.stats['account'], 1) self.assertEqual(app.responses.stats['container'], 0) # Make sure memcache was called self.assertEqual(mock_cache.mock_calls, [ mock.call.get('account/a'), mock.call.set('account/a', exp_cached_info_a, time=0), ]) mock_cache.reset_mock() info_c = get_info(app, env, 'a', 'c') # Check that you got proper info self.assertEqual(info_c['status'], 200) self.assertEqual(info_c['bytes'], 6666) self.assertEqual(info_c['object_count'], 1000) # Make sure the env cache is set exp_cached_info_c = { k: str(v) if k in ( 'bytes', 'object_count', 'storage_policy') else v for k, v in info_c.items()} self.assertEqual(env['swift.infocache'].get('account/a'), exp_cached_info_a) self.assertEqual(env['swift.infocache'].get('container/a/c'), exp_cached_info_c) # Check app call for container, but no new calls for account self.assertEqual(app.responses.stats['account'], 1) self.assertEqual(app.responses.stats['container'], 1) # Make sure container info was cached self.assertEqual(mock_cache.mock_calls, [ mock.call.get('container/a/c'), mock.call.set('container/a/c', exp_cached_info_c, time=0), ]) # reset call counts app = FakeApp(ZeroCacheDynamicResponseFactory()) env = {'swift.cache': mock_cache} mock_cache.reset_mock() info_c = get_info(app, env, 'a', 'c') # Check that you got proper info self.assertEqual(info_c['status'], 200) self.assertEqual(info_c['bytes'], 6666) self.assertEqual(info_c['object_count'], 1000) # Make sure the env cache is set self.assertEqual(env['swift.infocache'].get('account/a'), exp_cached_info_a) self.assertEqual(env['swift.infocache'].get('container/a/c'), exp_cached_info_c) # check app calls both account and container self.assertEqual(app.responses.stats['account'], 1) self.assertEqual(app.responses.stats['container'], 1) # Make sure account info was cached but container was not self.assertEqual(mock_cache.mock_calls, [ mock.call.get('container/a/c'), mock.call.get('account/a'), mock.call.set('account/a', exp_cached_info_a, time=0), mock.call.set('container/a/c', exp_cached_info_c, time=0), ])
def test_get_info(self): app = FakeApp() # Do a non cached call to account env = {} info_a = get_info(app, env, 'a') # Check that you got proper info self.assertEqual(info_a['status'], 200) self.assertEqual(info_a['bytes'], 6666) self.assertEqual(info_a['total_object_count'], 1000) # Make sure the env cache is set self.assertEqual(env.get('swift.account/a'), info_a) # Make sure the app was called self.assertEqual(app.responses.stats['account'], 1) # Do an env cached call to account info_a = get_info(app, env, 'a') # Check that you got proper info self.assertEqual(info_a['status'], 200) self.assertEqual(info_a['bytes'], 6666) self.assertEqual(info_a['total_object_count'], 1000) # Make sure the env cache is set self.assertEqual(env.get('swift.account/a'), info_a) # Make sure the app was NOT called AGAIN self.assertEqual(app.responses.stats['account'], 1) # This time do env cached call to account and non cached to container info_c = get_info(app, env, 'a', 'c') # Check that you got proper info self.assertEqual(info_c['status'], 200) self.assertEqual(info_c['bytes'], 6666) self.assertEqual(info_c['object_count'], 1000) # Make sure the env cache is set self.assertEqual(env.get('swift.account/a'), info_a) self.assertEqual(env.get('swift.container/a/c'), info_c) # Make sure the app was called for container self.assertEqual(app.responses.stats['container'], 1) # This time do a non cached call to account than non cached to # container app = FakeApp() env = {} # abandon previous call to env info_c = get_info(app, env, 'a', 'c') # Check that you got proper info self.assertEqual(info_c['status'], 200) self.assertEqual(info_c['bytes'], 6666) self.assertEqual(info_c['object_count'], 1000) # Make sure the env cache is set self.assertEqual(env.get('swift.account/a'), info_a) self.assertEqual(env.get('swift.container/a/c'), info_c) # check app calls both account and container self.assertEqual(app.responses.stats['account'], 1) self.assertEqual(app.responses.stats['container'], 1) # This time do an env cached call to container while account is not # cached del (env['swift.account/a']) info_c = get_info(app, env, 'a', 'c') # Check that you got proper info self.assertEqual(info_a['status'], 200) self.assertEqual(info_c['bytes'], 6666) self.assertEqual(info_c['object_count'], 1000) # Make sure the env cache is set and account still not cached self.assertEqual(env.get('swift.container/a/c'), info_c) # no additional calls were made self.assertEqual(app.responses.stats['account'], 1) self.assertEqual(app.responses.stats['container'], 1) # Do a non cached call to account not found with ret_not_found app = FakeApp(statuses=(404, )) env = {} info_a = get_info(app, env, 'a', ret_not_found=True) # Check that you got proper info self.assertEqual(info_a['status'], 404) self.assertEqual(info_a['bytes'], None) self.assertEqual(info_a['total_object_count'], None) # Make sure the env cache is set self.assertEqual(env.get('swift.account/a'), info_a) # and account was called self.assertEqual(app.responses.stats['account'], 1) # Do a cached call to account not found with ret_not_found info_a = get_info(app, env, 'a', ret_not_found=True) # Check that you got proper info self.assertEqual(info_a['status'], 404) self.assertEqual(info_a['bytes'], None) self.assertEqual(info_a['total_object_count'], None) # Make sure the env cache is set self.assertEqual(env.get('swift.account/a'), info_a) # add account was NOT called AGAIN self.assertEqual(app.responses.stats['account'], 1) # Do a non cached call to account not found without ret_not_found app = FakeApp(statuses=(404, )) env = {} info_a = get_info(app, env, 'a') # Check that you got proper info self.assertEqual(info_a, None) self.assertEqual(env['swift.account/a']['status'], 404) # and account was called self.assertEqual(app.responses.stats['account'], 1) # Do a cached call to account not found without ret_not_found info_a = get_info(None, env, 'a') # Check that you got proper info self.assertEqual(info_a, None) self.assertEqual(env['swift.account/a']['status'], 404) # add account was NOT called AGAIN self.assertEqual(app.responses.stats['account'], 1)
def test_get_info(self): global FakeResponse_status_int # Do a non cached call to account env = {} with patch('swift.proxy.controllers.base.' '_prepare_pre_auth_info_request', FakeRequest): info_a = get_info(None, env, 'a') # Check that you got proper info self.assertEquals(info_a['status'], 201) self.assertEquals(info_a['bytes'], 6666) self.assertEquals(info_a['total_object_count'], 1000) # Make sure the env cache is set self.assertEquals(env.get('swift.account/a'), info_a) # Do an env cached call to account info_a = get_info(None, env, 'a') # Check that you got proper info self.assertEquals(info_a['status'], 201) self.assertEquals(info_a['bytes'], 6666) self.assertEquals(info_a['total_object_count'], 1000) # Make sure the env cache is set self.assertEquals(env.get('swift.account/a'), info_a) # This time do env cached call to account and non cached to container with patch('swift.proxy.controllers.base.' '_prepare_pre_auth_info_request', FakeRequest): info_c = get_info(None, env, 'a', 'c') # Check that you got proper info self.assertEquals(info_a['status'], 201) self.assertEquals(info_c['bytes'], 6666) self.assertEquals(info_c['object_count'], 1000) # Make sure the env cache is set self.assertEquals(env.get('swift.account/a'), info_a) self.assertEquals(env.get('swift.container/a/c'), info_c) # This time do a non cached call to account than non cached to # container env = {} # abandon previous call to env with patch('swift.proxy.controllers.base.' '_prepare_pre_auth_info_request', FakeRequest): info_c = get_info(None, env, 'a', 'c') # Check that you got proper info self.assertEquals(info_a['status'], 201) self.assertEquals(info_c['bytes'], 6666) self.assertEquals(info_c['object_count'], 1000) # Make sure the env cache is set self.assertEquals(env.get('swift.account/a'), info_a) self.assertEquals(env.get('swift.container/a/c'), info_c) # This time do an env cached call to container while account is not # cached del(env['swift.account/a']) info_c = get_info(None, env, 'a', 'c') # Check that you got proper info self.assertEquals(info_a['status'], 201) self.assertEquals(info_c['bytes'], 6666) self.assertEquals(info_c['object_count'], 1000) # Make sure the env cache is set and account still not cached self.assertEquals(env.get('swift.container/a/c'), info_c) # Do a non cached call to account not found with ret_not_found env = {} with patch('swift.proxy.controllers.base.' '_prepare_pre_auth_info_request', FakeRequest): try: FakeResponse_status_int = 404 info_a = get_info(None, env, 'a', ret_not_found=True) finally: FakeResponse_status_int = 201 # Check that you got proper info self.assertEquals(info_a['status'], 404) self.assertEquals(info_a['bytes'], 6666) self.assertEquals(info_a['total_object_count'], 1000) # Make sure the env cache is set self.assertEquals(env.get('swift.account/a'), info_a) # Do a cached call to account not found with ret_not_found info_a = get_info(None, env, 'a', ret_not_found=True) # Check that you got proper info self.assertEquals(info_a['status'], 404) self.assertEquals(info_a['bytes'], 6666) self.assertEquals(info_a['total_object_count'], 1000) # Make sure the env cache is set self.assertEquals(env.get('swift.account/a'), info_a) # Do a non cached call to account not found without ret_not_found env = {} with patch('swift.proxy.controllers.base.' '_prepare_pre_auth_info_request', FakeRequest): try: FakeResponse_status_int = 404 info_a = get_info(None, env, 'a') finally: FakeResponse_status_int = 201 # Check that you got proper info self.assertEquals(info_a, None) self.assertEquals(env['swift.account/a']['status'], 404) # Do a cached call to account not found without ret_not_found info_a = get_info(None, env, 'a') # Check that you got proper info self.assertEquals(info_a, None) self.assertEquals(env['swift.account/a']['status'], 404)
def test_get_info_zero_recheck(self): mock_cache = mock.Mock() mock_cache.get.return_value = None app = FakeApp(ZeroCacheDynamicResponseFactory()) env = {'swift.cache': mock_cache} info_a = get_info(app, env, 'a') # Check that you got proper info self.assertEqual(info_a['status'], 200) self.assertEqual(info_a['bytes'], 6666) self.assertEqual(info_a['total_object_count'], 1000) self.assertEqual(info_a['container_count'], 333) # Make sure the env cache is set exp_cached_info_a = { k: str(v) if k in ('bytes', 'container_count', 'total_object_count') else v for k, v in info_a.items() } self.assertEqual(env['swift.infocache'].get('account/a'), exp_cached_info_a) # Make sure the app was called self.assertEqual(app.responses.stats['account'], 1) self.assertEqual(app.responses.stats['container'], 0) # Make sure memcache was called self.assertEqual(mock_cache.mock_calls, [ mock.call.get('account/a'), mock.call.set('account/a', exp_cached_info_a, time=0), ]) mock_cache.reset_mock() info_c = get_info(app, env, 'a', 'c') # Check that you got proper info self.assertEqual(info_c['status'], 200) self.assertEqual(info_c['bytes'], 6666) self.assertEqual(info_c['object_count'], 1000) # Make sure the env cache is set exp_cached_info_c = { k: str(v) if k in ('bytes', 'object_count') else v for k, v in info_c.items() } self.assertEqual(env['swift.infocache'].get('account/a'), exp_cached_info_a) self.assertEqual(env['swift.infocache'].get('container/a/c'), exp_cached_info_c) # Check app call for container, but no new calls for account self.assertEqual(app.responses.stats['account'], 1) self.assertEqual(app.responses.stats['container'], 1) # Make sure container info was cached self.assertEqual(mock_cache.mock_calls, [ mock.call.get('container/a/c'), mock.call.set('container/a/c', exp_cached_info_c, time=0), ]) # reset call counts app = FakeApp(ZeroCacheDynamicResponseFactory()) env = {'swift.cache': mock_cache} mock_cache.reset_mock() info_c = get_info(app, env, 'a', 'c') # Check that you got proper info self.assertEqual(info_c['status'], 200) self.assertEqual(info_c['bytes'], 6666) self.assertEqual(info_c['object_count'], 1000) # Make sure the env cache is set self.assertEqual(env['swift.infocache'].get('account/a'), exp_cached_info_a) self.assertEqual(env['swift.infocache'].get('container/a/c'), exp_cached_info_c) # check app calls both account and container self.assertEqual(app.responses.stats['account'], 1) self.assertEqual(app.responses.stats['container'], 1) # Make sure account info was cached but container was not self.assertEqual(mock_cache.mock_calls, [ mock.call.get('container/a/c'), mock.call.get('account/a'), mock.call.set('account/a', exp_cached_info_a, time=0), mock.call.set('container/a/c', exp_cached_info_c, time=0), ])
def test_get_info(self): app = FakeApp() # Do a non cached call to account env = {} info_a = get_info(app, env, 'a') # Check that you got proper info self.assertEqual(info_a['status'], 200) self.assertEqual(info_a['bytes'], 6666) self.assertEqual(info_a['total_object_count'], 1000) # Make sure the env cache is set self.assertEqual(env.get('swift.account/a'), info_a) # Make sure the app was called self.assertEqual(app.responses.stats['account'], 1) # Do an env cached call to account info_a = get_info(app, env, 'a') # Check that you got proper info self.assertEqual(info_a['status'], 200) self.assertEqual(info_a['bytes'], 6666) self.assertEqual(info_a['total_object_count'], 1000) # Make sure the env cache is set self.assertEqual(env.get('swift.account/a'), info_a) # Make sure the app was NOT called AGAIN self.assertEqual(app.responses.stats['account'], 1) # This time do env cached call to account and non cached to container info_c = get_info(app, env, 'a', 'c') # Check that you got proper info self.assertEqual(info_c['status'], 200) self.assertEqual(info_c['bytes'], 6666) self.assertEqual(info_c['object_count'], 1000) # Make sure the env cache is set self.assertEqual(env.get('swift.account/a'), info_a) self.assertEqual(env.get('swift.container/a/c'), info_c) # Make sure the app was called for container self.assertEqual(app.responses.stats['container'], 1) # This time do a non cached call to account than non cached to # container app = FakeApp() env = {} # abandon previous call to env info_c = get_info(app, env, 'a', 'c') # Check that you got proper info self.assertEqual(info_c['status'], 200) self.assertEqual(info_c['bytes'], 6666) self.assertEqual(info_c['object_count'], 1000) # Make sure the env cache is set self.assertEqual(env.get('swift.account/a'), info_a) self.assertEqual(env.get('swift.container/a/c'), info_c) # check app calls both account and container self.assertEqual(app.responses.stats['account'], 1) self.assertEqual(app.responses.stats['container'], 1) # This time do an env cached call to container while account is not # cached del(env['swift.account/a']) info_c = get_info(app, env, 'a', 'c') # Check that you got proper info self.assertEqual(info_a['status'], 200) self.assertEqual(info_c['bytes'], 6666) self.assertEqual(info_c['object_count'], 1000) # Make sure the env cache is set and account still not cached self.assertEqual(env.get('swift.container/a/c'), info_c) # no additional calls were made self.assertEqual(app.responses.stats['account'], 1) self.assertEqual(app.responses.stats['container'], 1) # Do a non cached call to account not found with ret_not_found app = FakeApp(statuses=(404,)) env = {} info_a = get_info(app, env, 'a', ret_not_found=True) # Check that you got proper info self.assertEqual(info_a['status'], 404) self.assertEqual(info_a['bytes'], None) self.assertEqual(info_a['total_object_count'], None) # Make sure the env cache is set self.assertEqual(env.get('swift.account/a'), info_a) # and account was called self.assertEqual(app.responses.stats['account'], 1) # Do a cached call to account not found with ret_not_found info_a = get_info(app, env, 'a', ret_not_found=True) # Check that you got proper info self.assertEqual(info_a['status'], 404) self.assertEqual(info_a['bytes'], None) self.assertEqual(info_a['total_object_count'], None) # Make sure the env cache is set self.assertEqual(env.get('swift.account/a'), info_a) # add account was NOT called AGAIN self.assertEqual(app.responses.stats['account'], 1) # Do a non cached call to account not found without ret_not_found app = FakeApp(statuses=(404,)) env = {} info_a = get_info(app, env, 'a') # Check that you got proper info self.assertEqual(info_a, None) self.assertEqual(env['swift.account/a']['status'], 404) # and account was called self.assertEqual(app.responses.stats['account'], 1) # Do a cached call to account not found without ret_not_found info_a = get_info(None, env, 'a') # Check that you got proper info self.assertEqual(info_a, None) self.assertEqual(env['swift.account/a']['status'], 404) # add account was NOT called AGAIN self.assertEqual(app.responses.stats['account'], 1)
def test_get_info(self): global FakeResponse_status_int # Do a non cached call to account env = {} with patch( 'swift.proxy.controllers.base.' '_prepare_pre_auth_info_request', FakeRequest): info_a = get_info(None, env, 'a') # Check that you got proper info self.assertEquals(info_a['status'], 201) self.assertEquals(info_a['bytes'], 6666) self.assertEquals(info_a['total_object_count'], 1000) # Make sure the env cache is set self.assertEquals(env.get('swift.account/a'), info_a) # Do an env cached call to account info_a = get_info(None, env, 'a') # Check that you got proper info self.assertEquals(info_a['status'], 201) self.assertEquals(info_a['bytes'], 6666) self.assertEquals(info_a['total_object_count'], 1000) # Make sure the env cache is set self.assertEquals(env.get('swift.account/a'), info_a) # This time do env cached call to account and non cached to container with patch( 'swift.proxy.controllers.base.' '_prepare_pre_auth_info_request', FakeRequest): info_c = get_info(None, env, 'a', 'c') # Check that you got proper info self.assertEquals(info_a['status'], 201) self.assertEquals(info_c['bytes'], 6666) self.assertEquals(info_c['object_count'], 1000) # Make sure the env cache is set self.assertEquals(env.get('swift.account/a'), info_a) self.assertEquals(env.get('swift.container/a/c'), info_c) # This time do a non cached call to account than non cached to # container env = {} # abandon previous call to env with patch( 'swift.proxy.controllers.base.' '_prepare_pre_auth_info_request', FakeRequest): info_c = get_info(None, env, 'a', 'c') # Check that you got proper info self.assertEquals(info_a['status'], 201) self.assertEquals(info_c['bytes'], 6666) self.assertEquals(info_c['object_count'], 1000) # Make sure the env cache is set self.assertEquals(env.get('swift.account/a'), info_a) self.assertEquals(env.get('swift.container/a/c'), info_c) # This time do an env cached call to container while account is not # cached del (env['swift.account/a']) info_c = get_info(None, env, 'a', 'c') # Check that you got proper info self.assertEquals(info_a['status'], 201) self.assertEquals(info_c['bytes'], 6666) self.assertEquals(info_c['object_count'], 1000) # Make sure the env cache is set and account still not cached self.assertEquals(env.get('swift.container/a/c'), info_c) # Do a non cached call to account not found with ret_not_found env = {} with patch( 'swift.proxy.controllers.base.' '_prepare_pre_auth_info_request', FakeRequest): try: FakeResponse_status_int = 404 info_a = get_info(None, env, 'a', ret_not_found=True) finally: FakeResponse_status_int = 201 # Check that you got proper info self.assertEquals(info_a['status'], 404) self.assertEquals(info_a['bytes'], 6666) self.assertEquals(info_a['total_object_count'], 1000) # Make sure the env cache is set self.assertEquals(env.get('swift.account/a'), info_a) # Do a cached call to account not found with ret_not_found info_a = get_info(None, env, 'a', ret_not_found=True) # Check that you got proper info self.assertEquals(info_a['status'], 404) self.assertEquals(info_a['bytes'], 6666) self.assertEquals(info_a['total_object_count'], 1000) # Make sure the env cache is set self.assertEquals(env.get('swift.account/a'), info_a) # Do a non cached call to account not found without ret_not_found env = {} with patch( 'swift.proxy.controllers.base.' '_prepare_pre_auth_info_request', FakeRequest): try: FakeResponse_status_int = 404 info_a = get_info(None, env, 'a') finally: FakeResponse_status_int = 201 # Check that you got proper info self.assertEquals(info_a, None) self.assertEquals(env['swift.account/a']['status'], 404) # Do a cached call to account not found without ret_not_found info_a = get_info(None, env, 'a') # Check that you got proper info self.assertEquals(info_a, None) self.assertEquals(env['swift.account/a']['status'], 404)
def test_get_info(self): global FakeResponse_status_int # Do a non cached call to account env = {} with patch("swift.proxy.controllers.base." "_prepare_pre_auth_info_request", FakeRequest): info_a = get_info(None, env, "a") # Check that you got proper info self.assertEquals(info_a["status"], 201) self.assertEquals(info_a["bytes"], 6666) self.assertEquals(info_a["total_object_count"], 1000) # Make sure the env cache is set self.assertEquals(env, {"swift.account/a": info_a}) # Do an env cached call to account info_a = get_info(None, env, "a") # Check that you got proper info self.assertEquals(info_a["status"], 201) self.assertEquals(info_a["bytes"], 6666) self.assertEquals(info_a["total_object_count"], 1000) # Make sure the env cache is set self.assertEquals(env, {"swift.account/a": info_a}) # This time do env cached call to account and non cached to container with patch("swift.proxy.controllers.base." "_prepare_pre_auth_info_request", FakeRequest): info_c = get_info(None, env, "a", "c") # Check that you got proper info self.assertEquals(info_a["status"], 201) self.assertEquals(info_c["bytes"], 6666) self.assertEquals(info_c["object_count"], 1000) # Make sure the env cache is set self.assertEquals(env["swift.account/a"], info_a) self.assertEquals(env["swift.container/a/c"], info_c) # This time do a non cached call to account than non cached to # container env = {} # abandon previous call to env with patch("swift.proxy.controllers.base." "_prepare_pre_auth_info_request", FakeRequest): info_c = get_info(None, env, "a", "c") # Check that you got proper info self.assertEquals(info_a["status"], 201) self.assertEquals(info_c["bytes"], 6666) self.assertEquals(info_c["object_count"], 1000) # Make sure the env cache is set self.assertEquals(env["swift.account/a"], info_a) self.assertEquals(env["swift.container/a/c"], info_c) # This time do an env cached call to container while account is not # cached del (env["swift.account/a"]) info_c = get_info(None, env, "a", "c") # Check that you got proper info self.assertEquals(info_a["status"], 201) self.assertEquals(info_c["bytes"], 6666) self.assertEquals(info_c["object_count"], 1000) # Make sure the env cache is set and account still not cached self.assertEquals(env, {"swift.container/a/c": info_c}) # Do a non cached call to account not found with ret_not_found env = {} with patch("swift.proxy.controllers.base." "_prepare_pre_auth_info_request", FakeRequest): try: FakeResponse_status_int = 404 info_a = get_info(None, env, "a", ret_not_found=True) finally: FakeResponse_status_int = 201 # Check that you got proper info self.assertEquals(info_a["status"], 404) self.assertEquals(info_a["bytes"], 6666) self.assertEquals(info_a["total_object_count"], 1000) # Make sure the env cache is set self.assertEquals(env, {"swift.account/a": info_a}) # Do a cached call to account not found with ret_not_found info_a = get_info(None, env, "a", ret_not_found=True) # Check that you got proper info self.assertEquals(info_a["status"], 404) self.assertEquals(info_a["bytes"], 6666) self.assertEquals(info_a["total_object_count"], 1000) # Make sure the env cache is set self.assertEquals(env, {"swift.account/a": info_a}) # Do a non cached call to account not found without ret_not_found env = {} with patch("swift.proxy.controllers.base." "_prepare_pre_auth_info_request", FakeRequest): try: FakeResponse_status_int = 404 info_a = get_info(None, env, "a") finally: FakeResponse_status_int = 201 # Check that you got proper info self.assertEquals(info_a, None) self.assertEquals(env["swift.account/a"]["status"], 404) # Do a cached call to account not found without ret_not_found info_a = get_info(None, env, "a") # Check that you got proper info self.assertEquals(info_a, None) self.assertEquals(env["swift.account/a"]["status"], 404)