Skip to content

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

50.8 KB
Raw Blame
"""
Integration tests for the AmazonMQ service (RabbitMQ CRUD).
"""

import uuid

import pytest
from botocore.exceptions import ClientError


@pytest.fixture
def isolated_mq_module_state():
    from ministack.core.responses import (
        get_account_id,
        get_region,
        set_request_account_id,
        set_request_region,
    )
    from ministack.services import mq as service

    original_account = get_account_id()
    original_region = get_region()
    stores = (service._brokers, service._name_index, service._tags, service._users)
    original_data = [dict(store._data) for store in stores]

    service.reset()
    set_request_account_id("111111111111")
    set_request_region("us-east-1")
    try:
        yield service
    finally:
        service.reset()
        for store, data in zip(stores, original_data):
            store._data.update(data)
        set_request_account_id(original_account)
        set_request_region(original_region)

# ###########################################################################
# Helpers
# ###########################################################################

def _name(suffix: str = "") -> str:
    """Generate a unique broker name for a test run."""
    return f"intg-mq-{suffix}-{uuid.uuid4().hex[:8]}"


def _create(mq, **kwargs) -> dict:
    params = dict(
        BrokerName=_name("base"),
        EngineType="RABBITMQ",
        EngineVersion="3.13",
        HostInstanceType="mq.m5.large",
        PubliclyAccessible=False,
        DeploymentMode="SINGLE_INSTANCE",
    )
    params.update(kwargs)
    return mq.create_broker(**params)


############################################################################
# CreateBroker
############################################################################

def test_mq_create_broker_with_required_options(mq):
    name = _name("create")
    resp = mq.create_broker(
        BrokerName=name,
        EngineType="RABBITMQ",
        EngineVersion="3.13",
        HostInstanceType="mq.m5.large",
        PubliclyAccessible=False,
        DeploymentMode="SINGLE_INSTANCE",
    )
    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
    assert "BrokerId" in resp
    assert "BrokerArn" in resp
    assert resp["BrokerArn"].startswith("arn:aws:mq:")

def test_mq_create_broker_with_duplicated_name(mq):
    name = _name("dup")
    _create(mq, BrokerName=name)

    with pytest.raises(ClientError) as exc:
        _create(mq, BrokerName=name)
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 409
    assert exc.value.response["Error"]["Code"] == "ConflictException"

@pytest.mark.parametrize(
    "create_params",
    [
        {"BrokerName": _name("invalid-engine"), "EngineType": "INVALID_ENGINE", "EngineVersion": "1.0", "HostInstanceType": "mq.m5.large", "DeploymentMode": "SINGLE_INSTANCE", "PubliclyAccessible": False},
        {"BrokerName": _name("invalid-engine-version"), "EngineType": "RABBITMQ", "EngineVersion": "INVALID_VERSION", "HostInstanceType": "mq.m5.large", "DeploymentMode": "SINGLE_INSTANCE", "PubliclyAccessible": False},
        {"BrokerName": _name("invalid-deployment-mode"), "EngineType": "RABBITMQ", "EngineVersion": "3.13", "HostInstanceType": "mq.m5.large", "DeploymentMode": "INVALID_MODE", "PubliclyAccessible": False},
        {"BrokerName": _name("invalid-instance-type"), "EngineType": "RABBITMQ", "EngineVersion": "3.13", "HostInstanceType": "INVALID_INSTANCE", "DeploymentMode": "SINGLE_INSTANCE", "PubliclyAccessible": False},
        {"BrokerName": _name("invalid-storage-type"), "EngineType": "RABBITMQ", "EngineVersion": "3.13", "HostInstanceType": "mq.m5.large", "DeploymentMode": "SINGLE_INSTANCE", "StorageType": "INVALID_STORAGE", "PubliclyAccessible": False}
    ],
)
def test_mq_create_broker_with_invalid_parameters(
    mq, create_params
):
    """Test that invalid parameters return BadRequestException."""
    with pytest.raises(ClientError) as exc:
        mq.create_broker(**create_params)
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 400
    assert exc.value.response["Error"]["Code"] == "BadRequestException"

def test_mq_create_broker_initializes_empty_tags(mq):
    """Test that _tags[broker_arn] = {} when no tags provided (Line 222)."""
    name = _name("tags-init-empty")
    resp = mq.create_broker(
        BrokerName=name,
        EngineType="RABBITMQ",
        EngineVersion="3.13",
        HostInstanceType="mq.m5.large",
        PubliclyAccessible=False,
        DeploymentMode="SINGLE_INSTANCE",
    )
    broker_arn = resp["BrokerArn"]

    # Verify tags dict is initialized and empty
    list_resp = mq.list_tags(ResourceArn=broker_arn)
    assert list_resp["Tags"] == {}

def test_mq_create_broker_initializes_empty_users(mq):
    """Test that _users[broker_id] = {} on creation (Line 223)."""
    broker_id = _create(mq, BrokerName=_name("users-init"), EngineType="ACTIVEMQ", EngineVersion="5.19")["BrokerId"]

    # Verify users dict is initialized and empty
    list_resp = mq.list_users(BrokerId=broker_id)
    assert list_resp.get("Users", []) == []
    assert list_resp["MaxResults"] == 20

def test_mq_create_broker_with_tags_initializes_tags(mq):
    """Test that _tags[broker_arn] stores provided tags (Line 222)."""
    name = _name("tags-init-with")
    resp = mq.create_broker(
        BrokerName=name,
        EngineType="RABBITMQ",
        EngineVersion="3.13",
        HostInstanceType="mq.m5.large",
        PubliclyAccessible=False,
        DeploymentMode="SINGLE_INSTANCE",
        Tags={"environment": "test", "team": "platform"},
    )
    broker_arn = resp["BrokerArn"]

    # Verify tags are persisted
    list_resp = mq.list_tags(ResourceArn=broker_arn)
    assert list_resp["Tags"]["environment"] == "test"
    assert list_resp["Tags"]["team"] == "platform"

def test_mq_create_broker_with_empty_tags_dict(mq):
    """Test that empty tags dict is handled correctly (Line 222)."""
    name = _name("tags-init-empty-dict")
    resp = mq.create_broker(
        BrokerName=name,
        EngineType="RABBITMQ",
        EngineVersion="3.13",
        HostInstanceType="mq.m5.large",
        PubliclyAccessible=False,
        DeploymentMode="SINGLE_INSTANCE",
        Tags={},
    )
    broker_arn = resp["BrokerArn"]

    list_resp = mq.list_tags(ResourceArn=broker_arn)
    assert list_resp["Tags"] == {}

############################################################################
# ListBrokers
############################################################################

def test_mq_list_brokers(mq):
    names = [_name("list") for _ in range(2)]
    ids = set()
    for n in names:
        r = mq.create_broker(
            BrokerName=n,
            EngineType="RABBITMQ",
            EngineVersion="3.13",
            HostInstanceType="mq.m5.large",
            PubliclyAccessible=False,
            DeploymentMode="SINGLE_INSTANCE",
        )
        ids.add(r["BrokerId"])

    resp = mq.list_brokers()
    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
    listed_ids = {b["BrokerId"] for b in resp.get("BrokerSummaries", [])}
    assert ids.issubset(listed_ids), f"Expected {ids} in {listed_ids}"

def test_mq_list_brokers_with_max_results(mq):
    # Create 10 brokers to ensure we have more than 5 to list
    for _ in range(10):
        _create(mq, BrokerName=_name("list-max"))

    resp = mq.list_brokers(MaxResults=5)
    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
    assert len(resp.get("BrokerSummaries", [])) <= 5

@pytest.mark.parametrize("invalid_max", [4, 101])
def test_mq_list_brokers_with_invalid_max_results(mq, invalid_max):
    with pytest.raises(ClientError) as exc:
        mq.list_brokers(MaxResults=invalid_max)
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 400
    assert exc.value.response["Error"]["Code"] == "BadRequestException"

def test_mq_list_brokers_pagination(mq):
    # Create 10 brokers to ensure we have more than 5 to list
    created_ids = []
    for _ in range(10):
        resp = _create(mq, BrokerName=_name("list-page"))
        created_ids.append(resp["BrokerId"])

    # Paginate with a stable page size and gather IDs until we find all new brokers.
    listed_ids = set()
    token = None
    pages = 0
    while True:
        pages += 1
        kwargs = {"MaxResults": 5}
        if token:
            kwargs["NextToken"] = token

        resp = mq.list_brokers(**kwargs)
        assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
        assert len(resp.get("BrokerSummaries", [])) <= 5

        listed_ids.update({b["BrokerId"] for b in resp.get("BrokerSummaries", [])})
        if set(created_ids).issubset(listed_ids):
            break

        token = resp.get("NextToken")
        if not token:
            break

        # Safety guard in case pagination regresses.
        assert pages <= 100

    assert set(created_ids).issubset(listed_ids), f"Expected {created_ids} in {listed_ids}"

############################################################################
# DescribeBrokers
############################################################################

def test_mq_describe_broker(mq):
    name = _name("describe")
    create_resp = _create(mq, BrokerName=name)
    broker_id = create_resp["BrokerId"]

    desc = mq.describe_broker(BrokerId=broker_id)
    assert desc["ResponseMetadata"]["HTTPStatusCode"] == 200
    assert desc["BrokerId"] == broker_id
    assert desc["BrokerName"] == name
    assert desc["EngineType"] == "RABBITMQ"
    assert desc["BrokerState"] == "RUNNING"
    assert "BrokerInstances" in desc

def test_mq_describe_broker_with_non_existent_id(mq):
    with pytest.raises(ClientError) as exc:
        mq.describe_broker(BrokerId="invalid-id")
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 404
    assert exc.value.response["Error"]["Code"] == "NotFoundException"

def test_mq_describe_broker_includes_tags(mq):
    """Test that DescribeBroker returns tags from _tags dict (Line 271)."""
    name = _name("describe-tags")
    create_resp = mq.create_broker(
        BrokerName=name,
        EngineType="RABBITMQ",
        EngineVersion="3.13",
        HostInstanceType="mq.m5.large",
        PubliclyAccessible=False,
        DeploymentMode="SINGLE_INSTANCE",
        Tags={"env": "staging", "owner": "devops"},
    )
    broker_id = create_resp["BrokerId"]

    desc = mq.describe_broker(BrokerId=broker_id)
    assert desc["ResponseMetadata"]["HTTPStatusCode"] == 200
    assert "Tags" in desc
    assert desc["Tags"]["env"] == "staging"
    assert desc["Tags"]["owner"] == "devops"

def test_mq_describe_broker_includes_empty_tags(mq):
    """Test that DescribeBroker returns empty tags object when none exist (Line 271)."""
    name = _name("describe-tags-empty")
    create_resp = mq.create_broker(
        BrokerName=name,
        EngineType="RABBITMQ",
        EngineVersion="3.13",
        HostInstanceType="mq.m5.large",
        PubliclyAccessible=False,
        DeploymentMode="SINGLE_INSTANCE",
    )
    broker_id = create_resp["BrokerId"]

    desc = mq.describe_broker(BrokerId=broker_id)
    assert "Tags" in desc
    assert desc["Tags"] == {}
    assert isinstance(desc["Tags"], dict)

def test_mq_describe_broker_tags_reflect_create_tags_additions(mq):
    """Test that DescribeBroker reflects tags added via CreateTags (Line 271)."""
    name = _name("describe-tags-added")
    create_resp = _create(mq, BrokerName=name)
    broker_id = create_resp["BrokerId"]
    arn = create_resp["BrokerArn"]

    # Initially no tags
    desc1 = mq.describe_broker(BrokerId=broker_id)
    assert desc1["Tags"] == {}

    # Add tags
    mq.create_tags(ResourceArn=arn, Tags={"added": "after"})

    # Verify DescribeBroker now shows the tags
    desc2 = mq.describe_broker(BrokerId=broker_id)
    assert desc2["Tags"]["added"] == "after"

############################################################################
# DeleteBrokers
############################################################################

def test_mq_delete_broker(mq):
    name = _name("delete")
    broker_id = _create(mq, BrokerName=name)["BrokerId"]

    del_resp = mq.delete_broker(BrokerId=broker_id)
    assert del_resp["ResponseMetadata"]["HTTPStatusCode"] == 200
    assert del_resp["BrokerId"] == broker_id

def test_mq_delete_broker_with_non_existent_id(mq):
    with pytest.raises(ClientError) as exc:
        mq.delete_broker(BrokerId="invalid-id")
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 404
    assert exc.value.response["Error"]["Code"] == "NotFoundException"

def test_mq_delete_broker_removes_tags(mq):
    """Test that DeleteBroker removes entry from _tags dict (Line 281)."""
    name = _name("delete-tags-cleanup")
    create_resp = mq.create_broker(
        BrokerName=name,
        EngineType="RABBITMQ",
        EngineVersion="3.13",
        HostInstanceType="mq.m5.large",
        PubliclyAccessible=False,
        DeploymentMode="SINGLE_INSTANCE",
        Tags={"cleanup": "test"},
    )
    broker_id = create_resp["BrokerId"]
    broker_arn = create_resp["BrokerArn"]

    # Verify tags exist before delete
    list_resp = mq.list_tags(ResourceArn=broker_arn)
    assert list_resp["Tags"]["cleanup"] == "test"

    # Delete broker
    mq.delete_broker(BrokerId=broker_id)

    # Verify tags are cleaned up - ListTags should fail with 404
    with pytest.raises(ClientError) as exc:
        mq.list_tags(ResourceArn=broker_arn)
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 404

def test_mq_delete_broker_removes_users(mq):
    """Test that DeleteBroker removes entry from _users dict (Line 282)."""
    broker_id = _create(mq, BrokerName=_name("delete-users-cleanup"), EngineType="ACTIVEMQ", EngineVersion="5.19")["BrokerId"]

    # Create a user
    mq.create_user(
        BrokerId=broker_id,
        Username="cleanup_user",
        Password="CleanupPassw0rd!",
        ConsoleAccess=False,
    )

    # Verify user exists
    list_resp = mq.list_users(BrokerId=broker_id)
    usernames = {u["Username"] for u in list_resp.get("Users", [])}
    assert "cleanup_user" in usernames

    # Delete broker
    mq.delete_broker(BrokerId=broker_id)

    # Verify users are cleaned up - ListUsers should fail with 404
    with pytest.raises(ClientError) as exc:
        mq.list_users(BrokerId=broker_id)
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 404

def test_mq_delete_broker_clears_name_index(mq):
    """Test that DeleteBroker cleans up _name_index secondary index."""
    name = _name("delete-name-index")
    broker_id = _create(mq, BrokerName=name)["BrokerId"]

    # Delete broker
    mq.delete_broker(BrokerId=broker_id)

    # Verify name index is cleared - creating broker with same name should succeed
    resp = mq.create_broker(
        BrokerName=name,
        EngineType="RABBITMQ",
        EngineVersion="3.13",
        HostInstanceType="mq.m5.large",
        PubliclyAccessible=False,
        DeploymentMode="SINGLE_INSTANCE",
    )
    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
    assert resp["BrokerId"] != broker_id

############################################################################
# UpdateBroker
############################################################################

def test_mq_update_broker_with_required_options(mq):
    broker_id = _create(mq, BrokerName=_name("update"))["BrokerId"]

    resp = mq.update_broker(
        BrokerId=broker_id,
        HostInstanceType="mq.m5.xlarge",
        AutoMinorVersionUpgrade=True,
    )
    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
    assert resp["BrokerId"] == broker_id
    assert resp["HostInstanceType"] == "mq.m5.xlarge"

def test_mq_update_broker_with_non_existent_id(mq):
    with pytest.raises(ClientError) as exc:
        mq.update_broker(
            BrokerId="invalid-id",
            HostInstanceType="mq.m5.xlarge",
            AutoMinorVersionUpgrade=True,
        )
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 404
    assert exc.value.response["Error"]["Code"] == "NotFoundException"

@pytest.mark.parametrize("update_params", [
    {"HostInstanceType": "INVALID_INSTANCE", "AutoMinorVersionUpgrade": True},
    {"EngineVersion": "INVALID_VERSION", "AutoMinorVersionUpgrade": True},
])
def test_mq_update_broker_with_invalid_options(mq, update_params):
    broker_id = _create(mq, BrokerName=_name("update-invalid"))["BrokerId"]

    with pytest.raises(ClientError) as exc:
        mq.update_broker(BrokerId=broker_id, **update_params)
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 400
    assert exc.value.response["Error"]["Code"] == "BadRequestException"

############################################################################
# RebootBroker
############################################################################

def test_mq_reboot_broker(mq):
    broker_id = _create(mq, BrokerName=_name("reboot"))["BrokerId"]

    resp = mq.reboot_broker(BrokerId=broker_id)
    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200

def test_mq_reboot_broker_with_non_existent_id(mq):
    with pytest.raises(ClientError) as exc:
        mq.reboot_broker(BrokerId="invalid-id")
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 404
    assert exc.value.response["Error"]["Code"] == "NotFoundException"

############################################################################
# DescribeBrokerEngineTypes
############################################################################

def test_mq_describe_broker_engine_types_with_no_params(mq):
    resp = mq.describe_broker_engine_types()
    assert len(resp["BrokerEngineTypes"]) > 0
    assert resp["MaxResults"] == 20

def test_mq_describe_broker_engine_types_with_engine_type(mq):
    resp = mq.describe_broker_engine_types(EngineType="RABBITMQ")
    assert len(resp["BrokerEngineTypes"]) > 0
    assert all(e["EngineType"] == "RABBITMQ" for e in resp["BrokerEngineTypes"])

def test_mq_describe_broker_engine_types_with_invalid_engine_type(mq):
    with pytest.raises(ClientError) as exc:
        mq.describe_broker_engine_types(EngineType="INVALID_ENGINE")
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 400
    assert exc.value.response["Error"]["Code"] == "BadRequestException"

@pytest.mark.parametrize("invalid_max", [4, 101])
def test_mq_describe_broker_engine_types_with_invalid_max_results(mq, invalid_max):
    with pytest.raises(ClientError) as exc:
        mq.describe_broker_engine_types(MaxResults=invalid_max)
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 400
    assert exc.value.response["Error"]["Code"] == "BadRequestException"

########################################################################
# DescribeBrokerInstanceOptions
########################################################################

def test_mq_describe_broker_instance_options(mq):
    resp = mq.describe_broker_instance_options()

    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
    assert len(resp.get("BrokerInstanceOptions", [])) > 0
    for option in resp["BrokerInstanceOptions"]:
        assert "AvailabilityZones" in option
        assert "EngineType" in option
        assert "HostInstanceType" in option
        assert "StorageType" in option
        assert "SupportedEngineVersions" in option
        assert "SupportedDeploymentModes" in option

def test_mq_describe_broker_instance_options_engine_versions_are_strings(mq):
    # SupportedEngineVersions is a list of strings; only DescribeBrokerEngineTypes
    # wraps each version in an object with a Name.
    engine_versions = {
        e["EngineType"]: sorted(v["Name"] for v in e["EngineVersions"])
        for e in mq.describe_broker_engine_types()["BrokerEngineTypes"]
    }
    options = mq.describe_broker_instance_options()["BrokerInstanceOptions"]
    assert options
    for option in options:
        versions = option["SupportedEngineVersions"]
        assert all(isinstance(v, str) for v in versions), versions
        assert sorted(versions) == engine_versions[option["EngineType"]]

@pytest.mark.parametrize(
    "kwargs,assertions",
    [
        (
            {"EngineType": "RABBITMQ"},
            lambda o: o["EngineType"] == "RABBITMQ",
        ),
        (
            {"HostInstanceType": "mq.m5.large"},
            lambda o: o["HostInstanceType"] == "mq.m5.large",
        ),
        (
            {"StorageType": "EBS"},
            lambda o: o["StorageType"] == "EBS",
        ),
        (
            {"EngineType": "RABBITMQ", "HostInstanceType": "mq.m5.large"},
            lambda o: (
                o["EngineType"] == "RABBITMQ"
                and o["HostInstanceType"] == "mq.m5.large"
            ),
        ),
        (
            {"EngineType": "RABBITMQ", "StorageType": "EBS"},
            lambda o: (
                o["EngineType"] == "RABBITMQ"
                and o["StorageType"] == "EBS"
            ),
        ),
        (
            {"HostInstanceType": "mq.m5.large", "StorageType": "EBS"},
            lambda o: (
                o["HostInstanceType"] == "mq.m5.large"
                and o["StorageType"] == "EBS"
            ),
        ),
        (
            {
                "EngineType": "RABBITMQ",
                "HostInstanceType": "mq.m5.large",
                "StorageType": "EBS",
            },
            lambda o: (
                o["EngineType"] == "RABBITMQ"
                and o["HostInstanceType"] == "mq.m5.large"
                and o["StorageType"] == "EBS"
            ),
        ),
    ],
)
def test_mq_broker_instance_options_filtered(mq, kwargs, assertions):
    resp = mq.describe_broker_instance_options(**kwargs)

    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
    assert len(resp.get("BrokerInstanceOptions", [])) > 0
    assert all(assertions(o) for o in resp["BrokerInstanceOptions"])

@pytest.mark.parametrize(
    "kwargs",
    [
        {"EngineType": "INVALID_ENGINE"},
        {"HostInstanceType": "INVALID_INSTANCE"},
        {"StorageType": "INVALID_STORAGE"},
    ],
)
def test_mq_describe_broker_instance_options_with_invalid_parameters(mq, kwargs):
    with pytest.raises(ClientError) as exc:
        mq.describe_broker_instance_options(**kwargs)
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 400
    assert exc.value.response["Error"]["Code"] == "BadRequestException"

def test_mq_describe_broker_instance_options_with_max_results(mq):
    resp = mq.describe_broker_instance_options(MaxResults=5)

    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
    assert resp["MaxResults"] == 5
    assert len(resp.get("BrokerInstanceOptions", [])) == 5

@pytest.mark.parametrize("invalid_max", [4, 101])
def test_mq_describe_broker_instance_options_with_invalid_max_results(mq, invalid_max):
    with pytest.raises(ClientError) as exc:
        mq.describe_broker_instance_options(MaxResults=invalid_max)
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 400
    assert exc.value.response["Error"]["Code"] == "BadRequestException"

def test_mq_describe_broker_instance_options_pagination(mq):
    # Walk all pages with a stable page size and verify pagination progress.
    seen = set()
    token = None
    pages = 0
    while True:
        pages += 1
        kwargs = {"MaxResults": 5}
        if token:
            kwargs["NextToken"] = token

        resp = mq.describe_broker_instance_options(**kwargs)
        assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
        assert resp["MaxResults"] == 5

        items = resp.get("BrokerInstanceOptions", [])
        assert len(items) <= 5

        page_keys = {
            (o["EngineType"], o["HostInstanceType"], o["StorageType"])
            for o in items
        }
        assert page_keys.isdisjoint(seen)
        seen.update(page_keys)

        token = resp.get("NextToken")
        if not token:
            break

        # Safety guard in case pagination regresses.
        assert pages <= 100

    # Ensure pagination actually covered more than one page worth of results.
    assert len(seen) > 5

#########################################################################
# CreateTags
#########################################################################

def test_mq_create_tags(mq):
    broker = _create(mq, BrokerName=_name("tags"))
    arn = broker["BrokerArn"]

    create_resp = mq.create_tags(ResourceArn=arn, Tags={"env": "dev", "team": "core"})
    assert create_resp["ResponseMetadata"]["HTTPStatusCode"] == 204

def test_mq_create_tags_with_non_existent_arn(mq):
    with pytest.raises(ClientError) as exc:
        mq.create_tags(ResourceArn="arn:aws:mq:invalid-arn", Tags={"env": "dev"})
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 404
    assert exc.value.response["Error"]["Code"] == "NotFoundException"

##########################################################################
# ListTags
##########################################################################

def test_mq_list_tags(mq):
    broker = _create(mq, BrokerName=_name("tags"))
    arn = broker["BrokerArn"]

    mq.create_tags(ResourceArn=arn, Tags={"env": "dev", "team": "core"})

    list_resp = mq.list_tags(ResourceArn=arn)
    assert list_resp["ResponseMetadata"]["HTTPStatusCode"] == 200
    assert list_resp["Tags"]["env"] == "dev"
    assert list_resp["Tags"]["team"] == "core"

def test_mq_list_tags_with_no_tags(mq):
    broker = _create(mq, BrokerName=_name("tags"))
    arn = broker["BrokerArn"]

    list_resp = mq.list_tags(ResourceArn=arn)
    assert list_resp["ResponseMetadata"]["HTTPStatusCode"] == 200
    assert list_resp["Tags"] == {}

def test_mq_list_tags_with_non_existent_arn(mq):
    with pytest.raises(ClientError) as exc:
        mq.list_tags(ResourceArn="arn:aws:mq:invalid-arn")
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 404
    assert exc.value.response["Error"]["Code"] == "NotFoundException"


@pytest.mark.parametrize(
    "arn_template",
    [
        "arn:aws:sqs:us-east-1:000000000000:broker:{broker_id}",
        "arn:aws:mq:us-west-2:000000000000:broker:{broker_id}",
        "arn:aws:mq:us-east-1:111111111111:broker:{broker_id}",
    ],
)
def test_mq_tag_arns_must_parse_to_local_broker(mq, arn_template):
    broker = _create(mq, BrokerName=_name("tag-arn"))
    arn = arn_template.format(broker_id=broker["BrokerId"])

    with pytest.raises(ClientError) as exc:
        mq.create_tags(ResourceArn=arn, Tags={"env": "dev"})

    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 404
    assert exc.value.response["Error"]["Code"] == "NotFoundException"


def test_mq_list_tags_multiple_times_consistent(mq):
    """Test that ListTags returns consistent results across multiple calls."""
    broker = _create(mq, BrokerName=_name("tags-consistency"))
    arn = broker["BrokerArn"]

    mq.create_tags(ResourceArn=arn, Tags={"a": "1", "b": "2", "c": "3"})

    # Call ListTags multiple times and verify consistency
    resp1 = mq.list_tags(ResourceArn=arn)
    resp2 = mq.list_tags(ResourceArn=arn)
    resp3 = mq.list_tags(ResourceArn=arn)

    assert resp1["Tags"] == resp2["Tags"] == resp3["Tags"]
    assert len(resp1["Tags"]) == 3

###########################################################################
# DeleteTags
###########################################################################

def test_mq_delete_tags(mq):
    broker = _create(mq, BrokerName=_name("tags"))
    arn = broker["BrokerArn"]

    mq.create_tags(ResourceArn=arn, Tags={"env": "dev", "team": "core"})

    del_resp = mq.delete_tags(ResourceArn=arn, TagKeys=["env"])
    assert del_resp["ResponseMetadata"]["HTTPStatusCode"] == 204

    list_resp = mq.list_tags(ResourceArn=arn)
    assert "env" not in list_resp["Tags"]
    assert list_resp["Tags"]["team"] == "core"

def test_mq_delete_tags_with_non_existent_arn(mq):
    with pytest.raises(ClientError) as exc:
        mq.delete_tags(ResourceArn="arn:aws:mq:invalid-arn", TagKeys=["env"])
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 404
    assert exc.value.response["Error"]["Code"] == "NotFoundException"

def test_mq_delete_tags_idempotent(mq):
    """Test that DeleteTags is idempotent (deleting non-existent key succeeds)."""
    broker = _create(mq, BrokerName=_name("tags-idempotent"))
    arn = broker["BrokerArn"]

    mq.create_tags(ResourceArn=arn, Tags={"key1": "value1"})

    # Delete non-existent key - should succeed
    del_resp = mq.delete_tags(ResourceArn=arn, TagKeys=["nonexistent"])
    assert del_resp["ResponseMetadata"]["HTTPStatusCode"] == 204

    # Verify original tag still exists
    list_resp = mq.list_tags(ResourceArn=arn)
    assert list_resp["Tags"]["key1"] == "value1"

############################################################################
# CreateUser
############################################################################

def test_mq_create_user_with_required_options(mq):
    broker_id = _create(mq, BrokerName=_name("user"), EngineType="ACTIVEMQ", EngineVersion="5.19")["BrokerId"]

    resp = mq.create_user(
        BrokerId=broker_id,
        Username="testuser",
        Password="TestPassw0rd!",
        ConsoleAccess=False,
    )
    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200

def test_mq_create_user_with_duplicated_username(mq):
    broker_id = _create(mq, BrokerName=_name("user"), EngineType="ACTIVEMQ", EngineVersion="5.19")["BrokerId"]

    mq.create_user(
        BrokerId=broker_id,
        Username="testuser",
        Password="TestPassw0rd!",
        ConsoleAccess=False,
    )

    with pytest.raises(ClientError) as exc:
        mq.create_user(
            BrokerId=broker_id,
            Username="testuser",
            Password="AnotherPassw0rd!",
            ConsoleAccess=False,
        )
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 409
    assert exc.value.response["Error"]["Code"] == "ConflictException"

@pytest.mark.parametrize("invalid_password", [
    "pas",            # less than 4 characters
    "password,",  # with commas
    "password:",  # with colons
    "password="  # with equals sign
])
def test_mq_create_user_with_invalid_password(mq, invalid_password):
    broker_id = _create(mq, BrokerName=_name("user"), EngineType="ACTIVEMQ", EngineVersion="5.19")["BrokerId"]
    with pytest.raises(ClientError) as exc:
        mq.create_user(
            BrokerId=broker_id,
            Username="testuser",
            Password=invalid_password,
            ConsoleAccess=False,
        )
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 400
    assert exc.value.response["Error"]["Code"] == "BadRequestException"

def test_mq_create_user_with_non_existent_broker_id(mq):
    with pytest.raises(ClientError) as exc:
        mq.create_user(
            BrokerId="invalid-id",
            Username="testuser",
            Password="TestPassw0rd!",
            ConsoleAccess=False,
        )
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 404
    assert exc.value.response["Error"]["Code"] == "NotFoundException"

def test_mq_create_user_with_not_supported_engine_type(mq):
    broker_id = _create(mq, BrokerName=_name("user-invalid"), EngineType="RABBITMQ", EngineVersion="4.2")["BrokerId"]

    with pytest.raises(ClientError) as exc:
        mq.create_user(
            BrokerId=broker_id,
            Username="testuser",
            Password="TestPassw0rd!",
            ConsoleAccess=False,
        )
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 400
    assert exc.value.response["Error"]["Code"] == "BadRequestException"

##########################################################################
# DeleteUser
##########################################################################

def test_mq_delete_user(mq):
    broker_id = _create(mq, BrokerName=_name("user"), EngineType="ACTIVEMQ", EngineVersion="5.19")["BrokerId"]

    mq.create_user(
        BrokerId=broker_id,
        Username="testuser",
        Password="TestPassw0rd!",
        ConsoleAccess=False,
    )

    del_resp = mq.delete_user(BrokerId=broker_id, Username="testuser")
    assert del_resp["ResponseMetadata"]["HTTPStatusCode"] == 200

def test_mq_delete_user_with_non_existent_username(mq):
    broker_id = _create(mq, BrokerName=_name("user"), EngineType="ACTIVEMQ", EngineVersion="5.19")["BrokerId"]

    with pytest.raises(ClientError) as exc:
        mq.delete_user(BrokerId=broker_id, Username="nonexistentuser")
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 404
    assert exc.value.response["Error"]["Code"] == "NotFoundException"

def test_mq_delete_user_with_non_existent_broker_id(mq):
    with pytest.raises(ClientError) as exc:
        mq.delete_user(BrokerId="invalid-id", Username="testuser")
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 404
    assert exc.value.response["Error"]["Code"] == "NotFoundException"

def test_mq_delete_user_with_not_supported_engine_type(mq):
    broker_id = _create(mq, BrokerName=_name("user-invalid"), EngineType="RABBITMQ", EngineVersion="4.2")["BrokerId"]

    with pytest.raises(ClientError) as exc:
        mq.delete_user(BrokerId=broker_id, Username="testuser")
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 400
    assert exc.value.response["Error"]["Code"] == "BadRequestException"

###########################################################################
# ListUsers
###########################################################################

def test_mq_list_users(mq):
    broker_id = _create(mq, BrokerName=_name("user"), EngineType="ACTIVEMQ", EngineVersion="5.19")["BrokerId"]

    mq.create_user(
        BrokerId=broker_id,
        Username="testuser1",
        Password="TestPassw0rd!",
        ConsoleAccess=False,
    )

    list_resp = mq.list_users(BrokerId=broker_id)
    assert list_resp["ResponseMetadata"]["HTTPStatusCode"] == 200
    assert list_resp["MaxResults"] == 20
    usernames = {u["Username"] for u in list_resp.get("Users", [])}
    assert "testuser1" in usernames

def test_mq_list_users_with_no_users(mq):
    broker_id = _create(mq, BrokerName=_name("user"), EngineType="ACTIVEMQ", EngineVersion="5.19")["BrokerId"]

    list_resp = mq.list_users(BrokerId=broker_id)
    assert list_resp["ResponseMetadata"]["HTTPStatusCode"] == 200
    assert list_resp.get("Users", []) == []
    assert isinstance(list_resp.get("Users", []), list)

def test_mq_list_users_with_non_existent_broker_id(mq):
    with pytest.raises(ClientError) as exc:
        mq.list_users(BrokerId="invalid-id")
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 404
    assert exc.value.response["Error"]["Code"] == "NotFoundException"

def test_mq_list_users_with_not_supported_engine_type(mq):
    broker_id = _create(mq, BrokerName=_name("user-invalid"), EngineType="RABBITMQ")["BrokerId"]

    with pytest.raises(ClientError) as exc:
        mq.list_users(BrokerId=broker_id)
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 400
    assert exc.value.response["Error"]["Code"] == "BadRequestException"

def test_mq_list_users_with_pagination(mq):
    broker_id = _create(mq, BrokerName=_name("user-page"), EngineType="ACTIVEMQ", EngineVersion="5.19")["BrokerId"]

    # Create enough users to require multiple pages.
    expected_usernames = set()
    for i in range(9):
        username = f"testuser{i}"
        expected_usernames.add(username)
        mq.create_user(
            BrokerId=broker_id,
            Username=username,
            Password="TestPassw0rd!",
            ConsoleAccess=False,
        )

    # Paginate with stable MaxResults and gather until all created users are observed.
    listed_usernames = set()
    token = None
    pages = 0
    while True:
        pages += 1
        kwargs = {"BrokerId": broker_id, "MaxResults": 5}
        if token:
            kwargs["NextToken"] = token

        resp = mq.list_users(**kwargs)
        assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
        assert resp["MaxResults"] == 5
        assert len(resp.get("Users", [])) <= 5

        listed_usernames.update({u["Username"] for u in resp.get("Users", [])})
        if expected_usernames.issubset(listed_usernames):
            break

        token = resp.get("NextToken")
        if not token:
            break

        # Safety guard in case pagination regresses.
        assert pages <= 100

    assert expected_usernames.issubset(listed_usernames), f"Expected {expected_usernames} in {listed_usernames}"

@pytest.mark.parametrize("invalid_max", [4, 101])
def test_mq_list_users_with_invalid_max_results(mq, invalid_max):
    broker_id = _create(mq, BrokerName=_name("user-invalid-max"), EngineType="ACTIVEMQ", EngineVersion="5.19")["BrokerId"]

    with pytest.raises(ClientError) as exc:
        mq.list_users(BrokerId=broker_id, MaxResults=invalid_max)
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 400
    assert exc.value.response["Error"]["Code"] == "BadRequestException"

############################################################################
# UpdateUser
############################################################################

def test_mq_update_user(mq):
    broker_id = _create(mq, BrokerName=_name("user"), EngineType="ACTIVEMQ", EngineVersion="5.19")["BrokerId"]

    mq.create_user(
        BrokerId=broker_id,
        Username="full_update_user",
        Password="InitialPassw0rd!",
        ConsoleAccess=False,
        Groups=["users"],
        ReplicationUser=False,
    )

    # Update all fields
    mq.update_user(
        BrokerId=broker_id,
        Username="full_update_user",
        Password="UpdatedPassw0rd!",
        ConsoleAccess=True,
        Groups=["admins", "ops"],
        ReplicationUser=True,
    )

    # Verify updates
    user = mq.describe_user(BrokerId=broker_id, Username="full_update_user")
    assert user["ConsoleAccess"]
    assert set(user["Groups"]) == {"admins", "ops"}
    assert user["ReplicationUser"]

def test_mq_update_user_with_non_existent_username(mq):
    broker_id = _create(mq, BrokerName=_name("user"), EngineType="ACTIVEMQ", EngineVersion="5.19")["BrokerId"]

    with pytest.raises(ClientError) as exc:
        mq.update_user(
            BrokerId=broker_id,
            Username="nonexistentuser",
            Password="NewPassw0rd!",
            ConsoleAccess=True,
        )
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 404
    assert exc.value.response["Error"]["Code"] == "NotFoundException"

def test_mq_update_user_with_non_existent_broker_id(mq):
    with pytest.raises(ClientError) as exc:
        mq.update_user(
            BrokerId="invalid-id",
            Username="testuser",
            Password="NewPassw0rd!",
            ConsoleAccess=True,
        )
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 404
    assert exc.value.response["Error"]["Code"] == "NotFoundException"

def test_mq_update_user_with_not_supported_engine_type(mq):
    broker_id = _create(mq, BrokerName=_name("user-invalid-update"), EngineType="RABBITMQ")["BrokerId"]

    with pytest.raises(ClientError) as exc:
        mq.update_user(
            BrokerId=broker_id,
            Username="testuser",
            Password="NewPassw0rd!",
            ConsoleAccess=True,
        )
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 400
    assert exc.value.response["Error"]["Code"] == "BadRequestException"

@pytest.mark.parametrize("invalid_password", [
    "pas",            # less than 4 characters
    "password,",  # with commas
    "password:",  # with colons
    "password="  # with equals sign
])
def test_mq_update_user_with_invalid_password(mq, invalid_password):
    broker_id = _create(mq, BrokerName=_name("user-invalid-update"), EngineType="ACTIVEMQ", EngineVersion="5.19")["BrokerId"]

    mq.create_user(
        BrokerId=broker_id,
        Username="testuser",
        Password="TestPassw0rd!",
        ConsoleAccess=False,
    )

    with pytest.raises(ClientError) as exc:
        mq.update_user(
            BrokerId=broker_id,
            Username="testuser",
            Password=invalid_password,
        )
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 400
    assert exc.value.response["Error"]["Code"] == "BadRequestException"

############################################################################
# DescribeUser
############################################################################

def test_mq_describe_user(mq):
    broker_id = _create(mq, BrokerName=_name("user"), EngineType="ACTIVEMQ", EngineVersion="5.19")["BrokerId"]

    mq.create_user(
        BrokerId=broker_id,
        Username="testuser",
        Password="TestPassw0rd!",
        ConsoleAccess=False,
        Groups=["group1", "group2"],
        ReplicationUser = True
    )

    desc_resp = mq.describe_user(BrokerId=broker_id, Username="testuser")
    assert desc_resp["ResponseMetadata"]["HTTPStatusCode"] == 200
    assert desc_resp["Username"] == "testuser"
    assert desc_resp["ConsoleAccess"] is False
    assert set(desc_resp["Groups"]) == {"group1", "group2"}
    assert desc_resp["ReplicationUser"] is True

def test_mq_describe_user_with_non_existent_username(mq):
    broker_id = _create(mq, BrokerName=_name("user"), EngineType="ACTIVEMQ", EngineVersion="5.19")["BrokerId"]

    with pytest.raises(ClientError) as exc:
        mq.describe_user(BrokerId=broker_id, Username="nonexistentuser")
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 404
    assert exc.value.response["Error"]["Code"] == "NotFoundException"

def test_mq_describe_user_with_non_existent_broker_id(mq):
    with pytest.raises(ClientError) as exc:
        mq.describe_user(BrokerId="invalid-id", Username="testuser")
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 404
    assert exc.value.response["Error"]["Code"] == "NotFoundException"

def test_mq_describe_user_with_not_supported_engine_type(mq):
    broker_id = _create(mq, BrokerName=_name("user-invalid-describe"), EngineType="RABBITMQ")["BrokerId"]

    with pytest.raises(ClientError) as exc:
        mq.describe_user(BrokerId=broker_id, Username="testuser")
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 400
    assert exc.value.response["Error"]["Code"] == "BadRequestException"


############################################################################
# Lifecycle tests
############################################################################

def test_mq_create_describe_delete_broker_tags_lifecycle(mq):
    """Test full lifecycle: create with tags -> describe shows tags -> delete removes tags."""
    name = _name("lifecycle-tags")

    # 1. Create broker with tags
    create_resp = mq.create_broker(
        BrokerName=name,
        EngineType="RABBITMQ",
        EngineVersion="3.13",
        HostInstanceType="mq.m5.large",
        PubliclyAccessible=False,
        DeploymentMode="SINGLE_INSTANCE",
        Tags={"lifecycle": "test", "phase": "all"},
    )
    broker_id = create_resp["BrokerId"]
    broker_arn = create_resp["BrokerArn"]

    # 2. Describe broker and verify tags included
    desc = mq.describe_broker(BrokerId=broker_id)
    assert desc["Tags"]["lifecycle"] == "test"
    assert desc["Tags"]["phase"] == "all"

    # 3. Add more tags
    mq.create_tags(ResourceArn=broker_arn, Tags={"added": "later"})

    # 4. Verify describe shows all tags
    desc2 = mq.describe_broker(BrokerId=broker_id)
    assert desc2["Tags"]["lifecycle"] == "test"
    assert desc2["Tags"]["phase"] == "all"
    assert desc2["Tags"]["added"] == "later"

    # 5. Delete broker
    mq.delete_broker(BrokerId=broker_id)

    # 6. Verify tags are cleaned up
    with pytest.raises(ClientError) as exc:
        mq.list_tags(ResourceArn=broker_arn)
    assert exc.value.response["ResponseMetadata"]["HTTPStatusCode"] == 404


def test_mq_multiple_brokers_isolated_tags(mq):
    """Test that tags from different brokers don't interfere with each other."""
    # Create two brokers with different tags
    name1 = _name("isolated-1")
    resp1 = mq.create_broker(
        BrokerName=name1,
        EngineType="RABBITMQ",
        EngineVersion="3.13",
        HostInstanceType="mq.m5.large",
        PubliclyAccessible=False,
        DeploymentMode="SINGLE_INSTANCE",
        Tags={"broker": "first", "env": "prod"},
    )
    arn1 = resp1["BrokerArn"]

    name2 = _name("isolated-2")
    resp2 = mq.create_broker(
        BrokerName=name2,
        EngineType="RABBITMQ",
        EngineVersion="3.13",
        HostInstanceType="mq.m5.large",
        PubliclyAccessible=False,
        DeploymentMode="SINGLE_INSTANCE",
        Tags={"broker": "second", "env": "dev"},
    )
    arn2 = resp2["BrokerArn"]

    # Verify each broker has its own isolated tags
    tags1 = mq.list_tags(ResourceArn=arn1)["Tags"]
    tags2 = mq.list_tags(ResourceArn=arn2)["Tags"]

    assert tags1["broker"] == "first"
    assert tags1["env"] == "prod"
    assert tags2["broker"] == "second"
    assert tags2["env"] == "dev"


def test_mq_multiple_brokers_isolated_users(mq):
    """Test that users from different brokers don't interfere with each other."""
    # Create two ActiveMQ brokers
    broker_id1 = _create(mq, BrokerName=_name("users-isolated-1"), EngineType="ACTIVEMQ", EngineVersion="5.19")["BrokerId"]
    broker_id2 = _create(mq, BrokerName=_name("users-isolated-2"), EngineType="ACTIVEMQ", EngineVersion="5.19")["BrokerId"]

    # Create users with same username in different brokers
    mq.create_user(
        BrokerId=broker_id1,
        Username="shared_name",
        Password="Broker1Passw0rd!",
        ConsoleAccess=True,
    )

    mq.create_user(
        BrokerId=broker_id2,
        Username="shared_name",
        Password="Broker2Passw0rd!",
        ConsoleAccess=False,
    )

    # Verify users are isolated
    user1 = mq.describe_user(BrokerId=broker_id1, Username="shared_name")
    user2 = mq.describe_user(BrokerId=broker_id2, Username="shared_name")

    assert user1 is not None
    assert user2 is not None
    assert user1["ConsoleAccess"]
    assert not user2["ConsoleAccess"]


def test_mq_recreate_broker_after_delete_has_fresh_tags_and_users(mq):
    """Test that recreating a broker after deletion starts with fresh tag/user dicts."""
    name = _name("recreate-fresh")

    # Create, add tags/users, and delete
    resp1 = mq.create_broker(
        BrokerName=name,
        EngineType="ACTIVEMQ",
        EngineVersion="5.19",
        HostInstanceType="mq.m5.large",
        PubliclyAccessible=False,
        DeploymentMode="SINGLE_INSTANCE",
        Tags={"first": "creation"},
    )
    broker_id1 = resp1["BrokerId"]
    broker_arn1 = resp1["BrokerArn"]

    # Add a user
    mq.create_user(
        BrokerId=broker_id1,
        Username="first_user",
        Password="FirstPassw0rd!",
        ConsoleAccess=True,
    )

    # Delete the broker
    mq.delete_broker(BrokerId=broker_id1)

    # Recreate broker with same name
    resp2 = mq.create_broker(
        BrokerName=name,
        EngineType="ACTIVEMQ",
        EngineVersion="5.19",
        HostInstanceType="mq.m5.large",
        PubliclyAccessible=False,
        DeploymentMode="SINGLE_INSTANCE",
    )
    broker_id2 = resp2["BrokerId"]
    broker_arn2 = resp2["BrokerArn"]

    # Verify fresh state
    tags = mq.list_tags(ResourceArn=broker_arn2)["Tags"]
    users = mq.list_users(BrokerId=broker_id2)["Users"]

    assert tags == {}
    assert users == []

    # Verify old ARN is different from new ARN
    assert broker_arn1 != broker_arn2


def _regional_broker_body(name):
    return {
        "brokerName": name,
        "engineType": "ACTIVEMQ",
        "engineVersion": "5.19",
        "hostInstanceType": "mq.m5.large",
        "publiclyAccessible": False,
        "deploymentMode": "SINGLE_INSTANCE",
    }


def test_mq_brokers_are_isolated_by_region(isolated_mq_module_state):
    import json

    from ministack.core.responses import set_request_region

    service = isolated_mq_module_state
    broker_name = "regional-shared-name"

    east_status, _headers, east_body = service._create_broker(
        _regional_broker_body(broker_name)
    )
    east_broker_id = json.loads(east_body)["brokerId"]

    set_request_region("us-west-2")
    west_status, _headers, west_body = service._create_broker(
        _regional_broker_body(broker_name)
    )
    west_broker_id = json.loads(west_body)["brokerId"]

    assert east_status == west_status == 200
    assert east_broker_id != west_broker_id
    _status, _headers, west_list_body = service._list_brokers({})
    assert [b["brokerId"] for b in json.loads(west_list_body)["brokerSummaries"]] == [
        west_broker_id
    ]
    assert service._describe_broker(east_broker_id)[0] == 404

    set_request_region("us-east-1")
    _status, _headers, east_list_body = service._list_brokers({})
    assert [b["brokerId"] for b in json.loads(east_list_body)["brokerSummaries"]] == [
        east_broker_id
    ]
    assert service._create_broker(_regional_broker_body(broker_name))[0] == 409


def test_mq_legacy_state_follows_parent_broker_region(isolated_mq_module_state):
    from ministack.core.responses import AccountScopedDict

    service = isolated_mq_module_state
    account_id = "111111111111"
    broker_id = "legacy-broker-id"
    broker_name = "legacy-broker"
    broker_arn = f"arn:aws:mq:us-west-2:{account_id}:broker:{broker_id}"

    brokers = AccountScopedDict()
    brokers.set_scoped(account_id, "ignored", broker_id, {
        "brokerId": broker_id,
        "brokerName": broker_name,
        "brokerArn": broker_arn,
    })
    name_index = AccountScopedDict()
    name_index.set_scoped(account_id, "ignored", broker_name, broker_id)
    tags = AccountScopedDict()
    tags.set_scoped(account_id, "ignored", broker_arn, {"env": "legacy"})
    users = AccountScopedDict()
    users.set_scoped(account_id, "ignored", broker_id, {
        "legacy-user": {"username": "legacy-user"}
    })

    service.load_persisted_state({
        "brokers": brokers,
        "name_index": name_index,
        "tags": tags,
        "users": users,
    })

    assert service._brokers.get_scoped(account_id, "us-west-2", broker_id) is not None
    assert service._brokers.get_scoped(account_id, "us-east-1", broker_id) is None
    assert service._name_index.get_scoped(account_id, "us-west-2", broker_name) == broker_id
    assert "legacy-user" in service._users.get_scoped(account_id, "us-west-2", broker_id)
    assert service._tags.get_scoped(account_id, "ignored", broker_arn) == {"env": "legacy"}


def test_mq_legacy_orphaned_users_are_dropped(isolated_mq_module_state):
    from ministack.core.responses import AccountScopedDict

    service = isolated_mq_module_state
    account_id = "111111111111"
    users = AccountScopedDict()
    users.set_scoped(account_id, "ignored", "missing-broker-id", {
        "orphaned-user": {"username": "orphaned-user"}
    })

    service.load_persisted_state({"users": users})

    assert not service._users.has_any()


def test_mq_reset_clears_all_regions(isolated_mq_module_state):
    from ministack.core.responses import set_request_region

    service = isolated_mq_module_state
    assert service._create_broker(_regional_broker_body("east-broker"))[0] == 200
    set_request_region("us-west-2")
    assert service._create_broker(_regional_broker_body("west-broker"))[0] == 200

    service.reset()

    assert not service._brokers.has_any()
    assert not service._name_index.has_any()
    assert not service._users.has_any()
    assert service._tags._data == {}