Skip to content

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

Add Resource Groups Tagging API - Phase 2 (GetTagKeys, GetTagValues + 9 services) (#379) (#380)

Akhil adiga703dc5937855
diff --git a/ministack/services/tagging.py b/ministack/services/tagging.py
index 7cb208c2..a1f48fa3 100644
--- a/ministack/services/tagging.py
+++ b/ministack/services/tagging.py
@@ -1,6 +1,6 @@
"""
Resource Groups Tagging API emulator.
-Phase 1: GetResources across S3, Lambda, SQS, SNS, DynamoDB, EventBridge.
+Phase 2: extends GetResources to 15 services and adds GetTagKeys, GetTagValues.
"""
import json
@@ -23,6 +23,16 @@ def _normalise_list(tag_list):
return tag_list or []
+def _normalise_kms(tag_list):
+ """Convert KMS [{"TagKey": k, "TagValue": v}] to standard format."""
+ return [{"Key": t["TagKey"], "Value": t["TagValue"]} for t in (tag_list or [])]
+
+
+def _normalise_ecs(tag_list):
+ """Convert ECS [{"key": k, "value": v}] (lowercase) to standard format."""
+ return [{"Key": t["key"], "Value": t["value"]} for t in (tag_list or [])]
+
+
# ── Per-service tag collectors ────────────────────────────────────────────────
def _collect_s3():
@@ -64,14 +74,90 @@ def _collect_eventbridge():
yield arn, _normalise_flat(tags)
+def _collect_kms():
+ import ministack.services.kms as svc
+ for key_id, rec in svc._keys.items():
+ arn = f"arn:aws:kms:{REGION}:{_account()}:key/{key_id}"
+ yield arn, _normalise_kms(rec.get("Tags", []))
+
+
+def _collect_ecr():
+ import ministack.services.ecr as svc
+ for name, repo in svc._repositories.items():
+ arn = f"arn:aws:ecr:{REGION}:{_account()}:repository/{name}"
+ yield arn, _normalise_list(repo.get("tags", []))
+
+
+def _collect_ecs():
+ import ministack.services.ecs as svc
+ for arn, tags in svc._tags.items():
+ yield arn, _normalise_ecs(tags)
+
+
+def _collect_glue():
+ import ministack.services.glue as svc
+ for arn, tags in svc._tags.items():
+ yield arn, _normalise_flat(tags)
+
+
+def _collect_cognito():
+ import ministack.services.cognito as svc
+ for pool_id, pool in svc._user_pools.items():
+ arn = f"arn:aws:cognito-idp:{REGION}:{_account()}:userpool/{pool_id}"
+ yield arn, _normalise_flat(pool.get("UserPoolTags", {}))
+ for pool_id, tags in svc._identity_tags.items():
+ arn = f"arn:aws:cognito-identity:{REGION}:{_account()}:identitypool/{pool_id}"
+ yield arn, _normalise_flat(tags)
+
+
+def _collect_appsync():
+ import ministack.services.appsync as svc
+ for arn, tags in svc._tags.items():
+ yield arn, _normalise_flat(tags)
+
+
+def _collect_scheduler():
+ import ministack.services.scheduler as svc
+ for arn, tags in svc._tags.items():
+ yield arn, _normalise_flat(tags)
+
+
+def _collect_cloudfront():
+ import ministack.services.cloudfront as svc
+ for arn, tags in svc._tags.items():
+ yield arn, _normalise_list(tags)
+
+
+def _collect_efs():
+ import ministack.services.efs as svc
+ for fs_id, fs in svc._file_systems.items():
+ arn = f"arn:aws:elasticfilesystem:{REGION}:{_account()}:file-system/{fs_id}"
+ yield arn, _normalise_list(fs.get("Tags", []))
+ for ap_id, ap in svc._access_points.items():
+ arn = f"arn:aws:elasticfilesystem:{REGION}:{_account()}:access-point/{ap_id}"
+ yield arn, _normalise_list(ap.get("Tags", []))
+
+
# ResourceTypeFilter prefix -> collector
_COLLECTORS = {
- "s3": _collect_s3,
- "lambda": _collect_lambda,
- "sqs": _collect_sqs,
- "sns": _collect_sns,
- "dynamodb": _collect_dynamodb,
- "events": _collect_eventbridge,
+ # Phase 1
+ "s3": _collect_s3,
+ "lambda": _collect_lambda,
+ "sqs": _collect_sqs,
+ "sns": _collect_sns,
+ "dynamodb": _collect_dynamodb,
+ "events": _collect_eventbridge,
+ # Phase 2
+ "kms": _collect_kms,
+ "ecr": _collect_ecr,
+ "ecs": _collect_ecs,
+ "glue": _collect_glue,
+ "cognito-idp": _collect_cognito,
+ "cognito-identity": _collect_cognito,
+ "appsync": _collect_appsync,
+ "scheduler": _collect_scheduler,
+ "cloudfront": _collect_cloudfront,
+ "elasticfilesystem": _collect_efs,
}
@@ -139,10 +225,44 @@ def _get_resources(data):
}).encode()
+def _get_tag_keys(data):
+ keys = set()
+ for collector in _COLLECTORS.values():
+ try:
+ for _arn, tags in collector():
+ for t in tags:
+ keys.add(t["Key"])
+ except Exception:
+ pass
+ return 200, {"Content-Type": "application/x-amz-json-1.1"}, json.dumps({
+ "TagKeys": sorted(keys),
+ "PaginationToken": "",
+ }).encode()
+
+
+def _get_tag_values(data):
+ target_key = data.get("Key", "")
+ values = set()
+ for collector in _COLLECTORS.values():
+ try:
+ for _arn, tags in collector():
+ for t in tags:
+ if t["Key"] == target_key:
+ values.add(t["Value"])
+ except Exception:
+ pass
+ return 200, {"Content-Type": "application/x-amz-json-1.1"}, json.dumps({
+ "TagValues": sorted(values),
+ "PaginationToken": "",
+ }).encode()
+
+
# ── Entry point ───────────────────────────────────────────────────────────────
_HANDLERS = {
"GetResources": _get_resources,
+ "GetTagKeys": _get_tag_keys,
+ "GetTagValues": _get_tag_values,
}
diff --git a/tests/conftest.py b/tests/conftest.py
index 46c6e5d5..c02e7490 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -300,6 +300,14 @@ def transfer():
def eks():
return make_client("eks")
[email protected](scope="session")
+def appsync():
+ return make_client("appsync")
+
[email protected](scope="session")
+def scheduler():
+ return make_client("scheduler")
+
@pytest.fixture(scope="session")
def tagging():
return make_client("resourcegroupstaggingapi")
diff --git a/tests/test_tagging.py b/tests/test_tagging.py
index e6f25b5e..5f4616ac 100644
--- a/tests/test_tagging.py
+++ b/tests/test_tagging.py
@@ -169,3 +169,308 @@ def test_tagging_get_resources_no_match(tagging):
def test_tagging_get_resources_pagination_token_empty(tagging):
resp = tagging.get_resources()
assert resp.get("PaginationToken", "") == ""
+
+
+# ========== Phase 2: New service collectors ==========
+
+def test_tagging_get_resources_kms(tagging, kms_client):
+ key_id = kms_client.create_key(Description="tg-kms-basic")["KeyMetadata"]["KeyId"]
+ kms_client.tag_resource(KeyId=key_id, Tags=[{"TagKey": _TAG_KEY, "TagValue": "kms-basic"}])
+
+ resp = tagging.get_resources(TagFilters=[{"Key": _TAG_KEY, "Values": ["kms-basic"]}])
+ arns = [r["ResourceARN"] for r in resp["ResourceTagMappingList"]]
+ assert any(key_id in a for a in arns)
+
+
+def test_tagging_get_resources_kms_tags_returned(tagging, kms_client):
+ """KMS stores tags as TagKey/TagValue — verify normalised to Key/Value in response."""
+ key_id = kms_client.create_key(Description="tg-kms-tags")["KeyMetadata"]["KeyId"]
+ kms_client.tag_resource(KeyId=key_id, Tags=[
+ {"TagKey": _TAG_KEY, "TagValue": "kms-tags"},
+ {"TagKey": "team", "TagValue": "platform"},
+ ])
+
+ resp = tagging.get_resources(TagFilters=[{"Key": _TAG_KEY, "Values": ["kms-tags"]}])
+ matched = [r for r in resp["ResourceTagMappingList"] if key_id in r["ResourceARN"]]
+ assert len(matched) == 1
+ tag_map = {t["Key"]: t["Value"] for t in matched[0]["Tags"]}
+ assert tag_map[_TAG_KEY] == "kms-tags"
+ assert tag_map["team"] == "platform"
+
+
+def test_tagging_get_resources_ecr(tagging, ecr):
+ ecr.create_repository(
+ repositoryName="tg-ecr-basic",
+ tags=[{"Key": _TAG_KEY, "Value": "ecr-basic"}],
+ )
+
+ resp = tagging.get_resources(TagFilters=[{"Key": _TAG_KEY, "Values": ["ecr-basic"]}])
+ arns = [r["ResourceARN"] for r in resp["ResourceTagMappingList"]]
+ assert any("tg-ecr-basic" in a for a in arns)
+
+
+def test_tagging_get_resources_ecs(tagging, ecs):
+ ecs.create_cluster(
+ clusterName="tg-ecs-basic",
+ tags=[{"key": _TAG_KEY, "value": "ecs-basic"}],
+ )
+
+ resp = tagging.get_resources(TagFilters=[{"Key": _TAG_KEY, "Values": ["ecs-basic"]}])
+ arns = [r["ResourceARN"] for r in resp["ResourceTagMappingList"]]
+ assert any("tg-ecs-basic" in a for a in arns)
+
+
+def test_tagging_get_resources_ecs_tags_returned(tagging, ecs):
+ """ECS stores tags as lowercase key/value — verify normalised to Key/Value in response."""
+ ecs.create_cluster(clusterName="tg-ecs-tags", tags=[
+ {"key": _TAG_KEY, "value": "ecs-tags"},
+ {"key": "team", "value": "infra"},
+ ])
+
+ resp = tagging.get_resources(TagFilters=[{"Key": _TAG_KEY, "Values": ["ecs-tags"]}])
+ matched = [r for r in resp["ResourceTagMappingList"] if "tg-ecs-tags" in r["ResourceARN"]]
+ assert len(matched) == 1
+ tag_map = {t["Key"]: t["Value"] for t in matched[0]["Tags"]}
+ assert tag_map[_TAG_KEY] == "ecs-tags"
+ assert tag_map["team"] == "infra"
+
+
+def test_tagging_get_resources_glue(tagging, glue):
+ glue.create_database(DatabaseInput={"Name": "tg-glue-db"})
+ db_arn = glue.get_database(Name="tg-glue-db")["Database"].get(
+ "DatabaseArn",
+ f"arn:aws:glue:us-east-1:000000000000:database/tg-glue-db",
+ )
+ glue.tag_resource(ResourceArn=db_arn, TagsToAdd={_TAG_KEY: "glue-basic"})
+
+ resp = tagging.get_resources(TagFilters=[{"Key": _TAG_KEY, "Values": ["glue-basic"]}])
+ arns = [r["ResourceARN"] for r in resp["ResourceTagMappingList"]]
+ assert db_arn in arns
+
+
+def test_tagging_get_resources_cognito_idp(tagging, cognito_idp):
+ pool_id = cognito_idp.create_user_pool(PoolName="tg-cognito-pool")["UserPool"]["Id"]
+ pool_arn = cognito_idp.describe_user_pool(UserPoolId=pool_id)["UserPool"]["Arn"]
+ cognito_idp.tag_resource(ResourceArn=pool_arn, Tags={_TAG_KEY: "cognito-idp-basic"})
+
+ resp = tagging.get_resources(TagFilters=[{"Key": _TAG_KEY, "Values": ["cognito-idp-basic"]}])
+ arns = [r["ResourceARN"] for r in resp["ResourceTagMappingList"]]
+ assert any(pool_id in a for a in arns)
+
+
+def test_tagging_get_resources_cognito_identity(tagging, cognito_identity):
+ pool_id = cognito_identity.create_identity_pool(
+ IdentityPoolName="tg-cognito-identity",
+ AllowUnauthenticatedIdentities=False,
+ )["IdentityPoolId"]
+ cognito_identity.tag_resource(
+ ResourceArn=f"arn:aws:cognito-identity:us-east-1:000000000000:identitypool/{pool_id}",
+ Tags={_TAG_KEY: "cognito-identity-basic"},
+ )
+
+ resp = tagging.get_resources(TagFilters=[{"Key": _TAG_KEY, "Values": ["cognito-identity-basic"]}])
+ arns = [r["ResourceARN"] for r in resp["ResourceTagMappingList"]]
+ assert any(pool_id in a for a in arns)
+
+
+def test_tagging_get_resources_appsync(tagging, appsync):
+ api_id = appsync.create_graphql_api(
+ name="tg-appsync-api",
+ authenticationType="API_KEY",
+ tags={_TAG_KEY: "appsync-basic"},
+ )["graphqlApi"]["apiId"]
+ api_arn = appsync.get_graphql_api(apiId=api_id)["graphqlApi"]["arn"]
+
+ resp = tagging.get_resources(TagFilters=[{"Key": _TAG_KEY, "Values": ["appsync-basic"]}])
+ arns = [r["ResourceARN"] for r in resp["ResourceTagMappingList"]]
+ assert api_arn in arns
+
+
+def test_tagging_get_resources_scheduler(tagging, scheduler):
+ scheduler.create_schedule(
+ Name="tg-scheduler-sched",
+ GroupName="default",
+ ScheduleExpression="rate(1 hour)",
+ Target={
+ "Arn": "arn:aws:sqs:us-east-1:000000000000:dummy",
+ "RoleArn": "arn:aws:iam::000000000000:role/dummy",
+ },
+ FlexibleTimeWindow={"Mode": "OFF"},
+ )
+ sched_arn = f"arn:aws:scheduler:us-east-1:000000000000:schedule/default/tg-scheduler-sched"
+ scheduler.tag_resource(ResourceArn=sched_arn, Tags=[{"Key": _TAG_KEY, "Value": "scheduler-basic"}])
+
+ resp = tagging.get_resources(TagFilters=[{"Key": _TAG_KEY, "Values": ["scheduler-basic"]}])
+ arns = [r["ResourceARN"] for r in resp["ResourceTagMappingList"]]
+ assert any("tg-scheduler-sched" in a for a in arns)
+
+
+def test_tagging_get_resources_cloudfront(tagging, cloudfront):
+ dist_id = cloudfront.create_distribution(DistributionConfig={
+ "CallerReference": "tg-cf-dist",
+ "Origins": {"Quantity": 1, "Items": [{
+ "Id": "o1",
+ "DomainName": "example.com",
+ "S3OriginConfig": {"OriginAccessIdentity": ""},
+ }]},
+ "DefaultCacheBehavior": {
+ "TargetOriginId": "o1",
+ "ViewerProtocolPolicy": "allow-all",
+ "ForwardedValues": {"QueryString": False, "Cookies": {"Forward": "none"}},
+ "MinTTL": 0,
+ },
+ "Comment": "",
+ "Enabled": True,
+ })["Distribution"]["Id"]
+ dist_arn = cloudfront.get_distribution(Id=dist_id)["Distribution"]["ARN"]
+ cloudfront.tag_resource(
+ Resource=dist_arn,
+ Tags={"Items": [{"Key": _TAG_KEY, "Value": "cf-basic"}]},
+ )
+
+ resp = tagging.get_resources(TagFilters=[{"Key": _TAG_KEY, "Values": ["cf-basic"]}])
+ arns = [r["ResourceARN"] for r in resp["ResourceTagMappingList"]]
+ assert dist_arn in arns
+
+
+def test_tagging_get_resources_efs(tagging, efs):
+ fs_id = efs.create_file_system(
+ Tags=[{"Key": _TAG_KEY, "Value": "efs-basic"}],
+ )["FileSystemId"]
+
+ resp = tagging.get_resources(TagFilters=[{"Key": _TAG_KEY, "Values": ["efs-basic"]}])
+ arns = [r["ResourceARN"] for r in resp["ResourceTagMappingList"]]
+ assert any(fs_id in a for a in arns)
+
+
+def test_tagging_get_resources_efs_access_point(tagging, efs):
+ fs_id = efs.create_file_system()["FileSystemId"]
+ ap_id = efs.create_access_point(
+ FileSystemId=fs_id,
+ Tags=[{"Key": _TAG_KEY, "Value": "efs-ap"}],
+ )["AccessPointId"]
+
+ resp = tagging.get_resources(TagFilters=[{"Key": _TAG_KEY, "Values": ["efs-ap"]}])
+ arns = [r["ResourceARN"] for r in resp["ResourceTagMappingList"]]
+ assert any(ap_id in a for a in arns)
+
+
+def test_tagging_get_resources_resource_type_filter_kms(tagging, kms_client, s3):
+ """ResourceTypeFilters=["kms"] returns KMS resources and excludes S3."""
+ key_id = kms_client.create_key(Description="tg-type-kms")["KeyMetadata"]["KeyId"]
+ kms_client.tag_resource(KeyId=key_id, Tags=[{"TagKey": _TAG_KEY, "TagValue": "type-kms"}])
+ s3.create_bucket(Bucket="tg-type-kms-s3")
+ s3.put_bucket_tagging(Bucket="tg-type-kms-s3", Tagging={
+ "TagSet": [{"Key": _TAG_KEY, "Value": "type-kms"}]
+ })
+
+ resp = tagging.get_resources(
+ TagFilters=[{"Key": _TAG_KEY, "Values": ["type-kms"]}],
+ ResourceTypeFilters=["kms"],
+ )
+ arns = [r["ResourceARN"] for r in resp["ResourceTagMappingList"]]
+ assert any(key_id in a for a in arns)
+ assert not any("tg-type-kms-s3" in a for a in arns)
+
+
+def test_tagging_get_resources_cross_service_phase2(tagging, kms_client, ecr):
+ """GetResources fan-out includes Phase 2 collectors (KMS + ECR)."""
+ key_id = kms_client.create_key(Description="tg-cross2-kms")["KeyMetadata"]["KeyId"]
+ kms_client.tag_resource(KeyId=key_id, Tags=[{"TagKey": _TAG_KEY, "TagValue": "cross-phase2"}])
+ ecr.create_repository(
+ repositoryName="tg-cross2-ecr",
+ tags=[{"Key": _TAG_KEY, "Value": "cross-phase2"}],
+ )
+
+ resp = tagging.get_resources(TagFilters=[{"Key": _TAG_KEY, "Values": ["cross-phase2"]}])
+ arns = [r["ResourceARN"] for r in resp["ResourceTagMappingList"]]
+ assert any(key_id in a for a in arns)
+ assert any("tg-cross2-ecr" in a for a in arns)
+
+
+# ========== GetTagKeys ==========
+
+def test_tagging_get_tag_keys_returns_known_key(tagging, s3):
+ s3.create_bucket(Bucket="tg-keys-s3")
+ s3.put_bucket_tagging(Bucket="tg-keys-s3", Tagging={
+ "TagSet": [{"Key": _TAG_KEY, "Value": "keys-test"}]
+ })
+ resp = tagging.get_tag_keys()
+ assert _TAG_KEY in resp["TagKeys"]
+
+
+def test_tagging_get_tag_keys_no_duplicates(tagging, s3):
+ """Same key on multiple resources appears once."""
+ s3.create_bucket(Bucket="tg-keys-dup-a")
+ s3.put_bucket_tagging(Bucket="tg-keys-dup-a", Tagging={
+ "TagSet": [{"Key": _TAG_KEY, "Value": "v1"}]
+ })
+ s3.create_bucket(Bucket="tg-keys-dup-b")
+ s3.put_bucket_tagging(Bucket="tg-keys-dup-b", Tagging={
+ "TagSet": [{"Key": _TAG_KEY, "Value": "v2"}]
+ })
+ resp = tagging.get_tag_keys()
+ assert resp["TagKeys"].count(_TAG_KEY) == 1
+
+
+def test_tagging_get_tag_keys_cross_service_phase2(tagging, kms_client):
+ """GetTagKeys aggregates keys from Phase 2 collectors, not just Phase 1."""
+ key_id = kms_client.create_key(Description="tg-keys-kms")["KeyMetadata"]["KeyId"]
+ kms_client.tag_resource(KeyId=key_id, Tags=[{"TagKey": _TAG_KEY, "TagValue": "keys-kms"}])
+
+ resp = tagging.get_tag_keys()
+ assert _TAG_KEY in resp["TagKeys"]
+
+
+def test_tagging_get_tag_keys_pagination_token_empty(tagging):
+ resp = tagging.get_tag_keys()
+ assert resp.get("PaginationToken", "") == ""
+
+
+# ========== GetTagValues ==========
+
+def test_tagging_get_tag_values_returns_values(tagging, s3):
+ s3.create_bucket(Bucket="tg-vals-a")
+ s3.put_bucket_tagging(Bucket="tg-vals-a", Tagging={
+ "TagSet": [{"Key": _TAG_KEY, "Value": "vals-v1"}]
+ })
+ s3.create_bucket(Bucket="tg-vals-b")
+ s3.put_bucket_tagging(Bucket="tg-vals-b", Tagging={
+ "TagSet": [{"Key": _TAG_KEY, "Value": "vals-v2"}]
+ })
+ resp = tagging.get_tag_values(Key=_TAG_KEY)
+ assert "vals-v1" in resp["TagValues"]
+ assert "vals-v2" in resp["TagValues"]
+
+
+def test_tagging_get_tag_values_excludes_other_keys(tagging, s3):
+ s3.create_bucket(Bucket="tg-vals-other")
+ s3.put_bucket_tagging(Bucket="tg-vals-other", Tagging={
+ "TagSet": [{"Key": "other-key", "Value": "should-not-appear"}]
+ })
+ resp = tagging.get_tag_values(Key=_TAG_KEY)
+ assert "should-not-appear" not in resp["TagValues"]
+
+
+def test_tagging_get_tag_values_cross_service_phase2(tagging, s3, kms_client):
+ """GetTagValues returns values sourced from both Phase 1 and Phase 2 collectors."""
+ s3.create_bucket(Bucket="tg-vals-phase2-s3")
+ s3.put_bucket_tagging(Bucket="tg-vals-phase2-s3", Tagging={
+ "TagSet": [{"Key": _TAG_KEY, "Value": "vals-from-s3"}]
+ })
+ key_id = kms_client.create_key(Description="tg-vals-kms")["KeyMetadata"]["KeyId"]
+ kms_client.tag_resource(KeyId=key_id, Tags=[{"TagKey": _TAG_KEY, "TagValue": "vals-from-kms"}])
+
+ resp = tagging.get_tag_values(Key=_TAG_KEY)
+ assert "vals-from-s3" in resp["TagValues"]
+ assert "vals-from-kms" in resp["TagValues"]
+
+
+def test_tagging_get_tag_values_empty_for_unknown_key(tagging):
+ resp = tagging.get_tag_values(Key="__nonexistent_key__")
+ assert resp["TagValues"] == []
+
+
+def test_tagging_get_tag_values_pagination_token_empty(tagging):
+ resp = tagging.get_tag_values(Key=_TAG_KEY)
+ assert resp.get("PaginationToken", "") == ""