From 3f8af1cd565d0017809ab0bb03c5aa5aa8824fef Mon Sep 17 00:00:00 2001 From: Roman Mogylatov Date: Mon, 30 Nov 2020 18:15:07 -0500 Subject: [PATCH] Add tests for async injections in wiring @inject --- tests/unit/asyncutils.py | 57 +++++++++++++++++ .../samples/wiringsamples/asyncinjections.py | 50 +++++++++++++++ tests/unit/wiring/test_wiring_py36.py | 62 +++++++++++++++++++ 3 files changed, 169 insertions(+) create mode 100644 tests/unit/asyncutils.py create mode 100644 tests/unit/samples/wiringsamples/asyncinjections.py diff --git a/tests/unit/asyncutils.py b/tests/unit/asyncutils.py new file mode 100644 index 00000000..ca1b96d2 --- /dev/null +++ b/tests/unit/asyncutils.py @@ -0,0 +1,57 @@ +"""Test utils.""" + +import asyncio +import contextlib +import sys +import gc +import unittest + + +def run(main): + loop = asyncio.get_event_loop() + return loop.run_until_complete(main) + + +def setup_test_loop( + loop_factory=asyncio.new_event_loop +) -> asyncio.AbstractEventLoop: + loop = loop_factory() + try: + module = loop.__class__.__module__ + skip_watcher = 'uvloop' in module + except AttributeError: # pragma: no cover + # Just in case + skip_watcher = True + asyncio.set_event_loop(loop) + if sys.platform != 'win32' and not skip_watcher: + policy = asyncio.get_event_loop_policy() + watcher = asyncio.SafeChildWatcher() # type: ignore + watcher.attach_loop(loop) + with contextlib.suppress(NotImplementedError): + policy.set_child_watcher(watcher) + return loop + + +def teardown_test_loop(loop: asyncio.AbstractEventLoop, fast: bool = False) -> None: + closed = loop.is_closed() + if not closed: + loop.call_soon(loop.stop) + loop.run_forever() + loop.close() + + if not fast: + gc.collect() + + asyncio.set_event_loop(None) + + +class AsyncTestCase(unittest.TestCase): + + def setUp(self): + self.loop = setup_test_loop() + + def tearDown(self): + teardown_test_loop(self.loop) + + def _run(self, f): + return self.loop.run_until_complete(f) diff --git a/tests/unit/samples/wiringsamples/asyncinjections.py b/tests/unit/samples/wiringsamples/asyncinjections.py new file mode 100644 index 00000000..204300e3 --- /dev/null +++ b/tests/unit/samples/wiringsamples/asyncinjections.py @@ -0,0 +1,50 @@ +import asyncio + +from dependency_injector import containers, providers +from dependency_injector.wiring import inject, Provide, Closing + + +class TestResource: + def __init__(self): + self.init_counter = 0 + self.shutdown_counter = 0 + + def reset_counters(self): + self.init_counter = 0 + self.shutdown_counter = 0 + + +resource1 = TestResource() +resource2 = TestResource() + + +async def async_resource(resource): + await asyncio.sleep(0.001) + resource.init_counter += 1 + + yield resource + + await asyncio.sleep(0.001) + resource.shutdown_counter += 1 + + +class Container(containers.DeclarativeContainer): + + resource1 = providers.Resource(async_resource, providers.Object(resource1)) + resource2 = providers.Resource(async_resource, providers.Object(resource2)) + + +@inject +async def async_injection( + resource1: object = Provide[Container.resource1], + resource2: object = Provide[Container.resource2], +): + return resource1, resource2 + + +@inject +async def async_injection_with_closing( + resource1: object = Closing[Provide[Container.resource1]], + resource2: object = Closing[Provide[Container.resource2]], +): + return resource1, resource2 diff --git a/tests/unit/wiring/test_wiring_py36.py b/tests/unit/wiring/test_wiring_py36.py index 7c061ad9..ada0e8d9 100644 --- a/tests/unit/wiring/test_wiring_py36.py +++ b/tests/unit/wiring/test_wiring_py36.py @@ -5,6 +5,12 @@ from dependency_injector.wiring import wire, Provide, Closing # Runtime import to avoid syntax errors in samples on Python < 3.5 import os +_TOP_DIR = os.path.abspath( + os.path.sep.join(( + os.path.dirname(__file__), + '../', + )), +) _SAMPLES_DIR = os.path.abspath( os.path.sep.join(( os.path.dirname(__file__), @@ -12,8 +18,11 @@ _SAMPLES_DIR = os.path.abspath( )), ) import sys +sys.path.append(_TOP_DIR) sys.path.append(_SAMPLES_DIR) +from asyncutils import AsyncTestCase + from wiringsamples import module, package from wiringsamples.service import Service from wiringsamples.container import Container, SubContainer @@ -267,3 +276,56 @@ class WiringAndFastAPITest(unittest.TestCase): self.assertEqual(result_2.shutdown_counter, 2) self.assertIsNot(result_1, result_2) + + +class WiringAsyncInjectionsTest(AsyncTestCase): + + def test_async_injections(self): + from wiringsamples import asyncinjections + + container = asyncinjections.Container() + container.wire(modules=[asyncinjections]) + self.addCleanup(container.unwire) + + asyncinjections.resource1.reset_counters() + asyncinjections.resource2.reset_counters() + + resource1, resource2 = self._run(asyncinjections.async_injection()) + + self.assertIs(resource1, asyncinjections.resource1) + self.assertEqual(asyncinjections.resource1.init_counter, 1) + self.assertEqual(asyncinjections.resource1.shutdown_counter, 0) + + self.assertIs(resource2, asyncinjections.resource2) + self.assertEqual(asyncinjections.resource2.init_counter, 1) + self.assertEqual(asyncinjections.resource2.shutdown_counter, 0) + + def test_async_injections_with_closing(self): + from wiringsamples import asyncinjections + + container = asyncinjections.Container() + container.wire(modules=[asyncinjections]) + self.addCleanup(container.unwire) + + asyncinjections.resource1.reset_counters() + asyncinjections.resource2.reset_counters() + + resource1, resource2 = self._run(asyncinjections.async_injection_with_closing()) + + self.assertIs(resource1, asyncinjections.resource1) + self.assertEqual(asyncinjections.resource1.init_counter, 1) + self.assertEqual(asyncinjections.resource1.shutdown_counter, 1) + + self.assertIs(resource2, asyncinjections.resource2) + self.assertEqual(asyncinjections.resource2.init_counter, 1) + self.assertEqual(asyncinjections.resource2.shutdown_counter, 1) + + resource1, resource2 = self._run(asyncinjections.async_injection_with_closing()) + + self.assertIs(resource1, asyncinjections.resource1) + self.assertEqual(asyncinjections.resource1.init_counter, 2) + self.assertEqual(asyncinjections.resource1.shutdown_counter, 2) + + self.assertIs(resource2, asyncinjections.resource2) + self.assertEqual(asyncinjections.resource2.init_counter, 2) + self.assertEqual(asyncinjections.resource2.shutdown_counter, 2)