fix linting for tests

Author: atstaeff

tests/shared/database.py

@@ -1,9 +1,11 @@
-import uuid
+import logging
+import os
 import time
+import uuid
+
 from eventsourcingdb.client import Client
 from eventsourcingdb.container import Container
 from .testing_database import TestingDatabase
-import os
 
 
 class Database:
@@ -21,82 +23,95 @@ def __init__(
         self.with_authorization: TestingDatabase = with_authorization
         self.with_invalid_url: TestingDatabase = with_invalid_url
 
-    @classmethod
-    async def create(cls, max_retries=3, retry_delay=2.0) -> 'Database':
-        """Create a new Database instance with retry mechanism for container startup"""
-        api_token = str(uuid.uuid4())
-
-        dockerfile_path = os.path.join(
-            os.path.dirname(__file__),
-            'docker/eventsourcingdb/Dockerfile')
-        with open(dockerfile_path, 'r') as dockerfile:
-            content = dockerfile.read().strip()
-            image_tag = content.split(':')[-1]
-
-        container = Container(
+    @staticmethod
+    def _create_container(api_token, image_tag):
+        return Container(
             image_name="thenativeweb/eventsourcingdb",
             image_tag=image_tag,
             api_token=api_token,
             internal_port=3000
         )
 
-        # Try with retries
+    @staticmethod
+    async def _initialize_clients(container, api_token):
+        with_authorization_client = container.get_client()
+        await with_authorization_client.initialize()
+
+        with_authorization = TestingDatabase(
+            with_authorization_client,
+            container
+        )
+
+        with_invalid_url_client = Client(
+            base_url='http://localhost.invalid',
+            api_token=api_token
+        )
+        await with_invalid_url_client.initialize()
+
+        with_invalid_url = TestingDatabase(
+            with_invalid_url_client
+        )
+        return with_authorization, with_invalid_url
+
+    @staticmethod
+    def _stop_container_safely(container):
+        """Safely stop a container, ignoring errors"""
+        try:
+            container.stop()
+        except OSError:
+            pass
+
+    @classmethod
+    async def create(cls, max_retries=3, retry_delay=2.0) -> 'Database':
+        api_token = str(uuid.uuid4())
+        image_tag = cls._get_image_tag_from_dockerfile()
+        container = cls._create_container(api_token, image_tag)
+        error = None
+
         for attempt in range(max_retries):
             try:
-                # Start the container with timeout handling
                 container.start()
-
-                # Create client with authorization
-                with_authorization_client = container.get_client()
-                await with_authorization_client.initialize()
-                with_authorization = TestingDatabase(
-                    with_authorization_client,
-                    container  # Pass container to TestingDatabase for cleanup
+            except OSError as caught_error:
+                error = caught_error
+                retry = True
+            except Exception as unexpected_error:
+                cls._stop_container_safely(container)
+                raise unexpected_error
+            else:
+                retry = False
+
+            if retry:
+                if attempt == max_retries - 1:
+                    cls._stop_container_safely(container)
+                    msg = f"Failed to initialize database container after {max_retries} attempts"
+                    raise RuntimeError(f"{msg}: {error}") from error
+                logging.warning(
+                    "Container startup attempt %d failed: %s. Retrying in %s seconds...",
+                    attempt + 1, error, retry_delay
                 )
+                time.sleep(retry_delay)
+                cls._stop_container_safely(container)
+                container = cls._create_container(api_token, "latest")
+                continue
 
-                # Create client with invalid URL but valid token
-                with_invalid_url_client = Client(
-                    base_url='http://localhost.invalid',
-                    api_token=api_token
-                )
-                await with_invalid_url_client.initialize()
-                with_invalid_url = TestingDatabase(
-                    with_invalid_url_client
-                )
+            try:
+                auth_db, invalid_url_db = await cls._initialize_clients(container, api_token)
+            except Exception as client_error:
+                cls._stop_container_safely(container)
+                raise client_error
 
-                return cls(Database.__create_key, with_authorization, with_invalid_url)
+            return cls(Database.__create_key, auth_db, invalid_url_db)
 
-            except Exception as e:
-                # On the last attempt, raise the error
-                if attempt == max_retries - 1:
-                    # Cleanup the container if it was created
-                    try:
-                        container.stop()
-                    except BaseException:
-                        pass
-                    raise RuntimeError(
-                        f"Failed to initialize database container after {max_retries} attempts: {e}")
-
-                # Otherwise wait and retry
-                print(
-                    f"Container startup attempt {
-                        attempt +
-                        1} failed: {e}. Retrying in {retry_delay} seconds...")
-                time.sleep(retry_delay)
+        raise RuntimeError("Failed to create database: Unexpected error during retry loop")
 
-                # Try to clean up the failed container before retrying
-                try:
-                    container.stop()
-                except BaseException:
-                    pass
-
-                # Create a new container for the next attempt
-                container = Container(
-                    image_name="thenativeweb/eventsourcingdb",
-                    image_tag="latest",
-                    api_token=api_token,
-                    internal_port=3000
-                )
+    @staticmethod
+    def _get_image_tag_from_dockerfile():
+        dockerfile_path = os.path.join(
+            os.path.dirname(__file__),
+            'docker/eventsourcingdb/Dockerfile')
+        with open(dockerfile_path, 'r', encoding='utf-8') as dockerfile:
+            content = dockerfile.read().strip()
+            return content.split(':')[-1]
 
     async def stop(self):
         await self.with_authorization.stop()

tests/shared/testing_database.py

@@ -1,4 +1,3 @@
-from typing import Optional
 from eventsourcingdb.client import Client
 from eventsourcingdb.container import Container
 
@@ -7,7 +6,7 @@ class TestingDatabase:
     def __init__(
         self,
         client: Client,
-        container: Optional[Container] = None
+        container: Container | None = None
     ):
         self.__client = client
         self.__container = container

tests/test_read_event_types.py

@@ -47,11 +47,11 @@ async def test_reads_all_types_of_existing_events_and_registered_schemas(
 
         await client.register_event_schema(
             "org.ban.ban",
-            {"type": "object", "properties": {}}  # Add required properties field
+            {"type": "object", "properties": {}}  # Added required properties field
         )
         await client.register_event_schema(
             "org.bing.chilling",
-            {"type": "object", "properties": {}}  # Add required properties field
+            {"type": "object", "properties": {}}  # Added required properties field
         )
 
         actual_event_types: set[EventType] = set()
@@ -82,12 +82,12 @@ async def test_reads_all_types_of_existing_events_and_registered_schemas(
             EventType(
                 event_type="org.ban.ban",
                 is_phantom=True,
-                schema={"type": "object", "properties": {}},  # Update expected schema
+                schema={"type": "object", "properties": {}},  # Updated expected schema
             ),
             EventType(
                 event_type="org.bing.chilling",
                 is_phantom=True,
-                schema={"type": "object", "properties": {}},  # Update expected schema
+                schema={"type": "object", "properties": {}},  # Updated expected schema
             ),
         }