mockstack 0.0.3__py3-none-any.whl

mockstack/templating.py

@@ -0,0 +1,114 @@
+"""Templates related functionality."""
+
+from collections import OrderedDict
+from pathlib import Path
+from typing import Generator
+
+from fastapi import Request
+
+from mockstack.identifiers import looks_like_id, prefixes
+
+
+def missing_template_detail(request: Request, *, templates_dir: Path) -> str:
+    """Return a detailed message for a missing template."""
+    return (
+        "Template not found for given request. "
+        f"path: {request.url.path}, "
+        f"query: {request.query_params}, "
+        f"templates_dir: {templates_dir}, "
+    )
+
+
+def iter_possible_template_arguments(
+    request: Request,
+    default_identifier_key: str = "id",
+    default_media_type: str = "application/json",
+    default_template_name: str = "index.j2",
+    template_file_separator: str = "-",
+    template_file_extension: str = ".j2",
+) -> Generator[dict, None, None]:
+    """Infer the template arguments for a given request.
+
+    This includes:
+
+    - Inferring the name for the template file from the URL
+    - Inferring the context variables available for the template from the URL and request body.
+    - Inferring the response (media) type for the template from the URL and request body.
+
+    There is a fair amount of extrapolation happening here. The philosophy is to provide
+    a behavior that "just works" for the majority of the cases encountered in practice.
+
+    """
+    path = request.url.path
+
+    name_segments, context = parse_template_name_segments_and_context(
+        path,
+        default_identifier_key=default_identifier_key,
+    )
+    media_type = request.headers.get("Content-Type", default_media_type)
+
+    template_name_kwargs = dict(
+        template_file_separator=template_file_separator,
+        template_file_extension=template_file_extension,
+        default_template_name=default_template_name,
+    )
+    for name in iter_possible_template_filenames(
+        name_segments, context, **template_name_kwargs
+    ):
+        yield dict(
+            name=name,
+            context=context,
+            media_type=media_type,
+        )
+
+
+def parse_template_name_segments_and_context(
+    path: str, *, default_identifier_key: str
+) -> tuple[list[str], dict[str, str]]:
+    """Infer the template name segments and the template context for a given URI path."""
+    name_segments: list[str] = []
+    context: OrderedDict[str, str] = OrderedDict()
+    for segment in (s for s in path.split("/") if s):
+        if looks_like_id(segment):
+            if name_segments:
+                # this is a nested identifier, use the last name segment as the key
+                context[name_segments[-1]] = segment
+            else:
+                # this identifier is unscoped, use our default identifier key
+                context[default_identifier_key] = segment
+        else:
+            name_segments.append(segment)
+
+    return name_segments, context
+
+
+def iter_possible_template_filenames(
+    name_segments: list[str],
+    context: dict[str, str],
+    *,
+    template_file_separator: str,
+    template_file_extension: str,
+    default_template_name: str,
+) -> Generator[str, None, None]:
+    """Infer the template filename from the name segments and context.
+
+    We have a cascade of possible filename formats:
+
+    - <n>.<id>.<id>.j2
+    - <n>.<id>.j2
+    - <n>.j2
+
+    The first option is the most specific, and the last option is the least specific.
+    The IDs correspond to any identifiers found in the path of the request, in order.
+
+    """
+    if name_segments:
+        if context:
+            for prefix in prefixes(context.values(), reverse=True):
+                yield (
+                    f"{template_file_separator.join(name_segments)}.{'.'.join(prefix)}{template_file_extension}"
+                )
+
+        yield template_file_separator.join(name_segments) + template_file_extension
+
+    yield default_template_name

mockstack/tests/conftest.py

@@ -0,0 +1,29 @@
+"""Shared fixtures for the unit-tests."""
+
+import os
+
+import pytest
+from fastapi import FastAPI
+
+from mockstack.config import OpenTelemetrySettings, Settings
+
+
+@pytest.fixture
+def app():
+    """Create a FastAPI app for testing."""
+    return FastAPI()
+
+
+@pytest.fixture
+def templates_dir():
+    """Return the path to the test templates directory."""
+    return os.path.join(os.path.dirname(__file__), "fixtures", "templates")
+
+
+@pytest.fixture
+def settings(templates_dir):
+    """Return a Settings object for testing."""
+    return Settings(
+        templates_dir=templates_dir,
+        opentelemetry=OpenTelemetrySettings(enabled=False),
+    )

mockstack/tests/routers/test_catchall.py

@@ -0,0 +1,46 @@
+"""Tests for the catchall router module."""
+
+from unittest.mock import AsyncMock
+
+import pytest
+from fastapi.responses import JSONResponse
+from starlette.testclient import TestClient
+
+from mockstack.routers.catchall import catchall_router_provider
+
+
+@pytest.fixture
+def mock_strategy():
+    """Create a mock strategy for testing."""
+    strategy = AsyncMock()
+    response_data = {"message": "Mock response"}
+    strategy.apply.return_value = JSONResponse(content=response_data)
+    return strategy
+
+
+@pytest.mark.asyncio
+async def test_catchall_router_provider(app, settings, mock_strategy):
+    """Test that the catchall router provider sets up routes correctly."""
+    # Set up the app state with the mock strategy
+    app.state.strategy = mock_strategy
+
+    # Apply the router provider
+    catchall_router_provider(app, settings)
+
+    # Create a test client
+    client = TestClient(app)
+
+    # Test each HTTP method
+    for method in ["GET", "POST", "PUT", "DELETE", "PATCH"]:
+        # Make the request using the test client
+        response = client.request(method, "/test/path")
+
+        # Verify the response
+        assert response.status_code == 200
+        assert response.json() == {"message": "Mock response"}
+
+        # Verify the strategy was called
+        mock_strategy.apply.assert_called_once()
+
+        # Reset the mock for the next iteration
+        mock_strategy.reset_mock()

mockstack/tests/routers/test_homepage.py

@@ -0,0 +1,27 @@
+"""Tests for the homepage router module."""
+
+import pytest
+
+from mockstack.routers.homepage import homepage_router_provider
+
+
+@pytest.mark.asyncio
+async def test_homepage_router_provider(app, settings):
+    """Test that the homepage router provider sets up routes correctly."""
+    # Apply the router provider
+    router = homepage_router_provider(app, settings)
+
+    # Include the router in the app
+    app.include_router(router)
+
+    # Create a test client
+    from fastapi.testclient import TestClient
+
+    client = TestClient(app)
+
+    # Test the homepage endpoint
+    response = client.get("/")
+
+    # Verify the response
+    assert response.status_code == 200
+    assert response.json() == {"Hello": "World"}

mockstack/tests/strategies/test_filefixtures.py

@@ -0,0 +1,312 @@
+"""Unit tests for the filefixtures strategy module."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from fastapi import HTTPException, Request
+
+from mockstack.strategies.filefixtures import (
+    FileFixturesStrategy,
+)
+from mockstack.templating import (
+    iter_possible_template_arguments,
+    iter_possible_template_filenames,
+    parse_template_name_segments_and_context,
+)
+
+
+@pytest.mark.parametrize(
+    "path,expected_results",
+    [
+        (
+            "/api/v1/projects/1234",
+            [
+                {
+                    "name": "api-v1-projects.1234.j2",
+                    "context": {"projects": "1234"},
+                    "media_type": "application/json",
+                },
+                {
+                    "name": "api-v1-projects.j2",
+                    "context": {"projects": "1234"},
+                    "media_type": "application/json",
+                },
+                {
+                    "name": "index.j2",
+                    "context": {"projects": "1234"},
+                    "media_type": "application/json",
+                },
+            ],
+        ),
+        (
+            "/api/v1/users/3a4e5ad9-17ee-41af-972f-864dfccd4856",
+            [
+                {
+                    "name": "api-v1-users.3a4e5ad9-17ee-41af-972f-864dfccd4856.j2",
+                    "context": {"users": "3a4e5ad9-17ee-41af-972f-864dfccd4856"},
+                    "media_type": "application/json",
+                },
+                {
+                    "name": "api-v1-users.j2",
+                    "context": {"users": "3a4e5ad9-17ee-41af-972f-864dfccd4856"},
+                    "media_type": "application/json",
+                },
+                {
+                    "name": "index.j2",
+                    "context": {"users": "3a4e5ad9-17ee-41af-972f-864dfccd4856"},
+                    "media_type": "application/json",
+                },
+            ],
+        ),
+        (
+            "/api/v1/projects",
+            [
+                {
+                    "name": "api-v1-projects.j2",
+                    "context": {},
+                    "media_type": "application/json",
+                },
+                {
+                    "name": "index.j2",
+                    "context": {},
+                    "media_type": "application/json",
+                },
+            ],
+        ),
+        (
+            "/1234",
+            [
+                {
+                    "name": "index.j2",
+                    "context": {"id": "1234"},
+                    "media_type": "application/json",
+                },
+            ],
+        ),
+    ],
+)
+def test_iter_possible_template_arguments(
+    path: str,
+    expected_results: list,
+) -> None:
+    """Test the iter_possible_template_arguments function with various paths."""
+    request = Request(
+        scope={
+            "type": "http",
+            "method": "GET",
+            "path": path,
+            "query_string": b"",
+            "headers": [],
+        }
+    )
+
+    results = list(iter_possible_template_arguments(request))
+    assert len(results) == len(expected_results)
+
+    for actual, expected in zip(results, expected_results):
+        assert actual["name"] == expected["name"]
+        assert actual["context"] == expected["context"]
+        assert actual["media_type"] == expected["media_type"]
+
+
+def test_iter_possible_template_arguments_with_custom_media_type():
+    """Test that custom media type from headers is respected."""
+    request = Request(
+        scope={
+            "type": "http",
+            "method": "GET",
+            "path": "/api/v1/projects",
+            "query_string": b"",
+            "headers": [(b"content-type", b"application/xml")],
+        }
+    )
+
+    results = list(iter_possible_template_arguments(request))
+    assert len(results) == 2
+    assert results[0]["media_type"] == "application/xml"
+    assert results[1]["media_type"] == "application/xml"
+
+
+def test_parse_template_name_segments_and_context():
+    """Test the parse_template_name_segments_and_context function."""
+    # Test with a simple path
+    name_segments, context = parse_template_name_segments_and_context(
+        "/api/v1/projects/1234", default_identifier_key="id"
+    )
+    assert name_segments == ["api", "v1", "projects"]
+    assert context == {"projects": "1234"}
+
+    # Test with a path with no identifiers
+    name_segments, context = parse_template_name_segments_and_context(
+        "/api/v1/projects", default_identifier_key="id"
+    )
+    assert name_segments == ["api", "v1", "projects"]
+    assert context == {}
+
+    # Test with a path with only an identifier
+    name_segments, context = parse_template_name_segments_and_context(
+        "/1234", default_identifier_key="id"
+    )
+    assert name_segments == []
+    assert context == {"id": "1234"}
+
+    # Test with a path with multiple identifiers
+    name_segments, context = parse_template_name_segments_and_context(
+        "/api/v1/projects/1234/tasks/5678", default_identifier_key="id"
+    )
+    assert name_segments == ["api", "v1", "projects", "tasks"]
+    assert context == {"projects": "1234", "tasks": "5678"}
+
+
+def test_iter_possible_template_filenames():
+    """Test the iter_possible_template_filenames function."""
+    # Test with name segments and context
+    filenames = list(
+        iter_possible_template_filenames(
+            ["api", "v1", "projects"],
+            context={"projects": "1234"},
+            template_file_separator="-",
+            template_file_extension=".j2",
+            default_template_name="index.j2",
+        )
+    )
+    assert filenames == ["api-v1-projects.1234.j2", "api-v1-projects.j2", "index.j2"]
+
+    # Test with name segments and no context
+    filenames = list(
+        iter_possible_template_filenames(
+            ["api", "v1", "projects"],
+            context={},
+            template_file_separator="-",
+            template_file_extension=".j2",
+            default_template_name="index.j2",
+        )
+    )
+    assert filenames == ["api-v1-projects.j2", "index.j2"]
+
+    # Test with no name segments and context
+    filenames = list(
+        iter_possible_template_filenames(
+            [],
+            context={"id": "1234"},
+            template_file_separator="-",
+            template_file_extension=".j2",
+            default_template_name="index.j2",
+        )
+    )
+    assert filenames == ["index.j2"]
+
+    # Test with no name segments and no context
+    filenames = list(
+        iter_possible_template_filenames(
+            [],
+            context={},
+            template_file_separator="-",
+            template_file_extension=".j2",
+            default_template_name="index.j2",
+        )
+    )
+    assert filenames == ["index.j2"]
+
+    # Test with custom separator and extension
+    filenames = list(
+        iter_possible_template_filenames(
+            ["api", "v1", "projects"],
+            context={"projects": "1234"},
+            template_file_separator="_",
+            template_file_extension=".html",
+            default_template_name="default.html",
+        )
+    )
+    assert filenames == [
+        "api_v1_projects.1234.html",
+        "api_v1_projects.html",
+        "default.html",
+    ]
+
+
+def test_filefixtures_strategy_init(settings):
+    """Test the FileFixturesStrategy initialization."""
+    strategy = FileFixturesStrategy(settings)
+    assert strategy.templates_dir == settings.templates_dir
+    assert strategy.env is not None
+
+
+@pytest.mark.asyncio
+async def test_filefixtures_strategy_apply(settings):
+    """Test the FileFixturesStrategy apply method."""
+    strategy = FileFixturesStrategy(settings)
+    request = Request(
+        scope={
+            "type": "http",
+            "method": "GET",
+            "path": "/api/v1/projects/1234",
+            "query_string": b"",
+            "headers": [],
+        }
+    )
+
+    with pytest.raises(HTTPException) as exc_info:
+        await strategy.apply(request)
+
+    assert exc_info.value.status_code == 404
+
+
+@pytest.mark.asyncio
+async def test_file_fixtures_strategy_apply_success(settings):
+    """Test the FileFixturesStrategy apply method when template exists."""
+    # Setup
+    strategy = FileFixturesStrategy(settings)
+
+    # Create a mock template
+    mock_template = MagicMock()
+    mock_template.render.return_value = '{"status": "success"}'
+
+    # Patch the environment to return our mock template
+    with (
+        patch.object(strategy.env, "get_template", return_value=mock_template),
+        patch("os.path.exists", return_value=True),
+    ):
+        request = Request(
+            scope={
+                "type": "http",
+                "method": "GET",
+                "path": "/api/v1/projects/1234",
+                "query_string": b"",
+                "headers": [],
+            }
+        )
+
+        # Execute
+        response = await strategy.apply(request)
+
+        # Assert
+        assert response.media_type == "application/json"
+        assert response.body.decode() == '{"status": "success"}'
+        mock_template.render.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_file_fixtures_strategy_apply_template_not_found(settings):
+    """Test the FileFixturesStrategy apply method when template doesn't exist."""
+    # Setup
+    strategy = FileFixturesStrategy(settings)
+
+    # Mock os.path.exists to return False for all template files
+    with patch("os.path.exists", return_value=False):
+        request = Request(
+            scope={
+                "type": "http",
+                "method": "GET",
+                "path": "/api/v1/projects/1234",
+                "query_string": b"",
+                "headers": [],
+            }
+        )
+
+        # Execute and Assert
+        with pytest.raises(HTTPException) as exc_info:
+            await strategy.apply(request)
+
+        assert exc_info.value.status_code == 404
+        assert "Template not found" in str(exc_info.value.detail)

mockstack/tests/test_display.py

@@ -0,0 +1,33 @@
+"""Tests for the display module."""
+
+from unittest.mock import patch
+
+from mockstack.display import ANSIColors, announce
+
+
+def test_ansicolors_constants():
+    """Test that ANSIColors constants are defined correctly."""
+    assert ANSIColors.HEADER == "\033[95m"
+    assert ANSIColors.OKBLUE == "\033[94m"
+    assert ANSIColors.OKCYAN == "\033[96m"
+    assert ANSIColors.OKGREEN == "\033[92m"
+    assert ANSIColors.WARNING == "\033[93m"
+    assert ANSIColors.FAIL == "\033[91m"
+    assert ANSIColors.ENDC == "\033[0m"
+    assert ANSIColors.BOLD == "\033[1m"
+    assert ANSIColors.UNDERLINE == "\033[4m"
+
+
+def test_announce(settings):
+    """Test the announce function logs the correct message."""
+    with patch("mockstack.display.logging") as mock_logging:
+        mock_logger = mock_logging.getLogger.return_value
+
+        announce(settings)
+
+        mock_logging.getLogger.assert_called_once_with("uvicorn")
+        mock_logger.info.assert_called()
+
+        # Check that the log message contains the expected information
+        first_log_message = mock_logger.info.call_args[0][0]
+        assert "OpenTelemetry enabled:" in first_log_message

mockstack/tests/test_identifiers.py

@@ -0,0 +1,94 @@
+"""Unit tests for the identifiers module."""
+
+import pytest
+
+from mockstack.identifiers import looks_like_id, prefixes
+
+
+def test_prefixes():
+    # Test basic functionality
+    assert list(prefixes([1, 2, 3])) == [(1,), (1, 2), (1, 2, 3)]
+
+    # Test with reverse=True
+    assert list(prefixes([1, 2, 3], reverse=True)) == [(1, 2, 3), (1, 2), (1,)]
+
+    # Test with empty list
+    assert list(prefixes([])) == []
+
+    # Test with single element
+    assert list(prefixes([1])) == [(1,)]
+
+    # Test with strings
+    assert list(prefixes(["a", "b", "c"])) == [("a",), ("a", "b"), ("a", "b", "c")]
+
+
+@pytest.mark.parametrize(
+    "chunk,expected,reason",
+    [
+        # Even length numeric IDs
+        ("1234", True, "Even length numeric"),
+        ("12", True, "Even length numeric"),
+        ("1234567890", True, "Even length numeric"),
+        # Odd length numeric IDs
+        ("123", False, "Odd length numeric"),
+        ("12345", False, "Odd length numeric"),
+        # Even length hexadecimal IDs
+        ("abcd", True, "Even length hex"),
+        ("1234abcd", True, "Even length hex"),
+        ("1234567890abcdef", True, "Even length hex"),
+        # Odd length hexadecimal IDs
+        ("abc", False, "Odd length hex"),
+        ("1234567890abcde", False, "Odd length hex"),
+        ("1234567890abcdefg", False, "Invalid hex character"),
+        ("xyz", False, "Not hex"),
+        # UUID format (36 characters with dashes)
+        ("3a4e5ad9-17ee-41af-972f-864dfccd4856", True, "Valid UUID"),
+        ("3A4E5AD9-17EE-41AF-972F-864DFCCD4856", True, "UUID with uppercase"),
+        ("3a4e5ad917ee41af972f864dfccd4856", True, "UUID without dashes"),
+        ("3a4e5ad9-17ee-41af-972f-864dfccd485", False, "UUID too short"),
+        ("3a4e5ad9-17ee-41af-972f-864dfccd4856-", False, "UUID too long"),
+        ("3a4e5ad9-17ee-41af-972f-864dfccd485g", False, "UUID with invalid char"),
+        # Common non-ID path segments
+        ("api", False, "Common path segment"),
+        ("v1", False, "API version"),
+        ("users", False, "Resource name"),
+        ("projects", False, "Resource name"),
+        ("index", False, "Page name"),
+        ("create", False, "Action name"),
+        ("update", False, "Action name"),
+        ("delete", False, "Action name"),
+    ],
+)
+def test_looks_like_id(chunk: str, expected: bool, reason: str) -> None:
+    """Test the looks_like_id function with various inputs.
+
+    The test cases cover:
+    1. Even and odd length numeric IDs
+    2. Even and odd length hexadecimal IDs
+    3. Valid and invalid UUID formats
+    4. Common non-ID path segments
+    """
+    assert looks_like_id(chunk) == expected, f"Failed for {chunk} ({reason})"
+
+
+def test_looks_like_id_empty_string():
+    """Test that empty string is not considered an ID."""
+    assert not looks_like_id("")
+
+
+def test_looks_like_id_whitespace():
+    """Test that whitespace is not considered an ID."""
+    assert not looks_like_id(" ")
+    assert not looks_like_id("\t")
+    assert not looks_like_id("\n")
+    assert not looks_like_id("  ")
+
+
+def test_looks_like_id_special_chars():
+    """Test that strings with special characters are not considered IDs."""
+    assert not looks_like_id("12-34")  # Hyphen in wrong place
+    assert not looks_like_id("12_34")  # Underscore
+    assert not looks_like_id("12.34")  # Period
+    assert not looks_like_id("12/34")  # Slash
+    assert not looks_like_id("12+34")  # Plus
+    assert not looks_like_id("@1234")  # At symbol