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,294 +1,273 @@
+"""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")
+    container.config.from_dict({
+        "database": {
+                 "dsn": ":memory:",
+                    },
+        "aws": {
+            "access_key_id": "KEY",
+            "secret_access_key": "SECRET",
+               },
+        "auth": {
+             "token_ttl": 3600,
+                },
+    })
 
-    def test(self):
+    # User service
-        container = containers.DynamicContainer()
+    user_service1 = container.user_service()
-        container.from_yaml_schema(f"{_SAMPLES_DIR}/schemasample/container-single.yml")
+    user_service2 = container.user_service()
-        container.config.from_dict({
+    assert isinstance(user_service1, UserService)
-            "database": {
+    assert isinstance(user_service2, UserService)
-                "dsn": ":memory:",
+    assert user_service1 is not user_service2
-            },
-            "aws": {
-                "access_key_id": "KEY",
-                "secret_access_key": "SECRET",
-            },
-            "auth": {
-                "token_ttl": 3600,
-            },
-        })
 
-        # User service
+    assert isinstance(user_service1.db, sqlite3.Connection)
-        user_service1 = container.user_service()
+    assert isinstance(user_service2.db, sqlite3.Connection)
-        user_service2 = container.user_service()
+    assert user_service1.db is user_service2.db
-        self.assertIsInstance(user_service1, UserService)
-        self.assertIsInstance(user_service2, UserService)
-        self.assertIsNot(user_service1, user_service2)
 
-        self.assertIsInstance(user_service1.db, sqlite3.Connection)
+    # Auth service
-        self.assertIsInstance(user_service2.db, sqlite3.Connection)
+    auth_service1 = container.auth_service()
-        self.assertIs(user_service1.db, user_service2.db)
+    auth_service2 = container.auth_service()
+    assert isinstance(auth_service1, AuthService)
+    assert isinstance(auth_service2, AuthService)
+    assert auth_service1 is not auth_service2
 
-        # Auth service
+    assert isinstance(auth_service1.db, sqlite3.Connection)
-        auth_service1 = container.auth_service()
+    assert isinstance(auth_service2.db, sqlite3.Connection)
-        auth_service2 = container.auth_service()
+    assert auth_service1.db is auth_service2.db
-        self.assertIsInstance(auth_service1, AuthService)
+    assert auth_service1.db is container.database_client()
-        self.assertIsInstance(auth_service2, AuthService)
+    assert auth_service2.db is container.database_client()
-        self.assertIsNot(auth_service1, auth_service2)
 
-        self.assertIsInstance(auth_service1.db, sqlite3.Connection)
+    assert auth_service1.token_ttl == 3600
-        self.assertIsInstance(auth_service2.db, sqlite3.Connection)
+    assert auth_service2.token_ttl == 3600
-        self.assertIs(auth_service1.db, auth_service2.db)
-        self.assertIs(auth_service1.db, container.database_client())
-        self.assertIs(auth_service2.db, container.database_client())
 
-        self.assertEqual(auth_service1.token_ttl, 3600)
+    # Photo service
-        self.assertEqual(auth_service2.token_ttl, 3600)
+    photo_service1 = container.photo_service()
+    photo_service2 = container.photo_service()
+    assert isinstance(photo_service1, PhotoService)
+    assert isinstance(photo_service2, PhotoService)
+    assert photo_service1 is not photo_service2
 
-        # Photo service
+    assert isinstance(photo_service1.db, sqlite3.Connection)
-        photo_service1 = container.photo_service()
+    assert isinstance(photo_service2.db, sqlite3.Connection)
-        photo_service2 = container.photo_service()
+    assert photo_service1.db is photo_service2.db
-        self.assertIsInstance(photo_service1, PhotoService)
+    assert photo_service1.db is container.database_client()
-        self.assertIsInstance(photo_service2, PhotoService)
+    assert photo_service2.db is container.database_client()
-        self.assertIsNot(photo_service1, photo_service2)
 
-        self.assertIsInstance(photo_service1.db, sqlite3.Connection)
+    assert photo_service1.s3 is photo_service2.s3
-        self.assertIsInstance(photo_service2.db, sqlite3.Connection)
+    assert photo_service1.s3 is container.s3_client()
-        self.assertIs(photo_service1.db, photo_service2.db)
+    assert photo_service2.s3 is container.s3_client()
-        self.assertIs(photo_service1.db, container.database_client())
-        self.assertIs(photo_service2.db, container.database_client())
-
-        self.assertIs(photo_service1.s3, photo_service2.s3)
-        self.assertIs(photo_service1.s3, container.s3_client())
-        self.assertIs(photo_service2.s3, 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")
+    container.core.config.from_dict({
+        "database": {
+            "dsn": ":memory:",
+        },
+        "aws": {
+            "access_key_id": "KEY",
+            "secret_access_key": "SECRET",
+        },
+        "auth": {
+            "token_ttl": 3600,
+        },
+    })
 
-    def test(self):
+    # User service
-        container = containers.DynamicContainer()
+    user_service1 = container.services.user()
-        container.from_yaml_schema(f"{_SAMPLES_DIR}/schemasample/container-multiple.yml")
+    user_service2 = container.services.user()
-        container.core.config.from_dict({
+    assert isinstance(user_service1, UserService)
-            "database": {
+    assert isinstance(user_service2, UserService)
-                "dsn": ":memory:",
+    assert user_service1 is not user_service2
-            },
-            "aws": {
-                "access_key_id": "KEY",
-                "secret_access_key": "SECRET",
-            },
-            "auth": {
-                "token_ttl": 3600,
-            },
-        })
 
-        # User service
+    assert isinstance(user_service1.db, sqlite3.Connection)
-        user_service1 = container.services.user()
+    assert isinstance(user_service2.db, sqlite3.Connection)
-        user_service2 = container.services.user()
+    assert user_service1.db is user_service2.db
-        self.assertIsInstance(user_service1, UserService)
-        self.assertIsInstance(user_service2, UserService)
-        self.assertIsNot(user_service1, user_service2)
 
-        self.assertIsInstance(user_service1.db, sqlite3.Connection)
+    # Auth service
-        self.assertIsInstance(user_service2.db, sqlite3.Connection)
+    auth_service1 = container.services.auth()
-        self.assertIs(user_service1.db, user_service2.db)
+    auth_service2 = container.services.auth()
+    assert isinstance(auth_service1, AuthService)
+    assert isinstance(auth_service2, AuthService)
+    assert auth_service1 is not auth_service2
 
-        # Auth service
+    assert isinstance(auth_service1.db, sqlite3.Connection)
-        auth_service1 = container.services.auth()
+    assert isinstance(auth_service2.db, sqlite3.Connection)
-        auth_service2 = container.services.auth()
+    assert auth_service1.db is auth_service2.db
-        self.assertIsInstance(auth_service1, AuthService)
+    assert auth_service1.db is container.gateways.database_client()
-        self.assertIsInstance(auth_service2, AuthService)
+    assert auth_service2.db is container.gateways.database_client()
-        self.assertIsNot(auth_service1, auth_service2)
 
-        self.assertIsInstance(auth_service1.db, sqlite3.Connection)
+    assert auth_service1.token_ttl == 3600
-        self.assertIsInstance(auth_service2.db, sqlite3.Connection)
+    assert auth_service2.token_ttl == 3600
-        self.assertIs(auth_service1.db, auth_service2.db)
-        self.assertIs(auth_service1.db, container.gateways.database_client())
-        self.assertIs(auth_service2.db, container.gateways.database_client())
 
-        self.assertEqual(auth_service1.token_ttl, 3600)
+    # Photo service
-        self.assertEqual(auth_service2.token_ttl, 3600)
+    photo_service1 = container.services.photo()
+    photo_service2 = container.services.photo()
+    assert isinstance(photo_service1, PhotoService)
+    assert isinstance(photo_service2, PhotoService)
+    assert photo_service1 is not photo_service2
 
-        # Photo service
+    assert isinstance(photo_service1.db, sqlite3.Connection)
-        photo_service1 = container.services.photo()
+    assert isinstance(photo_service2.db, sqlite3.Connection)
-        photo_service2 = container.services.photo()
+    assert photo_service1.db is photo_service2.db
-        self.assertIsInstance(photo_service1, PhotoService)
+    assert photo_service1.db is container.gateways.database_client()
-        self.assertIsInstance(photo_service2, PhotoService)
+    assert photo_service2.db is container.gateways.database_client()
-        self.assertIsNot(photo_service1, photo_service2)
 
-        self.assertIsInstance(photo_service1.db, sqlite3.Connection)
+    assert photo_service1.s3 is photo_service2.s3
-        self.assertIsInstance(photo_service2.db, sqlite3.Connection)
+    assert photo_service1.s3 is container.gateways.s3_client()
-        self.assertIs(photo_service1.db, photo_service2.db)
+    assert photo_service2.s3 is container.gateways.s3_client()
-        self.assertIs(photo_service1.db, container.gateways.database_client())
-        self.assertIs(photo_service2.db, container.gateways.database_client())
-
-        self.assertIs(photo_service1.s3, photo_service2.s3)
-        self.assertIs(photo_service1.s3, container.gateways.s3_client())
-        self.assertIs(photo_service2.s3, 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")
+    container.core.config.from_dict({
+        "database": {
+            "dsn": ":memory:",
+        },
+        "aws": {
+            "access_key_id": "KEY",
+            "secret_access_key": "SECRET",
+        },
+        "auth": {
+            "token_ttl": 3600,
+        },
+    })
 
-    def test(self):
+    # User service
-        container = containers.DynamicContainer()
+    user_service1 = container.services.user()
-        container.from_yaml_schema(f"{_SAMPLES_DIR}/schemasample/container-multiple-reordered.yml")
+    user_service2 = container.services.user()
-        container.core.config.from_dict({
+    assert isinstance(user_service1, UserService)
-            "database": {
+    assert isinstance(user_service2, UserService)
-                "dsn": ":memory:",
+    assert user_service1 is not user_service2
-            },
-            "aws": {
-                "access_key_id": "KEY",
-                "secret_access_key": "SECRET",
-            },
-            "auth": {
-                "token_ttl": 3600,
-            },
-        })
 
-        # User service
+    assert isinstance(user_service1.db, sqlite3.Connection)
-        user_service1 = container.services.user()
+    assert isinstance(user_service2.db, sqlite3.Connection)
-        user_service2 = container.services.user()
+    assert user_service1.db is user_service2.db
-        self.assertIsInstance(user_service1, UserService)
-        self.assertIsInstance(user_service2, UserService)
-        self.assertIsNot(user_service1, user_service2)
 
-        self.assertIsInstance(user_service1.db, sqlite3.Connection)
+    # Auth service
-        self.assertIsInstance(user_service2.db, sqlite3.Connection)
+    auth_service1 = container.services.auth()
-        self.assertIs(user_service1.db, user_service2.db)
+    auth_service2 = container.services.auth()
+    assert isinstance(auth_service1, AuthService)
+    assert isinstance(auth_service2, AuthService)
+    assert auth_service1 is not auth_service2
 
-        # Auth service
+    assert isinstance(auth_service1.db, sqlite3.Connection)
-        auth_service1 = container.services.auth()
+    assert isinstance(auth_service2.db, sqlite3.Connection)
-        auth_service2 = container.services.auth()
+    assert auth_service1.db is auth_service2.db
-        self.assertIsInstance(auth_service1, AuthService)
+    assert auth_service1.db is container.gateways.database_client()
-        self.assertIsInstance(auth_service2, AuthService)
+    assert auth_service2.db is container.gateways.database_client()
-        self.assertIsNot(auth_service1, auth_service2)
 
-        self.assertIsInstance(auth_service1.db, sqlite3.Connection)
+    assert auth_service1.token_ttl == 3600
-        self.assertIsInstance(auth_service2.db, sqlite3.Connection)
+    assert auth_service2.token_ttl == 3600
-        self.assertIs(auth_service1.db, auth_service2.db)
-        self.assertIs(auth_service1.db, container.gateways.database_client())
-        self.assertIs(auth_service2.db, container.gateways.database_client())
 
-        self.assertEqual(auth_service1.token_ttl, 3600)
+    # Photo service
-        self.assertEqual(auth_service2.token_ttl, 3600)
+    photo_service1 = container.services.photo()
+    photo_service2 = container.services.photo()
+    assert isinstance(photo_service1, PhotoService)
+    assert isinstance(photo_service2, PhotoService)
+    assert photo_service1 is not photo_service2
 
-        # Photo service
+    assert isinstance(photo_service1.db, sqlite3.Connection)
-        photo_service1 = container.services.photo()
+    assert isinstance(photo_service2.db, sqlite3.Connection)
-        photo_service2 = container.services.photo()
+    assert photo_service1.db is photo_service2.db
-        self.assertIsInstance(photo_service1, PhotoService)
+    assert photo_service1.db is container.gateways.database_client()
-        self.assertIsInstance(photo_service2, PhotoService)
+    assert photo_service2.db is container.gateways.database_client()
-        self.assertIsNot(photo_service1, photo_service2)
 
-        self.assertIsInstance(photo_service1.db, sqlite3.Connection)
+    assert photo_service1.s3 is photo_service2.s3
-        self.assertIsInstance(photo_service2.db, sqlite3.Connection)
+    assert photo_service1.s3 is container.gateways.s3_client()
-        self.assertIs(photo_service1.db, photo_service2.db)
+    assert photo_service2.s3 is container.gateways.s3_client()
-        self.assertIs(photo_service1.db, container.gateways.database_client())
-        self.assertIs(photo_service2.db, container.gateways.database_client())
-
-        self.assertIs(photo_service1.s3, photo_service2.s3)
-        self.assertIs(photo_service1.s3, container.gateways.s3_client())
-        self.assertIs(photo_service2.s3, 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")
+    container.core.config.from_dict({
+        "database": {
+            "dsn": ":memory:",
+        },
+        "aws": {
+            "access_key_id": "KEY",
+            "secret_access_key": "SECRET",
+        },
+        "auth": {
+            "token_ttl": 3600,
+        },
+    })
 
-    def test(self):
+    # User service
-        container = containers.DynamicContainer()
+    user_service1 = container.services.user()
-        container.from_yaml_schema(f"{_SAMPLES_DIR}/schemasample/container-multiple-inline.yml")
+    user_service2 = container.services.user()
-        container.core.config.from_dict({
+    assert isinstance(user_service1, UserService)
-            "database": {
+    assert isinstance(user_service2, UserService)
-                "dsn": ":memory:",
+    assert user_service1 is not user_service2
-            },
-            "aws": {
-                "access_key_id": "KEY",
-                "secret_access_key": "SECRET",
-            },
-            "auth": {
-                "token_ttl": 3600,
-            },
-        })
 
-        # User service
+    assert isinstance(user_service1.db, sqlite3.Connection)
-        user_service1 = container.services.user()
+    assert isinstance(user_service2.db, sqlite3.Connection)
-        user_service2 = container.services.user()
+    assert user_service1.db is user_service2.db
-        self.assertIsInstance(user_service1, UserService)
-        self.assertIsInstance(user_service2, UserService)
-        self.assertIsNot(user_service1, user_service2)
 
-        self.assertIsInstance(user_service1.db, sqlite3.Connection)
+    # Auth service
-        self.assertIsInstance(user_service2.db, sqlite3.Connection)
+    auth_service1 = container.services.auth()
-        self.assertIs(user_service1.db, user_service2.db)
+    auth_service2 = container.services.auth()
+    assert isinstance(auth_service1, AuthService)
+    assert isinstance(auth_service2, AuthService)
+    assert auth_service1 is not auth_service2
 
-        # Auth service
+    assert isinstance(auth_service1.db, sqlite3.Connection)
-        auth_service1 = container.services.auth()
+    assert isinstance(auth_service2.db, sqlite3.Connection)
-        auth_service2 = container.services.auth()
+    assert auth_service1.db is auth_service2.db
-        self.assertIsInstance(auth_service1, AuthService)
+    assert auth_service1.db is container.gateways.database_client()
-        self.assertIsInstance(auth_service2, AuthService)
+    assert auth_service2.db is container.gateways.database_client()
-        self.assertIsNot(auth_service1, auth_service2)
 
-        self.assertIsInstance(auth_service1.db, sqlite3.Connection)
+    assert auth_service1.token_ttl == 3600
-        self.assertIsInstance(auth_service2.db, sqlite3.Connection)
+    assert auth_service2.token_ttl == 3600
-        self.assertIs(auth_service1.db, auth_service2.db)
-        self.assertIs(auth_service1.db, container.gateways.database_client())
-        self.assertIs(auth_service2.db, container.gateways.database_client())
 
-        self.assertEqual(auth_service1.token_ttl, 3600)
+    # Photo service
-        self.assertEqual(auth_service2.token_ttl, 3600)
+    photo_service1 = container.services.photo()
+    photo_service2 = container.services.photo()
+    assert isinstance(photo_service1, PhotoService)
+    assert isinstance(photo_service2, PhotoService)
+    assert photo_service1 is not photo_service2
 
-        # Photo service
+    assert isinstance(photo_service1.db, sqlite3.Connection)
-        photo_service1 = container.services.photo()
+    assert isinstance(photo_service2.db, sqlite3.Connection)
-        photo_service2 = container.services.photo()
+    assert photo_service1.db is photo_service2.db
-        self.assertIsInstance(photo_service1, PhotoService)
+    assert photo_service1.db is container.gateways.database_client()
-        self.assertIsInstance(photo_service2, PhotoService)
+    assert photo_service2.db is container.gateways.database_client()
-        self.assertIsNot(photo_service1, photo_service2)
 
-        self.assertIsInstance(photo_service1.db, sqlite3.Connection)
+    assert photo_service1.s3 is photo_service2.s3
-        self.assertIsInstance(photo_service2.db, sqlite3.Connection)
+    assert photo_service1.s3 is container.gateways.s3_client()
-        self.assertIs(photo_service1.db, photo_service2.db)
+    assert photo_service2.s3 is container.gateways.s3_client()
-        self.assertIs(photo_service1.db, container.gateways.database_client())
-        self.assertIs(photo_service2.db, container.gateways.database_client())
-
-        self.assertIs(photo_service1.s3, photo_service2.s3)
-        self.assertIs(photo_service1.s3, container.gateways.s3_client())
-        self.assertIs(photo_service2.s3, 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):
+    container.from_yaml_schema(f"{SAMPLES_DIR}/schemasample/container-boto3-session.yml")
+    container.config.from_dict(
+        {
+            "aws_access_key_id": "key",
+            "aws_secret_access_key": "secret",
+            "aws_session_token": "token",
+            "aws_region_name": "us-east-1",
+        },
+    )
 
-    @unittest.skip("Boto3 tries to connect to the internet")
+    assert container.s3_client().__class__.__name__ == "S3"
-    def test(self):
+    assert container.sqs_client().__class__.__name__ == "SQS"
-        container = containers.DynamicContainer()
-        container.from_yaml_schema(f"{_SAMPLES_DIR}/schemasample/container-boto3-session.yml")
-        container.config.from_dict(
-            {
-                "aws_access_key_id": "key",
-                "aws_secret_access_key": "secret",
-                "aws_session_token": "token",
-                "aws_region_name": "us-east-1",
-            },
-        )
-
-        self.assertEqual(container.s3_client().__class__.__name__, "S3")
-        self.assertEqual(container.sqs_client().__class__.__name__, "SQS")