planar 0.5.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

planar/test_cli.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from unittest.mock import MagicMock, patch
+from unittest.mock import patch
 
 import pytest
 import typer
@@ -14,11 +14,9 @@ def cli_runner():
 
 
 @pytest.fixture
-def mock_planar_server():
-    with patch("planar.cli.PlanarServer") as mock_server_class:
-        mock_server_instance = MagicMock()
-        mock_server_class.return_value = mock_server_instance
-        yield mock_server_class, mock_server_instance
+def mock_uvicorn_run():
+    with patch("planar.cli.uvicorn.run") as mock_run:
+        yield mock_run
 
 
 @pytest.fixture
@@ -35,7 +33,7 @@ def mock_path_is_file():
 
 class TestDevCommand:
     def test_dev_command_defaults(
-        self, cli_runner, mock_planar_server, mock_path_is_file
+        self, cli_runner, mock_uvicorn_run, mock_path_is_file
     ):
         """Test that 'planar dev' sets correct defaults and invokes uvicorn.run."""
         env = {}
@@ -43,15 +41,15 @@ class TestDevCommand:
             result = cli_runner.invoke(app, ["dev"])
 
         assert result.exit_code == 0
-        mock_planar_server[1].run.assert_called_once()
+        mock_uvicorn_run.assert_called_once()
 
         # Verify uvicorn.run arguments
-        run_args = mock_planar_server[0].call_args[0]
-        config = run_args[0]
-        assert config.app == "app:app"
-        assert config.reload is True
-        assert config.host == "127.0.0.1"
-        assert config.port == 8000
+        call_args = mock_uvicorn_run.call_args
+        assert call_args[0][0] == "app:app"
+        assert call_args.kwargs["reload"] is True
+        assert call_args.kwargs["host"] == "127.0.0.1"
+        assert call_args.kwargs["port"] == 8000
+        assert call_args.kwargs["timeout_graceful_shutdown"] == 4
 
         # Verify environment variable
         assert env["PLANAR_ENV"] == "dev"
@@ -59,7 +57,7 @@ class TestDevCommand:
 
 class TestProdCommand:
     def test_prod_command_defaults(
-        self, cli_runner, mock_planar_server, mock_path_is_file
+        self, cli_runner, mock_uvicorn_run, mock_path_is_file
     ):
         """Test that 'planar prod' sets correct defaults and invokes uvicorn.run."""
         env = {}
@@ -67,15 +65,15 @@ class TestProdCommand:
             result = cli_runner.invoke(app, ["prod"])
 
         assert result.exit_code == 0
-        mock_planar_server[1].run.assert_called_once()
+        mock_uvicorn_run.assert_called_once()
 
         # Verify uvicorn.run arguments
-        run_args = mock_planar_server[0].call_args[0]
-        config = run_args[0]
-        assert config.app == "app:app"
-        assert config.reload is False
-        assert config.host == "0.0.0.0"
-        assert config.port == 8000
+        call_args = mock_uvicorn_run.call_args
+        assert call_args[0][0] == "app:app"
+        assert call_args.kwargs["reload"] is False
+        assert call_args.kwargs["host"] == "0.0.0.0"
+        assert call_args.kwargs["port"] == 8000
+        assert call_args.kwargs["timeout_graceful_shutdown"] == 4
 
         # Verify environment variable
         assert env["PLANAR_ENV"] == "prod"
@@ -84,7 +82,7 @@ class TestProdCommand:
 class TestArgumentParsing:
     @pytest.mark.parametrize("command", ["dev", "prod"])
     def test_custom_port(
-        self, cli_runner, mock_planar_server, mock_path_is_file, command
+        self, cli_runner, mock_uvicorn_run, mock_path_is_file, command
     ):
         """Test custom port settings for both dev and prod commands."""
         port = "9999"
@@ -92,54 +90,80 @@ class TestArgumentParsing:
             result = cli_runner.invoke(app, [command, "--port", port])
 
         assert result.exit_code == 0
-        mock_planar_server[1].run.assert_called_once()
+        mock_uvicorn_run.assert_called_once()
 
         # Verify config arguments
-        run_args = mock_planar_server[0].call_args[0]
-        config = run_args[0]
-        assert config.port == int(port)
+        call_args = mock_uvicorn_run.call_args
+        assert call_args.kwargs["port"] == int(port)
 
     @pytest.mark.parametrize("command", ["dev", "prod"])
     def test_custom_host(
-        self, cli_runner, mock_planar_server, mock_path_is_file, command
+        self, cli_runner, mock_uvicorn_run, mock_path_is_file, command
     ):
-        """Test custom host settings for both dev and prod commands."""
-        host = "1.1.1.1"
+        """Test custom host settings."""
+        host = "0.0.0.0"
         with patch("os.environ", {}):
             result = cli_runner.invoke(app, [command, "--host", host])
 
         assert result.exit_code == 0
-        mock_planar_server[1].run.assert_called_once()
+        mock_uvicorn_run.assert_called_once()
 
         # Verify config arguments
-        run_args = mock_planar_server[0].call_args[0]
-        config = run_args[0]
-        assert config.host == host
+        call_args = mock_uvicorn_run.call_args
+        assert call_args.kwargs["host"] == host
 
     @pytest.mark.parametrize("command", ["dev", "prod"])
     def test_custom_app_name(
-        self, cli_runner, mock_planar_server, mock_path_is_file, command
+        self, cli_runner, mock_uvicorn_run, mock_path_is_file, command
     ):
-        """Test specifying --app custom_app generates the correct import string."""
+        """Test custom app instance name."""
         with (
             patch("os.environ", {}),
-            patch("planar.cli.get_module_str_from_path", return_value="module"),
+            patch("planar.cli.get_module_str_from_path", return_value="app"),
         ):
-            result = cli_runner.invoke(app, [command, "--app", "custom_app"])
+            result = cli_runner.invoke(app, [command, "--app", "server"])
 
         assert result.exit_code == 0
-        mock_planar_server[1].run.assert_called_once()
+        mock_uvicorn_run.assert_called_once()
 
         # Verify config arguments
-        run_args = mock_planar_server[0].call_args[0]
-        config = run_args[0]
-        assert config.app == "module:custom_app"
+        call_args = mock_uvicorn_run.call_args
+        assert call_args[0][0] == "app:server"
+
+    @pytest.mark.parametrize("command", ["dev", "prod"])
+    def test_custom_path(
+        self, cli_runner, mock_uvicorn_run, mock_path_is_file, command
+    ):
+        """Test custom application path."""
+        path = "custom/app.py"
+        with (
+            patch("os.environ", {}),
+            patch("planar.cli.get_module_str_from_path", return_value="custom.app"),
+        ):
+            result = cli_runner.invoke(app, [command, path])
+
+        assert result.exit_code == 0
+        mock_uvicorn_run.assert_called_once()
+
+        # Verify config arguments
+        call_args = mock_uvicorn_run.call_args
+        assert call_args[0][0] == "custom.app:app"
+
+    @pytest.mark.parametrize("command", ["dev", "prod"])
+    def test_invalid_path(self, cli_runner, mock_uvicorn_run, command):
+        """Test handling of invalid path."""
+        with patch("pathlib.Path.is_file", return_value=False):
+            result = cli_runner.invoke(app, [command, "nonexistent/app.py"])
+
+        assert result.exit_code == 1
+        assert "not found" in result.output
+        mock_uvicorn_run.assert_not_called()
 
 
 class TestAppPathResolution:
     @pytest.mark.parametrize("command", ["dev", "prod"])
     def test_explicit_path(
-        self, cli_runner, mock_planar_server, mock_path_is_file, command
+        self, cli_runner, mock_uvicorn_run, mock_path_is_file, command
     ):
         """Test command --path sets PLANAR_ENTRY_POINT and generates correct import string."""
         env = {}
@@ -151,12 +175,11 @@ class TestAppPathResolution:
 
         assert result.exit_code == 0
         assert env["PLANAR_ENTRY_POINT"] == "path/to/app.py"
-        mock_planar_server[1].run.assert_called_once()
+        mock_uvicorn_run.assert_called_once()
 
         # Verify config arguments
-        run_args = mock_planar_server[0].call_args[0]
-        config = run_args[0]
-        assert config.app == "path.to.app:app"
+        call_args = mock_uvicorn_run.call_args
+        assert call_args[0][0] == "path.to.app:app"
 
     @pytest.mark.parametrize(
         "path,error_text",
@@ -183,7 +206,7 @@ class TestDefaultPathDiscovery:
         ],
     )
     def test_default_files(
-        self, cli_runner, mock_planar_server, file_exists, expected_path
+        self, cli_runner, mock_uvicorn_run, file_exists, expected_path
     ):
         """Test default file discovery works for app.py and main.py."""
         env = {}
@@ -197,7 +220,7 @@ class TestDefaultPathDiscovery:
 
         assert result.exit_code == 0
         assert env["PLANAR_ENTRY_POINT"] == str(expected_path)
-        mock_planar_server[1].run.assert_called_once()
+        mock_uvicorn_run.assert_called_once()
 
     def test_no_default_files(self, cli_runner):
         """Test with neither app.py nor main.py existing: Verify exit code 1 and error message."""
@@ -241,7 +264,7 @@ class TestModuleStringConversion:
 
 
 class TestConfigFileHandling:
-    def test_config_handling(self, cli_runner, mock_planar_server, mock_path_is_file):
+    def test_config_handling(self, cli_runner, mock_uvicorn_run, mock_path_is_file):
         """Test config file handling."""
         env = {}
         with patch("os.environ", env):
@@ -252,7 +275,7 @@ class TestConfigFileHandling:
 
         assert result.exit_code == 0
         assert env["PLANAR_CONFIG"] == "valid/config.yaml"
-        mock_planar_server[1].run.assert_called_once()
+        mock_uvicorn_run.assert_called_once()
 
         # Test invalid config
         with patch("pathlib.Path.exists", return_value=False):
@@ -263,7 +286,7 @@ class TestConfigFileHandling:
 
 
 class TestUvicornInteraction:
-    def test_successful_run(self, cli_runner, mock_planar_server, mock_path_is_file):
+    def test_successful_run(self, cli_runner, mock_uvicorn_run, mock_path_is_file):
         """Test successful uvicorn.run with correct parameters."""
         with (
             patch("os.environ", {}),
@@ -272,15 +295,14 @@ class TestUvicornInteraction:
             result = cli_runner.invoke(app, ["dev", "src/main.py"])
 
         assert result.exit_code == 0
-        mock_planar_server[1].run.assert_called_once()
+        mock_uvicorn_run.assert_called_once()
 
         # Verify config arguments
-        run_args = mock_planar_server[0].call_args[0]
-        config = run_args[0]
-        assert config.app == "src.main:app"
-        assert config.host == "127.0.0.1"
-        assert config.port == 8000
-        assert config.reload is True
+        call_args = mock_uvicorn_run.call_args
+        assert call_args[0][0] == "src.main:app"
+        assert call_args.kwargs["host"] == "127.0.0.1"
+        assert call_args.kwargs["port"] == 8000
+        assert call_args.kwargs["reload"] is True
 
 
 class TestScaffoldCommand:

planar/test_config.py

@@ -7,11 +7,11 @@ import pytest
 
 from planar.config import (
     JWT_COPLANE_CONFIG,
-    JWT_DISABLED_CONFIG,
     LOCAL_CORS_CONFIG,
     PROD_CORS_CONFIG,
     InvalidConfigurationError,
     PostgreSQLConfig,
+    SecurityConfig,
     SQLiteConfig,
     load_config,
     load_environment_aware_config,
@@ -236,11 +236,12 @@ db_connections:
 app:
   db_connection: custom_db
 
-cors:
-  allow_origins: ["https://custom.example.com"]
-  allow_credentials: true
-  allow_methods: ["GET", "POST"]
-  allow_headers: ["Authorization"]
+security:
+    cors:
+        allow_origins: ["https://custom.example.com"]
+        allow_credentials: true
+        allow_methods: ["GET", "POST"]
+        allow_headers: ["Authorization"]
 """
 
 
@@ -250,8 +251,8 @@ def test_load_environment_aware_config_dev_default():
         config = load_environment_aware_config()
 
         assert config.environment == "dev"
-        assert config.cors == LOCAL_CORS_CONFIG
-        assert config.jwt == JWT_DISABLED_CONFIG
+        assert config.security.cors == LOCAL_CORS_CONFIG
+        assert config.security.jwt is None
         assert config.app.db_connection == "app"
         assert isinstance(config.db_connections["app"], SQLiteConfig)
         assert config.db_connections["app"].path == "planar_dev.db"
@@ -265,8 +266,9 @@ def test_load_environment_aware_config_prod_default():
         config = load_environment_aware_config()
 
         assert config.environment == "prod"
-        assert config.cors == PROD_CORS_CONFIG
-        assert config.jwt == JWT_COPLANE_CONFIG
+        assert config.security == SecurityConfig(
+            cors=PROD_CORS_CONFIG, jwt=JWT_COPLANE_CONFIG
+        )
         assert config.app.db_connection == "app"
         assert isinstance(config.db_connections["app"], SQLiteConfig)
         assert config.db_connections["app"].path == "planar.db"
@@ -368,8 +370,9 @@ db_connections:
 def test_load_environment_aware_config_partial_override(temp_config_file):
     """Test that partial override configs merge correctly with defaults."""
     partial_override = """
-cors:
-  allow_origins: ["https://custom.example.com"]
+security:
+  cors:
+    allow_origins: ["https://custom.example.com"]
 """
 
     with open(temp_config_file, "w") as f:
@@ -383,11 +386,11 @@ cors:
         config = load_environment_aware_config()
 
         # Should override specific fields
-        assert config.cors.allow_origins == ["https://custom.example.com"]
+        assert config.security.cors.allow_origins == ["https://custom.example.com"]
 
         # Should keep defaults for non-overridden fields
         assert config.app.db_connection == "app"  # default
-        assert config.cors.allow_credentials  # from LOCAL_CORS_CONFIG
+        assert config.security.cors.allow_credentials  # from LOCAL_CORS_CONFIG
         assert config.environment == "dev"
         assert isinstance(config.db_connections["app"], SQLiteConfig)
 

planar/testing/fixtures.py

@@ -0,0 +1,325 @@
+"""
+Pytest fixtures for the Planar library.
+
+This module provides pytest fixtures that can be used both internally by the planar library
+and by external users who want to test their code that uses planar.
+
+Usage in external projects:
+- By default, these fixtures are auto-loaded when planar is installed
+- To disable auto-loading: set PYTEST_DISABLE_PLUGIN_AUTOLOAD=1
+- To manually enable: use `uv run pytest -p planar` or add to conftest.py:
+  `pytest_plugins = ["planar.testing.fixtures"]`
+  or add to pyproject.toml:
+  `[project.entry-points.pytest11]
+  planar = "planar.testing.fixtures"
+  `
+
+Available fixtures:
+- storage: In-memory file storage for tests
+- tmp_db_url: Parametrized database URL (SQLite/PostgreSQL)
+- session: Database session
+- client: Planar test client
+- observer: Workflow observer for testing
+- tracer: Tracer for workflow testing
+"""
+
+import asyncio
+import os
+import subprocess
+import time
+import uuid
+from contextlib import asynccontextmanager
+from pathlib import Path
+
+import pytest
+
+from planar.config import load_config
+from planar.db import DatabaseManager, new_session
+from planar.files.storage.context import set_storage
+from planar.logging import set_context_metadata
+from planar.object_registry import ObjectRegistry
+from planar.session import engine_var, session_var
+from planar.testing.memory_storage import MemoryStorage
+from planar.testing.planar_test_client import (
+    planar_test_client,
+)
+from planar.testing.workflow_observer import WorkflowObserver
+from planar.workflows.tracing import Tracer
+
+_TEST_DATABASES = []
+if os.getenv("PLANAR_TEST_SQLITE", "1") == "1":
+    _TEST_DATABASES.append("sqlite")
+if os.getenv("PLANAR_TEST_POSTGRESQL", "0") == "1":
+    _TEST_DATABASES.append("postgresql")
+
+
+def load_logging_config():
+    logging_config = os.getenv("PLANAR_TEST_LOGGING_CONFIG", None)
+    if logging_config is None:
+        return None
+    f = Path(logging_config)
+    if not f.exists():
+        print("Logging configuration file does not exist:", f)
+        return None
+    try:
+        text = f.read_text()
+        return load_config(text)
+    except Exception as e:
+        print("Failed to load logging configuration:", e)
+        return None
+
+
+@pytest.fixture(autouse=True, scope="session")
+def configure_session_logging():
+    test_config = load_logging_config()
+    if test_config:
+        if test_config.otel:
+            test_config.otel.resource_attributes = {
+                **(test_config.otel.resource_attributes or {}),
+                "service.name": f"{time.strftime('%Y-%m-%d %H:%M:%S')}-planar-test-run",
+            }
+        test_config.configure_logging()
+
+
+@pytest.fixture(autouse=True)
+async def configure_test_logging(request):
+    # get the current test name
+    set_context_metadata("test.id", request.node.name)
+
+
+@pytest.fixture(autouse=True)
+def reset_object_registry():
+    """
+    Reset the ObjectRegistry singleton before each test to ensure clean state.
+    """
+    ObjectRegistry.get_instance().reset()
+    yield  # Run the test
+
+
+@pytest.fixture()
+def tmp_db_path(tmp_path_factory):
+    """
+    Create a temporary SQLite database file and return its URL. The database
+    file is created in a temporary directory managed by pytest.
+    """
+    tmp_dir = tmp_path_factory.mktemp("sqlite_db")
+    db_file = tmp_dir / "test.db"
+    return str(db_file)
+
+
+@pytest.fixture()
+async def storage():
+    storage = MemoryStorage()
+    set_storage(storage)
+    yield storage
+
+
+@pytest.fixture()
+def tmp_sqlite_url(tmp_db_path: str):
+    return f"sqlite+aiosqlite:///{tmp_db_path}"
+
+
+@pytest.fixture(scope="session")
+def tmp_postgresql_container():
+    container_name = "planar-postgres-" + uuid.uuid4().hex
+
+    # Start the postgres container.
+    container_process = subprocess.Popen(
+        [
+            "docker",
+            "run",
+            "--rm",
+            "--name",
+            container_name,
+            "-e",
+            "POSTGRES_PASSWORD=123",
+            "-p",
+            "127.0.0.1:5432:5432",
+            "docker.io/library/postgres",
+        ],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+
+    # Wait until Postgres is ready to accept connections.
+    remaining_tries = 10
+    while remaining_tries > 0:
+        process = subprocess.run(
+            [
+                "docker",
+                "exec",
+                container_name,
+                "psql",
+                "-U",
+                "postgres",
+                "-c",
+                "CREATE DATABASE dummy;",
+            ],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        if process.returncode != 0:
+            remaining_tries -= 1
+            if remaining_tries == 0:
+                # Terminate container if it fails to start.
+                container_process.terminate()
+                container_process.wait()
+                raise Exception("Failed to create database")
+            time.sleep(10)
+        else:
+            break
+
+    try:
+        yield container_name
+    finally:
+        container_process.terminate()
+        container_process.wait()
+
+
+@pytest.fixture()
+def tmp_postgresql_url(request):
+    container_name = os.getenv("PLANAR_TEST_POSTGRESQL_CONTAINER", None)
+
+    if container_name is None:
+        # lazy load the session-scoped container fixture, which will
+        # create a temporary docker container for the duration of the session
+        container_name = request.getfixturevalue("tmp_postgresql_container")
+
+    db_name = "test_" + uuid.uuid4().hex
+
+    process = subprocess.run(
+        [
+            "docker",
+            "exec",
+            container_name,
+            "psql",
+            "-U",
+            "postgres",
+            "-c",
+            f"CREATE DATABASE {db_name};",
+        ],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+
+    if process.returncode != 0:
+        raise Exception("Failed to create database")
+
+    url = f"postgresql+asyncpg://postgres:123@127.0.0.1:5432/{db_name}"
+
+    try:
+        yield url
+    finally:
+        kill_all_sessions = f"""
+            SELECT
+                pg_terminate_backend(pid)
+            FROM
+                pg_stat_activity
+            WHERE
+                -- don't kill my own connection!
+                pid <> pg_backend_pid()
+                -- don't kill the connections to other databases
+                AND datname = '{db_name}'
+                ;
+            """
+        process = subprocess.run(
+            [
+                "docker",
+                "exec",
+                container_name,
+                "psql",
+                "-U",
+                "postgres",
+                "-c",
+                kill_all_sessions,
+                "-c",
+                f"DROP DATABASE {db_name};",
+            ],
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        if process.returncode != 0:
+            raise Exception("Failed to drop database")
+
+
+@pytest.fixture(params=_TEST_DATABASES)
+def tmp_db_url(request):
+    fixture_name = f"tmp_{request.param}_url"
+    return request.getfixturevalue(fixture_name)
+
+
+@pytest.fixture()
+async def tmp_db_engine(tmp_db_url: str):
+    async with engine_context(tmp_db_url) as engine:
+        yield engine
+
+
+@pytest.fixture()
+async def mem_db_engine(tmp_db_engine):
+    # Memory databases don't work well with aiosqlite due to the "database
+    # table is locked" error (which doesn't respect timeouts), so just use a
+    # temporary db file for now until we figure out a fix.
+    yield tmp_db_engine
+
+    # name = uuid4()
+    # async with engine_context(
+    #     f"sqlite+aiosqlite:///file:{name}?mode=memory&cache=shared&uri=true"
+    # ) as engine:
+    #     yield engine
+
+
+@pytest.fixture(name="session")
+async def session_fixture(mem_db_engine):
+    async with new_session(mem_db_engine) as session:
+        tok = session_var.set(session)
+        yield session
+        session_var.reset(tok)
+
+
+@pytest.fixture(name="observer")
+def workflow_observer_fixture():
+    yield WorkflowObserver()
+
+
+@pytest.fixture(name="client")
+async def planar_test_client_fixture(
+    request,
+    tmp_db_url: str,
+    tracer: Tracer,
+    observer: WorkflowObserver,
+    storage: MemoryStorage,
+):
+    """
+    Create a PlanarTestClient for testing.
+
+    This fixture requires an 'app' fixture to be defined in your test file
+    or conftest.py that returns a PlanarApp instance.
+
+    Example:
+        @pytest.fixture(name="app")
+        def app_fixture():
+            app = PlanarApp()
+            app.register_workflow(my_workflow)
+            return app
+    """
+    app = request.getfixturevalue("app")
+    app.tracer = tracer
+    app.storage = storage
+    async with planar_test_client(app, tmp_db_url, observer) as client:
+        yield client
+
+
+@pytest.fixture(name="tracer")
+async def tracer_fixture():
+    yield None
+
+
+@asynccontextmanager
+async def engine_context(url: str):
+    db_manager = DatabaseManager(url)
+    db_manager.connect()
+    await db_manager.migrate(use_alembic=True)
+    engine = db_manager.get_engine()
+    tok = engine_var.set(engine)
+    yield engine
+    engine_var.reset(tok)