iceaxe 0.7.0.dev2__tar.gz → 0.7.1__tar.gz

{iceaxe-0.7.0.dev2/iceaxe.egg-info → iceaxe-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iceaxe
-Version: 0.7.0.dev2
+Version: 0.7.1
 Summary: A modern, fast ORM for Python.
 Author-email: Pierce Freeman <pierce@freeman.vc>
 Requires-Python: >=3.11

{iceaxe-0.7.0.dev2 → iceaxe-0.7.1}/iceaxe/__tests__/conftest.py

@@ -1,84 +1,151 @@
+import logging
+
 import asyncpg
 import pytest
 import pytest_asyncio
 
+from iceaxe.__tests__ import docker_helpers
 from iceaxe.base import DBModelMetaclass
 from iceaxe.session import DBConnection
 
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+@pytest.fixture(scope="session")
+def docker_postgres():
+    """
+    Fixture that creates a PostgreSQL container using the Python Docker API.
+    This allows running individual tests without needing Docker Compose.
+    """
+    # Create and start a PostgreSQL container
+    postgres_container = docker_helpers.PostgresContainer()
+
+    # Start the container and yield connection details
+    connection_info = postgres_container.start()
+    yield connection_info
+
+    # Cleanup: stop the container
+    postgres_container.stop()
+
 
 @pytest_asyncio.fixture
-async def db_connection():
+async def db_connection(docker_postgres):
+    """
+    Create a database connection using the PostgreSQL container.
+    """
     conn = DBConnection(
         await asyncpg.connect(
-            host="localhost",
-            port=5438,
-            user="iceaxe",
-            password="mysecretpassword",
-            database="iceaxe_test_db",
+            host=docker_postgres["host"],
+            port=docker_postgres["port"],
+            user=docker_postgres["user"],
+            password=docker_postgres["password"],
+            database=docker_postgres["database"],
         )
     )
 
     # Drop all tables first to ensure clean state
-    await conn.conn.execute("DROP TABLE IF EXISTS artifactdemo CASCADE")
-    await conn.conn.execute("DROP TABLE IF EXISTS userdemo CASCADE")
-    await conn.conn.execute("DROP TABLE IF EXISTS complexdemo CASCADE")
-    await conn.conn.execute("DROP TABLE IF EXISTS article CASCADE")
+    known_tables = [
+        "artifactdemo",
+        "userdemo",
+        "complexdemo",
+        "article",
+        "employee",
+        "department",
+        "projectassignment",
+        "employeemetadata",
+        "functiondemomodel",
+        "demomodela",
+        "demomodelb",
+        "jsondemo",
+        "complextypedemo",
+    ]
+    known_types = ["statusenum", "employeestatus"]
+
+    for table in known_tables:
+        await conn.conn.execute(f"DROP TABLE IF EXISTS {table} CASCADE", timeout=30.0)
+
+    for known_type in known_types:
+        await conn.conn.execute(
+            f"DROP TYPE IF EXISTS {known_type} CASCADE", timeout=30.0
+        )
 
     # Create tables
-    await conn.conn.execute("""
+    await conn.conn.execute(
+        """
         CREATE TABLE IF NOT EXISTS userdemo (
             id SERIAL PRIMARY KEY,
             name TEXT,
             email TEXT
         )
-    """)
+    """,
+        timeout=30.0,
+    )
 
-    await conn.conn.execute("""
+    await conn.conn.execute(
+        """
         CREATE TABLE IF NOT EXISTS artifactdemo (
             id SERIAL PRIMARY KEY,
             title TEXT,
             user_id INT REFERENCES userdemo(id)
         )
-    """)
+    """,
+        timeout=30.0,
+    )
 
-    await conn.conn.execute("""
+    await conn.conn.execute(
+        """
         CREATE TABLE IF NOT EXISTS complexdemo (
             id SERIAL PRIMARY KEY,
             string_list TEXT[],
             json_data JSON
         )
-    """)
+    """,
+        timeout=30.0,
+    )
 
-    await conn.conn.execute("""
+    await conn.conn.execute(
+        """
         CREATE TABLE IF NOT EXISTS article (
             id SERIAL PRIMARY KEY,
             title TEXT,
             content TEXT,
             summary TEXT
         )
-    """)
+    """,
+        timeout=30.0,
+    )
 
     # Create each index separately to handle errors better
     yield conn
 
     # Drop all tables after tests
-    await conn.conn.execute("DROP TABLE IF EXISTS artifactdemo CASCADE")
-    await conn.conn.execute("DROP TABLE IF EXISTS userdemo CASCADE")
-    await conn.conn.execute("DROP TABLE IF EXISTS complexdemo CASCADE")
-    await conn.conn.execute("DROP TABLE IF EXISTS article CASCADE")
+    for table in known_tables:
+        await conn.conn.execute(f"DROP TABLE IF EXISTS {table} CASCADE", timeout=30.0)
+
+    # Drop all types after tests
+    for known_type in known_types:
+        await conn.conn.execute(
+            f"DROP TYPE IF EXISTS {known_type} CASCADE", timeout=30.0
+        )
+
     await conn.conn.close()
 
 
 @pytest_asyncio.fixture()
 async def indexed_db_connection(db_connection: DBConnection):
     await db_connection.conn.execute(
-        "CREATE INDEX IF NOT EXISTS article_title_tsv_idx ON article USING GIN (to_tsvector('english', title))"
+        "CREATE INDEX IF NOT EXISTS article_title_tsv_idx ON article USING GIN (to_tsvector('english', title))",
+        timeout=30.0,
     )
     await db_connection.conn.execute(
-        "CREATE INDEX IF NOT EXISTS article_content_tsv_idx ON article USING GIN (to_tsvector('english', content))"
+        "CREATE INDEX IF NOT EXISTS article_content_tsv_idx ON article USING GIN (to_tsvector('english', content))",
+        timeout=30.0,
     )
     await db_connection.conn.execute(
-        "CREATE INDEX IF NOT EXISTS article_summary_tsv_idx ON article USING GIN (to_tsvector('english', summary))"
+        "CREATE INDEX IF NOT EXISTS article_summary_tsv_idx ON article USING GIN (to_tsvector('english', summary))",
+        timeout=30.0,
     )
 
     yield db_connection
@@ -88,7 +155,7 @@ async def indexed_db_connection(db_connection: DBConnection):
 async def clear_table(db_connection):
     # Clear all tables and reset sequences
     await db_connection.conn.execute(
-        "TRUNCATE TABLE userdemo, article RESTART IDENTITY CASCADE"
+        "TRUNCATE TABLE userdemo, article RESTART IDENTITY CASCADE", timeout=30.0
     )
 
 
@@ -107,7 +174,8 @@ async def clear_all_database_objects(db_connection: DBConnection):
                 EXECUTE 'DROP TABLE IF EXISTS ' || quote_ident(r.tablename) || ' CASCADE';
             END LOOP;
         END $$;
-    """
+    """,
+        timeout=30.0,
     )
 
     # Step 2: Drop all custom types in the public schema
@@ -120,7 +188,8 @@ async def clear_all_database_objects(db_connection: DBConnection):
                 EXECUTE 'DROP TYPE IF EXISTS ' || quote_ident(r.typname) || ' CASCADE';
             END LOOP;
         END $$;
-    """
+    """,
+        timeout=30.0,
     )
 
 

iceaxe-0.7.1/iceaxe/__tests__/docker_helpers.py

@@ -0,0 +1,208 @@
+"""
+Docker helper utilities for testing.
+
+This module provides classes and functions to manage Docker containers for testing,
+particularly focusing on PostgreSQL database containers.
+"""
+
+import logging
+import socket
+import time
+import uuid
+from typing import Any, Dict, Optional, cast
+
+import docker
+from docker.errors import APIError
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+def get_free_port() -> int:
+    """Find a free port on the host machine."""
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("", 0))
+        return s.getsockname()[1]
+
+
+class PostgresContainer:
+    """
+    A class that manages a PostgreSQL Docker container for testing.
+
+    This class handles the lifecycle of a PostgreSQL container, including:
+    - Starting the container with appropriate configuration
+    - Finding available ports
+    - Waiting for the container to be ready
+    - Providing connection information
+    - Cleaning up after tests
+    """
+
+    def __init__(
+        self,
+        pg_user: str = "iceaxe",
+        pg_password: str = "mysecretpassword",
+        pg_db: str = "iceaxe_test_db",
+        postgres_version: str = "16",
+    ):
+        self.pg_user = pg_user
+        self.pg_password = pg_password
+        self.pg_db = pg_db
+        self.postgres_version = postgres_version
+        self.port = get_free_port()
+        self.container: Optional[Any] = None
+        self.client = docker.from_env()
+        self.container_name = f"iceaxe-postgres-test-{uuid.uuid4().hex[:8]}"
+
+    def start(self) -> Dict[str, Any]:
+        """
+        Start the PostgreSQL container.
+
+        Returns:
+            Dict[str, Any]: Connection information for the PostgreSQL container
+
+        Raises:
+            RuntimeError: If the container fails to start or become ready
+        """
+        logger.info(f"Starting PostgreSQL container on port {self.port}")
+
+        max_attempts = 3
+        attempt = 0
+
+        while attempt < max_attempts:
+            attempt += 1
+            try:
+                self.container = self._run_container(self.port)
+                break
+            except APIError as e:
+                if "port is already allocated" in str(e) and attempt < max_attempts:
+                    logger.warning(
+                        f"Port {self.port} is still in use. Trying with a new port (attempt {attempt}/{max_attempts})."
+                    )
+                    self.port = get_free_port()
+                else:
+                    raise RuntimeError(f"Failed to start PostgreSQL container: {e}")
+
+        # Wait for PostgreSQL to be ready
+        if not self._wait_for_container_ready():
+            self.stop()
+            raise RuntimeError("Failed to connect to PostgreSQL container")
+
+        return self.get_connection_info()
+
+    def _run_container(
+        self, port: int
+    ) -> Any:  # Type as Any since docker.models.containers.Container isn't imported
+        """
+        Run the Docker container with the specified port.
+
+        Args:
+            port: The port to map PostgreSQL to on the host
+
+        Returns:
+            The Docker container object
+        """
+        return self.client.containers.run(
+            f"postgres:{self.postgres_version}",
+            name=self.container_name,
+            detach=True,
+            environment={
+                "POSTGRES_USER": self.pg_user,
+                "POSTGRES_PASSWORD": self.pg_password,
+                "POSTGRES_DB": self.pg_db,
+                # Additional settings for faster startup in testing
+                "POSTGRES_HOST_AUTH_METHOD": "trust",
+            },
+            ports={"5432/tcp": port},
+            remove=True,  # Auto-remove container when stopped
+        )
+
+    def _wait_for_container_ready(self) -> bool:
+        """
+        Wait for the PostgreSQL container to be ready.
+
+        Returns:
+            bool: True if the container is ready, False otherwise
+        """
+        max_retries = 30
+        retry_interval = 1
+
+        for i in range(max_retries):
+            try:
+                if self.container is None:
+                    logger.warning("Container is None, cannot proceed")
+                    return False
+
+                # We've already checked that self.container is not None
+                container = cast(Any, self.container)
+                container.reload()  # Refresh container status
+                if container.status != "running":
+                    logger.warning(f"Container status: {container.status}")
+                    return False
+
+                # Try to connect to PostgreSQL
+                conn = socket.create_connection(("localhost", self.port), timeout=1)
+                conn.close()
+                # Wait a bit more to ensure PostgreSQL is fully initialized
+                time.sleep(2)
+                logger.info(f"PostgreSQL container is ready after {i + 1} attempt(s)")
+                return True
+            except (socket.error, ConnectionRefusedError) as e:
+                if i == max_retries - 1:
+                    logger.warning(
+                        f"Failed to connect after {max_retries} attempts: {e}"
+                    )
+                    return False
+                time.sleep(retry_interval)
+            except Exception as e:
+                logger.warning(f"Unexpected error checking container readiness: {e}")
+                if i == max_retries - 1:
+                    return False
+                time.sleep(retry_interval)
+
+        return False
+
+    def stop(self) -> None:
+        """
+        Stop the PostgreSQL container.
+
+        This method ensures the container is properly stopped and removed.
+        """
+        if self.container is not None:
+            try:
+                logger.info(f"Stopping PostgreSQL container {self.container_name}")
+                # We've already checked that self.container is not None
+                container = cast(Any, self.container)
+                container.stop(timeout=10)  # Allow 10 seconds for graceful shutdown
+            except Exception as e:
+                logger.warning(f"Failed to stop container: {e}")
+                try:
+                    # Force remove as a fallback
+                    if self.container is not None:
+                        self.container.remove(force=True)
+                    logger.info("Forced container removal")
+                except Exception as e2:
+                    logger.warning(f"Failed to force remove container: {e2}")
+
+    def get_connection_info(self) -> Dict[str, Any]:
+        """
+        Get the connection information for the PostgreSQL container.
+
+        Returns:
+            Dict[str, Any]: A dictionary containing connection parameters
+        """
+        return {
+            "host": "localhost",
+            "port": self.port,
+            "user": self.pg_user,
+            "password": self.pg_password,
+            "database": self.pg_db,
+        }
+
+    def get_connection_string(self) -> str:
+        """
+        Get a PostgreSQL connection string.
+
+        Returns:
+            str: A connection string in the format 'postgresql://user:password@host:port/database'
+        """
+        return f"postgresql://{self.pg_user}:{self.pg_password}@localhost:{self.port}/{self.pg_db}"

{iceaxe-0.7.0.dev2 → iceaxe-0.7.1}/iceaxe/__tests__/migrations/test_action_sorter.py

@@ -19,7 +19,7 @@ class MockNode(DBObject):
     async def create(self, actor: DatabaseActions):
         pass
 
-    async def migrate(self, previous: "MockNode", actor: DatabaseActions):
+    async def migrate(self, previous: DBObject, actor: DatabaseActions):
         pass
 
     async def destroy(self, actor: DatabaseActions):

{iceaxe-0.7.0.dev2 → iceaxe-0.7.1}/iceaxe/__tests__/schemas/test_actions.py

@@ -263,8 +263,8 @@ async def test_add_column_any_type(
         (ColumnType.SERIAL, ColumnType.INTEGER),
         (ColumnType.BIGSERIAL, ColumnType.BIGINT),
         (ColumnType.CHAR, "character"),
-        (ColumnType.TIME, "time without time zone"),
-        (ColumnType.TIMESTAMP, "timestamp without time zone"),
+        (ColumnType.TIME_WITHOUT_TIME_ZONE, "time without time zone"),
+        (ColumnType.TIMESTAMP_WITHOUT_TIME_ZONE, "timestamp without time zone"),
     )
 
     allowed_values = {enum_value.value}
@@ -365,7 +365,7 @@ async def test_modify_column_type(
         (ColumnType.VARCHAR, ColumnType.DATE, "2023-01-01", "2023-01-01", True),
         (
             ColumnType.TEXT,
-            ColumnType.TIMESTAMP,
+            ColumnType.TIMESTAMP_WITHOUT_TIME_ZONE,
             "2023-01-01 12:00:00",
             "2023-01-01 12:00:00",
             True,
@@ -443,7 +443,7 @@ async def test_modify_column_type_with_autocast(
     actual_value = row[column_name]
     if isinstance(expected_value, str) and to_type in [
         ColumnType.DATE,
-        ColumnType.TIMESTAMP,
+        ColumnType.TIMESTAMP_WITHOUT_TIME_ZONE,
     ]:
         # For date/timestamp, convert to string for comparison
         actual_value = str(actual_value)
@@ -1158,7 +1158,7 @@ async def test_modify_column_type_date_to_timestamp(
     await db_backed_actions.modify_column_type(
         table_name,
         column_name,
-        explicit_data_type=ColumnType.TIMESTAMP,
+        explicit_data_type=ColumnType.TIMESTAMP_WITHOUT_TIME_ZONE,
         autocast=False,
     )
 

{iceaxe-0.7.0.dev2 → iceaxe-0.7.1}/iceaxe/__tests__/schemas/test_db_memory_serializer.py

@@ -750,7 +750,7 @@ def test_enum_column_assignment(clear_all_database_objects):
                     DBColumn(
                         table_name="exampledbmodel",
                         column_name="standard_datetime",
-                        column_type=ColumnType.TIMESTAMP,
+                        column_type=ColumnType.TIMESTAMP_WITHOUT_TIME_ZONE,
                         column_is_list=False,
                         nullable=False,
                     ),
@@ -810,7 +810,7 @@ def test_enum_column_assignment(clear_all_database_objects):
                     DBColumn(
                         table_name="exampledbmodel",
                         column_name="standard_time",
-                        column_type=ColumnType.TIME,
+                        column_type=ColumnType.TIME_WITHOUT_TIME_ZONE,
                         column_is_list=False,
                         nullable=False,
                     ),

{iceaxe-0.7.0.dev2 → iceaxe-0.7.1}/iceaxe/__tests__/schemas/test_db_serializer.py

@@ -143,6 +143,52 @@ class ValueEnumInt(IntEnum):
                 )
             ],
         ),
+        # Test PostgreSQL's storage format for timestamp without timezone
+        (
+            """
+            CREATE TABLE exampledbmodel (
+                id SERIAL PRIMARY KEY,
+                created_at TIMESTAMP NOT NULL
+            );
+            """,
+            [
+                (
+                    DBColumn(
+                        table_name="exampledbmodel",
+                        column_name="created_at",
+                        column_type=ColumnType.TIMESTAMP_WITHOUT_TIME_ZONE,
+                        column_is_list=False,
+                        nullable=False,
+                    ),
+                    [
+                        DBTable(table_name="exampledbmodel"),
+                    ],
+                )
+            ],
+        ),
+        # Test PostgreSQL's storage format for timestamp with timezone
+        (
+            """
+            CREATE TABLE exampledbmodel (
+                id SERIAL PRIMARY KEY,
+                created_at TIMESTAMPTZ NOT NULL
+            );
+            """,
+            [
+                (
+                    DBColumn(
+                        table_name="exampledbmodel",
+                        column_name="created_at",
+                        column_type=ColumnType.TIMESTAMP_WITH_TIME_ZONE,
+                        column_is_list=False,
+                        nullable=False,
+                    ),
+                    [
+                        DBTable(table_name="exampledbmodel"),
+                    ],
+                )
+            ],
+        ),
     ],
 )
 async def test_simple_db_serializer(

{iceaxe-0.7.0.dev2 → iceaxe-0.7.1}/iceaxe/__tests__/test_comparison.py

@@ -10,6 +10,7 @@ from iceaxe.base import TableBase
 from iceaxe.comparison import ComparisonType, FieldComparison
 from iceaxe.field import DBFieldClassDefinition, DBFieldInfo
 from iceaxe.queries_str import QueryLiteral
+from iceaxe.sql_types import ColumnType
 from iceaxe.typing import column
 
 
@@ -354,3 +355,29 @@ def test_force_join_constraints(
     )
     forced = comparison.force_join_constraints()
     assert forced.comparison == expected_comparison
+
+
+@pytest.mark.parametrize(
+    "sql_type_string, expected_column_type",
+    [
+        ("timestamp", ColumnType.TIMESTAMP_WITHOUT_TIME_ZONE),  # Tests aliasing
+        ("timestamp without time zone", ColumnType.TIMESTAMP_WITHOUT_TIME_ZONE),
+        ("timestamp with time zone", ColumnType.TIMESTAMP_WITH_TIME_ZONE),
+        ("time", ColumnType.TIME_WITHOUT_TIME_ZONE),  # Tests aliasing
+        ("time without time zone", ColumnType.TIME_WITHOUT_TIME_ZONE),
+        ("time with time zone", ColumnType.TIME_WITH_TIME_ZONE),
+    ],
+)
+def test_postgres_datetime_timezone_casting(
+    sql_type_string: str, expected_column_type: ColumnType
+):
+    """
+    Test that PostgresDateTime fields with different timezone configurations
+    are properly handled by the ColumnType enum, specifically testing that
+    PostgreSQL's storage format ('timestamp without time zone') can be parsed.
+    This also tests that SQL standard aliases like "timestamp" correctly map
+    to "timestamp without time zone".
+    """
+
+    # Test that ColumnType enum can handle PostgreSQL's storage formats and aliases
+    assert ColumnType(sql_type_string) == expected_column_type