mockstack 0.2.0__tar.gz → 0.3.0__tar.gz

mockstack-0.3.0/.env.example

@@ -0,0 +1,20 @@
+# Example environment variables for mockstack
+
+# the strategy to use
+MOCKSTACK__STRATEGY = filefixtures
+
+# strategy-specific settings
+
+# base dir for all templates. Used by 'filefixtures' strategy
+# and other hybrid strategies utilizing templates.
+MOCKSTACK__TEMPLATES_DIR = "/some/path/templates/"
+
+# rules table for the proxyrules strategy.
+# see .mockstack/tests/fixtures/ for examples.
+MOCKSTACK__PROXYRULES_RULES_FILENAME="/some/path/proxyrules.yml"
+
+MOCKSTACK__PROXYRULES_SIMULATE_CREATE_ON_MISSING = true
+
+# OpenTelemetry settings
+MOCKSTACK__OPENTELEMETRY__ENABLED = true
+MOCKSTACK__OPENTELEMETRY__CAPTURE_RESPONSE_BODY = true

{mockstack-0.2.0/mockstack.egg-info → mockstack-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mockstack
-Version: 0.2.0
+Version: 0.3.0
 Summary: An API mocking workhorse
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/adamhadani/mockstack

{mockstack-0.2.0 → mockstack-0.3.0}/mockstack/config.py

@@ -49,6 +49,10 @@ class Settings(BaseSettings):
     # or reverse proxy the request to the target URL "silently".
     proxyrules_redirect_via: ProxyRulesRedirectVia = ProxyRulesRedirectVia.REVERSE_PROXY
 
+    # controls behavior of proxying. Whether to simulate creation of resources
+    # when a POST request is made to a resource that doesn't match any rules..
+    proxyrules_simulate_create_on_missing: bool = False
+
     # metadata fields to inject into created resources.
     # A few template fields are available. See documentation for more details.
     created_resource_metadata: dict[str, Any] = {
@@ -74,7 +78,8 @@ class Settings(BaseSettings):
         "disable_existing_loggers": False,
         "formatters": {
             "standard": {
-                "format": "     %(levelname)s   [%(name)s] %(message)s",
+                "()": "uvicorn.logging.DefaultFormatter",
+                "fmt": "%(levelprefix)s %(message)s",
             },
         },
         "handlers": {
@@ -86,10 +91,26 @@ class Settings(BaseSettings):
             },
         },
         "loggers": {
+            "uvicorn": {
+                "handlers": ["console"],
+                "level": "INFO",
+                "propagate": False,
+            },
             "FileFixturesStrategy": {
                 "handlers": ["console"],
                 "level": "INFO",
+                "propagate": False,
             },
+            "ProxyRulesStrategy": {
+                "handlers": ["console"],
+                "level": "INFO",
+                "propagate": False,
+            },
+        },
+        "root": {
+            "handlers": ["console"],
+            "level": "INFO",
+            "propagate": False,
         },
     }
 

mockstack-0.3.0/mockstack/intent.py

@@ -0,0 +1,53 @@
+"""Helpers for deducing user intent from a request."""
+
+from fastapi import Request
+
+
+def wants_json(request: Request) -> bool:
+    """Check if the request wants JSON response."""
+    content_type = request.headers.get("Content-Type", "")
+    return any(
+        (
+            content_type.startswith("application/json"),
+            content_type.startswith("text/json"),
+            request.url.path.endswith(".json"),
+        )
+    )
+
+
+def looks_like_a_search(request: Request) -> bool:
+    """Check if the request looks like a search.
+
+    This is a heuristic to try and identify cases where a POST
+    request is used for issuing a search rather than for creating
+    a new resource.
+
+    """
+    return any(
+        (
+            request.url.path.endswith("_search"),
+            request.url.path.endswith("/search"),
+            request.url.path.endswith("_query"),
+        )
+    )
+
+
+def looks_like_a_command(request: Request) -> bool:
+    """Check if the request looks like a command.
+
+    This is a heuristic to try and identify cases where a POST
+    request is used for issuing a command rather than for creating
+    a new resource.
+    """
+    return any(
+        (
+            request.url.path.endswith("_command"),
+            request.url.path.endswith("/command"),
+            request.url.path.endswith("_request"),
+            request.url.path.endswith("/request"),
+            request.url.path.endswith("_run"),
+            request.url.path.endswith("/run"),
+            request.url.path.endswith("_execute"),
+            request.url.path.endswith("/execute"),
+        )
+    )

mockstack-0.3.0/mockstack/strategies/create_mixin.py

@@ -0,0 +1,81 @@
+"""Create mixin class."""
+
+from datetime import datetime, timezone
+from uuid import uuid4
+
+from fastapi import Request, Response, status
+from fastapi.responses import JSONResponse
+from jinja2 import Environment
+
+from mockstack.intent import wants_json
+
+
+class CreateMixin:
+    """A mixin for strategies that need to simulate creation of resources."""
+
+    async def _create(
+        self, request: Request, *, env: Environment, created_resource_metadata: dict
+    ) -> Response:
+        if wants_json(request):
+            # We return a 201 CREATED response with the resource as the body,
+            # potentially injecting the resource ID into the response.
+            resource = await request.json()
+
+            return JSONResponse(
+                status_code=status.HTTP_201_CREATED,
+                content=self._content(
+                    resource,
+                    request=request,
+                    env=env,
+                    created_resource_metadata=created_resource_metadata,
+                ),
+            )
+        else:
+            # We return a 201 CREATED response with an empty body.
+            return Response(
+                status_code=status.HTTP_201_CREATED,
+                content=None,
+            )
+
+    def _content(
+        self,
+        resource: dict,
+        *,
+        env: Environment,
+        request: Request,
+        created_resource_metadata: dict,
+    ) -> dict:
+        """Create a new resource given a request resource.
+
+        We use the request resource as the basis for the new resource.
+        We then inject an identifier into the resource if it doesn't already have one,
+        as well as any other metadata fields that are configured for the strategy.
+
+        """
+
+        def with_metadata(resource: dict, copy=True) -> dict:
+            """Inject metadata fields into the resource."""
+            _resource = resource.copy() if copy else resource
+            for key, value in created_resource_metadata.items():
+                if isinstance(value, str):
+                    _resource[key] = env.from_string(value).render(
+                        self._metadata_context(request)
+                    )
+                else:
+                    _resource[key] = value
+            return _resource
+
+        return with_metadata(resource)
+
+    def _metadata_context(self, request: Request) -> dict:
+        """Context for injecting metadata fields into resources.
+
+        Some care is needed to ensure that we only expose the minimum amount
+        of information here since templates are user-defined.
+
+        """
+        return {
+            "utcnow": lambda: datetime.now(timezone.utc),
+            "uuid4": uuid4,
+            "request": request,
+        }

{mockstack-0.2.0 → mockstack-0.3.0}/mockstack/strategies/filefixtures.py

@@ -2,67 +2,26 @@
 
 import logging
 import os
-from datetime import datetime, timezone
 from pathlib import Path
-from uuid import uuid4
 
 from fastapi import HTTPException, Request, Response, status
-from fastapi.responses import JSONResponse
 from jinja2 import Environment, FileSystemLoader
 
 from mockstack.config import Settings
 from mockstack.display import ANSIColors
+from mockstack.intent import (
+    looks_like_a_command,
+    looks_like_a_search,
+)
 from mockstack.strategies.base import BaseStrategy
+from mockstack.strategies.create_mixin import CreateMixin
 from mockstack.templating import (
     iter_possible_template_arguments,
     missing_template_detail,
 )
 
 
-def is_json_media_type(media_type: str) -> bool:
-    """Check if the media type is JSON."""
-    return media_type in ("application/json", "text/json")
-
-
-def looks_like_a_search(request: Request) -> bool:
-    """Check if the request looks like a search.
-
-    This is a heuristic to try and identify cases where a POST
-    request is used for issuing a search rather than for creating
-    a new resource.
-
-    """
-    return any(
-        (
-            request.url.path.endswith("_search"),
-            request.url.path.endswith("/search"),
-            request.url.path.endswith("_query"),
-        )
-    )
-
-
-def looks_like_a_command(request: Request) -> bool:
-    """Check if the request looks like a command.
-
-    This is a heuristic to try and identify cases where a POST
-    request is used for issuing a command rather than for creating
-    a new resource.
-    """
-    return any(
-        (
-            request.url.path.endswith("_command"),
-            request.url.path.endswith("/command"),
-            request.url.path.endswith("_request"),
-            request.url.path.endswith("/request"),
-            request.url.path.endswith("_run"),
-            request.url.path.endswith("/run"),
-            request.url.path.endswith("_execute"),
-            request.url.path.endswith("/execute"),
-        )
-    )
-
-
-class FileFixturesStrategy(BaseStrategy):
+class FileFixturesStrategy(BaseStrategy, CreateMixin):
     """Strategy for using file-based fixtures."""
 
     logger = logging.getLogger("FileFixturesStrategy")
@@ -126,24 +85,11 @@ class FileFixturesStrategy(BaseStrategy):
                 request, status_code=status.HTTP_201_CREATED
             )
         else:
-            # Creating a new resource.
-            media_type = request.headers.get("Content-Type", "application/json")
-
-            if is_json_media_type(media_type):
-                # We return a 201 CREATED response with the resource as the body,
-                # potentially injecting the resource ID into the response.
-                resource = await request.json()
-
-                return JSONResponse(
-                    status_code=status.HTTP_201_CREATED,
-                    content=self._created(resource, request=request),
-                )
-            else:
-                # We return a 201 CREATEDresponse with an empty body.
-                return Response(
-                    status_code=status.HTTP_201_CREATED,
-                    content=None,
-                )
+            return await self._create(
+                request,
+                env=self.env,
+                created_resource_metadata=self.created_resource_metadata,
+            )
 
     async def _get(self, request: Request) -> Response:
         """Apply the strategy for GET requests.
@@ -176,42 +122,6 @@ class FileFixturesStrategy(BaseStrategy):
         """Apply the strategy for PUT requests."""
         return Response(status_code=status.HTTP_204_NO_CONTENT)
 
-    def _created(self, resource: dict, *, request: Request) -> dict:
-        """Create a new resource given a request resource.
-
-        We use the request resource as the basis for the new resource.
-        We then inject an identifier into the resource if it doesn't already have one,
-        as well as any other metadata fields that are configured for the strategy.
-
-        """
-
-        def with_metadata(resource: dict, copy=True) -> dict:
-            """Inject metadata fields into the resource."""
-            _resource = resource.copy() if copy else resource
-            for key, value in self.created_resource_metadata.items():
-                if isinstance(value, str):
-                    _resource[key] = self.env.from_string(value).render(
-                        self._metadata_context(request)
-                    )
-                else:
-                    _resource[key] = value
-            return _resource
-
-        return with_metadata(resource)
-
-    def _metadata_context(self, request: Request) -> dict:
-        """Context for injecting metadata fields into resources.
-
-        Some care is needed to ensure that we only expose the minimum amount
-        of information here since templates are user-defined.
-
-        """
-        return {
-            "utcnow": lambda: datetime.now(timezone.utc),
-            "uuid4": uuid4,
-            "request": request,
-        }
-
     def _response_from_template(
         self, request: Request, status_code: int = status.HTTP_200_OK
     ) -> Response:

{mockstack-0.2.0 → mockstack-0.3.0}/mockstack/strategies/proxyrules.py

@@ -10,12 +10,14 @@ import httpx
 import yaml
 from fastapi import Request, Response, status
 from fastapi.responses import RedirectResponse
+from jinja2 import Environment
 from starlette.datastructures import Headers
 
 from mockstack.config import Settings
 from mockstack.constants import ProxyRulesRedirectVia
 from mockstack.display import ANSIColors
 from mockstack.strategies.base import BaseStrategy
+from mockstack.strategies.create_mixin import CreateMixin
 
 
 class Rule:
@@ -50,7 +52,7 @@ class Rule:
         return re.sub(self.pattern, self.replacement, path)
 
 
-class ProxyRulesStrategy(BaseStrategy):
+class ProxyRulesStrategy(BaseStrategy, CreateMixin):
     """Strategy for using proxy rules."""
 
     logger = logging.getLogger("ProxyRulesStrategy")
@@ -59,6 +61,12 @@ class ProxyRulesStrategy(BaseStrategy):
         super().__init__(settings, *args, **kwargs)
         self.rules_filename = settings.proxyrules_rules_filename
         self.proxyrules_redirect_via = settings.proxyrules_redirect_via
+        self.proxyrules_simulate_create_on_missing = (
+            settings.proxyrules_simulate_create_on_missing
+        )
+        self.created_resource_metadata = settings.created_resource_metadata
+
+        self.env = Environment()
 
     def __str__(self) -> str:
         HIGHLIGHT = ANSIColors.HEADER
@@ -67,7 +75,8 @@ class ProxyRulesStrategy(BaseStrategy):
         return (
             f"{HIGHLIGHT}[proxyrules]{ENDC} "
             f"rules_filename: {HIGHLIGHT}{self.rules_filename}{ENDC}. "
-            f"redirect_via: {HIGHLIGHT}{self.proxyrules_redirect_via}{ENDC}"
+            f"redirect_via: {HIGHLIGHT}{self.proxyrules_redirect_via}{ENDC}. "
+            f"simulate_create_on_missing: {HIGHLIGHT}{self.proxyrules_simulate_create_on_missing}{ENDC}"
         )
 
     @cached_property
@@ -91,8 +100,20 @@ class ProxyRulesStrategy(BaseStrategy):
     async def apply(self, request: Request) -> Response:
         rule = self.rule_for(request)
         if rule is None:
-            self.logger.warning(f"No rule found for request: {request.url.path=}")
-            return Response(status_code=status.HTTP_404_NOT_FOUND)
+            self.logger.warning(
+                f"No rule found for request: {request.method} {request.url.path}"
+            )
+            if self.proxyrules_simulate_create_on_missing:
+                self.logger.info(
+                    "Simulating resource creation for missing rule for {request.method} {request.url.path}"
+                )
+                return await self._create(
+                    request,
+                    env=self.env,
+                    created_resource_metadata=self.created_resource_metadata,
+                )
+            else:
+                return Response(status_code=status.HTTP_404_NOT_FOUND)
 
         url = rule.apply(request)
         self.logger.info(f"Redirecting to: {url}")
@@ -114,7 +135,7 @@ class ProxyRulesStrategy(BaseStrategy):
 
             case _:
                 raise ValueError(
-                    f"Invalid redirect via: {self.proxyrules_redirect_via}"
+                    f"Invalid redirect via value: {self.proxyrules_redirect_via=}"
                 )
 
     async def reverse_proxy(self, request: Request, url: str) -> Response:

{mockstack-0.2.0 → mockstack-0.3.0}/mockstack/telemetry.py

@@ -5,7 +5,6 @@ from importlib import metadata
 from fastapi import FastAPI, Request
 from opentelemetry import trace
 from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
-from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
 from opentelemetry.sdk.resources import Resource
 from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.trace.export import BatchSpanProcessor

{mockstack-0.2.0 → mockstack-0.3.0}/mockstack/tests/conftest.py

@@ -37,6 +37,7 @@ def settings(templates_dir, proxyrules_rules_filename):
         templates_dir=templates_dir,
         proxyrules_rules_filename=proxyrules_rules_filename,
         proxyrules_redirect_via=ProxyRulesRedirectVia.HTTP_TEMPORARY_REDIRECT,
+        proxyrules_simulate_create_on_missing=False,
         opentelemetry=OpenTelemetrySettings(enabled=False),
     )
 

{mockstack-0.2.0 → mockstack-0.3.0/mockstack.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mockstack
-Version: 0.2.0
+Version: 0.3.0
 Summary: An API mocking workhorse
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/adamhadani/mockstack

{mockstack-0.2.0 → mockstack-0.3.0}/mockstack.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ mockstack/config.py
 mockstack/constants.py
 mockstack/display.py
 mockstack/identifiers.py
+mockstack/intent.py
 mockstack/lifespan.py
 mockstack/main.py
 mockstack/middleware.py
@@ -35,6 +36,7 @@ mockstack/routers/catchall.py
 mockstack/routers/homepage.py
 mockstack/strategies/__init__.py
 mockstack/strategies/base.py
+mockstack/strategies/create_mixin.py
 mockstack/strategies/factory.py
 mockstack/strategies/filefixtures.py
 mockstack/strategies/proxyrules.py

{mockstack-0.2.0 → mockstack-0.3.0}/pyproject.toml

@@ -47,9 +47,9 @@ dev = [
 
 [tool.mypy]
 namespace_packages = true
+ignore_missing_imports = true
 
 [tool.pytest.ini_options]
 asyncio_default_fixture_loop_scope = "function"
 
 [tool.ruff.lint]
-select = ["I"]

mockstack-0.2.0/.env.example

@@ -1,7 +0,0 @@
-# Example environment variables for mockstack
-
-# base dir for all templates
-MOCKSTACK__TEMPLATES_DIR = "./templates/"
-
-# OpenTelemetry settings
-MOCKSTACK__OPENTELEMETRY__ENABLED="false"