From 2821a092f735f5f2847ed68155def98a76597857 Mon Sep 17 00:00:00 2001 From: Tiago Espinha Date: Fri, 16 May 2025 21:43:15 +0100 Subject: [PATCH 1/3] Adds parity tests for ListRuleNamesByTarget. Tests the following cases: - Listing rule names for a target (filtering out irrelevant rule). - Usage of limit and pagination. - Listing rule names when no matches for given target. --- tests/aws/services/events/test_events.py | 287 ++++++++++++++++++ .../services/events/test_events.snapshot.json | 128 ++++++++ .../events/test_events.validation.json | 18 ++ 3 files changed, 433 insertions(+) diff --git a/tests/aws/services/events/test_events.py b/tests/aws/services/events/test_events.py index 5d7f2a731b0b6..4612998310270 100644 --- a/tests/aws/services/events/test_events.py +++ b/tests/aws/services/events/test_events.py @@ -1742,6 +1742,293 @@ def test_process_pattern_to_single_matching_rules_single_target( ) snapshot.match(f"events-{num_events}", events) + @markers.aws.validated + @pytest.mark.parametrize("bus_name", ["custom", "default"]) + def test_list_rule_names_by_target( + self, + bus_name, + events_create_event_bus, + events_put_rule, + sqs_create_queue, + sqs_get_queue_arn, + aws_client, + snapshot, + clean_up, + ): + """Test the ListRuleNamesByTarget API to verify it correctly returns rules associated with a target.""" + # Create an SQS queue to use as a target + queue_name = f"queue-{short_uid()}" + queue_url = sqs_create_queue(QueueName=queue_name) + queue_arn = sqs_get_queue_arn(queue_url) + snapshot.add_transformer(snapshot.transform.regex(queue_arn, "")) + + # Create an event bus if using custom bus + if bus_name == "custom": + bus_name = f"bus-{short_uid()}" + events_create_event_bus(Name=bus_name) + snapshot.add_transformer(snapshot.transform.regex(bus_name, "")) + + # Create multiple rules targeting the same SQS queue + rule_prefix = f"rule-{short_uid()}-" + snapshot.add_transformer(snapshot.transform.regex(rule_prefix, "")) + rule_names = [] + + # Create 3 rules all targeting the same SQS queue + for i in range(3): + rule_name = f"{rule_prefix}{i}" + rule_names.append(rule_name) + events_put_rule( + Name=rule_name, + EventBusName=bus_name, + EventPattern=json.dumps({"source": [f"source-{i}"]}), + ) + + # Add the SQS queue as a target for this rule + target_id = f"target-{i}" + snapshot.add_transformer(snapshot.transform.regex(target_id, f"")) + aws_client.events.put_targets( + Rule=rule_name, + EventBusName=bus_name, + Targets=[{"Id": target_id, "Arn": queue_arn}], + ) + + # Create a rule targeting a different resource (to verify filtering) + other_rule = f"{rule_prefix}other" + events_put_rule( + Name=other_rule, + EventBusName=bus_name, + EventPattern=json.dumps({"source": ["other-source"]}), + ) + + # Test the ListRuleNamesByTarget API + response = aws_client.events.list_rule_names_by_target( + TargetArn=queue_arn, + EventBusName=bus_name, + ) + + # The response should contain all rules that target our queue + snapshot.match("list_rule_names_by_target", response) + + # Verify the response contains the expected rule names + assert set(response.get("RuleNames", [])) == set(rule_names) + assert other_rule not in response.get("RuleNames", []) + + # Clean up targets and rules + for rule_name in rule_names + [other_rule]: + try: + # Remove targets first (only for rules that have targets) + if rule_name in rule_names: # other_rule has no targets + aws_client.events.remove_targets( + Rule=rule_name, + EventBusName=bus_name, + Ids=[f"target-{rule_names.index(rule_name)}"], + ) + # Delete rule + aws_client.events.delete_rule( + Name=rule_name, + EventBusName=bus_name, + Force=True, + ) + except aws_client.events.exceptions.ResourceNotFoundException: + # Ignore if rule or event bus was already deleted + pass + + # Delete custom event bus if we created one + if bus_name != "default": + try: + aws_client.events.delete_event_bus(Name=bus_name) + except aws_client.events.exceptions.ResourceNotFoundException: + # Ignore if event bus was already deleted + pass + + @markers.aws.validated + @pytest.mark.parametrize("bus_name", ["custom", "default"]) + def test_list_rule_names_by_target_with_limit( + self, + bus_name, + events_create_event_bus, + events_put_rule, + sqs_create_queue, + sqs_get_queue_arn, + aws_client, + snapshot, + clean_up, + ): + """Test the ListRuleNamesByTarget API with pagination to verify it correctly handles limits and next tokens.""" + # Create an SQS queue to use as a target + queue_name = f"queue-{short_uid()}" + queue_url = sqs_create_queue(QueueName=queue_name) + queue_arn = sqs_get_queue_arn(queue_url) + snapshot.add_transformer(snapshot.transform.regex(queue_arn, "")) + + # Create an event bus if using custom bus + if bus_name == "custom": + bus_name = f"bus-{short_uid()}" + events_create_event_bus(Name=bus_name) + snapshot.add_transformer(snapshot.transform.regex(bus_name, "")) + + # Create multiple rules targeting the same SQS queue + rule_prefix = f"rule-{short_uid()}-" + snapshot.add_transformer(snapshot.transform.regex(rule_prefix, "")) + rule_names = [] + + # Create 5 rules all targeting the same SQS queue + for i in range(5): + rule_name = f"{rule_prefix}{i}" + rule_names.append(rule_name) + events_put_rule( + Name=rule_name, + EventBusName=bus_name, + EventPattern=json.dumps({"source": [f"source-{i}"]}), + ) + + # Add the SQS queue as a target for this rule + target_id = f"target-{i}" + snapshot.add_transformer(snapshot.transform.regex(target_id, f"")) + aws_client.events.put_targets( + Rule=rule_name, + EventBusName=bus_name, + Targets=[{"Id": target_id, "Arn": queue_arn}], + ) + + # Test pagination with limit=2 + all_rule_names = [] + next_token = None + + # First page + response = aws_client.events.list_rule_names_by_target( + TargetArn=queue_arn, + EventBusName=bus_name, + Limit=2, + ) + # Store the original NextToken value before replacing it for snapshot comparison + original_next_token = response["NextToken"] + # Transform NextToken to a fixed value for snapshot comparison + if "NextToken" in response: + response["NextToken"] = "" + snapshot.match("first_page", response) + all_rule_names.extend(response["RuleNames"]) + assert len(response["RuleNames"]) == 2 + assert "NextToken" in response + + # Second page + next_token = original_next_token + response = aws_client.events.list_rule_names_by_target( + TargetArn=queue_arn, + EventBusName=bus_name, + Limit=2, + NextToken=next_token, + ) + # Store the original NextToken value before replacing it for snapshot comparison + original_next_token = response["NextToken"] + # Transform NextToken to a fixed value for snapshot comparison + if "NextToken" in response: + response["NextToken"] = "" + snapshot.match("second_page", response) + all_rule_names.extend(response["RuleNames"]) + assert len(response["RuleNames"]) == 2 + assert "NextToken" in response + + # Third page (should have 1 remaining) + next_token = original_next_token + response = aws_client.events.list_rule_names_by_target( + TargetArn=queue_arn, + EventBusName=bus_name, + Limit=2, + NextToken=next_token, + ) + # Transform NextToken to a fixed value for snapshot comparison + if "NextToken" in response: + response["NextToken"] = "" + snapshot.match("third_page", response) + all_rule_names.extend(response["RuleNames"]) + assert len(response["RuleNames"]) == 1 + assert "NextToken" not in response + + # Verify we got all rules + assert set(all_rule_names) == set(rule_names) + + # Clean up targets and rules + for rule_name in rule_names: + try: + # Remove targets first + aws_client.events.remove_targets( + Rule=rule_name, + EventBusName=bus_name, + Ids=[f"target-{rule_names.index(rule_name)}"], + ) + # Delete rule + aws_client.events.delete_rule( + Name=rule_name, + EventBusName=bus_name, + Force=True, + ) + except aws_client.events.exceptions.ResourceNotFoundException: + # Ignore if rule or event bus was already deleted + pass + + # Delete custom event bus if we created one + if bus_name != "default": + try: + aws_client.events.delete_event_bus(Name=bus_name) + except aws_client.events.exceptions.ResourceNotFoundException: + # Ignore if event bus was already deleted + pass + + @markers.aws.validated + @pytest.mark.parametrize("bus_name", ["custom", "default"]) + def test_list_rule_names_by_target_no_matches( + self, + bus_name, + events_create_event_bus, + events_put_rule, + sqs_create_queue, + sqs_get_queue_arn, + aws_client, + snapshot, + clean_up, + ): + """Test that ListRuleNamesByTarget returns empty result when no rules match the target.""" + # Create two SQS queues + search_queue_url = sqs_create_queue() + search_queue_arn = sqs_get_queue_arn(search_queue_url) + + target_queue_url = sqs_create_queue() + target_queue_arn = sqs_get_queue_arn(target_queue_url) + + # Create event bus if needed + if bus_name == "custom": + bus_name = f"bus-{short_uid()}" + events_create_event_bus(Name=bus_name) + + # Create rules targeting the target queue, but none targeting the search queue + rule_name = f"rule-{short_uid()}" + events_put_rule( + Name=rule_name, + EventBusName=bus_name, + EventPattern=json.dumps({"source": ["test-source"]}), + ) + + # Add the target + aws_client.events.put_targets( + Rule=rule_name, + EventBusName=bus_name, + Targets=[{"Id": "target-1", "Arn": target_queue_arn}], + ) + + # Test the ListRuleNamesByTarget API with the search queue ARN + response = aws_client.events.list_rule_names_by_target( + TargetArn=search_queue_arn, + EventBusName=bus_name, + ) + + snapshot.match("list_rule_names_by_target_no_matches", response) + + # Verify the response contains an empty list + assert response.get("RuleNames", None) is not None + assert len(response.get("RuleNames")) == 0 + assert "NextToken" not in response + class TestEventPattern: @markers.aws.validated diff --git a/tests/aws/services/events/test_events.snapshot.json b/tests/aws/services/events/test_events.snapshot.json index a3805f60e72c3..9387b1a946c5d 100644 --- a/tests/aws/services/events/test_events.snapshot.json +++ b/tests/aws/services/events/test_events.snapshot.json @@ -2573,5 +2573,133 @@ } } } + }, + "tests/aws/services/events/test_events.py::TestEventRule::test_list_rule_names_by_target[custom]": { + "recorded-date": "16-05-2025, 11:55:27", + "recorded-content": { + "list_rule_names_by_target": { + "RuleNames": [ + "0", + "1", + "2" + ], + "ResponseMetadata": { + "HTTPHeaders": {}, + "HTTPStatusCode": 200 + } + } + } + }, + "tests/aws/services/events/test_events.py::TestEventRule::test_list_rule_names_by_target[default]": { + "recorded-date": "16-05-2025, 11:55:28", + "recorded-content": { + "list_rule_names_by_target": { + "RuleNames": [ + "0", + "1", + "2" + ], + "ResponseMetadata": { + "HTTPHeaders": {}, + "HTTPStatusCode": 200 + } + } + } + }, + "tests/aws/services/events/test_events.py::TestEventRule::test_list_rule_names_by_target_with_limit[custom]": { + "recorded-date": "16-05-2025, 20:05:21", + "recorded-content": { + "first_page": { + "NextToken": "", + "RuleNames": [ + "0", + "1" + ], + "ResponseMetadata": { + "HTTPHeaders": {}, + "HTTPStatusCode": 200 + } + }, + "second_page": { + "NextToken": "", + "RuleNames": [ + "2", + "3" + ], + "ResponseMetadata": { + "HTTPHeaders": {}, + "HTTPStatusCode": 200 + } + }, + "third_page": { + "RuleNames": [ + "4" + ], + "ResponseMetadata": { + "HTTPHeaders": {}, + "HTTPStatusCode": 200 + } + } + } + }, + "tests/aws/services/events/test_events.py::TestEventRule::test_list_rule_names_by_target_with_limit[default]": { + "recorded-date": "16-05-2025, 20:05:22", + "recorded-content": { + "first_page": { + "NextToken": "", + "RuleNames": [ + "0", + "1" + ], + "ResponseMetadata": { + "HTTPHeaders": {}, + "HTTPStatusCode": 200 + } + }, + "second_page": { + "NextToken": "", + "RuleNames": [ + "2", + "3" + ], + "ResponseMetadata": { + "HTTPHeaders": {}, + "HTTPStatusCode": 200 + } + }, + "third_page": { + "RuleNames": [ + "4" + ], + "ResponseMetadata": { + "HTTPHeaders": {}, + "HTTPStatusCode": 200 + } + } + } + }, + "tests/aws/services/events/test_events.py::TestEventRule::test_list_rule_names_by_target_no_matches[custom]": { + "recorded-date": "16-05-2025, 20:34:26", + "recorded-content": { + "list_rule_names_by_target_no_matches": { + "RuleNames": [], + "ResponseMetadata": { + "HTTPHeaders": {}, + "HTTPStatusCode": 200 + } + } + } + }, + "tests/aws/services/events/test_events.py::TestEventRule::test_list_rule_names_by_target_no_matches[default]": { + "recorded-date": "16-05-2025, 20:34:27", + "recorded-content": { + "list_rule_names_by_target_no_matches": { + "RuleNames": [], + "ResponseMetadata": { + "HTTPHeaders": {}, + "HTTPStatusCode": 200 + } + } + } } } diff --git a/tests/aws/services/events/test_events.validation.json b/tests/aws/services/events/test_events.validation.json index 7eea542d2272c..a3a209d326c8f 100644 --- a/tests/aws/services/events/test_events.validation.json +++ b/tests/aws/services/events/test_events.validation.json @@ -86,6 +86,24 @@ "tests/aws/services/events/test_events.py::TestEventRule::test_disable_re_enable_rule[default]": { "last_validated_date": "2025-01-08T15:28:56+00:00" }, + "tests/aws/services/events/test_events.py::TestEventRule::test_list_rule_names_by_target[custom]": { + "last_validated_date": "2025-05-16T11:55:33+00:00" + }, + "tests/aws/services/events/test_events.py::TestEventRule::test_list_rule_names_by_target[default]": { + "last_validated_date": "2025-05-16T11:55:34+00:00" + }, + "tests/aws/services/events/test_events.py::TestEventRule::test_list_rule_names_by_target_no_matches[custom]": { + "last_validated_date": "2025-05-16T20:34:26+00:00" + }, + "tests/aws/services/events/test_events.py::TestEventRule::test_list_rule_names_by_target_no_matches[default]": { + "last_validated_date": "2025-05-16T20:34:27+00:00" + }, + "tests/aws/services/events/test_events.py::TestEventRule::test_list_rule_names_by_target_with_limit[custom]": { + "last_validated_date": "2025-05-16T20:05:36+00:00" + }, + "tests/aws/services/events/test_events.py::TestEventRule::test_list_rule_names_by_target_with_limit[default]": { + "last_validated_date": "2025-05-16T20:05:37+00:00" + }, "tests/aws/services/events/test_events.py::TestEventRule::test_list_rule_with_limit": { "last_validated_date": "2025-01-08T15:28:51+00:00" }, From 9910899089c9870e2f7709836a9f356a188a4b9a Mon Sep 17 00:00:00 2001 From: Tiago Espinha Date: Fri, 16 May 2025 21:46:19 +0100 Subject: [PATCH 2/3] Implements the ListRuleNamesByTarget. Also brings in a new _get_limited_list_and_next_token for convenience of filtering and paging. --- .../localstack/services/events/provider.py | 42 ++++++++++++++++++- 1 file changed, 41 insertions(+), 1 deletion(-) diff --git a/localstack-core/localstack/services/events/provider.py b/localstack-core/localstack/services/events/provider.py index 67e5e1bd9763e..644129e220511 100644 --- a/localstack-core/localstack/services/events/provider.py +++ b/localstack-core/localstack/services/events/provider.py @@ -758,7 +758,29 @@ def list_rule_names_by_target( limit: LimitMax100 = None, **kwargs, ) -> ListRuleNamesByTargetResponse: - raise NotImplementedError + region = context.region + account_id = context.account_id + store = self.get_store(region, account_id) + event_bus_name = extract_event_bus_name(event_bus_name) + event_bus = self.get_event_bus(event_bus_name, store) + + # Find all rules that have a target with the specified ARN + matching_rule_names = [] + for rule_name, rule in event_bus.rules.items(): + for target_id, target in rule.targets.items(): + if target["Arn"] == target_arn: + matching_rule_names.append(rule_name) + break # Found a match in this rule, no need to check other targets + + limited_rules, next_token = self._get_limited_list_and_next_token( + matching_rule_names, next_token, limit + ) + + response = ListRuleNamesByTargetResponse(RuleNames=limited_rules) + if next_token is not None: + response["NextToken"] = next_token + + return response @handler("PutRule") def put_rule( @@ -1514,6 +1536,24 @@ def _get_limited_dict_and_next_token( ) return limited_dict, next_token + def _get_limited_list_and_next_token( + self, input_list: list, next_token: NextToken | None, limit: LimitMax100 | None + ) -> tuple[list, NextToken]: + """Return a slice of the given list starting from next_token with length of limit + and new last index encoded as a next_token for pagination.""" + input_list_len = len(input_list) + start_index = decode_next_token(next_token) if next_token is not None else 0 + end_index = start_index + limit if limit is not None else input_list_len + limited_list = input_list[start_index:end_index] + + next_token = ( + encode_next_token(end_index) + # return a next_token (encoded integer of next starting index) if not all items are returned + if end_index < input_list_len + else None + ) + return limited_list, next_token + def _check_resource_exists( self, resource_arn: Arn, resource_type: ResourceType, store: EventsStore ) -> None: From 369b8b958aad15334d6a14d45a2bdf8f72567854 Mon Sep 17 00:00:00 2001 From: Tiago Espinha Date: Mon, 19 May 2025 09:42:26 +0100 Subject: [PATCH 3/3] Fixing review comments. - Gets rid of useless transforms for results that aren't in the output. - Gets rid of explicit cleanups, since all resources are created by self-cleaning fixtures. - Changes NextToken to use a cleaner transform instead of explicitly changing it around. - Gets rid of asserts since they're redundant, given the snapshots do all of the matching. --- tests/aws/services/events/test_events.py | 102 ++---------------- .../services/events/test_events.snapshot.json | 20 ++-- .../events/test_events.validation.json | 12 +-- 3 files changed, 26 insertions(+), 108 deletions(-) diff --git a/tests/aws/services/events/test_events.py b/tests/aws/services/events/test_events.py index 4612998310270..cb748eb832c1c 100644 --- a/tests/aws/services/events/test_events.py +++ b/tests/aws/services/events/test_events.py @@ -1760,13 +1760,11 @@ def test_list_rule_names_by_target( queue_name = f"queue-{short_uid()}" queue_url = sqs_create_queue(QueueName=queue_name) queue_arn = sqs_get_queue_arn(queue_url) - snapshot.add_transformer(snapshot.transform.regex(queue_arn, "")) # Create an event bus if using custom bus if bus_name == "custom": bus_name = f"bus-{short_uid()}" events_create_event_bus(Name=bus_name) - snapshot.add_transformer(snapshot.transform.regex(bus_name, "")) # Create multiple rules targeting the same SQS queue rule_prefix = f"rule-{short_uid()}-" @@ -1785,7 +1783,6 @@ def test_list_rule_names_by_target( # Add the SQS queue as a target for this rule target_id = f"target-{i}" - snapshot.add_transformer(snapshot.transform.regex(target_id, f"")) aws_client.events.put_targets( Rule=rule_name, EventBusName=bus_name, @@ -1809,38 +1806,6 @@ def test_list_rule_names_by_target( # The response should contain all rules that target our queue snapshot.match("list_rule_names_by_target", response) - # Verify the response contains the expected rule names - assert set(response.get("RuleNames", [])) == set(rule_names) - assert other_rule not in response.get("RuleNames", []) - - # Clean up targets and rules - for rule_name in rule_names + [other_rule]: - try: - # Remove targets first (only for rules that have targets) - if rule_name in rule_names: # other_rule has no targets - aws_client.events.remove_targets( - Rule=rule_name, - EventBusName=bus_name, - Ids=[f"target-{rule_names.index(rule_name)}"], - ) - # Delete rule - aws_client.events.delete_rule( - Name=rule_name, - EventBusName=bus_name, - Force=True, - ) - except aws_client.events.exceptions.ResourceNotFoundException: - # Ignore if rule or event bus was already deleted - pass - - # Delete custom event bus if we created one - if bus_name != "default": - try: - aws_client.events.delete_event_bus(Name=bus_name) - except aws_client.events.exceptions.ResourceNotFoundException: - # Ignore if event bus was already deleted - pass - @markers.aws.validated @pytest.mark.parametrize("bus_name", ["custom", "default"]) def test_list_rule_names_by_target_with_limit( @@ -1859,13 +1824,11 @@ def test_list_rule_names_by_target_with_limit( queue_name = f"queue-{short_uid()}" queue_url = sqs_create_queue(QueueName=queue_name) queue_arn = sqs_get_queue_arn(queue_url) - snapshot.add_transformer(snapshot.transform.regex(queue_arn, "")) # Create an event bus if using custom bus if bus_name == "custom": bus_name = f"bus-{short_uid()}" events_create_event_bus(Name=bus_name) - snapshot.add_transformer(snapshot.transform.regex(bus_name, "")) # Create multiple rules targeting the same SQS queue rule_prefix = f"rule-{short_uid()}-" @@ -1884,7 +1847,6 @@ def test_list_rule_names_by_target_with_limit( # Add the SQS queue as a target for this rule target_id = f"target-{i}" - snapshot.add_transformer(snapshot.transform.regex(target_id, f"")) aws_client.events.put_targets( Rule=rule_name, EventBusName=bus_name, @@ -1902,17 +1864,19 @@ def test_list_rule_names_by_target_with_limit( Limit=2, ) # Store the original NextToken value before replacing it for snapshot comparison - original_next_token = response["NextToken"] - # Transform NextToken to a fixed value for snapshot comparison - if "NextToken" in response: - response["NextToken"] = "" + next_token = response["NextToken"] + snapshot.add_transformer( + snapshot.transform.jsonpath( + jsonpath="$..NextToken", + value_replacement="", + reference_replacement=True, + ) + ) + snapshot.match("first_page", response) all_rule_names.extend(response["RuleNames"]) - assert len(response["RuleNames"]) == 2 - assert "NextToken" in response # Second page - next_token = original_next_token response = aws_client.events.list_rule_names_by_target( TargetArn=queue_arn, EventBusName=bus_name, @@ -1920,60 +1884,19 @@ def test_list_rule_names_by_target_with_limit( NextToken=next_token, ) # Store the original NextToken value before replacing it for snapshot comparison - original_next_token = response["NextToken"] - # Transform NextToken to a fixed value for snapshot comparison - if "NextToken" in response: - response["NextToken"] = "" + next_token = response["NextToken"] snapshot.match("second_page", response) all_rule_names.extend(response["RuleNames"]) - assert len(response["RuleNames"]) == 2 - assert "NextToken" in response # Third page (should have 1 remaining) - next_token = original_next_token response = aws_client.events.list_rule_names_by_target( TargetArn=queue_arn, EventBusName=bus_name, Limit=2, NextToken=next_token, ) - # Transform NextToken to a fixed value for snapshot comparison - if "NextToken" in response: - response["NextToken"] = "" snapshot.match("third_page", response) all_rule_names.extend(response["RuleNames"]) - assert len(response["RuleNames"]) == 1 - assert "NextToken" not in response - - # Verify we got all rules - assert set(all_rule_names) == set(rule_names) - - # Clean up targets and rules - for rule_name in rule_names: - try: - # Remove targets first - aws_client.events.remove_targets( - Rule=rule_name, - EventBusName=bus_name, - Ids=[f"target-{rule_names.index(rule_name)}"], - ) - # Delete rule - aws_client.events.delete_rule( - Name=rule_name, - EventBusName=bus_name, - Force=True, - ) - except aws_client.events.exceptions.ResourceNotFoundException: - # Ignore if rule or event bus was already deleted - pass - - # Delete custom event bus if we created one - if bus_name != "default": - try: - aws_client.events.delete_event_bus(Name=bus_name) - except aws_client.events.exceptions.ResourceNotFoundException: - # Ignore if event bus was already deleted - pass @markers.aws.validated @pytest.mark.parametrize("bus_name", ["custom", "default"]) @@ -2024,11 +1947,6 @@ def test_list_rule_names_by_target_no_matches( snapshot.match("list_rule_names_by_target_no_matches", response) - # Verify the response contains an empty list - assert response.get("RuleNames", None) is not None - assert len(response.get("RuleNames")) == 0 - assert "NextToken" not in response - class TestEventPattern: @markers.aws.validated diff --git a/tests/aws/services/events/test_events.snapshot.json b/tests/aws/services/events/test_events.snapshot.json index 9387b1a946c5d..668c13edfb4fe 100644 --- a/tests/aws/services/events/test_events.snapshot.json +++ b/tests/aws/services/events/test_events.snapshot.json @@ -2575,7 +2575,7 @@ } }, "tests/aws/services/events/test_events.py::TestEventRule::test_list_rule_names_by_target[custom]": { - "recorded-date": "16-05-2025, 11:55:27", + "recorded-date": "19-05-2025, 07:53:33", "recorded-content": { "list_rule_names_by_target": { "RuleNames": [ @@ -2591,7 +2591,7 @@ } }, "tests/aws/services/events/test_events.py::TestEventRule::test_list_rule_names_by_target[default]": { - "recorded-date": "16-05-2025, 11:55:28", + "recorded-date": "19-05-2025, 07:53:34", "recorded-content": { "list_rule_names_by_target": { "RuleNames": [ @@ -2607,10 +2607,10 @@ } }, "tests/aws/services/events/test_events.py::TestEventRule::test_list_rule_names_by_target_with_limit[custom]": { - "recorded-date": "16-05-2025, 20:05:21", + "recorded-date": "19-05-2025, 07:54:06", "recorded-content": { "first_page": { - "NextToken": "", + "NextToken": "<:1>", "RuleNames": [ "0", "1" @@ -2621,7 +2621,7 @@ } }, "second_page": { - "NextToken": "", + "NextToken": "<:2>", "RuleNames": [ "2", "3" @@ -2643,10 +2643,10 @@ } }, "tests/aws/services/events/test_events.py::TestEventRule::test_list_rule_names_by_target_with_limit[default]": { - "recorded-date": "16-05-2025, 20:05:22", + "recorded-date": "19-05-2025, 07:54:07", "recorded-content": { "first_page": { - "NextToken": "", + "NextToken": "<:1>", "RuleNames": [ "0", "1" @@ -2657,7 +2657,7 @@ } }, "second_page": { - "NextToken": "", + "NextToken": "<:2>", "RuleNames": [ "2", "3" @@ -2679,7 +2679,7 @@ } }, "tests/aws/services/events/test_events.py::TestEventRule::test_list_rule_names_by_target_no_matches[custom]": { - "recorded-date": "16-05-2025, 20:34:26", + "recorded-date": "19-05-2025, 07:54:49", "recorded-content": { "list_rule_names_by_target_no_matches": { "RuleNames": [], @@ -2691,7 +2691,7 @@ } }, "tests/aws/services/events/test_events.py::TestEventRule::test_list_rule_names_by_target_no_matches[default]": { - "recorded-date": "16-05-2025, 20:34:27", + "recorded-date": "19-05-2025, 07:54:50", "recorded-content": { "list_rule_names_by_target_no_matches": { "RuleNames": [], diff --git a/tests/aws/services/events/test_events.validation.json b/tests/aws/services/events/test_events.validation.json index a3a209d326c8f..a28109be3f564 100644 --- a/tests/aws/services/events/test_events.validation.json +++ b/tests/aws/services/events/test_events.validation.json @@ -87,22 +87,22 @@ "last_validated_date": "2025-01-08T15:28:56+00:00" }, "tests/aws/services/events/test_events.py::TestEventRule::test_list_rule_names_by_target[custom]": { - "last_validated_date": "2025-05-16T11:55:33+00:00" + "last_validated_date": "2025-05-19T07:53:33+00:00" }, "tests/aws/services/events/test_events.py::TestEventRule::test_list_rule_names_by_target[default]": { - "last_validated_date": "2025-05-16T11:55:34+00:00" + "last_validated_date": "2025-05-19T07:53:34+00:00" }, "tests/aws/services/events/test_events.py::TestEventRule::test_list_rule_names_by_target_no_matches[custom]": { - "last_validated_date": "2025-05-16T20:34:26+00:00" + "last_validated_date": "2025-05-19T07:54:49+00:00" }, "tests/aws/services/events/test_events.py::TestEventRule::test_list_rule_names_by_target_no_matches[default]": { - "last_validated_date": "2025-05-16T20:34:27+00:00" + "last_validated_date": "2025-05-19T07:54:50+00:00" }, "tests/aws/services/events/test_events.py::TestEventRule::test_list_rule_names_by_target_with_limit[custom]": { - "last_validated_date": "2025-05-16T20:05:36+00:00" + "last_validated_date": "2025-05-19T07:54:06+00:00" }, "tests/aws/services/events/test_events.py::TestEventRule::test_list_rule_names_by_target_with_limit[default]": { - "last_validated_date": "2025-05-16T20:05:37+00:00" + "last_validated_date": "2025-05-19T07:54:07+00:00" }, "tests/aws/services/events/test_events.py::TestEventRule::test_list_rule_with_limit": { "last_validated_date": "2025-01-08T15:28:51+00:00"