Ministack: Free, open-source local AWS emulator - 60+ services, Terraform compatible, real databases. Free forever. MIT licensed.
Python awsaws-emulatoraws-localaws-sdkdevtoolsdockerdynamodbec2emulatorlambdalocalstacklocalstack-alternativeministackmock-awsopen-sourcepythons3sqsterraform
feat(ssm): service settings (GetServiceSetting, UpdateServiceSetting, ResetServiceSetting) (#2132)
Jeff Heller7ae995b7d72c
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex eab7fe20..ce9fdcb6 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -8,6 +8,8 @@ Versioning follows [Semantic Versioning](https://semver.org/).## [Unreleased]### Added++- **SSM — service settings** — `GetServiceSetting`, `UpdateServiceSetting` and `ResetServiceSetting`, per account and region, persisted. `SettingValue` is validated for the ids whose accepted values AWS documents, and `/ssm/parameter-store/default-parameter-tier` sets the `Tier` of a `PutParameter` that names none. Unblocks Terraform's `aws_ssm_service_setting`.- **Auth — SigV4a signatures are verified under `AUTH=true`** — requests signed with `AWS4-ECDSA-P256-SHA256`, which SDKs use for Multi-Region Access Points, were refused for every IAM user. Header and presigned S3 signatures are now checked with the P-256 key SigV4a derives from the secret, with their date or expiry, and an `X-Amz-Region-Set` that leaves out the serving region is refused (`RegionSetMismatch` on S3, the unknown-key error elsewhere). Contributed by @iot-rocket.### Fixeddiff --git a/README.md b/README.mdindex 87ff074f..131f065b 100644--- a/README.md+++ b/README.md@@ -420,7 +420,7 @@ subnet = ec2.create_subnet(| Service | Operations | Notes ||---------|-----------|-------|-| **SSM Parameter Store** | PutParameter, GetParameter, GetParameters, GetParametersByPath, DeleteParameter, DeleteParameters, DescribeParameters, GetParameterHistory, LabelParameterVersion, AddTagsToResource, RemoveTagsFromResource, ListTagsForResource | Supports String, SecureString, StringList; `name:version` and `name:label` selectors on `GetParameter` / `GetParameters` |+| **SSM Parameter Store** | PutParameter, GetParameter, GetParameters, GetParametersByPath, DeleteParameter, DeleteParameters, DescribeParameters, GetParameterHistory, LabelParameterVersion, AddTagsToResource, RemoveTagsFromResource, ListTagsForResource, GetServiceSetting, UpdateServiceSetting, ResetServiceSetting | Supports String, SecureString, StringList; `name:version` and `name:label` selectors on `GetParameter` / `GetParameters` || **EventBridge** | CreateEventBus, UpdateEventBus, DeleteEventBus, ListEventBuses, DescribeEventBus, PutRule, DeleteRule, ListRules, DescribeRule, EnableRule, DisableRule, PutTargets, RemoveTargets, ListTargetsByRule, ListRuleNamesByTarget, PutEvents, TestEventPattern, TagResource, UntagResource, ListTagsForResource, CreateArchive, DeleteArchive, DescribeArchive, UpdateArchive, ListArchives, PutPermission, RemovePermission, CreateConnection, DescribeConnection, DeleteConnection, UpdateConnection, DeauthorizeConnection, ListConnections, CreateApiDestination, DescribeApiDestination, DeleteApiDestination, UpdateApiDestination, ListApiDestinations, StartReplay, DescribeReplay, ListReplays, CancelReplay, CreateEndpoint, DeleteEndpoint, DescribeEndpoint, ListEndpoints, UpdateEndpoint, ActivateEventSource, DeactivateEventSource, DescribeEventSource, CreatePartnerEventSource, DeletePartnerEventSource, DescribePartnerEventSource, ListPartnerEventSources, ListPartnerEventSourceAccounts, ListEventSources, PutPartnerEvents | Lambda target dispatch on PutEvents; S3 EventBridge notifications; archives capture matching events and `StartReplay` re-dispatches them to the destination bus in a background thread; API destination targets are **invoked over HTTP** on PutEvents — connection auth (Basic, API Key, OAuth client-credentials with token caching and 401/407 refresh), connection/target header/query/body parameter merging with connection precedence, `*` path parameters, dynamic JSON-path parameter values resolved from the untransformed event, and the AWS default headers (`User-Agent: Amazon/EventBridge/ApiDestinations`, default `Content-Type: application/json; charset=utf-8`), which connection and target parameters cannot override; redirects are not followed (a `3xx` is a non-retryable delivery failure), only `http(s)` invocation and OAuth authorization endpoints are accepted, `HttpMethod` and `AuthorizationType` are validated against their enums, and a connection that is not `AUTHORIZED` is not invoked (`DeauthorizeConnection` clears its stored credentials) — the 24h retry pipeline, rate limiting, and DLQs are not modeled; SaaS/partner APIs are otherwise control-plane stubs. Event patterns are **validated** — `PutRule`, `TestEventPattern`, `CreateArchive` and `UpdateArchive` reject a malformed pattern with `InvalidEventPatternException` carrying AWS's own reason text — and evaluate `prefix`/`suffix` (plain or case-insensitive via a nested `equals-ignore-case`), `wildcard` (AWS semantics — only `*` is special, `\` escapes — with catastrophic backtracking ruled out), `equals-ignore-case` (AWS's per-character case alternation), `exactly`, `cidr` (IPv4/IPv6, host bits floored, `/32` and `/128` refused as AWS refuses them), `numeric` (as the grammar it is: one comparison or a lower-then-upper bound), `exists` (leaf nodes only, so an object or an empty array does not exist), `anything-but` (a literal, a list, or a nested `prefix`/`suffix`/`wildcard`/`equals-ignore-case`, singly or as a list), and `$or` at any field position — expanded into flat alternatives at rule creation, so AWS's per-leaf last-write-wins collision rule and its 1000-combination cap both hold. All ten envelope fields are filterable, an unmodelled key is a path the event lacks rather than an error, `resources` is an intersection, array values are matched per element (with AWS's array-consistency rule), and values compare as JSON so a string never equals a number. An operand or key the matcher cannot evaluate never matches, rather than raising or matching everything. Not modeled: the 4096-character pattern limit, the wildcard-complexity refusal, and the 256-leaf rule-size cap || **Kinesis** | CreateStream, DeleteStream, DescribeStream, DescribeStreamSummary, ListStreams, ListShards, PutRecord, PutRecords, GetShardIterator, GetRecords, IncreaseStreamRetentionPeriod, DecreaseStreamRetentionPeriod, MergeShards, SplitShard, UpdateShardCount, StartStreamEncryption, StopStreamEncryption, EnableEnhancedMonitoring, DisableEnhancedMonitoring, RegisterStreamConsumer, DeregisterStreamConsumer, ListStreamConsumers, DescribeStreamConsumer, SubscribeToShard, AddTagsToStream, RemoveTagsFromStream, ListTagsForStream | Partition key → shard routing; AWS limits enforced (1 MB/record, 500 records/batch, 5 MB payload, 256-char partition key); SubscribeToShard pushes `SubscribeToShardEvent`s over HTTP/1.1 or HTTP/2 (h2c) for up to 5 minutes, JSON or CBOR || **CloudWatch Metrics** | PutMetricData, GetMetricStatistics, GetMetricData, ListMetrics, PutMetricAlarm, PutCompositeAlarm, DescribeAlarms, DescribeAlarmsForMetric, DescribeAlarmHistory, DeleteAlarms, SetAlarmState, EnableAlarmActions, DisableAlarmActions, TagResource, UntagResource, ListTagsForResource, PutDashboard, GetDashboard, DeleteDashboards, ListDashboards | CBOR and JSON protocol |diff --git a/ministack/services/ssm.py b/ministack/services/ssm.pyindex cfb58826..6df29fef 100644--- a/ministack/services/ssm.py+++ b/ministack/services/ssm.py@@ -20,6 +20,7 @@ from datetime import datetime, timezonefrom ministack.core.arn import ArnParseError, parse_arnfrom ministack.core.concurrency import spawn_background+from ministack.core.iam_evaluator import request_caller_arnfrom ministack.core.responses import (AccountRegionScopedDict,AccountScopedDict,@@ -40,6 +41,33 @@ _parameters = AccountRegionScopedDict()_parameter_history = AccountRegionScopedDict()_tags = AccountRegionScopedDict()_commands = AccountRegionScopedDict()+_service_settings = AccountRegionScopedDict()++# SettingIds are the botocore ssm model's list; (default value, default LastModifiedDate) observed on AWS+# (GetServiceSetting, us-east-1, 2026-10-10), except high-throughput-enabled (ResetServiceSetting API reference example).+_SERVICE_SETTING_DEFAULTS = {+ "/ssm/parameter-store/high-throughput-enabled": ("false", 1555532571.138),+ "/ssm/parameter-store/default-parameter-tier": ("Standard", 1565131339.38),+ "/ssm/documents/console/public-sharing-permission": ("Enable", 1612382724.747),+ "/ssm/managed-instance/activation-tier": ("standard", 1579134984.656),+ "/ssm/managed-instance/default-ec2-instance-management-role": ("$None", 1636561263.576),+ "/ssm/automation/customer-script-log-destination": ("None", 1572919724.731),+ "/ssm/automation/customer-script-log-group-name": ("/aws/ssm/automation/executeScript", 1572898415.256),+ "/ssm/automation/enable-adaptive-concurrency": ("False", 1632330231.776),+ "/ssm/appmanager/appmanager-enabled": ("False", 1604983265.572),+ "/ssm/opsinsights/opscenter": ("Disabled", 1622077352.094),+}+# Accepted SettingValues per the UpdateServiceSetting API reference; an id missing here takes any string.+# The error message is observed for default-parameter-tier; its format for the other ids is inferred.+_SERVICE_SETTING_VALUES = {+ "/ssm/parameter-store/high-throughput-enabled": ("true", "false"),+ "/ssm/parameter-store/default-parameter-tier": ("Standard", "Advanced", "Intelligent-Tiering"),+ "/ssm/documents/console/public-sharing-permission": ("Enable", "Disable"),+ "/ssm/managed-instance/activation-tier": ("standard", "advanced"),+ "/ssm/appmanager/appmanager-enabled": ("True", "False"),+ "/ssm/opsinsights/opscenter": ("Enabled", "Disabled"),+}+_DEFAULT_TIER_SETTING = "/ssm/parameter-store/default-parameter-tier"# ── Persistence ────────────────────────────────────────────@@ -50,6 +78,7 @@ def get_state():"parameter_history": copy.deepcopy(_parameter_history),"tags": copy.deepcopy(_tags),"commands": copy.deepcopy(_commands),+ "service_settings": copy.deepcopy(_service_settings),}@@ -106,6 +135,7 @@ def _restore_state(data):_restore_parameter_history(data.get("parameter_history", {}))_tags.update(data.get("tags", {}))_commands.update(data.get("commands", {}))+ _service_settings.update(data.get("service_settings", {}))def _now_iso() -> str:@@ -248,6 +278,9 @@ async def handle_request(method, path, headers, body, query_params):"GetCommandInvocation": _get_command_invocation,"ListCommands": _list_commands,"DescribeInstanceInformation": _describe_instance_information,+ "GetServiceSetting": _get_service_setting,+ "UpdateServiceSetting": lambda d: _update_service_setting(d, request_caller_arn(headers, query_params)),+ "ResetServiceSetting": _reset_service_setting,}handler = handlers.get(action)@@ -351,7 +384,7 @@ def _put_parameter(data):"LastModifiedDate": now,"DataType": data.get("DataType", "text"),"Description": data.get("Description", existing.get("Description", "") if existing else ""),- "Tier": data.get("Tier", "Standard"),+ "Tier": data.get("Tier") or _default_tier(data, value),"AllowedPattern": data.get("AllowedPattern", ""),"Policies": data.get("Policies", []),"Labels": [],@@ -1082,7 +1115,73 @@ def _describe_instance_information(data):return json_response(out)+def _service_setting_id(data):+ value = data.get("SettingId") or ""+ if value.startswith("arn:"):+ resource = value.split(":", 5)[-1]+ value = resource[len("servicesetting"):] if resource.startswith("servicesetting/") else ""+ return value if value in _SERVICE_SETTING_DEFAULTS else None+++def _service_setting_out(setting_id):+ default_value, default_date = _SERVICE_SETTING_DEFAULTS[setting_id]+ stored = _service_settings.get(setting_id)+ return {+ "SettingId": setting_id,+ "SettingValue": stored["value"] if stored else default_value,+ "LastModifiedDate": stored["modified"] if stored else default_date,+ "LastModifiedUser": stored["user"] if stored else "System",+ "ARN": f"arn:aws:ssm:{get_region()}:{get_account_id()}:servicesetting{setting_id}",+ "Status": "Customized" if stored else "Default",+ }+++def _default_tier(data, value):+ """Tier of a parameter put without one: the account and region's default-parameter-tier setting."""+ setting = _service_settings.get(_DEFAULT_TIER_SETTING)+ tier = setting["value"] if setting else "Standard"+ if tier == "Intelligent-Tiering":+ return "Advanced" if len(value.encode()) > 4096 or data.get("Policies") else "Standard"+ return tier+++def _service_setting_not_found(data):+ return error_response_json(+ "ServiceSettingNotFound", f"ServiceSetting {data.get('SettingId')} does not exist.", 400+ )+++def _get_service_setting(data):+ setting_id = _service_setting_id(data)+ if setting_id is None:+ return _service_setting_not_found(data)+ return json_response({"ServiceSetting": _service_setting_out(setting_id)})+++def _update_service_setting(data, caller):+ setting_id = _service_setting_id(data)+ if setting_id is None:+ return _service_setting_not_found(data)+ value = data.get("SettingValue")+ accepted = _SERVICE_SETTING_VALUES.get(setting_id)+ if accepted and value not in accepted:+ return error_response_json(+ "ValidationException", f"Invalid setting value, allowed value pattern: {'|'.join(accepted)}", 400+ )+ _service_settings[setting_id] = {"value": value, "modified": _now_epoch(), "user": caller}+ return json_response({})+++def _reset_service_setting(data):+ setting_id = _service_setting_id(data)+ if setting_id is None:+ return _service_setting_not_found(data)+ _service_settings.pop(setting_id, None)+ return json_response({"ServiceSetting": _service_setting_out(setting_id)})++def reset():+ _service_settings.clear()_parameters.clear()_parameter_history.clear()_tags.clear()diff --git a/tests/test_ssm.py b/tests/test_ssm.pyindex c87ff028..40c6ecd3 100644--- a/tests/test_ssm.py+++ b/tests/test_ssm.py@@ -1122,3 +1122,193 @@ def test_unicode_ssm_parameter(ssm):ssm.put_parameter(Name="/unicode/param", Value="값: τιμή", Type="String")resp = ssm.get_parameter(Name="/unicode/param")assert resp["Parameter"]["Value"] == "값: τιμή"+++_HT = "/ssm/parameter-store/high-throughput-enabled"+_HT_ARN = "arn:aws:ssm:us-east-1:000000000000:servicesetting" + _HT+_TIER = "/ssm/parameter-store/default-parameter-tier"+# Independent of the implementation. Observed on AWS (GetServiceSetting, us-east-1, 2026-10-10): value and default+# LastModifiedDate; high-throughput-enabled is the ResetServiceSetting API reference example.+_OBSERVED_DEFAULTS = {+ _HT: ("false", 1555532571.138),+ _TIER: ("Standard", 1565131339.38),+ "/ssm/documents/console/public-sharing-permission": ("Enable", 1612382724.747),+ "/ssm/managed-instance/activation-tier": ("standard", 1579134984.656),+ "/ssm/managed-instance/default-ec2-instance-management-role": ("$None", 1636561263.576),+ "/ssm/automation/customer-script-log-destination": ("None", 1572919724.731),+ "/ssm/automation/customer-script-log-group-name": ("/aws/ssm/automation/executeScript", 1572898415.256),+ "/ssm/automation/enable-adaptive-concurrency": ("False", 1632330231.776),+ "/ssm/appmanager/appmanager-enabled": ("False", 1604983265.572),+ "/ssm/opsinsights/opscenter": ("Disabled", 1622077352.094),+}+# Accepted values per UpdateServiceSetting's API reference; the other ids accept any string.+_ACCEPTED = {+ _HT: ("true", "false"),+ _TIER: ("Standard", "Advanced", "Intelligent-Tiering"),+ "/ssm/documents/console/public-sharing-permission": ("Enable", "Disable"),+ "/ssm/managed-instance/activation-tier": ("standard", "advanced"),+ "/ssm/appmanager/appmanager-enabled": ("True", "False"),+ "/ssm/opsinsights/opscenter": ("Enabled", "Disabled"),+}+++def service_settings(ssm):+ yield ssm+ for setting_id in _OBSERVED_DEFAULTS:+ ssm.reset_service_setting(SettingId=setting_id)+++def _ssm_model():+ from botocore.loaders import Loader+ from botocore.model import ServiceModel++ return ServiceModel(Loader().load_service_model("ssm", "service-2"))+++def _error_code(call, **kwargs):+ with pytest.raises(ClientError) as exc:+ call(**kwargs)+ return exc.value.response["Error"]+++def test_ssm_service_setting_defaults(service_settings):+ import re++ # The model lists the SettingIds only in the documentation prose of the request shape.+ model_ids = set(re.findall(r"/ssm/[a-z0-9/-]+", _ssm_model().shape_for("GetServiceSettingRequest").members["SettingId"].documentation))+ assert set(_OBSERVED_DEFAULTS) == model_ids+ for setting_id, (default, modified) in _OBSERVED_DEFAULTS.items():+ setting = service_settings.get_service_setting(SettingId=setting_id)["ServiceSetting"]+ assert (setting["SettingValue"], setting["Status"], setting["LastModifiedUser"]) == (default, "Default", "System")+ assert setting["LastModifiedDate"].timestamp() == pytest.approx(modified), setting_id+ assert service_settings.get_service_setting(SettingId=_HT)["ServiceSetting"]["ARN"] == _HT_ARN+++def test_ssm_service_setting_update_and_reset(service_settings):+ ssm = service_settings+ assert ssm.update_service_setting(SettingId=_HT_ARN, SettingValue="true")["ResponseMetadata"]["HTTPStatusCode"] == 200+ setting = ssm.get_service_setting(SettingId=_HT)["ServiceSetting"]+ assert (setting["SettingValue"], setting["Status"]) == ("true", "Customized")+ assert "LastModifiedDate" in setting and setting["LastModifiedUser"]+ reset = ssm.reset_service_setting(SettingId=_HT_ARN)["ServiceSetting"]+ assert (reset["SettingValue"], reset["Status"], reset["LastModifiedUser"]) == ("false", "Default", "System")+ for call, extra in ((ssm.get_service_setting, {}), (ssm.reset_service_setting, {}),+ (ssm.update_service_setting, {"SettingValue": "x"})):+ assert _error_code(call, SettingId="/ssm/nope", **extra)["Code"] == "ServiceSettingNotFound"+++def test_ssm_service_setting_value_validation(service_settings):+ ssm = service_settings+ for setting_id, accepted in _ACCEPTED.items():+ error = _error_code(ssm.update_service_setting, SettingId=setting_id, SettingValue="NotAValue")+ assert error["Code"] == "ValidationException"+ assert error["Message"] == f"Invalid setting value, allowed value pattern: {'|'.join(accepted)}"+ assert ssm.get_service_setting(SettingId=setting_id)["ServiceSetting"]["Status"] == "Default"+ for value in accepted:+ ssm.update_service_setting(SettingId=setting_id, SettingValue=value)+ for setting_id in set(_OBSERVED_DEFAULTS) - set(_ACCEPTED):+ ssm.update_service_setting(SettingId=setting_id, SettingValue="any")+++def test_ssm_service_setting_last_modified_user_is_caller(service_settings, iam):+ username = f"ssm-setting-{_uuid_mod.uuid4().hex[:8]}"+ arn = iam.create_user(UserName=username)["User"]["Arn"]+ key = iam.create_access_key(UserName=username)["AccessKey"]+ try:+ caller = boto3.client(+ "ssm",+ endpoint_url=os.environ.get("MINISTACK_ENDPOINT", "http://localhost:4566"),+ aws_access_key_id=key["AccessKeyId"],+ aws_secret_access_key=key["SecretAccessKey"],+ region_name="us-east-1",+ )+ caller.update_service_setting(SettingId=_HT, SettingValue="true")+ assert service_settings.get_service_setting(SettingId=_HT)["ServiceSetting"]["LastModifiedUser"] == arn+ finally:+ iam.delete_access_key(UserName=username, AccessKeyId=key["AccessKeyId"])+ iam.delete_user(UserName=username)+++def test_ssm_service_setting_per_region(service_settings):+ west = _regional_ssm("us-west-2")+ try:+ west.update_service_setting(SettingId=_HT, SettingValue="true")+ assert service_settings.get_service_setting(SettingId=_HT)["ServiceSetting"]["Status"] == "Default"+ assert west.get_service_setting(SettingId=_HT)["ServiceSetting"]["ARN"].startswith("arn:aws:ssm:us-west-2:")+ finally:+ west.reset_service_setting(SettingId=_HT)+++def test_ssm_service_setting_persisted():+ from ministack.services import ssm as ssm_service++ ssm_service.reset()+ try:+ ssm_service._update_service_setting({"SettingId": _HT, "SettingValue": "true"}, "arn:aws:iam::000000000000:root")+ saved = ssm_service.get_state()+ ssm_service.reset()+ ssm_service.load_persisted_state(saved)+ body = json.loads(ssm_service._get_service_setting({"SettingId": _HT})[2])+ finally:+ ssm_service.reset()+ assert body["ServiceSetting"]["SettingValue"] == "true"+++def test_ssm_default_parameter_tier_setting(service_settings):+ ssm = service_settings+ tiers = set(_ssm_model().shape_for("ParameterTier").enum)+ big = "x" * 4097+ name = f"/tier/{_uuid_mod.uuid4().hex[:8]}"+ cases = {"Standard": ("Standard", "Standard"), "Advanced": ("Advanced", "Advanced"),+ "Intelligent-Tiering": ("Standard", "Advanced")}+ try:+ for default_tier, (small_tier, big_tier) in cases.items():+ ssm.update_service_setting(SettingId=_TIER, SettingValue=default_tier)+ put = ssm.put_parameter(Name=name, Value="v", Type="String", Overwrite=True)+ listed = ssm.describe_parameters(ParameterFilters=[{"Key": "Name", "Values": [name]}])["Parameters"][0]+ assert (put["Tier"], listed["Tier"]) == (small_tier, small_tier)+ ssm.delete_parameter(Name=name)+ assert ssm.put_parameter(Name=name, Value=big, Type="String")["Tier"] == big_tier+ ssm.delete_parameter(Name=name)+ assert ssm.put_parameter(Name=name, Value=big, Type="String", Tier="Standard")["Tier"] == "Standard"+ ssm.delete_parameter(Name=name)+ assert {put["Tier"], listed["Tier"], big_tier} <= tiers+ finally:+ ssm.delete_parameters(Names=[name])+++def _assert_matches_shape(shape, value, path):+ if shape.type_name == "structure":+ assert isinstance(value, dict), path+ assert set(value) <= set(shape.members), (path, set(value) - set(shape.members))+ assert set(shape.required_members) <= set(value), path+ for key, member in value.items():+ _assert_matches_shape(shape.members[key], member, f"{path}.{key}")+ elif shape.type_name == "string":+ assert isinstance(value, str), path+ elif shape.type_name == "timestamp":+ assert isinstance(value, (int, float)) and not isinstance(value, bool), path # json protocol: epoch seconds+++def test_ssm_service_setting_matches_botocore_model(service_settings):+ """Raw responses and error codes against the installed botocore ssm service-2.json."""+ from botocore import xform_name++ ssm = service_settings+ model = _ssm_model()+ for operation, extra in (("GetServiceSetting", {}), ("UpdateServiceSetting", {"SettingValue": "true"}),+ ("GetServiceSetting", {}), ("ResetServiceSetting", {})):+ captured = []+ handler = lambda response_dict, **kw: captured.append(json.loads(response_dict["body"])) # noqa: E731+ ssm.meta.events.register(f"response-received.ssm.{operation}", handler)+ try:+ getattr(ssm, xform_name(operation))(SettingId=_HT, **extra)+ finally:+ ssm.meta.events.unregister(f"response-received.ssm.{operation}", handler)+ _assert_matches_shape(model.operation_model(operation).output_shape, captured[0], operation)+ modelled = {e.name for op in ("GetServiceSetting", "UpdateServiceSetting", "ResetServiceSetting")+ for e in model.operation_model(op).error_shapes}+ assert _error_code(ssm.get_service_setting, SettingId="/ssm/nope")["Code"] in modelled+ # ValidationException is not modelled for UpdateServiceSetting; observed on AWS (us-east-1, 2026-10-10).+ assert "ValidationException" not in modelled