From 6015afa76bfe28ff3d55c107427cdc05a007c436 Mon Sep 17 00:00:00 2001 From: Roman Mogylatov Date: Fri, 15 Oct 2021 11:30:29 -0400 Subject: [PATCH] Migrate Factory async mode tests --- tests/unit/providers/async/__init__.py | 1 + .../unit/providers/async/test_factory_py36.py | 381 ++++++++++++++++++ tests/unit/providers/test_async_py36.py | 332 --------------- tests/unit/providers/test_types_py36.py | 12 +- 4 files changed, 387 insertions(+), 339 deletions(-) create mode 100644 tests/unit/providers/async/__init__.py create mode 100644 tests/unit/providers/async/test_factory_py36.py diff --git a/tests/unit/providers/async/__init__.py b/tests/unit/providers/async/__init__.py new file mode 100644 index 00000000..8b3ee44e --- /dev/null +++ b/tests/unit/providers/async/__init__.py @@ -0,0 +1 @@ +"""Provider asynchronous mode tests.""" diff --git a/tests/unit/providers/async/test_factory_py36.py b/tests/unit/providers/async/test_factory_py36.py new file mode 100644 index 00000000..5337ce5b --- /dev/null +++ b/tests/unit/providers/async/test_factory_py36.py @@ -0,0 +1,381 @@ +"""Factory async mode tests.""" + +import asyncio +import random + +from dependency_injector import containers, providers +from pytest import mark, raises + + +RESOURCE1 = object() +RESOURCE2 = object() + + +async def init_resource(resource): + await asyncio.sleep(random.randint(1, 10) / 1000) + yield resource + await asyncio.sleep(random.randint(1, 10) / 1000) + + +class Client: + def __init__(self, resource1: object, resource2: object) -> None: + self.resource1 = resource1 + self.resource2 = resource2 + + +class Service: + def __init__(self, client: Client) -> None: + self.client = client + + +class BaseContainer(containers.DeclarativeContainer): + resource1 = providers.Resource(init_resource, providers.Object(RESOURCE1)) + resource2 = providers.Resource(init_resource, providers.Object(RESOURCE2)) + + +class Container(BaseContainer): + client = providers.Factory( + Client, + resource1=BaseContainer.resource1, + resource2=BaseContainer.resource2, + ) + + service = providers.Factory( + Service, + client=client, + ) + + +@mark.asyncio +async def test_args_injection(): + class ContainerWithArgs(BaseContainer): + client = providers.Factory( + Client, + BaseContainer.resource1, + BaseContainer.resource2, + ) + + service = providers.Factory( + Service, + client, + ) + + container = ContainerWithArgs() + + client1 = await container.client() + client2 = await container.client() + + assert isinstance(client1, Client) + assert client1.resource1 is RESOURCE1 + assert client1.resource2 is RESOURCE2 + + assert isinstance(client2, Client) + assert client2.resource1 is RESOURCE1 + assert client2.resource2 is RESOURCE2 + + service1 = await container.service() + service2 = await container.service() + + assert isinstance(service1, Service) + assert isinstance(service1.client, Client) + assert service1.client.resource1 is RESOURCE1 + assert service1.client.resource2 is RESOURCE2 + + assert isinstance(service2, Service) + assert isinstance(service2.client, Client) + assert service2.client.resource1 is RESOURCE1 + assert service2.client.resource2 is RESOURCE2 + + assert service1.client is not service2.client + + +@mark.asyncio +async def test_kwargs_injection(): + class ContainerWithKwArgs(Container): + ... + + container = ContainerWithKwArgs() + + client1 = await container.client() + client2 = await container.client() + + assert isinstance(client1, Client) + assert client1.resource1 is RESOURCE1 + assert client1.resource2 is RESOURCE2 + + assert isinstance(client2, Client) + assert client2.resource1 is RESOURCE1 + assert client2.resource2 is RESOURCE2 + + service1 = await container.service() + service2 = await container.service() + + assert isinstance(service1, Service) + assert isinstance(service1.client, Client) + assert service1.client.resource1 is RESOURCE1 + assert service1.client.resource2 is RESOURCE2 + + assert isinstance(service2, Service) + assert isinstance(service2.client, Client) + assert service2.client.resource1 is RESOURCE1 + assert service2.client.resource2 is RESOURCE2 + + assert service1.client is not service2.client + + +@mark.asyncio +async def test_context_kwargs_injection(): + resource2_extra = object() + + container = Container() + + client1 = await container.client(resource2=resource2_extra) + client2 = await container.client(resource2=resource2_extra) + + assert isinstance(client1, Client) + assert client1.resource1 is RESOURCE1 + assert client1.resource2 is resource2_extra + + assert isinstance(client2, Client) + assert client2.resource1 is RESOURCE1 + assert client2.resource2 is resource2_extra + + +@mark.asyncio +async def test_args_kwargs_injection(): + class ContainerWithArgsAndKwArgs(BaseContainer): + client = providers.Factory( + Client, + BaseContainer.resource1, + resource2=BaseContainer.resource2, + ) + + service = providers.Factory( + Service, + client=client, + ) + + container = ContainerWithArgsAndKwArgs() + + client1 = await container.client() + client2 = await container.client() + + assert isinstance(client1, Client) + assert client1.resource1 is RESOURCE1 + assert client1.resource2 is RESOURCE2 + + assert isinstance(client2, Client) + assert client2.resource1 is RESOURCE1 + assert client2.resource2 is RESOURCE2 + + service1 = await container.service() + service2 = await container.service() + + assert isinstance(service1, Service) + assert isinstance(service1.client, Client) + assert service1.client.resource1 is RESOURCE1 + assert service1.client.resource2 is RESOURCE2 + + assert isinstance(service2, Service) + assert isinstance(service2.client, Client) + assert service2.client.resource1 is RESOURCE1 + assert service2.client.resource2 is RESOURCE2 + + assert service1.client is not service2.client + + +@mark.asyncio +async def test_injection_error(): + async def init_resource(): + raise Exception("Something went wrong") + + class Container(containers.DeclarativeContainer): + resource_with_error = providers.Resource(init_resource) + + client = providers.Factory( + Client, + resource1=resource_with_error, + resource2=None, + ) + + container = Container() + + with raises(Exception, match="Something went wrong"): + await container.client() + + +@mark.asyncio +async def test_injection_runtime_error_async_provides(): + async def create_client(*args, **kwargs): + raise Exception("Something went wrong") + + class Container(BaseContainer): + client = providers.Factory( + create_client, + resource1=BaseContainer.resource1, + resource2=None, + ) + + container = Container() + + with raises(Exception, match="Something went wrong"): + await container.client() + + +@mark.asyncio +async def test_injection_call_error_async_provides(): + async def create_client(): # <-- no args defined + ... + + class Container(BaseContainer): + client = providers.Factory( + create_client, + resource1=BaseContainer.resource1, + resource2=None, + ) + + container = Container() + + with raises(TypeError) as exception_info: + await container.client() + assert "create_client() got" in str(exception_info.value) + assert "unexpected keyword argument" in str(exception_info.value) + + +@mark.asyncio +async def test_attributes_injection(): + class ContainerWithAttributes(BaseContainer): + client = providers.Factory( + Client, + BaseContainer.resource1, + resource2=None, + ) + client.add_attributes(resource2=BaseContainer.resource2) + + service = providers.Factory( + Service, + client=None, + ) + service.add_attributes(client=client) + + container = ContainerWithAttributes() + + client1 = await container.client() + client2 = await container.client() + + assert isinstance(client1, Client) + assert client1.resource1 is RESOURCE1 + assert client1.resource2 is RESOURCE2 + + assert isinstance(client2, Client) + assert client2.resource1 is RESOURCE1 + assert client2.resource2 is RESOURCE2 + + service1 = await container.service() + service2 = await container.service() + + assert isinstance(service1, Service) + assert isinstance(service1.client, Client) + assert service1.client.resource1 is RESOURCE1 + assert service1.client.resource2 is RESOURCE2 + + assert isinstance(service2, Service) + assert isinstance(service2.client, Client) + assert service2.client.resource1 is RESOURCE1 + assert service2.client.resource2 is RESOURCE2 + + assert service1.client is not service2.client + + +@mark.asyncio +async def test_attributes_injection_attribute_error(): + class ClientWithException(Client): + @property + def attribute_set_error(self): + return None + + @attribute_set_error.setter + def attribute_set_error(self, value): + raise Exception("Something went wrong") + + class Container(BaseContainer): + client = providers.Factory( + ClientWithException, + resource1=BaseContainer.resource1, + resource2=BaseContainer.resource2, + ) + client.add_attributes(attribute_set_error=123) + + container = Container() + + with raises(Exception, match="Something went wrong"): + await container.client() + + +@mark.asyncio +async def test_attributes_injection_runtime_error(): + async def init_resource(): + raise Exception("Something went wrong") + + class Container(containers.DeclarativeContainer): + resource = providers.Resource(init_resource) + + client = providers.Factory( + Client, + resource1=None, + resource2=None, + ) + client.add_attributes(resource1=resource) + client.add_attributes(resource2=resource) + + container = Container() + + with raises(Exception, match="Something went wrong"): + await container.client() + + +@mark.asyncio +async def test_async_instance_and_sync_attributes_injection(): + class ContainerWithAttributes(BaseContainer): + resource1 = providers.Resource(init_resource, providers.Object(RESOURCE1)) + + client = providers.Factory( + Client, + BaseContainer.resource1, + resource2=None, + ) + client.add_attributes(resource2=providers.Object(RESOURCE2)) + + service = providers.Factory( + Service, + client=None, + ) + service.add_attributes(client=client) + + container = ContainerWithAttributes() + + client1 = await container.client() + client2 = await container.client() + + assert isinstance(client1, Client) + assert client1.resource1 is RESOURCE1 + assert client1.resource2 is RESOURCE2 + + assert isinstance(client2, Client) + assert client2.resource1 is RESOURCE1 + assert client2.resource2 is RESOURCE2 + + service1 = await container.service() + service2 = await container.service() + + assert isinstance(service1, Service) + assert isinstance(service1.client, Client) + assert service1.client.resource1 is RESOURCE1 + assert service1.client.resource2 is RESOURCE2 + + assert isinstance(service2, Service) + assert isinstance(service2.client, Client) + assert service2.client.resource1 is RESOURCE1 + assert service2.client.resource2 is RESOURCE2 + + assert service1.client is not service2.client diff --git a/tests/unit/providers/test_async_py36.py b/tests/unit/providers/test_async_py36.py index e0603a7b..79624e6d 100644 --- a/tests/unit/providers/test_async_py36.py +++ b/tests/unit/providers/test_async_py36.py @@ -55,338 +55,6 @@ class Container(containers.DeclarativeContainer): ) -class FactoryTests(AsyncTestCase): - - def test_args_injection(self): - class ContainerWithArgs(containers.DeclarativeContainer): - resource1 = providers.Resource(init_resource, providers.Object(RESOURCE1)) - resource2 = providers.Resource(init_resource, providers.Object(RESOURCE2)) - - client = providers.Factory( - Client, - resource1, - resource2, - ) - - service = providers.Factory( - Service, - client, - ) - - container = ContainerWithArgs() - - client1 = self._run(container.client()) - client2 = self._run(container.client()) - - self.assertIsInstance(client1, Client) - self.assertIs(client1.resource1, RESOURCE1) - self.assertIs(client1.resource2, RESOURCE2) - - self.assertIsInstance(client2, Client) - self.assertIs(client2.resource1, RESOURCE1) - self.assertIs(client2.resource2, RESOURCE2) - - service1 = self._run(container.service()) - service2 = self._run(container.service()) - - self.assertIsInstance(service1, Service) - self.assertIsInstance(service1.client, Client) - self.assertIs(service1.client.resource1, RESOURCE1) - self.assertIs(service1.client.resource2, RESOURCE2) - - self.assertIsInstance(service2, Service) - self.assertIsInstance(service2.client, Client) - self.assertIs(service2.client.resource1, RESOURCE1) - self.assertIs(service2.client.resource2, RESOURCE2) - - self.assertIsNot(service1.client, service2.client) - - def test_kwargs_injection(self): - container = Container() - - client1 = self._run(container.client()) - client2 = self._run(container.client()) - - self.assertIsInstance(client1, Client) - self.assertIs(client1.resource1, RESOURCE1) - self.assertIs(client1.resource2, RESOURCE2) - - self.assertIsInstance(client2, Client) - self.assertIs(client2.resource1, RESOURCE1) - self.assertIs(client2.resource2, RESOURCE2) - - service1 = self._run(container.service()) - service2 = self._run(container.service()) - - self.assertIsInstance(service1, Service) - self.assertIsInstance(service1.client, Client) - self.assertIs(service1.client.resource1, RESOURCE1) - self.assertIs(service1.client.resource2, RESOURCE2) - - self.assertIsInstance(service2, Service) - self.assertIsInstance(service2.client, Client) - self.assertIs(service2.client.resource1, RESOURCE1) - self.assertIs(service2.client.resource2, RESOURCE2) - - self.assertIsNot(service1.client, service2.client) - - def test_context_kwargs_injection(self): - resource2_extra = object() - - container = Container() - - client1 = self._run(container.client(resource2=resource2_extra)) - client2 = self._run(container.client(resource2=resource2_extra)) - - self.assertIsInstance(client1, Client) - self.assertIs(client1.resource1, RESOURCE1) - self.assertIs(client1.resource2, resource2_extra) - - self.assertIsInstance(client2, Client) - self.assertIs(client2.resource1, RESOURCE1) - self.assertIs(client2.resource2, resource2_extra) - - def test_args_kwargs_injection(self): - class ContainerWithArgsAndKwArgs(containers.DeclarativeContainer): - resource1 = providers.Resource(init_resource, providers.Object(RESOURCE1)) - resource2 = providers.Resource(init_resource, providers.Object(RESOURCE2)) - - client = providers.Factory( - Client, - resource1, - resource2=resource2, - ) - - service = providers.Factory( - Service, - client=client, - ) - - container = ContainerWithArgsAndKwArgs() - - client1 = self._run(container.client()) - client2 = self._run(container.client()) - - self.assertIsInstance(client1, Client) - self.assertIs(client1.resource1, RESOURCE1) - self.assertIs(client1.resource2, RESOURCE2) - - self.assertIsInstance(client2, Client) - self.assertIs(client2.resource1, RESOURCE1) - self.assertIs(client2.resource2, RESOURCE2) - - service1 = self._run(container.service()) - service2 = self._run(container.service()) - - self.assertIsInstance(service1, Service) - self.assertIsInstance(service1.client, Client) - self.assertIs(service1.client.resource1, RESOURCE1) - self.assertIs(service1.client.resource2, RESOURCE2) - - self.assertIsInstance(service2, Service) - self.assertIsInstance(service2.client, Client) - self.assertIs(service2.client.resource1, RESOURCE1) - self.assertIs(service2.client.resource2, RESOURCE2) - - self.assertIsNot(service1.client, service2.client) - - def test_injection_error(self): - async def init_resource(): - raise Exception("Something went wrong") - - class Container(containers.DeclarativeContainer): - resource_with_error = providers.Resource(init_resource) - - client = providers.Factory( - Client, - resource1=resource_with_error, - resource2=None, - ) - - container = Container() - - with self.assertRaises(Exception) as context: - self._run(container.client()) - self.assertEqual(str(context.exception), "Something went wrong") - - def test_injection_runtime_error_async_provides(self): - async def create_client(*args, **kwargs): - raise Exception("Something went wrong") - - class Container(containers.DeclarativeContainer): - resource = providers.Resource(init_resource, providers.Object(RESOURCE1)) - - client = providers.Factory( - create_client, - resource1=resource, - resource2=None, - ) - - container = Container() - - with self.assertRaises(Exception) as context: - self._run(container.client()) - self.assertEqual(str(context.exception), "Something went wrong") - - def test_injection_call_error_async_provides(self): - async def create_client(): # <-- no args defined - ... - - class Container(containers.DeclarativeContainer): - resource = providers.Resource(init_resource, providers.Object(RESOURCE1)) - - client = providers.Factory( - create_client, - resource1=resource, - resource2=None, - ) - - container = Container() - - with self.assertRaises(TypeError) as context: - self._run(container.client()) - self.assertIn("create_client() got", str(context.exception)) - self.assertIn("unexpected keyword argument", str(context.exception)) - - def test_attributes_injection(self): - class ContainerWithAttributes(containers.DeclarativeContainer): - resource1 = providers.Resource(init_resource, providers.Object(RESOURCE1)) - resource2 = providers.Resource(init_resource, providers.Object(RESOURCE2)) - - client = providers.Factory( - Client, - resource1, - resource2=None, - ) - client.add_attributes(resource2=resource2) - - service = providers.Factory( - Service, - client=None, - ) - service.add_attributes(client=client) - - container = ContainerWithAttributes() - - client1 = self._run(container.client()) - client2 = self._run(container.client()) - - self.assertIsInstance(client1, Client) - self.assertIs(client1.resource1, RESOURCE1) - self.assertIs(client1.resource2, RESOURCE2) - - self.assertIsInstance(client2, Client) - self.assertIs(client2.resource1, RESOURCE1) - self.assertIs(client2.resource2, RESOURCE2) - - service1 = self._run(container.service()) - service2 = self._run(container.service()) - - self.assertIsInstance(service1, Service) - self.assertIsInstance(service1.client, Client) - self.assertIs(service1.client.resource1, RESOURCE1) - self.assertIs(service1.client.resource2, RESOURCE2) - - self.assertIsInstance(service2, Service) - self.assertIsInstance(service2.client, Client) - self.assertIs(service2.client.resource1, RESOURCE1) - self.assertIs(service2.client.resource2, RESOURCE2) - - self.assertIsNot(service1.client, service2.client) - - def test_attributes_injection_attribute_error(self): - class ClientWithException(Client): - @property - def attribute_set_error(self): - return None - - @attribute_set_error.setter - def attribute_set_error(self, value): - raise Exception("Something went wrong") - - class Container(containers.DeclarativeContainer): - resource = providers.Resource(init_resource, providers.Object(RESOURCE1)) - - client = providers.Factory( - ClientWithException, - resource1=resource, - resource2=resource, - ) - client.add_attributes(attribute_set_error=123) - - container = Container() - - with self.assertRaises(Exception) as context: - self._run(container.client()) - self.assertEqual(str(context.exception), "Something went wrong") - - def test_attributes_injection_runtime_error(self): - async def init_resource(): - raise Exception("Something went wrong") - - class Container(containers.DeclarativeContainer): - resource = providers.Resource(init_resource) - - client = providers.Factory( - Client, - resource1=None, - resource2=None, - ) - client.add_attributes(resource1=resource) - client.add_attributes(resource2=resource) - - container = Container() - - with self.assertRaises(Exception) as context: - self._run(container.client()) - self.assertEqual(str(context.exception), "Something went wrong") - - def test_async_instance_and_sync_attributes_injection(self): - class ContainerWithAttributes(containers.DeclarativeContainer): - resource1 = providers.Resource(init_resource, providers.Object(RESOURCE1)) - - client = providers.Factory( - Client, - resource1, - resource2=None, - ) - client.add_attributes(resource2=providers.Object(RESOURCE2)) - - service = providers.Factory( - Service, - client=None, - ) - service.add_attributes(client=client) - - container = ContainerWithAttributes() - - client1 = self._run(container.client()) - client2 = self._run(container.client()) - - self.assertIsInstance(client1, Client) - self.assertIs(client1.resource1, RESOURCE1) - self.assertIs(client1.resource2, RESOURCE2) - - self.assertIsInstance(client2, Client) - self.assertIs(client2.resource1, RESOURCE1) - self.assertIs(client2.resource2, RESOURCE2) - - service1 = self._run(container.service()) - service2 = self._run(container.service()) - - self.assertIsInstance(service1, Service) - self.assertIsInstance(service1.client, Client) - self.assertIs(service1.client.resource1, RESOURCE1) - self.assertIs(service1.client.resource2, RESOURCE2) - - self.assertIsInstance(service2, Service) - self.assertIsInstance(service2.client, Client) - self.assertIs(service2.client.resource1, RESOURCE1) - self.assertIs(service2.client.resource2, RESOURCE2) - - self.assertIsNot(service1.client, service2.client) - - class FactoryAggregateTests(AsyncTestCase): def test_async_mode(self): diff --git a/tests/unit/providers/test_types_py36.py b/tests/unit/providers/test_types_py36.py index acaabb2a..430a1857 100644 --- a/tests/unit/providers/test_types_py36.py +++ b/tests/unit/providers/test_types_py36.py @@ -1,4 +1,4 @@ -import unittest +"""Provider typing in runtime tests.""" from dependency_injector import providers @@ -7,9 +7,7 @@ class SomeClass: ... -class TypesTest(unittest.TestCase): - - def test_provider(self): - provider: providers.Provider[SomeClass] = providers.Factory(SomeClass) - some_object = provider() - self.assertIsInstance(some_object, SomeClass) +def test_provider(): + provider: providers.Provider[SomeClass] = providers.Factory(SomeClass) + some_object = provider() + assert isinstance(some_object, SomeClass)