local-web-services-python-sdk 0.1.0__tar.gz → 0.1.2__tar.gz

local_web_services_python_sdk-0.1.2/.github/workflows/ci.yml

@@ -0,0 +1,48 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+permissions:
+  pull-requests: write
+  checks: write
+  contents: read
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - run: make install
+      - run: make lint
+      - run: make format-check
+
+  analysis:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - run: make install
+      - run: make complexity
+      - run: make cpd
+      - run: make pylint
+
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - run: make install
+      - run: make test

local_web_services_python_sdk-0.1.2/Makefile

@@ -0,0 +1,36 @@
+.DEFAULT_GOAL := help
+
+.PHONY: help install lint format format-check complexity cpd pylint test check
+
+help: ## Show available targets
+	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf "  %-15s %s\n", $$1, $$2}'
+
+install: ## Install dependencies
+	uv sync --all-groups
+
+lint: ## Run linter
+	uvx ruff check src tests
+
+format: ## Auto-format code
+	uvx black src tests
+
+format-check: ## Check formatting without changing files
+	uvx black --check src tests
+
+complexity: ## Check cyclomatic complexity (all functions must be grade B or better)
+	@output=$$(uvx radon cc src -a -nc); \
+	echo "$$output"; \
+	echo "$$output" | grep -qE '^ +[A-Z]' && { echo "FAIL: complexity grade C or worse detected"; exit 1; } || true
+
+cpd: ## Check for copy-pasted code (5+ similar lines)
+	@output=$$(uvx --from pylint symilar -d 5 --ignore-imports --ignore-docstrings --ignore-signatures $$(find src -name "*.py")); \
+	echo "$$output" | tail -1; \
+	echo "$$output" | tail -1 | grep -q "duplicates=0 " || { echo "$$output"; exit 1; }
+
+pylint: ## Run pylint checks
+	uvx --from pylint pylint src/lws_testing --recursive=y
+
+test: ## Run test suite
+	uv run pytest tests/ -v
+
+check: lint format-check complexity cpd pylint test ## Run all checks (what CI runs)

{local_web_services_python_sdk-0.1.0 → local_web_services_python_sdk-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: local-web-services-python-sdk
-Version: 0.1.0
+Version: 0.1.2
 Summary: Python testing SDK for local-web-services — in-process pytest fixtures and boto3 helpers
 Project-URL: Homepage, https://local-web-services.github.io/www
 Project-URL: Repository, https://github.com/local-web-services/local-web-services-sdk-python

{local_web_services_python_sdk-0.1.0 → local_web_services_python_sdk-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "local-web-services-python-sdk"
-version = "0.1.0"
+version = "0.1.2"
 description = "Python testing SDK for local-web-services — in-process pytest fixtures and boto3 helpers"
 readme = "README.md"
 license = "MIT"
@@ -79,5 +79,5 @@ max-complexity = 10
 disable = [
     "E0401", "W0718", "R0801", "C0301", "C0302", "C0114", "C0115",
     "R0903", "R0902", "R0913", "R0917", "R0904", "R0911", "R0914", "C0103",
-    "W0603", "W0621",
+    "W0603", "W0621", "C0415", "C0116", "W0212",
 ]

{local_web_services_python_sdk-0.1.0 → local_web_services_python_sdk-0.1.2}/src/lws_testing/_builders/chaos.py

@@ -18,23 +18,23 @@ class ChaosBuilder:
         self._mgmt_port = mgmt_port
         self._config: dict = {"enabled": True}
 
-    def error_rate(self, rate: float) -> "ChaosBuilder":
+    def error_rate(self, rate: float) -> ChaosBuilder:
         """Set the fraction of requests that return an error (0.0–1.0)."""
         self._config["error_rate"] = float(rate)
         return self
 
-    def latency(self, min_ms: int = 0, max_ms: int = 0) -> "ChaosBuilder":
+    def latency(self, min_ms: int = 0, max_ms: int = 0) -> ChaosBuilder:
         """Inject artificial latency into responses."""
         self._config["latency_min_ms"] = min_ms
         self._config["latency_max_ms"] = max_ms
         return self
 
-    def connection_reset_rate(self, rate: float) -> "ChaosBuilder":
+    def connection_reset_rate(self, rate: float) -> ChaosBuilder:
         """Set the fraction of requests that receive a connection reset (0.0–1.0)."""
         self._config["connection_reset_rate"] = float(rate)
         return self
 
-    def timeout_rate(self, rate: float) -> "ChaosBuilder":
+    def timeout_rate(self, rate: float) -> ChaosBuilder:
         """Set the fraction of requests that time out (0.0–1.0)."""
         self._config["timeout_rate"] = float(rate)
         return self

{local_web_services_python_sdk-0.1.0 → local_web_services_python_sdk-0.1.2}/src/lws_testing/_builders/iam.py

@@ -24,17 +24,17 @@ class IamBuilder:
         self._updates: dict[str, Any] = {}
         self._identities: dict[str, Any] = {}
 
-    def mode(self, mode: str) -> "IamBuilder":
+    def mode(self, mode: str) -> IamBuilder:
         """Set the global IAM auth mode (``"enforce"``, ``"audit"``, ``"disabled"``)."""
         self._updates["mode"] = mode
         return self
 
-    def default_identity(self, name: str) -> "IamBuilder":
+    def default_identity(self, name: str) -> IamBuilder:
         """Set the default identity used when no identity header is present."""
         self._updates["default_identity"] = name
         return self
 
-    def identity(self, name: str) -> "_IdentityBuilder":
+    def identity(self, name: str) -> _IdentityBuilder:
         """Start configuring a named identity."""
         return _IdentityBuilder(self, name)
 
@@ -64,7 +64,7 @@ class _IdentityBuilder:
         self._inline_policies: list[dict[str, Any]] = []
         self._boundary: dict[str, Any] | None = None
 
-    def allow(self, actions: list[str], resource: str = "*") -> "_IdentityBuilder":
+    def allow(self, actions: list[str], resource: str = "*") -> _IdentityBuilder:
         """Add an Allow statement to this identity's inline policy."""
         self._inline_policies.append(
             {
@@ -83,7 +83,7 @@ class _IdentityBuilder:
         )
         return self
 
-    def deny(self, actions: list[str], resource: str = "*") -> "_IdentityBuilder":
+    def deny(self, actions: list[str], resource: str = "*") -> _IdentityBuilder:
         """Add an explicit Deny statement to this identity's inline policy."""
         self._inline_policies.append(
             {
@@ -102,7 +102,7 @@ class _IdentityBuilder:
         )
         return self
 
-    def boundary(self, actions: list[str], resource: str = "*") -> "_IdentityBuilder":
+    def boundary(self, actions: list[str], resource: str = "*") -> _IdentityBuilder:
         """Set a permissions boundary for this identity."""
         self._boundary = {
             "Version": "2012-10-17",
@@ -116,7 +116,7 @@ class _IdentityBuilder:
         }
         return self
 
-    def apply(self) -> "IamBuilder":
+    def apply(self) -> IamBuilder:
         """Register the identity and return the parent builder for chaining."""
         config: dict[str, Any] = {"inline_policies": self._inline_policies}
         if self._boundary is not None:

{local_web_services_python_sdk-0.1.0 → local_web_services_python_sdk-0.1.2}/src/lws_testing/_builders/mock.py

@@ -23,11 +23,11 @@ class MockBuilder:
         self._mgmt_port = mgmt_port
         self._rules: list[dict[str, Any]] = []
 
-    def operation(self, operation_name: str) -> "_MockRuleBuilder":
+    def operation(self, operation_name: str) -> _MockRuleBuilder:
         """Start building a mock rule for *operation_name*."""
         return _MockRuleBuilder(self, operation_name)
 
-    def _add_rule(self, rule: dict[str, Any]) -> "MockBuilder":
+    def _add_rule(self, rule: dict[str, Any]) -> MockBuilder:
         self._rules.append(rule)
         self._apply()
         return self
@@ -58,7 +58,7 @@ class _MockRuleBuilder:
         self._operation = operation
         self._match_headers: dict[str, str] = {}
 
-    def with_header(self, name: str, value: str) -> "_MockRuleBuilder":
+    def with_header(self, name: str, value: str) -> _MockRuleBuilder:
         """Add an additional header match constraint."""
         self._match_headers[name] = value
         return self

{local_web_services_python_sdk-0.1.0 → local_web_services_python_sdk-0.1.2}/src/lws_testing/_discovery/hcl.py

@@ -6,7 +6,6 @@ import re
 from pathlib import Path
 from typing import Any
 
-
 # Matches:  resource "aws_dynamodb_table" "logical_name" {
 _RESOURCE_HEADER = re.compile(
     r'resource\s+"(?P<type>[^"]+)"\s+"(?P<logical>[^"]+)"\s*\{',
@@ -14,7 +13,18 @@ _RESOURCE_HEADER = re.compile(
 # Matches a simple  key = "value"  assignment
 _ATTR_STR = re.compile(r'^\s*(?P<key>\w+)\s*=\s*"(?P<value>[^"]*)"')
 # Matches a simple  key = value  (unquoted booleans / numbers)
-_ATTR_BARE = re.compile(r'^\s*(?P<key>\w+)\s*=\s*(?P<value>\S+)')
+_ATTR_BARE = re.compile(r"^\s*(?P<key>\w+)\s*=\s*(?P<value>\S+)")
+
+# Maps Terraform resource types to (collection_key, builder_function)
+_DISPATCH: dict[str, tuple[str, Any]] = {
+    "aws_dynamodb_table": ("tables", "_build_table"),
+    "aws_sqs_queue": ("queues", "_build_queue"),
+    "aws_s3_bucket": ("buckets", "_build_bucket"),
+    "aws_sns_topic": ("topics", "_build_topic"),
+    "aws_sfn_state_machine": ("state_machines", "_build_state_machine"),
+    "aws_ssm_parameter": ("parameters", "_build_parameter"),
+    "aws_secretsmanager_secret": ("secrets", "_build_secret"),
+}
 
 
 def discover(project_dir: Path) -> dict[str, Any]:
@@ -35,58 +45,43 @@ def discover(project_dir: Path) -> dict[str, Any]:
     for tf_file in tf_files:
         resources.extend(_parse_tf_file(tf_file))
 
-    tables: list[dict[str, Any]] = []
-    queues: list[dict[str, Any]] = []
-    buckets: list[str] = []
-    topics: list[dict[str, Any]] = []
-    state_machines: list[dict[str, Any]] = []
-    parameters: list[dict[str, Any]] = []
-    secrets: list[dict[str, Any]] = []
-
+    return _classify_resources(resources)
+
+
+def _classify_resources(
+    resources: list[tuple[str, str, dict[str, str]]],
+) -> dict[str, list[Any]]:
+    """Route parsed resources into typed collections."""
+    result: dict[str, list[Any]] = {
+        "tables": [],
+        "queues": [],
+        "buckets": [],
+        "topics": [],
+        "state_machines": [],
+        "parameters": [],
+        "secrets": [],
+    }
+    handlers = _get_handlers()
     for resource_type, _logical, attrs in resources:
-        if resource_type == "aws_dynamodb_table":
-            table = _build_table(attrs)
-            if table:
-                tables.append(table)
-        elif resource_type == "aws_sqs_queue":
-            queue = _build_queue(attrs)
-            if queue:
-                queues.append(queue)
-        elif resource_type == "aws_s3_bucket":
-            name = attrs.get("bucket") or attrs.get("name")
-            if name:
-                buckets.append(name)
-        elif resource_type == "aws_sns_topic":
-            name = attrs.get("name")
-            if name:
-                topics.append({"name": name})
-        elif resource_type == "aws_sfn_state_machine":
-            sm = _build_state_machine(attrs)
-            if sm:
-                state_machines.append(sm)
-        elif resource_type == "aws_ssm_parameter":
-            param = _build_parameter(attrs)
-            if param:
-                parameters.append(param)
-        elif resource_type == "aws_secretsmanager_secret":
-            name = attrs.get("name")
-            if name:
-                secrets.append(
-                    {
-                        "name": name,
-                        "description": attrs.get("description", ""),
-                        "secret_string": "",
-                    }
-                )
+        if resource_type not in _DISPATCH:
+            continue
+        key, handler_name = _DISPATCH[resource_type]
+        item = handlers[handler_name](attrs)
+        if item is not None:
+            result[key].append(item)
+    return result
 
+
+def _get_handlers() -> dict[str, Any]:
+    """Return a map of handler name to callable."""
     return {
-        "tables": tables,
-        "queues": queues,
-        "buckets": buckets,
-        "topics": topics,
-        "state_machines": state_machines,
-        "parameters": parameters,
-        "secrets": secrets,
+        "_build_table": _build_table,
+        "_build_queue": _build_queue,
+        "_build_bucket": _build_bucket,
+        "_build_topic": _build_topic,
+        "_build_state_machine": _build_state_machine,
+        "_build_parameter": _build_parameter,
+        "_build_secret": _build_secret,
     }
 
 
@@ -115,11 +110,8 @@ def _collect_block(lines: list[str], start: int) -> tuple[dict[str, str], int]:
     i = start
     while i < len(lines) and depth > 0:
         line = lines[i]
-        opens = line.count("{")
-        closes = line.count("}")
-        depth += opens - closes
+        depth += line.count("{") - line.count("}")
         if depth > 1:
-            # Nested block — skip its contents
             i += 1
             continue
         if depth == 0:
@@ -162,6 +154,17 @@ def _build_queue(attrs: dict[str, str]) -> dict[str, Any] | None:
     return spec
 
 
+def _build_bucket(attrs: dict[str, str]) -> str | None:
+    """Build a bucket name from S3 resource attributes."""
+    return attrs.get("bucket") or attrs.get("name")
+
+
+def _build_topic(attrs: dict[str, str]) -> dict[str, str] | None:
+    """Build a topic spec dict from SNS resource attributes."""
+    name = attrs.get("name")
+    return {"name": name} if name else None
+
+
 def _build_state_machine(attrs: dict[str, str]) -> dict[str, Any] | None:
     """Build a state machine spec dict from Step Functions resource attributes."""
     name = attrs.get("name")
@@ -185,3 +188,15 @@ def _build_parameter(attrs: dict[str, str]) -> dict[str, Any] | None:
         "type": attrs.get("type", "String"),
         "description": attrs.get("description", ""),
     }
+
+
+def _build_secret(attrs: dict[str, str]) -> dict[str, Any] | None:
+    """Build a secret spec dict from Secrets Manager resource attributes."""
+    name = attrs.get("name")
+    if not name:
+        return None
+    return {
+        "name": name,
+        "description": attrs.get("description", ""),
+        "secret_string": "",
+    }

{local_web_services_python_sdk-0.1.0 → local_web_services_python_sdk-0.1.2}/src/lws_testing/_logs.py

@@ -33,7 +33,7 @@ class LogCapture:
         if self._handler is None:
             return
         full_backlog = self._handler.backlog()
-        self._entries = full_backlog[self._snapshot_len:]
+        self._entries = full_backlog[self._snapshot_len :]
 
     # ── Access ────────────────────────────────────────────────────────────────
 
@@ -59,11 +59,11 @@ class LogCapture:
         matching = [
             e
             for e in self._entries
-            if e.get("service", "").lower() == expected_service
-            and e.get("operation") == operation
+            if e.get("service", "").lower() == expected_service and e.get("operation") == operation
         ]
         assert matching, (
-            f"Expected {service}.{operation} to have been called, but no matching log entry was found. "
+            f"Expected {service}.{operation} to have been called, "
+            f"but no matching log entry was found. "
             f"Captured entries: {self._entries}"
         )
 
@@ -73,8 +73,7 @@ class LogCapture:
         matching = [
             e
             for e in self._entries
-            if e.get("service", "").lower() == expected_service
-            and e.get("operation") == operation
+            if e.get("service", "").lower() == expected_service and e.get("operation") == operation
         ]
         assert not matching, (
             f"Expected {service}.{operation} NOT to have been called, "
@@ -84,9 +83,7 @@ class LogCapture:
     def assert_no_errors(self) -> None:
         """Assert that no ERROR-level log entries were captured."""
         errors = [e for e in self._entries if e.get("level") == "ERROR"]
-        assert not errors, (
-            f"Expected no ERROR log entries, but found {len(errors)}: {errors}"
-        )
+        assert not errors, f"Expected no ERROR log entries, but found {len(errors)}: {errors}"
 
     def assert_call_count(self, service: str, operation: str, expected_count: int) -> None:
         """Assert that *service*.*operation* was called exactly *expected_count* times."""
@@ -94,8 +91,7 @@ class LogCapture:
         actual_entries = [
             e
             for e in self._entries
-            if e.get("service", "").lower() == expected_service
-            and e.get("operation") == operation
+            if e.get("service", "").lower() == expected_service and e.get("operation") == operation
         ]
         actual_count = len(actual_entries)
         assert actual_count == expected_count, (

{local_web_services_python_sdk-0.1.0 → local_web_services_python_sdk-0.1.2}/src/lws_testing/_resources/dynamodb.py

@@ -54,7 +54,8 @@ class DynamoDBHelper:
         """Assert that an item matching *key* exists; return the item."""
         item = self.get(key)
         assert item is not None, (
-            f"Expected item with key {key} in table {self._table_name!r} to exist, but it was not found."
+            f"Expected item with key {key} in table {self._table_name!r} "
+            "to exist, but it was not found."
         )
         return item
 

{local_web_services_python_sdk-0.1.0 → local_web_services_python_sdk-0.1.2}/src/lws_testing/_resources/sqs.py

@@ -62,9 +62,7 @@ class SQSHelper:
             QueueUrl=self._queue_url,
             AttributeNames=["ApproximateNumberOfMessages"],
         )
-        actual_count = int(
-            response["Attributes"].get("ApproximateNumberOfMessages", "0")
-        )
+        actual_count = int(response["Attributes"].get("ApproximateNumberOfMessages", "0"))
         assert actual_count == expected_count, (
             f"Expected {expected_count} message(s) in queue {self._queue_name!r}, "
             f"but found approximately {actual_count}."

{local_web_services_python_sdk-0.1.0 → local_web_services_python_sdk-0.1.2}/src/lws_testing/_transport/inprocess.py

@@ -112,8 +112,8 @@ def _create_management_app(
 ) -> Any:
     """Build a FastAPI management app with reset, mock, and chaos endpoints."""
     from fastapi import FastAPI
-    from lws.api.management import _handle_reset, create_management_router
     from fastapi.responses import JSONResponse
+    from lws.api.management import _handle_reset, create_management_router
 
     orchestrator = _StubOrchestrator(providers)
     app = FastAPI(title="LWS Testing Management")
@@ -134,139 +134,189 @@ def _create_management_app(
     return app
 
 
-async def start_services(
-    spec: dict[str, Any],
-    data_dir: Path,
-) -> tuple[Any, dict[str, int], int, list[Any]]:
-    """Start all LWS services in-process.
-
-    Returns:
-        Tuple of (log_handler, service_ports, management_port, servers_list).
-        ``servers_list`` is a list of ``(Server, Task)`` pairs that can be
-        passed directly to :func:`stop_services`.
-    """
+def _setup_logging() -> Any:
+    """Initialise WebSocketLogHandler and install it globally."""
     from lws.logging.logger import WebSocketLogHandler, set_ws_handler
-    from lws.providers._shared.aws_chaos import AwsChaosConfig
-    from lws.providers._shared.aws_operation_mock import AwsMockConfig
+
+    log_handler = WebSocketLogHandler()
+    set_ws_handler(log_handler)
+    return log_handler
+
+
+def _convert_spec(spec: dict[str, Any]) -> dict[str, list[Any]]:
+    """Convert raw spec dict to typed provider config lists."""
+    return {
+        "tables": [_make_table_config(t) for t in spec.get("tables", [])],
+        "queues": [_make_queue_config(q) for q in spec.get("queues", [])],
+        "buckets": [b if isinstance(b, str) else b["name"] for b in spec.get("buckets", [])],
+        "topics": [_make_topic_config(t) for t in spec.get("topics", [])],
+        "state_machines": [_make_state_machine_config(sm) for sm in spec.get("state_machines", [])],
+        "parameters": [_make_initial_parameter(p) for p in spec.get("parameters", [])],
+        "secrets": [_make_initial_secret(s) for s in spec.get("secrets", [])],
+    }
+
+
+def _create_providers(cfg: dict[str, list[Any]], data_dir: Path) -> dict[str, Any]:
+    """Instantiate all service providers."""
     from lws.providers.dynamodb.provider import SqliteDynamoProvider
-    from lws.providers.dynamodb.routes import create_dynamodb_app
-    from lws.providers.mockserver.provider import start_uvicorn_server
     from lws.providers.s3.provider import S3Provider
-    from lws.providers.s3.routes import create_s3_app
-    from lws.providers.secretsmanager.routes import create_secretsmanager_app
     from lws.providers.sns.provider import SnsProvider
-    from lws.providers.sns.routes import create_sns_app
     from lws.providers.sqs.provider import SqsProvider
-    from lws.providers.sqs.routes import create_sqs_app
-    from lws.providers.ssm.routes import create_ssm_app
     from lws.providers.stepfunctions.provider import StepFunctionsProvider
-    from lws.providers.stepfunctions.routes import create_stepfunctions_app
-
-    # Set up log handler
-    log_handler = WebSocketLogHandler()
-    set_ws_handler(log_handler)
-
-    # Convert spec to provider configs
-    tables = [_make_table_config(t) for t in spec.get("tables", [])]
-    queues = [_make_queue_config(q) for q in spec.get("queues", [])]
-    buckets = [b if isinstance(b, str) else b["name"] for b in spec.get("buckets", [])]
-    topics = [_make_topic_config(t) for t in spec.get("topics", [])]
-    state_machines = [_make_state_machine_config(sm) for sm in spec.get("state_machines", [])]
-    parameters = [_make_initial_parameter(p) for p in spec.get("parameters", [])]
-    secrets = [_make_initial_secret(s) for s in spec.get("secrets", [])]
 
-    # Create providers
     dynamo_data = data_dir / "dynamodb"
     dynamo_data.mkdir(parents=True, exist_ok=True)
     s3_data = data_dir / "s3"
     s3_data.mkdir(parents=True, exist_ok=True)
 
-    dynamo_provider = SqliteDynamoProvider(data_dir=dynamo_data, tables=tables)
-    sqs_provider = SqsProvider(queues=queues)
-    s3_provider = S3Provider(data_dir=s3_data, buckets=buckets)
-    sns_provider = SnsProvider(topics=topics)
-    sf_provider = StepFunctionsProvider(state_machines=state_machines)
+    return {
+        "dynamodb": SqliteDynamoProvider(data_dir=dynamo_data, tables=cfg["tables"]),
+        "sqs": SqsProvider(queues=cfg["queues"]),
+        "s3": S3Provider(data_dir=s3_data, buckets=cfg["buckets"]),
+        "sns": SnsProvider(topics=cfg["topics"]),
+        "stepfunctions": StepFunctionsProvider(state_machines=cfg["state_machines"]),
+    }
 
-    # Create mutable chaos and mock configs per service
-    service_names = ["dynamodb", "sqs", "s3", "sns", "stepfunctions", "ssm", "secretsmanager"]
-    chaos_configs: dict[str, AwsChaosConfig] = {s: AwsChaosConfig() for s in service_names}
-    mock_configs: dict[str, AwsMockConfig] = {s: AwsMockConfig(service=s) for s in service_names}
 
-    # Allocate ephemeral ports
-    ports: dict[str, int] = {s: _free_port() for s in service_names}
-    mgmt_port = _free_port()
+def _build_service_apps(
+    providers: dict[str, Any],
+    ports: dict[str, int],
+    chaos_configs: dict[str, Any],
+    mock_configs: dict[str, Any],
+    cfg: dict[str, list[Any]],
+) -> list[tuple[str, Any]]:
+    """Build FastAPI apps for all services; return as (service_name, app) pairs."""
+    from lws.providers.dynamodb.routes import create_dynamodb_app
+    from lws.providers.s3.routes import create_s3_app
+    from lws.providers.secretsmanager.routes import create_secretsmanager_app
+    from lws.providers.sns.routes import create_sns_app
+    from lws.providers.sqs.routes import create_sqs_app
+    from lws.providers.ssm.routes import create_ssm_app
+    from lws.providers.stepfunctions.routes import create_stepfunctions_app
+
+    return [
+        (
+            "dynamodb",
+            create_dynamodb_app(
+                providers["dynamodb"],
+                chaos=chaos_configs["dynamodb"],
+                aws_mock=mock_configs["dynamodb"],
+            ),
+        ),
+        (
+            "sqs",
+            create_sqs_app(
+                providers["sqs"],
+                port=ports["sqs"],
+                chaos=chaos_configs["sqs"],
+                aws_mock=mock_configs["sqs"],
+            ),
+        ),
+        (
+            "s3",
+            create_s3_app(
+                providers["s3"],
+                chaos=chaos_configs["s3"],
+                aws_mock=mock_configs["s3"],
+            ),
+        ),
+        (
+            "sns",
+            create_sns_app(
+                providers["sns"],
+                chaos=chaos_configs["sns"],
+                aws_mock=mock_configs["sns"],
+            ),
+        ),
+        (
+            "stepfunctions",
+            create_stepfunctions_app(
+                providers["stepfunctions"],
+                chaos=chaos_configs["stepfunctions"],
+                aws_mock=mock_configs["stepfunctions"],
+            ),
+        ),
+        (
+            "ssm",
+            create_ssm_app(
+                initial_parameters=cfg["parameters"] or None,
+                chaos=chaos_configs["ssm"],
+                aws_mock=mock_configs["ssm"],
+            ),
+        ),
+        (
+            "secretsmanager",
+            create_secretsmanager_app(
+                initial_secrets=cfg["secrets"] or None,
+                chaos=chaos_configs["secretsmanager"],
+                aws_mock=mock_configs["secretsmanager"],
+            ),
+        ),
+    ]
+
+
+async def _start_providers(providers: dict[str, Any]) -> None:
+    """Start the lifecycle of all service providers."""
+    for provider in providers.values():
+        await provider.start()
 
-    # Build FastAPI apps
-    dynamo_app = create_dynamodb_app(
-        dynamo_provider,
-        chaos=chaos_configs["dynamodb"],
-        aws_mock=mock_configs["dynamodb"],
-    )
-    sqs_app = create_sqs_app(
-        sqs_provider,
-        port=ports["sqs"],
-        chaos=chaos_configs["sqs"],
-        aws_mock=mock_configs["sqs"],
-    )
-    s3_app = create_s3_app(
-        s3_provider,
-        chaos=chaos_configs["s3"],
-        aws_mock=mock_configs["s3"],
-    )
-    sns_app = create_sns_app(
-        sns_provider,
-        chaos=chaos_configs["sns"],
-        aws_mock=mock_configs["sns"],
-    )
-    sf_app = create_stepfunctions_app(
-        sf_provider,
-        chaos=chaos_configs["stepfunctions"],
-        aws_mock=mock_configs["stepfunctions"],
-    )
-    ssm_app = create_ssm_app(
-        initial_parameters=parameters or None,
-        chaos=chaos_configs["ssm"],
-        aws_mock=mock_configs["ssm"],
-    )
-    secretsmanager_app = create_secretsmanager_app(
-        initial_secrets=secrets or None,
-        chaos=chaos_configs["secretsmanager"],
-        aws_mock=mock_configs["secretsmanager"],
-    )
 
-    # Start provider state (non-HTTP lifecycle)
-    await dynamo_provider.start()
-    await sqs_provider.start()
-    await s3_provider.start()
-    await sns_provider.start()
-    await sf_provider.start()
+async def _start_all_servers(
+    service_apps: list[tuple[str, Any]],
+    ports: dict[str, int],
+    mgmt_app: Any,
+    mgmt_port: int,
+) -> list[Any]:
+    """Start uvicorn servers for every service app plus the management app."""
+    from lws.providers.mockserver.provider import start_uvicorn_server
 
-    # Start uvicorn servers for each service
     servers: list[Any] = []
-    service_apps = [
-        ("dynamodb", dynamo_app),
-        ("sqs", sqs_app),
-        ("s3", s3_app),
-        ("sns", sns_app),
-        ("stepfunctions", sf_app),
-        ("ssm", ssm_app),
-        ("secretsmanager", secretsmanager_app),
-    ]
     for svc, app in service_apps:
         server, task = await start_uvicorn_server(app, ports[svc], host="127.0.0.1")
         servers.append((server, task))
-
-    # Start management app
-    all_providers: dict[str, Any] = {
-        "dynamodb": dynamo_provider,
-        "sqs": sqs_provider,
-        "s3": s3_provider,
-        "sns": sns_provider,
-        "stepfunctions": sf_provider,
-    }
-    mgmt_app = _create_management_app(all_providers, chaos_configs, mock_configs)
     mgmt_server, mgmt_task = await start_uvicorn_server(mgmt_app, mgmt_port, host="127.0.0.1")
     servers.append((mgmt_server, mgmt_task))
+    return servers
+
+
+_SERVICE_NAMES = [
+    "dynamodb",
+    "sqs",
+    "s3",
+    "sns",
+    "stepfunctions",
+    "ssm",
+    "secretsmanager",
+]
+
+
+async def start_services(
+    spec: dict[str, Any],
+    data_dir: Path,
+) -> tuple[Any, dict[str, int], int, list[Any]]:
+    """Start all LWS services in-process.
+
+    Returns:
+        Tuple of (log_handler, service_ports, management_port, servers_list).
+        ``servers_list`` is a list of ``(Server, Task)`` pairs that can be
+        passed directly to :func:`stop_services`.
+    """
+    from lws.providers._shared.aws_chaos import AwsChaosConfig
+    from lws.providers._shared.aws_operation_mock import AwsMockConfig
+
+    log_handler = _setup_logging()
+    cfg = _convert_spec(spec)
+    providers = _create_providers(cfg, data_dir)
+
+    chaos_configs: dict[str, Any] = {s: AwsChaosConfig() for s in _SERVICE_NAMES}
+    mock_configs: dict[str, Any] = {s: AwsMockConfig(service=s) for s in _SERVICE_NAMES}
+    ports: dict[str, int] = {s: _free_port() for s in _SERVICE_NAMES}
+    mgmt_port = _free_port()
+
+    service_apps = _build_service_apps(providers, ports, chaos_configs, mock_configs, cfg)
+    await _start_providers(providers)
+    mgmt_app = _create_management_app(providers, chaos_configs, mock_configs)
+    servers = await _start_all_servers(service_apps, ports, mgmt_app, mgmt_port)
 
     return log_handler, ports, mgmt_port, servers
 

{local_web_services_python_sdk-0.1.0 → local_web_services_python_sdk-0.1.2}/src/lws_testing/fixtures.py

@@ -26,7 +26,8 @@ Available fixtures
 
 from __future__ import annotations
 
-from typing import Any, Generator
+from collections.abc import Generator
+from typing import Any
 
 import pytest
 

{local_web_services_python_sdk-0.1.0 → local_web_services_python_sdk-0.1.2}/src/lws_testing/session.py

@@ -3,15 +3,35 @@
 from __future__ import annotations
 
 import asyncio
+import os
 import shutil
 import socket
 import tempfile
 import threading
+from collections.abc import Generator
 from contextlib import contextmanager
 from pathlib import Path
-from typing import Any, Generator
-
-import httpx
+from typing import Any
+
+# Maps boto3 service name → AWS SDK endpoint URL env var.
+# Setting these redirects *any* boto3 client created in the process to the
+# local LWS service — no production-code changes required.
+_SERVICE_ENV_VARS: dict[str, str] = {
+    "dynamodb": "AWS_ENDPOINT_URL_DYNAMODB",
+    "sqs": "AWS_ENDPOINT_URL_SQS",
+    "s3": "AWS_ENDPOINT_URL_S3",
+    "sns": "AWS_ENDPOINT_URL_SNS",
+    "stepfunctions": "AWS_ENDPOINT_URL_STEPFUNCTIONS",
+    "ssm": "AWS_ENDPOINT_URL_SSM",
+    "secretsmanager": "AWS_ENDPOINT_URL_SECRETSMANAGER",
+}
+
+# Credential / region overrides so boto3 never tries to contact IAM or STS.
+_TEST_CREDENTIALS: dict[str, str] = {
+    "AWS_ACCESS_KEY_ID": "test",
+    "AWS_SECRET_ACCESS_KEY": "test",
+    "AWS_DEFAULT_REGION": "us-east-1",
+}
 
 
 def _free_port() -> int:
@@ -71,11 +91,12 @@ class LwsSession:
         self._thread: threading.Thread | None = None
         self._data_dir: Path | None = None
         self._log_handler: Any = None
+        self._saved_env: dict[str, str | None] = {}
 
     # ── Constructors ──────────────────────────────────────────────────────────
 
     @classmethod
-    def from_cdk(cls, project_dir: str = ".") -> "LwsSession":
+    def from_cdk(cls, project_dir: str = ".") -> LwsSession:
         """Create a session by discovering resources from a CDK project.
 
         Reads the synthesised cloud assembly in ``{project_dir}/cdk.out/``.
@@ -91,7 +112,7 @@ class LwsSession:
         return cls(**spec)
 
     @classmethod
-    def from_hcl(cls, project_dir: str = ".") -> "LwsSession":
+    def from_hcl(cls, project_dir: str = ".") -> LwsSession:
         """Create a session by discovering resources from an HCL project.
 
         Reads ``.tf`` files in ``project_dir`` to discover tables, queues,
@@ -107,7 +128,7 @@ class LwsSession:
 
     # ── Context manager ───────────────────────────────────────────────────────
 
-    def __enter__(self) -> "LwsSession":
+    def __enter__(self) -> LwsSession:
         self._start()
         return self
 
@@ -137,19 +158,24 @@ class LwsSession:
         ready.wait(timeout=30)
 
         if error_holder:
-            raise RuntimeError(f"LwsSession failed to start: {error_holder[0]}") from error_holder[0]
+            exc = error_holder[0]
+            raise RuntimeError(f"LwsSession failed to start: {exc}") from exc
+
+        self._patch_env()
 
     async def _async_start(self, ready: threading.Event) -> None:
         """Create providers, build apps, start servers."""
         from lws_testing._transport.inprocess import start_services
 
-        self._log_handler, self._ports, self._mgmt_port, self._servers = (
-            await start_services(self._spec, self._data_dir)
+        self._log_handler, self._ports, self._mgmt_port, self._servers = await start_services(
+            self._spec, self._data_dir
         )
         ready.set()
 
     def _stop(self) -> None:
         """Stop all servers and clean up temporary state."""
+        self._restore_env()
+
         if self._loop and self._loop.is_running():
             future = asyncio.run_coroutine_threadsafe(self._async_stop(), self._loop)
             future.result(timeout=10)
@@ -167,6 +193,33 @@ class LwsSession:
 
         await stop_services(self._servers)
 
+    # ── Environment patching ──────────────────────────────────────────────────
+
+    def _patch_env(self) -> None:
+        """Set AWS SDK endpoint env vars so any boto3 client hits local LWS.
+
+        This is the drop-in mechanism: production code that creates boto3
+        clients the normal way (``boto3.client("dynamodb")``) is automatically
+        redirected to the local services without any code changes.
+        """
+        for service, env_var in _SERVICE_ENV_VARS.items():
+            port = self._ports.get(service)
+            if port:
+                self._saved_env[env_var] = os.environ.get(env_var)
+                os.environ[env_var] = f"http://127.0.0.1:{port}"
+        for key, val in _TEST_CREDENTIALS.items():
+            self._saved_env[key] = os.environ.get(key)
+            os.environ[key] = val
+
+    def _restore_env(self) -> None:
+        """Restore all env vars that were overridden by :meth:`_patch_env`."""
+        for key, saved in self._saved_env.items():
+            if saved is None:
+                os.environ.pop(key, None)
+            else:
+                os.environ[key] = saved
+        self._saved_env = {}
+
     # ── boto3 client factory ──────────────────────────────────────────────────
 
     def client(self, service: str) -> Any:
@@ -279,6 +332,15 @@ class LwsSession:
 
         return S3Helper(bucket_name, self.client("s3"))
 
+    def queue_url(self, queue_name: str) -> str:
+        """Return the local SQS URL for *queue_name*.
+
+        Use this to set the queue URL env var that production code reads::
+
+            os.environ["ORDER_QUEUE_URL"] = session.queue_url("OrderQueue")
+        """
+        return f"http://127.0.0.1:{self._ports['sqs']}/000000000000/{queue_name}"
+
     # ── Mock / chaos / IAM builders ───────────────────────────────────────────
 
     def mock(self, service: str) -> Any:

{local_web_services_python_sdk-0.1.0 → local_web_services_python_sdk-0.1.2}/tests/unit/test_session_lifecycle.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import pytest
+
 from lws_testing import LwsSession
 
 
@@ -102,3 +103,47 @@ def test_all_services_available(session):
     for svc in expected_services:
         client = session.client(svc)
         assert client is not None, f"Expected service {svc!r} to be available"
+
+
+def test_vanilla_boto3_client_is_redirected_to_lws(session):
+    # Arrange — env vars are set by the session; a plain boto3 client should
+    # hit LWS without any explicit endpoint_url
+    import boto3
+
+    # Act
+    vanilla_client = boto3.client("dynamodb", region_name="us-east-1")
+    response = vanilla_client.list_tables()
+
+    # Assert — LWS responded (real AWS would also return this key, but if the
+    # env var wasn't set the call would fail with NoCredentialsError or timeout)
+    assert "TableNames" in response
+
+
+def test_env_vars_are_restored_after_session_closes():
+    # Arrange — capture state before any session starts
+    import os
+
+    expected_key = "AWS_ENDPOINT_URL_DYNAMODB"
+    value_before = os.environ.get(expected_key)
+
+    # Act
+    with LwsSession(tables=[{"name": "Tmp", "partition_key": "id"}]):
+        actual_during = os.environ.get(expected_key)
+
+    actual_after = os.environ.get(expected_key)
+
+    # Assert
+    assert actual_during is not None, "Expected env var to be set during session"
+    assert actual_after == value_before, "Expected env var to be restored after session"
+
+
+def test_queue_url_returns_local_url(session):
+    # Arrange
+    expected_queue_name = "OrderQueue"
+
+    # Act
+    actual_url = session.queue_url(expected_queue_name)
+
+    # Assert
+    assert "127.0.0.1" in actual_url
+    assert expected_queue_name in actual_url

local_web_services_python_sdk-0.1.0/Makefile

@@ -1,17 +0,0 @@
-.PHONY: install check lint format test
-
-install:
-	uv sync --all-groups
-
-lint:
-	uv run ruff check src/ tests/
-	uv run pylint src/
-
-format:
-	uv run black src/ tests/
-	uv run ruff check --fix src/ tests/
-
-test:
-	uv run pytest tests/ -v
-
-check: lint test