container refactoring to testcontainer.io

Author: atstaeff

tests/shared/build_database.py

@@ -1,5 +1,16 @@
-from .docker.image import Image
-
+import docker
+from docker import errors
 
 def build_database(dockerfile_directory: str) -> None:
-    Image('eventsourcingdb', 'latest').build(dockerfile_directory)
+    """Build the database image using the Docker SDK."""
+    client = docker.from_env()
+    try:
+        client.images.build(
+            path=dockerfile_directory,
+            tag='eventsourcingdb:latest',
+            rm=True
+        )
+    except errors.BuildError as e:
+        raise RuntimeError(f"Failed to build database image: {e}")
+    except errors.APIError as e:
+        raise RuntimeError(f"Docker API error: {e}")

tests/shared/containerized_testing_database.py

@@ -1,40 +1,45 @@
 import uuid
-
 from eventsourcingdb.client import Client
-
-from .containerized_testing_database import ContainerizedTestingDatabase
-from .docker.image import Image
+from eventsourcingdb.container import Container
 from .testing_database import TestingDatabase
 
-
 class Database:
     __create_key = object()
 
     def __init__(
         self,
         create_key,
-        with_authorization: ContainerizedTestingDatabase,
+        with_authorization: TestingDatabase,
         with_invalid_url: TestingDatabase
     ):
         assert create_key == Database.__create_key, \
             'Database objects must be created using Database.create.'
 
-        self.with_authorization: ContainerizedTestingDatabase = with_authorization
+        self.with_authorization: TestingDatabase = with_authorization
         self.with_invalid_url: TestingDatabase = with_invalid_url
 
     @classmethod
     async def create(cls) -> 'Database':
-        image = Image('eventsourcingdb', 'latest')
-
         api_token = str(uuid.uuid4())
-        with_authorization = await ContainerizedTestingDatabase.create(
-            image,
-            ['run', '--api-token', f'{api_token}', '--data-directory-temporary'],
-            api_token,
+        
+        # Erstellen und Starten des Containers mit der zentralen Container-Klasse
+        container = Container(
+            api_token=api_token
+        )
+        container.start()
+        
+        # Client mit Autorisierung erstellen
+        with_authorization_client = container.get_client()
+        await with_authorization_client.initialize()
+        with_authorization = TestingDatabase(
+            with_authorization_client,
+            container  # Container an TestingDatabase übergeben für cleanup
         )
 
+        # Client mit ungültiger URL erstellen - api_token statt auth_token verwenden
         with_invalid_url_client = Client(
-            base_url='http://localhost.invalid', api_token=api_token
+            base_url='http://localhost.invalid',
+            api_token=api_token
         )
         await with_invalid_url_client.initialize()
         with_invalid_url = TestingDatabase(

tests/shared/database.py

@@ -1,11 +1,21 @@
-from dataclasses import dataclass
-
+from typing import Optional
 from eventsourcingdb.client import Client
+from eventsourcingdb.container import Container
 
-
-@dataclass
 class TestingDatabase:
-    client: Client
+    def __init__(
+        self,
+        client: Client,
+        container: Optional[Container] = None
+    ):
+        self.__client = client
+        self.__container = container
 
     async def stop(self) -> None:
+        if self.__container is not None:
+            self.__container.stop()
         await self.client.close()
+
+    @property
+    def client(self) -> Client:
+        return self.__client