Merge pull request #1335 from abuckenheimer/fix_windows_unittests

unittests passing on windows again

tests/conftest.py

@@ -1,7 +1,11 @@
+import sys
 import pytest
 
 from sanic import Sanic
 
+if sys.platform in ['win32', 'cygwin']:
+    collect_ignore = ["test_worker.py"]
+
 
 @pytest.fixture
 def app(request):

tests/test_config.py

@@ -1,10 +1,20 @@
 from os import environ
+from pathlib import Path
+from contextlib import contextmanager
+from tempfile import TemporaryDirectory
+from textwrap import dedent
 import pytest
-from tempfile import NamedTemporaryFile
 
 from sanic import Sanic
 
 
+@contextmanager
+def temp_path():
+    """ a simple cross platform replacement for NamedTemporaryFile """
+    with TemporaryDirectory() as td:
+        yield Path(td, 'file')
+
+
 def test_load_from_object(app):
     class Config:
         not_for_config = 'should not be used'
@@ -38,16 +48,15 @@ def test_load_env_prefix():
 
 
 def test_load_from_file(app):
-    config = b"""
-VALUE = 'some value'
-condition = 1 == 1
-if condition:
-    CONDITIONAL = 'should be set'
-    """
-    with NamedTemporaryFile() as config_file:
-        config_file.write(config)
-        config_file.seek(0)
-        app.config.from_pyfile(config_file.name)
+    config = dedent("""
+    VALUE = 'some value'
+    condition = 1 == 1
+    if condition:
+        CONDITIONAL = 'should be set'
+    """)
+    with temp_path() as config_path:
+        config_path.write_text(config)
+        app.config.from_pyfile(str(config_path))
         assert 'VALUE' in app.config
         assert app.config.VALUE == 'some value'
         assert 'CONDITIONAL' in app.config
@@ -61,11 +70,10 @@ def test_load_from_missing_file(app):
 
 
 def test_load_from_envvar(app):
-    config = b"VALUE = 'some value'"
-    with NamedTemporaryFile() as config_file:
-        config_file.write(config)
-        config_file.seek(0)
-        environ['APP_CONFIG'] = config_file.name
+    config = "VALUE = 'some value'"
+    with temp_path() as config_path:
+        config_path.write_text(config)
+        environ['APP_CONFIG'] = str(config_path)
         app.config.from_envvar('APP_CONFIG')
         assert 'VALUE' in app.config
         assert app.config.VALUE == 'some value'

tests/test_keep_alive_timeout.py

@@ -9,60 +9,22 @@
 from aiohttp import TCPConnector
 from sanic.testing import SanicTestClient, HOST, PORT
 
-try:
-    try:
-        import packaging # direct use
-    except ImportError:
-        # setuptools v39.0 and above.
-        try:
-            from setuptools.extern import packaging
-        except ImportError:
-            # Before setuptools v39.0
-            from pkg_resources.extern import packaging
-    version = packaging.version
-except ImportError:
-    raise RuntimeError("The 'packaging' library is missing.")
-
-aiohttp_version = version.parse(aiohttp.__version__)
 
 class ReuseableTCPConnector(TCPConnector):
     def __init__(self, *args, **kwargs):
         super(ReuseableTCPConnector, self).__init__(*args, **kwargs)
         self.old_proto = None
 
-    if aiohttp_version >= version.parse('3.3.0'):
-        async def connect(self, req, traces, timeout):
-            new_conn = await super(ReuseableTCPConnector, self)\
-                                    .connect(req, traces, timeout)
-            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
-    elif aiohttp_version >= version.parse('3.0.0'):
-        async def connect(self, req, traces=None):
-            new_conn = await super(ReuseableTCPConnector, self)\
-                                    .connect(req, traces=traces)
-            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
-    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
+    async def connect(self, req, *args, **kwargs):
+        new_conn = await super(ReuseableTCPConnector, self)\
+                                .connect(req, *args, **kwargs)
+        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):
@@ -147,14 +109,14 @@ async def _collect_response(loop):
             try:
                 request, response = results
                 return request, response
-            except:
+            except Exception:
                 raise ValueError(
                     "Request and response object expected, got ({})".format(
                         results))
         else:
             try:
                 return results[-1]
-            except:
+            except Exception:
                 raise ValueError(
                     "Request object expected, got ({})".format(results))
 

tests/test_multiprocessing.py

@@ -1,14 +1,20 @@
 import multiprocessing
 import random
 import signal
+import pytest
 
 from sanic.testing import HOST, PORT
 
 
+@pytest.mark.skipif(
+    not hasattr(signal, 'SIGALRM'),
+    reason='SIGALRM is not implemented for this platform, we have to come '
+    'up with another timeout strategy to test these'
+)
 def test_multiprocessing(app):
     """Tests that the number of children we produce is correct"""
     # Selects a number at random so we can spot check
-    num_workers = random.choice(range(2,  multiprocessing.cpu_count() * 2 + 1))
+    num_workers = random.choice(range(2, multiprocessing.cpu_count() * 2 + 1))
     process_list = set()
 
     def stop_on_alarm(*args):

tests/test_request_timeout.py

@@ -5,13 +5,15 @@
 from sanic.response import text
 from sanic.config import Config
 import aiohttp
-from aiohttp import TCPConnector, ClientResponse
-from sanic.testing import SanicTestClient, HOST, PORT
+from aiohttp import TCPConnector
+from sanic.testing import SanicTestClient, HOST
 
 try:
     try:
-        import packaging # direct use
-    except ImportError:
+        # direct use
+        import packaging
+        version = packaging.version
+    except (ImportError, AttributeError):
         # setuptools v39.0 and above.
         try:
             from setuptools.extern import packaging
@@ -22,8 +24,10 @@
 except ImportError:
     raise RuntimeError("The 'packaging' library is missing.")
 
+
 aiohttp_version = version.parse(aiohttp.__version__)
 
+
 class DelayableTCPConnector(TCPConnector):
 
     class RequestContextManager(object):
@@ -56,8 +60,7 @@ async def start(self, connection, read_until_eof=False):
                 if aiohttp_version >= version.parse("3.3.0"):
                     ret = await self.orig_start(connection)
                 else:
-                    ret = await self.orig_start(connection,
-                                                read_until_eof)
+                    ret = await self.orig_start(connection, read_until_eof)
             except Exception as e:
                 raise e
             return ret
@@ -71,57 +74,43 @@ def close(self):
         async def delayed_send(self, *args, **kwargs):
             req = self.req
             if self.delay and self.delay > 0:
-                #sync_sleep(self.delay)
+                # sync_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
 
-            if aiohttp_version >= version.parse("3.1.0"):
-                try:
-                    delayed_resp = await self.orig_send(*args, **kwargs)
-                except Exception as e:
-                    if aiohttp_version >= version.parse("3.3.0"):
-                        return aiohttp.ClientResponse(req.method, req.url,
-                                                      writer=None,
-                                                      continue100=None,
-                                                      timer=None,
-                                                      request_info=None,
-                                                      traces=[],
-                                                      loop=req.loop,
-                                                      session=None)
-                    else:
-                        return aiohttp.ClientResponse(req.method, req.url,
-                                                      writer=None,
-                                                      continue100=None,
-                                                      timer=None,
-                                                      request_info=None,
-                                                      auto_decompress=None,
-                                                      traces=[],
-                                                      loop=req.loop,
-                                                      session=None)
-            else:
-                try:
-                    delayed_resp = self.orig_send(*args, **kwargs)
-                except Exception as e:
+            try:
+                return await self.orig_send(*args, **kwargs)
+            except Exception as e:
+                if aiohttp_version < version.parse("3.1.0"):
                     return aiohttp.ClientResponse(req.method, req.url)
-            return delayed_resp
+                kw = dict(
+                    writer=None,
+                    continue100=None,
+                    timer=None,
+                    request_info=None,
+                    traces=[],
+                    loop=req.loop,
+                    session=None
+                )
+                if aiohttp_version < version.parse("3.3.0"):
+                    kw['auto_decompress'] = None
+                return aiohttp.ClientResponse(req.method, req.url, **kw)
+
+        def _send(self, *args, **kwargs):
+            gen = self.delayed_send(*args, **kwargs)
+            task = self.req.loop.create_task(gen)
+            self.send_task = task
+            self._acting_as = task
+            return self
 
         if aiohttp_version >= version.parse("3.1.0"):
             # aiohttp changed the request.send method to async
             async def send(self, *args, **kwargs):
-                gen = self.delayed_send(*args, **kwargs)
-                task = self.req.loop.create_task(gen)
-                self.send_task = task
-                self._acting_as = task
-                return self
+                return self._send(*args, **kwargs)
         else:
-            def send(self, *args, **kwargs):
-                gen = self.delayed_send(*args, **kwargs)
-                task = self.req.loop.create_task(gen)
-                self.send_task = task
-                self._acting_as = task
-                return self
+            send = _send
 
     def __init__(self, *args, **kwargs):
         _post_connect_delay = kwargs.pop('post_connect_delay', 0)
@@ -130,45 +119,18 @@ def __init__(self, *args, **kwargs):
         self._post_connect_delay = _post_connect_delay
         self._pre_request_delay = _pre_request_delay
 
-    if aiohttp_version >= version.parse("3.3.0"):
-        async def connect(self, req, traces, timeout):
-            d_req = DelayableTCPConnector.\
-                RequestContextManager(req, self._pre_request_delay)
-            conn = await super(DelayableTCPConnector, self).\
-                connect(req, traces, timeout)
-            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
-    elif aiohttp_version >= version.parse("3.0.0"):
-        async def connect(self, req, traces=None):
-            d_req = DelayableTCPConnector.\
-                RequestContextManager(req, self._pre_request_delay)
-            conn = await super(DelayableTCPConnector, self).\
-                connect(req, traces=traces)
-            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
-    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
+    async def connect(self, req, *args, **kwargs):
+        d_req = DelayableTCPConnector.\
+            RequestContextManager(req, self._pre_request_delay)
+        conn = await super(DelayableTCPConnector, self).\
+            connect(req, *args, **kwargs)
+        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):