Skip to content

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

55.8 KB
Raw Blame
import json
import os
import time
import uuid as _uuid_mod

import boto3
import pytest
from botocore.config import Config
from botocore.exceptions import ClientError


def _regional_ssm(region_name):
    return boto3.client(
        "ssm",
        endpoint_url=os.environ.get("MINISTACK_ENDPOINT", "http://localhost:4566"),
        aws_access_key_id="test",
        aws_secret_access_key="test",
        region_name=region_name,
        config=Config(region_name=region_name, retries={"mode": "standard"}),
    )


def test_ssm_put_get(ssm):
    ssm.put_parameter(Name="/app/db/host", Value="localhost", Type="String")
    resp = ssm.get_parameter(Name="/app/db/host")
    assert resp["Parameter"]["Value"] == "localhost"

def test_ssm_get_by_path(ssm):
    ssm.put_parameter(Name="/app/config/key1", Value="val1", Type="String")
    ssm.put_parameter(Name="/app/config/key2", Value="val2", Type="String")
    resp = ssm.get_parameters_by_path(Path="/app/config", Recursive=True)
    assert len(resp["Parameters"]) >= 2

def test_ssm_overwrite(ssm):
    ssm.put_parameter(Name="/app/overwrite", Value="v1", Type="String")
    ssm.put_parameter(Name="/app/overwrite", Value="v2", Type="String", Overwrite=True)
    resp = ssm.get_parameter(Name="/app/overwrite")
    assert resp["Parameter"]["Value"] == "v2"

def test_ssm_put_get_v2(ssm):
    ssm.put_parameter(Name="/ps2/pg/host", Value="db.local", Type="String")
    resp = ssm.get_parameter(Name="/ps2/pg/host")
    assert resp["Parameter"]["Value"] == "db.local"
    assert resp["Parameter"]["Type"] == "String"
    assert resp["Parameter"]["Version"] == 1

    ssm.put_parameter(Name="/ps2/pg/pass", Value="secret123", Type="SecureString")
    resp_enc = ssm.get_parameter(Name="/ps2/pg/pass", WithDecryption=True)
    assert resp_enc["Parameter"]["Value"] == "secret123"

def test_ssm_overwrite_version_v2(ssm):
    ssm.put_parameter(Name="/ps2/ov/p", Value="v1", Type="String")
    r1 = ssm.get_parameter(Name="/ps2/ov/p")
    assert r1["Parameter"]["Version"] == 1

    ssm.put_parameter(Name="/ps2/ov/p", Value="v2", Type="String", Overwrite=True)
    r2 = ssm.get_parameter(Name="/ps2/ov/p")
    assert r2["Parameter"]["Value"] == "v2"
    assert r2["Parameter"]["Version"] == 2

    ssm.put_parameter(Name="/ps2/ov/p", Value="v3", Type="String", Overwrite=True)
    r3 = ssm.get_parameter(Name="/ps2/ov/p")
    assert r3["Parameter"]["Version"] == 3

def test_ssm_get_by_path_v2(ssm):
    ssm.put_parameter(Name="/ps2/path/x", Value="vx", Type="String")
    ssm.put_parameter(Name="/ps2/path/y", Value="vy", Type="String")
    ssm.put_parameter(Name="/ps2/path/sub/z", Value="vz", Type="String")

    resp = ssm.get_parameters_by_path(Path="/ps2/path", Recursive=True)
    names = [p["Name"] for p in resp["Parameters"]]
    assert "/ps2/path/x" in names
    assert "/ps2/path/y" in names
    assert "/ps2/path/sub/z" in names

    resp_shallow = ssm.get_parameters_by_path(Path="/ps2/path", Recursive=False)
    names_shallow = [p["Name"] for p in resp_shallow["Parameters"]]
    assert "/ps2/path/x" in names_shallow
    assert "/ps2/path/sub/z" not in names_shallow

def test_ssm_get_parameters_multiple_v2(ssm):
    ssm.put_parameter(Name="/ps2/multi/a", Value="va", Type="String")
    ssm.put_parameter(Name="/ps2/multi/b", Value="vb", Type="String")
    resp = ssm.get_parameters(Names=["/ps2/multi/a", "/ps2/multi/b", "/ps2/multi/nope"])
    assert len(resp["Parameters"]) == 2
    assert any(p["Name"] == "/ps2/multi/a" for p in resp["Parameters"])
    assert any(p["Name"] == "/ps2/multi/b" for p in resp["Parameters"])
    assert "/ps2/multi/nope" in resp["InvalidParameters"]

def test_ssm_delete_v2(ssm):
    ssm.put_parameter(Name="/ps2/del/tmp", Value="bye", Type="String")
    ssm.delete_parameter(Name="/ps2/del/tmp")
    with pytest.raises(ClientError) as exc:
        ssm.get_parameter(Name="/ps2/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="/ps2/del/b1", Value="v1", Type="String")
    ssm.put_parameter(Name="/ps2/del/b2", Value="v2", Type="String")
    resp = ssm.delete_parameters(Names=["/ps2/del/b1", "/ps2/del/b2", "/ps2/del/ghost"])
    assert len(resp["DeletedParameters"]) == 2
    assert "/ps2/del/ghost" in resp["InvalidParameters"]

def test_ssm_describe_v2(ssm):
    ssm.put_parameter(Name="/ps2/desc/alpha", Value="va", Type="String", Description="alpha param")
    ssm.put_parameter(Name="/ps2/desc/beta", Value="vb", Type="SecureString")
    resp = ssm.describe_parameters(
        ParameterFilters=[{"Key": "Name", "Option": "BeginsWith", "Values": ["/ps2/desc/"]}]
    )
    names = [p["Name"] for p in resp["Parameters"]]
    assert "/ps2/desc/alpha" in names
    assert "/ps2/desc/beta" in names

def test_ssm_parameter_history_v2(ssm):
    ssm.put_parameter(Name="/ps2/hist/h", Value="h1", Type="String", Description="d1")
    ssm.put_parameter(Name="/ps2/hist/h", Value="h2", Type="String", Overwrite=True, Description="d2")
    ssm.put_parameter(Name="/ps2/hist/h", Value="h3", Type="String", Overwrite=True, Description="d3")
    resp = ssm.get_parameter_history(Name="/ps2/hist/h")
    assert len(resp["Parameters"]) == 3
    assert resp["Parameters"][0]["Value"] == "h1"
    assert resp["Parameters"][0]["Version"] == 1
    assert resp["Parameters"][2]["Value"] == "h3"
    assert resp["Parameters"][2]["Version"] == 3

def test_ssm_tags_v2(ssm):
    ssm.put_parameter(Name="/ps2/tag/t1", Value="v", Type="String")
    ssm.add_tags_to_resource(
        ResourceType="Parameter",
        ResourceId="/ps2/tag/t1",
        Tags=[{"Key": "team", "Value": "platform"}, {"Key": "env", "Value": "staging"}],
    )
    resp = ssm.list_tags_for_resource(ResourceType="Parameter", ResourceId="/ps2/tag/t1")
    tag_map = {t["Key"]: t["Value"] for t in resp["TagList"]}
    assert tag_map["team"] == "platform"
    assert tag_map["env"] == "staging"

    ssm.remove_tags_from_resource(
        ResourceType="Parameter",
        ResourceId="/ps2/tag/t1",
        TagKeys=["team"],
    )
    resp2 = ssm.list_tags_for_resource(ResourceType="Parameter", ResourceId="/ps2/tag/t1")
    tag_map2 = {t["Key"]: t["Value"] for t in resp2["TagList"]}
    assert "team" not in tag_map2
    assert tag_map2["env"] == "staging"

def test_ssm_label_parameter_version(ssm):
    import uuid as _uuid

    pname = f"/intg/label/{_uuid.uuid4().hex[:8]}"
    ssm.put_parameter(Name=pname, Value="v1", Type="String")
    ssm.put_parameter(Name=pname, Value="v2", Type="String", Overwrite=True)
    resp = ssm.label_parameter_version(Name=pname, ParameterVersion=1, Labels=["stable"])
    assert resp["ParameterVersion"] == 1
    assert resp["InvalidLabels"] == []

def test_ssm_add_remove_tags(ssm):
    import uuid as _uuid

    pname = f"/intg/tagged/{_uuid.uuid4().hex[:8]}"
    ssm.put_parameter(Name=pname, Value="hello", Type="String")
    ssm.add_tags_to_resource(
        ResourceType="Parameter",
        ResourceId=pname,
        Tags=[{"Key": "env", "Value": "prod"}, {"Key": "team", "Value": "backend"}],
    )
    tags = ssm.list_tags_for_resource(ResourceType="Parameter", ResourceId=pname)
    tag_map = {t["Key"]: t["Value"] for t in tags["TagList"]}
    assert tag_map.get("env") == "prod"
    assert tag_map.get("team") == "backend"
    ssm.remove_tags_from_resource(ResourceType="Parameter", ResourceId=pname, TagKeys=["team"])
    tags2 = ssm.list_tags_for_resource(ResourceType="Parameter", ResourceId=pname)
    tag_map2 = {t["Key"]: t["Value"] for t in tags2["TagList"]}
    assert "team" not in tag_map2
    assert tag_map2.get("env") == "prod"

def test_ssm_put_parameter_with_tags_then_list(ssm):
    """PutParameter with Tags must be readable via ListTagsForResource (GH-249)."""
    import uuid as _uuid

    pname = f"/intg/put-tags/{_uuid.uuid4().hex[:8]}"
    ssm.put_parameter(
        Name=pname,
        Value="tagged-value",
        Type="String",
        Tags=[{"Key": "env", "Value": "prod"}, {"Key": "team", "Value": "backend"}],
    )
    tags = ssm.list_tags_for_resource(ResourceType="Parameter", ResourceId=pname)
    tag_map = {t["Key"]: t["Value"] for t in tags["TagList"]}
    assert tag_map.get("env") == "prod"
    assert tag_map.get("team") == "backend"


def test_ssm_put_parameter_tags_work_with_add_and_remove(ssm):
    """Tags set via PutParameter must be compatible with AddTags/RemoveTags (GH-249)."""
    import uuid as _uuid

    pname = f"/intg/put-tags-compat/{_uuid.uuid4().hex[:8]}"
    ssm.put_parameter(
        Name=pname,
        Value="v1",
        Type="String",
        Tags=[{"Key": "env", "Value": "dev"}],
    )
    # AddTagsToResource on top of PutParameter tags
    ssm.add_tags_to_resource(
        ResourceType="Parameter",
        ResourceId=pname,
        Tags=[{"Key": "team", "Value": "platform"}],
    )
    tags = ssm.list_tags_for_resource(ResourceType="Parameter", ResourceId=pname)
    tag_map = {t["Key"]: t["Value"] for t in tags["TagList"]}
    assert tag_map.get("env") == "dev"
    assert tag_map.get("team") == "platform"

    # RemoveTagsFromResource on PutParameter-created tag
    ssm.remove_tags_from_resource(
        ResourceType="Parameter", ResourceId=pname, TagKeys=["env"]
    )
    tags2 = ssm.list_tags_for_resource(ResourceType="Parameter", ResourceId=pname)
    tag_map2 = {t["Key"]: t["Value"] for t in tags2["TagList"]}
    assert "env" not in tag_map2
    assert tag_map2.get("team") == "platform"


def test_ssm_get_parameter_history(ssm):
    """GetParameterHistory returns all versions of a parameter."""
    ssm.put_parameter(Name="/qa/ssm/hist", Value="v1", Type="String")
    ssm.put_parameter(Name="/qa/ssm/hist", Value="v2", Type="String", Overwrite=True)
    ssm.put_parameter(Name="/qa/ssm/hist", Value="v3", Type="String", Overwrite=True)
    history = ssm.get_parameter_history(Name="/qa/ssm/hist")["Parameters"]
    assert len(history) == 3
    values = [h["Value"] for h in history]
    assert "v1" in values and "v2" in values and "v3" in values

def test_ssm_describe_parameters_filter(ssm):
    """DescribeParameters with ParameterFilters filters by path prefix."""
    ssm.put_parameter(Name="/qa/ssm/filter/a", Value="1", Type="String")
    ssm.put_parameter(Name="/qa/ssm/filter/b", Value="2", Type="String")
    ssm.put_parameter(Name="/qa/ssm/other/c", Value="3", Type="String")
    resp = ssm.describe_parameters(ParameterFilters=[{"Key": "Path", "Values": ["/qa/ssm/filter"]}])
    names = [p["Name"] for p in resp["Parameters"]]
    assert "/qa/ssm/filter/a" in names
    assert "/qa/ssm/filter/b" in names
    assert "/qa/ssm/other/c" not in names

def test_ssm_secure_string_not_decrypted_by_default(ssm):
    """SecureString value is not returned in plaintext without WithDecryption=True."""
    ssm.put_parameter(Name="/qa/ssm/secure", Value="mysecret", Type="SecureString")
    resp = ssm.get_parameter(Name="/qa/ssm/secure", WithDecryption=False)
    assert resp["Parameter"]["Value"] != "mysecret"
    resp2 = ssm.get_parameter(Name="/qa/ssm/secure", WithDecryption=True)
    assert resp2["Parameter"]["Value"] == "mysecret"


def test_ssm_describe_parameters_reports_the_key_for_a_secure_string(ssm):
    """ParameterMetadata.KeyId is "the alias of the AWS KMS key used to
    encrypt the parameter. Applies to SecureString parameters only", so
    DescribeParameters reports it for a SecureString and omits it for the
    rest. Without it Terraform's aws_ssm_parameter records an empty key_id
    and plans the same in-place update on every run.
    Reported by @edersonbrilhante."""
    import uuid as _uuid

    suffix = _uuid.uuid4().hex[:8]
    default_key = f"/qa/ssm/keyid/default-{suffix}"
    custom_key = f"/qa/ssm/keyid/custom-{suffix}"
    plain = f"/qa/ssm/keyid/plain-{suffix}"
    custom = "arn:aws:kms:us-east-1:000000000000:key/11111111-2222-3333-4444-555555555555"
    ssm.put_parameter(Name=default_key, Value="s", Type="SecureString")
    ssm.put_parameter(Name=custom_key, Value="s", Type="SecureString", KeyId=custom)
    ssm.put_parameter(Name=plain, Value="p", Type="String")
    try:
        def described(name):
            found = ssm.describe_parameters(
                ParameterFilters=[{"Key": "Name", "Values": [name]}])["Parameters"]
            assert found, name
            return found[0]

        # No KeyId on the request: the account's default SSM key, an AWS
        # managed key, whose alias has the form aws/<service-name>.
        assert described(default_key)["KeyId"] == "alias/aws/ssm"
        assert described(custom_key)["KeyId"] == custom
        assert "KeyId" not in described(plain)

        # ParameterHistory carries the same member.
        history = ssm.get_parameter_history(Name=default_key)["Parameters"]
        assert history[-1]["KeyId"] == "alias/aws/ssm"
        assert "KeyId" not in ssm.get_parameter_history(Name=plain)["Parameters"][-1]

        # GetParameter's Parameter shape has no KeyId member.
        assert "KeyId" not in ssm.get_parameter(Name=default_key)["Parameter"]
    finally:
        for name in (default_key, custom_key, plain):
            ssm.delete_parameter(Name=name)


def test_ssm_get_parameters_by_path_root_non_recursive(ssm):
    """GetParametersByPath with Path=/ and Recursive=False should only return top-level params."""
    ssm.put_parameter(Name="/toplevel", Value="top", Type="String", Overwrite=True)
    ssm.put_parameter(Name="/nested/deep", Value="deep", Type="String", Overwrite=True)

    resp = ssm.get_parameters_by_path(Path="/", Recursive=False)
    names = [p["Name"] for p in resp["Parameters"]]
    assert "/toplevel" in names
    assert "/nested/deep" not in names


def test_ssm_restore_legacy_parameter_history_uses_parameter_arn_region():
    from ministack.core.responses import AccountScopedDict, set_request_account_id, set_request_region
    from ministack.services import ssm as ssm_service

    account_id = "000000000000"
    name = f"/legacy/history/{_uuid_mod.uuid4().hex[:8]}"

    set_request_account_id(account_id)
    set_request_region("us-east-1")
    ssm_service.reset()
    parameters = AccountScopedDict()
    parameters[name] = {
        "Name": name,
        "Type": "String",
        "Value": "v2",
        "Version": 2,
        "ARN": f"arn:aws:ssm:us-west-2:{account_id}:parameter/{name.lstrip('/')}",
    }
    parameter_history = AccountScopedDict()
    parameter_history[name] = [
        {"Name": name, "Type": "String", "Value": "v1", "Version": 1},
        {"Name": name, "Type": "String", "Value": "v2", "Version": 2},
    ]

    try:
        ssm_service.load_persisted_state({
            "parameters": parameters,
            "parameter_history": parameter_history,
        })

        assert len(ssm_service._parameter_history.get_scoped(account_id, "us-west-2", name)) == 2
        assert ssm_service._parameter_history.get_scoped(account_id, "us-east-1", name) is None
    finally:
        ssm_service.reset()


def test_ssm_restore_legacy_history_prefers_exact_parameter_name_region():
    from ministack.core.responses import AccountScopedDict, set_request_account_id, set_request_region
    from ministack.services import ssm as ssm_service

    account_id = "000000000000"
    suffix = _uuid_mod.uuid4().hex[:8]
    bare_name = f"legacy-history-exact-{suffix}"
    path_name = f"/{bare_name}"

    set_request_account_id(account_id)
    set_request_region("us-east-1")
    ssm_service.reset()
    parameters = AccountScopedDict()
    parameters[bare_name] = {
        "Name": bare_name,
        "Type": "String",
        "Value": "bare",
        "Version": 1,
        "ARN": f"arn:aws:ssm:us-west-2:{account_id}:parameter{bare_name}",
    }
    parameters[path_name] = {
        "Name": path_name,
        "Type": "String",
        "Value": "path",
        "Version": 1,
        "ARN": f"arn:aws:ssm:us-east-1:{account_id}:parameter/{bare_name}",
    }
    parameter_history = AccountScopedDict()
    parameter_history[bare_name] = [
        {"Name": bare_name, "Type": "String", "Value": "bare", "Version": 1},
    ]

    try:
        ssm_service.load_persisted_state({
            "parameters": parameters,
            "parameter_history": parameter_history,
        })

        assert len(ssm_service._parameter_history.get_scoped(account_id, "us-west-2", bare_name)) == 1
        assert ssm_service._parameter_history.get_scoped(account_id, "us-east-1", bare_name) is None
    finally:
        ssm_service.reset()


def test_ssm_restore_legacy_bare_name_tags_uses_stored_parameter_arn():
    from ministack.core.responses import AccountScopedDict, set_request_account_id, set_request_region
    from ministack.services import ssm as ssm_service

    account_id = "000000000000"
    name = f"legacy-tag-{_uuid_mod.uuid4().hex[:8]}"
    legacy_arn = f"arn:aws:ssm:us-west-2:{account_id}:parameter{name}"

    set_request_account_id(account_id)
    set_request_region("us-east-1")
    ssm_service.reset()
    parameters = AccountScopedDict()
    parameters[name] = {
        "Name": name,
        "Type": "String",
        "Value": "legacy",
        "Version": 1,
        "ARN": legacy_arn,
    }
    tags = AccountScopedDict()
    tags[legacy_arn] = {"env": "legacy"}

    try:
        ssm_service.load_persisted_state({
            "parameters": parameters,
            "tags": tags,
        })
        set_request_region("us-west-2")
        assert ssm_service.resolve_parameter_value(legacy_arn) == "legacy"
        status, _headers, body = ssm_service._list_tags_for_resource({
            "ResourceType": "Parameter",
            "ResourceId": name,
        })
        assert status == 200
        assert json.loads(body)["TagList"] == [{"Key": "env", "Value": "legacy"}]

        status, _headers, _body = ssm_service._put_parameter({
            "Name": name,
            "Type": "String",
            "Value": "updated",
            "Overwrite": True,
        })
        assert status == 200
        assert ssm_service._parameters[name]["ARN"] == legacy_arn
        status, _headers, body = ssm_service._list_tags_for_resource({
            "ResourceType": "Parameter",
            "ResourceId": name,
        })
        assert status == 200
        assert json.loads(body)["TagList"] == [{"Key": "env", "Value": "legacy"}]
    finally:
        ssm_service.reset()


def test_ssm_arn_lookup_prefers_exact_stored_arn_match():
    from ministack.core.responses import AccountScopedDict, set_request_account_id, set_request_region
    from ministack.services import ssm as ssm_service

    account_id = "000000000000"
    suffix = _uuid_mod.uuid4().hex[:8]
    bare_name = f"legacy-exact-{suffix}"
    path_name = f"/{bare_name}"
    bare_arn = f"arn:aws:ssm:us-west-2:{account_id}:parameter{bare_name}"
    path_arn = f"arn:aws:ssm:us-west-2:{account_id}:parameter/{bare_name}"

    set_request_account_id(account_id)
    set_request_region("us-east-1")
    ssm_service.reset()
    parameters = AccountScopedDict()
    parameters[bare_name] = {
        "Name": bare_name,
        "Type": "String",
        "Value": "bare",
        "Version": 1,
        "ARN": bare_arn,
    }
    parameters[path_name] = {
        "Name": path_name,
        "Type": "String",
        "Value": "path",
        "Version": 1,
        "ARN": path_arn,
    }

    try:
        ssm_service.load_persisted_state({"parameters": parameters})
        set_request_region("us-west-2")
        assert ssm_service.resolve_parameter_value(bare_arn) == "bare"
        assert ssm_service.resolve_parameter_value(path_arn) == "path"
    finally:
        ssm_service.reset()


def test_ssm_exact_legacy_slash_twin_can_be_overwritten():
    from ministack.core.responses import AccountScopedDict, set_request_account_id, set_request_region
    from ministack.services import ssm as ssm_service

    account_id = "000000000000"
    suffix = _uuid_mod.uuid4().hex[:8]
    bare_name = f"legacy-overwrite-{suffix}"
    path_name = f"/{bare_name}"

    set_request_account_id(account_id)
    set_request_region("us-east-1")
    ssm_service.reset()
    parameters = AccountScopedDict()
    parameters[bare_name] = {
        "Name": bare_name,
        "Type": "String",
        "Value": "bare",
        "Version": 1,
        "ARN": f"arn:aws:ssm:us-west-2:{account_id}:parameter{bare_name}",
    }
    parameters[path_name] = {
        "Name": path_name,
        "Type": "String",
        "Value": "path",
        "Version": 1,
        "ARN": f"arn:aws:ssm:us-west-2:{account_id}:parameter/{bare_name}",
    }

    try:
        ssm_service.load_persisted_state({"parameters": parameters})
        set_request_region("us-west-2")
        status, _headers, _body = ssm_service._put_parameter({
            "Name": bare_name,
            "Type": "String",
            "Value": "updated-bare",
            "Overwrite": True,
        })
        assert status == 200
        assert ssm_service._parameters[bare_name]["Value"] == "updated-bare"
        assert ssm_service._parameters[path_name]["Value"] == "path"
    finally:
        ssm_service.reset()


def test_ssm_legacy_no_slash_arn_does_not_fallback_to_path_parameter():
    from ministack.core.responses import AccountScopedDict, set_request_account_id, set_request_region
    from ministack.services import ssm as ssm_service

    account_id = "000000000000"
    suffix = _uuid_mod.uuid4().hex[:8]
    path_name = f"/legacy-stale-{suffix}"
    path_arn = f"arn:aws:ssm:us-west-2:{account_id}:parameter/{path_name.lstrip('/')}"
    stale_legacy_arn = f"arn:aws:ssm:us-west-2:{account_id}:parameter{path_name.lstrip('/')}"

    set_request_account_id(account_id)
    set_request_region("us-east-1")
    ssm_service.reset()
    parameters = AccountScopedDict()
    parameters[path_name] = {
        "Name": path_name,
        "Type": "String",
        "Value": "path",
        "Version": 1,
        "ARN": path_arn,
    }

    try:
        ssm_service.load_persisted_state({"parameters": parameters})
        set_request_region("us-west-2")
        assert ssm_service.resolve_parameter_value(path_arn) == "path"
        assert ssm_service.resolve_parameter_value(stale_legacy_arn) is None
    finally:
        ssm_service.reset()


def test_ssm_malformed_or_foreign_partition_arn_does_not_fallback_to_name():
    from ministack.core.responses import AccountScopedDict, set_request_account_id, set_request_region
    from ministack.services import ssm as ssm_service

    account_id = "000000000000"
    name = f"/invalid-arn/{_uuid_mod.uuid4().hex[:8]}"
    canonical_arn = f"arn:aws:ssm:us-east-1:{account_id}:parameter/{name.lstrip('/')}"
    missing_region_arn = f"arn:aws:ssm::{account_id}:parameter/{name.lstrip('/')}"
    foreign_partition_arn = f"arn:aws-cn:ssm:us-east-1:{account_id}:parameter/{name.lstrip('/')}"

    set_request_account_id(account_id)
    set_request_region("us-east-1")
    ssm_service.reset()
    parameters = AccountScopedDict()
    parameters[name] = {
        "Name": name,
        "Type": "String",
        "Value": "value",
        "Version": 1,
        "ARN": canonical_arn,
    }

    try:
        ssm_service.load_persisted_state({"parameters": parameters})
        assert ssm_service.resolve_parameter_value(canonical_arn) == "value"
        assert ssm_service.resolve_parameter_value(missing_region_arn) is None
        assert ssm_service.resolve_parameter_value(foreign_partition_arn) is None
    finally:
        ssm_service.reset()


def test_ssm_restore_legacy_add_tags_key_for_bare_name_parameter():
    from ministack.core.responses import AccountScopedDict, set_request_account_id, set_request_region
    from ministack.services import ssm as ssm_service

    account_id = "000000000000"
    name = f"legacy-add-tags-{_uuid_mod.uuid4().hex[:8]}"
    legacy_arn = f"arn:aws:ssm:us-west-2:{account_id}:parameter{name}"
    legacy_add_tags_arn = f"arn:aws:ssm:us-west-2:{account_id}:parameter/{name}"

    set_request_account_id(account_id)
    set_request_region("us-east-1")
    ssm_service.reset()
    parameters = AccountScopedDict()
    parameters[name] = {
        "Name": name,
        "Type": "String",
        "Value": "legacy",
        "Version": 1,
        "ARN": legacy_arn,
    }
    tags = AccountScopedDict()
    tags[legacy_add_tags_arn] = {"env": "legacy-add-tags"}

    try:
        ssm_service.load_persisted_state({
            "parameters": parameters,
            "tags": tags,
        })
        set_request_region("us-west-2")
        status, _headers, body = ssm_service._list_tags_for_resource({
            "ResourceType": "Parameter",
            "ResourceId": name,
        })
        assert status == 200
        assert json.loads(body)["TagList"] == [{"Key": "env", "Value": "legacy-add-tags"}]

        status, _headers, body = ssm_service._list_tags_for_resource({
            "ResourceType": "Parameter",
            "ResourceId": legacy_add_tags_arn,
        })
        assert status == 200
        assert json.loads(body)["TagList"] == [{"Key": "env", "Value": "legacy-add-tags"}]

        status, _headers, _body = ssm_service._delete_parameter({"Name": name})
        assert status == 200
        assert ssm_service._tags.get_scoped(account_id, "us-west-2", legacy_arn) is None
        assert ssm_service._tags.get_scoped(account_id, "us-west-2", legacy_add_tags_arn) is None
    finally:
        ssm_service.reset()


def test_cloudformation_ssm_parameter_uses_canonical_arn_builder():
    from ministack.core.responses import set_request_account_id, set_request_region
    from ministack.services import ssm as ssm_service
    from ministack.services.cloudformation import provisioners

    account_id = "000000000000"
    name = f"cfn-param-{_uuid_mod.uuid4().hex[:8]}"

    set_request_account_id(account_id)
    set_request_region("us-west-2")
    ssm_service.reset()
    try:
        provisioners._ssm_create("Param", {"Name": name, "Value": "value"}, "stack")
        assert ssm_service._parameters[name]["ARN"] == (
            f"arn:aws:ssm:us-west-2:{account_id}:parameter/{name}"
        )
    finally:
        ssm_service.reset()


def test_ssm_parameters_are_region_scoped_by_name(ssm):
    west = _regional_ssm("us-west-2")
    name = f"/mr/ssm/{_uuid_mod.uuid4().hex[:8]}"

    ssm.put_parameter(Name=name, Value="east", Type="String")
    west.put_parameter(Name=name, Value="west", Type="String")

    east_param = ssm.get_parameter(Name=name)["Parameter"]
    west_param = west.get_parameter(Name=name)["Parameter"]

    assert east_param["Value"] == "east"
    assert west_param["Value"] == "west"
    assert ":us-east-1:" in east_param["ARN"]
    assert ":us-west-2:" in west_param["ARN"]

    ssm.delete_parameter(Name=name)
    with pytest.raises(ClientError) as exc:
        ssm.get_parameter(Name=name)
    assert exc.value.response["Error"]["Code"] == "ParameterNotFound"
    assert west.get_parameter(Name=name)["Parameter"]["Value"] == "west"


def test_ssm_delete_rejects_parameter_arn(ssm):
    name = f"/mr/ssm/delete-arn/{_uuid_mod.uuid4().hex[:8]}"
    ssm.put_parameter(Name=name, Value="value", Type="String")
    arn = ssm.get_parameter(Name=name)["Parameter"]["ARN"]

    with pytest.raises(ClientError) as exc:
        ssm.delete_parameter(Name=arn)
    assert exc.value.response["Error"]["Code"] == "ValidationException"
    assert ssm.get_parameter(Name=name)["Parameter"]["Value"] == "value"

    resp = ssm.delete_parameters(Names=[arn])
    assert arn in resp["InvalidParameters"]
    assert ssm.get_parameter(Name=name)["Parameter"]["Value"] == "value"

    ssm.delete_parameter(Name=name)


def test_ssm_put_rejects_slash_variant_duplicate(ssm):
    name = f"mr-ssm-duplicate-{_uuid_mod.uuid4().hex[:8]}"
    ssm.put_parameter(Name=name, Value="bare", Type="String")

    with pytest.raises(ClientError) as exc:
        ssm.put_parameter(Name=f"/{name}", Value="path", Type="String")
    assert exc.value.response["Error"]["Code"] == "ParameterAlreadyExists"

    with pytest.raises(ClientError) as exc:
        ssm.put_parameter(Name=f"/{name}", Value="path", Type="String", Overwrite=True)
    assert exc.value.response["Error"]["Code"] == "ParameterAlreadyExists"

    assert ssm.get_parameter(Name=name)["Parameter"]["Value"] == "bare"
    ssm.delete_parameter(Name=name)


_SSM_PATH_MSG = (
    'Parameter name: can\'t be prefixed with "ssm" (case-insensitive). If formed as a path, it can consist '
    "of sub-paths divided by slash symbol; each sub-path can be formed as a mix of letters, numbers and "
    "the following 3 symbols .-_"
)
_AWS_SSM_PLAIN_MSG = 'Parameter name: can\'t be prefixed with "aws" or "ssm" (case-insensitive).'
_TAGS_OVERWRITE_MSG = (
    "Invalid request: tags and overwrite can't be used together. To create a parameter "
    "with tags, please remove overwrite flag. To update tags for an existing parameter, "
    "please use AddTagsToResource or RemoveTagsFromResource."
)


def test_ssm_put_parameter_requires_type_on_create(ssm):
    name = f"/ps-type/{_uuid_mod.uuid4().hex[:8]}"
    with pytest.raises(ClientError) as exc:
        ssm.put_parameter(Name=name, Value="x")
    err = exc.value.response["Error"]
    assert err["Code"] == "ValidationException"
    assert err["Message"] == "A parameter type is required when you create a parameter."
    with pytest.raises(ClientError) as exc:
        ssm.get_parameter(Name=name)
    assert exc.value.response["Error"]["Code"] == "ParameterNotFound"


def test_ssm_put_parameter_overwrite_keeps_type_when_omitted(ssm):
    name = f"/ps-type/{_uuid_mod.uuid4().hex[:8]}"
    ssm.put_parameter(Name=name, Value="old", Type="SecureString")
    ssm.put_parameter(Name=name, Value="new", Overwrite=True)
    param = ssm.get_parameter(Name=name, WithDecryption=True)["Parameter"]
    assert param["Type"] == "SecureString"
    assert param["Version"] == 2
    assert param["Value"] == "new"
    ssm.delete_parameter(Name=name)


@pytest.mark.parametrize(
    "template,code,message",
    [
        ("/ssm/{id}", "ValidationException", _SSM_PATH_MSG),
        ("/SSM/{id}", "ValidationException", _SSM_PATH_MSG),
        ("/ssm2-{id}/y", "ValidationException", _SSM_PATH_MSG),
        ("/aws/{id}", "AccessDeniedException", None),
        ("/AWS/{id}", "AccessDeniedException", None),
        ("/awsfoo{id}/y", "AccessDeniedException", None),
        ("ssmTest{id}", "ValidationException", _AWS_SSM_PLAIN_MSG),
        ("awsTest{id}", "ValidationException", _AWS_SSM_PLAIN_MSG),
        ("SSM-test{id}", "ValidationException", _AWS_SSM_PLAIN_MSG),
    ],
)
def test_ssm_put_parameter_rejects_reserved_prefixes(ssm, template, code, message):
    name = template.format(id=_uuid_mod.uuid4().hex[:8])
    if message is None:
        message = f"No access to reserved parameter name: {name[1:]}."
    with pytest.raises(ClientError) as exc:
        ssm.put_parameter(Name=name, Value="x", Type="String")
    err = exc.value.response
    assert err["Error"]["Code"] == code
    assert err["Error"]["Message"] == message
    assert err["ResponseMetadata"]["HTTPStatusCode"] == 400


def test_ssm_put_parameter_allows_reserved_words_later_in_path(ssm):
    name = f"/app-{_uuid_mod.uuid4().hex[:8]}/ssm/aws"
    ssm.put_parameter(Name=name, Value="ok", Type="String")
    assert ssm.get_parameter(Name=name)["Parameter"]["Value"] == "ok"
    ssm.delete_parameter(Name=name)


def test_ssm_put_parameter_name_error_wins_over_other_checks(ssm):
    name = f"/aws/{_uuid_mod.uuid4().hex[:8]}"
    with pytest.raises(ClientError) as exc:
        ssm.put_parameter(Name=name, Value="x", Overwrite=True, Tags=[{"Key": "k", "Value": "v"}])
    assert exc.value.response["Error"]["Code"] == "AccessDeniedException"


def test_ssm_public_latest_ami_parameter_names_a_stub_image(ssm, ec2):
    param = ssm.get_parameter(Name="/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-default-x86_64")["Parameter"]
    assert param["ARN"].split(":")[4] == ""
    assert ec2.describe_images(ImageIds=[param["Value"]])["Images"][0]["Name"].startswith("al2023-ami-")


def test_ssm_put_parameter_rejects_tags_with_overwrite(ssm):
    tags = [{"Key": "k", "Value": "v"}]
    new_name = f"/ps-tags/{_uuid_mod.uuid4().hex[:8]}"
    with pytest.raises(ClientError) as exc:
        ssm.put_parameter(Name=new_name, Value="x", Type="String", Overwrite=True, Tags=tags)
    err = exc.value.response["Error"]
    assert err["Code"] == "ValidationException"
    assert err["Message"] == _TAGS_OVERWRITE_MSG
    with pytest.raises(ClientError) as exc:
        ssm.get_parameter(Name=new_name)
    assert exc.value.response["Error"]["Code"] == "ParameterNotFound"

    name = f"/ps-tags/{_uuid_mod.uuid4().hex[:8]}"
    ssm.put_parameter(Name=name, Value="old", Type="String", Tags=tags)
    with pytest.raises(ClientError) as exc:
        ssm.put_parameter(Name=name, Value="new", Type="String", Overwrite=True, Tags=[{"Key": "a", "Value": "b"}])
    assert exc.value.response["Error"]["Message"] == _TAGS_OVERWRITE_MSG
    param = ssm.get_parameter(Name=name)["Parameter"]
    assert (param["Value"], param["Version"]) == ("old", 1)
    assert ssm.list_tags_for_resource(ResourceType="Parameter", ResourceId=name)["TagList"] == tags

    ssm.put_parameter(Name=name, Value="new", Type="String", Overwrite=True, Tags=[])
    assert ssm.get_parameter(Name=name)["Parameter"]["Value"] == "new"
    ssm.delete_parameter(Name=name)


def test_ssm_parameter_arn_lookup_is_request_region_scoped(ssm):
    west = _regional_ssm("us-west-2")
    name = f"/mr/ssm/arn/{_uuid_mod.uuid4().hex[:8]}"

    ssm.put_parameter(Name=name, Value="east", Type="String")
    west.put_parameter(Name=name, Value="west", Type="String")

    east_arn = ssm.get_parameter(Name=name)["Parameter"]["ARN"]
    west_arn = west.get_parameter(Name=name)["Parameter"]["ARN"]

    assert ssm.get_parameter(Name=east_arn)["Parameter"]["Value"] == "east"
    with pytest.raises(ClientError) as exc:
        ssm.get_parameter(Name=west_arn)
    assert exc.value.response["Error"]["Code"] == "ParameterNotFound"


def test_ssm_tags_accept_current_region_parameter_arn(ssm):
    west = _regional_ssm("us-west-2")
    name = f"/mr/ssm/tag/{_uuid_mod.uuid4().hex[:8]}"

    ssm.put_parameter(Name=name, Value="east", Type="String")
    west.put_parameter(Name=name, Value="west", Type="String")

    east_arn = ssm.get_parameter(Name=name)["Parameter"]["ARN"]
    ssm.add_tags_to_resource(
        ResourceType="Parameter",
        ResourceId=east_arn,
        Tags=[{"Key": "scope", "Value": "east"}],
    )

    east_tags = ssm.list_tags_for_resource(ResourceType="Parameter", ResourceId=east_arn)["TagList"]
    west_tags = west.list_tags_for_resource(ResourceType="Parameter", ResourceId=name)["TagList"]

    assert {tag["Key"]: tag["Value"] for tag in east_tags} == {"scope": "east"}
    assert west_tags == []


def test_ssm_resolve_parameter_value_uses_arn_region_without_tail_fallback():
    from ministack.core.responses import (
        get_account_id,
        get_region,
        set_request_account_id,
        set_request_region,
    )
    from ministack.services import ssm as ssm_service

    original_account = get_account_id()
    original_region = get_region()
    name = f"/mr/ssm/resolve/{_uuid_mod.uuid4().hex[:8]}"

    try:
        ssm_service.reset()
        set_request_account_id("000000000000")
        set_request_region("us-east-1")
        ssm_service._put_parameter({"Name": name, "Value": "east", "Type": "String"})

        west_arn = f"arn:aws:ssm:us-west-2:000000000000:parameter/{name.lstrip('/')}"
        assert ssm_service.resolve_parameter_value(west_arn) is None

        set_request_region("us-west-2")
        ssm_service._put_parameter({"Name": name, "Value": "west", "Type": "String"})

        set_request_region("us-east-1")
        assert ssm_service.resolve_parameter_value(name) == "east"
        assert ssm_service.resolve_parameter_value(west_arn) == "west"
        assert ssm_service.resolve_parameter_value(
            west_arn.replace(":ssm:", ":secretsmanager:", 1)
        ) is None
        assert ssm_service.resolve_parameter_value(
            west_arn.replace(":000000000000:", ":111111111111:", 1)
        ) is None
    finally:
        ssm_service.reset()
        set_request_account_id(original_account)
        set_request_region(original_region)


def test_cloudformation_ssm_parameter_is_region_scoped():
    """A CloudFormation-created ``AWS::SSM::Parameter`` is stored under the
    deploy request's region, so a client in another region cannot read it."""
    from ministack.core.responses import (
        get_account_id,
        get_region,
        set_request_account_id,
        set_request_region,
    )
    from ministack.services import ssm as ssm_service
    from ministack.services.cloudformation import provisioners

    original_account = get_account_id()
    original_region = get_region()
    account_id = "000000000000"
    name = f"cfn-region-{_uuid_mod.uuid4().hex[:8]}"

    try:
        set_request_account_id(account_id)
        set_request_region("us-west-2")
        ssm_service.reset()
        provisioners._ssm_create("Param", {"Name": name, "Value": "west"}, "stack")

        # Stored only under the deploy region.
        assert ssm_service._parameters.get_scoped(account_id, "us-west-2", name) is not None
        assert ssm_service._parameters.get_scoped(account_id, "us-east-1", name) is None

        # Readable in the deploy region.
        status, _headers, body = ssm_service._get_parameter({"Name": name})
        assert status == 200
        assert json.loads(body)["Parameter"]["Value"] == "west"

        # Absent from another region.
        set_request_region("us-east-1")
        status, _headers, body = ssm_service._get_parameter({"Name": name})
        assert status == 400
        assert json.loads(body)["__type"] == "ParameterNotFound"
    finally:
        ssm_service.reset()
        set_request_account_id(original_account)
        set_request_region(original_region)


# ── Run Command helpers ────────────────────────────────────
# A command needs an agent answering, and this emulator's agent is the container behind the
# instance. So the tests that send a command register an AMI and launch a real box; the ones that
# prove refusal do not need one.


def _docker_reachable():
    try:
        import docker as _probe

        _probe.from_env(timeout=5).ping()
        return True
    except Exception:
        return False


requires_docker = pytest.mark.skipif(
    not _docker_reachable(), reason="no reachable Docker daemon")


@pytest.fixture
def boxed_instance(ec2):
    """A running instance with a container behind it, so SSM can reach it."""
    ami = ec2.register_image(Name=f"ssm-{_uuid_mod.uuid4().hex[:8]}",
                             ImageLocation="alpine:3")["ImageId"]
    instance_id = ec2.run_instances(ImageId=ami, MinCount=1,
                                    MaxCount=1)["Instances"][0]["InstanceId"]
    try:
        yield instance_id
    finally:
        ec2.terminate_instances(InstanceIds=[instance_id])
        ec2.deregister_image(ImageId=ami)


def _poll_invocation(ssm, command_id, instance_id, timeout=30):
    """Run Command is asynchronous on AWS, so a caller polls to a terminal state."""
    deadline = time.time() + timeout
    terminal = {"Success", "Failed", "Cancelled", "TimedOut"}
    while time.time() < deadline:
        inv = ssm.get_command_invocation(CommandId=command_id, InstanceId=instance_id)
        if inv["Status"] in terminal:
            return inv
        time.sleep(0.2)
    raise AssertionError(f"invocation never reached a terminal state: {inv['Status']}")


@requires_docker
@pytest.mark.data_plane
def test_ssm_run_command_health_probe(ssm, boxed_instance):
    """The Run Command shape a health probe needs: send, then poll to a terminal invocation."""
    tag = _uuid_mod.uuid4().hex[:8]
    command = ssm.send_command(InstanceIds=[boxed_instance], DocumentName="AWS-RunShellScript",
                               Comment=f"probe {tag}",
                               Parameters={"commands": ["echo ok"]})["Command"]
    assert command["CommandId"]
    assert command["DocumentName"] == "AWS-RunShellScript"
    assert command["InstanceIds"] == [boxed_instance]
    assert command["TargetCount"] == 1
    # SendCommand answers before the command has been delivered, as on AWS.
    assert command["Status"] == "Pending"
    assert command["CompletedCount"] == 0

    inv = _poll_invocation(ssm, command["CommandId"], boxed_instance)
    assert inv["Status"] == "Success"
    assert inv["StatusDetails"] == "Success"
    assert inv["ResponseCode"] == 0
    # The script actually ran in the box.
    assert inv["StandardOutputContent"].strip() == "ok"
    assert inv["DocumentName"] == "AWS-RunShellScript"
    # These are strings in the SSM model, not timestamps, so boto3 must not have parsed them.
    assert isinstance(inv["ExecutionStartDateTime"], str)
    assert isinstance(inv["ExecutionEndDateTime"], str)

    # A caller that checks whether the instance is managed before sending must see it.
    info = ssm.describe_instance_information()["InstanceInformationList"]
    mine = [i for i in info if i["InstanceId"] == boxed_instance]
    assert len(mine) == 1
    assert mine[0]["PingStatus"] == "Online"
    assert mine[0]["ResourceType"] == "EC2Instance"


@requires_docker
@pytest.mark.data_plane
def test_ssm_run_command_probe_can_fail(ssm, boxed_instance):
    """The point of a real box: a health check that is wrong reports Failed, not Success."""
    command = ssm.send_command(InstanceIds=[boxed_instance], DocumentName="AWS-RunShellScript",
                               Parameters={"commands": ["echo bad >&2", "exit 7"]})["Command"]
    inv = _poll_invocation(ssm, command["CommandId"], boxed_instance)
    assert inv["Status"] == "Failed"
    assert inv["StatusDetails"] == "Failed"
    assert inv["ResponseCode"] == 7
    assert inv["StandardErrorContent"].strip() == "bad"
    listed = ssm.list_commands(CommandId=command["CommandId"])["Commands"][0]
    assert listed["Status"] == "Failed"
    assert listed["ErrorCount"] == 1


def test_ssm_send_command_validates_the_instance(ssm, ec2):
    """AWS folds several problems into InvalidInstanceId: no such node, a terminated one, and
    an agent that is not running. A metadata-only instance is the last of those."""
    with pytest.raises(ClientError) as exc:
        ssm.send_command(InstanceIds=["i-00000000000000000"], DocumentName="AWS-RunShellScript")
    assert exc.value.response["Error"]["Code"] == "InvalidInstanceId"

    instance_id = ec2.run_instances(ImageId="ami-12345678", MinCount=1,
                                    MaxCount=1)["Instances"][0]["InstanceId"]
    ec2.terminate_instances(InstanceIds=[instance_id])
    with pytest.raises(ClientError) as exc:
        ssm.send_command(InstanceIds=[instance_id], DocumentName="AWS-RunShellScript")
    assert exc.value.response["Error"]["Code"] == "InvalidInstanceId"

    # Running, but nothing is behind it, so no agent is answering — which is one of the causes
    # AWS lists for this error. It is not listed as a managed node either.
    boxless = ec2.run_instances(ImageId="ami-12345678", MinCount=1,
                                MaxCount=1)["Instances"][0]["InstanceId"]
    try:
        with pytest.raises(ClientError) as exc:
            ssm.send_command(InstanceIds=[boxless], DocumentName="AWS-RunShellScript")
        assert exc.value.response["Error"]["Code"] == "InvalidInstanceId"
        listed = [i["InstanceId"]
                  for i in ssm.describe_instance_information()["InstanceInformationList"]]
        assert boxless not in listed
    finally:
        ec2.terminate_instances(InstanceIds=[boxless])


@requires_docker
@pytest.mark.data_plane
def test_ssm_send_command_accepts_a_managed_instance(ssm, boxed_instance):
    """Rejecting everything would satisfy the refusals above, so prove one is taken."""
    assert ssm.send_command(InstanceIds=[boxed_instance],
                            DocumentName="AWS-RunShellScript",
                            Parameters={"commands": ["true"]})["Command"]["CommandId"]
    listed = [i["InstanceId"]
              for i in ssm.describe_instance_information()["InstanceInformationList"]]
    assert boxed_instance in listed


@requires_docker
@pytest.mark.data_plane
def test_ssm_command_lookup_filters_and_errors(ssm, ec2):
    """listCommands narrows by command and instance; unknown ids get what AWS answers."""
    ami = ec2.register_image(Name=f"ssm-lookup-{_uuid_mod.uuid4().hex[:8]}",
                             ImageLocation="alpine:3")["ImageId"]
    instance_id = ec2.run_instances(ImageId=ami, MinCount=1,
                                    MaxCount=1)["Instances"][0]["InstanceId"]
    other_id = ec2.run_instances(ImageId=ami, MinCount=1,
                                 MaxCount=1)["Instances"][0]["InstanceId"]
    try:
        mine = ssm.send_command(InstanceIds=[instance_id],
                                DocumentName="AWS-RunShellScript",
                                Parameters={"commands": ["true"]})["Command"]["CommandId"]
        theirs = ssm.send_command(InstanceIds=[other_id],
                                  DocumentName="AWS-RunShellScript",
                                  Parameters={"commands": ["true"]})["Command"]["CommandId"]

        assert [c["CommandId"] for c in ssm.list_commands(CommandId=mine)["Commands"]] == [mine]
        by_instance = [c["CommandId"] for c in ssm.list_commands(InstanceId=other_id)["Commands"]]
        assert theirs in by_instance and mine not in by_instance

        # A command id nobody knows narrows the list to nothing; AWS does not call it an error.
        assert ssm.list_commands(CommandId="ffffffff-ffff-ffff-ffff-ffffffffffff")["Commands"] == []

        # AWS resolves the invocation before the command, so this is not InvalidCommandId.
        with pytest.raises(ClientError) as exc:
            ssm.get_command_invocation(CommandId="ffffffff-ffff-ffff-ffff-ffffffffffff",
                                       InstanceId=instance_id)
        assert exc.value.response["Error"]["Code"] == "InvocationDoesNotExist"

        # A real command, but not for that instance: the invocation does not exist.
        with pytest.raises(ClientError) as exc:
            ssm.get_command_invocation(CommandId=mine, InstanceId=other_id)
        assert exc.value.response["Error"]["Code"] == "InvocationDoesNotExist"
    finally:
        ec2.terminate_instances(InstanceIds=[instance_id, other_id])
        ec2.deregister_image(ImageId=ami)


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"),
}


@pytest.fixture
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", None), "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)
            assert {put["Tier"], listed["Tier"]} <= tiers
            ssm.delete_parameter(Name=name)
            if big_tier:
                assert ssm.put_parameter(Name=name, Value=big, Type="String")["Tier"] == big_tier
                ssm.delete_parameter(Name=name)
        # An Advanced parameter stays Advanced when overwritten without a Tier.
        ssm.put_parameter(Name=name, Value="v", Type="String", Tier="Advanced")
        ssm.update_service_setting(SettingId=_TIER, SettingValue="Standard")
        assert ssm.put_parameter(Name=name, Value="w", Type="String", Overwrite=True)["Tier"] == "Advanced"
    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