Merge lp:~canonical-ci-engineering/adt-request-proxy/trunk-additional-testing into lp:adt-request-proxy

[Thomi Richards]

Add some more tests for the adt-request-proxy service.

Add some more tests for the adt-request-proxy service.

[lp:~canonical-ci-engineering/adt-request-proxy/trunk-additional-testing]

5. By Thomi Richards on 2015-03-11

Remove unused import.

[Celso Providelo (cprov)]

Cool, Thomi, specially the "memory://" magic kombu URI ;)

review: Approve

=== modified file 'adt_request_proxy/__init__.py'
--- adt_request_proxy/__init__.py	2015-03-10 20:41:29 +0000
+++ adt_request_proxy/__init__.py	2015-03-11 01:37:05 +0000
@@ -26,7 +26,7 @@
 from adt_request_proxy import errors
 from adt_request_proxy.queue import RabbitQueuer
 
-def create_flask_app():
+def create_flask_app(config):
     app = flask.Flask('adt_cloud_worker')
 
     app.add_url_rule(
@@ -42,6 +42,8 @@
         response.status_code = error.status
         return response
 
+    app.extensions['rabbit'] = RabbitQueuer(config)
+    app.config['SWIFT_URL'] = config['swift']['public_url']
     return app
 
 
@@ -53,15 +55,14 @@
     parser.add_argument('-c', '--conf', default='.adt-service.conf',
                         help='Configuration file path')
     args = parser.parse_args()
-
-
-    app = create_flask_app()
-
     # Load configuration options & create queuer
     config = configparser.ConfigParser()
     config.read(args.conf)
-    app.extensions['rabbit'] = RabbitQueuer(config)
-    app.config['SWIFT_URL'] = config['swift']['public_url']
+
+
+    app = create_flask_app(config)
+
+
 
     app.run()
 
 
=== modified file 'adt_request_proxy/queue.py'
--- adt_request_proxy/queue.py	2015-03-09 03:29:34 +0000
+++ adt_request_proxy/queue.py	2015-03-11 01:37:05 +0000
@@ -26,14 +26,12 @@
     """A class that can send things to the rabbit queue. An instance of this
     is stored in 'flask.g'.
 
-    TODO: This code can almost certainly be improved - for example, maybe
-        don't create a new connection every time we queue something?
-
     """
 
     def __init__(self, config):
-        self.amqp_uris = config.get('amqp', 'uris').split()
+        self.amqp_uris = config['amqp']['uris'].split()
         self.adt_exchange = kombu.Exchange("adt.exchange", type="topic")
+        self.connection = kombu.Connection(self.amqp_uris)
 
     def queue_test(self, payload):
         """Take 'payload' and enqueue it on the rabbit queue.
@@ -47,7 +45,8 @@
         On error, an exception will be raised.
 
         """
-        routing_key = payload['arch'] + '.' + payload['platform']
+        payload_copy = payload.copy()
+        routing_key = payload_copy['arch'] + '.' + payload_copy['platform']
         queue = kombu.Queue(
             'adt.requests.{}'.format(routing_key),
             self.adt_exchange, routing_key=routing_key)
@@ -56,10 +55,9 @@
         # available works the request is preserved.
         declare = [self.adt_exchange, queue]
 
-        connection = kombu.Connection(self.amqp_uris)
-        payload['request_id'] = uuid()
+        payload_copy['request_id'] = uuid()
 
-        with producers[connection].acquire(block=True) as producer:
+        with producers[self.connection].acquire(block=True) as producer:
 
             def errback(exc, interval):
                 # TODO: This should raise an exception if something goes wrong.
@@ -69,12 +67,12 @@
                 logger.error('Error: %r', exc, exc_info=1)
                 logger.info('Retry in %s seconds.', interval)
 
-            publish = connection.ensure(
+            publish = self.connection.ensure(
                 producer, producer.publish,
                 errback=errback, max_retries=3)
             publish(
-                payload,
+                payload_copy,
                 exchange=self.adt_exchange,
                 routing_key=routing_key,
                 declare=declare)
-        return payload['request_id']
+        return payload_copy['request_id']
 
=== modified file 'adt_request_proxy/tests/test_functional.py'
--- adt_request_proxy/tests/test_functional.py	2015-03-10 20:41:29 +0000
+++ adt_request_proxy/tests/test_functional.py	2015-03-11 01:37:05 +0000
@@ -17,13 +17,22 @@
 
 """Full-stack functional tests for the web application."""
 
+import json
+import uuid
+
+import kombu
 import testtools
-from testtools.matchers import Equals
+from testtools.matchers import (
+    Contains,
+    Equals,
+    HasLength,
+)
 
 import adt_request_proxy
-
-
-class FunctionalWebAppTests(testtools.TestCase):
+from adt_request_proxy.queue import RabbitQueuer
+
+
+class RequestProxyTestBase(testtools.TestCase):
 
     """A suite of functional tests for the web app.
 
@@ -40,10 +49,26 @@
 
     def setUp(self):
         super().setUp()
-        self.server_app = adt_request_proxy.create_flask_app()
+        test_config = {
+            'swift': {
+                'public_url': 'http://swift.test.com',
+            },
+            'amqp': {
+                'uris': 'memory://'
+            },
+        }
+        self.server_app = adt_request_proxy.create_flask_app(test_config)
         self.server_app.config['TESTING'] = True
         self.client = self.server_app.test_client()
 
+
+class WebEndpointTests(RequestProxyTestBase):
+
+    def set_queuer_double(self):
+        """Create and install the QueuerDouble, returning an instance of it."""
+        instance = self.server_app.extensions['rabbit'] = QueuerDouble()
+        return instance
+
     def assertEndpointDisallowsMethods(self, endpoint, methods):
         for method in methods:
             fn = getattr(self.client, method.lower(), None)
@@ -59,4 +84,105 @@
             ['GET', 'PATCH', 'DELETE']
         )
 
-    # TODO: add more tests here ;)
+    def test_missing_args_causes_400_error(self):
+        q = self.set_queuer_double()
+        resp = self.client.post('/v1/test')
+
+        self.assertThat(resp.status_code, Equals(400))
+        self.assertThat(q.queued_payloads, HasLength(0))
+
+    def test_can_queue_test_with_all_parameters_present(self):
+        """Test that we can enqueue test payloads, and that the response we
+        get is sensible.
+
+        This should perhaps be broken down into smaller tests if it grows
+        much more.
+
+        """
+        q = self.set_queuer_double()
+        resp = self.client.post(
+            '/v1/test',
+            data = {
+                'package-name': 'librepng',
+                'architecture': 'i386',
+                'platform': 'nova',
+            }
+        )
+        self.assertThat(resp.status_code, Equals(200))
+        self.assertThat(q.queued_payloads, HasLength(1))
+        self.assertThat(resp.mimetype, Equals("application/json"))
+        data = json.loads(resp.data.decode())
+        self.assertThat(
+            data['result_url'],
+            Equals('http://swift.test.com/{}/results.tgz'.format(
+                q.generated_uuids[0]
+            ))
+        )
+
+
+class QueuerDouble(object):
+
+    """A test double for adt_request_proxy.queue.RabbitQueuer.
+
+    Simply adds queued payloads to a list, and implements methods to make
+    assertions on the queued payloads.
+
+    """
+
+    def __init__(self):
+        self.queued_payloads = []
+        self.generated_uuids = []
+
+    def queue_test(self, payload):
+        request_id = str(uuid.uuid1())
+        payload['request_id'] = request_id
+        self.queued_payloads.append(payload)
+        self.generated_uuids.append(request_id)
+        return payload['request_id']
+
+
+class QueuerTests(RequestProxyTestBase):
+
+    """Tests for the rabbit queue class.
+
+    The RabbitQueuer is highly stateful, so it's almost impossible to test with
+    unit tests.
+
+    What we can do, which is a reasonable half-measure is to configure the
+    queuer class with an in-memory transport, and attempt to rigerously test the
+    interface between the queuer and it's caller.
+
+    """
+    def test_queueing_does_not_alter_payload(self):
+        q = RabbitQueuer(dict(amqp=dict(uris='memory://')))
+
+        test_payload = {
+            'package_name': 'librepng',
+            'arch': 'amd64',
+            'platform': 'nova',
+            'nova_image': 'some-nova-image',
+        }
+        copy_payload = test_payload.copy()
+        request_id = q.queue_test(copy_payload)
+        self.assertEqual(test_payload, copy_payload)
+
+    def test_attempt_queue_test(self):
+        q = RabbitQueuer(dict(amqp=dict(uris='memory://')))
+
+        test_payload = {
+            'package_name': 'librepng',
+            'arch': 'amd64',
+            'platform': 'nova',
+            'nova_image': 'some-nova-image',
+        }
+        request_id = q.queue_test(test_payload)
+
+        # make sure the message got on the channel:
+        conn = kombu.Connection("memory://")
+        consumer_queue = conn.SimpleQueue("adt.requests.amd64.nova")
+        message = consumer_queue.get(timeout=10.0)
+        message.ack()
+
+        # message must have request_id set:
+        test_payload['request_id'] = request_id
+        self.assertEqual(test_payload, message.payload)