mockstack 0.10.0__tar.gz → 0.11.0__tar.gz

{mockstack-0.10.0 → mockstack-0.11.0}/Dockerfile

@@ -1,7 +1,7 @@
 # ---------------------------- Build Time Arguments ----------------------------
 
 # Define build argument for version
-ARG PYTHON_IMAGE_VERSION=3.13.3-slim
+ARG PYTHON_IMAGE_VERSION=3.13-slim
 ARG MOCKSTACK_VERSION=0.8.0
 
 # ---------------------------- Base Image --------------------------------

{mockstack-0.10.0 → mockstack-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mockstack
-Version: 0.10.0
+Version: 0.11.0
 Summary: An API mocking workhorse
 Author-email: Adam Ever-Hadani <mockstack.contact@gmail.com>
 License-Expression: MIT

{mockstack-0.10.0 → mockstack-0.11.0}/mockstack/constants.py

@@ -12,6 +12,17 @@ PROXYRULES_FILE_TEMPLATE_PREFIX = "file:///"
 
 SENSITIVE_HEADERS = ["authorization", "cookie", "set-cookie"]
 
+# See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Encoding
+CONTENT_ENCODING_COMPRESSED = (
+    "gzip",
+    "compress",
+    "deflate",
+    "br",
+    "zstd",
+    "dcb",
+    "dcz",
+)
+
 
 class ProxyRulesRedirectVia(StrEnum):
     """The type of redirect to use for the proxy rules strategy.

mockstack-0.11.0/mockstack/rules.py

@@ -0,0 +1,112 @@
+"""Rules for the proxy rules strategy."""
+
+import re
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Self
+
+from fastapi import Request
+
+from mockstack.constants import PROXYRULES_FILE_TEMPLATE_PREFIX
+from mockstack.templating import parse_template_name_segments_and_identifiers
+
+
+class RuleResult(ABC):
+    """Base class for rule application results."""
+
+    @abstractmethod
+    def get_result_type(self) -> str:
+        """Return the type of result."""
+        pass
+
+
+@dataclass
+class URLRuleResult(RuleResult):
+    """Result for URL-based rules."""
+
+    url: str
+
+    def get_result_type(self) -> str:
+        return "url"
+
+
+@dataclass
+class TemplateRuleResult(RuleResult):
+    """Result for template-based rules."""
+
+    template_path: str
+    template_context: dict
+
+    def get_result_type(self) -> str:
+        return "template"
+
+
+class Rule:
+    """A rule for the proxy rules strategy."""
+
+    def __init__(
+        self,
+        pattern: str,
+        replacement: str,
+        method: str | None = None,
+        name: str | None = None,
+    ):
+        self.pattern = pattern
+        self.replacement = replacement
+        self.method = method
+        self.name = name
+
+    @classmethod
+    def from_dict(cls, data: dict[str, str]) -> Self:
+        return cls(
+            pattern=data["pattern"],
+            replacement=data["replacement"],
+            method=data.get("method", None),
+            name=data.get("name", None),
+        )
+
+    def matches(self, request: Request) -> bool:
+        """Check if the rule matches the request."""
+        if self.method is not None and request.method.lower() != self.method.lower():
+            # if rule is limited to a specific HTTP method, validate first.
+            return False
+
+        return re.match(self.pattern, request.url.path) is not None
+
+    def apply(self, request: Request) -> RuleResult:
+        """Apply the rule to the request."""
+        path = request.url.path
+        result = self._url_for(path)
+
+        # Check if the replacement is a file template
+        if result.startswith(PROXYRULES_FILE_TEMPLATE_PREFIX):
+            # Extract the file path from the file:/// URL
+            file_path = result[len(PROXYRULES_FILE_TEMPLATE_PREFIX) - 1 :]
+
+            # Create template context from request
+            template_context = self._create_template_context(request)
+
+            return TemplateRuleResult(
+                template_path=file_path,
+                template_context=template_context,
+            )
+        else:
+            # Regular URL replacement
+            return URLRuleResult(url=result)
+
+    def _url_for(self, path: str) -> str:
+        return re.sub(self.pattern, self.replacement, path)
+
+    def _create_template_context(self, request: Request) -> dict:
+        """Create template context from the request, using the same logic as templating.py."""
+        path = request.url.path
+        name_segments, identifiers = parse_template_name_segments_and_identifiers(
+            path, default_identifier_key="id"
+        )
+        return {
+            "query": dict(request.query_params),
+            "headers": dict(request.headers),
+            "path": request.url.path,
+            "method": request.method,
+            **identifiers,
+        }

{mockstack-0.10.0 → mockstack-0.11.0}/mockstack/strategies/proxyrules.py

@@ -1,131 +1,41 @@
 """Strategy for using proxy rules."""
 
 import logging
-import re
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
 from functools import cached_property
 from pathlib import Path
-from typing import Self
 from urllib.parse import urlparse
 
 import httpx
 import yaml
 from fastapi import Request, Response, status
 from fastapi.responses import JSONResponse, RedirectResponse
+from httpx import Headers as ResponseHeaders
 from jinja2 import Environment
 from starlette.datastructures import Headers
 
 from mockstack.config import Settings
-from mockstack.constants import PROXYRULES_FILE_TEMPLATE_PREFIX, ProxyRulesRedirectVia
+from mockstack.constants import CONTENT_ENCODING_COMPRESSED, ProxyRulesRedirectVia
 from mockstack.intent import looks_like_a_create
+from mockstack.rules import Rule, TemplateRuleResult, URLRuleResult
 from mockstack.strategies.base import BaseStrategy
 from mockstack.strategies.create_mixin import CreateMixin
-from mockstack.templating import (
-    templates_env_provider,
-    parse_template_name_segments_and_identifiers,
-)
+from mockstack.templating import templates_env_provider
 
 
-class RuleResult(ABC):
-    """Base class for rule application results."""
+def maybe_update_response_headers(
+    response_headers: ResponseHeaders,
+    *,
+    request_headers: Headers,
+) -> ResponseHeaders:
+    """Update the response headers if needed, e.g. to adjust for compression etc."""
+    _headers = response_headers.copy()
 
-    @abstractmethod
-    def get_result_type(self) -> str:
-        """Return the type of result."""
-        pass
+    if _headers.get("content-encoding") in CONTENT_ENCODING_COMPRESSED:
+        # If the response is compressed, we need to remove the content-encoding header
+        # since httpx will automatically decompress the response while proxying.
+        _headers["content-encoding"] = "identity"
 
-
-@dataclass
-class URLRuleResult(RuleResult):
-    """Result for URL-based rules."""
-
-    url: str
-
-    def get_result_type(self) -> str:
-        return "url"
-
-
-@dataclass
-class TemplateRuleResult(RuleResult):
-    """Result for template-based rules."""
-
-    template_path: str
-    template_context: dict
-
-    def get_result_type(self) -> str:
-        return "template"
-
-
-class Rule:
-    """A rule for the proxy rules strategy."""
-
-    def __init__(
-        self,
-        pattern: str,
-        replacement: str,
-        method: str | None = None,
-        name: str | None = None,
-    ):
-        self.pattern = pattern
-        self.replacement = replacement
-        self.method = method
-        self.name = name
-
-    @classmethod
-    def from_dict(cls, data: dict[str, str]) -> Self:
-        return cls(
-            pattern=data["pattern"],
-            replacement=data["replacement"],
-            method=data.get("method", None),
-            name=data.get("name", None),
-        )
-
-    def matches(self, request: Request) -> bool:
-        """Check if the rule matches the request."""
-        if self.method is not None and request.method.lower() != self.method.lower():
-            # if rule is limited to a specific HTTP method, validate first.
-            return False
-
-        return re.match(self.pattern, request.url.path) is not None
-
-    def apply(self, request: Request) -> RuleResult:
-        """Apply the rule to the request."""
-        path = request.url.path
-        result = self._url_for(path)
-
-        # Check if the replacement is a file template
-        if result.startswith(PROXYRULES_FILE_TEMPLATE_PREFIX):
-            # Extract the file path from the file:/// URL
-            file_path = result[len(PROXYRULES_FILE_TEMPLATE_PREFIX) - 1 :]
-
-            # Create template context from request
-            template_context = self._create_template_context(request)
-
-            return TemplateRuleResult(
-                template_path=file_path,
-                template_context=template_context,
-            )
-        else:
-            # Regular URL replacement
-            return URLRuleResult(url=result)
-
-    def _url_for(self, path: str) -> str:
-        return re.sub(self.pattern, self.replacement, path)
-
-    def _create_template_context(self, request: Request) -> dict:
-        """Create template context from the request, using the same logic as templating.py."""
-        path = request.url.path
-        name_segments, identifiers = parse_template_name_segments_and_identifiers(
-            path, default_identifier_key="id"
-        )
-        return {
-            "query": dict(request.query_params),
-            "headers": dict(request.headers),
-            "path": request.url.path,
-            "method": request.method,
-            **identifiers,
-        }
+    return _headers
 
 
 class ProxyRulesStrategy(BaseStrategy, CreateMixin):
@@ -299,12 +209,16 @@ class ProxyRulesStrategy(BaseStrategy, CreateMixin):
 
             resp = await client.send(req, stream=False)
             content = resp.read()
+            response_headers = maybe_update_response_headers(
+                resp.headers,
+                request_headers=request.headers,
+            )
 
             return Response(
                 content=content,
                 status_code=resp.status_code,
-                headers=resp.headers,
-                media_type=resp.headers.get("content-type"),
+                headers=response_headers,
+                media_type=response_headers.get("content-type"),
             )
 
     def reverse_proxy_headers(self, headers: Headers, url: str) -> Headers:

{mockstack-0.10.0 → mockstack-0.11.0}/mockstack/tests/strategies/test_proxyrules.py

@@ -1,5 +1,6 @@
 """Unit tests for the proxyrules module."""
 
+from pathlib import Path
 from unittest.mock import AsyncMock, MagicMock, patch
 
 import httpx
@@ -12,143 +13,10 @@ from mockstack.constants import ProxyRulesRedirectVia
 from mockstack.strategies.proxyrules import (
     ProxyRulesStrategy,
     Rule,
-    URLRuleResult,
-    TemplateRuleResult,
+    maybe_update_response_headers,
 )
 
 
-def test_rule_from_dict():
-    """Test creating a Rule from a dictionary."""
-    data = {
-        "pattern": r"/api/v1/projects/(\d+)",
-        "replacement": r"/projects/\1",
-        "method": "GET",
-    }
-    rule = Rule.from_dict(data)
-    assert rule.pattern == data["pattern"]
-    assert rule.replacement == data["replacement"]
-    assert rule.method == data["method"]
-
-
-def test_rule_from_dict_without_method():
-    """Test creating a Rule from a dictionary without a method."""
-    data = {
-        "pattern": r"/api/v1/projects/(\d+)",
-        "replacement": r"/projects/\1",
-    }
-    rule = Rule.from_dict(data)
-    assert rule.pattern == data["pattern"]
-    assert rule.replacement == data["replacement"]
-    assert rule.method is None
-
-
-@pytest.mark.parametrize(
-    "pattern,path,method,expected",
-    [
-        (r"/api/v1/projects/\d+", "/api/v1/projects/123", "GET", True),
-        (r"/api/v1/projects/\d+", "/api/v1/projects/123", "POST", True),
-        (r"/api/v1/projects/\d+", "/api/v1/projects/abc", "GET", False),
-        (r"/api/v1/projects/\d+", "/api/v1/users/123", "GET", False),
-        (r"/api/v1/projects/\d+", "/api/v1/projects/123", "POST", True),
-    ],
-)
-def test_rule_matches(pattern, path, method, expected):
-    """Test the rule matching logic."""
-    rule = Rule(pattern=pattern, replacement="", method=None)
-    request = Request(
-        scope={
-            "type": "http",
-            "method": method,
-            "path": path,
-            "query_string": b"",
-            "headers": [],
-        }
-    )
-    assert rule.matches(request) == expected
-
-
-@pytest.mark.parametrize(
-    "pattern,path,method,expected",
-    [
-        (r"/api/v1/projects/\d+", "/api/v1/projects/123", "GET", True),
-        (r"/api/v1/projects/\d+", "/api/v1/projects/123", "POST", False),
-    ],
-)
-def test_rule_matches_with_method(pattern, path, method, expected):
-    """Test the rule matching logic with method restriction."""
-    rule = Rule(pattern=pattern, replacement="", method="GET")
-    request = Request(
-        scope={
-            "type": "http",
-            "method": method,
-            "path": path,
-            "query_string": b"",
-            "headers": [],
-        }
-    )
-    assert rule.matches(request) == expected
-
-
-@pytest.mark.parametrize(
-    "pattern,replacement,path,expected_url",
-    [
-        (
-            r"/api/v1/projects/(\d+)",
-            r"/projects/\1",
-            "/api/v1/projects/123",
-            "/projects/123",
-        ),
-        (
-            r"/api/v1/users/([^/]+)",
-            r"/users/\1",
-            "/api/v1/users/john",
-            "/users/john",
-        ),
-    ],
-)
-def test_rule_apply(pattern, replacement, path, expected_url):
-    """Test the rule application logic."""
-    rule = Rule(pattern=pattern, replacement=replacement)
-    request = Request(
-        scope={
-            "type": "http",
-            "method": "GET",
-            "path": path,
-            "query_string": b"",
-            "headers": [],
-        }
-    )
-    result = rule.apply(request)
-    assert isinstance(result, URLRuleResult)
-    assert result.get_result_type() == "url"
-    assert result.url == expected_url
-
-
-def test_rule_apply_template():
-    """Test the rule application logic for template files."""
-    rule = Rule(
-        pattern=r"/api/v1/projects/(\d+)",
-        replacement=r"file:///path/to/template.json",
-    )
-    request = Request(
-        scope={
-            "type": "http",
-            "method": "GET",
-            "path": "/api/v1/projects/1234",
-            "query_string": b"",
-            "headers": [],
-        }
-    )
-    result = rule.apply(request)
-    assert isinstance(result, TemplateRuleResult)
-    assert result.get_result_type() == "template"
-    assert result.template_path == "/path/to/template.json"
-    assert result.template_context is not None
-    # The context should contain the extracted project ID from the path
-    assert "projects" in result.template_context
-    assert result.template_context["projects"] == "1234"
-
-
 def test_proxy_rules_strategy_load_rules(settings):
     """Test loading rules from the rules file."""
     strategy = ProxyRulesStrategy(settings)
@@ -271,8 +139,6 @@ def test_proxy_rules_strategy_get_content_type(settings):
     """Test content type detection based on file extension."""
     strategy = ProxyRulesStrategy(settings)
 
-    from pathlib import Path
-
     # Test various file extensions
     assert strategy._get_content_type(Path("file.json")) == "application/json"
     assert strategy._get_content_type(Path("file.xml")) == "application/xml"
@@ -492,3 +358,16 @@ async def test_proxy_rules_strategy_reverse_proxy(settings_reverse_proxy, span):
         assert isinstance(headers, Headers)
 
         mock_client.send.assert_called_once()
+
+    def test_maybe_update_response_headers_updates_content_encoding():
+        """Test maybe_update_response_headers updates content-encoding."""
+        headers = Headers(
+            {"content-encoding": "gzip", "content-type": "application/json"}
+        )
+        request_headers = Headers({"accept-encoding": "gzip"})
+
+        updated_headers = maybe_update_response_headers(headers, request_headers)
+
+        assert updated_headers["content-encoding"] == "identity"
+        assert updated_headers["content-type"] == "application/json"
+        assert updated_headers["accept-encoding"] == "gzip"

mockstack-0.11.0/mockstack/tests/test_rules.py

@@ -0,0 +1,138 @@
+"""Unit-tests for the rules module."""
+
+import pytest
+from fastapi import Request
+
+from mockstack.rules import Rule, TemplateRuleResult, URLRuleResult
+
+
+def test_rule_from_dict():
+    """Test creating a Rule from a dictionary."""
+    data = {
+        "pattern": r"/api/v1/projects/(\d+)",
+        "replacement": r"/projects/\1",
+        "method": "GET",
+    }
+    rule = Rule.from_dict(data)
+    assert rule.pattern == data["pattern"]
+    assert rule.replacement == data["replacement"]
+    assert rule.method == data["method"]
+
+
+def test_rule_from_dict_without_method():
+    """Test creating a Rule from a dictionary without a method."""
+    data = {
+        "pattern": r"/api/v1/projects/(\d+)",
+        "replacement": r"/projects/\1",
+    }
+    rule = Rule.from_dict(data)
+    assert rule.pattern == data["pattern"]
+    assert rule.replacement == data["replacement"]
+    assert rule.method is None
+
+
+@pytest.mark.parametrize(
+    "pattern,path,method,expected",
+    [
+        (r"/api/v1/projects/\d+", "/api/v1/projects/123", "GET", True),
+        (r"/api/v1/projects/\d+", "/api/v1/projects/123", "POST", True),
+        (r"/api/v1/projects/\d+", "/api/v1/projects/abc", "GET", False),
+        (r"/api/v1/projects/\d+", "/api/v1/users/123", "GET", False),
+        (r"/api/v1/projects/\d+", "/api/v1/projects/123", "POST", True),
+    ],
+)
+def test_rule_matches(pattern, path, method, expected):
+    """Test the rule matching logic."""
+    rule = Rule(pattern=pattern, replacement="", method=None)
+    request = Request(
+        scope={
+            "type": "http",
+            "method": method,
+            "path": path,
+            "query_string": b"",
+            "headers": [],
+        }
+    )
+    assert rule.matches(request) == expected
+
+
+@pytest.mark.parametrize(
+    "pattern,path,method,expected",
+    [
+        (r"/api/v1/projects/\d+", "/api/v1/projects/123", "GET", True),
+        (r"/api/v1/projects/\d+", "/api/v1/projects/123", "POST", False),
+    ],
+)
+def test_rule_matches_with_method(pattern, path, method, expected):
+    """Test the rule matching logic with method restriction."""
+    rule = Rule(pattern=pattern, replacement="", method="GET")
+    request = Request(
+        scope={
+            "type": "http",
+            "method": method,
+            "path": path,
+            "query_string": b"",
+            "headers": [],
+        }
+    )
+    assert rule.matches(request) == expected
+
+
+@pytest.mark.parametrize(
+    "pattern,replacement,path,expected_url",
+    [
+        (
+            r"/api/v1/projects/(\d+)",
+            r"/projects/\1",
+            "/api/v1/projects/123",
+            "/projects/123",
+        ),
+        (
+            r"/api/v1/users/([^/]+)",
+            r"/users/\1",
+            "/api/v1/users/john",
+            "/users/john",
+        ),
+    ],
+)
+def test_rule_apply(pattern, replacement, path, expected_url):
+    """Test the rule application logic."""
+    rule = Rule(pattern=pattern, replacement=replacement)
+    request = Request(
+        scope={
+            "type": "http",
+            "method": "GET",
+            "path": path,
+            "query_string": b"",
+            "headers": [],
+        }
+    )
+    result = rule.apply(request)
+    assert isinstance(result, URLRuleResult)
+    assert result.get_result_type() == "url"
+    assert result.url == expected_url
+
+
+def test_rule_apply_template():
+    """Test the rule application logic for template files."""
+    rule = Rule(
+        pattern=r"/api/v1/projects/(\d+)",
+        replacement=r"file:///path/to/template.json",
+    )
+    request = Request(
+        scope={
+            "type": "http",
+            "method": "GET",
+            "path": "/api/v1/projects/1234",
+            "query_string": b"",
+            "headers": [],
+        }
+    )
+    result = rule.apply(request)
+    assert isinstance(result, TemplateRuleResult)
+    assert result.get_result_type() == "template"
+    assert result.template_path == "/path/to/template.json"
+    assert result.template_context is not None
+    # The context should contain the extracted project ID from the path
+    assert "projects" in result.template_context
+    assert result.template_context["projects"] == "1234"

{mockstack-0.10.0 → mockstack-0.11.0}/mockstack.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mockstack
-Version: 0.10.0
+Version: 0.11.0
 Summary: An API mocking workhorse
 Author-email: Adam Ever-Hadani <mockstack.contact@gmail.com>
 License-Expression: MIT

{mockstack-0.10.0 → mockstack-0.11.0}/mockstack.egg-info/SOURCES.txt

@@ -48,6 +48,7 @@ mockstack/intent.py
 mockstack/lifespan.py
 mockstack/main.py
 mockstack/middleware.py
+mockstack/rules.py
 mockstack/telemetry.py
 mockstack/templating.py
 mockstack.egg-info/PKG-INFO
@@ -73,6 +74,7 @@ mockstack/tests/test_display.py
 mockstack/tests/test_identifiers.py
 mockstack/tests/test_intent.py
 mockstack/tests/test_middleware.py
+mockstack/tests/test_rules.py
 mockstack/tests/test_telemetry.py
 mockstack/tests/test_templating.py
 mockstack/tests/fixtures/__init__.py