From cc1373d9bc5a813a8532b89560960231e6609a3b Mon Sep 17 00:00:00 2001 From: Clay Gerrard Date: 2010年8月19日 11:54:55 -0500 Subject: [PATCH 1/3] make it easier for subclasses of swift.common.client.Connection to override the behavior of reauthorization (get_auth) --- swift/common/client.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/swift/common/client.py b/swift/common/client.py index 30c376f89e..16a5acd1e1 100644 --- a/swift/common/client.py +++ b/swift/common/client.py @@ -629,6 +629,9 @@ class Connection(object): self.attempts = 0 self.snet = snet + def get_auth(self): + return get_auth(self.authurl, self.user, self.key, snet=self.snet) + def _retry(self, func, *args, **kwargs): kwargs['http_conn'] = self.http_conn self.attempts = 0 @@ -637,9 +640,7 @@ class Connection(object): self.attempts += 1 try: if not self.url or not self.token: - self.url, self.token = \ - get_auth(self.authurl, self.user, self.key, - snet=self.snet) + self.url, self.token = self.get_auth() self.http_conn = None if not self.http_conn: self.http_conn = http_connection(self.url) From fba7dd3de33d20ec546e4a3a082f080471ba89f8 Mon Sep 17 00:00:00 2001 From: Clay Gerrard Date: 2010年8月19日 14:27:10 -0500 Subject: [PATCH 2/3] added some tests for swift.common.client, coverage from 11% => ~66% --- test/unit/common/test_client.py | 260 +++++++++++++++++++++++++++++++- 1 file changed, 255 insertions(+), 5 deletions(-) diff --git a/test/unit/common/test_client.py b/test/unit/common/test_client.py index 24c9ca1982..ef2f089263 100644 --- a/test/unit/common/test_client.py +++ b/test/unit/common/test_client.py @@ -13,16 +13,266 @@ # See the License for the specific language governing permissions and # limitations under the License. -# TODO: Tests +# TODO: More tests import unittest -from swift.common import client -class TestAuditor(unittest.TestCase): +from swift.common import client as c - def test_placeholder(self): - pass +class TestHttpHelpers(unittest.TestCase): + def test_quote(self): + value = 'standard string' + self.assertEquals('standard%20string', c.quote(value)) + value = u'\u0075nicode string' + self.assertEquals('unicode%20string', c.quote(value)) + + def test_http_connection(self): + url = 'http://www.test.com' + _, conn = c.http_connection(url) + self.assertTrue(isinstance(conn, c.HTTPConnection)) + url = 'https://www.test.com' + _, conn = c.http_connection(url) + self.assertTrue(isinstance(conn, c.HTTPSConnection)) + url = 'ftp://www.test.com' + self.assertRaises(c.ClientException, c.http_connection, url) + +class TestClientException(unittest.TestCase): + + def test_is_exception(self): + self.assertTrue(issubclass(c.ClientException, Exception)) + + def test_format(self): + exc = c.ClientException('something failed') + self.assertTrue('something failed' in str(exc)) + test_kwargs = ( + 'scheme', + 'host', + 'port', + 'path', + 'query', + 'status', + 'reason', + 'device', + ) + for value in test_kwargs: + kwargs = { + 'http_%s' % value: value + } + exc = c.ClientException('test', **kwargs) + self.assertTrue(value in str(exc)) + +class TestJsonImport(unittest.TestCase): + + def tearDown(self): + try: + import json + except ImportError: + pass + else: + reload(json) + + try: + import simplejson + except ImportError: + pass + else: + reload(simplejson) + + def test_any(self): + self.assertTrue(hasattr(c, 'json_loads')) + + def test_no_simplejson(self): + # break simplejson + try: + import simplejson + except ImportError: + # that was easy + pass + else: + delattr(simplejson, 'loads') + reload(c) + + try: + from json import loads + except ImportError: + # this case is stested in _no_json + pass + else: + self.assertEquals(loads, c.json_loads) + + def test_no_json(self): + # first break simplejson + try: + import simplejson + except ImportError: + # that was easy + pass + else: + delattr(simplejson, 'loads') + + # then break json + try: + import json + except ImportError: + # that was easy + _orig_dumps = None + else: + _orig_dumps = json.dumps + delattr(json, 'loads') + reload(c) + + if _orig_dumps: + # thank goodness + data = { + 'string': 'value', + 'int': 0, + 'bool': True, + 'none': None, + } + json_string = _orig_dumps(data) + else: + # wow, I guess we really need this thing... + data = ['value1', 'value2'] + json_string = "['value1', 'value2']" + + self.assertEquals(data, c.json_loads(json_string)) + self.assertRaises(AttributeError, c.json_loads, self) + +class MockHttpTest(unittest.TestCase): + + def setUp(self): + # Yoink! + from test.unit.proxy.test_server import fake_http_connect + # TODO: mock http connection class with more control over headers + def fake_http_connection(*args, **kwargs): + _orig_http_connection = c.http_connection + def wrapper(url): + parsed, _conn = _orig_http_connection(url) + conn = fake_http_connect(*args, **kwargs)() + def request(*args, **kwargs): + return + conn.request = request + return parsed, conn + return wrapper + self.fake_http_connection = fake_http_connection + + def tearDown(self): + reload(c) + +# TODO: following tests cases are placeholders, need more tests, better coverage + +class TestGetAuth(MockHttpTest): + + def test_ok(self): + c.http_connection = self.fake_http_connection(200) + url, token = c.get_auth('http://www.test.com', 'asdf', 'asdf') + self.assertEquals(url, None) + self.assertEquals(token, None) + +class TestGetAccount(MockHttpTest): + + def test_no_content(self): + c.http_connection = self.fake_http_connection(204) + value = c.get_account('http://www.test.com', 'asdf') + self.assertEquals(value, []) + +class TestHeadAccount(MockHttpTest): + + def test_server_error(self): + c.http_connection = self.fake_http_connection(500) + self.assertRaises(c.ClientException, c.head_account, + 'http://www.tests.com', 'asdf') + +class TestGetContainer(MockHttpTest): + + def test_no_content(self): + c.http_connection = self.fake_http_connection(204) + value = c.get_container('http://www.test.com', 'asdf', 'asdf') + self.assertEquals(value, []) + +class TestHeadContainer(MockHttpTest): + + def test_server_error(self): + c.http_connection = self.fake_http_connection(500) + self.assertRaises(c.ClientException, c.head_container, + 'http://www.test.com', 'asdf', 'asdf', + ) + +class TestPutContainer(MockHttpTest): + + def test_ok(self): + c.http_connection = self.fake_http_connection(200) + value = c.put_container('http://www.test.com', 'asdf', 'asdf') + self.assertEquals(value, None) + +class TestDeleteContainer(MockHttpTest): + + def test_ok(self): + c.http_connection = self.fake_http_connection(200) + value = c.delete_container('http://www.test.com', 'asdf', 'asdf') + self.assertEquals(value, None) + +class TestGetObject(MockHttpTest): + + def test_server_error(self): + c.http_connection = self.fake_http_connection(500) + self.assertRaises(c.ClientException, c.get_object, 'http://www.test.com', 'asdf', 'asdf', 'asdf') + +class TestHeadObject(MockHttpTest): + + def test_server_error(self): + c.http_connection = self.fake_http_connection(500) + self.assertRaises(c.ClientException, c.head_object, 'http://www.test.com', 'asdf', 'asdf', 'asdf') + +class TestPutObject(MockHttpTest): + + def test_ok(self): + c.http_connection = self.fake_http_connection(200) + value = c.put_object('http://www.test.com', 'asdf', 'asdf', 'asdf', 'asdf') + self.assertTrue(isinstance(value, basestring)) + + def test_server_error(self): + c.http_connection = self.fake_http_connection(500) + self.assertRaises(c.ClientException, c.put_object, + 'http://www.test.com', 'asdf', 'asdf', 'asdf', 'asdf') + +class TestPostObject(MockHttpTest): + + def test_ok(self): + c.http_connection = self.fake_http_connection(200) + value = c.post_object('http://www.test.com', 'asdf', 'asdf', 'asdf', {}) + + def test_server_error(self): + c.http_connection = self.fake_http_connection(500) + self.assertRaises(c.ClientException, c.post_object, + 'http://www.test.com', 'asdf', 'asdf', 'asdf', {}) + +class TestDeleteObject(MockHttpTest): + + def test_ok(self): + c.http_connection = self.fake_http_connection(200) + value = c.delete_object('http://www.test.com', 'asdf', 'asdf', 'asdf') + + def test_server_error(self): + c.http_connection = self.fake_http_connection(500) + self.assertRaises(c.ClientException, c.delete_object, + 'http://www.test.com', 'asdf', 'asdf', 'asdf') + +class TestConnection(MockHttpTest): + + def test_instance(self): + conn = c.Connection('http://www.test.com', 'asdf', 'asdf') + self.assertEquals(conn.retries, 5) + + def test_retry(self): + c.http_connection = self.fake_http_connection(500) + def quick_sleep(*args): + pass + c.sleep = quick_sleep + conn = c.Connection('http://www.test.com', 'asdf', 'asdf') + self.assertRaises(c.ClientException, conn.head_account) + self.assertEquals(conn.attempts, conn.retries + 1) if __name__ == '__main__': unittest.main() From 7455b4d2385f82ddae6ef179a123617f04c1ca74 Mon Sep 17 00:00:00 2001 From: Clay Gerrard Date: 2010年8月19日 17:09:20 -0500 Subject: [PATCH 3/3] found a error condition in swift.common.client where the resp would not be consumed, added tests and fixed --- swift/common/client.py | 2 + test/unit/common/test_client.py | 69 +++++++++++++++++++++++++++++++++ 2 files changed, 71 insertions(+) diff --git a/swift/common/client.py b/swift/common/client.py index 16a5acd1e1..21e42342b7 100644 --- a/swift/common/client.py +++ b/swift/common/client.py @@ -164,6 +164,7 @@ def get_auth(url, user, key, snet=False): conn.request('GET', parsed.path, '', {'X-Auth-User': user, 'X-Auth-Key': key}) resp = conn.getresponse() + resp.read() if resp.status < 200 or resp.status>= 300: raise ClientException('Auth GET failed', http_scheme=parsed.scheme, http_host=conn.host, http_port=conn.port, @@ -246,6 +247,7 @@ def head_account(url, token, http_conn=None): parsed, conn = http_connection(url) conn.request('HEAD', parsed.path, '', {'X-Auth-Token': token}) resp = conn.getresponse() + resp.read() if resp.status < 200 or resp.status>= 300: raise ClientException('Account HEAD failed', http_scheme=parsed.scheme, http_host=conn.host, http_port=conn.port, diff --git a/test/unit/common/test_client.py b/test/unit/common/test_client.py index ef2f089263..44a46240de 100644 --- a/test/unit/common/test_client.py +++ b/test/unit/common/test_client.py @@ -153,6 +153,14 @@ class MockHttpTest(unittest.TestCase): def request(*args, **kwargs): return conn.request = request + + conn.has_been_read = False + _orig_read = conn.read + def read(*args, **kwargs): + conn.has_been_read = True + return _orig_read(*args, **kwargs) + conn.read = read + return parsed, conn return wrapper self.fake_http_connection = fake_http_connection @@ -179,6 +187,11 @@ class TestGetAccount(MockHttpTest): class TestHeadAccount(MockHttpTest): + def test_ok(self): + c.http_connection = self.fake_http_connection(200) + value = c.head_account('http://www.tests.com', 'asdf') + self.assertEquals(value, (0, 0, 0)) + def test_server_error(self): c.http_connection = self.fake_http_connection(500) self.assertRaises(c.ClientException, c.head_account, @@ -274,5 +287,61 @@ class TestConnection(MockHttpTest): self.assertRaises(c.ClientException, conn.head_account) self.assertEquals(conn.attempts, conn.retries + 1) + def test_resp_read_on_server_error(self): + c.http_connection = self.fake_http_connection(500) + conn = c.Connection('http://www.test.com', 'asdf', 'asdf', retries=0) + def get_auth(*args, **kwargs): + return 'http://www.new.com', 'new' + conn.get_auth = get_auth + self.url, self.token = conn.get_auth() + + method_signatures = ( + (conn.head_account, []), + (conn.get_account, []), + (conn.head_container, ('asdf',)), + (conn.get_container, ('asdf',)), + (conn.put_container, ('asdf',)), + (conn.delete_container, ('asdf',)), + (conn.head_object, ('asdf', 'asdf')), + (conn.get_object, ('asdf', 'asdf')), + (conn.put_object, ('asdf', 'asdf', 'asdf')), + (conn.post_object, ('asdf', 'asdf', {})), + (conn.delete_object, ('asdf', 'asdf')), + ) + + for method, args in method_signatures: + self.assertRaises(c.ClientException, method, *args) + try: + self.assertTrue(conn.http_conn[1].has_been_read) + except AssertionError: + self.fail('%s did not read the resp on server error' % method.__name__) + + def test_reauth(self): + c.http_connection = self.fake_http_connection(401) + def get_auth(*args, **kwargs): + return 'http://www.new.com', 'new' + def swap_sleep(*args): + self.swap_sleep_called = True + c.get_auth = get_auth + c.http_connection = self.fake_http_connection(200) + c.sleep = swap_sleep + self.swap_sleep_called = False + + conn = c.Connection('http://www.test.com', 'asdf', 'asdf', + preauthurl = 'http://www.old.com', + preauthtoken = 'old' + ) + + self.assertEquals(conn.attempts, 0) + self.assertEquals(conn.url, 'http://www.old.com') + self.assertEquals(conn.token, 'old') + + value = conn.head_account() + + self.assertTrue(self.swap_sleep_called) + self.assertEquals(conn.attempts, 2) + self.assertEquals(conn.url, 'http://www.new.com') + self.assertEquals(conn.token, 'new') + if __name__ == '__main__': unittest.main()

AltStyle によって変換されたページ (->オリジナル) /