Merge lp:~eday/burrow/backend-unittests into lp:burrow

[Eric Day]

Added HTTP backend unit tests that work against a running server (auto started/killed with test).

=== modified file '.bzrignore'
--- .bzrignore	2011-04-20 18:21:51 +0000
+++ .bzrignore	2011-08-10 05:42:35 +0000
@@ -1,4 +1,4 @@
-.coverage
+.coverage*
 burrow.egg-info
 ChangeLog
 coverage

=== modified file 'burrow/backend/__init__.py'
--- burrow/backend/__init__.py	2011-08-09 19:43:03 +0000
+++ burrow/backend/__init__.py	2011-08-10 05:42:35 +0000
@@ -112,7 +112,7 @@
         if detail == 'none':
             detail = None
         elif detail is not None and detail not in ['id', 'all']:
-            raise burrow.backend.BadDetail(detail)
+            raise burrow.backend.InvalidArguments(detail)
         return detail
 
     def _get_message_detail(self, filters, default=None):
@@ -121,7 +121,7 @@
         if detail == 'none':
             detail = None
         elif detail is not None and detail not in options:
-            raise burrow.backend.BadDetail(detail)
+            raise burrow.backend.InvalidArguments(detail)
         return detail
 
 
@@ -129,5 +129,5 @@
     pass
 
 
-class BadDetail(Exception):
+class InvalidArguments(Exception):
     pass

=== modified file 'burrow/backend/http.py'
--- burrow/backend/http.py	2011-04-22 02:18:26 +0000
+++ burrow/backend/http.py	2011-08-10 05:42:35 +0000
@@ -67,7 +67,7 @@
         url = self._add_parameters(url, filters=filters)
         return self._request('GET', url)
 
-    def update_messages(self, account, queue, attributes={}, filters={}):
+    def update_messages(self, account, queue, attributes, filters={}):
         url = '/%s/%s' % (account, queue)
         url = self._add_parameters(url, attributes, filters)
         return self._request('POST', url)
@@ -75,20 +75,34 @@
     def create_message(self, account, queue, message, body, attributes={}):
         url = '/%s/%s/%s' % (account, queue, message)
         url = self._add_parameters(url, attributes)
-        return self._request('PUT', url, body=body)
-
-    def delete_message(self, account, queue, message):
-        url = '/%s/%s/%s' % (account, queue, message)
-        return self._request('DELETE', url)
-
-    def get_message(self, account, queue, message):
-        url = '/%s/%s/%s' % (account, queue, message)
-        return self._request('GET', url)
-
-    def update_message(self, account, queue, message, attributes={}):
-        url = '/%s/%s/%s' % (account, queue, message)
-        url = self._add_parameters(url, attributes)
-        return self._request('POST', url)
+        try:
+            return self._request('PUT', url, body=body).next()
+        except StopIteration:
+            return False
+
+    def delete_message(self, account, queue, message, filters={}):
+        url = '/%s/%s/%s' % (account, queue, message)
+        url = self._add_parameters(url, filters=filters)
+        try:
+            return self._request('DELETE', url).next()
+        except StopIteration:
+            return None
+
+    def get_message(self, account, queue, message, filters={}):
+        url = '/%s/%s/%s' % (account, queue, message)
+        url = self._add_parameters(url, filters=filters)
+        try:
+            return self._request('GET', url).next()
+        except StopIteration:
+            return None
+
+    def update_message(self, account, queue, message, attributes, filters={}):
+        url = '/%s/%s/%s' % (account, queue, message)
+        url = self._add_parameters(url, attributes, filters)
+        try:
+            return self._request('POST', url).next()
+        except StopIteration:
+            return None
 
     def clean(self):
         pass
@@ -111,7 +125,21 @@
         connection = httplib.HTTPConnection(*self.server)
         connection.request(method, '/v1.0' + url, *args, **kwargs)
         response = connection.getresponse()
-        if response.status == 200:
-            return json.loads(response.read())
-        if response.status >= 400:
-            raise Exception(response.reason)
+        if response.status >= 200 and response.status < 300:
+            if int(response.getheader('content-length')) == 0:
+                if response.status == 201:
+                    yield True
+                return
+            body = response.read()
+            if response.getheader('content-type')[:16] == 'application/json':
+                body = json.loads(body)
+                if isinstance(body, list):
+                    for item in body:
+                        yield item
+                    return
+            yield body
+        if response.status == 400:
+            raise burrow.backend.InvalidArguments()
+        if response.status == 404:
+            raise burrow.backend.NotFound()
+        raise Exception(response.reason)

=== modified file 'burrow/frontend/wsgi.py'
--- burrow/frontend/wsgi.py	2011-08-09 17:22:31 +0000
+++ burrow/frontend/wsgi.py	2011-08-10 05:42:35 +0000
@@ -173,33 +173,24 @@
     @webob.dec.wsgify
     def _delete_message(self, req, account, queue, message):
         filters = self._parse_filters(req)
-        try:
-            message = self.backend.delete_message(account, queue, message,
-                filters)
-        except burrow.backend.NotFound:
-            return self._response(status=404)
-        return self._response(body=message)
+        body = lambda: self.backend.delete_message(account, queue, message,
+            filters)
+        return self._response(body=body)
 
     @webob.dec.wsgify
     def _get_message(self, req, account, queue, message):
         filters = self._parse_filters(req)
-        try:
-            message = self.backend.get_message(account, queue, message,
-                filters)
-        except burrow.backend.NotFound:
-            return self._response(status=404)
-        return self._response(body=message)
+        body = lambda: self.backend.get_message(account, queue, message,
+            filters)
+        return self._response(body=body)
 
     @webob.dec.wsgify
     def _post_message(self, req, account, queue, message):
         attributes = self._parse_attributes(req)
         filters = self._parse_filters(req)
-        try:
-            message = self.backend.update_message(account, queue, message,
-                attributes, filters)
-        except burrow.backend.NotFound:
-            return self._response(status=404)
-        return self._response(body=message)
+        body = lambda: self.backend.update_message(account, queue, message,
+            attributes, filters)
+        return self._response(body=body)
 
     @webob.dec.wsgify
     def _put_message(self, req, account, queue, message):
@@ -241,12 +232,17 @@
         return attributes
 
     def _response(self, status=200, body=None, content_type=None):
-        if isinstance(body, types.GeneratorType):
-            try:
+        try:
+            if isinstance(body, types.GeneratorType):
                 body = list(body)
-            except burrow.backend.NotFound:
-                body = None
-                status = 404
+            if isinstance(body, types.FunctionType):
+                body = body()
+        except burrow.backend.InvalidArguments:
+            status = 400
+            body = None
+        except burrow.backend.NotFound:
+            status = 404
+            body = None
         if body == []:
             body = None
         if body is None:
@@ -258,11 +254,17 @@
                 if isinstance(body, list) or isinstance(body, dict):
                     content_type = 'application/json'
                 else:
-                    content_type = "application/octet-stream"
+                    content_type = 'application/octet-stream'
             if content_type == 'application/json':
                 body = json.dumps(body, indent=2)
-        return webob.Response(status=status, body=body,
-            content_type=content_type)
+        response = webob.Response(status=status)
+        if body is not None:
+            response.content_type = content_type
+            if isinstance(body, unicode):
+                response.unicode_body = body
+            else:
+                response.body = body
+        return response
 
 
 class WSGILog(object):

=== added file 'test/backend/test_http.py'
--- test/backend/test_http.py	1970-01-01 00:00:00 +0000
+++ test/backend/test_http.py	2011-08-10 05:42:35 +0000
@@ -0,0 +1,77 @@
+# Copyright (C) 2011 OpenStack LLC.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import atexit
+import ConfigParser
+import os
+import signal
+import time
+
+import burrow.server
+import burrow.backend.http
+import test.backend.test_memory
+
+
+class TestHTTP(test.backend.test_memory.TestMemory):
+    '''Unittests for the HTTP backend.'''
+
+    def setUp(self):
+        config = (ConfigParser.ConfigParser(), 'test')
+        self.backend = burrow.backend.http.Backend(config)
+        self.check_empty()
+
+
+def kill_server():
+    try:
+        pid_file = open('server.pid', 'r')
+        pid = pid_file.read()
+        pid_file.close()
+        try:
+            os.kill(int(pid), signal.SIGUSR1)
+            time.sleep(1)
+            os.kill(int(pid), signal.SIGTERM)
+        except OSError:
+            pass
+        os.unlink('server.pid')
+    except IOError:
+        pass
+
+
+def start_server():
+    pid = os.fork()
+    if pid == 0:
+        try:
+            import coverage
+            cov = coverage.coverage(data_suffix=True)
+            cov.start()
+
+            def save_coverage(signum, frame):
+                cov.save()
+
+            signal.signal(signal.SIGUSR1, save_coverage)
+        except:
+            pass
+        server = burrow.server.Server(add_default_log_handler=False)
+        server.frontends[0].default_ttl = 0
+        server.run()
+        os.exit(0)
+    pid_file = open('server.pid', 'w')
+    pid_file.write(str(pid))
+    pid_file.close()
+    time.sleep(1)
+
+
+kill_server()
+start_server()
+atexit.register(kill_server)

=== modified file 'test/backend/test_memory.py'
--- test/backend/test_memory.py	2011-08-09 22:53:44 +0000
+++ test/backend/test_memory.py	2011-08-10 05:42:35 +0000
@@ -75,7 +75,7 @@
         self.backend.create_message('a', 'q', 'm', 'test')
         filters = dict(detail='bad')
         accounts = self.backend.delete_accounts(filters)
-        self.assertRaises(burrow.backend.BadDetail, list, accounts)
+        self.assertRaises(burrow.backend.InvalidArguments, list, accounts)
         self.assertEquals([], list(self.backend.delete_accounts()))
 
     def test_accounts_delete_marker(self):
@@ -145,7 +145,7 @@
         self.backend.create_message('a', 'q', 'm', 'test')
         filters = dict(detail='bad')
         accounts = self.backend.get_accounts(filters)
-        self.assertRaises(burrow.backend.BadDetail, list, accounts)
+        self.assertRaises(burrow.backend.InvalidArguments, list, accounts)
         self.assertEquals([], list(self.backend.delete_accounts()))
 
     def test_accounts_get_marker(self):
@@ -237,7 +237,7 @@
         self.backend.create_message('a', 'q', 'm', 'test')
         filters = dict(detail='bad')
         queues = self.backend.delete_queues('a', filters)
-        self.assertRaises(burrow.backend.BadDetail, list, queues)
+        self.assertRaises(burrow.backend.InvalidArguments, list, queues)
         self.assertEquals([], list(self.backend.delete_queues('a')))
 
     def test_queues_delete_marker(self):
@@ -307,7 +307,7 @@
         self.backend.create_message('a', 'q', 'm', 'test')
         filters = dict(detail='bad')
         queues = self.backend.get_queues('a', filters)
-        self.assertRaises(burrow.backend.BadDetail, list, queues)
+        self.assertRaises(burrow.backend.InvalidArguments, list, queues)
         self.assertEquals([], list(self.backend.delete_queues('a')))
 
     def test_queues_get_marker(self):
@@ -428,7 +428,7 @@
         self.backend.create_message('a', 'q', 'm', 'test')
         filters = dict(detail='bad')
         messages = self.backend.delete_messages('a', 'q', filters)
-        self.assertRaises(burrow.backend.BadDetail, list, messages)
+        self.assertRaises(burrow.backend.InvalidArguments, list, messages)
         self.assertEquals([], list(self.backend.delete_messages('a', 'q')))
 
     def test_messages_delete_marker(self):
@@ -514,7 +514,7 @@
         self.backend.create_message('a', 'q', 'm', 'test')
         filters = dict(detail='bad')
         messages = self.backend.get_messages('a', 'q', filters)
-        self.assertRaises(burrow.backend.BadDetail, list, messages)
+        self.assertRaises(burrow.backend.InvalidArguments, list, messages)
         self.delete_messages()
 
     def test_messages_get_marker(self):
@@ -618,7 +618,7 @@
         attributes = dict(ttl=100, hide=200)
         filters = dict(detail='bad')
         messages = self.backend.update_messages('a', 'q', attributes, filters)
-        self.assertRaises(burrow.backend.BadDetail, list, messages)
+        self.assertRaises(burrow.backend.InvalidArguments, list, messages)
         self.delete_messages()
 
     def test_messages_update_marker(self):
@@ -752,7 +752,7 @@
     def test_message_delete_detail_bad(self):
         self.backend.create_message('a', 'q', 'm', 'test')
         filters = dict(detail='bad')
-        self.assertRaises(burrow.backend.BadDetail,
+        self.assertRaises(burrow.backend.InvalidArguments,
             self.backend.delete_message, 'a', 'q', 'm', filters)
         self.delete_messages()
 
@@ -794,7 +794,7 @@
     def test_message_get_detail_bad(self):
         self.backend.create_message('a', 'q', 'm', 'test')
         filters = dict(detail='bad')
-        self.assertRaises(burrow.backend.BadDetail,
+        self.assertRaises(burrow.backend.InvalidArguments,
             self.backend.get_message, 'a', 'q', 'm', filters)
         self.delete_messages()
 
@@ -848,27 +848,27 @@
         self.backend.create_message('a', 'q', 'm', 'test')
         attributes = dict(ttl=100, hide=200)
         filters = dict(detail='bad')
-        self.assertRaises(burrow.backend.BadDetail,
+        self.assertRaises(burrow.backend.InvalidArguments,
             self.backend.update_message, 'a', 'q', 'm', attributes, filters)
         self.delete_messages()
 
     def test_message_ttl(self):
         attributes = dict(ttl=1)
         self.backend.create_message('a', 'q', 'm', 'test', attributes)
-        time.sleep(1)
+        time.sleep(2)
         self.backend.clean()
 
     def test_message_ttl_large(self):
         attributes = dict(ttl=1)
         for x in xrange(0, 1000):
             self.backend.create_message('a', 'q', str(x), str(x), attributes)
-        time.sleep(1)
+        time.sleep(2)
         self.backend.clean()
 
     def test_message_hide(self):
         attributes = dict(hide=1)
         self.backend.create_message('a', 'q', 'm', 'test', attributes)
-        time.sleep(1)
+        time.sleep(2)
         self.backend.clean()
         message = self.backend.get_message('a', 'q', 'm')
         self.assertEquals(dict(id='m', ttl=0, hide=0, body='test'), message)
@@ -878,7 +878,7 @@
         attributes = dict(hide=1)
         for x in xrange(0, 1000):
             self.backend.create_message('a', 'q', str(x), str(x), attributes)
-        time.sleep(1)
+        time.sleep(2)
         self.backend.clean()
         message = self.backend.get_message('a', 'q', '0')
         self.assertEquals(dict(id='0', ttl=0, hide=0, body='0'), message)