winloop 0.1.4__cp38-cp38-win_amd64.whl

tests/__main__.py

@@ -0,0 +1,16 @@
+import os.path
+import sys
+import unittest
+import unittest.runner
+
+
+def suite():
+    test_loader = unittest.TestLoader()
+    test_suite = test_loader.discover(os.path.dirname(__file__))
+    return test_suite
+
+
+if __name__ == '__main__':
+    runner = unittest.runner.TextTestRunner()
+    result = runner.run(suite())
+    sys.exit(not result.wasSuccessful())

tests/test_aiodns.py

@@ -0,0 +1,40 @@
+# NOTE: I forked the aiodns Repository you will have to use that for now
+# or wait for the pull request I recently made to go through:
+# https://github.com/saghul/aiodns/pull/116
+
+try:
+    import aiodns
+except ImportError:
+    skip_tests = True
+else:
+    skip_tests = False
+
+import unittest
+
+from winloop import _testbase as tb
+
+
+class _TestAiodns:
+    def test_dns_query(self):
+        # This is not allowed to fail...
+        resolver = aiodns.DNSResolver(loop=self.loop)
+
+        async def test():
+            async def query(name, query_type):
+                return await resolver.query(name, query_type)
+            await query('google.com', 'A')
+            await query('httpbin.org', 'A')
+            await query('example.com', 'A')
+
+        self.loop.run_until_complete(test())
+
+
+@unittest.skipIf(skip_tests, "no aiodns module")
+class Test_UV_Aiodns(_TestAiodns, tb.UVTestCase):
+    pass
+
+
+@unittest.skip("aiodns needs a SelectorEventLoop on Windows."
+               " See more: https://github.com/saghul/aiodns/issues/86")
+class Test_AIO_Aiodns(_TestAiodns, tb.AIOTestCase):
+    pass

tests/test_aiohttp.py

@@ -0,0 +1,133 @@
+try:
+    import aiohttp
+    import aiohttp.web
+except ImportError:
+    skip_tests = True
+else:
+    skip_tests = False
+
+import asyncio
+import sys
+import unittest
+import weakref
+
+from winloop import _testbase as tb
+
+# TODO: Fix or patch DeprecationWarning
+
+
+class _TestAioHTTP:
+
+    def test_aiohttp_basic_1(self):
+
+        PAYLOAD = '<h1>It Works!</h1>' * 10000
+
+        async def on_request(request):
+            return aiohttp.web.Response(text=PAYLOAD)
+
+        asyncio.set_event_loop(self.loop)
+        app = aiohttp.web.Application()
+        app.router.add_get('/', on_request)
+
+        runner = aiohttp.web.AppRunner(app)
+        self.loop.run_until_complete(runner.setup())
+        site = aiohttp.web.TCPSite(runner, '0.0.0.0', '0')
+        self.loop.run_until_complete(site.start())
+        port = site._server.sockets[0].getsockname()[1]
+
+        async def test():
+            # Make sure we're using the correct event loop.
+            self.assertIs(asyncio.get_event_loop(), self.loop)
+
+            for addr in (('localhost', port),
+                         ('127.0.0.1', port)):
+                async with aiohttp.ClientSession() as client:
+                    async with client.get('http://{}:{}'.format(*addr)) as r:
+                        self.assertEqual(r.status, 200)
+                        result = await r.text()
+                        self.assertEqual(result, PAYLOAD)
+
+        self.loop.run_until_complete(test())
+        self.loop.run_until_complete(runner.cleanup())
+
+    def test_aiohttp_graceful_shutdown(self):
+        # NOTE: This Might Already be solved I haven't checked yet - Vizonex
+        if self.implementation == 'asyncio' and sys.version_info >= (3, 12, 0):
+            # In Python 3.12.0, asyncio.Server.wait_closed() waits for all
+            # existing connections to complete, before aiohttp sends
+            # on_shutdown signals.
+            # https://github.com/aio-libs/aiohttp/issues/7675#issuecomment-1752143748
+            # https://github.com/python/cpython/pull/98582
+            raise unittest.SkipTest('bug in aiohttp: #7675')
+
+        async def websocket_handler(request):
+            ws = aiohttp.web.WebSocketResponse()
+            await ws.prepare(request)
+            request.app['websockets'].add(ws)
+            try:
+                async for msg in ws:
+                    await ws.send_str(msg.data)
+            finally:
+                request.app['websockets'].discard(ws)
+            return ws
+
+        async def on_shutdown(app):
+            for ws in set(app['websockets']):
+                await ws.close(
+                    code=aiohttp.WSCloseCode.GOING_AWAY,
+                    message='Server shutdown')
+
+        asyncio.set_event_loop(self.loop)
+        app = aiohttp.web.Application()
+        app.router.add_get('/', websocket_handler)
+        app.on_shutdown.append(on_shutdown)
+        app['websockets'] = weakref.WeakSet()
+
+        runner = aiohttp.web.AppRunner(app)
+        self.loop.run_until_complete(runner.setup())
+        site = aiohttp.web.TCPSite(
+            runner,
+            '0.0.0.0',
+            0,
+            # https://github.com/aio-libs/aiohttp/pull/7188
+            shutdown_timeout=0.1,
+        )
+        self.loop.run_until_complete(site.start())
+        port = site._server.sockets[0].getsockname()[1]
+
+        async def client():
+            async with aiohttp.ClientSession() as client:
+                async with client.ws_connect(
+                        'http://127.0.0.1:{}'.format(port)) as ws:
+                    await ws.send_str("hello")
+                    async for msg in ws:
+                        assert msg.data == "hello"
+
+        client_task = asyncio.ensure_future(client())
+
+        async def stop():
+            await asyncio.sleep(0.1)
+            try:
+                await asyncio.wait_for(runner.cleanup(), timeout=0.5)
+            finally:
+                try:
+                    client_task.cancel()
+                    await client_task
+                except asyncio.CancelledError:
+                    pass
+
+        self.loop.run_until_complete(stop())
+
+
+@unittest.skipIf(skip_tests, "no aiohttp module")
+class Test_UV_AioHTTP(_TestAioHTTP, tb.UVTestCase):
+    pass
+
+
+@unittest.skipIf(skip_tests, "no aiohttp module")
+class Test_AIO_AioHTTP(_TestAioHTTP, tb.AIOTestCase):
+    pass
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_aiomultiprocess.py

@@ -0,0 +1,60 @@
+try:
+    import aiomultiprocess
+    import multiprocessing
+except ImportError:
+    skip_tests = True
+else:
+    skip_tests = False
+import unittest
+import winloop
+import random
+import asyncio
+from winloop import _testbase as tb
+
+
+async def test_func(sleep: float):
+    return await asyncio.sleep(sleep)
+
+
+def my_map():
+    return [random.uniform(0.005, 1) for _ in range(7)]
+
+
+class _Test_Multiprocessing():
+    """Used for Testing aiomultiprocessing"""
+
+    def test_proccess_spawning(self):
+
+        # See:
+        # https://github.com/Vizonex/Winloop/issues/11#issuecomment-1922659521
+        self.processes = set()
+        # There must be at least 2 pids setup for this to be correctly ran...
+        total_proccesses = 2
+
+        async def test():
+            async with aiomultiprocess.Pool(total_proccesses) as pool:
+                self.processes.update(p.pid for p in pool.processes)
+                await pool.map(test_func, my_map())
+            await asyncio.sleep(0.005)
+            self.assertEqual(len(self.processes), total_proccesses)
+
+        self.loop.run_until_complete(test())
+
+
+@unittest.skipIf(skip_tests, "no aiomultiproccess module")
+class Test_UV_AioMultiprocess(_Test_Multiprocessing, tb.UVTestCase):
+    pass
+
+
+@unittest.skipIf(skip_tests, "no aiomultiproccess module")
+class Test_AIO_AioMultiprocess(_Test_Multiprocessing, tb.AIOTestCase):
+    pass
+
+
+if __name__ == "__main__":
+    # I have confirmed that multiproccessing is supported so no need
+    # to continue with trying... - Vizonex...
+    multiprocessing.freeze_support()
+    # aiomultiprocess.set_start_method("spawn")
+    winloop.install()
+    unittest.main()