stackport 0.4.3__tar.gz → 0.4.4__tar.gz

{stackport-0.4.3/stackport.egg-info → stackport-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stackport
-Version: 0.4.3
+Version: 0.4.4
 Summary: Universal AWS resource browser for local emulators
 Author: Davi Reis Vieira
 License: MIT

{stackport-0.4.3 → stackport-0.4.4}/backend/routes/dynamodb.py

@@ -1,4 +1,5 @@
 import base64
+import binascii
 import json
 import logging
 from typing import Any
@@ -27,6 +28,58 @@ def _plain_to_dynamodb_item(plain: dict[str, Any]) -> dict[str, Any]:
     return {k: _serializer.serialize(v) for k, v in plain.items()}
 
 
+# Binary (B / BS) travels as base64 over StackPort's HTTP API, the same way AWS
+# writes it in DynamoDB JSON. boto3 hands us raw bytes, which JSON cannot carry.
+
+
+def _to_json_safe(obj: Any) -> Any:
+    """Replace every bytes value with its base64 text. Safe to apply to whole
+    low-level responses: DynamoDB only returns bytes inside B and BS."""
+    if isinstance(obj, (bytes, bytearray)):
+        return base64.b64encode(obj).decode("ascii")
+    if isinstance(obj, dict):
+        return {k: _to_json_safe(v) for k, v in obj.items()}
+    if isinstance(obj, list):
+        return [_to_json_safe(v) for v in obj]
+    return obj
+
+
+def _b64_to_bytes(value: Any, name: str) -> bytes:
+    if isinstance(value, (bytes, bytearray)):
+        return bytes(value)
+    try:
+        return base64.b64decode(value, validate=True)
+    except (binascii.Error, TypeError, ValueError) as e:
+        raise HTTPException(status_code=400, detail=f"Attribute {name!r} is not valid base64 for type B") from e
+
+
+def _attr_from_json(av: Any, name: str) -> Any:
+    """Inverse of _to_json_safe for one DynamoDB attribute value. Type-aware, so
+    strings under S stay strings and only B / BS are decoded."""
+    if not isinstance(av, dict):
+        return av
+    if "B" in av:
+        return {**av, "B": _b64_to_bytes(av["B"], name)}
+    if "BS" in av and isinstance(av["BS"], list):
+        return {**av, "BS": [_b64_to_bytes(v, name) for v in av["BS"]]}
+    if "L" in av and isinstance(av["L"], list):
+        return {**av, "L": [_attr_from_json(v, name) for v in av["L"]]}
+    if "M" in av and isinstance(av["M"], dict):
+        return {**av, "M": {k: _attr_from_json(v, f"{name}.{k}") for k, v in av["M"].items()}}
+    return av
+
+
+def _item_from_json(item: dict[str, Any]) -> dict[str, Any]:
+    return {k: _attr_from_json(v, k) for k, v in item.items()}
+
+
+def _key_value(attr_type: str, value: str, name: str) -> dict[str, Any]:
+    """Typed key value for a query condition. Binary keys arrive as base64."""
+    if attr_type == "B":
+        return {"B": _b64_to_bytes(value, name)}
+    return {attr_type: value}
+
+
 def _get_partition_sort_keys(dynamodb: Any, table_name: str) -> tuple[str | None, str | None]:
     table_resp = dynamodb.describe_table(TableName=table_name)
     key_schema = table_resp["Table"].get("KeySchema", [])
@@ -56,7 +109,7 @@ def _coerce_item_dict(raw: dict[str, Any], item_format: str) -> dict[str, Any]:
             return _plain_to_dynamodb_item(raw)
         except TypeError as e:
             raise HTTPException(status_code=400, detail=f"Could not convert plain item to DynamoDB types: {e}") from e
-    return raw
+    return _item_from_json(raw)
 
 
 def _coerce_key_dict(raw: dict[str, Any], item_format: str) -> dict[str, Any]:
@@ -65,7 +118,7 @@ def _coerce_key_dict(raw: dict[str, Any], item_format: str) -> dict[str, Any]:
             return _plain_to_dynamodb_item(raw)
         except TypeError as e:
             raise HTTPException(status_code=400, detail=f"Could not convert plain key to DynamoDB types: {e}") from e
-    return raw
+    return _item_from_json(raw)
 
 
 def _invalidate_table_item_count(table_name: str, endpoint_url: str | None) -> None:
@@ -237,7 +290,7 @@ def scan_table(
     if exclusive_start_key:
         try:
             decoded = base64.b64decode(exclusive_start_key).decode("utf-8")
-            scan_params["ExclusiveStartKey"] = json.loads(decoded)
+            scan_params["ExclusiveStartKey"] = _item_from_json(json.loads(decoded))
         except Exception:
             logger.debug("Invalid exclusive_start_key", exc_info=True)
 
@@ -248,11 +301,11 @@ def scan_table(
         last_evaluated_key = resp.get("LastEvaluatedKey")
         next_token = None
         if last_evaluated_key:
-            next_token = base64.b64encode(json.dumps(last_evaluated_key).encode("utf-8")).decode("utf-8")
+            next_token = base64.b64encode(json.dumps(_to_json_safe(last_evaluated_key)).encode("utf-8")).decode("utf-8")
 
         return {
             "table": name,
-            "items": items,
+            "items": _to_json_safe(items),
             "count": len(items),
             "scanned_count": resp.get("ScannedCount", len(items)),
             "next_token": next_token,
@@ -285,19 +338,19 @@ def query_table(name: str, request: QueryRequest, ep: EndpointInfo = Depends(get
         # Build key condition expression
         key_condition = f"#{partition_key} = :pk"
         expression_attr_names = {f"#{partition_key}": partition_key}
-        expression_attr_values = {":pk": {partition_key_type: request.partition_key_value}}
+        expression_attr_values = {":pk": _key_value(partition_key_type, request.partition_key_value, partition_key)}
 
         if sort_key and request.sort_key_value:
             sort_key_type = attribute_defs.get(sort_key, "S")
             if request.sort_key_operator == "=":
                 key_condition += f" AND #{sort_key} = :sk"
-                expression_attr_values[":sk"] = {sort_key_type: request.sort_key_value}
+                expression_attr_values[":sk"] = _key_value(sort_key_type, request.sort_key_value, sort_key)
             elif request.sort_key_operator in ("<", "<=", ">", ">="):
                 key_condition += f" AND #{sort_key} {request.sort_key_operator} :sk"
-                expression_attr_values[":sk"] = {sort_key_type: request.sort_key_value}
+                expression_attr_values[":sk"] = _key_value(sort_key_type, request.sort_key_value, sort_key)
             elif request.sort_key_operator == "BEGINS_WITH":
                 key_condition += f" AND begins_with(#{sort_key}, :sk)"
-                expression_attr_values[":sk"] = {sort_key_type: request.sort_key_value}
+                expression_attr_values[":sk"] = _key_value(sort_key_type, request.sort_key_value, sort_key)
             expression_attr_names[f"#{sort_key}"] = sort_key
 
         query_params = {
@@ -313,10 +366,12 @@ def query_table(name: str, request: QueryRequest, ep: EndpointInfo = Depends(get
 
         return {
             "table": name,
-            "items": items,
+            "items": _to_json_safe(items),
             "count": len(items),
             "scanned_count": resp.get("ScannedCount", len(items)),
         }
+    except HTTPException:
+        raise
     except Exception as e:
         logger.error("Failed to query table %s: %s", name, e, exc_info=True)
         return {"error": str(e), "items": [], "count": 0}
@@ -411,7 +466,7 @@ def batch_write_items(
         return {
             "ok": True,
             "table": name,
-            "unprocessed": uproc,
+            "unprocessed": _to_json_safe(uproc),
             "message": "Some items were not processed; retry with returned keys.",
         }
 

{stackport-0.4.3 → stackport-0.4.4}/backend/routes/resources.py

@@ -85,6 +85,11 @@ _PREFERRED_ID_FIELD: dict[tuple[str, str], str] = {
     ("cognito-idp", "user_pools"): "Id",
     ("apigateway", "rest_apis"): "id",
     ("apigateway", "apis"): "ApiId",
+    ("iam", "policies"): "Arn",
+    ("ec2", "subnets"): "SubnetId",
+    ("ec2", "security_groups"): "GroupId",
+    ("elasticfilesystem", "file_systems"): "FileSystemId",
+    ("rds", "db_clusters"): "DBClusterIdentifier",
 }
 
 # Known ID field names for extracting a resource identifier from list results

{stackport-0.4.3 → stackport-0.4.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "stackport"
-version = "0.4.3"
+version = "0.4.4"
 description = "Universal AWS resource browser for local emulators"
 readme = "README.md"
 license = {text = "MIT"}

{stackport-0.4.3 → stackport-0.4.4/stackport.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stackport
-Version: 0.4.3
+Version: 0.4.4
 Summary: Universal AWS resource browser for local emulators
 Author: Davi Reis Vieira
 License: MIT

{stackport-0.4.3 → stackport-0.4.4}/tests/test_dynamodb_routes.py

@@ -407,3 +407,170 @@ class TestItemWrites:
         assert any(k.endswith(":dynamodb:item_count:t1") for k in cache_keys), (
             f"expected item_count cache invalidation, got calls: {cache_keys}"
         )
+
+
+# Binary attributes (#176). b"\x00\x8e\xff" is not valid UTF-8, which is what
+# crashed FastAPI's encoder; its base64 form is "AI7/".
+RAW = b"\x00\x8e\xff"
+RAW_B64 = "AI7/"
+
+
+def _hash_table(mock_ddb, key_type="S"):
+    mock_ddb.describe_table.return_value = {
+        "Table": {
+            "KeySchema": [{"AttributeName": "pk", "KeyType": "HASH"}],
+            "AttributeDefinitions": [{"AttributeName": "pk", "AttributeType": key_type}],
+        }
+    }
+
+
+class TestBinaryAttributes:
+    @patch("backend.routes.dynamodb.get_client")
+    def test_scan_returns_binary_as_base64(self, mock_get_client):
+        mock_ddb = MagicMock()
+        mock_get_client.return_value = mock_ddb
+        mock_ddb.scan.return_value = {
+            "Items": [
+                {
+                    "pk": {"S": "a"},
+                    "blob": {"B": RAW},
+                    "set": {"BS": [RAW, b"ok"]},
+                    "nested": {"M": {"inner": {"B": RAW}, "list": {"L": [{"B": RAW}, {"S": "keep"}]}}},
+                }
+            ],
+            "ScannedCount": 1,
+        }
+
+        resp = client.get("/api/dynamodb/tables/t1/items")
+        assert resp.status_code == 200
+        item = resp.json()["items"][0]
+        assert item["pk"] == {"S": "a"}
+        assert item["blob"] == {"B": RAW_B64}
+        assert item["set"] == {"BS": [RAW_B64, "b2s="]}
+        assert item["nested"]["M"]["inner"] == {"B": RAW_B64}
+        assert item["nested"]["M"]["list"]["L"] == [{"B": RAW_B64}, {"S": "keep"}]
+
+    @patch("backend.routes.dynamodb.get_client")
+    def test_scan_paginates_on_a_binary_key(self, mock_get_client):
+        mock_ddb = MagicMock()
+        mock_get_client.return_value = mock_ddb
+        mock_ddb.scan.return_value = {
+            "Items": [{"pk": {"B": RAW}}],
+            "ScannedCount": 1,
+            "LastEvaluatedKey": {"pk": {"B": RAW}},
+        }
+
+        first = client.get("/api/dynamodb/tables/t1/items?limit=1")
+        assert first.status_code == 200
+        body = first.json()
+        assert "error" not in body
+        assert body["next_token"]
+
+        client.get(f"/api/dynamodb/tables/t1/items?limit=1&exclusive_start_key={body['next_token']}")
+        assert mock_ddb.scan.call_args[1]["ExclusiveStartKey"] == {"pk": {"B": RAW}}
+
+    @patch("backend.routes.dynamodb.get_client")
+    def test_query_on_a_binary_partition_key(self, mock_get_client):
+        mock_ddb = MagicMock()
+        mock_get_client.return_value = mock_ddb
+        _hash_table(mock_ddb, key_type="B")
+        mock_ddb.query.return_value = {"Items": [{"pk": {"B": RAW}}], "ScannedCount": 1}
+
+        resp = client.post("/api/dynamodb/tables/t1/query", json={"partition_key_value": RAW_B64})
+        assert resp.status_code == 200
+        assert resp.json()["items"] == [{"pk": {"B": RAW_B64}}]
+        assert mock_ddb.query.call_args[1]["ExpressionAttributeValues"][":pk"] == {"B": RAW}
+
+    @patch("backend.routes.dynamodb.get_client")
+    def test_query_with_invalid_base64_key_is_400(self, mock_get_client):
+        mock_ddb = MagicMock()
+        mock_get_client.return_value = mock_ddb
+        _hash_table(mock_ddb, key_type="B")
+
+        resp = client.post("/api/dynamodb/tables/t1/query", json={"partition_key_value": "not base64!"})
+        assert resp.status_code == 400
+        mock_ddb.query.assert_not_called()
+
+    @patch("backend.routes.dynamodb.get_client")
+    def test_put_decodes_base64_to_bytes(self, mock_get_client):
+        mock_ddb = MagicMock()
+        mock_get_client.return_value = mock_ddb
+        _hash_table(mock_ddb)
+
+        resp = client.put(
+            "/api/dynamodb/tables/t1/items",
+            json={
+                "item": {"pk": {"S": "a"}, "blob": {"B": RAW_B64}, "set": {"BS": [RAW_B64]}, "m": {"M": {"x": {"B": RAW_B64}}}},
+                "item_format": "dynamodb",
+            },
+        )
+        assert resp.status_code == 200
+        item = mock_ddb.put_item.call_args[1]["Item"]
+        assert item["pk"] == {"S": "a"}
+        assert item["blob"] == {"B": RAW}
+        assert item["set"] == {"BS": [RAW]}
+        assert item["m"] == {"M": {"x": {"B": RAW}}}
+
+    @patch("backend.routes.dynamodb.get_client")
+    def test_put_with_invalid_base64_is_400(self, mock_get_client):
+        mock_ddb = MagicMock()
+        mock_get_client.return_value = mock_ddb
+        _hash_table(mock_ddb)
+
+        resp = client.put(
+            "/api/dynamodb/tables/t1/items",
+            json={"item": {"pk": {"S": "a"}, "blob": {"B": "not base64!"}}, "item_format": "dynamodb"},
+        )
+        assert resp.status_code == 400
+        assert "blob" in resp.json()["detail"]
+        mock_ddb.put_item.assert_not_called()
+
+    @patch("backend.routes.dynamodb.get_client")
+    def test_delete_and_batch_delete_by_binary_key(self, mock_get_client):
+        mock_ddb = MagicMock()
+        mock_get_client.return_value = mock_ddb
+        _hash_table(mock_ddb, key_type="B")
+        mock_ddb.batch_write_item.return_value = {"UnprocessedItems": {}}
+
+        resp = client.request(
+            "DELETE", "/api/dynamodb/tables/t1/items", json={"key": {"pk": {"B": RAW_B64}}, "item_format": "dynamodb"}
+        )
+        assert resp.status_code == 200
+        assert mock_ddb.delete_item.call_args[1]["Key"] == {"pk": {"B": RAW}}
+
+        resp = client.post(
+            "/api/dynamodb/tables/t1/items/batch",
+            json={"item_format": "dynamodb", "operations": [{"op": "delete", "key": {"pk": {"B": RAW_B64}}}]},
+        )
+        assert resp.status_code == 200
+        req = mock_ddb.batch_write_item.call_args[1]["RequestItems"]["t1"]
+        assert req == [{"DeleteRequest": {"Key": {"pk": {"B": RAW}}}}]
+
+    @patch("backend.routes.dynamodb.get_client")
+    def test_batch_unprocessed_binary_is_returned_as_base64(self, mock_get_client):
+        mock_ddb = MagicMock()
+        mock_get_client.return_value = mock_ddb
+        _hash_table(mock_ddb, key_type="B")
+        mock_ddb.batch_write_item.return_value = {
+            "UnprocessedItems": {"t1": [{"PutRequest": {"Item": {"pk": {"B": RAW}}}}]}
+        }
+
+        resp = client.post(
+            "/api/dynamodb/tables/t1/items/batch",
+            json={"item_format": "dynamodb", "operations": [{"op": "put", "item": {"pk": {"B": RAW_B64}}}]},
+        )
+        assert resp.status_code == 200
+        assert resp.json()["unprocessed"] == {"t1": [{"PutRequest": {"Item": {"pk": {"B": RAW_B64}}}}]}
+
+    @patch("backend.routes.dynamodb.get_client")
+    def test_scan_output_round_trips_through_put(self, mock_get_client):
+        """What Edit does: take an item from the scan and save it unchanged."""
+        mock_ddb = MagicMock()
+        mock_get_client.return_value = mock_ddb
+        _hash_table(mock_ddb)
+        original = {"pk": {"S": "a"}, "blob": {"B": RAW}, "set": {"BS": [RAW, b"ok"]}}
+        mock_ddb.scan.return_value = {"Items": [original], "ScannedCount": 1}
+
+        scanned = client.get("/api/dynamodb/tables/t1/items").json()["items"][0]
+        client.put("/api/dynamodb/tables/t1/items", json={"item": scanned, "item_format": "dynamodb"})
+        assert mock_ddb.put_item.call_args[1]["Item"] == original

stackport-0.4.4/tests/test_registries.py

@@ -0,0 +1,142 @@
+"""Validate SERVICE_REGISTRY, DESCRIBE_REGISTRY, and _METHOD_KWARGS consistency."""
+
+import csv
+import io
+from unittest.mock import MagicMock
+
+import boto3
+import pytest
+from click.testing import CliRunner
+
+from backend.cli import cli
+from backend.routes.resources import (
+    _ID_FIELDS,
+    _PREFERRED_ID_FIELD,
+    DESCRIBE_REGISTRY,
+    _extract_id,
+    _summarize_item,
+)
+from backend.routes.stats import _METHOD_KWARGS, SERVICE_REGISTRY
+
+
+class TestServiceRegistry:
+    def test_all_entries_are_4_tuples(self):
+        for service, entries in SERVICE_REGISTRY.items():
+            for entry in entries:
+                assert len(entry) == 4, f"{service}: entry {entry} is not a 4-tuple"
+                resource_type, boto3_service, method, response_key = entry
+                assert isinstance(resource_type, str) and resource_type
+                assert isinstance(boto3_service, str) and boto3_service
+                assert isinstance(method, str) and method
+                assert isinstance(response_key, str) and response_key
+
+    def test_no_duplicate_resource_types_per_service(self):
+        for service, entries in SERVICE_REGISTRY.items():
+            types = [e[0] for e in entries]
+            assert len(types) == len(set(types)), f"{service} has duplicate resource types"
+
+    def test_expected_services_present(self):
+        expected = {"s3", "sqs", "sns", "dynamodb", "lambda", "iam", "ec2", "logs"}
+        assert expected.issubset(SERVICE_REGISTRY.keys())
+
+
+class TestDescribeRegistry:
+    def test_all_entries_are_4_tuples(self):
+        for key, entry in DESCRIBE_REGISTRY.items():
+            assert len(entry) == 4, f"{key}: entry {entry} is not a 4-tuple"
+            boto3_service, method, id_param, response_key = entry
+            assert isinstance(boto3_service, str) and boto3_service
+            assert isinstance(method, str) and method
+            assert isinstance(id_param, str) and id_param
+            assert response_key is None or isinstance(response_key, str)
+
+    def test_keys_are_service_type_tuples(self):
+        for key in DESCRIBE_REGISTRY:
+            assert isinstance(key, tuple) and len(key) == 2
+            service, res_type = key
+            assert isinstance(service, str) and isinstance(res_type, str)
+
+
+class TestMethodKwargs:
+    def test_keys_reference_valid_methods(self):
+        """All _METHOD_KWARGS keys should reference methods that exist in SERVICE_REGISTRY."""
+        all_methods = set()
+        for entries in SERVICE_REGISTRY.values():
+            for _, boto3_service, method, _ in entries:
+                all_methods.add((boto3_service, method))
+
+        for key in _METHOD_KWARGS:
+            assert key in all_methods, (
+                f"_METHOD_KWARGS key {key} not found in SERVICE_REGISTRY methods"
+            )
+
+    def test_values_are_dicts(self):
+        for key, value in _METHOD_KWARGS.items():
+            assert isinstance(value, dict), f"{key}: value is not a dict"
+
+
+class TestIdFields:
+    def test_id_fields_are_strings(self):
+        for field in _ID_FIELDS:
+            assert isinstance(field, str) and field
+
+    def test_no_duplicates(self):
+        assert len(_ID_FIELDS) == len(set(_ID_FIELDS))
+
+
+class TestPreferredIdField:
+    @pytest.fixture(params=[
+        ("apigateway", "apis", "ApiId", "ApiId"),
+        ("iam", "policies", "Arn", "PolicyArn"),
+        ("ec2", "subnets", "SubnetId", "SubnetIds"),
+        ("ec2", "security_groups", "GroupId", "GroupIds"),
+        ("elasticfilesystem", "file_systems", "FileSystemId", "FileSystemId"),
+        ("rds", "db_clusters", "DBClusterIdentifier", "DBClusterIdentifier"),
+    ], ids=lambda case: f"{case[0]}/{case[1]}")
+    def resource_case(self, request):
+        service, resource_type, id_field, id_param = request.param
+        entry = next(e for e in SERVICE_REGISTRY[service] if e[0] == resource_type)
+        _, boto_service, list_method, response_key = entry
+        client = boto3.client(
+            boto_service, region_name="us-east-1",
+            aws_access_key_id="test", aws_secret_access_key="test",
+        )
+        model = client.meta.service_model
+        operation = model.operation_model(client.meta.method_to_api_mapping[list_method])
+        shape = operation.output_shape.members[response_key].member
+        assert id_field in shape.members
+        _, describe_method, registered_param, _ = DESCRIBE_REGISTRY[(service, resource_type)]
+        assert registered_param == id_param
+        describe = model.operation_model(client.meta.method_to_api_mapping[describe_method])
+        assert id_param in describe.input_shape.members
+
+        # Include every member, even optional ones: sparse fixtures hide collisions.
+        # Unique field-name markers reveal which field wins; no AWS calls are made.
+        item = {field: f"value-of-{field}" for field in shape.members}
+        return service, resource_type, list_method, response_key, item, item[id_field]
+
+    def test_list_id_matches_describe_contract(self, resource_case):
+        service, resource_type, _, _, item, expected = resource_case
+        preferred = _PREFERRED_ID_FIELD.get((service, resource_type))
+        assert _extract_id(item, preferred) == expected
+        assert _summarize_item(item, preferred)["id"] == expected
+
+    @pytest.mark.parametrize("output", ["table", "csv"])
+    def test_cli_list_emits_describe_identifier(self, resource_case, output, monkeypatch):
+        service, resource_type, list_method, response_key, item, expected = resource_case
+        client = MagicMock()
+        # Other resource types listed by the same service are empty.
+        for _, _, method, key in SERVICE_REGISTRY[service]:
+            getattr(client, method).return_value = {key: []}
+        getattr(client, list_method).return_value = {response_key: [item]}
+        monkeypatch.setattr("backend.cli.get_client", lambda *args, **kwargs: client)
+
+        result = CliRunner().invoke(cli, ["list", service, "--output", output])
+        assert result.exit_code == 0, result.output
+        if output == "csv":
+            rows = list(csv.DictReader(io.StringIO(result.output)))
+            assert len(rows) == 1
+            assert rows[0]["resource_type"] == resource_type
+            assert rows[0]["resource_id"] == expected
+        else:
+            assert any(line.startswith(f"  {expected}") for line in result.output.splitlines())

stackport-0.4.3/tests/test_registries.py

@@ -1,85 +0,0 @@
-"""Validate SERVICE_REGISTRY, DESCRIBE_REGISTRY, and _METHOD_KWARGS consistency."""
-
-from backend.routes.resources import (
-    DESCRIBE_REGISTRY,
-    _ID_FIELDS,
-    _PREFERRED_ID_FIELD,
-    _extract_id,
-    _summarize_item,
-)
-from backend.routes.stats import SERVICE_REGISTRY, _METHOD_KWARGS
-
-
-class TestServiceRegistry:
-    def test_all_entries_are_4_tuples(self):
-        for service, entries in SERVICE_REGISTRY.items():
-            for entry in entries:
-                assert len(entry) == 4, f"{service}: entry {entry} is not a 4-tuple"
-                resource_type, boto3_service, method, response_key = entry
-                assert isinstance(resource_type, str) and resource_type
-                assert isinstance(boto3_service, str) and boto3_service
-                assert isinstance(method, str) and method
-                assert isinstance(response_key, str) and response_key
-
-    def test_no_duplicate_resource_types_per_service(self):
-        for service, entries in SERVICE_REGISTRY.items():
-            types = [e[0] for e in entries]
-            assert len(types) == len(set(types)), f"{service} has duplicate resource types"
-
-    def test_expected_services_present(self):
-        expected = {"s3", "sqs", "sns", "dynamodb", "lambda", "iam", "ec2", "logs"}
-        assert expected.issubset(SERVICE_REGISTRY.keys())
-
-
-class TestDescribeRegistry:
-    def test_all_entries_are_4_tuples(self):
-        for key, entry in DESCRIBE_REGISTRY.items():
-            assert len(entry) == 4, f"{key}: entry {entry} is not a 4-tuple"
-            boto3_service, method, id_param, response_key = entry
-            assert isinstance(boto3_service, str) and boto3_service
-            assert isinstance(method, str) and method
-            assert isinstance(id_param, str) and id_param
-            assert response_key is None or isinstance(response_key, str)
-
-    def test_keys_are_service_type_tuples(self):
-        for key in DESCRIBE_REGISTRY:
-            assert isinstance(key, tuple) and len(key) == 2
-            service, res_type = key
-            assert isinstance(service, str) and isinstance(res_type, str)
-
-
-class TestMethodKwargs:
-    def test_keys_reference_valid_methods(self):
-        """All _METHOD_KWARGS keys should reference methods that exist in SERVICE_REGISTRY."""
-        all_methods = set()
-        for entries in SERVICE_REGISTRY.values():
-            for _, boto3_service, method, _ in entries:
-                all_methods.add((boto3_service, method))
-
-        for key in _METHOD_KWARGS:
-            assert key in all_methods, (
-                f"_METHOD_KWARGS key {key} not found in SERVICE_REGISTRY methods"
-            )
-
-    def test_values_are_dicts(self):
-        for key, value in _METHOD_KWARGS.items():
-            assert isinstance(value, dict), f"{key}: value is not a dict"
-
-
-class TestIdFields:
-    def test_id_fields_are_strings(self):
-        for field in _ID_FIELDS:
-            assert isinstance(field, str) and field
-
-    def test_no_duplicates(self):
-        assert len(_ID_FIELDS) == len(set(_ID_FIELDS))
-
-
-class TestPreferredIdField:
-    def test_apigatewayv2_api_id_wins_over_name(self):
-        """get_api takes ApiId, but the list item also has Name, which ranks first
-        in _ID_FIELDS — without the override the detail lookup 404s."""
-        item = {"ApiId": "acf2a85b", "Name": "my-api", "ProtocolType": "HTTP"}
-        preferred = _PREFERRED_ID_FIELD.get(("apigateway", "apis"))
-        assert _extract_id(item, preferred) == "acf2a85b"
-        assert _summarize_item(item, preferred)["id"] == "acf2a85b"