mountaineer 0.5.0.dev2__tar.gz → 0.5.0.dev4__tar.gz

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

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

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

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

{mountaineer-0.5.0.dev2 → mountaineer-0.5.0.dev4}/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.dev4}/PKG-INFO

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

{mountaineer-0.5.0.dev2 → mountaineer-0.5.0.dev4}/ci_webapp/ci_webapp/cli.py

@@ -1,5 +1,5 @@
 from click import command
-from mountaineer.cli import handle_runserver, handle_watch
+from mountaineer.cli import handle_build, handle_runserver, handle_watch
 
 
 @command()
@@ -20,3 +20,10 @@ def watch():
         webcontroller="ci_webapp.app:controller",
         subscribe_to_mountaineer=True,
     )
+
+
+@command()
+def build():
+    handle_build(
+        webcontroller="ci_webapp.app:controller",
+    )

{mountaineer-0.5.0.dev2 → mountaineer-0.5.0.dev4}/ci_webapp/ci_webapp/controllers/root_layout.py

@@ -4,6 +4,7 @@ from mountaineer.actions import sideeffect
 
 class RootLayoutRender(RenderBase):
     layout_value: int
+    layout_arg: int
 
 
 class RootLayoutController(LayoutControllerBase):
@@ -13,9 +14,10 @@ class RootLayoutController(LayoutControllerBase):
         super().__init__()
         self.layout_value = 0
 
-    def render(self) -> RootLayoutRender:
+    def render(self, layout_arg: int | None = None) -> RootLayoutRender:
         return RootLayoutRender(
             layout_value=self.layout_value,
+            layout_arg=layout_arg or 0,
         )
 
     @sideeffect

{mountaineer-0.5.0.dev2 → mountaineer-0.5.0.dev4}/ci_webapp/ci_webapp/views/app/layout.tsx

@@ -6,7 +6,9 @@ const Layout = ({ children }: { children: ReactNode }) => {
 
   return (
     <div className="p-6">
-      <h1>Layout State: {serverState.layout_value}</h1>
+      <h1>
+        Layout State: {serverState.layout_value} : {serverState.layout_arg}
+      </h1>
       <div>{children}</div>
       <div>
         <button

{mountaineer-0.5.0.dev2 → mountaineer-0.5.0.dev4}/ci_webapp/pyproject.toml

@@ -14,6 +14,7 @@ mountaineer = { path = "../", develop = true }
 [tool.poetry.scripts]
 runserver = "ci_webapp.cli:runserver"
 watch = "ci_webapp.cli:watch"
+build = "ci_webapp.cli:build"
 
 [tool.poetry.group.dev.dependencies]
 types-setuptools = "^69.0.0.20240125"

mountaineer-0.5.0.dev4/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.dev2 → mountaineer-0.5.0.dev4}/docs_website/docs/views.md

@@ -239,13 +239,9 @@ app_controller = AppController(...)
 app_controller.register(RootLayoutController())
 ```
 
-In general you can implement layout controllers just like you do for pages. But since they're shared across multiple pages there are a few important differences to keep in mind:
+In general you can implement layout controllers just like you do for pages. But since they're shared across multiple child controllers, make sure the keyword arguments you use in your `render` signature don't have any conflicts. Mountaineer will merge these signatures at runtime and check for duplicate keyword names across the layout's child pages. Arguments are allowed to share the same name _and_ type, in which case they will be resolved to the same value. Arguments with conflicting types will raise a `TypeError`.
 
-- Layout controllers will be rendered in an isolated scope. Sideeffects in one layout controller won't affect the others.
-- Dependency injections are similarly isolated. They are run in an isolated, synthetic context and not with the same dependency injection parameters that the page uses.
-- Layout controllers don't modify the page signature. Query params on layouts won't be extracted, for instance.
-
-As long as you write your layout controllers without directly referencing the page that they might be wrapping, which is the case for most layouts, you should be good to go.
+It's also worth noting that layout controllers will resolve their dependencies in the same scope as the page controllers. So if you need database access within your layout, you'll receive the same underlying transaction as the page controller. This makes dependency injection a powerful way to save on resources, but be careful to not treat them as isolated objects.
 
 ## Typescript Configuration
 

{mountaineer-0.5.0.dev2 → mountaineer-0.5.0.dev4}/mountaineer/__tests__/actions/test_fields.py

@@ -1,4 +1,4 @@
-from typing import AsyncIterator, Iterator, Optional, Type, cast
+from typing import AsyncIterator, Iterator, Optional, Type
 
 import pytest
 from fastapi.responses import JSONResponse
@@ -124,24 +124,19 @@ def test_fuse_metadata_to_response_typehint(
         metadata, sample_controller, render_model
     )
 
-    assert "ExampleController" in raw_model.model_fields.keys()
-
-    fused_model = cast(
-        BaseModel, raw_model.model_fields["ExampleController"].annotation
-    )
     if expected_sideeffect_fields:
-        assert "sideeffect" in fused_model.model_fields.keys()
-        assert fused_model.model_fields["sideeffect"].annotation
+        assert "sideeffect" in raw_model.model_fields.keys()
+        assert raw_model.model_fields["sideeffect"].annotation
         basic_compare_model_fields(
-            fused_model.model_fields["sideeffect"].annotation.model_fields,
+            raw_model.model_fields["sideeffect"].annotation.model_fields,
             expected_sideeffect_fields,
         )
 
     if expected_passthrough_fields:
-        assert "passthrough" in fused_model.model_fields.keys()
-        assert fused_model.model_fields["passthrough"].annotation
+        assert "passthrough" in raw_model.model_fields.keys()
+        assert raw_model.model_fields["passthrough"].annotation
         basic_compare_model_fields(
-            fused_model.model_fields["passthrough"].annotation.model_fields,
+            raw_model.model_fields["passthrough"].annotation.model_fields,
             expected_passthrough_fields,
         )
 

{mountaineer-0.5.0.dev2 → mountaineer-0.5.0.dev4}/mountaineer/__tests__/actions/test_passthrough_dec.py

@@ -100,11 +100,9 @@ async def test_can_call_passthrough():
 
     # The response payload should be the same both both sync and async endpoints
     expected_response = {
-        "TestController": {
-            "passthrough": ExamplePassthroughModel(
-                status="success",
-            )
-        }
+        "passthrough": ExamplePassthroughModel(
+            status="success",
+        )
     }
 
     assert return_value_sync == expected_response

{mountaineer-0.5.0.dev2 → mountaineer-0.5.0.dev4}/mountaineer/__tests__/actions/test_sideeffect_dec.py

@@ -101,13 +101,11 @@ async def call_sideeffect_common(controller: ControllerCommon):
 
         # The response payload should be the same both both sync and async endpoints
         expected_response = {
-            controller.__class__.__name__: {
-                "sideeffect": ExampleRenderModel(
-                    value_a="Hello",
-                    value_b="World",
-                ),
-                "passthrough": None,
-            }
+            "sideeffect": ExampleRenderModel(
+                value_a="Hello",
+                value_b="World",
+            ),
+            "passthrough": None,
         }
 
         assert return_value_sync == expected_response
@@ -279,10 +277,8 @@ def test_limit_codepath_experimental(
     elapsed = (monotonic_ns() - start) / 1e9
     assert response.status_code == 200
     assert response.json() == {
-        "ExampleController": {
-            "sideeffect": {
-                "value_a": "Hello 1229",
-            }
+        "sideeffect": {
+            "value_a": "Hello 1229",
         }
     }
 

mountaineer-0.5.0.dev4/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.dev4/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.dev4/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",
+            },
+        ),
+    ]