Skip to content

Ministack: Free, open-source local AWS emulator - 60+ services, Terraform compatible, real databases. Free forever. MIT licensed.

release v1.3.24

Nahuel990438092fca9fe
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 91b5c8f9..40af56e6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,16 @@ Versioning follows [Semantic Versioning](https://semver.org/).
---
+## [1.3.24] — 2026-05-02
+
+### Fixed
+
+- **`x-amzn-errortype` header now emitted on every JSON-protocol error response.** Real AWS sends the error type in both the body (`__type`) and the `x-amzn-errortype` header. boto3 falls back to the body, but Java SDK v2, Go SDK v2, and Rust SDK prefer the header — without it they surface `SdkClientException: unknown error type` instead of the actual code. Applied centrally in `error_response_json` and inline in 12 services that build error bodies directly (apigateway v1/v2, opensearch, scheduler, eks, ses, backup, sqs, cloudwatch, dynamodb, tagging).
+- **AppConfig 404 bodies now include `__type`.** Was `{"Code": ..., "Message": ...}`; generic JSON error parsers that look for `__type` saw an unknown shape. Body now carries both styles.
+- **Three previously-stateless services expose a no-op `reset()`** (`account`, `waf-classic`, `resourcegroupstaggingapi`) so `/_ministack/reset` no longer logs a warning per call.
+
+---
+
## [1.3.23] — 2026-05-01
### Added
diff --git a/README.md b/README.md
index 68c513a2..fc68becc 100644
--- a/README.md
+++ b/README.md
@@ -28,7 +28,7 @@ LocalStack recently moved its core services behind a paid plan. If you relied on
- **40+ AWS services** emulated on a single port (4566)
- **Drop-in compatible** — works with `boto3`, AWS CLI, Terraform, CDK, Pulumi, any SDK
-- **Real infrastructure** — RDS spins up actual Postgres/MySQL containers, ElastiCache spins up real Redis, Athena runs real SQL via DuckDB, ECS runs real Docker containers
+- **Real infrastructure** — RDS spins up actual Postgres/MySQL containers, ElastiCache spins up real Redis, Athena runs real SQL via DuckDB (full image only), ECS runs real Docker containers
- **Tiny footprint** — ~270MB image, ~21MB RAM at idle vs LocalStack's ~1GB image and ~500MB RAM
- **Fast startup** — under 2 seconds, HTTP/2 (h2c) supported
- **MIT licensed** — use it, fork it, contribute to it
@@ -573,6 +573,8 @@ A Redis sidecar is also always available at `localhost:6379` when using Docker C
## Athena with Real SQL
+> **Requires the full image** (`ministackorg/ministack:full`). The default light image ships without DuckDB and returns mocked results — `SELECT 1+1` will return `1`, not `2`.
+
Athena queries run via DuckDB and can query files in your local S3 data directory:
```python
@@ -936,7 +938,7 @@ pip install boto3 pytest duckdb docker cbor2
# Start MiniStack
docker compose up -d
-# Run the full test suite (2,100+ tests across all services)
+# Run the full test suite (2,200+ tests across all services)
pytest tests/ -v
```
diff --git a/ministack/core/responses.py b/ministack/core/responses.py
index a1217af4..5aa0715a 100644
--- a/ministack/core/responses.py
+++ b/ministack/core/responses.py
@@ -223,12 +223,21 @@ def error_response_xml(code: str, message: str, status: int, namespace: str = "h
def error_response_json(code: str, message: str, status: int = 400) -> tuple:
- """AWS-style JSON error response."""
+ """AWS-style JSON error response.
+
+ Real AWS emits the error type in BOTH the body (`__type`) and the
+ `x-amzn-errortype` response header. Java/Go SDK v2 prefer the header;
+ boto3 reads the body. Send both.
+ """
data = {
"__type": code,
"message": message,
}
- return json_response(data, status)
+ body = json.dumps(data, ensure_ascii=False).encode("utf-8")
+ return status, {
+ "Content-Type": "application/x-amz-json-1.0",
+ "x-amzn-errortype": code,
+ }, body
def now_iso() -> str:
diff --git a/ministack/services/account.py b/ministack/services/account.py
index f33488c7..b7fd52f1 100644
--- a/ministack/services/account.py
+++ b/ministack/services/account.py
@@ -119,3 +119,7 @@ async def handle_request(method, path, headers, body, query_params):
except json.JSONDecodeError:
return error_response_json("SerializationException", "invalid JSON body", 400)
return fn(payload)
+
+
+def reset():
+ pass
diff --git a/ministack/services/apigateway.py b/ministack/services/apigateway.py
index acffa65c..e1d79139 100644
--- a/ministack/services/apigateway.py
+++ b/ministack/services/apigateway.py
@@ -159,7 +159,7 @@ def _apigw_response(data: dict, status: int = 200) -> tuple:
def _apigw_error(code: str, message: str, status: int) -> tuple:
- return status, {"Content-Type": "application/json"}, json.dumps({"message": message, "__type": code}, ensure_ascii=False).encode("utf-8")
+ return status, {"Content-Type": "application/json", "x-amzn-errortype": code}, json.dumps({"message": message, "__type": code}, ensure_ascii=False).encode("utf-8")
def _api_arn(api_id: str) -> str:
diff --git a/ministack/services/apigateway_v1.py b/ministack/services/apigateway_v1.py
index ce3d19bd..fda71344 100644
--- a/ministack/services/apigateway_v1.py
+++ b/ministack/services/apigateway_v1.py
@@ -160,7 +160,7 @@ def _v1_error(code, message, status):
# other JSON-protocol AWS service. boto3 reads this to populate
# ``ClientError.response["Error"]["Code"]``; with plain "type" it falls
# back to the numeric HTTP status as the code.
- return status, {"Content-Type": "application/json"}, json.dumps({"message": message, "__type": code}, ensure_ascii=False).encode("utf-8")
+ return status, {"Content-Type": "application/json", "x-amzn-errortype": code}, json.dumps({"message": message, "__type": code}, ensure_ascii=False).encode("utf-8")
def _qp(query_params, key, default=None):
diff --git a/ministack/services/appconfig.py b/ministack/services/appconfig.py
index fa0f6328..74f368bb 100644
--- a/ministack/services/appconfig.py
+++ b/ministack/services/appconfig.py
@@ -828,7 +828,7 @@ def _json(status, data):
def _error(status, code, message):
- body = json.dumps({"Message": message, "Code": code}).encode("utf-8")
+ body = json.dumps({"__type": code, "Message": message, "Code": code, "message": message}).encode("utf-8")
return status, {"Content-Type": "application/json", "x-amzn-errortype": code}, body
diff --git a/ministack/services/backup.py b/ministack/services/backup.py
index f42caa30..76a0d478 100644
--- a/ministack/services/backup.py
+++ b/ministack/services/backup.py
@@ -117,7 +117,7 @@ def _no_content():
def _err(code, msg, status=400):
return (
status,
- {"Content-Type": "application/json"},
+ {"Content-Type": "application/json", "x-amzn-errortype": code},
json.dumps({"__type": code, "Message": msg}).encode(),
)
diff --git a/ministack/services/cloudwatch.py b/ministack/services/cloudwatch.py
index 456dab6e..0704af60 100644
--- a/ministack/services/cloudwatch.py
+++ b/ministack/services/cloudwatch.py
@@ -1433,7 +1433,7 @@ def _error(code, message, status, use_json=False, use_cbor=False):
if use_json or use_cbor:
return (
status,
- {"Content-Type": "application/x-amz-json-1.0"},
+ {"Content-Type": "application/x-amz-json-1.0", "x-amzn-errortype": code},
json.dumps({"__type": code, "message": message}).encode(),
)
body = (
diff --git a/ministack/services/dynamodb.py b/ministack/services/dynamodb.py
index 990428c2..1f28d14f 100644
--- a/ministack/services/dynamodb.py
+++ b/ministack/services/dynamodb.py
@@ -1325,7 +1325,8 @@ def _transact_cancel_response(total, failed_idx, reason):
"message": f"Transaction cancelled, please refer cancellation reasons for specific reasons [{', '.join(r['Code'] for r in reasons)}]",
"CancellationReasons": reasons,
}
- return json_response(data, 400)
+ body = json.dumps(data, ensure_ascii=False).encode("utf-8")
+ return 400, {"Content-Type": "application/x-amz-json-1.0", "x-amzn-errortype": "TransactionCanceledException"}, body
# ---------------------------------------------------------------------------
diff --git a/ministack/services/eks.py b/ministack/services/eks.py
index edb81fb5..892ae4cf 100644
--- a/ministack/services/eks.py
+++ b/ministack/services/eks.py
@@ -134,7 +134,7 @@ def _json_resp(status, body):
def _error(status, code, message):
- return _json_resp(status, {"__type": code, "message": message})
+ return status, {"Content-Type": "application/json", "x-amzn-errortype": code}, json.dumps({"__type": code, "message": message}).encode()
def _get_docker():
diff --git a/ministack/services/opensearch.py b/ministack/services/opensearch.py
index b48b5bee..96647d66 100644
--- a/ministack/services/opensearch.py
+++ b/ministack/services/opensearch.py
@@ -129,12 +129,15 @@ def restore_state(data):
# Wire helpers
# ---------------------------------------------------------------------------
-def _json(status, body):
- return status, {"Content-Type": "application/json"}, json.dumps(body).encode()
+def _json(status, body, extra_headers=None):
+ headers = {"Content-Type": "application/json"}
+ if extra_headers:
+ headers.update(extra_headers)
+ return status, headers, json.dumps(body).encode()
def _error(status, code, message):
- return _json(status, {"__type": code, "Message": message})
+ return _json(status, {"__type": code, "Message": message}, {"x-amzn-errortype": code})
def _arn(name):
diff --git a/ministack/services/scheduler.py b/ministack/services/scheduler.py
index 4a4e13a2..dcccb371 100644
--- a/ministack/services/scheduler.py
+++ b/ministack/services/scheduler.py
@@ -86,7 +86,7 @@ def _json_resp(status, body):
def _error(status, code, message):
- return _json_resp(status, {"__type": code, "Message": message})
+ return status, {"Content-Type": "application/json", "x-amzn-errortype": code}, json.dumps({"__type": code, "Message": message}).encode()
def _ensure_default_group():
diff --git a/ministack/services/ses.py b/ministack/services/ses.py
index 3fa34e4e..e6a29d98 100644
--- a/ministack/services/ses.py
+++ b/ministack/services/ses.py
@@ -1148,7 +1148,7 @@ def _json_response(status, data):
def _json_error(code, message, status):
- return _json_response(status, {"__type": code, "message": message})
+ return status, {"Content-Type": "application/json", "x-amzn-errortype": code}, json.dumps({"__type": code, "message": message}).encode("utf-8")
def reset():
diff --git a/ministack/services/sqs.py b/ministack/services/sqs.py
index 8de889ec..683bd7b9 100644
--- a/ministack/services/sqs.py
+++ b/ministack/services/sqs.py
@@ -913,6 +913,7 @@ def _json_err_resp(code: str, msg: str, status: int = 400) -> tuple:
headers = {
"Content-Type": "application/x-amz-json-1.0",
"x-amzn-query-error": f"{legacy};{fault}",
+ "x-amzn-errortype": code,
}
return (status, headers, json.dumps({"__type": code, "message": msg}).encode("utf-8"))
diff --git a/ministack/services/tagging.py b/ministack/services/tagging.py
index b9514336..3246f928 100644
--- a/ministack/services/tagging.py
+++ b/ministack/services/tagging.py
@@ -731,16 +731,20 @@ async def handle_request(method, path, headers, body, query_params):
try:
data = json.loads(body) if body else {}
except json.JSONDecodeError:
- return 400, {"Content-Type": "application/x-amz-json-1.1"}, json.dumps({
+ return 400, {"Content-Type": "application/x-amz-json-1.1", "x-amzn-errortype": "SerializationException"}, json.dumps({
"__type": "SerializationException",
"message": "Invalid JSON",
}).encode()
handler = _HANDLERS.get(action)
if not handler:
- return 400, {"Content-Type": "application/x-amz-json-1.1"}, json.dumps({
+ return 400, {"Content-Type": "application/x-amz-json-1.1", "x-amzn-errortype": "InvalidRequestException"}, json.dumps({
"__type": "InvalidRequestException",
"message": f"Unknown action: {action}",
}).encode()
return handler(data)
+
+
+def reset():
+ pass
diff --git a/ministack/services/waf_v1.py b/ministack/services/waf_v1.py
index a49d2314..f0683324 100644
--- a/ministack/services/waf_v1.py
+++ b/ministack/services/waf_v1.py
@@ -108,3 +108,7 @@ async def handle_request(method, path, headers, body, query_params):
return error_response_json("WAFInvalidOperationException",
f"Operation '{op}' is not implemented in this stub.",
400)
+
+
+def reset():
+ pass
diff --git a/pyproject.toml b/pyproject.toml
index 364c21cb..238959e0 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
[project]
name = "ministack"
-version = "1.3.23"
+version = "1.3.24"
description = "Free, open-source local AWS emulator — drop-in LocalStack replacement"
readme = "README.md"
license = { file = "LICENSE" }
diff --git a/tests/test_account.py b/tests/test_account.py
index b49f2713..e9f757e8 100644
--- a/tests/test_account.py
+++ b/tests/test_account.py
@@ -63,3 +63,12 @@ def test_account_get_contact_information(acct):
info = acct.get_contact_information()["ContactInformation"]
assert info["FullName"]
assert info["CountryCode"] == "US"
+
+
+def test_account_module_exposes_no_op_reset():
+ """`/_ministack/reset` iterates every service module's `reset()`. Account
+ is stateless, so this is a no-op stub — but it must exist or the central
+ reset logs a warning per call."""
+ from ministack.services import account
+ assert callable(getattr(account, "reset", None))
+ account.reset()
diff --git a/tests/test_apigatewayv2.py b/tests/test_apigatewayv2.py
index cc79199f..c5ebca7b 100644
--- a/tests/test_apigatewayv2.py
+++ b/tests/test_apigatewayv2.py
@@ -277,6 +277,8 @@ def test_apigw_api_not_found(apigw):
with pytest.raises(ClientError) as exc:
apigw.get_api(ApiId="00000000")
assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 404
+ # Real AWS sends `x-amzn-errortype` on REST-JSON errors; Java/Go SDK v2 read it.
+ assert exc.value.response["ResponseMetadata"]["HTTPHeaders"].get("x-amzn-errortype")
def test_apigw_route_on_deleted_api(apigw):
from botocore.exceptions import ClientError
diff --git a/tests/test_appconfig.py b/tests/test_appconfig.py
index 7fc7ffce..745381c5 100644
--- a/tests/test_appconfig.py
+++ b/tests/test_appconfig.py
@@ -537,6 +537,22 @@ def test_appconfig_get_nonexistent_application(appconfig_client):
with pytest.raises(ClientError) as exc:
appconfig_client.get_application(ApplicationId="nonexistent")
assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"
+ # Real AWS sends `x-amzn-errortype` on REST-JSON errors; Java/Go SDK v2 read it.
+ assert exc.value.response["ResponseMetadata"]["HTTPHeaders"].get("x-amzn-errortype") == "ResourceNotFoundException"
+ # Body must also include `__type` (was previously only `Code`/`Message`,
+ # which generic JSON-error parsers miss). Verify via raw HTTP since boto3
+ # surfaces only Error.Code/Message.
+ import json, urllib.request, urllib.error
+ req = urllib.request.Request(
+ "http://localhost:4566/applications/nonexistent",
+ headers={"Authorization": "AWS4-HMAC-SHA256 Credential=test/20260501/us-east-1/appconfig/aws4_request"},
+ )
+ try:
+ urllib.request.urlopen(req, timeout=5)
+ assert False, "expected 404"
+ except urllib.error.HTTPError as e:
+ body = json.loads(e.read())
+ assert body.get("__type") == "ResourceNotFoundException"
def test_appconfig_get_nonexistent_environment(appconfig_client):
diff --git a/tests/test_cloudwatch_logs.py b/tests/test_cloudwatch_logs.py
index 5b2394df..50814fe3 100644
--- a/tests/test_cloudwatch_logs.py
+++ b/tests/test_cloudwatch_logs.py
@@ -853,3 +853,12 @@ def test_subscription_filter_destination_resolvable_after_warm_boot():
"state. _destinations must be persisted alongside _log_groups."
)
mod.reset()
+
+
+def test_logs_describe_streams_on_nonexistent_group_carries_errortype(logs):
+ """Real AWS sends `x-amzn-errortype` on JSON-protocol errors. Java/Go SDK
+ v2 read it; without it they raise SdkClientException(unknown error type)."""
+ with pytest.raises(ClientError) as exc:
+ logs.describe_log_streams(logGroupName="missing-lg")
+ assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"
+ assert exc.value.response["ResponseMetadata"]["HTTPHeaders"].get("x-amzn-errortype") == "ResourceNotFoundException"
diff --git a/tests/test_dynamodb.py b/tests/test_dynamodb.py
index 7b479ac0..ac73ddfa 100644
--- a/tests/test_dynamodb.py
+++ b/tests/test_dynamodb.py
@@ -356,6 +356,9 @@ def test_dynamodb_delete_table_not_found(ddb):
with pytest.raises(ClientError) as exc:
ddb.delete_table(TableName="t_nonexistent_xyz")
assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"
+ # Real AWS sends `x-amzn-errortype` on JSON-protocol errors. Java/Go SDK v2
+ # read it; without it they raise SdkClientException(unknown error type).
+ assert exc.value.response["ResponseMetadata"]["HTTPHeaders"].get("x-amzn-errortype") == "ResourceNotFoundException"
def test_dynamodb_deletion_protection(ddb):
diff --git a/tests/test_eventbridge.py b/tests/test_eventbridge.py
index 5d4e104b..02031030 100644
--- a/tests/test_eventbridge.py
+++ b/tests/test_eventbridge.py
@@ -338,6 +338,8 @@ def test_eventbridge_delete_rule_v2(eb):
with pytest.raises(ClientError) as exc:
eb.describe_rule(Name="eb-del-v2")
assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"
+ # Real AWS sends `x-amzn-errortype` on JSON-protocol errors; Java/Go SDK v2 read it.
+ assert exc.value.response["ResponseMetadata"]["HTTPHeaders"].get("x-amzn-errortype") == "ResourceNotFoundException"
def test_eventbridge_tags_v2(eb):
resp = eb.put_rule(Name="eb-tag-v2", ScheduleExpression="rate(1 hour)", State="ENABLED")
diff --git a/tests/test_firehose.py b/tests/test_firehose.py
index 6add8811..640774f7 100644
--- a/tests/test_firehose.py
+++ b/tests/test_firehose.py
@@ -323,3 +323,12 @@ def test_firehose_s3_destination_writes(s3, fh):
obj = s3.get_object(Bucket=bucket, Key=key)
body = obj["Body"].read()
assert b"hello from firehose" in body
+
+
+def test_firehose_describe_nonexistent_carries_errortype(fh):
+ """Real AWS sends `x-amzn-errortype` on JSON-protocol errors. Java/Go SDK
+ v2 read it; without it they raise SdkClientException(unknown error type)."""
+ with pytest.raises(ClientError) as exc:
+ fh.describe_delivery_stream(DeliveryStreamName="missing-fh")
+ assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"
+ assert exc.value.response["ResponseMetadata"]["HTTPHeaders"].get("x-amzn-errortype") == "ResourceNotFoundException"
diff --git a/tests/test_kinesis.py b/tests/test_kinesis.py
index ee63c3ce..4a93ae6a 100644
--- a/tests/test_kinesis.py
+++ b/tests/test_kinesis.py
@@ -118,6 +118,8 @@ def test_kinesis_delete_stream_v2(kin):
with pytest.raises(ClientError) as exc:
kin.describe_stream(StreamName="kin-del-v2")
assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"
+ # Real AWS sends `x-amzn-errortype` on JSON-protocol errors; Java/Go SDK v2 read it.
+ assert exc.value.response["ResponseMetadata"]["HTTPHeaders"].get("x-amzn-errortype") == "ResourceNotFoundException"
def test_kinesis_stream_encryption(kin):
import uuid as _uuid
diff --git a/tests/test_kms.py b/tests/test_kms.py
index 9148c9b1..f8403c9a 100644
--- a/tests/test_kms.py
+++ b/tests/test_kms.py
@@ -79,6 +79,9 @@ def test_kms_describe_nonexistent_key(kms_client):
with pytest.raises(ClientError) as exc_info:
kms_client.describe_key(KeyId="nonexistent-key-id")
assert "NotFoundException" in str(exc_info.value)
+ # Real AWS sends `x-amzn-errortype` on JSON-protocol errors. Java/Go SDK v2
+ # read it; without it they raise SdkClientException(unknown error type).
+ assert exc_info.value.response["ResponseMetadata"]["HTTPHeaders"].get("x-amzn-errortype") == "NotFoundException"
def test_kms_sign_and_verify_pkcs1(kms_client):
key = kms_client.create_key(KeySpec="RSA_2048", KeyUsage="SIGN_VERIFY")
diff --git a/tests/test_lambda.py b/tests/test_lambda.py
index 60b1ad3d..699db395 100644
--- a/tests/test_lambda.py
+++ b/tests/test_lambda.py
@@ -204,6 +204,8 @@ def test_lambda_get_function_not_found(lam):
with pytest.raises(ClientError) as exc:
lam.get_function(FunctionName="nonexistent-func-xyz")
assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"
+ # Real AWS sends `x-amzn-errortype` on REST-JSON errors; Java/Go SDK v2 read it.
+ assert exc.value.response["ResponseMetadata"]["HTTPHeaders"].get("x-amzn-errortype") == "ResourceNotFoundException"
def test_lambda_list_functions(lam):
resp = lam.list_functions()
diff --git a/tests/test_secretsmanager.py b/tests/test_secretsmanager.py
index b70f3119..fbb18e96 100644
--- a/tests/test_secretsmanager.py
+++ b/tests/test_secretsmanager.py
@@ -101,6 +101,8 @@ def test_secretsmanager_delete_v2(sm):
with pytest.raises(ClientError) as exc:
sm.get_secret_value(SecretId="sm-del-v2")
assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"
+ # Real AWS sends `x-amzn-errortype` on JSON-protocol errors; Java/Go SDK v2 read it.
+ assert exc.value.response["ResponseMetadata"]["HTTPHeaders"].get("x-amzn-errortype") == "ResourceNotFoundException"
def test_secretsmanager_delete_with_recovery(sm):
sm.create_secret(Name="sm-del-rec", SecretString="recoverable")
diff --git a/tests/test_ssm.py b/tests/test_ssm.py
index 6f4e6727..63579a5b 100644
--- a/tests/test_ssm.py
+++ b/tests/test_ssm.py
@@ -83,6 +83,8 @@ def test_ssm_delete_v2(ssm):
with pytest.raises(ClientError) as exc:
ssm.get_parameter(Name="/ssm2/del/tmp")
assert exc.value.response["Error"]["Code"] == "ParameterNotFound"
+ # Real AWS sends `x-amzn-errortype` on JSON-protocol errors; Java/Go SDK v2 read it.
+ assert exc.value.response["ResponseMetadata"]["HTTPHeaders"].get("x-amzn-errortype") == "ParameterNotFound"
ssm.put_parameter(Name="/ssm2/del/b1", Value="v1", Type="String")
ssm.put_parameter(Name="/ssm2/del/b2", Value="v2", Type="String")
diff --git a/tests/test_stepfunctions.py b/tests/test_stepfunctions.py
index bb19bbbb..222e2483 100644
--- a/tests/test_stepfunctions.py
+++ b/tests/test_stepfunctions.py
@@ -2207,6 +2207,8 @@ def test_sfn_describe_not_found(sfn):
sfn.describe_state_machine(stateMachineArn="arn:aws:states:us-east-1:000000000000:stateMachine:nonexistent-99")
err = exc.value.response["Error"]["Code"]
assert "StateMachineDoesNotExist" in err or "NotFound" in err or "ResourceNotFound" in err
+ # Real AWS sends `x-amzn-errortype` on JSON-protocol errors; Java/Go SDK v2 read it.
+ assert exc.value.response["ResponseMetadata"]["HTTPHeaders"].get("x-amzn-errortype") == "StateMachineDoesNotExist"
def test_sfn_start_execution_not_found(sfn):
"""StartExecution on non-existent SM should fail."""
diff --git a/tests/test_tagging.py b/tests/test_tagging.py
index 712ec68b..eab338f6 100644
--- a/tests/test_tagging.py
+++ b/tests/test_tagging.py
@@ -699,3 +699,12 @@ def test_tagging_tag_resources_cross_account_isolation(s3):
resp_a = tag_a.get_resources(TagFilters=[{"Key": "tenant", "Values": ["A"]}])
arns_a = [r["ResourceARN"] for r in resp_a["ResourceTagMappingList"]]
assert arn_a in arns_a
+
+
+def test_tagging_module_exposes_no_op_reset():
+ """Tag dispatcher is stateless (delegates to per-service tag stores), but
+ must expose `reset()` so the central `/_ministack/reset` doesn't log a
+ warning."""
+ from ministack.services import tagging
+ assert callable(getattr(tagging, "reset", None))
+ tagging.reset()
diff --git a/tests/test_waf_v1.py b/tests/test_waf_v1.py
index a43458fe..0586f26f 100644
--- a/tests/test_waf_v1.py
+++ b/tests/test_waf_v1.py
@@ -79,3 +79,9 @@ def test_waf_v1_does_not_collide_with_wafv2():
# An empty wafv2 list still works alongside the v1 stub
assert isinstance(v1.list_web_acls(Limit=5)["WebACLs"], list)
assert isinstance(v2.list_web_acls(Scope="REGIONAL", Limit=5)["WebACLs"], list)
+
+
+def test_waf_v1_module_exposes_no_op_reset():
+ from ministack.services import waf_v1
+ assert callable(getattr(waf_v1, "reset", None))
+ waf_v1.reset()