Skip to content

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

71.0 KB
Raw Blame
import json
import uuid as _uuid_mod

import pytest
from botocore.exceptions import ClientError


def test_iam_role_user(iam):
    iam.create_role(
        RoleName="test-role",
        AssumeRolePolicyDocument=json.dumps({"Version": "2012-10-17", "Statement": []}),
    )
    roles = iam.list_roles()
    assert any(r["RoleName"] == "test-role" for r in roles.get("Roles", []))
    iam.create_user(UserName="test-user")
    users = iam.list_users()
    assert any(u["UserName"] == "test-user" for u in users.get("Users", []))

def test_iam_create_user(iam):
    resp = iam.create_user(UserName="iam-test-user")
    user = resp["User"]
    assert user["UserName"] == "iam-test-user"
    assert "Arn" in user
    assert "UserId" in user

def test_iam_get_user(iam):
    resp = iam.get_user(UserName="iam-test-user")
    assert resp["User"]["UserName"] == "iam-test-user"

def test_iam_get_user_not_found(iam):
    with pytest.raises(ClientError) as exc:
        iam.get_user(UserName="ghost-user-xyz")
    assert exc.value.response["Error"]["Code"] == "NoSuchEntity"

def test_iam_list_users(iam):
    resp = iam.list_users()
    names = [u["UserName"] for u in resp["Users"]]
    assert "iam-test-user" in names

def test_iam_delete_user(iam):
    iam.create_user(UserName="iam-del-user")
    iam.delete_user(UserName="iam-del-user")
    with pytest.raises(ClientError) as exc:
        iam.get_user(UserName="iam-del-user")
    assert exc.value.response["Error"]["Code"] == "NoSuchEntity"

def test_iam_create_role(iam):
    assume = json.dumps(
        {
            "Version": "2012-10-17",
            "Statement": [
                {
                    "Effect": "Allow",
                    "Principal": {"Service": "lambda.amazonaws.com"},
                    "Action": "sts:AssumeRole",
                }
            ],
        }
    )
    resp = iam.create_role(
        RoleName="iam-test-role",
        AssumeRolePolicyDocument=assume,
        Description="integration test role",
    )
    role = resp["Role"]
    assert role["RoleName"] == "iam-test-role"
    assert "Arn" in role
    assert "RoleId" in role

def test_iam_get_role(iam):
    resp = iam.get_role(RoleName="iam-test-role")
    assert resp["Role"]["RoleName"] == "iam-test-role"


_TRUST_ALLOW_ROOT = {"Effect": "Allow", "Principal": {"AWS": "arn:aws:iam::000000000000:root"},
                     "Action": "sts:AssumeRole"}
_TRUST_ALLOW_NOT_PRINCIPAL = {"Effect": "Allow", "NotPrincipal": {"AWS": "arn:aws:iam::111122223333:root"},
                              "Action": "sts:AssumeRole"}
_TRUST_DENY_NOT_PRINCIPAL = {"Effect": "Deny", "NotPrincipal": {"AWS": "arn:aws:iam::000000000000:root"},
                             "Action": "sts:AssumeRole"}


@pytest.mark.parametrize("statement, message", [
    ([_TRUST_ALLOW_NOT_PRINCIPAL], "Allow with NotPrincipal is not allowed."),
    (_TRUST_ALLOW_NOT_PRINCIPAL, "Allow with NotPrincipal is not allowed."),
    ([_TRUST_ALLOW_ROOT, _TRUST_DENY_NOT_PRINCIPAL], "AssumeRole policy must not contain NotPrincipal field."),
    ([_TRUST_DENY_NOT_PRINCIPAL, _TRUST_ALLOW_NOT_PRINCIPAL], "Allow with NotPrincipal is not allowed."),
], ids=["allow", "allow-object", "deny", "deny-then-allow"])
def test_iam_role_trust_policy_not_principal_refused(iam, statement, message):
    name = f"not-principal-role-{_uuid_mod.uuid4().hex[:8]}"
    refused = json.dumps({"Version": "2012-10-17", "Statement": statement})
    plain = {"Version": "2012-10-17", "Statement": [_TRUST_ALLOW_ROOT]}
    with pytest.raises(ClientError) as exc:
        iam.create_role(RoleName=name, AssumeRolePolicyDocument=refused)
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 400
    assert exc.value.response["Error"]["Code"] == "MalformedPolicyDocument"
    assert exc.value.response["Error"]["Message"] == message
    with pytest.raises(ClientError) as exc:
        iam.get_role(RoleName=name)
    assert exc.value.response["Error"]["Code"] == "NoSuchEntity"

    iam.create_role(RoleName=name, AssumeRolePolicyDocument=json.dumps(plain))
    try:
        with pytest.raises(ClientError) as exc:
            iam.update_assume_role_policy(RoleName=name, PolicyDocument=refused)
        assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 400
        assert exc.value.response["Error"]["Code"] == "MalformedPolicyDocument"
        assert exc.value.response["Error"]["Message"] == message
        assert iam.get_role(RoleName=name)["Role"]["AssumeRolePolicyDocument"] == plain
        # The name and the role's existence are checked before the document.
        with pytest.raises(ClientError) as exc:
            iam.create_role(RoleName=name, AssumeRolePolicyDocument=refused)
        assert exc.value.response["Error"]["Code"] == "EntityAlreadyExists"
        with pytest.raises(ClientError) as exc:
            iam.update_assume_role_policy(RoleName=f"{name}-missing", PolicyDocument=refused)
        assert exc.value.response["Error"]["Code"] == "NoSuchEntity"
    finally:
        iam.delete_role(RoleName=name)


def test_iam_update_role_description(iam):
    name = f"description-role-{_uuid_mod.uuid4().hex[:8]}"
    iam.create_role(
        RoleName=name,
        AssumeRolePolicyDocument=json.dumps({"Version": "2012-10-17", "Statement": []}),
    )
    updated = iam.update_role_description(RoleName=name, Description="updated description")["Role"]
    assert updated["Description"] == "updated description"
    assert iam.get_role(RoleName=name)["Role"]["Description"] == "updated description"
    iam.delete_role(RoleName=name)


def test_iam_role_permissions_boundary_roundtrip(iam):
    name = f"boundary-role-{_uuid_mod.uuid4().hex[:8]}"
    original_boundary = "arn:aws:iam::000000000000:policy/original-boundary"
    replacement_boundary = "arn:aws:iam::000000000000:policy/replacement-boundary"
    assume = json.dumps({"Version": "2012-10-17", "Statement": []})

    created = iam.create_role(
        RoleName=name,
        AssumeRolePolicyDocument=assume,
        PermissionsBoundary=original_boundary,
    )["Role"]
    assert created["PermissionsBoundary"] == {
        "PermissionsBoundaryType": "PermissionsBoundaryPolicy",
        "PermissionsBoundaryArn": original_boundary,
    }
    assert iam.get_role(RoleName=name)["Role"]["PermissionsBoundary"]["PermissionsBoundaryArn"] == original_boundary

    iam.put_role_permissions_boundary(RoleName=name, PermissionsBoundary=replacement_boundary)
    assert iam.get_role(RoleName=name)["Role"]["PermissionsBoundary"] == {
        "PermissionsBoundaryType": "PermissionsBoundaryPolicy",
        "PermissionsBoundaryArn": replacement_boundary,
    }

    iam.delete_role_permissions_boundary(RoleName=name)
    assert "PermissionsBoundary" not in iam.get_role(RoleName=name)["Role"]
    # AWS treats deletion as idempotent when the role exists without a boundary.
    iam.delete_role_permissions_boundary(RoleName=name)
    iam.delete_role(RoleName=name)


@pytest.mark.parametrize("operation", ["put", "delete"])
def test_iam_role_permissions_boundary_missing_role(iam, operation):
    name = f"missing-boundary-role-{_uuid_mod.uuid4().hex[:8]}"
    with pytest.raises(ClientError) as exc:
        if operation == "put":
            iam.put_role_permissions_boundary(
                RoleName=name,
                PermissionsBoundary="arn:aws:iam::000000000000:policy/boundary",
            )
        else:
            iam.delete_role_permissions_boundary(RoleName=name)
    assert exc.value.response["Error"]["Code"] == "NoSuchEntity"

def test_iam_user_permissions_boundary_roundtrip(iam):
    name = f"boundary-user-{_uuid_mod.uuid4().hex[:8]}"
    original_boundary = "arn:aws:iam::000000000000:policy/original-boundary"
    replacement_boundary = "arn:aws:iam::000000000000:policy/replacement-boundary"

    created = iam.create_user(UserName=name, PermissionsBoundary=original_boundary)["User"]
    assert created["PermissionsBoundary"] == {
        "PermissionsBoundaryType": "PermissionsBoundaryPolicy",
        "PermissionsBoundaryArn": original_boundary,
    }
    iam.put_user_permissions_boundary(UserName=name, PermissionsBoundary=replacement_boundary)
    assert iam.get_user(UserName=name)["User"]["PermissionsBoundary"]["PermissionsBoundaryArn"] == replacement_boundary
    iam.delete_user_permissions_boundary(UserName=name)
    assert "PermissionsBoundary" not in iam.get_user(UserName=name)["User"]
    iam.delete_user(UserName=name)


@pytest.mark.parametrize("operation", ["put", "delete"])
def test_iam_user_permissions_boundary_missing_user(iam, operation):
    name = f"missing-boundary-user-{_uuid_mod.uuid4().hex[:8]}"
    with pytest.raises(ClientError) as exc:
        if operation == "put":
            iam.put_user_permissions_boundary(
                UserName=name, PermissionsBoundary="arn:aws:iam::000000000000:policy/boundary")
        else:
            iam.delete_user_permissions_boundary(UserName=name)
    assert exc.value.response["Error"]["Code"] == "NoSuchEntity"


def _boundary_policy(iam, name):
    doc = json.dumps({"Version": "2012-10-17", "Statement": [
        {"Effect": "Allow", "Action": "sqs:ListQueues", "Resource": "*"}]})
    return iam.create_policy(PolicyName=name, PolicyDocument=doc)["Policy"]["Arn"]


def _iam_action(monkeypatch, auth, action, **params):
    """Run one IAM query action in-process with AUTH set to *auth*; return (status, body)."""
    import asyncio
    from urllib.parse import urlencode

    from ministack import app as app_mod
    from ministack.services import iam as iam_svc

    monkeypatch.setattr(app_mod, "AUTH", auth)
    body = urlencode({"Action": action, "Version": "2010-05-08", **params}).encode()
    status, _headers, payload = asyncio.run(iam_svc.handle_request("POST", "/", {}, body, {}))
    return status, payload.decode()


def _message(body):
    return body.split("<Message>", 1)[1].split("</Message>", 1)[0]


@pytest.mark.parametrize("auth", [True, False])
@pytest.mark.parametrize("kind", ["customer", "aws"])
@pytest.mark.parametrize("operation", [
    "CreateRole", "CreateUser", "PutRolePermissionsBoundary", "PutUserPermissionsBoundary"])
def test_iam_permissions_boundary_must_name_a_known_policy_under_auth(monkeypatch, auth, kind, operation):
    name = f"boundary-missing-{_uuid_mod.uuid4().hex[:8]}"
    missing = f"arn:aws:iam::{'aws' if kind == 'aws' else '000000000000'}:policy/{name}"
    entity = "Role" if "Role" in operation else "User"
    key = {f"{entity}Name": name}
    create = {"AssumeRolePolicyDocument": "{}"} if entity == "Role" else {}
    if operation.startswith("Put"):
        assert _iam_action(monkeypatch, False, f"Create{entity}", **key, **create)[0] == 200
    params = {**key, **(create if operation.startswith("Create") else {})}
    try:
        status, body = _iam_action(monkeypatch, auth, operation, PermissionsBoundary=missing, **params)
        if auth:
            assert (status, f"Scope ARN: {missing} does not exist or is not attachable.") == (404, _message(body))
        else:
            assert status == 200
    finally:
        _iam_action(monkeypatch, False, f"Delete{entity}", **key)


@pytest.mark.parametrize("auth, status", [(True, 400), (False, 200)])
def test_iam_permissions_boundary_must_be_an_arn_under_auth(monkeypatch, auth, status):
    name = f"boundary-malformed-{_uuid_mod.uuid4().hex[:8]}"
    _iam_action(monkeypatch, False, "CreateUser", UserName=name)
    try:
        got, body = _iam_action(monkeypatch, auth, "PutUserPermissionsBoundary", UserName=name,
                                PermissionsBoundary=f"not-an-arn-{name}")
        assert got == status
        if auth:
            assert _message(body) == "Invalid ARN:  Could not be parsed!"
    finally:
        _iam_action(monkeypatch, False, "DeleteUser", UserName=name)


@pytest.mark.parametrize("auth, status", [(True, 404), (False, 200)])
@pytest.mark.parametrize("entity", ["Role", "User"])
def test_iam_delete_absent_permissions_boundary_under_auth(monkeypatch, auth, status, entity):
    name = f"boundary-absent-{_uuid_mod.uuid4().hex[:8]}"
    create = {"AssumeRolePolicyDocument": "{}"} if entity == "Role" else {}
    _, created = _iam_action(monkeypatch, False, f"Create{entity}", **{f"{entity}Name": name}, **create)
    principal_id = created.split(f"<{entity}Id>", 1)[1].split("<", 1)[0]
    try:
        got, body = _iam_action(monkeypatch, auth, f"Delete{entity}PermissionsBoundary", **{f"{entity}Name": name})
        assert got == status
        if auth:
            assert _message(body) == f"Principal {principal_id} does not have scope"
    finally:
        _iam_action(monkeypatch, False, f"Delete{entity}", **{f"{entity}Name": name})


@pytest.mark.parametrize("auth, status", [(True, 409), (False, 200)])
def test_iam_delete_policy_in_use_as_a_boundary_under_auth(monkeypatch, auth, status):
    name = f"boundary-delete-{_uuid_mod.uuid4().hex[:8]}"
    _, created = _iam_action(monkeypatch, False, "CreatePolicy", PolicyName=name, PolicyDocument=json.dumps(
        {"Version": "2012-10-17", "Statement": [{"Effect": "Allow", "Action": "sqs:ListQueues", "Resource": "*"}]}))
    arn = created.split("<Arn>", 1)[1].split("<", 1)[0]
    _iam_action(monkeypatch, False, "CreateUser", UserName=name, PermissionsBoundary=arn)
    try:
        assert _iam_action(monkeypatch, auth, "DeletePolicy", PolicyArn=arn)[0] == status
    finally:
        _iam_action(monkeypatch, False, "DeleteUser", UserName=name)
        _iam_action(monkeypatch, False, "DeletePolicy", PolicyArn=arn)


def test_iam_permissions_boundary_uses_are_listed_as_policy_entities(iam):
    name = f"boundary-entities-{_uuid_mod.uuid4().hex[:8]}"
    boundary = _boundary_policy(iam, name)
    iam.create_user(UserName=name, PermissionsBoundary=boundary)
    iam.create_role(RoleName=name, PermissionsBoundary=boundary,
                    AssumeRolePolicyDocument=json.dumps({"Version": "2012-10-17", "Statement": []}))

    def entities(**kwargs):
        resp = iam.list_entities_for_policy(PolicyArn=boundary, **kwargs)
        return [r["RoleName"] for r in resp["PolicyRoles"]], [u["UserName"] for u in resp["PolicyUsers"]]

    assert entities() == ([name], [name])
    assert entities(PolicyUsageFilter="PermissionsBoundary") == ([name], [name])
    assert entities(PolicyUsageFilter="PermissionsPolicy") == ([], [])
    listed_user = next(u for u in iam.list_users()["Users"] if u["UserName"] == name)
    listed_role = next(r for r in iam.list_roles()["Roles"] if r["RoleName"] == name)
    assert "PermissionsBoundary" not in listed_user and "PermissionsBoundary" not in listed_role
    iam.delete_user(UserName=name)
    iam.delete_role(RoleName=name)
    iam.delete_policy(PolicyArn=boundary)


def test_iam_permissions_boundary_accepts_an_aws_managed_policy(iam):
    name = f"boundary-managed-{_uuid_mod.uuid4().hex[:8]}"
    boundary = "arn:aws:iam::aws:policy/ReadOnlyAccess"
    iam.create_user(UserName=name)
    iam.put_user_permissions_boundary(UserName=name, PermissionsBoundary=boundary)
    assert iam.get_user(UserName=name)["User"]["PermissionsBoundary"]["PermissionsBoundaryArn"] == boundary
    iam.delete_user(UserName=name)


def test_iam_policy_counts_its_permissions_boundary_uses(iam):
    name = f"boundary-count-{_uuid_mod.uuid4().hex[:8]}"
    boundary = _boundary_policy(iam, name)
    assert iam.get_policy(PolicyArn=boundary)["Policy"]["PermissionsBoundaryUsageCount"] == 0
    iam.create_user(UserName=f"{name}-user", PermissionsBoundary=boundary)
    iam.create_role(RoleName=f"{name}-role", PermissionsBoundary=boundary,
                    AssumeRolePolicyDocument=json.dumps({"Version": "2012-10-17", "Statement": []}))
    policy = iam.get_policy(PolicyArn=boundary)["Policy"]
    assert (policy["AttachmentCount"], policy["PermissionsBoundaryUsageCount"]) == (0, 2)
    listed = next(p for p in iam.list_policies(Scope="Local")["Policies"] if p["Arn"] == boundary)
    assert listed["PermissionsBoundaryUsageCount"] == 2
    iam.delete_user(UserName=f"{name}-user")
    iam.delete_role_permissions_boundary(RoleName=f"{name}-role")
    assert iam.get_policy(PolicyArn=boundary)["Policy"]["PermissionsBoundaryUsageCount"] == 0
    iam.delete_role(RoleName=f"{name}-role")
    iam.delete_policy(PolicyArn=boundary)


def test_iam_list_roles(iam):
    resp = iam.list_roles()
    names = [r["RoleName"] for r in resp["Roles"]]
    assert "iam-test-role" in names

def test_iam_delete_role(iam):
    assume = json.dumps({"Version": "2012-10-17", "Statement": []})
    iam.create_role(RoleName="iam-del-role", AssumeRolePolicyDocument=assume)
    iam.delete_role(RoleName="iam-del-role")
    with pytest.raises(ClientError) as exc:
        iam.get_role(RoleName="iam-del-role")
    assert exc.value.response["Error"]["Code"] == "NoSuchEntity"

def test_iam_create_policy(iam):
    policy_doc = json.dumps(
        {
            "Version": "2012-10-17",
            "Statement": [
                {
                    "Effect": "Allow",
                    "Action": "s3:GetObject",
                    "Resource": "arn:aws:s3:::my-bucket/*",
                }
            ],
        }
    )
    resp = iam.create_policy(
        PolicyName="iam-test-policy",
        PolicyDocument=policy_doc,
    )
    pol = resp["Policy"]
    assert pol["PolicyName"] == "iam-test-policy"
    assert "Arn" in pol
    assert pol["DefaultVersionId"] == "v1"

def test_iam_get_policy(iam):
    arn = "arn:aws:iam::000000000000:policy/iam-test-policy"
    resp = iam.get_policy(PolicyArn=arn)
    assert resp["Policy"]["PolicyName"] == "iam-test-policy"


def test_iam_policy_description_roundtrip(iam):
    """Regression for #438: CreatePolicy(Description=...) must survive GetPolicy.
    Without this, Terraform force-replaces every aws_iam_policy with a description
    on every warm boot because `description` is ForceNew in the provider."""
    import uuid as _u
    name = f"desc-policy-{_u.uuid4().hex[:8]}"
    created = iam.create_policy(
        PolicyName=name,
        Description="managed by ministack regression test",
        PolicyDocument='{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Action":"*","Resource":"*"}]}',
    )
    assert created["Policy"].get("Description") == "managed by ministack regression test"
    fetched = iam.get_policy(PolicyArn=created["Policy"]["Arn"])
    assert fetched["Policy"].get("Description") == "managed by ministack regression test"
    iam.delete_policy(PolicyArn=created["Policy"]["Arn"])


def test_iam_user_tags_serialized_in_get_user(iam):
    """Regression for #441: GetUser must include Tags set via TagUser / CreateUser.
    _user_xml previously omitted <Tags>, so Terraform's refresh saw empty tags
    and re-added default_tags on every apply."""
    import uuid as _u
    name = f"tag-user-{_u.uuid4().hex[:8]}"
    iam.create_user(UserName=name, Tags=[{"Key": "Team", "Value": "core"}])
    resp = iam.get_user(UserName=name)
    tags = {t["Key"]: t["Value"] for t in resp["User"].get("Tags", [])}
    assert tags.get("Team") == "core"
    iam.tag_user(UserName=name, Tags=[{"Key": "Env", "Value": "dev"}])
    resp = iam.get_user(UserName=name)
    tags = {t["Key"]: t["Value"] for t in resp["User"].get("Tags", [])}
    assert tags == {"Team": "core", "Env": "dev"}
    iam.delete_user(UserName=name)


_IDENTITY_TAG_TRUST = {"Statement": [{"Effect": "Allow", "Principal": {"Service": "lambda.amazonaws.com"},
                                 "Action": "sts:AssumeRole"}]}


def _identity_tag_map(tags):
    result = {t["Key"]: t["Value"] for t in tags}
    assert len(result) == len(tags), f"Duplicate tag keys in response: {tags}"
    return result


@pytest.mark.parametrize("resource", ["user", "role"])
def test_iam_identity_tag_keys_ignore_case_and_preserve_spelling(iam, resource):
    name = f"tag-case-{resource}-{_uuid_mod.uuid4().hex[:8]}"
    params = {f"{resource.title()}Name": name}
    create_params = {"AssumeRolePolicyDocument": json.dumps(_IDENTITY_TAG_TRUST)} if resource == "role" else {}
    original = [{"Key": "Department", "Value": "Finance"}, {"Key": "ExternalKey", "Value": "Keep"}]
    getattr(iam, f"create_{resource}")(**params, **create_params, Tags=original)
    try:
        assert _identity_tag_map(getattr(iam, f"get_{resource}")(**params)[resource.title()]["Tags"]) == _identity_tag_map(original)
        # Untag must match both the original spelling and a subsequently changed spelling.
        getattr(iam, f"untag_{resource}")(**params, TagKeys=["DEPARTMENT"])
        assert getattr(iam, f"list_{resource}_tags")(**params)["Tags"] == [original[1]]
        getattr(iam, f"tag_{resource}")(**params, Tags=[original[0]])
        # A spelling-only update and a case-sensitive value change must both take effect.
        for key, value in [("department", "Finance"), ("DEPARTMENT", "finance")]:
            getattr(iam, f"tag_{resource}")(**params, Tags=[{"Key": key, "Value": value}])
            expected = {key: value, "ExternalKey": "Keep"}
            assert _identity_tag_map(getattr(iam, f"get_{resource}")(**params)[resource.title()]["Tags"]) == expected
            assert _identity_tag_map(getattr(iam, f"list_{resource}_tags")(**params)["Tags"]) == expected
        getattr(iam, f"untag_{resource}")(**params, TagKeys=["DePaRtMeNt", "missing"])
        assert getattr(iam, f"list_{resource}_tags")(**params)["Tags"] == [original[1]]
    finally:
        getattr(iam, f"delete_{resource}")(**params)


@pytest.mark.parametrize("resource", ["user", "role"])
@pytest.mark.parametrize("operation", ["create", "tag"])
@pytest.mark.parametrize("second_key", ["Department", "department"])
def test_iam_identity_duplicate_tag_keys_reject_entire_request(iam, resource, operation, second_key):
    params = {f"{resource.title()}Name": f"tag-duplicate-{resource}-{_uuid_mod.uuid4().hex[:8]}"}
    create_params = {"AssumeRolePolicyDocument": json.dumps(_IDENTITY_TAG_TRUST)} if resource == "role" else {}
    original = [{"Key": "Department", "Value": "Finance"}]
    if operation == "tag":
        getattr(iam, f"create_{resource}")(**params, **create_params, Tags=original)
    try:
        with pytest.raises(ClientError) as exc:
            getattr(iam, f"{operation}_{resource}")(**params,
                **(create_params if operation == "create" else {}), Tags=[
                    {"Key": "Unrelated", "Value": "MustNotBeAdded"},
                    {"Key": "Department", "Value": "HR"}, {"Key": second_key, "Value": "HR"},
                ])
        assert exc.value.response["Error"]["Code"] == "InvalidInput"
        assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 400
        if operation == "tag":
            assert getattr(iam, f"list_{resource}_tags")(**params)["Tags"] == original
        else:
            with pytest.raises(iam.exceptions.NoSuchEntityException):
                getattr(iam, f"get_{resource}")(**params)
    finally:
        try:
            getattr(iam, f"delete_{resource}")(**params)
        except iam.exceptions.NoSuchEntityException:
            pass


@pytest.mark.parametrize("resource", ["policy", "instance_profile"])
def test_iam_other_resource_tag_keys_remain_case_sensitive(iam, resource):
    name = f"tag-case-{resource}-{_uuid_mod.uuid4().hex[:8]}"
    tags = [{"Key": "Costcenter", "Value": "1234"}, {"Key": "costcenter", "Value": "5678"}]
    if resource == "policy":
        arn = iam.create_policy(PolicyName=name, PolicyDocument=json.dumps({
            "Statement": [{"Effect": "Allow", "Action": "s3:ListBucket", "Resource": "*"}],
        }), Tags=[tags[0]])["Policy"]["Arn"]
        params = {"PolicyArn": arn}
    else:
        iam.create_instance_profile(InstanceProfileName=name, Tags=[tags[0]])
        params = {"InstanceProfileName": name}
    try:
        getattr(iam, f"tag_{resource}")(**params, Tags=[tags[1]])
        assert _identity_tag_map(getattr(iam, f"list_{resource}_tags")(**params)["Tags"]) == _identity_tag_map(tags)
        getattr(iam, f"untag_{resource}")(**params, TagKeys=["Costcenter"])
        assert getattr(iam, f"list_{resource}_tags")(**params)["Tags"] == [tags[1]]
    finally:
        getattr(iam, f"delete_{resource}")(**params)


def test_iam_attach_role_policy(iam):
    policy_arn = "arn:aws:iam::000000000000:policy/iam-test-policy"
    iam.attach_role_policy(RoleName="iam-test-role", PolicyArn=policy_arn)

def test_iam_list_attached_role_policies(iam):
    resp = iam.list_attached_role_policies(RoleName="iam-test-role")
    arns = [p["PolicyArn"] for p in resp["AttachedPolicies"]]
    assert "arn:aws:iam::000000000000:policy/iam-test-policy" in arns

def test_iam_detach_role_policy(iam):
    policy_arn = "arn:aws:iam::000000000000:policy/iam-test-policy"
    iam.detach_role_policy(RoleName="iam-test-role", PolicyArn=policy_arn)
    resp = iam.list_attached_role_policies(RoleName="iam-test-role")
    arns = [p["PolicyArn"] for p in resp["AttachedPolicies"]]
    assert policy_arn not in arns

def test_iam_put_role_policy(iam):
    inline_doc = json.dumps(
        {
            "Version": "2012-10-17",
            "Statement": [
                {
                    "Effect": "Allow",
                    "Action": "logs:*",
                    "Resource": "*",
                }
            ],
        }
    )
    iam.put_role_policy(
        RoleName="iam-test-role",
        PolicyName="inline-logs",
        PolicyDocument=inline_doc,
    )

def test_iam_get_role_policy(iam):
    resp = iam.get_role_policy(RoleName="iam-test-role", PolicyName="inline-logs")
    assert resp["RoleName"] == "iam-test-role"
    assert resp["PolicyName"] == "inline-logs"
    doc = resp["PolicyDocument"]
    if isinstance(doc, str):
        doc = json.loads(doc)
    assert doc["Statement"][0]["Action"] == "logs:*"

def test_iam_list_role_policies(iam):
    resp = iam.list_role_policies(RoleName="iam-test-role")
    assert "inline-logs" in resp["PolicyNames"]

def test_iam_create_access_key(iam):
    username = f"create-key-user-{_uuid_mod.uuid4().hex[:8]}"
    iam.create_user(UserName=username)
    try:
        resp = iam.create_access_key(UserName=username)
        key = resp["AccessKey"]
        assert key["UserName"] == username
        assert key["AccessKeyId"].startswith("AKIA")
        assert len(key["SecretAccessKey"]) > 0
        assert key["Status"] == "Active"
    finally:
        keys = iam.list_access_keys(UserName=username)["AccessKeyMetadata"]
        for k in keys:
            iam.delete_access_key(AccessKeyId=k["AccessKeyId"])
        iam.delete_user(UserName=username)


def test_iam_update_access_key(iam):
    username = f"upd-key-user-{_uuid_mod.uuid4().hex[:8]}"
    iam.create_user(UserName=username)
    resp = iam.create_access_key(UserName=username)
    key_id = resp["AccessKey"]["AccessKeyId"]
    try:
        iam.update_access_key(UserName=username, AccessKeyId=key_id, Status="Inactive")
        keys = iam.list_access_keys(UserName=username)["AccessKeyMetadata"]
        found = next(k for k in keys if k["AccessKeyId"] == key_id)
        assert found["Status"] == "Inactive"

        iam.update_access_key(UserName=username, AccessKeyId=key_id, Status="Active")
        keys = iam.list_access_keys(UserName=username)["AccessKeyMetadata"]
        found = next(k for k in keys if k["AccessKeyId"] == key_id)
        assert found["Status"] == "Active"
    finally:
        iam.delete_access_key(AccessKeyId=key_id)
        iam.delete_user(UserName=username)


def test_iam_update_access_key_not_found(iam):
    with pytest.raises(ClientError) as exc:
        iam.update_access_key(AccessKeyId="test-key-do-not-use", Status="Inactive")
    assert exc.value.response["Error"]["Code"] == "NoSuchEntity"


def test_iam_update_access_key_invalid_status(iam):
    username = f"inv-status-user-{_uuid_mod.uuid4().hex[:8]}"
    iam.create_user(UserName=username)
    resp = iam.create_access_key(UserName=username)
    key_id = resp["AccessKey"]["AccessKeyId"]
    try:
        with pytest.raises(ClientError) as exc:
            iam.update_access_key(AccessKeyId=key_id, Status="Disabled")
        assert exc.value.response["Error"]["Code"] == "InvalidInput"
    finally:
        iam.delete_access_key(AccessKeyId=key_id)
        iam.delete_user(UserName=username)


def test_iam_get_access_key_last_used(iam):
    username = f"key-last-used-{_uuid_mod.uuid4().hex[:8]}"
    iam.create_user(UserName=username)
    resp = iam.create_access_key(UserName=username)
    key_id = resp["AccessKey"]["AccessKeyId"]
    try:
        result = iam.get_access_key_last_used(AccessKeyId=key_id)
        assert result["UserName"] == username
        last_used = result["AccessKeyLastUsed"]
        assert last_used["Region"] == "N/A"
        assert last_used["ServiceName"] == "N/A"
        assert "LastUsedDate" not in last_used
    finally:
        iam.delete_access_key(AccessKeyId=key_id)
        iam.delete_user(UserName=username)


def test_iam_get_access_key_last_used_not_found(iam):
    with pytest.raises(ClientError) as exc:
        iam.get_access_key_last_used(AccessKeyId="test-key-do-not-use")
    assert exc.value.response["Error"]["Code"] == "NoSuchEntity"


def test_iam_instance_profile(iam):
    assume = json.dumps({"Version": "2012-10-17", "Statement": []})
    try:
        iam.create_role(RoleName="ip-role", AssumeRolePolicyDocument=assume)
    except ClientError:
        pass

    resp = iam.create_instance_profile(InstanceProfileName="test-ip")
    ip = resp["InstanceProfile"]
    assert ip["InstanceProfileName"] == "test-ip"
    assert "Arn" in ip

    iam.add_role_to_instance_profile(InstanceProfileName="test-ip", RoleName="ip-role")

    resp = iam.get_instance_profile(InstanceProfileName="test-ip")
    roles = resp["InstanceProfile"]["Roles"]
    assert any(r["RoleName"] == "ip-role" for r in roles)

    resp = iam.list_instance_profiles()
    names = [p["InstanceProfileName"] for p in resp["InstanceProfiles"]]
    assert "test-ip" in names

    iam.remove_role_from_instance_profile(InstanceProfileName="test-ip", RoleName="ip-role")
    iam.delete_instance_profile(InstanceProfileName="test-ip")

def test_iam_groups(iam):
    iam.create_group(GroupName="test-grp")
    resp = iam.get_group(GroupName="test-grp")
    assert resp["Group"]["GroupName"] == "test-grp"

    listed = iam.list_groups()
    assert any(g["GroupName"] == "test-grp" for g in listed["Groups"])

    iam.create_user(UserName="grp-usr")
    iam.add_user_to_group(GroupName="test-grp", UserName="grp-usr")
    members = iam.get_group(GroupName="test-grp")
    assert any(u["UserName"] == "grp-usr" for u in members["Users"])

    user_groups = iam.list_groups_for_user(UserName="grp-usr")
    assert any(g["GroupName"] == "test-grp" for g in user_groups["Groups"])

    iam.remove_user_from_group(GroupName="test-grp", UserName="grp-usr")
    iam.delete_group(GroupName="test-grp")

def test_iam_group_managed_policy(iam):
    iam.create_group(GroupName="grp-managed")
    pol = iam.create_policy(
        PolicyName="grp-managed-pol",
        PolicyDocument=json.dumps(
            {
                "Version": "2012-10-17",
                "Statement": [{"Effect": "Allow", "Action": "s3:GetObject", "Resource": "*"}],
            }
        ),
    )
    arn = pol["Policy"]["Arn"]

    iam.attach_group_policy(GroupName="grp-managed", PolicyArn=arn)
    listed = iam.list_attached_group_policies(GroupName="grp-managed")
    assert any(p["PolicyArn"] == arn for p in listed["AttachedPolicies"])

    iam.detach_group_policy(GroupName="grp-managed", PolicyArn=arn)
    listed = iam.list_attached_group_policies(GroupName="grp-managed")
    assert not any(p["PolicyArn"] == arn for p in listed["AttachedPolicies"])


def test_iam_group_managed_policy_unknown_group(iam):
    with pytest.raises(ClientError) as exc:
        iam.attach_group_policy(
            GroupName="no-such-grp",
            PolicyArn="arn:aws:iam::aws:policy/AmazonS3ReadOnlyAccess",
        )
    assert exc.value.response["Error"]["Code"] == "NoSuchEntity"


def test_iam_group_inline_policy(iam):
    iam.create_group(GroupName="grp-inline")
    doc = json.dumps(
        {
            "Version": "2012-10-17",
            "Statement": [{"Effect": "Allow", "Action": "s3:*", "Resource": "*"}],
        }
    )
    iam.put_group_policy(GroupName="grp-inline", PolicyName="s3-acc", PolicyDocument=doc)
    resp = iam.get_group_policy(GroupName="grp-inline", PolicyName="s3-acc")
    assert resp["PolicyName"] == "s3-acc"
    # botocore URL-decodes and parses the policy document into a dict.
    assert resp["PolicyDocument"] == json.loads(doc)
    listed = iam.list_group_policies(GroupName="grp-inline")
    assert "s3-acc" in listed["PolicyNames"]
    iam.delete_group_policy(GroupName="grp-inline", PolicyName="s3-acc")
    listed = iam.list_group_policies(GroupName="grp-inline")
    assert "s3-acc" not in listed["PolicyNames"]


def test_iam_user_inline_policy(iam):
    iam.create_user(UserName="inl-pol-usr")
    doc = json.dumps(
        {
            "Version": "2012-10-17",
            "Statement": [{"Effect": "Allow", "Action": "s3:*", "Resource": "*"}],
        }
    )
    iam.put_user_policy(UserName="inl-pol-usr", PolicyName="s3-acc", PolicyDocument=doc)
    resp = iam.get_user_policy(UserName="inl-pol-usr", PolicyName="s3-acc")
    assert resp["PolicyName"] == "s3-acc"
    listed = iam.list_user_policies(UserName="inl-pol-usr")
    assert "s3-acc" in listed["PolicyNames"]
    iam.delete_user_policy(UserName="inl-pol-usr", PolicyName="s3-acc")

def test_iam_service_linked_role(iam):
    resp = iam.create_service_linked_role(AWSServiceName="elasticloadbalancing.amazonaws.com")
    role = resp["Role"]
    assert "AWSServiceRoleFor" in role["RoleName"]
    assert role["Path"].startswith("/aws-service-role/")

    del_resp = iam.delete_service_linked_role(RoleName=role["RoleName"])
    task_id = del_resp["DeletionTaskId"]
    assert task_id

    status = iam.get_service_linked_role_deletion_status(DeletionTaskId=task_id)
    assert status["Status"] == "SUCCEEDED"

    with pytest.raises(ClientError) as exc:
        iam.get_role(RoleName=role["RoleName"])
    assert exc.value.response["Error"]["Code"] == "NoSuchEntity"

def test_iam_oidc_provider(iam):
    resp = iam.create_open_id_connect_provider(
        Url="https://oidc.example.com",
        ClientIDList=["my-client"],
        ThumbprintList=["a" * 40],
    )
    arn = resp["OpenIDConnectProviderArn"]
    assert "oidc.example.com" in arn
    desc = iam.get_open_id_connect_provider(OpenIDConnectProviderArn=arn)
    assert "my-client" in desc["ClientIDList"]
    iam.delete_open_id_connect_provider(OpenIDConnectProviderArn=arn)

def test_iam_policy_tags(iam):
    resp = iam.create_policy(
        PolicyName="tagged-pol",
        PolicyDocument=json.dumps(
            {
                "Version": "2012-10-17",
                "Statement": [{"Effect": "Allow", "Action": "*", "Resource": "*"}],
            }
        ),
    )
    arn = resp["Policy"]["Arn"]
    iam.tag_policy(PolicyArn=arn, Tags=[{"Key": "env", "Value": "test"}])
    tags = iam.list_policy_tags(PolicyArn=arn)
    assert any(t["Key"] == "env" for t in tags["Tags"])
    iam.untag_policy(PolicyArn=arn, TagKeys=["env"])
    tags2 = iam.list_policy_tags(PolicyArn=arn)
    assert not any(t["Key"] == "env" for t in tags2["Tags"])


def test_iam_policy_tags_serialized_in_get_policy(iam):
    """Regression for #445: _managed_policy_xml must emit Tags so GetPolicy /
    ListPolicies surface them. Without this block, Terraform's aws_iam_policy
    refresh sees tags_all={} and replans default_tags on every apply — same
    bug class as #441 (user tags) and #438 (policy description)."""
    import uuid as _u
    name = f"tagged-serialize-{_u.uuid4().hex[:8]}"
    resp = iam.create_policy(
        PolicyName=name,
        PolicyDocument=json.dumps({"Version": "2012-10-17",
                                    "Statement": [{"Effect": "Allow", "Action": "*", "Resource": "*"}]}),
        Tags=[{"Key": "Team", "Value": "platform"}],
    )
    arn = resp["Policy"]["Arn"]
    # CreatePolicy response must carry Tags.
    create_tags = {t["Key"]: t["Value"] for t in resp["Policy"].get("Tags") or []}
    assert create_tags.get("Team") == "platform", f"CreatePolicy dropped Tags: {resp['Policy']}"
    # GetPolicy (separate endpoint, uses _managed_policy_xml) must too.
    got = iam.get_policy(PolicyArn=arn)
    got_tags = {t["Key"]: t["Value"] for t in got["Policy"].get("Tags") or []}
    assert got_tags.get("Team") == "platform", f"GetPolicy dropped Tags: {got['Policy']}"
    # TagPolicy after-the-fact must also round-trip via GetPolicy.
    iam.tag_policy(PolicyArn=arn, Tags=[{"Key": "Env", "Value": "dev"}])
    got2 = iam.get_policy(PolicyArn=arn)
    got2_tags = {t["Key"]: t["Value"] for t in got2["Policy"].get("Tags") or []}
    assert got2_tags == {"Team": "platform", "Env": "dev"}
    iam.delete_policy(PolicyArn=arn)

def test_iam_update_role(iam):
    iam.create_role(
        RoleName="test-update-role",
        AssumeRolePolicyDocument='{"Version":"2012-10-17","Statement":[]}',
    )
    iam.update_role(RoleName="test-update-role", Description="updated desc", MaxSessionDuration=7200)
    resp = iam.get_role(RoleName="test-update-role")
    assert resp["Role"]["Description"] == "updated desc"
    assert resp["Role"]["MaxSessionDuration"] == 7200

def test_iam_policy_version_crud(iam):
    """CreatePolicyVersion, GetPolicyVersion, ListPolicyVersions, DeletePolicyVersion."""
    doc1 = json.dumps(
        {
            "Version": "2012-10-17",
            "Statement": [{"Effect": "Allow", "Action": "s3:*", "Resource": "*"}],
        }
    )
    doc2 = json.dumps(
        {
            "Version": "2012-10-17",
            "Statement": [{"Effect": "Allow", "Action": "sqs:*", "Resource": "*"}],
        }
    )
    arn = iam.create_policy(PolicyName="qa-iam-versions", PolicyDocument=doc1)["Policy"]["Arn"]
    iam.create_policy_version(PolicyArn=arn, PolicyDocument=doc2, SetAsDefault=True)
    versions = iam.list_policy_versions(PolicyArn=arn)["Versions"]
    assert len(versions) == 2
    default = next(v for v in versions if v["IsDefaultVersion"])
    assert default["VersionId"] == "v2"
    v1 = iam.get_policy_version(PolicyArn=arn, VersionId="v1")["PolicyVersion"]
    assert v1["IsDefaultVersion"] is False
    iam.delete_policy_version(PolicyArn=arn, VersionId="v1")
    versions2 = iam.list_policy_versions(PolicyArn=arn)["Versions"]
    assert len(versions2) == 1

def test_iam_inline_user_policy(iam):
    """PutUserPolicy / GetUserPolicy / ListUserPolicies / DeleteUserPolicy."""
    iam.create_user(UserName="qa-iam-inline-user")
    doc = json.dumps(
        {
            "Version": "2012-10-17",
            "Statement": [{"Effect": "Allow", "Action": "s3:GetObject", "Resource": "*"}],
        }
    )
    iam.put_user_policy(UserName="qa-iam-inline-user", PolicyName="qa-inline", PolicyDocument=doc)
    policies = iam.list_user_policies(UserName="qa-iam-inline-user")["PolicyNames"]
    assert "qa-inline" in policies
    got = iam.get_user_policy(UserName="qa-iam-inline-user", PolicyName="qa-inline")
    # boto3 deserialises PolicyDocument as a dict
    assert "s3:GetObject" in json.dumps(got["PolicyDocument"])
    iam.delete_user_policy(UserName="qa-iam-inline-user", PolicyName="qa-inline")
    policies2 = iam.list_user_policies(UserName="qa-iam-inline-user")["PolicyNames"]
    assert "qa-inline" not in policies2

def test_iam_instance_profile_crud(iam):
    """CreateInstanceProfile, AddRoleToInstanceProfile, GetInstanceProfile, ListInstanceProfiles."""
    iam.create_role(
        RoleName="qa-iam-ip-role",
        AssumeRolePolicyDocument=json.dumps({"Version": "2012-10-17", "Statement": []}),
    )
    iam.create_instance_profile(InstanceProfileName="qa-iam-ip")
    iam.add_role_to_instance_profile(InstanceProfileName="qa-iam-ip", RoleName="qa-iam-ip-role")
    ip = iam.get_instance_profile(InstanceProfileName="qa-iam-ip")["InstanceProfile"]
    assert ip["InstanceProfileName"] == "qa-iam-ip"
    assert any(r["RoleName"] == "qa-iam-ip-role" for r in ip["Roles"])
    profiles = iam.list_instance_profiles()["InstanceProfiles"]
    assert any(p["InstanceProfileName"] == "qa-iam-ip" for p in profiles)
    iam.remove_role_from_instance_profile(InstanceProfileName="qa-iam-ip", RoleName="qa-iam-ip-role")
    iam.delete_instance_profile(InstanceProfileName="qa-iam-ip")


def test_iam_instance_profile_tags(iam):
    """TagInstanceProfile, ListInstanceProfileTags, UntagInstanceProfile round-trip."""
    iam.create_instance_profile(InstanceProfileName="qa-iam-ip-tags")
    iam.tag_instance_profile(
        InstanceProfileName="qa-iam-ip-tags",
        Tags=[{"Key": "k", "Value": "v"}],
    )
    tags = iam.list_instance_profile_tags(InstanceProfileName="qa-iam-ip-tags")["Tags"]
    assert any(t["Key"] == "k" and t["Value"] == "v" for t in tags)
    iam.untag_instance_profile(InstanceProfileName="qa-iam-ip-tags", TagKeys=["k"])
    tags2 = iam.list_instance_profile_tags(InstanceProfileName="qa-iam-ip-tags")["Tags"]
    assert not any(t["Key"] == "k" for t in tags2)
    iam.delete_instance_profile(InstanceProfileName="qa-iam-ip-tags")


def test_iam_instance_profile_tags_serialized_in_get(iam):
    """Tags set via TagInstanceProfile (and at create time) must read back from
    GetInstanceProfile / ListInstanceProfiles so Terraform's
    aws_iam_instance_profile does not detect tag drift on re-apply. Same bug
    class as #441 (user tags) / #445 (policy tags)."""
    import uuid as _u
    name = f"qa-iam-ip-ser-{_u.uuid4().hex[:8]}"
    # Tags supplied at create time must round-trip.
    iam.create_instance_profile(
        InstanceProfileName=name,
        Tags=[{"Key": "Team", "Value": "platform"}],
    )
    got = iam.get_instance_profile(InstanceProfileName=name)["InstanceProfile"]
    got_tags = {t["Key"]: t["Value"] for t in got.get("Tags") or []}
    assert got_tags.get("Team") == "platform", f"GetInstanceProfile dropped Tags: {got}"
    # TagInstanceProfile after-the-fact must also round-trip via GetInstanceProfile.
    iam.tag_instance_profile(InstanceProfileName=name, Tags=[{"Key": "Env", "Value": "dev"}])
    got2 = iam.get_instance_profile(InstanceProfileName=name)["InstanceProfile"]
    got2_tags = {t["Key"]: t["Value"] for t in got2.get("Tags") or []}
    assert got2_tags == {"Team": "platform", "Env": "dev"}
    # ListInstanceProfiles (separate code path) must surface them too.
    listed = iam.list_instance_profiles()["InstanceProfiles"]
    match = next(p for p in listed if p["InstanceProfileName"] == name)
    listed_tags = {t["Key"]: t["Value"] for t in match.get("Tags") or []}
    assert listed_tags == {"Team": "platform", "Env": "dev"}
    iam.delete_instance_profile(InstanceProfileName=name)


def test_iam_attach_detach_user_policy(iam):
    """AttachUserPolicy / DetachUserPolicy / ListAttachedUserPolicies."""
    iam.create_user(UserName="qa-iam-attach-user")
    doc = json.dumps({"Version": "2012-10-17", "Statement": [{"Effect": "Allow", "Action": "s3:GetObject", "Resource": "*"}]})
    policy_arn = iam.create_policy(PolicyName="qa-iam-attach-pol", PolicyDocument=doc)["Policy"]["Arn"]
    iam.attach_user_policy(UserName="qa-iam-attach-user", PolicyArn=policy_arn)
    attached = iam.list_attached_user_policies(UserName="qa-iam-attach-user")["AttachedPolicies"]
    assert any(p["PolicyArn"] == policy_arn for p in attached)
    iam.detach_user_policy(UserName="qa-iam-attach-user", PolicyArn=policy_arn)
    attached2 = iam.list_attached_user_policies(UserName="qa-iam-attach-user")["AttachedPolicies"]
    assert not any(p["PolicyArn"] == policy_arn for p in attached2)

def test_iam_list_entities_for_policy(iam):
    """ListEntitiesForPolicy returns users and roles attached to a policy."""
    doc = json.dumps({"Version": "2012-10-17", "Statement": [{"Effect": "Allow", "Action": "s3:GetObject", "Resource": "*"}]})
    assume = json.dumps({"Version": "2012-10-17", "Statement": []})
    policy_arn = iam.create_policy(PolicyName="qa-entities-pol", PolicyDocument=doc)["Policy"]["Arn"]
    iam.create_user(UserName="qa-entities-user")
    try:
        iam.create_role(RoleName="qa-entities-role", AssumeRolePolicyDocument=assume)
    except ClientError:
        pass
    iam.attach_user_policy(UserName="qa-entities-user", PolicyArn=policy_arn)
    iam.attach_role_policy(RoleName="qa-entities-role", PolicyArn=policy_arn)

    resp = iam.list_entities_for_policy(PolicyArn=policy_arn)
    user_names = [u["UserName"] for u in resp["PolicyUsers"]]
    role_names = [r["RoleName"] for r in resp["PolicyRoles"]]
    assert "qa-entities-user" in user_names
    assert "qa-entities-role" in role_names

    # Detach user and verify it's removed
    iam.detach_user_policy(UserName="qa-entities-user", PolicyArn=policy_arn)
    resp2 = iam.list_entities_for_policy(PolicyArn=policy_arn)
    user_names2 = [u["UserName"] for u in resp2["PolicyUsers"]]
    assert "qa-entities-user" not in user_names2
    assert "qa-entities-role" in [r["RoleName"] for r in resp2["PolicyRoles"]]

    # Test EntityFilter
    resp3 = iam.list_entities_for_policy(PolicyArn=policy_arn, EntityFilter="Role")
    assert len(resp3["PolicyRoles"]) >= 1
    assert len(resp3.get("PolicyUsers", [])) == 0


# -- AWS-managed policies (arn:aws:iam::aws:policy/<Name>) -----------------
#
# AWS-managed policies live under a virtual ``aws`` account that every
# customer can read regardless of their own session account. These
# tests cover the global store and its interaction with role/user
# attachment, ListPolicies scoping, and mutation rejection.

_ADMIN_ARN = "arn:aws:iam::aws:policy/AdministratorAccess"


def test_iam_get_aws_managed_policy_administrator_access(iam):
    """GetPolicy must succeed for a seeded AWS-managed policy even
    though no session can authenticate as the ``aws`` virtual account."""
    resp = iam.get_policy(PolicyArn=_ADMIN_ARN)
    assert resp["Policy"]["PolicyName"] == "AdministratorAccess"
    assert resp["Policy"]["Arn"] == _ADMIN_ARN
    assert resp["Policy"]["DefaultVersionId"] == "v1"


def test_iam_get_aws_managed_policy_version_returns_document(iam):
    resp = iam.get_policy_version(PolicyArn=_ADMIN_ARN, VersionId="v1")
    doc = resp["PolicyVersion"]["Document"]
    # boto3 deserialises PolicyDocument; stringify before checking.
    assert "Allow" in json.dumps(doc)


def test_iam_seeded_amazon_eks_cluster_policy(iam):
    """AmazonEKSClusterPolicy must be seeded with the real AWS document,
    not the wildcard fallback (issue #1092)."""
    arn = "arn:aws:iam::aws:policy/AmazonEKSClusterPolicy"
    pv = iam.get_policy_version(PolicyArn=arn, VersionId="v1")["PolicyVersion"]
    doc = pv["Document"] if isinstance(pv["Document"], dict) else json.loads(pv["Document"])
    actions = []
    for stmt in doc["Statement"]:
        a = stmt.get("Action", [])
        actions.extend(a if isinstance(a, list) else [a])
    # Spot-check that real EKS-cluster actions are present and the wildcard fallback isn't.
    assert "elasticloadbalancing:CreateLoadBalancer" in actions
    assert "ec2:CreateSecurityGroup" in actions
    assert "*" not in actions


def test_iam_seeded_amazon_eks_worker_node_policy(iam):
    arn = "arn:aws:iam::aws:policy/AmazonEKSWorkerNodePolicy"
    pv = iam.get_policy_version(PolicyArn=arn, VersionId="v1")["PolicyVersion"]
    doc = pv["Document"] if isinstance(pv["Document"], dict) else json.loads(pv["Document"])
    actions = doc["Statement"][0]["Action"]
    assert "eks:DescribeCluster" in actions
    assert "eks-auth:AssumeRoleForPodIdentity" in actions


def test_iam_seeded_amazon_eks_cni_policy(iam):
    arn = "arn:aws:iam::aws:policy/AmazonEKS_CNI_Policy"
    pv = iam.get_policy_version(PolicyArn=arn, VersionId="v1")["PolicyVersion"]
    doc = pv["Document"] if isinstance(pv["Document"], dict) else json.loads(pv["Document"])
    first_actions = doc["Statement"][0]["Action"]
    assert "ec2:AssignPrivateIpAddresses" in first_actions
    assert "ec2:ModifyNetworkInterfaceAttribute" in first_actions


def test_iam_seeded_aws_xray_daemon_write_access(iam):
    """AWSXRayDaemonWriteAccess is heavily referenced by
    terraform-aws-modules/lambda's `attach_tracing_policy = true` path
    via `data "aws_iam_policy" "tracing" { arn = ... }`."""
    arn = "arn:aws:iam::aws:policy/AWSXRayDaemonWriteAccess"
    resp = iam.get_policy(PolicyArn=arn)
    assert resp["Policy"]["PolicyName"] == "AWSXRayDaemonWriteAccess"
    pv = iam.get_policy_version(PolicyArn=arn, VersionId="v1")["PolicyVersion"]
    doc = pv["Document"] if isinstance(pv["Document"], dict) else json.loads(pv["Document"])
    actions = doc["Statement"][0]["Action"]
    assert "xray:PutTraceSegments" in actions
    assert "xray:PutTelemetryRecords" in actions
    assert "*" not in actions


def test_iam_seeded_aws_xray_readonly(iam):
    arn = "arn:aws:iam::aws:policy/AWSXrayReadOnlyAccess"
    pv = iam.get_policy_version(PolicyArn=arn, VersionId="v1")["PolicyVersion"]
    doc = pv["Document"] if isinstance(pv["Document"], dict) else json.loads(pv["Document"])
    actions = doc["Statement"][0]["Action"]
    assert "xray:BatchGetTraces" in actions
    assert "xray:GetServiceGraph" in actions


def test_iam_seeded_aws_lambda_role(iam):
    # AWS publishes this policy only under service-role/; the path-less ARN
    # answers NoSuchEntity, as on AWS.
    arn = "arn:aws:iam::aws:policy/service-role/AWSLambdaRole"
    pv = iam.get_policy_version(PolicyArn=arn, VersionId="v1")["PolicyVersion"]
    doc = pv["Document"] if isinstance(pv["Document"], dict) else json.loads(pv["Document"])
    actions = doc["Statement"][0]["Action"]
    assert "lambda:InvokeFunction" in actions


def test_iam_list_policies_scope_all_includes_aws_managed(iam):
    resp = iam.list_policies(Scope="All")
    arns = [p["Arn"] for p in resp["Policies"]]
    assert _ADMIN_ARN in arns


def test_iam_list_policies_scope_aws_returns_only_aws_managed(iam):
    # Seed a customer-managed policy so we can prove it's filtered out.
    doc = json.dumps({"Version": "2012-10-17",
                      "Statement": [{"Effect": "Allow", "Action": "*", "Resource": "*"}]})
    name = f"awsmgd-filter-cust-{_uuid_mod.uuid4().hex[:8]}"
    cust = iam.create_policy(PolicyName=name, PolicyDocument=doc)["Policy"]["Arn"]
    try:
        resp = iam.list_policies(Scope="AWS")
        arns = [p["Arn"] for p in resp["Policies"]]
        assert _ADMIN_ARN in arns
        assert all(a.startswith("arn:aws:iam::aws:") for a in arns)
        assert cust not in arns
    finally:
        iam.delete_policy(PolicyArn=cust)


def test_iam_list_policies_scope_local_excludes_aws_managed(iam):
    resp = iam.list_policies(Scope="Local")
    arns = [p["Arn"] for p in resp["Policies"]]
    assert all(not a.startswith("arn:aws:iam::aws:") for a in arns)


def test_iam_attach_aws_managed_policy_to_role(iam):
    """The original motivating use case: terraform attaches an
    AWS-managed policy by ARN to a customer role."""
    role_name = f"awsmgd-role-{_uuid_mod.uuid4().hex[:8]}"
    iam.create_role(
        RoleName=role_name,
        AssumeRolePolicyDocument=json.dumps({"Version": "2012-10-17", "Statement": []}),
    )
    try:
        iam.attach_role_policy(RoleName=role_name, PolicyArn=_ADMIN_ARN)
        attached = iam.list_attached_role_policies(RoleName=role_name)["AttachedPolicies"]
        names = [p["PolicyName"] for p in attached]
        arns = [p["PolicyArn"] for p in attached]
        assert "AdministratorAccess" in names
        assert _ADMIN_ARN in arns
        iam.detach_role_policy(RoleName=role_name, PolicyArn=_ADMIN_ARN)
    finally:
        iam.delete_role(RoleName=role_name)


def test_iam_cannot_create_policy_under_aws_account(iam, monkeypatch):
    """Customer code must never be able to author into the AWS-managed
    namespace. Real AWS rejects this with InvalidInput."""
    # We can't change the session account at request time from boto3,
    # so this test is best-effort: we ensure a normal CreatePolicy
    # response still lands under the session account, not under ``aws``.
    doc = json.dumps({"Version": "2012-10-17",
                      "Statement": [{"Effect": "Allow", "Action": "*", "Resource": "*"}]})
    name = f"awsmgd-bounds-{_uuid_mod.uuid4().hex[:8]}"
    resp = iam.create_policy(PolicyName=name, PolicyDocument=doc)
    try:
        assert not resp["Policy"]["Arn"].startswith("arn:aws:iam::aws:")
    finally:
        iam.delete_policy(PolicyArn=resp["Policy"]["Arn"])


def test_iam_cannot_delete_aws_managed_policy(iam):
    with pytest.raises(ClientError) as exc:
        iam.delete_policy(PolicyArn=_ADMIN_ARN)
    assert exc.value.response["Error"]["Code"] == "AccessDenied"


def test_iam_cannot_tag_aws_managed_policy(iam):
    with pytest.raises(ClientError) as exc:
        iam.tag_policy(PolicyArn=_ADMIN_ARN, Tags=[{"Key": "k", "Value": "v"}])
    assert exc.value.response["Error"]["Code"] == "AccessDenied"


def test_iam_unknown_aws_managed_policy_is_not_found_by_default(iam):
    """Real AWS returns NoSuchEntity for AWS-managed ARNs that don't
    exist (e.g. typos like ``AdminstratorAccess`` — missing ``i``).
    Ministack defaults to the same behaviour so that typos surface
    locally the same way they would in real AWS, instead of silently
    autovivifying a permissive stub and masking the bug until apply
    against real AWS."""
    arn = "arn:aws:iam::aws:policy/AdminstratorAccess"  # missing 'i'
    with pytest.raises(ClientError) as exc:
        iam.get_policy(PolicyArn=arn)
    assert exc.value.response["Error"]["Code"] == "NoSuchEntity"


def test_iam_aws_managed_attachment_count_is_per_account(iam):
    """AWS-managed AttachmentCount must reflect the calling account's
    own attachments — real AWS scopes the counter per-account. Attach
    to two roles and a user under the same session, then GetPolicy and
    expect AttachmentCount == 3."""
    role_a = f"awsmgd-count-role-a-{_uuid_mod.uuid4().hex[:8]}"
    role_b = f"awsmgd-count-role-b-{_uuid_mod.uuid4().hex[:8]}"
    user = f"awsmgd-count-user-{_uuid_mod.uuid4().hex[:8]}"
    assume = json.dumps({"Version": "2012-10-17", "Statement": []})
    # ReadOnlyAccess so the test doesn't contend with other tests that
    # attach AdministratorAccess.
    arn = "arn:aws:iam::aws:policy/ReadOnlyAccess"
    baseline = iam.get_policy(PolicyArn=arn)["Policy"]["AttachmentCount"]
    iam.create_role(RoleName=role_a, AssumeRolePolicyDocument=assume)
    iam.create_role(RoleName=role_b, AssumeRolePolicyDocument=assume)
    iam.create_user(UserName=user)
    try:
        iam.attach_role_policy(RoleName=role_a, PolicyArn=arn)
        iam.attach_role_policy(RoleName=role_b, PolicyArn=arn)
        iam.attach_user_policy(UserName=user, PolicyArn=arn)
        got = iam.get_policy(PolicyArn=arn)["Policy"]
        assert got["AttachmentCount"] == baseline + 3
        # Detach decrements.
        iam.detach_role_policy(RoleName=role_a, PolicyArn=arn)
        got2 = iam.get_policy(PolicyArn=arn)["Policy"]
        assert got2["AttachmentCount"] == baseline + 2
    finally:
        for r in (role_a, role_b):
            try:
                iam.detach_role_policy(RoleName=r, PolicyArn=arn)
            except ClientError:
                pass
            iam.delete_role(RoleName=r)
        try:
            iam.detach_user_policy(UserName=user, PolicyArn=arn)
        except ClientError:
            pass
        iam.delete_user(UserName=user)


def test_iam_aws_managed_attachment_count_persists_through_state_round_trip():
    """Regression for 1.3.36: the _aws_managed_attachment_counts sidecar
    added with the AWS-managed policy work (1.3.36) was missing from
    get_state/restore_state, so attachment counts on AWS-managed policies
    reset to zero on every warm-boot."""
    from ministack.services import iam as _iam

    arn = "arn:aws:iam::aws:policy/AdministratorAccess"
    _iam._aws_managed_attachment_counts.clear()
    _iam._bump_aws_managed_attachment(arn, +2)
    assert _iam._aws_managed_attachment_counts.get(arn) == 2

    snapshot = _iam.get_state()
    _iam._aws_managed_attachment_counts.clear()
    assert _iam._aws_managed_attachment_counts.get(arn, 0) == 0

    _iam.load_persisted_state(snapshot)
    assert _iam._aws_managed_attachment_counts.get(arn) == 2


# ── Service last accessed (Access Advisor) ────────────────────────────


def test_iam_service_last_accessed_job(iam):
    # Use the default account user
    resp_user = iam.create_user(UserName="sla-test-user")
    user_arn = resp_user["User"]["Arn"]
    try:
        gen_resp = iam.generate_service_last_accessed_details(Arn=user_arn)
        job_id = gen_resp["JobId"]
        assert job_id

        get_resp = iam.get_service_last_accessed_details(JobId=job_id)
        assert get_resp["JobStatus"] == "COMPLETED"
        assert "ServicesLastAccessed" in get_resp
        assert isinstance(get_resp["ServicesLastAccessed"], list)
    finally:
        iam.delete_user(UserName="sla-test-user")
# ── SAML providers + ListOpenIDConnectProviders ──────────────────────


def test_iam_saml_provider_crud(iam):
    name = "saml-test-provider"
    # botocore requires ≥ 1000 chars for SAMLMetadataDocument (client-side validation)
    metadata = "<EntityDescriptor>" + "x" * 990 + "</EntityDescriptor>"
    resp = iam.create_saml_provider(Name=name, SAMLMetadataDocument=metadata)
    arn = resp["SAMLProviderArn"]
    assert f":saml-provider/{name}" in arn

    providers = iam.list_saml_providers()["SAMLProviderList"]
    assert any(p["Arn"] == arn for p in providers)

    get_resp = iam.get_saml_provider(SAMLProviderArn=arn)
    assert get_resp["SAMLMetadataDocument"] == metadata

    iam.delete_saml_provider(SAMLProviderArn=arn)
    with pytest.raises(iam.exceptions.NoSuchEntityException):
        iam.get_saml_provider(SAMLProviderArn=arn)


def test_iam_list_oidc_providers(iam):
    resp = iam.create_open_id_connect_provider(
        Url="https://oidc-list-test.example.com",
        ClientIDList=["aud"],
        ThumbprintList=["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00"],
    )
    arn = resp["OpenIDConnectProviderArn"]
    try:
        providers = iam.list_open_id_connect_providers()["OpenIDConnectProviderList"]
        assert any(p["Arn"] == arn for p in providers)
    finally:
        iam.delete_open_id_connect_provider(OpenIDConnectProviderArn=arn)
# ── GetAccountAuthorizationDetails ───────────────────────────────────


def test_iam_account_authorization_details_all(iam):
    policy_doc = json.dumps({"Version": "2012-10-17", "Statement": [{"Effect": "Allow", "Action": "s3:GetObject", "Resource": "*"}]})
    assume_doc = json.dumps({"Version": "2012-10-17", "Statement": []})

    pol = iam.create_policy(PolicyName="aad-test-policy", PolicyDocument=policy_doc)
    pol_arn = pol["Policy"]["Arn"]
    iam.create_user(UserName="aad-test-user")
    iam.attach_user_policy(UserName="aad-test-user", PolicyArn=pol_arn)
    iam.create_group(GroupName="aad-test-group")
    iam.add_user_to_group(UserName="aad-test-user", GroupName="aad-test-group")
    iam.create_role(RoleName="aad-test-role", AssumeRolePolicyDocument=assume_doc)
    try:
        resp = iam.get_account_authorization_details()

        user_names = [u["UserName"] for u in resp.get("UserDetailList", [])]
        assert "aad-test-user" in user_names

        role_names = [r["RoleName"] for r in resp.get("RoleDetailList", [])]
        assert "aad-test-role" in role_names

        policy_arns = [p["Arn"] for p in resp.get("Policies", [])]
        assert pol_arn in policy_arns
    finally:
        iam.detach_user_policy(UserName="aad-test-user", PolicyArn=pol_arn)
        iam.remove_user_from_group(UserName="aad-test-user", GroupName="aad-test-group")
        iam.delete_user(UserName="aad-test-user")
        iam.delete_group(GroupName="aad-test-group")
        iam.delete_role(RoleName="aad-test-role")
        iam.delete_policy(PolicyArn=pol_arn)


def test_iam_account_authorization_details_filter(iam):
    assume_doc = json.dumps({"Version": "2012-10-17", "Statement": []})
    iam.create_user(UserName="aad-filter-user")
    iam.create_role(RoleName="aad-filter-role", AssumeRolePolicyDocument=assume_doc)
    try:
        resp = iam.get_account_authorization_details(Filter=["Role"])
        # UserDetailList should be empty when filtering for Role only
        assert resp.get("UserDetailList", []) == []
        role_names = [r["RoleName"] for r in resp.get("RoleDetailList", [])]
        assert "aad-filter-role" in role_names
    finally:
        iam.delete_user(UserName="aad-filter-user")
        iam.delete_role(RoleName="aad-filter-role")
# ── Virtual MFA devices ───────────────────────────────────────────────


def test_iam_create_virtual_mfa(iam):
    device_name = "mfa-device-create-test"
    resp = iam.create_virtual_mfa_device(VirtualMFADeviceName=device_name)
    dev = resp["VirtualMFADevice"]
    assert dev["SerialNumber"].endswith(f":mfa/{device_name}")
    assert len(dev["Base32StringSeed"]) > 0
    iam.delete_virtual_mfa_device(SerialNumber=dev["SerialNumber"])


def test_iam_enable_and_list_mfa(iam):
    user_name = "mfa-user-enable-list"
    device_name = "mfa-device-enable-list"
    iam.create_user(UserName=user_name)
    dev_resp = iam.create_virtual_mfa_device(VirtualMFADeviceName=device_name)
    serial = dev_resp["VirtualMFADevice"]["SerialNumber"]
    try:
        iam.enable_mfa_device(
            UserName=user_name,
            SerialNumber=serial,
            AuthenticationCode1="123456",
            AuthenticationCode2="234567",
        )
        resp = iam.list_mfa_devices(UserName=user_name)
        devices = resp["MFADevices"]
        assert any(d["SerialNumber"] == serial for d in devices)
        assert all("EnableDate" in d for d in devices if d["SerialNumber"] == serial)
    finally:
        try:
            iam.deactivate_mfa_device(UserName=user_name, SerialNumber=serial)
        except Exception:
            pass
        try:
            iam.delete_virtual_mfa_device(SerialNumber=serial)
        except Exception:
            pass
        iam.delete_user(UserName=user_name)


def test_iam_list_virtual_mfa_assignment_filter(iam):
    user_name = "mfa-user-filter"
    iam.create_user(UserName=user_name)
    d1 = iam.create_virtual_mfa_device(VirtualMFADeviceName="mfa-filter-assigned")["VirtualMFADevice"]["SerialNumber"]
    d2 = iam.create_virtual_mfa_device(VirtualMFADeviceName="mfa-filter-unassigned")["VirtualMFADevice"]["SerialNumber"]
    try:
        iam.enable_mfa_device(UserName=user_name, SerialNumber=d1,
                              AuthenticationCode1="111111", AuthenticationCode2="222222")

        # default (Assigned) returns only assigned
        assigned_serials = {d["SerialNumber"] for d in
                            iam.list_virtual_mfa_devices()["VirtualMFADevices"]}
        assert d1 in assigned_serials
        assert d2 not in assigned_serials

        # Unassigned returns only free device
        unassigned_serials = {d["SerialNumber"] for d in
                              iam.list_virtual_mfa_devices(AssignmentStatus="Unassigned")["VirtualMFADevices"]}
        assert d2 in unassigned_serials
        assert d1 not in unassigned_serials

        # Any returns both
        any_serials = {d["SerialNumber"] for d in
                       iam.list_virtual_mfa_devices(AssignmentStatus="Any")["VirtualMFADevices"]}
        assert d1 in any_serials
        assert d2 in any_serials
    finally:
        for serial, uname in [(d1, user_name), (d2, None)]:
            if uname:
                try:
                    iam.deactivate_mfa_device(UserName=uname, SerialNumber=serial)
                except Exception:
                    pass
            try:
                iam.delete_virtual_mfa_device(SerialNumber=serial)
            except Exception:
                pass
        iam.delete_user(UserName=user_name)


def test_iam_deactivate_mfa(iam):
    user_name = "mfa-user-deactivate"
    device_name = "mfa-device-deactivate"
    iam.create_user(UserName=user_name)
    serial = iam.create_virtual_mfa_device(VirtualMFADeviceName=device_name)["VirtualMFADevice"]["SerialNumber"]
    try:
        iam.enable_mfa_device(UserName=user_name, SerialNumber=serial,
                              AuthenticationCode1="111111", AuthenticationCode2="222222")
        iam.deactivate_mfa_device(UserName=user_name, SerialNumber=serial)

        # no devices for user after deactivate
        devices = iam.list_mfa_devices(UserName=user_name)["MFADevices"]
        assert not any(d["SerialNumber"] == serial for d in devices)

        # device should appear in Unassigned list
        unassigned = {d["SerialNumber"] for d in
                      iam.list_virtual_mfa_devices(AssignmentStatus="Unassigned")["VirtualMFADevices"]}
        assert serial in unassigned
    finally:
        try:
            iam.delete_virtual_mfa_device(SerialNumber=serial)
        except Exception:
            pass
        iam.delete_user(UserName=user_name)


def test_iam_delete_assigned_mfa_conflict(iam):
    user_name = "mfa-user-conflict"
    device_name = "mfa-device-conflict"
    iam.create_user(UserName=user_name)
    serial = iam.create_virtual_mfa_device(VirtualMFADeviceName=device_name)["VirtualMFADevice"]["SerialNumber"]
    try:
        iam.enable_mfa_device(UserName=user_name, SerialNumber=serial,
                              AuthenticationCode1="111111", AuthenticationCode2="222222")
        with pytest.raises(iam.exceptions.DeleteConflictException):
            iam.delete_virtual_mfa_device(SerialNumber=serial)
    finally:
        try:
            iam.deactivate_mfa_device(UserName=user_name, SerialNumber=serial)
        except Exception:
            pass
        try:
            iam.delete_virtual_mfa_device(SerialNumber=serial)
        except Exception:
            pass
        iam.delete_user(UserName=user_name)

# ── Login profiles ────────────────────────────────────────────────────


def test_iam_create_get_login_profile(iam):
    name = "lp-user-create-get"
    iam.create_user(UserName=name)
    try:
        resp = iam.create_login_profile(UserName=name, Password="Test1234!", PasswordResetRequired=True)
        profile = resp["LoginProfile"]
        assert profile["UserName"] == name
        assert "CreateDate" in profile
        assert profile["PasswordResetRequired"] is True

        resp2 = iam.get_login_profile(UserName=name)
        assert resp2["LoginProfile"]["UserName"] == name
        assert "CreateDate" in resp2["LoginProfile"]
    finally:
        try:
            iam.delete_login_profile(UserName=name)
        except Exception:
            pass
        iam.delete_user(UserName=name)


def test_iam_get_login_profile_absent(iam):
    name = "lp-user-absent"
    iam.create_user(UserName=name)
    try:
        with pytest.raises(iam.exceptions.NoSuchEntityException):
            iam.get_login_profile(UserName=name)
    finally:
        iam.delete_user(UserName=name)


def test_iam_create_login_profile_no_user(iam):
    with pytest.raises(iam.exceptions.NoSuchEntityException):
        iam.create_login_profile(UserName="lp-ghost-user-xyz", Password="Test1234!")


def test_iam_delete_login_profile(iam):
    name = "lp-user-delete"
    iam.create_user(UserName=name)
    try:
        iam.create_login_profile(UserName=name, Password="Test1234!")
        iam.delete_login_profile(UserName=name)
        with pytest.raises(iam.exceptions.NoSuchEntityException):
            iam.get_login_profile(UserName=name)
    finally:
        try:
            iam.delete_login_profile(UserName=name)
        except Exception:
            pass
        iam.delete_user(UserName=name)


# ── Credential report ─────────────────────────────────────────────────

_CRED_REPORT_COLUMNS = (
    "user,arn,user_creation_time,password_enabled,password_last_used,"
    "password_last_changed,password_next_rotation,mfa_active,"
    "access_key_1_active,access_key_1_last_rotated,access_key_1_last_used_date,"
    "access_key_1_last_used_region,access_key_1_last_used_service,"
    "access_key_2_active,access_key_2_last_rotated,access_key_2_last_used_date,"
    "access_key_2_last_used_region,access_key_2_last_used_service,"
    "cert_1_active,cert_1_last_rotated,cert_2_active,cert_2_last_rotated"
)


def test_iam_credential_report_get_before_generate(iam):
    with pytest.raises(Exception) as exc_info:
        iam.get_credential_report()
    assert exc_info.value.response["Error"]["Code"] == "ReportNotPresent"


def test_iam_credential_report_mfa_and_password(iam):
    user_a = "cr-user-a-mfapw"
    user_b = "cr-user-b-neither"
    device_name = "cr-mfa-device"

    iam.create_user(UserName=user_a)
    iam.create_user(UserName=user_b)
    iam.create_login_profile(UserName=user_a, Password="Test1234!")
    serial = iam.create_virtual_mfa_device(VirtualMFADeviceName=device_name)["VirtualMFADevice"]["SerialNumber"]
    iam.enable_mfa_device(UserName=user_a, SerialNumber=serial,
                          AuthenticationCode1="111111", AuthenticationCode2="222222")
    try:
        iam.generate_credential_report()
        resp = iam.get_credential_report()
        csv_bytes = resp["Content"]
        csv_text = csv_bytes.decode("utf-8") if isinstance(csv_bytes, (bytes, bytearray)) else csv_bytes
        rows = {r.split(",")[0]: r.split(",") for r in csv_text.strip().splitlines()[1:]}

        # user A: password_enabled=true, mfa_active=true
        assert rows[user_a][3] == "true", f"Expected password_enabled=true for {user_a}"
        assert rows[user_a][7] == "true", f"Expected mfa_active=true for {user_a}"

        # user B: password_enabled=false, mfa_active=false
        assert rows[user_b][3] == "false", f"Expected password_enabled=false for {user_b}"
        assert rows[user_b][7] == "false", f"Expected mfa_active=false for {user_b}"
    finally:
        try:
            iam.deactivate_mfa_device(UserName=user_a, SerialNumber=serial)
        except Exception:
            pass
        try:
            iam.delete_virtual_mfa_device(SerialNumber=serial)
        except Exception:
            pass
        try:
            iam.delete_login_profile(UserName=user_a)
        except Exception:
            pass
        iam.delete_user(UserName=user_a)
        iam.delete_user(UserName=user_b)


def test_iam_credential_report_header(iam):
    iam.generate_credential_report()
    resp = iam.get_credential_report()
    csv_bytes = resp["Content"]
    csv_text = csv_bytes.decode("utf-8") if isinstance(csv_bytes, (bytes, bytearray)) else csv_bytes
    lines = csv_text.strip().splitlines()
    assert lines[0] == _CRED_REPORT_COLUMNS
    user_col = [r.split(",")[0] for r in lines]
    assert "<root_account>" in user_col
# ── Account posture (summary / password policy / aliases) ─────────────


def test_iam_password_policy_absent_then_set(iam):
    # First, delete any existing policy to ensure clean state (serial test)
    try:
        iam.delete_account_password_policy()
    except Exception:
        pass
    with pytest.raises(iam.exceptions.NoSuchEntityException):
        iam.get_account_password_policy()
    iam.update_account_password_policy(MinimumPasswordLength=14)
    resp = iam.get_account_password_policy()
    assert resp["PasswordPolicy"]["MinimumPasswordLength"] == 14
    iam.delete_account_password_policy()


def test_iam_account_summary_counts(iam):
    resp = iam.get_account_summary()
    sm = resp["SummaryMap"]
    assert "Users" in sm
    assert "MFADevices" in sm
    assert "AccountMFAEnabled" in sm
    assert isinstance(sm["Users"], int)


def test_iam_account_alias_crud(iam):
    alias = "my-test-alias-acct"
    iam.create_account_alias(AccountAlias=alias)
    aliases = iam.list_account_aliases()["AccountAliases"]
    assert alias in aliases
    iam.delete_account_alias(AccountAlias=alias)
    aliases_after = iam.list_account_aliases()["AccountAliases"]
    assert alias not in aliases_after