Merge branch 'feature/adhoc-nuke-test-resource-worker' into develop

vumi/application/tests/test_http_relay.py

@@ -1,11 +1,10 @@
 from base64 import b64decode
 
-from twisted.internet.defer import inlineCallbacks, returnValue
+from twisted.internet.defer import inlineCallbacks
 from twisted.web import http
 
 from vumi.application.tests.utils import ApplicationTestCase
-from vumi.tests.utils import TestResourceWorker, get_stubbed_worker
-from vumi.application.tests.test_http_relay_stubs import TestResource
+from vumi.tests.utils import MockHttpServer
 from vumi.application.http_relay import HTTPRelayApplication
 from vumi.message import TransportEvent
 from vumi.tests.helpers import MessageHelper
@@ -14,7 +13,6 @@
 class HTTPRelayTestCase(ApplicationTestCase):
 
     application_class = HTTPRelayApplication
-    timeout = 1
 
     @inlineCallbacks
     def setUp(self):
@@ -24,35 +22,23 @@ def setUp(self):
 
     @inlineCallbacks
     def setup_resource_with_callback(self, callback):
-        self.resource = yield self.make_resource_worker(callback=callback)
-        self.app = yield self.setup_app(self.path, self.resource)
-
-    @inlineCallbacks
-    def setup_resource(self, code, content, headers):
-        self.resource = yield self.make_resource_worker(code, content,
-                                                        headers)
-        self.app = yield self.setup_app(self.path, self.resource)
-
-    @inlineCallbacks
-    def setup_app(self, path, resource):
-        app = yield self.get_application({
-            'url': 'http://localhost:%s%s' % (
-                resource.port,
-                path),
+        self.mock_server = MockHttpServer(callback)
+        self.addCleanup(self.mock_server.stop)
+        yield self.mock_server.start()
+        self.app = yield self.get_application({
+            'url': '%s%s' % (self.mock_server.url, self.path),
             'username': 'username',
             'password': 'password',
         })
-        returnValue(app)
 
-    @inlineCallbacks
-    def make_resource_worker(self, code=http.OK, content='',
-                                headers={}, callback=None):
-        w = get_stubbed_worker(TestResourceWorker, {})
-        w.set_resources([
-                (self.path, TestResource, (code, content, headers, callback))])
-        self._workers.append(w)
-        yield w.startWorker()
-        returnValue(w)
+    def setup_resource(self, code, content, headers):
+        def handler(request):
+            request.setResponseCode(code)
+            for key, value in headers.items():
+                request.setHeader(key, value)
+            return content
+
+        return self.setup_resource_with_callback(handler)
 
     @inlineCallbacks
     def test_http_relay_success_with_no_reply(self):

vumi/application/tests/test_rapidsms_relay.py

@@ -2,28 +2,17 @@
 
 import json
 
-from twisted.internet.defer import inlineCallbacks, returnValue
+from twisted.internet.defer import inlineCallbacks
 from twisted.web import http
-from twisted.web.resource import Resource
 
 from vumi.application.tests.test_base import ApplicationTestCase
-from vumi.tests.utils import TestResourceWorker, LogCatcher, get_stubbed_worker
+from vumi.tests.utils import LogCatcher, MockHttpServer
 from vumi.application.rapidsms_relay import RapidSMSRelay, BadRequestError
 from vumi.utils import http_request_full, basic_auth_string, to_kwargs
 from vumi.message import TransportUserMessage, from_json
 from vumi.tests.helpers import MessageHelper
 
 
-class DummyRapidResource(Resource):
-    isLeaf = True
-
-    def __init__(self, callback):
-        self.callback = callback
-
-    def render_POST(self, request):
-        return self.callback(request)
-
-
 class RapidSMSRelayTestCase(ApplicationTestCase):
 
     application_class = RapidSMSRelay
@@ -38,30 +27,23 @@ def setUp(self):
     def setup_resource(self, callback=None, auth=None):
         if callback is None:
             callback = lambda r: self.fail("No RapidSMS requests expected.")
-        self.resource = yield self.setup_dummy_rapidsms(callback=callback)
-        self.app = yield self.setup_app(self.path, self.resource, auth=auth)
+        self.mock_server = MockHttpServer(callback)
+        self.addCleanup(self.mock_server.stop)
+        yield self.mock_server.start()
+        url = '%s%s' % (self.mock_server.url, self.path)
+        self.app = yield self.setup_app(url, auth=auth)
 
-    @inlineCallbacks
-    def setup_app(self, path, resource, auth=None):
+    def setup_app(self, url, auth=None):
         vumi_username, vumi_password = auth if auth else (None, None)
-        app = yield self.get_application({
-            'rapidsms_url': 'http://localhost:%s%s' % (resource.port, path),
+        return self.get_application({
+            'rapidsms_url': url,
             'web_path': '/send/',
             'web_port': '0',
             'rapidsms_username': 'username',
             'rapidsms_password': 'password',
             'vumi_username': vumi_username,
             'vumi_password': vumi_password,
         })
-        returnValue(app)
-
-    @inlineCallbacks
-    def setup_dummy_rapidsms(self, callback):
-        w = get_stubbed_worker(TestResourceWorker, {})
-        w.set_resources([(self.path, DummyRapidResource, (callback,))])
-        self._workers.append(w)
-        yield w.startWorker()
-        returnValue(w)
 
     def get_response_msgs(self, response):
         payloads = from_json(response.delivered_body)

vumi/tests/utils.py

@@ -89,23 +89,6 @@ def get_stubbed_channel(broker=None, id=0):
     return amq_client.channel(id)
 
 
-class TestResourceWorker(Worker):
-    port = 9999
-    _resources = ()
-
-    def set_resources(self, resources):
-        self._resources = resources
-
-    def startWorker(self):
-        resources = [(cls(*args), path) for path, cls, args in self._resources]
-        self.resources = self.start_web_resources(resources, self.port)
-        return defer.succeed(None)
-
-    def stopWorker(self):
-        if self.resources:
-            self.resources.stopListening()
-
-
 def FakeRedis():
     warnings.warn("Use of FakeRedis is deprecated. "
                   "Use persist.tests.fake_redis instead.",

vumi/transports/vas2nets/tests/test_failures.py

@@ -2,38 +2,20 @@
 from datetime import datetime
 
 from twisted.web import http
-from twisted.web.resource import Resource
 from twisted.trial import unittest
 from twisted.internet.defer import inlineCallbacks, returnValue, Deferred
 
 from vumi.message import from_json
 from vumi.tests.utils import (
-    get_stubbed_worker, TestResourceWorker, PersistenceMixin)
+    PersistenceMixin, get_stubbed_worker, MockHttpServer)
 from vumi.tests.fake_amqp import FakeAMQPBroker
-from vumi.transports.failures import (FailureMessage, FailureWorker,
-                                      TemporaryFailure)
-from vumi.transports.vas2nets.vas2nets import (Vas2NetsTransport,
-                                               Vas2NetsTransportError)
+from vumi.transports.failures import (
+    FailureMessage, FailureWorker, TemporaryFailure)
+from vumi.transports.vas2nets.vas2nets import (
+    Vas2NetsTransport, Vas2NetsTransportError)
 from vumi.tests.helpers import MessageHelper
 
 
-class BadVas2NetsResource(Resource):
-    isLeaf = True
-
-    def __init__(self, body, headers=None, code=http.OK):
-        self.body = body
-        self.code = code
-        if headers is None:
-            headers = {'X-Nth-Smsid': 'message_id'}
-        self.headers = headers
-
-    def render_POST(self, request):
-        request.setResponseCode(self.code)
-        for k, v in self.headers.items():
-            request.setHeader(k, v)
-        return self.body
-
-
 class FailureCounter(object):
     def __init__(self, count):
         self.count = count
@@ -54,19 +36,17 @@ class Vas2NetsFailureWorkerTestCase(unittest.TestCase, PersistenceMixin):
     def setUp(self):
         self._persist_setUp()
         self.today = datetime.utcnow().date()
-        self.port = 9999
-        self.path = '/api/v1/sms/vas2nets/receive/'
         self.config = self.mk_config({
             'transport_name': 'vas2nets',
-            'url': 'http://localhost:%s%s' % (self.port, self.path),
+            'url': None,
             'username': 'username',
             'password': 'password',
             'owner': 'owner',
             'service': 'service',
             'subservice': 'subservice',
             'web_receive_path': '/receive',
             'web_receipt_path': '/receipt',
-            'web_port': 9998,
+            'web_port': 0,
         })
         self.fail_config = self.mk_config({
             'transport_name': 'vas2nets',
@@ -104,13 +84,20 @@ def mk_failure_worker(self, config, broker):
         returnValue(w)
 
     @inlineCallbacks
-    def mk_resource_worker(self, body, headers=None, code=http.OK):
-        w = get_stubbed_worker(TestResourceWorker, {}, self.broker)
-        self.workers.append(w)
-        w.set_resources([(self.path, BadVas2NetsResource,
-                          (body, headers, code))])
-        yield w.startWorker()
-        returnValue(w)
+    def mk_mock_server(self, body, headers=None, code=http.OK):
+        if headers is None:
+            headers = {'X-Nth-Smsid': 'message_id'}
+
+        def handler(request):
+            request.setResponseCode(code)
+            for k, v in headers.items():
+                request.setHeader(k, v)
+            return body
+
+        self.mock_server = MockHttpServer(handler)
+        self.addCleanup(self.mock_server.stop)
+        yield self.mock_server.start()
+        self.worker.config['url'] = self.mock_server.url
 
     def get_dispatched(self, rkey):
         return self.broker.get_dispatched('vumi', rkey)
@@ -133,7 +120,7 @@ def assert_dispatched_count(self, count, routing_key):
 
     @inlineCallbacks
     def test_send_sms_success(self):
-        yield self.mk_resource_worker("Result_code: 00, Message OK")
+        yield self.mk_mock_server("Result_code: 00, Message OK")
         yield self.worker._process_message(self.make_outbound("outbound"))
         self.assert_dispatched_count(1, 'vas2nets.event')
         self.assert_dispatched_count(0, 'vas2nets.failures')
@@ -144,7 +131,7 @@ def test_send_sms_fail(self):
         A 'No SmsId Header' error should not be retried.
         """
         self.worker.failure_published = FailureCounter(1)
-        yield self.mk_resource_worker("Result_code: 04, Internal system error "
+        yield self.mk_mock_server("Result_code: 04, Internal system error "
                                       "occurred while processing message",
                                       {})
         yield self.worker._process_message(self.make_outbound("outbound"))
@@ -176,6 +163,10 @@ def test_send_sms_noconn(self):
         """
         A 'connection refused' error should be retried.
         """
+        # TODO: Figure out a solution that doesn't require hoping that
+        #       nothing's listening on this port.
+        self.worker.config['url'] = 'http://localhost:9999/'
+
         self.worker.failure_published = FailureCounter(1)
         msg = self.make_outbound("outbound")
         yield self.worker._process_message(msg)