Convert signal tests to pytest usage

aiohttp/signals.py

@@ -1,28 +1,71 @@
 import asyncio
+from itertools import count
 
 
-class Signal(list):
-    """
-    Coroutine-based signal implementation
+class BaseSignal(list):
+
+    @asyncio.coroutine
+    def _send(self, *args, **kwargs):
+        for receiver in self:
+            res = receiver(*args, **kwargs)
+            if asyncio.iscoroutine(res) or isinstance(res, asyncio.Future):
+                yield from res
+
+    def copy(self):
+        raise NotImplementedError("copy() is forbidden")
+
+    def sort(self):
+        raise NotImplementedError("sort() is forbidden")
+
+
+class Signal(BaseSignal):
+    """Coroutine-based signal implementation.
 
     To connect a callback to a signal, use any list method.
 
     Signals are fired using the :meth:`send` coroutine, which takes named
     arguments.
     """
 
+    def __init__(self, app):
+        super().__init__()
+        self._app = app
+        klass = self.__class__
+        self._name = klass.__module__ + ':' + klass.__qualname__
+        self._pre = app.on_pre_signal
+        self._post = app.on_post_signal
+
     @asyncio.coroutine
     def send(self, *args, **kwargs):
         """
         Sends data to all registered receivers.
         """
-        for receiver in self:
-            res = receiver(*args, **kwargs)
-            if asyncio.iscoroutine(res) or isinstance(res, asyncio.Future):
-                yield from res
+        ordinal = None
+        debug = self._app._debug
+        if debug:
+            ordinal = self._pre.ordinal()
+            yield from self._pre.send(ordinal, self._name, *args, **kwargs)
+        yield from self._send(*args, **kwargs)
+        if debug:
+            yield from self._post.send(ordinal, self._name, *args, **kwargs)
 
-    def copy(self):
-        raise NotImplementedError("copy() is forbidden")
 
-    def sort(self):
-        raise NotImplementedError("sort() is forbidden")
+class DebugSignal(BaseSignal):
+
+    @asyncio.coroutine
+    def send(self, ordinal, name, *args, **kwargs):
+        yield from self._send(ordinal, name, *args, **kwargs)
+
+
+class PreSignal(DebugSignal):
+
+    def __init__(self):
+        super().__init__()
+        self._counter = count(1)
+
+    def ordinal(self):
+        return next(self._counter)
+
+
+class PostSignal(DebugSignal):
+    pass

aiohttp/web.py

@@ -7,7 +7,7 @@
 from .web_urldispatcher import *  # noqa
 from .web_ws import *  # noqa
 from .protocol import HttpVersion  # noqa
-from .signals import Signal
+from .signals import Signal, PreSignal, PostSignal
 
 
 import asyncio
@@ -180,13 +180,14 @@ class Application(dict):
 
     def __init__(self, *, logger=web_logger, loop=None,
                  router=None, handler_factory=RequestHandlerFactory,
-                 middlewares=()):
+                 middlewares=(), debug=False):
         if loop is None:
             loop = asyncio.get_event_loop()
         if router is None:
             router = UrlDispatcher()
         assert isinstance(router, AbstractRouter), router
 
+        self._debug = debug
         self._router = router
         self._handler_factory = handler_factory
         self._finish_callbacks = []
@@ -197,12 +198,26 @@ def __init__(self, *, logger=web_logger, loop=None,
             assert asyncio.iscoroutinefunction(factory), factory
         self._middlewares = list(middlewares)
 
-        self._on_response_prepare = Signal()
+        self._on_pre_signal = PreSignal()
+        self._on_post_signal = PostSignal()
+        self._on_response_prepare = Signal(self)
+
+    @property
+    def debug(self):
+        return self._debug
 
     @property
     def on_response_prepare(self):
         return self._on_response_prepare
 
+    @property
+    def on_pre_signal(self):
+        return self._on_pre_signal
+
+    @property
+    def on_post_signal(self):
+        return self._on_post_signal
+
     @property
     def router(self):
         return self._router

tests/test_signals.py

@@ -1,5 +1,4 @@
 import asyncio
-import unittest
 from unittest import mock
 from aiohttp.multidict import CIMultiDict
 from aiohttp.signals import Signal
@@ -8,101 +7,106 @@
 from aiohttp.protocol import HttpVersion11
 from aiohttp.protocol import RawRequestMessage
 
+import pytest
 
-class TestSignals(unittest.TestCase):
-    def setUp(self):
-        self.loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(None)
 
-    def tearDown(self):
-        self.loop.close()
+@pytest.fixture
+def app(loop):
+    return Application(loop=loop)
 
-    def make_request(self, method, path, headers=CIMultiDict(), app=None):
-        message = RawRequestMessage(method, path, HttpVersion11, headers,
-                                    False, False)
-        return self.request_from_message(message, app)
 
-    def request_from_message(self, message, app=None):
-        self.app = app if app is not None else mock.Mock()
-        self.payload = mock.Mock()
-        self.transport = mock.Mock()
-        self.reader = mock.Mock()
-        self.writer = mock.Mock()
-        req = Request(self.app, message, self.payload,
-                      self.transport, self.reader, self.writer)
-        return req
+def make_request(app, method, path, headers=CIMultiDict()):
+    message = RawRequestMessage(method, path, HttpVersion11, headers,
+                                False, False)
+    return request_from_message(message, app)
 
-    def test_add_response_prepare_signal_handler(self):
-        callback = asyncio.coroutine(lambda request, response: None)
-        app = Application(loop=self.loop)
-        app.on_response_prepare.append(callback)
 
-    def test_add_signal_handler_not_a_callable(self):
-        callback = True
-        app = Application(loop=self.loop)
-        app.on_response_prepare.append(callback)
-        with self.assertRaises(TypeError):
-            app.on_response_prepare(None, None)
+def request_from_message(message, app):
+    payload = mock.Mock()
+    transport = mock.Mock()
+    reader = mock.Mock()
+    writer = mock.Mock()
+    req = Request(app, message, payload,
+                  transport, reader, writer)
+    return req
 
-    def test_function_signal_dispatch(self):
-        signal = Signal()
-        kwargs = {'foo': 1, 'bar': 2}
 
-        callback_mock = mock.Mock()
-        callback = asyncio.coroutine(callback_mock)
+def test_add_response_prepare_signal_handler(loop, app):
+    callback = asyncio.coroutine(lambda request, response: None)
+    app.on_response_prepare.append(callback)
 
-        signal.append(callback)
 
-        self.loop.run_until_complete(signal.send(**kwargs))
-        callback_mock.assert_called_once_with(**kwargs)
+def test_add_signal_handler_not_a_callable(loop, app):
+    callback = True
+    app.on_response_prepare.append(callback)
+    with pytest.raises(TypeError):
+        app.on_response_prepare(None, None)
 
-    def test_function_signal_dispatch2(self):
-        signal = Signal()
-        args = {'a', 'b'}
-        kwargs = {'foo': 1, 'bar': 2}
 
-        callback_mock = mock.Mock()
-        callback = asyncio.coroutine(callback_mock)
+def test_function_signal_dispatch(loop, app):
+    signal = Signal(app)
+    kwargs = {'foo': 1, 'bar': 2}
 
-        signal.append(callback)
+    callback_mock = mock.Mock()
+    callback = asyncio.coroutine(callback_mock)
 
-        self.loop.run_until_complete(signal.send(*args, **kwargs))
-        callback_mock.assert_called_once_with(*args, **kwargs)
+    signal.append(callback)
 
-    def test_response_prepare(self):
-        callback = mock.Mock()
+    loop.run_until_complete(signal.send(**kwargs))
+    callback_mock.assert_called_once_with(**kwargs)
 
-        app = Application(loop=self.loop)
-        app.on_response_prepare.append(asyncio.coroutine(callback))
 
-        request = self.make_request('GET', '/', app=app)
-        response = Response(body=b'')
-        self.loop.run_until_complete(response.prepare(request))
+def test_function_signal_dispatch2(loop, app):
+    signal = Signal(app)
+    args = {'a', 'b'}
+    kwargs = {'foo': 1, 'bar': 2}
 
-        callback.assert_called_once_with(request=request,
-                                         response=response)
+    callback_mock = mock.Mock()
+    callback = asyncio.coroutine(callback_mock)
 
-    def test_non_coroutine(self):
-        signal = Signal()
-        kwargs = {'foo': 1, 'bar': 2}
+    signal.append(callback)
 
-        callback = mock.Mock()
+    loop.run_until_complete(signal.send(*args, **kwargs))
+    callback_mock.assert_called_once_with(*args, **kwargs)
 
-        signal.append(callback)
 
-        self.loop.run_until_complete(signal.send(**kwargs))
-        callback.assert_called_once_with(**kwargs)
+def test_response_prepare(loop, app):
+    callback = mock.Mock()
 
-    def test_copy_forbidden(self):
-        signal = Signal()
-        with self.assertRaises(NotImplementedError):
-            signal.copy()
+    app.on_response_prepare.append(asyncio.coroutine(callback))
 
-    def test_sort_forbidden(self):
-        l1 = lambda: None
-        l2 = lambda: None
-        l3 = lambda: None
-        signal = Signal([l1, l2, l3])
-        with self.assertRaises(NotImplementedError):
-            signal.sort()
-        self.assertEqual(signal, [l1, l2, l3])
+    request = make_request(app, 'GET', '/')
+    response = Response(body=b'')
+    loop.run_until_complete(response.prepare(request))
+
+    callback.assert_called_once_with(request=request,
+                                     response=response)
+
+
+def test_non_coroutine(loop, app):
+    signal = Signal(app)
+    kwargs = {'foo': 1, 'bar': 2}
+
+    callback = mock.Mock()
+
+    signal.append(callback)
+
+    loop.run_until_complete(signal.send(**kwargs))
+    callback.assert_called_once_with(**kwargs)
+
+
+def test_copy_forbidden(app):
+    signal = Signal(app)
+    with pytest.raises(NotImplementedError):
+        signal.copy()
+
+
+def test_sort_forbidden(app):
+    l1 = lambda: None
+    l2 = lambda: None
+    l3 = lambda: None
+    signal = Signal(app)
+    signal.extend([l1, l2, l3])
+    with pytest.raises(NotImplementedError):
+        signal.sort()
+    assert signal == [l1, l2, l3]

tests/test_web_exceptions.py

@@ -32,7 +32,8 @@ def append(self, data):
 
     def make_request(self, method='GET', path='/', headers=CIMultiDict()):
         self.app = mock.Mock()
-        self.app.on_response_prepare = signals.Signal()
+        self.app._debug = False
+        self.app.on_response_prepare = signals.Signal(self.app)
         message = RawRequestMessage(method, path, HttpVersion11, headers,
                                     False, False)
         req = Request(self.app, message, self.payload,

tests/test_web_request.py

@@ -24,7 +24,8 @@ def make_request(self, method, path, headers=CIMultiDict(), *,
         if version < HttpVersion(1, 1):
             closing = True
         self.app = mock.Mock()
-        self.app.on_response_prepare = Signal()
+        self.app._debug = False
+        self.app.on_response_prepare = Signal(self.app)
         message = RawRequestMessage(method, path, version, headers, closing,
                                     False)
         self.payload = mock.Mock()

tests/test_web_response.py

@@ -26,7 +26,8 @@ def make_request(self, method, path, headers=CIMultiDict(),
 
     def request_from_message(self, message):
         self.app = mock.Mock()
-        self.app.on_response_prepare = signals.Signal()
+        self.app._debug = False
+        self.app.on_response_prepare = signals.Signal(self.app)
         self.payload = mock.Mock()
         self.transport = mock.Mock()
         self.reader = mock.Mock()
@@ -537,7 +538,8 @@ def tearDown(self):
 
     def make_request(self, method, path, headers=CIMultiDict()):
         self.app = mock.Mock()
-        self.app.on_response_prepare = signals.Signal()
+        self.app._debug = False
+        self.app.on_response_prepare = signals.Signal(self.app)
         message = RawRequestMessage(method, path, HttpVersion11, headers,
                                     False, False)
         self.payload = mock.Mock()

tests/test_web_websocket.py

@@ -19,6 +19,7 @@ def tearDown(self):
 
     def make_request(self, method, path, headers=None, protocols=False):
         self.app = mock.Mock()
+        self.app._debug = False
         if headers is None:
             headers = CIMultiDict(
                 {'HOST': 'server.example.com',
@@ -37,7 +38,7 @@ def make_request(self, method, path, headers=None, protocols=False):
         self.reader = mock.Mock()
         self.writer = mock.Mock()
         self.app.loop = self.loop
-        self.app.on_response_prepare = signals.Signal()
+        self.app.on_response_prepare = signals.Signal(self.app)
         req = Request(self.app, message, self.payload,
                       self.transport, self.reader, self.writer)
         return req