Skip to content

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

47.0 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
from conftest import inprocess_iam_user, routed_request


def _regional_sm(region_name):
    endpoint = os.environ.get("MINISTACK_ENDPOINT", "http://localhost:4566")
    return boto3.client(
        "secretsmanager",
        endpoint_url=endpoint,
        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_secretsmanager_resource_policy(sm):
    sm.create_secret(Name="sm-pol-sec", SecretString="secret-val")
    policy = json.dumps(
        {
            "Version": "2012-10-17",
            "Statement": [
                {
                    "Effect": "Allow",
                    "Principal": "*",
                    "Action": "secretsmanager:GetSecretValue",
                    "Resource": "*",
                }
            ],
        }
    )
    sm.put_resource_policy(SecretId="sm-pol-sec", ResourcePolicy=policy)
    resp = sm.get_resource_policy(SecretId="sm-pol-sec")
    assert resp["Name"] == "sm-pol-sec"
    assert "ResourcePolicy" in resp
    sm.delete_resource_policy(SecretId="sm-pol-sec")

def test_secretsmanager_validate_resource_policy(sm):
    policy = json.dumps({"Version": "2012-10-17", "Statement": []})
    resp = sm.validate_resource_policy(ResourcePolicy=policy)
    assert resp["PolicyValidationPassed"] is True

def test_secretsmanager_rotate_secret(sm):
    """RotateSecret creates a new version and promotes it to AWSCURRENT."""
    sm.create_secret(Name="rotate-test-v39", SecretString="original")
    resp = sm.rotate_secret(
        SecretId="rotate-test-v39",
        RotationLambdaARN="arn:aws:lambda:us-east-1:000000000000:function:rotator",
        RotationRules={"AutomaticallyAfterDays": 30},
    )
    assert "VersionId" in resp
    desc = sm.describe_secret(SecretId="rotate-test-v39")
    assert desc["RotationEnabled"] is True
    assert desc["RotationLambdaARN"] == "arn:aws:lambda:us-east-1:000000000000:function:rotator"
    current = sm.get_secret_value(SecretId="rotate-test-v39", VersionStage="AWSCURRENT")
    assert current["SecretString"] == "original"
    sm.delete_secret(SecretId="rotate-test-v39", ForceDeleteWithoutRecovery=True)

# Migrated from test_secrets.py
def test_secretsmanager_create_get(sm):
    sm.create_secret(Name="test-secret-1", SecretString='{"user":"admin"}')
    resp = sm.get_secret_value(SecretId="test-secret-1")
    assert json.loads(resp["SecretString"])["user"] == "admin"


def test_secretsmanager_secrets_are_region_scoped_by_name(sm):
    name = f"sm-region-scope-{_uuid_mod.uuid4().hex[:8]}"
    west = _regional_sm("us-west-2")

    east_arn = sm.create_secret(Name=name, SecretString="east")["ARN"]
    west_arn = west.create_secret(Name=name, SecretString="west")["ARN"]

    assert east_arn.startswith("arn:aws:secretsmanager:us-east-1:000000000000:secret:")
    assert west_arn.startswith("arn:aws:secretsmanager:us-west-2:000000000000:secret:")
    assert sm.get_secret_value(SecretId=name)["SecretString"] == "east"
    assert west.get_secret_value(SecretId=name)["SecretString"] == "west"

    east_names = {entry["Name"] for entry in sm.list_secrets()["SecretList"]}
    west_names = {entry["Name"] for entry in west.list_secrets()["SecretList"]}
    assert name in east_names
    assert name in west_names

    with pytest.raises(ClientError) as exc:
        sm.get_secret_value(SecretId=west_arn)
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"


def test_secretsmanager_resource_policies_are_region_scoped(sm):
    name = f"sm-region-policy-{_uuid_mod.uuid4().hex[:8]}"
    west = _regional_sm("us-west-2")
    sm.create_secret(Name=name, SecretString="east")
    west.create_secret(Name=name, SecretString="west")

    east_policy = json.dumps({"Version": "2012-10-17", "Statement": [{"Sid": "east"}]})
    west_policy = json.dumps({"Version": "2012-10-17", "Statement": [{"Sid": "west"}]})
    sm.put_resource_policy(SecretId=name, ResourcePolicy=east_policy)
    west.put_resource_policy(SecretId=name, ResourcePolicy=west_policy)

    assert sm.get_resource_policy(SecretId=name)["ResourcePolicy"] == east_policy
    assert west.get_resource_policy(SecretId=name)["ResourcePolicy"] == west_policy


def test_secretsmanager_replicate_secret_to_regions_creates_target_region_secret(sm):
    name = f"sm-region-replica-{_uuid_mod.uuid4().hex[:8]}"
    west = _regional_sm("us-west-2")

    east_arn = sm.create_secret(Name=name, SecretString="primary")["ARN"]
    resp = sm.replicate_secret_to_regions(
        SecretId=name,
        AddReplicaRegions=[{"Region": "us-west-2", "KmsKeyId": "alias/west-key"}],
    )
    assert resp["ARN"] == east_arn
    assert resp["ReplicationStatus"] == [{
        "Region": "us-west-2",
        "Status": "InSync",
        "StatusMessage": "Replication succeeded (stub).",
        "KmsKeyId": "alias/west-key",
    }]

    replica_value = west.get_secret_value(SecretId=name)
    assert replica_value["SecretString"] == "primary"
    assert replica_value["ARN"].startswith(
        "arn:aws:secretsmanager:us-west-2:000000000000:secret:"
    )
    assert west.describe_secret(SecretId=name)["KmsKeyId"] == "alias/west-key"
    replica_description = west.describe_secret(SecretId=name)
    assert replica_description["PrimaryRegion"] == "us-east-1"
    replica_entries = {
        entry["Name"]: entry
        for entry in west.list_secrets()["SecretList"]
    }
    assert replica_entries[name]["PrimaryRegion"] == "us-east-1"


def test_secretsmanager_replicate_secret_to_regions_requires_force_for_existing_target(sm):
    name = f"sm-region-replica-conflict-{_uuid_mod.uuid4().hex[:8]}"
    west = _regional_sm("us-west-2")
    sm.create_secret(Name=name, SecretString="primary")
    west.create_secret(Name=name, SecretString="independent")

    with pytest.raises(ClientError) as exc:
        sm.replicate_secret_to_regions(
            SecretId=name,
            AddReplicaRegions=[{"Region": "us-west-2"}],
        )
    assert exc.value.response["Error"]["Code"] == "ResourceExistsException"
    assert west.get_secret_value(SecretId=name)["SecretString"] == "independent"

    sm.replicate_secret_to_regions(
        SecretId=name,
        AddReplicaRegions=[{"Region": "us-west-2"}],
        ForceOverwriteReplicaSecret=True,
    )
    assert west.get_secret_value(SecretId=name)["SecretString"] == "primary"


def test_secretsmanager_replicate_secret_to_regions_rejects_source_region(sm):
    name = f"sm-region-replica-source-{_uuid_mod.uuid4().hex[:8]}"
    sm.create_secret(Name=name, SecretString="primary")

    with pytest.raises(ClientError) as exc:
        sm.replicate_secret_to_regions(
            SecretId=name,
            AddReplicaRegions=[{"Region": "us-east-1"}],
        )
    assert exc.value.response["Error"]["Code"] == "InvalidParameterException"
    assert "ReplicationStatus" not in sm.describe_secret(SecretId=name)


def test_secretsmanager_replicate_secret_to_regions_does_not_partially_write(sm):
    name = f"sm-region-replica-partial-{_uuid_mod.uuid4().hex[:8]}"
    west = _regional_sm("us-west-2")
    sm.create_secret(Name=name, SecretString="primary")

    with pytest.raises(ClientError) as exc:
        sm.replicate_secret_to_regions(
            SecretId=name,
            AddReplicaRegions=[
                {"Region": "us-west-2"},
                {"Region": "us-east-1"},
            ],
        )
    assert exc.value.response["Error"]["Code"] == "InvalidParameterException"
    assert "ReplicationStatus" not in sm.describe_secret(SecretId=name)
    with pytest.raises(ClientError) as missing:
        west.get_secret_value(SecretId=name)
    assert missing.value.response["Error"]["Code"] == "ResourceNotFoundException"


def test_secretsmanager_replicate_secret_to_regions_does_not_copy_primary_kms(sm):
    name = f"sm-region-replica-kms-{_uuid_mod.uuid4().hex[:8]}"
    west = _regional_sm("us-west-2")
    sm.create_secret(Name=name, SecretString="primary", KmsKeyId="alias/source-key")

    sm.replicate_secret_to_regions(
        SecretId=name,
        AddReplicaRegions=[{"Region": "us-west-2"}],
    )

    assert "KmsKeyId" not in west.describe_secret(SecretId=name)


def test_secretsmanager_replicated_secret_versions_stay_in_sync(sm):
    name = f"sm-region-replica-sync-{_uuid_mod.uuid4().hex[:8]}"
    west = _regional_sm("us-west-2")
    sm.create_secret(Name=name, SecretString="primary")
    sm.replicate_secret_to_regions(
        SecretId=name,
        AddReplicaRegions=[{"Region": "us-west-2"}],
    )

    sm.update_secret(SecretId=name, SecretString="updated")
    assert west.get_secret_value(SecretId=name)["SecretString"] == "updated"

    sm.put_secret_value(SecretId=name, SecretString="put-value")
    assert west.get_secret_value(SecretId=name)["SecretString"] == "put-value"

    token = _uuid_mod.uuid4().hex
    sm.rotate_secret(SecretId=name, ClientRequestToken=token)
    replica_stages = west.describe_secret(SecretId=name)["VersionIdsToStages"]
    assert replica_stages[token] == ["AWSCURRENT"]


def test_secretsmanager_replica_rejects_direct_mutation(sm):
    name = f"sm-region-replica-readonly-{_uuid_mod.uuid4().hex[:8]}"
    west = _regional_sm("us-west-2")
    sm.create_secret(Name=name, SecretString="primary")
    sm.replicate_secret_to_regions(
        SecretId=name,
        AddReplicaRegions=[{"Region": "us-west-2"}],
    )

    with pytest.raises(ClientError) as exc:
        west.put_secret_value(SecretId=name, SecretString="west-only")
    assert exc.value.response["Error"]["Code"] == "InvalidRequestException"
    assert west.get_secret_value(SecretId=name)["SecretString"] == "primary"


def test_secretsmanager_primary_force_delete_removes_replicas(sm):
    name = f"sm-region-replica-delete-{_uuid_mod.uuid4().hex[:8]}"
    west = _regional_sm("us-west-2")
    sm.create_secret(Name=name, SecretString="primary")
    sm.replicate_secret_to_regions(
        SecretId=name,
        AddReplicaRegions=[{"Region": "us-west-2"}],
    )

    sm.delete_secret(SecretId=name, ForceDeleteWithoutRecovery=True)

    with pytest.raises(ClientError) as exc:
        west.get_secret_value(SecretId=name)
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"


def test_secretsmanager_primary_force_delete_removes_replica_policy(sm):
    from ministack.services import secretsmanager as _sm

    name = f"sm-region-replica-policy-delete-{_uuid_mod.uuid4().hex[:8]}"
    west = _regional_sm("us-west-2")
    sm.create_secret(Name=name, SecretString="primary")
    sm.replicate_secret_to_regions(
        SecretId=name,
        AddReplicaRegions=[{"Region": "us-west-2"}],
    )
    west_arn = west.describe_secret(SecretId=name)["ARN"]
    west.put_resource_policy(
        SecretId=name,
        ResourcePolicy=json.dumps({"Version": "2012-10-17", "Statement": []}),
    )

    sm.delete_secret(SecretId=name, ForceDeleteWithoutRecovery=True)

    assert _sm._resource_policies.get_scoped("000000000000", "us-west-2", west_arn) is None


def test_secretsmanager_replica_cannot_be_replicated(sm):
    name = f"sm-region-replica-chain-{_uuid_mod.uuid4().hex[:8]}"
    west = _regional_sm("us-west-2")
    east_2 = _regional_sm("us-east-2")
    sm.create_secret(Name=name, SecretString="primary")
    sm.replicate_secret_to_regions(
        SecretId=name,
        AddReplicaRegions=[{"Region": "us-west-2"}],
    )

    with pytest.raises(ClientError) as exc:
        west.replicate_secret_to_regions(
            SecretId=name,
            AddReplicaRegions=[{"Region": "us-east-2"}],
        )
    assert exc.value.response["Error"]["Code"] == "InvalidRequestException"
    with pytest.raises(ClientError) as missing:
        east_2.get_secret_value(SecretId=name)
    assert missing.value.response["Error"]["Code"] == "ResourceNotFoundException"


def test_secretsmanager_deleted_secret_cannot_be_replicated(sm):
    name = f"sm-region-replica-deleted-{_uuid_mod.uuid4().hex[:8]}"
    west = _regional_sm("us-west-2")
    sm.create_secret(Name=name, SecretString="primary")
    sm.delete_secret(SecretId=name, RecoveryWindowInDays=7)

    with pytest.raises(ClientError) as exc:
        sm.replicate_secret_to_regions(
            SecretId=name,
            AddReplicaRegions=[{"Region": "us-west-2"}],
        )
    assert exc.value.response["Error"]["Code"] == "InvalidRequestException"
    with pytest.raises(ClientError) as missing:
        west.get_secret_value(SecretId=name)
    assert missing.value.response["Error"]["Code"] == "ResourceNotFoundException"


def test_secretsmanager_force_overwrite_removes_target_policy(sm):
    from ministack.services import secretsmanager as _sm

    name = f"sm-region-replica-overwrite-policy-{_uuid_mod.uuid4().hex[:8]}"
    west = _regional_sm("us-west-2")
    sm.create_secret(Name=name, SecretString="primary")
    old_west_arn = west.create_secret(Name=name, SecretString="independent")["ARN"]
    west.put_resource_policy(
        SecretId=name,
        ResourcePolicy=json.dumps({"Version": "2012-10-17", "Statement": []}),
    )

    sm.replicate_secret_to_regions(
        SecretId=name,
        AddReplicaRegions=[{"Region": "us-west-2"}],
        ForceOverwriteReplicaSecret=True,
    )

    assert _sm._resource_policies.get_scoped("000000000000", "us-west-2", old_west_arn) is None


def test_secretsmanager_replicate_secret_to_regions_copies_resource_policy(sm):
    name = f"sm-region-replica-policy-{_uuid_mod.uuid4().hex[:8]}"
    west = _regional_sm("us-west-2")
    policy = json.dumps({"Version": "2012-10-17", "Statement": [{"Sid": "source"}]})
    sm.create_secret(Name=name, SecretString="primary")
    sm.put_resource_policy(SecretId=name, ResourcePolicy=policy)

    sm.replicate_secret_to_regions(
        SecretId=name,
        AddReplicaRegions=[{"Region": "us-west-2"}],
    )

    assert west.get_resource_policy(SecretId=name)["ResourcePolicy"] == policy


def test_secretsmanager_replica_resource_policy_stays_in_sync(sm):
    name = f"sm-region-replica-policy-sync-{_uuid_mod.uuid4().hex[:8]}"
    west = _regional_sm("us-west-2")
    sm.create_secret(Name=name, SecretString="primary")
    sm.replicate_secret_to_regions(
        SecretId=name,
        AddReplicaRegions=[{"Region": "us-west-2"}],
    )

    first_policy = json.dumps({"Version": "2012-10-17", "Statement": [{"Sid": "first"}]})
    second_policy = json.dumps({"Version": "2012-10-17", "Statement": [{"Sid": "second"}]})
    sm.put_resource_policy(SecretId=name, ResourcePolicy=first_policy)
    assert west.get_resource_policy(SecretId=name)["ResourcePolicy"] == first_policy

    sm.put_resource_policy(SecretId=name, ResourcePolicy=second_policy)
    assert west.get_resource_policy(SecretId=name)["ResourcePolicy"] == second_policy

    sm.delete_resource_policy(SecretId=name)
    assert "ResourcePolicy" not in west.get_resource_policy(SecretId=name)


def test_secretsmanager_replicate_secret_to_regions_preserves_replica_kms(sm):
    name = f"sm-region-replica-kms-repeat-{_uuid_mod.uuid4().hex[:8]}"
    west = _regional_sm("us-west-2")
    sm.create_secret(Name=name, SecretString="primary")
    sm.replicate_secret_to_regions(
        SecretId=name,
        AddReplicaRegions=[{"Region": "us-west-2", "KmsKeyId": "alias/west-key"}],
    )

    resp = sm.replicate_secret_to_regions(
        SecretId=name,
        AddReplicaRegions=[{"Region": "us-west-2"}],
    )

    assert west.describe_secret(SecretId=name)["KmsKeyId"] == "alias/west-key"
    assert resp["ReplicationStatus"] == [{
        "Region": "us-west-2",
        "Status": "InSync",
        "StatusMessage": "Replication succeeded (stub).",
        "KmsKeyId": "alias/west-key",
    }]


def test_secretsmanager_force_overwrite_transfers_replica_ownership(sm):
    name = f"sm-region-replica-owner-{_uuid_mod.uuid4().hex[:8]}"
    east_2 = _regional_sm("us-east-2")
    west = _regional_sm("us-west-2")
    sm.create_secret(Name=name, SecretString="east-primary")
    east_2.create_secret(Name=name, SecretString="east2-primary")
    sm.replicate_secret_to_regions(
        SecretId=name,
        AddReplicaRegions=[{"Region": "us-west-2"}],
    )
    east_2.replicate_secret_to_regions(
        SecretId=name,
        AddReplicaRegions=[{"Region": "us-west-2"}],
        ForceOverwriteReplicaSecret=True,
    )
    assert not sm.describe_secret(SecretId=name).get("ReplicationStatus")

    sm.update_secret(SecretId=name, SecretString="old-primary-update")
    assert west.get_secret_value(SecretId=name)["SecretString"] == "east2-primary"

    sm.delete_secret(SecretId=name, ForceDeleteWithoutRecovery=True)
    assert west.get_secret_value(SecretId=name)["SecretString"] == "east2-primary"

    east_2.update_secret(SecretId=name, SecretString="new-primary-update")
    assert west.get_secret_value(SecretId=name)["SecretString"] == "new-primary-update"


def test_secretsmanager_force_overwrite_cleans_up_overwritten_primary_replicas(sm):
    name = f"sm-region-replica-overwrite-primary-{_uuid_mod.uuid4().hex[:8]}"
    west = _regional_sm("us-west-2")
    eu_west_1 = _regional_sm("eu-west-1")
    sm.create_secret(Name=name, SecretString="east-primary")
    west.create_secret(Name=name, SecretString="west-primary")
    west.replicate_secret_to_regions(
        SecretId=name,
        AddReplicaRegions=[{"Region": "eu-west-1"}],
    )

    sm.replicate_secret_to_regions(
        SecretId=name,
        AddReplicaRegions=[{"Region": "us-west-2"}],
        ForceOverwriteReplicaSecret=True,
    )

    with pytest.raises(ClientError) as missing:
        eu_west_1.get_secret_value(SecretId=name)
    assert missing.value.response["Error"]["Code"] == "ResourceNotFoundException"


def test_secretsmanager_self_region_replication_status_does_not_mark_primary_replica():
    from ministack.core.responses import get_region, set_request_region
    from ministack.services import secretsmanager as _sm

    original_region = get_region()
    name = f"sm-region-replica-self-status-{_uuid_mod.uuid4().hex[:8]}"
    _sm.reset()
    set_request_region("us-east-1")
    try:
        _sm._create_secret({"Name": name, "SecretString": "primary"})
        secret = _sm._secrets.get(name)
        secret["ReplicationStatus"] = [{
            "Region": "us-east-1",
            "Status": "InSync",
            "StatusMessage": "legacy self-region status",
        }]

        _sm._update_secret({"SecretId": name, "SecretString": "updated"})

        secret = _sm._secrets.get(name)
        assert "_PrimarySecretArn" not in secret
        status, _, body = _sm._describe_secret({"SecretId": name})
        assert status == 200
        assert "PrimaryRegion" not in json.loads(body)
        status, _, body = _sm._get_secret_value({"SecretId": name})
        assert status == 200
        assert json.loads(body)["SecretString"] == "updated"
    finally:
        _sm.reset()
        set_request_region(original_region)


def test_secretsmanager_update_list(sm):
    sm.create_secret(Name="test-secret-2", SecretString="original")
    sm.update_secret(SecretId="test-secret-2", SecretString="updated")
    resp = sm.get_secret_value(SecretId="test-secret-2")
    assert resp["SecretString"] == "updated"
    listed = sm.list_secrets()
    assert any(s["Name"] == "test-secret-2" for s in listed["SecretList"])

def test_secretsmanager_create_get_v2(sm):
    sm.create_secret(Name="sm-cg-v2", SecretString='{"user":"admin","pass":"s3cr3t"}')
    resp = sm.get_secret_value(SecretId="sm-cg-v2")
    parsed = json.loads(resp["SecretString"])
    assert parsed["user"] == "admin"
    assert parsed["pass"] == "s3cr3t"
    assert "VersionId" in resp
    assert "ARN" in resp

    sm.create_secret(Name="sm-cg-bin", SecretBinary=b"\x00\x01\x02")
    resp_bin = sm.get_secret_value(SecretId="sm-cg-bin")
    assert resp_bin["SecretBinary"] == b"\x00\x01\x02"

def test_secretsmanager_update_v2(sm):
    sm.create_secret(Name="sm-upd-v2", SecretString="original")
    sm.update_secret(SecretId="sm-upd-v2", SecretString="updated", Description="new desc")
    resp = sm.get_secret_value(SecretId="sm-upd-v2")
    assert resp["SecretString"] == "updated"
    desc = sm.describe_secret(SecretId="sm-upd-v2")
    assert desc["Description"] == "new desc"

def test_secretsmanager_list_v2(sm):
    sm.create_secret(Name="sm-list-a", SecretString="a")
    sm.create_secret(Name="sm-list-b", SecretString="b")
    listed = sm.list_secrets()
    names = [s["Name"] for s in listed["SecretList"]]
    assert "sm-list-a" in names
    assert "sm-list-b" in names

def test_secretsmanager_delete_v2(sm):
    sm.create_secret(Name="sm-del-v2", SecretString="gone")
    sm.delete_secret(SecretId="sm-del-v2", ForceDeleteWithoutRecovery=True)
    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")
    sm.delete_secret(SecretId="sm-del-rec", RecoveryWindowInDays=7)
    with pytest.raises(ClientError) as exc:
        sm.get_secret_value(SecretId="sm-del-rec")
    assert (
        "marked for deletion" in exc.value.response["Error"]["Message"].lower()
        or exc.value.response["Error"]["Code"] == "InvalidRequestException"
    )
    desc = sm.describe_secret(SecretId="sm-del-rec")
    assert "DeletedDate" in desc

    sm.restore_secret(SecretId="sm-del-rec")
    resp = sm.get_secret_value(SecretId="sm-del-rec")
    assert resp["SecretString"] == "recoverable"

def test_secretsmanager_force_delete_secret_scheduled_for_deletion(sm):
    name = f"sm-force-pending-{_uuid_mod.uuid4().hex[:8]}"
    arn = sm.create_secret(Name=name, SecretString="v")["ARN"]
    sm.delete_secret(SecretId=name, RecoveryWindowInDays=7)

    resp = sm.delete_secret(SecretId=name, ForceDeleteWithoutRecovery=True)
    assert resp["ARN"] == arn
    assert resp["Name"] == name
    with pytest.raises(ClientError) as exc:
        sm.describe_secret(SecretId=name)
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"
    sm.create_secret(Name=name, SecretString="reused")
    assert sm.get_secret_value(SecretId=name)["SecretString"] == "reused"
    sm.delete_secret(SecretId=name, ForceDeleteWithoutRecovery=True)

def test_secretsmanager_delete_secret_scheduled_for_deletion_without_force(sm):
    name = f"sm-delete-pending-{_uuid_mod.uuid4().hex[:8]}"
    sm.create_secret(Name=name, SecretString="v")
    sm.delete_secret(SecretId=name, RecoveryWindowInDays=7)

    with pytest.raises(ClientError) as exc:
        sm.delete_secret(SecretId=name, RecoveryWindowInDays=7)
    assert exc.value.response["Error"]["Code"] == "InvalidRequestException"
    assert "DeletedDate" in sm.describe_secret(SecretId=name)
    sm.delete_secret(SecretId=name, ForceDeleteWithoutRecovery=True)

def test_secretsmanager_put_value_version_stages_v2(sm):
    sm.create_secret(Name="sm-pvs-v2", SecretString="v1")
    sm.put_secret_value(SecretId="sm-pvs-v2", SecretString="v2")

    desc = sm.describe_secret(SecretId="sm-pvs-v2")
    stages = desc["VersionIdsToStages"]
    current_vids = [vid for vid, s in stages.items() if "AWSCURRENT" in s]
    previous_vids = [vid for vid, s in stages.items() if "AWSPREVIOUS" in s]
    assert len(current_vids) == 1
    assert len(previous_vids) == 1
    assert current_vids[0] != previous_vids[0]

    cur = sm.get_secret_value(SecretId="sm-pvs-v2", VersionStage="AWSCURRENT")
    assert cur["SecretString"] == "v2"
    prev = sm.get_secret_value(SecretId="sm-pvs-v2", VersionStage="AWSPREVIOUS")
    assert prev["SecretString"] == "v1"

def test_secretsmanager_describe_v2(sm):
    sm.create_secret(
        Name="sm-dsc-v2",
        SecretString="val",
        Description="detailed desc",
        Tags=[{"Key": "Env", "Value": "dev"}],
    )
    resp = sm.describe_secret(SecretId="sm-dsc-v2")
    assert resp["Name"] == "sm-dsc-v2"
    assert resp["Description"] == "detailed desc"
    assert any(t["Key"] == "Env" for t in resp["Tags"])
    assert "VersionIdsToStages" in resp
    assert "ARN" in resp

def test_secretsmanager_tags_v2(sm):
    sm.create_secret(Name="sm-tag-v2", SecretString="val")
    sm.tag_resource(SecretId="sm-tag-v2", Tags=[{"Key": "team", "Value": "backend"}])
    sm.tag_resource(SecretId="sm-tag-v2", Tags=[{"Key": "env", "Value": "prod"}])

    desc = sm.describe_secret(SecretId="sm-tag-v2")
    assert any(t["Key"] == "team" and t["Value"] == "backend" for t in desc["Tags"])
    assert any(t["Key"] == "env" and t["Value"] == "prod" for t in desc["Tags"])

    sm.untag_resource(SecretId="sm-tag-v2", TagKeys=["team"])
    desc2 = sm.describe_secret(SecretId="sm-tag-v2")
    assert not any(t["Key"] == "team" for t in desc2.get("Tags", []))
    assert any(t["Key"] == "env" for t in desc2.get("Tags", []))

def test_secretsmanager_get_random_password_v2(sm):
    resp = sm.get_random_password(PasswordLength=32)
    assert len(resp["RandomPassword"]) == 32

    resp2 = sm.get_random_password(PasswordLength=20, ExcludeCharacters="aeiou")
    pw = resp2["RandomPassword"]
    assert len(pw) == 20
    for c in "aeiou":
        assert c not in pw


# Migrated from test_sm.py
def test_secretsmanager_put_secret_value_stages(sm):
    """PutSecretValue stages manage AWSCURRENT/AWSPREVIOUS correctly."""
    sm.create_secret(Name="qa-sm-stages", SecretString="v1")
    sm.put_secret_value(SecretId="qa-sm-stages", SecretString="v2")
    sm.put_secret_value(SecretId="qa-sm-stages", SecretString="v3")
    current = sm.get_secret_value(SecretId="qa-sm-stages", VersionStage="AWSCURRENT")
    assert current["SecretString"] == "v3"
    previous = sm.get_secret_value(SecretId="qa-sm-stages", VersionStage="AWSPREVIOUS")
    assert previous["SecretString"] == "v2"

def test_secretsmanager_list_secret_version_ids(sm):
    """ListSecretVersionIds returns all versions."""
    sm.create_secret(Name="qa-sm-versions", SecretString="initial")
    sm.put_secret_value(SecretId="qa-sm-versions", SecretString="second")
    resp = sm.list_secret_version_ids(SecretId="qa-sm-versions")
    assert len(resp["Versions"]) >= 2

def test_secretsmanager_update_secret_version_stage_moves_current(sm):
    """UpdateSecretVersionStage can move AWSCURRENT and refresh AWSPREVIOUS."""
    first = sm.create_secret(Name="qa-sm-stage-move-current", SecretString="v1")
    first_vid = first["VersionId"]
    second_vid = "22222222-2222-2222-2222-222222222222"
    sm.put_secret_value(
        SecretId="qa-sm-stage-move-current",
        SecretString="v2",
        ClientRequestToken=second_vid,
    )

    sm.update_secret_version_stage(
        SecretId="qa-sm-stage-move-current",
        VersionStage="AWSCURRENT",
        RemoveFromVersionId=second_vid,
        MoveToVersionId=first_vid,
    )

    current = sm.get_secret_value(SecretId="qa-sm-stage-move-current", VersionStage="AWSCURRENT")
    assert current["SecretString"] == "v1"
    previous = sm.get_secret_value(SecretId="qa-sm-stage-move-current", VersionStage="AWSPREVIOUS")
    assert previous["SecretString"] == "v2"

    versions = sm.list_secret_version_ids(SecretId="qa-sm-stage-move-current")["Versions"]
    version_stages = {v["VersionId"]: set(v["VersionStages"]) for v in versions}
    assert version_stages[first_vid] == {"AWSCURRENT"}
    assert version_stages[second_vid] == {"AWSPREVIOUS"}

def test_secretsmanager_update_secret_version_stage_moves_and_removes_custom_label(sm):
    """UpdateSecretVersionStage can move a custom label and then detach it."""
    first = sm.create_secret(Name="qa-sm-stage-custom", SecretString="v1")
    first_vid = first["VersionId"]
    second_vid = "33333333-3333-3333-3333-333333333333"
    sm.put_secret_value(
        SecretId="qa-sm-stage-custom",
        SecretString="v2",
        ClientRequestToken=second_vid,
        VersionStages=["BLUE"],
    )

    before = sm.get_secret_value(SecretId="qa-sm-stage-custom", VersionStage="BLUE")
    assert before["SecretString"] == "v2"

    sm.update_secret_version_stage(
        SecretId="qa-sm-stage-custom",
        VersionStage="BLUE",
        RemoveFromVersionId=second_vid,
        MoveToVersionId=first_vid,
    )

    moved = sm.get_secret_value(SecretId="qa-sm-stage-custom", VersionStage="BLUE")
    assert moved["SecretString"] == "v1"

    sm.update_secret_version_stage(
        SecretId="qa-sm-stage-custom",
        VersionStage="BLUE",
        RemoveFromVersionId=first_vid,
    )

    versions = sm.list_secret_version_ids(SecretId="qa-sm-stage-custom")["Versions"]
    version_stages = {v["VersionId"]: set(v["VersionStages"]) for v in versions}
    assert "BLUE" not in version_stages[first_vid]
    assert "BLUE" not in version_stages[second_vid]

    with pytest.raises(ClientError) as exc:
        sm.get_secret_value(SecretId="qa-sm-stage-custom", VersionStage="BLUE")
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"

def test_secretsmanager_update_secret_version_stage_requires_matching_remove_version(sm):
    """Moving an attached label requires RemoveFromVersionId to match the current owner."""
    first = sm.create_secret(Name="qa-sm-stage-guard", SecretString="v1")
    first_vid = first["VersionId"]
    second_vid = "44444444-4444-4444-4444-444444444444"
    sm.put_secret_value(
        SecretId="qa-sm-stage-guard",
        SecretString="v2",
        ClientRequestToken=second_vid,
    )

    with pytest.raises(ClientError) as exc:
        sm.update_secret_version_stage(
            SecretId="qa-sm-stage-guard",
            VersionStage="AWSCURRENT",
            MoveToVersionId=first_vid,
        )
    assert exc.value.response["Error"]["Code"] == "InvalidParameterException"

def test_secretsmanager_delete_and_restore(sm):
    """DeleteSecret schedules deletion; RestoreSecret cancels it."""
    sm.create_secret(Name="qa-sm-restore", SecretString="data")
    sm.delete_secret(SecretId="qa-sm-restore", RecoveryWindowInDays=7)
    with pytest.raises(ClientError) as exc:
        sm.get_secret_value(SecretId="qa-sm-restore")
    assert exc.value.response["Error"]["Code"] == "InvalidRequestException"
    sm.restore_secret(SecretId="qa-sm-restore")
    val = sm.get_secret_value(SecretId="qa-sm-restore")
    assert val["SecretString"] == "data"

def test_secretsmanager_get_random_password(sm):
    """GetRandomPassword returns a password of the requested length."""
    resp = sm.get_random_password(PasswordLength=24, ExcludeNumbers=True)
    pwd = resp["RandomPassword"]
    assert len(pwd) == 24
    assert not any(c.isdigit() for c in pwd)

def test_secretsmanager_batch_get_secret_value(sm):
    sm.create_secret(Name="batch-s1", SecretString="val1")
    sm.create_secret(Name="batch-s2", SecretString="val2")
    resp = sm.batch_get_secret_value(SecretIdList=["batch-s1", "batch-s2"])
    assert len(resp["SecretValues"]) == 2
    names = {s["Name"] for s in resp["SecretValues"]}
    assert "batch-s1" in names
    assert "batch-s2" in names
    assert len(resp.get("Errors", [])) == 0

def test_secretsmanager_batch_get_secret_value_with_missing(sm):
    resp = sm.batch_get_secret_value(SecretIdList=["batch-s1", "nonexistent-secret"])
    assert len(resp["SecretValues"]) == 1
    assert len(resp["Errors"]) == 1
    assert resp["Errors"][0]["SecretId"] == "nonexistent-secret"


# ---------------------------------------------------------------------------
# BatchGetSecretValue checks GetSecretValue per secret, ListSecrets for Filters
# ---------------------------------------------------------------------------

_BGSV_USER = "bgsv-user"
_BGSV_KEY = "AKIABGSVTESTUSER0001"
_BGSV_BATCH = {"Effect": "Allow", "Action": "secretsmanager:BatchGetSecretValue", "Resource": "*"}
_BGSV_GET_A = {"Effect": "Allow", "Action": "secretsmanager:GetSecretValue", "Resource": "{A}"}
_BGSV_LIST = {"Effect": "Allow", "Action": "secretsmanager:ListSecrets", "Resource": "*"}
_BGSV_FILTER = {"Filters": [{"Key": "name", "Values": ["bgsv-probe-"]}]}


def _bgsv_denied(action, resource=None):
    on = f" on resource: {resource}" if resource else ""
    return (f"User: arn:aws:iam::000000000000:user/{_BGSV_USER} is not authorized to perform: "
            f"{action}{on} because no identity-based policy allows the {action} action")


@pytest.mark.parametrize("auth_enabled, statements, request_body, values, errors, denied", [
    pytest.param(True, [_BGSV_BATCH, _BGSV_GET_A], {"SecretIdList": ["{a}", "{b}"]}, ["{a}"],
                 [("{b}", "AccessDeniedException")], None, id="names"),
    pytest.param(True, [_BGSV_BATCH, _BGSV_GET_A], {"SecretIdList": ["{A}", "{B}"]}, ["{a}"],
                 [("{B}", "AccessDeniedException")], None, id="arns"),
    pytest.param(True, [_BGSV_BATCH, _BGSV_GET_A], _BGSV_FILTER, None, None,
                 "secretsmanager:ListSecrets", id="filters-without-list"),
    pytest.param(True, [_BGSV_BATCH, _BGSV_GET_A, _BGSV_LIST], _BGSV_FILTER, ["{a}"],
                 [("{B}", "AccessDeniedException")], None, id="filters-with-list"),
    pytest.param(True, [dict(_BGSV_GET_A, Resource=["{A}", "{B}"])], {"SecretIdList": ["{a}"]}, None, None,
                 "secretsmanager:BatchGetSecretValue", id="no-batch-grant"),
    pytest.param(True, [_BGSV_BATCH, dict(_BGSV_GET_A, Resource="*")], {"SecretIdList": ["{a}", "bgsv-missing"]},
                 ["{a}"], [("bgsv-missing", "ResourceNotFoundException")], None, id="missing"),
    pytest.param(False, [], _BGSV_FILTER, ["{a}", "{b}"], [], None, id="no-auth-filters"),
])
def test_secretsmanager_batch_get_secret_value_authorizes_each_secret(
        monkeypatch, auth_enabled, statements, request_body, values, errors, denied):
    import asyncio

    from ministack import app as app_mod
    from ministack.core.responses import request_scope
    from ministack.services import iam as iam_svc
    from ministack.services import secretsmanager as sm_svc

    account = "000000000000"
    monkeypatch.setattr(app_mod, "AUTH", auth_enabled)
    names = {"a": "bgsv-probe-a", "b": "bgsv-probe-b", "c": "bgsv-other"}
    with request_scope(account, "us-east-1"):
        arns = {k.upper(): json.loads(sm_svc._create_secret({"Name": n, "SecretString": n})[2])["ARN"]
                for k, n in names.items()}
        fill = {**names, **arns}

        def render(value):
            text = json.dumps(value)
            for placeholder, real in fill.items():
                text = text.replace(f"{{{placeholder}}}", real)
            return json.loads(text)

        iam_svc._users.set_scoped(account, None, _BGSV_USER, {
            "UserName": _BGSV_USER, "UserId": "AIDABGSVTESTUSER", "AttachedPolicies": [],
            "Arn": f"arn:aws:iam::{account}:user/{_BGSV_USER}",
        })
        iam_svc._user_inline_policies[_BGSV_USER] = {"p": {"Statement": render(statements)}}
        iam_svc._access_keys.set_scoped(account, None, _BGSV_KEY, {
            "AccessKeyId": _BGSV_KEY, "SecretAccessKey": "secret", "Status": "Active", "UserName": _BGSV_USER,
        })
        try:
            status, _, payload = asyncio.run(app_mod._dispatch_service_request(
                "POST", "/", {
                    "host": "secretsmanager.us-east-1.localhost",
                    "authorization": f"AWS4-HMAC-SHA256 Credential={_BGSV_KEY}/20260915/us-east-1/secretsmanager/aws4_request",
                    "content-type": "application/x-amz-json-1.1",
                    "x-amz-target": "secretsmanager.BatchGetSecretValue",
                }, json.dumps(render(request_body)).encode(), {}, "req-1",
            ))
        finally:
            iam_svc._access_keys.pop_scoped(account, None, _BGSV_KEY, None)
            iam_svc._user_inline_policies.pop(_BGSV_USER, None)
            iam_svc._users.pop_scoped(account, None, _BGSV_USER, None)
            for name in names.values():
                sm_svc._secrets.pop(name, None)
    body = json.loads(payload)
    if denied:
        assert body["__type"] == "AccessDeniedException"
        assert body["message"] == _bgsv_denied(denied)
        return
    assert status == 200
    assert [v["Name"] for v in body["SecretValues"]] == render(values)
    expected_errors = [(render(sid), code) for sid, code in errors]
    assert [(e["SecretId"], e["ErrorCode"]) for e in body["Errors"]] == expected_errors
    for (sid, code), error in zip(expected_errors, body["Errors"]):
        if code == "AccessDeniedException":
            assert error["Message"] == _bgsv_denied("secretsmanager:GetSecretValue", sid)

def test_secretsmanager_kms_key_id_on_create_and_describe(sm):
    sm.create_secret(Name="kms-test-secret", SecretString="val", KmsKeyId="alias/my-key")
    resp = sm.describe_secret(SecretId="kms-test-secret")
    assert resp["KmsKeyId"] == "alias/my-key"

def test_secretsmanager_kms_key_id_on_update(sm):
    sm.update_secret(SecretId="kms-test-secret", KmsKeyId="alias/other-key")
    resp = sm.describe_secret(SecretId="kms-test-secret")
    assert resp["KmsKeyId"] == "alias/other-key"


def test_secretsmanager_get_by_partial_arn(sm):
    """GetSecretValue with a partial ARN (no random suffix) must resolve the secret."""
    import uuid as _uuid
    name = f"partial-arn-test/{_uuid.uuid4().hex[:8]}"
    created = sm.create_secret(Name=name, SecretString="partial-arn-value")
    full_arn = created["ARN"]

    # Full ARN works
    assert sm.get_secret_value(SecretId=full_arn)["SecretString"] == "partial-arn-value"

    # Partial ARN: strip the random suffix (last hyphen + 6 chars)
    partial_arn = full_arn.rsplit("-", 1)[0]
    assert partial_arn != full_arn
    assert sm.get_secret_value(SecretId=partial_arn)["SecretString"] == "partial-arn-value"


def test_secretsmanager_arn_lookup_rejects_foreign_scope_without_name_fallback(sm):
    """SecretId ARNs must be parsed before matching same-named local secrets."""
    name = f"sm-arn-scope-{_uuid_mod.uuid4().hex[:8]}"
    arn = sm.create_secret(Name=name, SecretString="scoped-value")["ARN"]
    partial_arn = arn.rsplit("-", 1)[0]

    assert sm.get_secret_value(SecretId=arn)["SecretString"] == "scoped-value"
    assert sm.get_secret_value(SecretId=partial_arn)["SecretString"] == "scoped-value"

    wrong_region_arn = arn.replace(":us-east-1:", ":us-west-2:")
    wrong_account_arn = arn.replace(":000000000000:", ":111111111111:")
    wrong_service_arn = arn.replace(":secretsmanager:", ":sqs:")
    wrong_region_partial = partial_arn.replace(":us-east-1:", ":us-west-2:")

    for bad_arn in (
        wrong_region_arn,
        wrong_account_arn,
        wrong_service_arn,
        wrong_region_partial,
    ):
        with pytest.raises(ClientError) as exc:
            sm.get_secret_value(SecretId=bad_arn)
        assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"

    west = _regional_sm("us-west-2")
    west_arn = west.create_secret(
        Name=f"{name}-west",
        SecretString="west-scoped-value",
    )["ARN"]
    with pytest.raises(ClientError) as exc:
        sm.get_secret_value(SecretId=west_arn)
    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"


def test_secretsmanager_list_include_planned_deletion(sm):
    """ListSecrets honors IncludePlannedDeletion per the AWS SecretListEntry spec.

    When a secret is soft-deleted (scheduled for deletion with a recovery
    window), it must:
      - be hidden from ListSecrets by default, and
      - be returned by ListSecrets(IncludePlannedDeletion=True) with its
        DeletedDate populated so clients can distinguish it.
    """
    sm.create_secret(Name="sm-list-pd", SecretString="soft")
    sm.delete_secret(SecretId="sm-list-pd", RecoveryWindowInDays=7)

    # Default: soft-deleted secret is hidden.
    names = [s["Name"] for s in sm.list_secrets()["SecretList"]]
    assert "sm-list-pd" not in names

    # IncludePlannedDeletion=True: soft-deleted secret is visible with DeletedDate.
    resp = sm.list_secrets(IncludePlannedDeletion=True)
    entry = next((s for s in resp["SecretList"] if s["Name"] == "sm-list-pd"), None)
    assert entry is not None
    assert "DeletedDate" in entry



# ========== from test_misc_medium_low_fixes.py ==========
# ForceDeleteWithoutRecovery must clean up the orphan _resource_policies[arn]
# entry, not just the _secrets[name] entry. Tests the in-process module
# directly so it can observe both dicts together.

import asyncio as _sm_asyncio
import importlib as _sm_importlib
import json as _sm_json


def _sm_invoke_action(mod, action, params):
    """Run a service module's action handler synchronously, return raw JSON body."""
    headers = {"x-amz-target": f"secretsmanager.{action}"}
    body = _sm_json.dumps(params).encode()
    status, _resp_headers, resp_body = _sm_asyncio.run(
        mod.handle_request("POST", "/", headers, body, {})
    )
    if status >= 300:
        raise AssertionError(f"{action} failed: {status} {resp_body!r}")
    return resp_body.decode() if isinstance(resp_body, bytes) else resp_body


def test_secretsmanager_force_delete_removes_resource_policy():
    sm = _sm_importlib.import_module("ministack.services.secretsmanager")
    sm.reset()

    create_resp = _sm_json.loads(_sm_invoke_action(
        sm, "CreateSecret",
        {"Name": "force-delete-canary", "SecretString": "x"},
    ))
    arn = create_resp["ARN"]
    _sm_invoke_action(sm, "PutResourcePolicy", {
        "SecretId": arn,
        "ResourcePolicy": '{"Version":"2012-10-17","Statement":[]}',
    })
    assert arn in sm._resource_policies, "Test setup failed — policy didn't register"

    _sm_invoke_action(sm, "DeleteSecret", {
        "SecretId": arn,
        "ForceDeleteWithoutRecovery": True,
    })

    assert arn not in sm._resource_policies, (
        "Force-deleting a secret left an orphan entry in _resource_policies "
        "keyed by the now-deleted ARN. The delete path must pop both "
        "_secrets[name] AND _resource_policies[arn]."
    )
    sm.reset()


def _policy_secret(effect, principal):
    """A secret whose resource policy has one statement on GetSecretValue."""
    sm = _sm_importlib.import_module("ministack.services.secretsmanager")
    arn = sm.create_secret_in_process(f"rp-{_uuid_mod.uuid4().hex[:8]}", "v")
    _sm_invoke_action(sm, "PutResourcePolicy", {"SecretId": arn, "ResourcePolicy": json.dumps({
        "Version": "2012-10-17", "Statement": [{"Effect": effect, "Principal": {"AWS": principal},
                                                "Action": "secretsmanager:GetSecretValue", "Resource": "*"}]})})
    return arn


def _get_secret_value(key, arn):
    status, _headers, body = routed_request(
        key, "secretsmanager", "POST", "/", json.dumps({"SecretId": arn}).encode(),
        {"content-type": "application/x-amz-json-1.1", "x-amz-target": "secretsmanager.GetSecretValue"})
    return status, json.loads(body).get("__type")


_ALLOW_SECRETS = {"Statement": [{"Effect": "Allow", "Action": "secretsmanager:*", "Resource": "*"}]}


def test_secret_policy_naming_the_user_allows_without_identity_policy(auth):
    key, user = inprocess_iam_user()
    assert _get_secret_value(key, _policy_secret("Allow", user)) == (200, None)


def test_secret_policy_naming_the_account_needs_an_identity_policy(auth):
    arn = _policy_secret("Allow", "arn:aws:iam::000000000000:root")
    key, _user = inprocess_iam_user()
    assert _get_secret_value(key, arn) == (403, "AccessDeniedException")
    key, _user = inprocess_iam_user(_ALLOW_SECRETS)
    assert _get_secret_value(key, arn) == (200, None)


def test_secret_policy_deny_beats_an_identity_allow(auth):
    key, user = inprocess_iam_user(_ALLOW_SECRETS)
    arn = _policy_secret("Deny", user)
    status, _headers, body = routed_request(
        key, "secretsmanager", "POST", "/", json.dumps({"SecretId": arn}).encode(),
        {"content-type": "application/x-amz-json-1.1", "x-amz-target": "secretsmanager.GetSecretValue"})
    assert (status, json.loads(body)) == (403, {"__type": "AccessDeniedException", "message": (
        f"User: {user} is not authorized to perform: secretsmanager:GetSecretValue on resource: {arn} "
        "with an explicit deny in a resource-based policy")})
    status, _headers, body = routed_request(
        key, "secretsmanager", "POST", "/", json.dumps({"SecretIdList": [arn]}).encode(),
        {"content-type": "application/x-amz-json-1.1", "x-amz-target": "secretsmanager.BatchGetSecretValue"})
    assert json.loads(body)["Errors"][0]["Message"].endswith("with an explicit deny in a resource-based policy")


def test_secretsmanager_arn_shaped_secret_name_does_not_bypass_scope_guard():
    sm = _sm_importlib.import_module("ministack.services.secretsmanager")
    sm.reset()
    arn_shaped_names = (
        "arn:aws:secretsmanager:us-west-2:000000000000:secret:foreign-shaped",
        "arn:aws:secretsmanager:us-east-1:000000000000:secret:local-shaped",
    )

    for arn_shaped_name in arn_shaped_names:
        _sm_invoke_action(
            sm,
            "CreateSecret",
            {"Name": arn_shaped_name, "SecretString": "x"},
        )

        headers = {"x-amz-target": "secretsmanager.GetSecretValue"}
        body = _sm_json.dumps({"SecretId": arn_shaped_name}).encode()
        status, _resp_headers, resp_body = _sm_asyncio.run(
            sm.handle_request("POST", "/", headers, body, {})
        )
        parsed = _sm_json.loads(resp_body.decode() if isinstance(resp_body, bytes) else resp_body)

        assert status == 400
        assert parsed["__type"] == "ResourceNotFoundException"
    sm.reset()


@pytest.mark.serial
def test_secret_label_updated_event_to_eventbridge(sm, eb, sqs):
    """Native 'Secret Label Updated' notification: moving AWSCURRENT (create /
    put / update-with-value) publishes an event to the default EventBridge bus;
    a metadata-only update does not. detail = {name, labelUpdated, versionId}."""
    suffix = _uuid_mod.uuid4().hex[:8]
    name = f"evt-secret-{suffix}"
    q = sqs.create_queue(QueueName=f"sm-evt-{suffix}")["QueueUrl"]
    qarn = sqs.get_queue_attributes(QueueUrl=q, AttributeNames=["QueueArn"])["Attributes"]["QueueArn"]
    eb.put_rule(
        Name=f"sm-rule-{suffix}",
        EventPattern=json.dumps({"source": ["aws.secretsmanager"],
                                 "detail-type": ["Secret Label Updated"]}),
    )
    eb.put_targets(Rule=f"sm-rule-{suffix}", Targets=[{"Id": "1", "Arn": qarn}])

    sm.create_secret(Name=name, SecretString="v1")
    sm.put_secret_value(SecretId=name, SecretString="v2")  # AWSCURRENT moves
    sm.update_secret(SecretId=name, Description="metadata only")  # must NOT emit

    time.sleep(1)
    msgs = sqs.receive_message(QueueUrl=q, MaxNumberOfMessages=10, WaitTimeSeconds=2).get("Messages", [])
    events = [json.loads(m["Body"]) for m in msgs]
    label_events = [e for e in events if e.get("detail-type") == "Secret Label Updated"]
    assert label_events, "no Secret Label Updated event delivered"
    for e in label_events:
        assert e["source"] == "aws.secretsmanager"
        d = e["detail"]
        assert d["name"] == name
        assert d["labelUpdated"] == "AWSCURRENT"
        assert d["versionId"]
    # Metadata-only update must not have emitted an extra event beyond the
    # AWSCURRENT moves (create + put); AWSPENDING/AWSPREVIOUS never emit.
    assert all(e["detail"]["labelUpdated"] == "AWSCURRENT" for e in label_events)


def test_unicode_secretsmanager(sm):
    sm.create_secret(Name="unicode-secret", SecretString="пароль: 密码")
    resp = sm.get_secret_value(SecretId="unicode-secret")
    assert resp["SecretString"] == "пароль: 密码"