Ministack: Free, open-source local AWS emulator - 60+ services, Terraform compatible, real databases. Free forever. MIT licensed.
Python awsaws-emulatoraws-localaws-sdkdevtoolsdockerdynamodbec2emulatorlambdalocalstacklocalstack-alternativeministackmock-awsopen-sourcepythons3sqsterraform
"""AWS Resource Groups (resource-groups, 2017-11-27) tests.
Driven via boto3 to lock the wire format against the real
botocore service-2.json. Tag-sync operations are intentionally not
exercised — they aren't reachable through the AWS CLI or Terraform.
"""
import json
import os
import uuid
import boto3
import pytest
from botocore.config import Config
from botocore.exceptions import ClientError
ENDPOINT = os.environ.get("MINISTACK_ENDPOINT", "http://localhost:4566")
REGION = "us-east-1"
def _client(account="test", region=REGION):
return boto3.client(
"resource-groups",
endpoint_url=ENDPOINT,
region_name=region,
aws_access_key_id=account,
aws_secret_access_key="test",
config=Config(retries={"mode": "standard"}),
)
@pytest.fixture(scope="module")
def rg():
return _client()
def _uid():
return uuid.uuid4().hex[:6]
def _tag_query(key="env", value="test"):
return {
"Type": "TAG_FILTERS_1_0",
"Query": json.dumps({
"ResourceTypeFilters": ["AWS::AllSupported"],
"TagFilters": [{"Key": key, "Values": [value]}],
}),
}
# ---------------------------------------------------------------------------
# Group CRUD
# ---------------------------------------------------------------------------
def test_create_group_with_resource_query(rg):
name = f"g-{_uid()}"
resp = rg.create_group(Name=name, Description="x", ResourceQuery=_tag_query())
assert resp["Group"]["Name"] == name
assert resp["Group"]["GroupArn"].endswith(f":group/{name}")
assert resp["ResourceQuery"]["Type"] == "TAG_FILTERS_1_0"
rg.delete_group(Group=name)
def test_create_group_duplicate_rejected(rg):
name = f"g-{_uid()}"
rg.create_group(Name=name, ResourceQuery=_tag_query())
try:
with pytest.raises(ClientError) as exc:
rg.create_group(Name=name, ResourceQuery=_tag_query())
assert exc.value.response["Error"]["Code"] == "BadRequestException"
finally:
rg.delete_group(Group=name)
def test_create_group_invalid_query_type_rejected(rg):
with pytest.raises(ClientError) as exc:
rg.create_group(Name=f"g-{_uid()}", ResourceQuery={"Type": "INVALID", "Query": "{}"})
assert exc.value.response["Error"]["Code"] == "BadRequestException"
def test_get_group_by_name_and_by_arn(rg):
name = f"g-{_uid()}"
arn = rg.create_group(Name=name, ResourceQuery=_tag_query())["Group"]["GroupArn"]
try:
by_name = rg.get_group(GroupName=name)
by_arn = rg.get_group(Group=arn)
assert by_name["Group"]["Name"] == name
assert by_arn["Group"]["Name"] == name
finally:
rg.delete_group(Group=name)
def test_group_arn_region_and_account_must_match_request(rg):
name = f"g-{_uid()}"
arn = rg.create_group(Name=name, ResourceQuery=_tag_query())["Group"]["GroupArn"]
foreign_region = arn.replace(":us-east-1:", ":us-west-2:")
foreign_account = arn.replace(":000000000000:", ":111111111111:")
try:
for group_arn in (foreign_region, foreign_account):
with pytest.raises(ClientError) as exc:
rg.get_group(Group=group_arn)
assert exc.value.response["Error"]["Code"] == "NotFoundException"
with pytest.raises(ClientError) as exc:
rg.tag(Arn=group_arn, Tags={"env": "foreign"})
assert exc.value.response["Error"]["Code"] == "NotFoundException"
assert rg.get_group(Group=arn)["Group"]["Name"] == name
finally:
rg.delete_group(Group=name)
def test_malformed_group_arn_does_not_resolve_as_group_name(rg):
name = f"g-{_uid()}"
rg.create_group(Name=name, ResourceQuery=_tag_query())
try:
malformed = f"arn:aws:resource-groups:us-east-1:000000000000:group/{name}:extra"
invalid_partition = f"arn:notaws:resource-groups:us-east-1:000000000000:group/{name}"
wrong_service = f"arn:aws:sns:us-east-1:000000000000:group/{name}"
for group_arn in (malformed, invalid_partition, wrong_service):
with pytest.raises(ClientError) as exc:
rg.get_group(Group=group_arn)
assert exc.value.response["Error"]["Code"] == "BadRequestException"
finally:
rg.delete_group(Group=name)
def test_get_group_not_found(rg):
with pytest.raises(ClientError) as exc:
rg.get_group(GroupName=f"missing-{_uid()}")
assert exc.value.response["Error"]["Code"] == "NotFoundException"
def test_update_group_fields_persist(rg):
name = f"g-{_uid()}"
rg.create_group(Name=name, ResourceQuery=_tag_query())
try:
rg.update_group(
GroupName=name,
Description="updated",
Criticality=3,
Owner="ops",
DisplayName="Group X",
)
out = rg.get_group(GroupName=name)["Group"]
assert out["Description"] == "updated"
assert out["Criticality"] == 3
assert out["Owner"] == "ops"
assert out["DisplayName"] == "Group X"
finally:
rg.delete_group(Group=name)
def test_delete_group_returns_group_record(rg):
name = f"g-{_uid()}"
rg.create_group(Name=name, ResourceQuery=_tag_query())
out = rg.delete_group(Group=name)
assert out["Group"]["Name"] == name
with pytest.raises(ClientError):
rg.get_group(GroupName=name)
def test_list_groups(rg):
name = f"g-{_uid()}"
rg.create_group(Name=name, ResourceQuery=_tag_query())
try:
out = rg.list_groups()
names = [g["GroupName"] for g in out["GroupIdentifiers"]]
assert name in names
finally:
rg.delete_group(Group=name)
# ---------------------------------------------------------------------------
# Group query + configuration
# ---------------------------------------------------------------------------
def test_get_and_update_group_query(rg):
name = f"g-{_uid()}"
rg.create_group(Name=name, ResourceQuery=_tag_query("env", "dev"))
try:
gq = rg.get_group_query(GroupName=name)["GroupQuery"]
assert gq["GroupName"] == name
assert gq["ResourceQuery"]["Type"] == "TAG_FILTERS_1_0"
new_query = _tag_query("env", "prod")
rg.update_group_query(GroupName=name, ResourceQuery=new_query)
gq2 = rg.get_group_query(GroupName=name)["GroupQuery"]
body = json.loads(gq2["ResourceQuery"]["Query"])
assert body["TagFilters"][0]["Values"] == ["prod"]
finally:
rg.delete_group(Group=name)
def test_put_and_get_group_configuration(rg):
name = f"g-{_uid()}"
rg.create_group(Name=name, ResourceQuery=_tag_query())
try:
cfg = [{"Type": "AWS::ResourceGroups::Generic", "Parameters": [
{"Name": "allowed-resource-types", "Values": ["AWS::EC2::Instance"]}
]}]
rg.put_group_configuration(Group=name, Configuration=cfg)
out = rg.get_group_configuration(Group=name)["GroupConfiguration"]
assert out["Status"] == "UPDATE_COMPLETE"
assert out["Configuration"][0]["Type"] == "AWS::ResourceGroups::Generic"
finally:
rg.delete_group(Group=name)
# ---------------------------------------------------------------------------
# Group membership
# ---------------------------------------------------------------------------
def test_group_and_ungroup_and_list_resources(rg):
name = f"g-{_uid()}"
rg.create_group(Name=name, ResourceQuery=_tag_query())
try:
arns = [
"arn:aws:ec2:us-east-1:000000000000:instance/i-aaa",
"arn:aws:ec2:us-east-1:000000000000:instance/i-bbb",
"arn:aws:s3:::some-bucket",
]
out = rg.group_resources(Group=name, ResourceArns=arns)
assert sorted(out["Succeeded"]) == sorted(arns)
assert out["Failed"] == []
listed = rg.list_group_resources(GroupName=name)
listed_arns = [r["ResourceArn"] for r in listed["ResourceIdentifiers"]]
assert sorted(listed_arns) == sorted(arns)
for r in listed["Resources"]:
assert r["Status"]["Name"] == "ACTIVE"
# resource-type filter
ec2_only = rg.list_group_resources(
GroupName=name,
Filters=[{"Name": "resource-type", "Values": ["AWS::EC2::Instance"]}],
)
assert all(
r["ResourceType"] == "AWS::EC2::Instance"
for r in ec2_only["ResourceIdentifiers"]
)
assert len(ec2_only["ResourceIdentifiers"]) == 2
rg.ungroup_resources(Group=name, ResourceArns=[arns[0]])
after = rg.list_group_resources(GroupName=name)
after_arns = {r["ResourceArn"] for r in after["ResourceIdentifiers"]}
assert arns[0] not in after_arns
assert arns[1] in after_arns
finally:
rg.delete_group(Group=name)
def test_group_resources_rejects_malformed_resource_arn(rg):
name = f"g-{_uid()}"
rg.create_group(Name=name, ResourceQuery=_tag_query())
try:
valid = "arn:aws:ec2:us-east-1:000000000000:instance/i-aaa"
malformed = "arn:aws:ec2:us-east-1:000000000000"
invalid_partition = "arn:notaws:ec2:us-east-1:000000000000:instance/i-aaa"
for resource_arn in (malformed, invalid_partition):
with pytest.raises(ClientError) as exc:
rg.group_resources(Group=name, ResourceArns=[valid, resource_arn])
assert exc.value.response["Error"]["Code"] == "BadRequestException"
assert rg.list_group_resources(GroupName=name)["ResourceIdentifiers"] == []
finally:
rg.delete_group(Group=name)
def test_group_resources_failed_request_does_not_partially_mutate_existing_members(rg):
name = f"g-{_uid()}"
rg.create_group(Name=name, ResourceQuery=_tag_query())
try:
existing = "arn:aws:ec2:us-east-1:000000000000:instance/i-existing"
valid = "arn:aws:ec2:us-east-1:000000000000:instance/i-new"
malformed = "arn:aws:ec2:us-east-1:000000000000"
rg.group_resources(Group=name, ResourceArns=[existing])
with pytest.raises(ClientError) as exc:
rg.group_resources(Group=name, ResourceArns=[valid, malformed])
assert exc.value.response["Error"]["Code"] == "BadRequestException"
listed = rg.list_group_resources(GroupName=name)["ResourceIdentifiers"]
assert [resource["ResourceArn"] for resource in listed] == [existing]
finally:
rg.delete_group(Group=name)
def test_ungroup_resources_failed_request_does_not_partially_mutate_existing_members(rg):
name = f"g-{_uid()}"
rg.create_group(Name=name, ResourceQuery=_tag_query())
try:
keep = "arn:aws:ec2:us-east-1:000000000000:instance/i-keep"
remove = "arn:aws:ec2:us-east-1:000000000000:instance/i-remove"
malformed = "arn:aws:ec2:us-east-1:000000000000"
rg.group_resources(Group=name, ResourceArns=[keep, remove])
with pytest.raises(ClientError) as exc:
rg.ungroup_resources(Group=name, ResourceArns=[remove, malformed])
assert exc.value.response["Error"]["Code"] == "BadRequestException"
listed = rg.list_group_resources(GroupName=name)["ResourceIdentifiers"]
assert [resource["ResourceArn"] for resource in listed] == [keep, remove]
finally:
rg.delete_group(Group=name)
def test_list_grouping_statuses(rg):
name = f"g-{_uid()}"
rg.create_group(Name=name, ResourceQuery=_tag_query())
try:
rg.group_resources(Group=name, ResourceArns=[
"arn:aws:ec2:us-east-1:000000000000:instance/i-zzz"
])
out = rg.list_grouping_statuses(Group=name)
assert out["Group"].endswith(f":group/{name}")
assert out["GroupingStatuses"][0]["Status"] == "SUCCESS"
assert out["GroupingStatuses"][0]["Action"] == "GROUP"
finally:
rg.delete_group(Group=name)
def test_search_resources_returns_empty_with_round_tripped_pagination(rg):
out = rg.search_resources(ResourceQuery=_tag_query(), MaxResults=10)
assert out["ResourceIdentifiers"] == []
assert out["QueryErrors"] == []
# ---------------------------------------------------------------------------
# Tags
# ---------------------------------------------------------------------------
def test_tag_untag_get_tags_lifecycle(rg):
name = f"g-{_uid()}"
arn = rg.create_group(Name=name, ResourceQuery=_tag_query())["Group"]["GroupArn"]
try:
rg.tag(Arn=arn, Tags={"env": "test", "owner": "ministack"})
got = rg.get_tags(Arn=arn)
assert got["Arn"] == arn
assert got["Tags"] == {"env": "test", "owner": "ministack"}
rg.untag(Arn=arn, Keys=["env"])
got2 = rg.get_tags(Arn=arn)
assert "env" not in got2["Tags"]
assert got2["Tags"]["owner"] == "ministack"
finally:
rg.delete_group(Group=name)
def test_tag_unknown_arn_returns_404(rg):
bogus = "arn:aws:resource-groups:us-east-1:000000000000:group/does-not-exist"
with pytest.raises(ClientError) as exc:
rg.tag(Arn=bogus, Tags={"k": "v"})
assert exc.value.response["Error"]["Code"] == "NotFoundException"
# ---------------------------------------------------------------------------
# Account settings
# ---------------------------------------------------------------------------
def test_get_and_update_account_settings(rg):
out = rg.get_account_settings()
assert "GroupLifecycleEventsDesiredStatus" in out["AccountSettings"]
rg.update_account_settings(GroupLifecycleEventsDesiredStatus="ACTIVE")
out2 = rg.get_account_settings()
assert out2["AccountSettings"]["GroupLifecycleEventsDesiredStatus"] == "ACTIVE"
# reset to INACTIVE so other tests/modules see a clean default
rg.update_account_settings(GroupLifecycleEventsDesiredStatus="INACTIVE")
def test_update_account_settings_invalid_value_rejected(rg):
with pytest.raises(ClientError) as exc:
rg.update_account_settings(GroupLifecycleEventsDesiredStatus="MAYBE")
assert exc.value.response["Error"]["Code"] == "BadRequestException"
# ---------------------------------------------------------------------------
# Multi-tenancy
# ---------------------------------------------------------------------------
def test_account_isolation_for_groups():
a = _client("111111111111")
b = _client("222222222222")
name = f"acct-{_uid()}"
a.create_group(Name=name, ResourceQuery=_tag_query())
try:
a_names = {g["GroupName"] for g in a.list_groups()["GroupIdentifiers"]}
b_names = {g["GroupName"] for g in b.list_groups()["GroupIdentifiers"]}
assert name in a_names
assert name not in b_names
with pytest.raises(ClientError) as exc:
b.get_group(GroupName=name)
assert exc.value.response["Error"]["Code"] == "NotFoundException"
finally:
a.delete_group(Group=name)
def test_region_isolation_for_groups_and_account_settings():
east = _client(region="us-east-1")
west = _client(region="us-west-2")
name = f"region-{_uid()}"
east.create_group(
Name=name,
Description="east",
ResourceQuery=_tag_query("region", "east"),
)
west.create_group(
Name=name,
Description="west",
ResourceQuery=_tag_query("region", "west"),
)
try:
east_group = east.get_group(GroupName=name)["Group"]
west_group = west.get_group(GroupName=name)["Group"]
assert east_group["Description"] == "east"
assert west_group["Description"] == "west"
assert ":us-east-1:" in east_group["GroupArn"]
assert ":us-west-2:" in west_group["GroupArn"]
east.update_account_settings(GroupLifecycleEventsDesiredStatus="ACTIVE")
assert (
east.get_account_settings()["AccountSettings"][
"GroupLifecycleEventsDesiredStatus"
]
== "ACTIVE"
)
assert (
west.get_account_settings()["AccountSettings"][
"GroupLifecycleEventsDesiredStatus"
]
== "INACTIVE"
)
finally:
east.update_account_settings(GroupLifecycleEventsDesiredStatus="INACTIVE")
east.delete_group(Group=name)
west.delete_group(Group=name)
def test_restore_legacy_child_state_uses_parent_group_region():
from ministack.core.responses import (
AccountScopedDict,
set_request_account_id,
set_request_region,
)
from ministack.services import resource_groups as service
account_id = "111111111111"
group_name = "legacy-group"
resource_region = "us-west-2"
boot_region = "us-east-1"
groups = AccountScopedDict()
queries = AccountScopedDict()
set_request_account_id(account_id)
set_request_region(boot_region)
groups[group_name] = {
"GroupArn": (
f"arn:aws:resource-groups:{resource_region}:{account_id}:"
f"group/{group_name}"
),
"Name": group_name,
}
queries[group_name] = _tag_query("region", "legacy")
service.reset()
try:
service.load_persisted_state({"groups": groups, "group_queries": queries})
assert service._groups.get_scoped(
account_id, resource_region, group_name
)["Name"] == group_name
assert service._group_queries.get_scoped(
account_id, resource_region, group_name
) == _tag_query("region", "legacy")
assert service._group_queries.get_scoped(
account_id, boot_region, group_name
) is None
finally:
service.reset()