Migrate container.from_schema() integration tests

tests/unit/samples/__init__.py

@@ -0,0 +1 @@
+"""Sample code for testing."""

tests/unit/samples/schemasample/container-multiple-inline.yml

@@ -12,7 +12,7 @@ container:
       provides: sqlite3.connect
       args:
         - provider: Callable
-          provides: schemasample.utils.return_
+          provides: samples.schemasample.utils.return_
           args:
             - container.core.config.database.dsn
 
@@ -27,32 +27,32 @@ container:
   services:
     user:
       provider: Factory
-      provides: schemasample.services.UserService
+      provides: samples.schemasample.services.UserService
       kwargs:
         db:
           provider: Callable
-          provides: schemasample.utils.return_
+          provides: samples.schemasample.utils.return_
           args:
             - container.gateways.database_client
 
     auth:
       provider: Factory
-      provides: schemasample.services.AuthService
+      provides: samples.schemasample.services.AuthService
       kwargs:
         db:
           provider: Callable
-          provides: schemasample.utils.return_
+          provides: samples.schemasample.utils.return_
           args:
             - container.gateways.database_client
         token_ttl: container.core.config.auth.token_ttl.as_int()
 
     photo:
       provider: Factory
-      provides: schemasample.services.PhotoService
+      provides: samples.schemasample.services.PhotoService
       kwargs:
         db:
           provider: Callable
-          provides: schemasample.utils.return_
+          provides: samples.schemasample.utils.return_
           args:
             - container.gateways.database_client
         s3: container.gateways.s3_client

tests/unit/samples/schemasample/container-multiple-reordered.yml

@@ -5,20 +5,20 @@ container:
   services:
     user:
       provider: Factory
-      provides: schemasample.services.UserService
+      provides: samples.schemasample.services.UserService
       kwargs:
         db: container.gateways.database_client
 
     auth:
       provider: Factory
-      provides: schemasample.services.AuthService
+      provides: samples.schemasample.services.AuthService
       kwargs:
         db: container.gateways.database_client
         token_ttl: container.core.config.auth.token_ttl.as_int()
 
     photo:
       provider: Factory
-      provides: schemasample.services.PhotoService
+      provides: samples.schemasample.services.PhotoService
       kwargs:
         db: container.gateways.database_client
         s3: container.gateways.s3_client

tests/unit/samples/schemasample/container-multiple.yml

@@ -24,20 +24,20 @@ container:
   services:
     user:
       provider: Factory
-      provides: schemasample.services.UserService
+      provides: samples.schemasample.services.UserService
       kwargs:
         db: container.gateways.database_client
 
     auth:
       provider: Factory
-      provides: schemasample.services.AuthService
+      provides: samples.schemasample.services.AuthService
       kwargs:
         db: container.gateways.database_client
         token_ttl: container.core.config.auth.token_ttl.as_int()
 
     photo:
       provider: Factory
-      provides: schemasample.services.PhotoService
+      provides: samples.schemasample.services.PhotoService
       kwargs:
         db: container.gateways.database_client
         s3: container.gateways.s3_client

tests/unit/samples/schemasample/container-single.yml

@@ -20,20 +20,20 @@ container:
 
   user_service:
     provider: Factory
-    provides: schemasample.services.UserService
+    provides: samples.schemasample.services.UserService
     kwargs:
       db: container.database_client
 
   auth_service:
     provider: Factory
-    provides: schemasample.services.AuthService
+    provides: samples.schemasample.services.AuthService
     kwargs:
       db: container.database_client
       token_ttl: container.config.auth.token_ttl.as_int()
 
   photo_service:
     provider: Factory
-    provides: schemasample.services.PhotoService
+    provides: samples.schemasample.services.PhotoService
     kwargs:
       db: container.database_client
       s3: container.s3_client

tests/unit/schema/conftest.py

@@ -0,0 +1,9 @@
+"""Container schema fixtures."""
+
+from dependency_injector import containers
+from pytest import fixture
+
+
+@fixture
+def container():
+    return containers.DynamicContainer()

tests/unit/schema/test_container_api_py36.py

@@ -7,12 +7,7 @@ import re
 
 import yaml
 from dependency_injector import containers, providers, errors
-from pytest import fixture, raises
+from pytest import raises
-
-
-@fixture
-def container():
-    return containers.DynamicContainer()
 
 
 def test_from_schema(container: containers.DynamicContainer):

tests/unit/schema/test_integration_py36.py

@@ -1,33 +1,24 @@
+"""Container tests for building containers from configuration files."""
+
+import os
 import sqlite3
-import unittest
 
 from dependency_injector import containers
+from pytest import mark
 
-# Runtime import
+from samples.schemasample.services import UserService, AuthService, PhotoService
-import os
+
-_TOP_DIR = os.path.abspath(
+
-    os.path.sep.join((
+SAMPLES_DIR = os.path.abspath(
-        os.path.dirname(__file__),
-        "../",
-    )),
-)
-_SAMPLES_DIR = os.path.abspath(
     os.path.sep.join((
         os.path.dirname(__file__),
         "../samples/",
     )),
 )
-import sys
-sys.path.append(_SAMPLES_DIR)
-
-from schemasample.services import UserService, AuthService, PhotoService
 
 
-class TestSchemaSingleContainer(unittest.TestCase):
+def test_single_container_schema(container: containers.DynamicContainer):
-
+    container.from_yaml_schema(f"{SAMPLES_DIR}/schemasample/container-single.yml")
-    def test(self):
-        container = containers.DynamicContainer()
-        container.from_yaml_schema(f"{_SAMPLES_DIR}/schemasample/container-single.yml")
     container.config.from_dict({
         "database": {
                  "dsn": ":memory:",
@@ -44,53 +35,50 @@ class TestSchemaSingleContainer(unittest.TestCase):
     # User service
     user_service1 = container.user_service()
     user_service2 = container.user_service()
-        self.assertIsInstance(user_service1, UserService)
+    assert isinstance(user_service1, UserService)
-        self.assertIsInstance(user_service2, UserService)
+    assert isinstance(user_service2, UserService)
-        self.assertIsNot(user_service1, user_service2)
+    assert user_service1 is not user_service2
 
-        self.assertIsInstance(user_service1.db, sqlite3.Connection)
+    assert isinstance(user_service1.db, sqlite3.Connection)
-        self.assertIsInstance(user_service2.db, sqlite3.Connection)
+    assert isinstance(user_service2.db, sqlite3.Connection)
-        self.assertIs(user_service1.db, user_service2.db)
+    assert user_service1.db is user_service2.db
 
     # Auth service
     auth_service1 = container.auth_service()
     auth_service2 = container.auth_service()
-        self.assertIsInstance(auth_service1, AuthService)
+    assert isinstance(auth_service1, AuthService)
-        self.assertIsInstance(auth_service2, AuthService)
+    assert isinstance(auth_service2, AuthService)
-        self.assertIsNot(auth_service1, auth_service2)
+    assert auth_service1 is not auth_service2
 
-        self.assertIsInstance(auth_service1.db, sqlite3.Connection)
+    assert isinstance(auth_service1.db, sqlite3.Connection)
-        self.assertIsInstance(auth_service2.db, sqlite3.Connection)
+    assert isinstance(auth_service2.db, sqlite3.Connection)
-        self.assertIs(auth_service1.db, auth_service2.db)
+    assert auth_service1.db is auth_service2.db
-        self.assertIs(auth_service1.db, container.database_client())
+    assert auth_service1.db is container.database_client()
-        self.assertIs(auth_service2.db, container.database_client())
+    assert auth_service2.db is container.database_client()
 
-        self.assertEqual(auth_service1.token_ttl, 3600)
+    assert auth_service1.token_ttl == 3600
-        self.assertEqual(auth_service2.token_ttl, 3600)
+    assert auth_service2.token_ttl == 3600
 
     # Photo service
     photo_service1 = container.photo_service()
     photo_service2 = container.photo_service()
-        self.assertIsInstance(photo_service1, PhotoService)
+    assert isinstance(photo_service1, PhotoService)
-        self.assertIsInstance(photo_service2, PhotoService)
+    assert isinstance(photo_service2, PhotoService)
-        self.assertIsNot(photo_service1, photo_service2)
+    assert photo_service1 is not photo_service2
 
-        self.assertIsInstance(photo_service1.db, sqlite3.Connection)
+    assert isinstance(photo_service1.db, sqlite3.Connection)
-        self.assertIsInstance(photo_service2.db, sqlite3.Connection)
+    assert isinstance(photo_service2.db, sqlite3.Connection)
-        self.assertIs(photo_service1.db, photo_service2.db)
+    assert photo_service1.db is photo_service2.db
-        self.assertIs(photo_service1.db, container.database_client())
+    assert photo_service1.db is container.database_client()
-        self.assertIs(photo_service2.db, container.database_client())
+    assert photo_service2.db is container.database_client()
 
-        self.assertIs(photo_service1.s3, photo_service2.s3)
+    assert photo_service1.s3 is photo_service2.s3
-        self.assertIs(photo_service1.s3, container.s3_client())
+    assert photo_service1.s3 is container.s3_client()
-        self.assertIs(photo_service2.s3, container.s3_client())
+    assert photo_service2.s3 is container.s3_client()
 
 
-class TestSchemaMultipleContainers(unittest.TestCase):
+def test_multiple_containers_schema(container: containers.DynamicContainer):
-
+    container.from_yaml_schema(f"{SAMPLES_DIR}/schemasample/container-multiple.yml")
-    def test(self):
-        container = containers.DynamicContainer()
-        container.from_yaml_schema(f"{_SAMPLES_DIR}/schemasample/container-multiple.yml")
     container.core.config.from_dict({
         "database": {
             "dsn": ":memory:",
@@ -107,53 +95,50 @@ class TestSchemaMultipleContainers(unittest.TestCase):
     # User service
     user_service1 = container.services.user()
     user_service2 = container.services.user()
-        self.assertIsInstance(user_service1, UserService)
+    assert isinstance(user_service1, UserService)
-        self.assertIsInstance(user_service2, UserService)
+    assert isinstance(user_service2, UserService)
-        self.assertIsNot(user_service1, user_service2)
+    assert user_service1 is not user_service2
 
-        self.assertIsInstance(user_service1.db, sqlite3.Connection)
+    assert isinstance(user_service1.db, sqlite3.Connection)
-        self.assertIsInstance(user_service2.db, sqlite3.Connection)
+    assert isinstance(user_service2.db, sqlite3.Connection)
-        self.assertIs(user_service1.db, user_service2.db)
+    assert user_service1.db is user_service2.db
 
     # Auth service
     auth_service1 = container.services.auth()
     auth_service2 = container.services.auth()
-        self.assertIsInstance(auth_service1, AuthService)
+    assert isinstance(auth_service1, AuthService)
-        self.assertIsInstance(auth_service2, AuthService)
+    assert isinstance(auth_service2, AuthService)
-        self.assertIsNot(auth_service1, auth_service2)
+    assert auth_service1 is not auth_service2
 
-        self.assertIsInstance(auth_service1.db, sqlite3.Connection)
+    assert isinstance(auth_service1.db, sqlite3.Connection)
-        self.assertIsInstance(auth_service2.db, sqlite3.Connection)
+    assert isinstance(auth_service2.db, sqlite3.Connection)
-        self.assertIs(auth_service1.db, auth_service2.db)
+    assert auth_service1.db is auth_service2.db
-        self.assertIs(auth_service1.db, container.gateways.database_client())
+    assert auth_service1.db is container.gateways.database_client()
-        self.assertIs(auth_service2.db, container.gateways.database_client())
+    assert auth_service2.db is container.gateways.database_client()
 
-        self.assertEqual(auth_service1.token_ttl, 3600)
+    assert auth_service1.token_ttl == 3600
-        self.assertEqual(auth_service2.token_ttl, 3600)
+    assert auth_service2.token_ttl == 3600
 
     # Photo service
     photo_service1 = container.services.photo()
     photo_service2 = container.services.photo()
-        self.assertIsInstance(photo_service1, PhotoService)
+    assert isinstance(photo_service1, PhotoService)
-        self.assertIsInstance(photo_service2, PhotoService)
+    assert isinstance(photo_service2, PhotoService)
-        self.assertIsNot(photo_service1, photo_service2)
+    assert photo_service1 is not photo_service2
 
-        self.assertIsInstance(photo_service1.db, sqlite3.Connection)
+    assert isinstance(photo_service1.db, sqlite3.Connection)
-        self.assertIsInstance(photo_service2.db, sqlite3.Connection)
+    assert isinstance(photo_service2.db, sqlite3.Connection)
-        self.assertIs(photo_service1.db, photo_service2.db)
+    assert photo_service1.db is photo_service2.db
-        self.assertIs(photo_service1.db, container.gateways.database_client())
+    assert photo_service1.db is container.gateways.database_client()
-        self.assertIs(photo_service2.db, container.gateways.database_client())
+    assert photo_service2.db is container.gateways.database_client()
 
-        self.assertIs(photo_service1.s3, photo_service2.s3)
+    assert photo_service1.s3 is photo_service2.s3
-        self.assertIs(photo_service1.s3, container.gateways.s3_client())
+    assert photo_service1.s3 is container.gateways.s3_client()
-        self.assertIs(photo_service2.s3, container.gateways.s3_client())
+    assert photo_service2.s3 is container.gateways.s3_client()
 
 
-class TestSchemaMultipleContainersReordered(unittest.TestCase):
+def test_multiple_reordered_containers_schema(container: containers.DynamicContainer):
-
+    container.from_yaml_schema(f"{SAMPLES_DIR}/schemasample/container-multiple-reordered.yml")
-    def test(self):
-        container = containers.DynamicContainer()
-        container.from_yaml_schema(f"{_SAMPLES_DIR}/schemasample/container-multiple-reordered.yml")
     container.core.config.from_dict({
         "database": {
             "dsn": ":memory:",
@@ -170,53 +155,50 @@ class TestSchemaMultipleContainersReordered(unittest.TestCase):
     # User service
     user_service1 = container.services.user()
     user_service2 = container.services.user()
-        self.assertIsInstance(user_service1, UserService)
+    assert isinstance(user_service1, UserService)
-        self.assertIsInstance(user_service2, UserService)
+    assert isinstance(user_service2, UserService)
-        self.assertIsNot(user_service1, user_service2)
+    assert user_service1 is not user_service2
 
-        self.assertIsInstance(user_service1.db, sqlite3.Connection)
+    assert isinstance(user_service1.db, sqlite3.Connection)
-        self.assertIsInstance(user_service2.db, sqlite3.Connection)
+    assert isinstance(user_service2.db, sqlite3.Connection)
-        self.assertIs(user_service1.db, user_service2.db)
+    assert user_service1.db is user_service2.db
 
     # Auth service
     auth_service1 = container.services.auth()
     auth_service2 = container.services.auth()
-        self.assertIsInstance(auth_service1, AuthService)
+    assert isinstance(auth_service1, AuthService)
-        self.assertIsInstance(auth_service2, AuthService)
+    assert isinstance(auth_service2, AuthService)
-        self.assertIsNot(auth_service1, auth_service2)
+    assert auth_service1 is not auth_service2
 
-        self.assertIsInstance(auth_service1.db, sqlite3.Connection)
+    assert isinstance(auth_service1.db, sqlite3.Connection)
-        self.assertIsInstance(auth_service2.db, sqlite3.Connection)
+    assert isinstance(auth_service2.db, sqlite3.Connection)
-        self.assertIs(auth_service1.db, auth_service2.db)
+    assert auth_service1.db is auth_service2.db
-        self.assertIs(auth_service1.db, container.gateways.database_client())
+    assert auth_service1.db is container.gateways.database_client()
-        self.assertIs(auth_service2.db, container.gateways.database_client())
+    assert auth_service2.db is container.gateways.database_client()
 
-        self.assertEqual(auth_service1.token_ttl, 3600)
+    assert auth_service1.token_ttl == 3600
-        self.assertEqual(auth_service2.token_ttl, 3600)
+    assert auth_service2.token_ttl == 3600
 
     # Photo service
     photo_service1 = container.services.photo()
     photo_service2 = container.services.photo()
-        self.assertIsInstance(photo_service1, PhotoService)
+    assert isinstance(photo_service1, PhotoService)
-        self.assertIsInstance(photo_service2, PhotoService)
+    assert isinstance(photo_service2, PhotoService)
-        self.assertIsNot(photo_service1, photo_service2)
+    assert photo_service1 is not photo_service2
 
-        self.assertIsInstance(photo_service1.db, sqlite3.Connection)
+    assert isinstance(photo_service1.db, sqlite3.Connection)
-        self.assertIsInstance(photo_service2.db, sqlite3.Connection)
+    assert isinstance(photo_service2.db, sqlite3.Connection)
-        self.assertIs(photo_service1.db, photo_service2.db)
+    assert photo_service1.db is photo_service2.db
-        self.assertIs(photo_service1.db, container.gateways.database_client())
+    assert photo_service1.db is container.gateways.database_client()
-        self.assertIs(photo_service2.db, container.gateways.database_client())
+    assert photo_service2.db is container.gateways.database_client()
 
-        self.assertIs(photo_service1.s3, photo_service2.s3)
+    assert photo_service1.s3 is photo_service2.s3
-        self.assertIs(photo_service1.s3, container.gateways.s3_client())
+    assert photo_service1.s3 is container.gateways.s3_client()
-        self.assertIs(photo_service2.s3, container.gateways.s3_client())
+    assert photo_service2.s3 is container.gateways.s3_client()
 
 
-class TestSchemaMultipleContainersWithInlineProviders(unittest.TestCase):
+def test_multiple_containers_with_inline_providers_schema(container: containers.DynamicContainer):
-
+    container.from_yaml_schema(f"{SAMPLES_DIR}/schemasample/container-multiple-inline.yml")
-    def test(self):
-        container = containers.DynamicContainer()
-        container.from_yaml_schema(f"{_SAMPLES_DIR}/schemasample/container-multiple-inline.yml")
     container.core.config.from_dict({
         "database": {
             "dsn": ":memory:",
@@ -233,54 +215,51 @@ class TestSchemaMultipleContainersWithInlineProviders(unittest.TestCase):
     # User service
     user_service1 = container.services.user()
     user_service2 = container.services.user()
-        self.assertIsInstance(user_service1, UserService)
+    assert isinstance(user_service1, UserService)
-        self.assertIsInstance(user_service2, UserService)
+    assert isinstance(user_service2, UserService)
-        self.assertIsNot(user_service1, user_service2)
+    assert user_service1 is not user_service2
 
-        self.assertIsInstance(user_service1.db, sqlite3.Connection)
+    assert isinstance(user_service1.db, sqlite3.Connection)
-        self.assertIsInstance(user_service2.db, sqlite3.Connection)
+    assert isinstance(user_service2.db, sqlite3.Connection)
-        self.assertIs(user_service1.db, user_service2.db)
+    assert user_service1.db is user_service2.db
 
     # Auth service
     auth_service1 = container.services.auth()
     auth_service2 = container.services.auth()
-        self.assertIsInstance(auth_service1, AuthService)
+    assert isinstance(auth_service1, AuthService)
-        self.assertIsInstance(auth_service2, AuthService)
+    assert isinstance(auth_service2, AuthService)
-        self.assertIsNot(auth_service1, auth_service2)
+    assert auth_service1 is not auth_service2
 
-        self.assertIsInstance(auth_service1.db, sqlite3.Connection)
+    assert isinstance(auth_service1.db, sqlite3.Connection)
-        self.assertIsInstance(auth_service2.db, sqlite3.Connection)
+    assert isinstance(auth_service2.db, sqlite3.Connection)
-        self.assertIs(auth_service1.db, auth_service2.db)
+    assert auth_service1.db is auth_service2.db
-        self.assertIs(auth_service1.db, container.gateways.database_client())
+    assert auth_service1.db is container.gateways.database_client()
-        self.assertIs(auth_service2.db, container.gateways.database_client())
+    assert auth_service2.db is container.gateways.database_client()
 
-        self.assertEqual(auth_service1.token_ttl, 3600)
+    assert auth_service1.token_ttl == 3600
-        self.assertEqual(auth_service2.token_ttl, 3600)
+    assert auth_service2.token_ttl == 3600
 
     # Photo service
     photo_service1 = container.services.photo()
     photo_service2 = container.services.photo()
-        self.assertIsInstance(photo_service1, PhotoService)
+    assert isinstance(photo_service1, PhotoService)
-        self.assertIsInstance(photo_service2, PhotoService)
+    assert isinstance(photo_service2, PhotoService)
-        self.assertIsNot(photo_service1, photo_service2)
+    assert photo_service1 is not photo_service2
 
-        self.assertIsInstance(photo_service1.db, sqlite3.Connection)
+    assert isinstance(photo_service1.db, sqlite3.Connection)
-        self.assertIsInstance(photo_service2.db, sqlite3.Connection)
+    assert isinstance(photo_service2.db, sqlite3.Connection)
-        self.assertIs(photo_service1.db, photo_service2.db)
+    assert photo_service1.db is photo_service2.db
-        self.assertIs(photo_service1.db, container.gateways.database_client())
+    assert photo_service1.db is container.gateways.database_client()
-        self.assertIs(photo_service2.db, container.gateways.database_client())
+    assert photo_service2.db is container.gateways.database_client()
 
-        self.assertIs(photo_service1.s3, photo_service2.s3)
+    assert photo_service1.s3 is photo_service2.s3
-        self.assertIs(photo_service1.s3, container.gateways.s3_client())
+    assert photo_service1.s3 is container.gateways.s3_client()
-        self.assertIs(photo_service2.s3, container.gateways.s3_client())
+    assert photo_service2.s3 is container.gateways.s3_client()
 
 
-class TestSchemaBoto3Session(unittest.TestCase):
+@mark.skip(reason="Boto3 tries to connect to the internet")
-
+def test_schema_with_boto3_session(container: containers.DynamicContainer):
-    @unittest.skip("Boto3 tries to connect to the internet")
+    container.from_yaml_schema(f"{SAMPLES_DIR}/schemasample/container-boto3-session.yml")
-    def test(self):
-        container = containers.DynamicContainer()
-        container.from_yaml_schema(f"{_SAMPLES_DIR}/schemasample/container-boto3-session.yml")
     container.config.from_dict(
         {
             "aws_access_key_id": "key",
@@ -290,5 +269,5 @@ class TestSchemaBoto3Session(unittest.TestCase):
         },
     )
 
-        self.assertEqual(container.s3_client().__class__.__name__, "S3")
+    assert container.s3_client().__class__.__name__ == "S3"
-        self.assertEqual(container.sqs_client().__class__.__name__, "SQS")
+    assert container.sqs_client().__class__.__name__ == "SQS"