mountaineer 0.5.0.dev2__tar.gz → 0.5.0.dev3__tar.gz

{mountaineer-0.5.0.dev2 → mountaineer-0.5.0.dev3}/Cargo.lock

@@ -535,7 +535,7 @@ dependencies = [
 
 [[package]]
 name = "mountaineer"
-version = "0.5.0-dev2"
+version = "0.5.0-dev3"
 dependencies = [
  "criterion",
  "deno_core_icudata",

{mountaineer-0.5.0.dev2 → mountaineer-0.5.0.dev3}/Cargo.toml

@@ -15,7 +15,7 @@ harness = false
 
 [package]
 name = "mountaineer"
-version = "0.5.0-dev2"
+version = "0.5.0-dev3"
 edition = "2021"
 
 [dependencies]

{mountaineer-0.5.0.dev2 → mountaineer-0.5.0.dev3}/Makefile

@@ -95,7 +95,11 @@ lint-validation-scripts:
 
 # Tests
 test-lib:
+	(cd $(LIB_DIR) && docker-compose -f docker-compose.test.yml up -d)
+	@$(call wait-for-postgres,30,5438)
+	@set -e; \
 	$(call test-common,$(LIB_DIR),$(LIB_NAME))
+	(cd $(LIB_DIR) && docker-compose -f docker-compose.test.yml down)
 	$(call test-rust-common,$(LIB_DIR),$(LIB_NAME))
 test-create-mountaineer-app:
 	$(call test-common,$(CREATE_MOUNTAINEER_APP_DIR),$(CREATE_MOUNTAINEER_APP_NAME))

{mountaineer-0.5.0.dev2 → mountaineer-0.5.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: mountaineer
-Version: 0.5.0.dev2
+Version: 0.5.0.dev3
 Requires-Dist: pydantic
 Requires-Dist: fastapi
 Requires-Dist: inflection

mountaineer-0.5.0.dev3/docker-compose.test.yml

@@ -0,0 +1,16 @@
+version: "3.8"
+
+services:
+  postgres:
+    image: postgres:latest
+    environment:
+      POSTGRES_USER: mountaineer
+      POSTGRES_PASSWORD: mysecretpassword
+      POSTGRES_DB: mountaineer_test_db
+    ports:
+      - "5438:5432"
+    volumes:
+      - postgres_data_test:/var/lib/postgresql/data
+
+volumes:
+  postgres_data_test:

mountaineer-0.5.0.dev3/mountaineer/__tests__/migrations/conftest.py

@@ -0,0 +1,135 @@
+from contextlib import asynccontextmanager, contextmanager
+from os import environ
+from warnings import filterwarnings
+
+import pytest
+import pytest_asyncio
+from fastapi import Depends
+from sqlalchemy import exc as sa_exc
+from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_sessionmaker
+from sqlmodel import SQLModel, text
+
+from mountaineer.config import ConfigBase, unregister_config
+from mountaineer.database import DatabaseDependencies
+from mountaineer.database.config import DatabaseConfig
+from mountaineer.dependencies.base import get_function_dependencies
+from mountaineer.test_utilities import bootstrap_database
+
+
+@contextmanager
+def clear_registration_metadata():
+    """
+    Temporarily clear the sqlalchemy metadata
+
+    """
+    archived_tables = SQLModel.metadata.tables
+    archived_schemas = SQLModel.metadata._schemas
+    archived_memos = SQLModel.metadata._fk_memos
+
+    try:
+        SQLModel.metadata.clear()
+        yield
+    finally:
+        # Restore
+        SQLModel.metadata.tables = archived_tables
+        SQLModel.metadata._schemas = archived_schemas
+        SQLModel.metadata._fk_memos = archived_memos
+
+
+@pytest_asyncio.fixture
+async def clear_all_database_objects(db_session: AsyncSession):
+    """
+    Clear all database objects, including those not directly created through
+    SQLAlchemy.
+
+    """
+    # Step 1: Drop all tables in the public schema
+    await db_session.execute(
+        text(
+            """
+        DO $$ DECLARE
+            r RECORD;
+        BEGIN
+            FOR r IN (SELECT tablename FROM pg_tables WHERE schemaname = 'public') LOOP
+                EXECUTE 'DROP TABLE IF EXISTS ' || quote_ident(r.tablename) || ' CASCADE';
+            END LOOP;
+        END $$;
+    """
+        )
+    )
+
+    # Step 2: Drop all custom types in the public schema
+    await db_session.execute(
+        text(
+            """
+        DO $$ DECLARE
+            r RECORD;
+        BEGIN
+            FOR r IN (SELECT typname FROM pg_type WHERE typtype = 'e' AND typnamespace = (SELECT oid FROM pg_namespace WHERE nspname = 'public')) LOOP
+                EXECUTE 'DROP TYPE IF EXISTS ' || quote_ident(r.typname) || ' CASCADE';
+            END LOOP;
+        END $$;
+    """
+        )
+    )
+
+    await db_session.commit()
+
+
+@pytest.fixture
+def isolated_sqlalchemy(clear_all_database_objects):
+    """
+    Drops database tables and clears the metadata that is registered
+    in-memory, just for this test
+
+    """
+    # Avoid also creating the tables for other SQLModels that have been defined
+    # in memory (and therefore captured in the same registry)
+    with clear_registration_metadata():
+        # Overrides the warning that we see when creating multiple ExampleDBModels
+        # in one session
+        filterwarnings("ignore", category=sa_exc.SAWarning)
+
+        yield
+
+
+class MigrationAppConfig(ConfigBase, DatabaseConfig):
+    pass
+
+
+@pytest.fixture(autouse=True)
+def config():
+    """
+    Test-time configuration. Set to auto-use the fixture so that the configuration
+    is mounted and exposed to the dependency injection framework in all tests.
+
+    """
+    unregister_config()
+    return MigrationAppConfig(
+        POSTGRES_HOST=environ.get("TEST_POSTGRES_HOST", "localhost"),
+        POSTGRES_USER=environ.get("TEST_POSTGRES_USER", "mountaineer"),
+        POSTGRES_PASSWORD=environ.get("TEST_POSTGRES_PASSWORD", "mysecretpassword"),
+        POSTGRES_DB=environ.get("TEST_POSTGRES_DB", "mountaineer_test_db"),
+        POSTGRES_PORT=int(environ.get("POSTGRES_PORT", "5438")),
+    )
+
+
+@pytest_asyncio.fixture(scope="function")
+async def db_engine(config: MigrationAppConfig):
+    @asynccontextmanager
+    async def run_bootstrap(
+        engine: AsyncEngine = Depends(DatabaseDependencies.get_db),
+    ):
+        await bootstrap_database(engine)
+        yield engine
+
+    async with get_function_dependencies(callable=run_bootstrap) as values:
+        async with run_bootstrap(**values) as engine:
+            yield engine
+
+
+@pytest_asyncio.fixture
+async def db_session(db_engine: AsyncEngine):
+    session_maker = async_sessionmaker(db_engine, expire_on_commit=False)
+    async with session_maker() as session:
+        yield session

mountaineer-0.5.0.dev3/mountaineer/__tests__/migrations/test_actions.py

@@ -0,0 +1,50 @@
+from unittest.mock import AsyncMock
+
+import pytest
+
+from mountaineer.migrations.actions import DatabaseActions, DryRunAction
+
+
+def example_action_fn(arg_1: str):
+    pass
+
+
+@pytest.mark.asyncio
+async def test_record_signature_dry_run():
+    database_actions = DatabaseActions(dry_run=True)
+
+    await database_actions._record_signature(
+        example_action_fn, {"arg_1": "test"}, "SQL"
+    )
+
+    assert database_actions.dry_run_actions == [
+        DryRunAction(fn=example_action_fn, kwargs={"arg_1": "test"})
+    ]
+    assert database_actions.prod_sqls == []
+
+
+@pytest.mark.asyncio
+async def test_record_signature_prod():
+    database_actions = DatabaseActions(dry_run=False, db_session=AsyncMock())
+
+    await database_actions._record_signature(
+        example_action_fn, {"arg_1": "test"}, "SQL"
+    )
+
+    assert database_actions.dry_run_actions == []
+    assert database_actions.prod_sqls == ["SQL"]
+
+
+@pytest.mark.asyncio
+async def test_record_signature_incorrect_kwarg():
+    database_actions = DatabaseActions(dry_run=False, db_session=AsyncMock())
+
+    # An extra, non-existent kwarg is provided
+    with pytest.raises(ValueError):
+        await database_actions._record_signature(
+            example_action_fn, {"arg_1": "test", "arg_2": "test"}, "SQL"
+        )
+
+    # A required kwarg is missing
+    with pytest.raises(ValueError):
+        await database_actions._record_signature(example_action_fn, {}, "SQL")

mountaineer-0.5.0.dev3/mountaineer/__tests__/migrations/test_db_memory_serializer.py

@@ -0,0 +1,194 @@
+from enum import Enum
+from unittest.mock import ANY
+
+import pytest
+from sqlmodel import Field, SQLModel
+
+from mountaineer.migrations.actions import (
+    ColumnType,
+    ConstraintType,
+    DatabaseActions,
+    DryRunAction,
+    DryRunComment,
+)
+from mountaineer.migrations.db_memory_serializer import DatabaseMemorySerializer
+
+
+@pytest.mark.asyncio
+async def test_from_scratch_migration():
+    """
+    Test a migration from scratch.
+
+    """
+
+    class OldValues(Enum):
+        A = "A"
+
+    class ModelA(SQLModel):
+        id: int = Field(primary_key=True)
+        animal: OldValues
+        was_nullable: str | None
+
+    migrator = DatabaseMemorySerializer()
+
+    db_objects = list(migrator.delegate([ModelA], context=None))
+    next_ordering = migrator.order_db_objects(db_objects)
+
+    actor = DatabaseActions()
+    actions = await migrator.build_actions(
+        actor, [], {}, [obj for obj, _ in db_objects], next_ordering
+    )
+
+    assert actions == [
+        DryRunComment(
+            text="\n" "NEW TABLE: modela\n",
+        ),
+        DryRunAction(
+            fn=actor.add_table,
+            kwargs={
+                "table_name": "modela",
+            },
+        ),
+        DryRunAction(
+            fn=actor.add_column,
+            kwargs={
+                "column_name": "id",
+                "custom_data_type": None,
+                "explicit_data_is_list": False,
+                "explicit_data_type": ColumnType.INTEGER,
+                "table_name": "modela",
+            },
+        ),
+        DryRunAction(
+            fn=actor.add_type,
+            kwargs={
+                "type_name": "oldvalues",
+                "values": [
+                    "A",
+                ],
+            },
+        ),
+        DryRunAction(
+            fn=actor.add_column,
+            kwargs={
+                "column_name": "was_nullable",
+                "custom_data_type": None,
+                "explicit_data_is_list": False,
+                "explicit_data_type": ColumnType.VARCHAR,
+                "table_name": "modela",
+            },
+        ),
+        DryRunAction(
+            fn=actor.add_constraint,
+            kwargs={
+                "columns": [
+                    "id",
+                ],
+                "constraint": ConstraintType.PRIMARY_KEY,
+                "constraint_args": None,
+                "constraint_name": "modela_pkey",
+                "table_name": "modela",
+            },
+        ),
+        DryRunAction(
+            fn=actor.add_column,
+            kwargs={
+                "column_name": "animal",
+                "custom_data_type": "oldvalues",
+                "explicit_data_is_list": False,
+                "explicit_data_type": None,
+                "table_name": "modela",
+            },
+        ),
+    ]
+
+
+@pytest.mark.asyncio
+async def test_diff_migration():
+    """
+    Test the diff migration between two schemas.
+
+    """
+
+    class OldValues(Enum):
+        A = "A"
+
+    class NewValues(Enum):
+        A = "A"
+        B = "B"
+
+    class ModelA(SQLModel):
+        id: int = Field(primary_key=True)
+        animal: OldValues
+        was_nullable: str | None
+
+    class ModelANew(SQLModel):
+        __tablename__ = "modela"  # type: ignore
+        id: int = Field(primary_key=True)
+        name: str
+        animal: NewValues
+        was_nullable: str
+
+    actor = DatabaseActions()
+    migrator = DatabaseMemorySerializer()
+
+    db_objects = list(migrator.delegate([ModelA], context=None))
+    db_objects_previous = [obj for obj, _ in db_objects]
+    previous_ordering = migrator.order_db_objects(db_objects)
+
+    db_objects_new = list(migrator.delegate([ModelANew], context=None))
+    db_objects_next = [obj for obj, _ in db_objects_new]
+    next_ordering = migrator.order_db_objects(db_objects_new)
+
+    actor = DatabaseActions()
+    actions = await migrator.build_actions(
+        actor, db_objects_previous, previous_ordering, db_objects_next, next_ordering
+    )
+    assert actions == [
+        DryRunAction(
+            fn=actor.add_column,
+            kwargs={
+                "column_name": "name",
+                "custom_data_type": None,
+                "explicit_data_is_list": False,
+                "explicit_data_type": ColumnType.VARCHAR,
+                "table_name": "modela",
+            },
+        ),
+        DryRunAction(
+            fn=actor.add_type,
+            kwargs={
+                "type_name": "newvalues",
+                "values": [
+                    "A",
+                    "B",
+                ],
+            },
+        ),
+        DryRunAction(
+            fn=actor.add_not_null,
+            kwargs={
+                "column_name": "was_nullable",
+                "table_name": "modela",
+            },
+        ),
+        DryRunComment(
+            text=ANY,
+        ),
+        DryRunAction(
+            fn=actor.modify_column_type,
+            kwargs={
+                "column_name": "animal",
+                "custom_data_type": "newvalues",
+                "explicit_data_is_list": False,
+                "explicit_data_type": None,
+                "table_name": "modela",
+            },
+        ),
+        DryRunAction(
+            fn=actor.drop_type,
+            kwargs={
+                "type_name": "oldvalues",
+            },
+        ),
+    ]