Merge pull request #1146 from yunstanford/upgrade-test-client

Upgrade test client

sanic/testing.py

@@ -1,7 +1,9 @@
 import traceback
 from json import JSONDecodeError
-
 from sanic.log import logger
+from sanic.exceptions import MethodNotSupported
+from sanic.response import text
+
 
 HOST = '127.0.0.1'
 PORT = 42101
@@ -54,6 +56,15 @@ class SanicTestClient:
                     results[0] = request
             self.app.request_middleware.appendleft(_collect_request)
 
+        @self.app.exception(MethodNotSupported)
+        async def error_handler(request, exception):
+            if request.method in ['HEAD', 'PATCH', 'PUT', 'DELETE']:
+                return text(
+                    '', exception.status_code, headers=exception.headers
+                )
+            else:
+                return self.app.error_handler.default(request, exception)
+
         @self.app.listener('after_server_start')
         async def _collect_response(sanic, loop):
             try:

tests/test_keep_alive_timeout.py

@@ -15,17 +15,30 @@ class ReuseableTCPConnector(TCPConnector):
         super(ReuseableTCPConnector, self).__init__(*args, **kwargs)
         self.old_proto = None
 
-    @asyncio.coroutine
+    if aiohttp.__version__ >= '3.0':
-    def connect(self, req):
+
-        new_conn = yield from super(ReuseableTCPConnector, self)\
+        async def connect(self, req, traces=None):
-                                                         .connect(req)
+            new_conn = await super(ReuseableTCPConnector, self)\
-        if self.old_proto is not None:
+                                    .connect(req, traces=traces)
-            if self.old_proto != new_conn._protocol:
+            if self.old_proto is not None:
-                raise RuntimeError(
+                if self.old_proto != new_conn._protocol:
-                    "We got a new connection, wanted the same one!")
+                    raise RuntimeError(
-        print(new_conn.__dict__)
+                        "We got a new connection, wanted the same one!")
-        self.old_proto = new_conn._protocol
+            print(new_conn.__dict__)
-        return new_conn
+            self.old_proto = new_conn._protocol
+            return new_conn
+    else:
+
+        async def connect(self, req):
+            new_conn = await super(ReuseableTCPConnector, self)\
+                                    .connect(req)
+            if self.old_proto is not None:
+                if self.old_proto != new_conn._protocol:
+                    raise RuntimeError(
+                        "We got a new connection, wanted the same one!")
+            print(new_conn.__dict__)
+            self.old_proto = new_conn._protocol
+            return new_conn
 
 
 class ReuseableSanicTestClient(SanicTestClient):
@@ -168,7 +181,7 @@ class ReuseableSanicTestClient(SanicTestClient):
 
             response.body = await response.read()
         if do_kill_session:
-            session.close()
+            await session.close()
             self._session = None
         return response
 

tests/test_request_timeout.py

@@ -28,19 +28,18 @@ class DelayableTCPConnector(TCPConnector):
             acting_as = self._acting_as
             return getattr(acting_as, item)
 
-        @asyncio.coroutine
+        async def start(self, connection, read_until_eof=False):
-        def start(self, connection, read_until_eof=False):
             if self.send_task is None:
                 raise RuntimeError("do a send() before you do a start()")
-            resp = yield from self.send_task
+            resp = await self.send_task
             self.send_task = None
             self.resp = resp
             self._acting_as = self.resp
             self.orig_start = getattr(resp, 'start')
 
             try:
-                ret = yield from self.orig_start(connection,
+                ret = await self.orig_start(connection,
-                                                 read_until_eof)
+                                            read_until_eof)
             except Exception as e:
                 raise e
             return ret
@@ -51,12 +50,11 @@ class DelayableTCPConnector(TCPConnector):
             if self.send_task is not None:
                 self.send_task.cancel()
 
-        @asyncio.coroutine
+        async def delayed_send(self, *args, **kwargs):
-        def delayed_send(self, *args, **kwargs):
             req = self.req
             if self.delay and self.delay > 0:
                 #sync_sleep(self.delay)
-                _ = yield from asyncio.sleep(self.delay)
+                await asyncio.sleep(self.delay)
             t = req.loop.time()
             print("sending at {}".format(t), flush=True)
             conn = next(iter(args)) # first arg is connection
@@ -80,18 +78,32 @@ class DelayableTCPConnector(TCPConnector):
         self._post_connect_delay = _post_connect_delay
         self._pre_request_delay = _pre_request_delay
 
-    @asyncio.coroutine
+    if aiohttp.__version__ >= '3.0':
-    def connect(self, req):
+
-        d_req = DelayableTCPConnector.\
+        async def connect(self, req, traces=None):
-            RequestContextManager(req, self._pre_request_delay)
+            d_req = DelayableTCPConnector.\
-        conn = yield from super(DelayableTCPConnector, self).connect(req)
+                RequestContextManager(req, self._pre_request_delay)
-        if self._post_connect_delay and self._post_connect_delay > 0:
+            conn = await super(DelayableTCPConnector, self).connect(req, traces=traces)
-            _ = yield from asyncio.sleep(self._post_connect_delay,
+            if self._post_connect_delay and self._post_connect_delay > 0:
-                                         loop=self._loop)
+                await asyncio.sleep(self._post_connect_delay,
-        req.send = d_req.send
+                                    loop=self._loop)
-        t = req.loop.time()
+            req.send = d_req.send
-        print("Connected at {}".format(t), flush=True)
+            t = req.loop.time()
-        return conn
+            print("Connected at {}".format(t), flush=True)
+            return conn
+    else:
+
+        async def connect(self, req):
+            d_req = DelayableTCPConnector.\
+                RequestContextManager(req, self._pre_request_delay)
+            conn = await super(DelayableTCPConnector, self).connect(req)
+            if self._post_connect_delay and self._post_connect_delay > 0:
+                await asyncio.sleep(self._post_connect_delay,
+                                   loop=self._loop)
+            req.send = d_req.send
+            t = req.loop.time()
+            print("Connected at {}".format(t), flush=True)
+            return conn
 
 
 class DelayableSanicTestClient(SanicTestClient):

tests/test_response.py

@@ -45,6 +45,10 @@ def test_method_not_allowed():
     request, response = app.test_client.head('/')
     assert response.headers['Allow'] == 'GET'
 
+    request, response = app.test_client.post('/')
+    assert response.headers['Allow'] == 'GET'
+
+
     @app.post('/')
     async def test(request):
         return response.json({'hello': 'world'})
@@ -54,6 +58,11 @@ def test_method_not_allowed():
     assert set(response.headers['Allow'].split(', ')) == set(['GET', 'POST'])
     assert response.headers['Content-Length'] == '0'
 
+    request, response = app.test_client.patch('/')
+    assert response.status == 405
+    assert set(response.headers['Allow'].split(', ')) == set(['GET', 'POST'])
+    assert response.headers['Content-Length'] == '0'
+
 
 @pytest.fixture
 def json_app():

tox.ini

@@ -13,7 +13,7 @@ deps =
     pytest-sanic
     pytest-sugar
     pytest-xdist
-    aiohttp==1.3.5
+    aiohttp>=2.3
     chardet<=2.3.0
     beautifulsoup4
     gunicorn