Ministack: Free, open-source local AWS emulator - 60+ services, Terraform compatible, real databases. Free forever. MIT licensed.
Python awsaws-emulatoraws-localaws-sdkdevtoolsdockerdynamodbec2emulatorlambdalocalstacklocalstack-alternativeministackmock-awsopen-sourcepythons3sqsterraform
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"] == "пароль: 密码"