From 4469cd87971cf3dcade37ae3129e7ce214fe99e6 Mon Sep 17 00:00:00 2001 From: Mark Sailes Date: Fri, 14 Jun 2024 22:11:01 +0100 Subject: [PATCH 1/2] Added the object representation of the CloudWatch Alarm (metric and composite types) Updated encoding properties to remove warnings --- aws-lambda-java-events/pom.xml | 14 ++++ .../runtime/events/CloudWatchAlarmEvent.java | 84 +++++++++++++++++++ .../events/CloudWatchAlarmEventTest.java | 58 +++++++++++++ .../resources/cloudwatch-composite-alarm.json | 30 +++++++ .../resources/cloudwatch-metric-alarm.json | 42 ++++++++++ 5 files changed, 228 insertions(+) create mode 100644 aws-lambda-java-events/src/main/java/com/amazonaws/services/lambda/runtime/events/CloudWatchAlarmEvent.java create mode 100644 aws-lambda-java-events/src/test/java/com/amazonaws/services/lambda/runtime/events/CloudWatchAlarmEventTest.java create mode 100644 aws-lambda-java-events/src/test/resources/cloudwatch-composite-alarm.json create mode 100644 aws-lambda-java-events/src/test/resources/cloudwatch-metric-alarm.json diff --git a/aws-lambda-java-events/pom.xml b/aws-lambda-java-events/pom.xml index 2c7442c0..59e1d388 100644 --- a/aws-lambda-java-events/pom.xml +++ b/aws-lambda-java-events/pom.xml @@ -35,6 +35,8 @@ 1.8 1.8 1.18.22 + UTF-8 + UTF-8 @@ -69,6 +71,18 @@ 2.36.1 test + + org.skyscreamer + jsonassert + 1.5.0 + test + + + com.amazonaws + aws-lambda-java-serialization + 1.1.5 + test + org.projectlombok diff --git a/aws-lambda-java-events/src/main/java/com/amazonaws/services/lambda/runtime/events/CloudWatchAlarmEvent.java b/aws-lambda-java-events/src/main/java/com/amazonaws/services/lambda/runtime/events/CloudWatchAlarmEvent.java new file mode 100644 index 00000000..66fb9590 --- /dev/null +++ b/aws-lambda-java-events/src/main/java/com/amazonaws/services/lambda/runtime/events/CloudWatchAlarmEvent.java @@ -0,0 +1,84 @@ +package com.amazonaws.services.lambda.runtime.events; + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.util.List; +import java.util.Map; + +@Data +@Builder(setterPrefix = "with") +@NoArgsConstructor +@AllArgsConstructor +public class CloudWatchAlarmEvent { + + private String source; + private String alarmArn; + private String accountId; + private String time; + private String region; + private AlarmData alarmData; + + @Data + @Builder(setterPrefix = "with") + @NoArgsConstructor + @AllArgsConstructor + public static class AlarmData { + private String alarmName; + private State state; + private State previousState; + private Configuration configuration; + } + + @Data + @Builder(setterPrefix = "with") + @NoArgsConstructor + @AllArgsConstructor + private static class State { + private String value; + private String reason; + private String reasonData; + private String timestamp; + private String actionsSuppressedBy; + private String actionsSuppressedReason; + } + + @Data + @Builder(setterPrefix = "with") + @NoArgsConstructor + @AllArgsConstructor + private static class Configuration { + private String description; + private List metrics; + private Boolean returnData; + + private String alarmRule; + private String actionsSuppressor; + private Integer actionsSuppressorWaitPeriod; + private Integer actionsSuppressorExtensionPeriod; + } + + @Data + @Builder(setterPrefix = "with") + @NoArgsConstructor + @AllArgsConstructor + private static class Metric { + private String id; + private MetricStat metricStat; + private Integer period; + private String stat; + private String unit; + } + + @Data + @Builder(setterPrefix = "with") + @NoArgsConstructor + @AllArgsConstructor + private static class MetricStat { + private String namespace; + private String name; + private Map dimensions; + } +} diff --git a/aws-lambda-java-events/src/test/java/com/amazonaws/services/lambda/runtime/events/CloudWatchAlarmEventTest.java b/aws-lambda-java-events/src/test/java/com/amazonaws/services/lambda/runtime/events/CloudWatchAlarmEventTest.java new file mode 100644 index 00000000..63a20955 --- /dev/null +++ b/aws-lambda-java-events/src/test/java/com/amazonaws/services/lambda/runtime/events/CloudWatchAlarmEventTest.java @@ -0,0 +1,58 @@ +package com.amazonaws.services.lambda.runtime.events; + +import com.amazonaws.services.lambda.runtime.serialization.PojoSerializer; +import com.amazonaws.services.lambda.runtime.serialization.factories.JacksonFactory; +import org.json.JSONException; +import org.junit.jupiter.api.Test; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; + +import static org.skyscreamer.jsonassert.JSONAssert.assertEquals; +import static org.skyscreamer.jsonassert.JSONCompareMode.STRICT; + +public class CloudWatchAlarmEventTest { + + JacksonFactory jacksonFactory = JacksonFactory.getInstance(); + + @Test + public void serdeCloudWatchCompositeAlarmEvent() throws JSONException { + String expected = readResource("cloudwatch-composite-alarm.json"); + String actual = deserializeSerializeJsonToString(expected, CloudWatchAlarmEvent.class); + + assertEquals(expected, actual, STRICT); + } + + @Test + public void serdeCloudWatchMetricAlarmEvent() throws JSONException { + String expected = readResource("cloudwatch-composite-alarm.json"); + String actual = deserializeSerializeJsonToString(expected, CloudWatchAlarmEvent.class); + + assertEquals(expected, actual, STRICT); + } + + private String deserializeSerializeJsonToString(String expected, Class modelClass) { + PojoSerializer serializer = jacksonFactory.getSerializer(modelClass); + T event = serializer.fromJson(expected); + + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + serializer.toJson(event, baos); + + return new String(baos.toByteArray(), StandardCharsets.UTF_8); + } + + private String readResource(String name) { + Path filePath = Paths.get("src", "test", "resources", name); + byte[] bytes = new byte[0]; + try { + bytes = Files.readAllBytes(filePath); + } catch (IOException e) { + e.printStackTrace(); + } + return new String(bytes, StandardCharsets.UTF_8); + } +} \ No newline at end of file diff --git a/aws-lambda-java-events/src/test/resources/cloudwatch-composite-alarm.json b/aws-lambda-java-events/src/test/resources/cloudwatch-composite-alarm.json new file mode 100644 index 00000000..353d470a --- /dev/null +++ b/aws-lambda-java-events/src/test/resources/cloudwatch-composite-alarm.json @@ -0,0 +1,30 @@ +{ + "source": "aws.cloudwatch", + "alarmArn": "arn:aws:cloudwatch:us-east-1:111122223333:alarm:SuppressionDemo.Main", + "accountId": "111122223333", + "time": "2023-08-04T12:56:46.138+0000", + "region": "us-east-1", + "alarmData": { + "alarmName": "CompositeDemo.Main", + "state": { + "value": "ALARM", + "reason": "arn:aws:cloudwatch:us-east-1:111122223333:alarm:CompositeDemo.FirstChild transitioned to ALARM at Friday 04 August, 2023 12:54:46 UTC", + "reasonData": "{\"triggeringAlarms\":[{\"arn\":\"arn:aws:cloudwatch:us-east-1:111122223333:alarm:CompositeDemo.FirstChild\",\"state\":{\"value\":\"ALARM\",\"timestamp\":\"2023-08-04T12:54:46.138+0000\"}}]}", + "timestamp": "2023-08-04T12:56:46.138+0000" + }, + "previousState": { + "value": "ALARM", + "reason": "arn:aws:cloudwatch:us-east-1:111122223333:alarm:CompositeDemo.FirstChild transitioned to ALARM at Friday 04 August, 2023 12:54:46 UTC", + "reasonData": "{\"triggeringAlarms\":[{\"arn\":\"arn:aws:cloudwatch:us-east-1:111122223333:alarm:CompositeDemo.FirstChild\",\"state\":{\"value\":\"ALARM\",\"timestamp\":\"2023-08-04T12:54:46.138+0000\"}}]}", + "timestamp": "2023-08-04T12:54:46.138+0000", + "actionsSuppressedBy": "WaitPeriod", + "actionsSuppressedReason": "Actions suppressed by WaitPeriod" + }, + "configuration": { + "alarmRule": "ALARM(CompositeDemo.FirstChild) OR ALARM(CompositeDemo.SecondChild)", + "actionsSuppressor": "CompositeDemo.ActionsSuppressor", + "actionsSuppressorWaitPeriod": 120, + "actionsSuppressorExtensionPeriod": 180 + } + } +} \ No newline at end of file diff --git a/aws-lambda-java-events/src/test/resources/cloudwatch-metric-alarm.json b/aws-lambda-java-events/src/test/resources/cloudwatch-metric-alarm.json new file mode 100644 index 00000000..8d7de148 --- /dev/null +++ b/aws-lambda-java-events/src/test/resources/cloudwatch-metric-alarm.json @@ -0,0 +1,42 @@ +{ + "source": "aws.cloudwatch", + "alarmArn": "arn:aws:cloudwatch:us-east-1:444455556666:alarm:lambda-demo-metric-alarm", + "accountId": "444455556666", + "time": "2023-08-04T12:36:15.490+0000", + "region": "us-east-1", + "alarmData": { + "alarmName": "lambda-demo-metric-alarm", + "state": { + "value": "ALARM", + "reason": "test", + "timestamp": "2023-08-04T12:36:15.490+0000" + }, + "previousState": { + "value": "INSUFFICIENT_DATA", + "reason": "Insufficient Data: 5 datapoints were unknown.", + "reasonData": "{\"version\":\"1.0\",\"queryDate\":\"2023-08-04T12:31:29.591+0000\",\"statistic\":\"Average\",\"period\":60,\"recentDatapoints\":[],\"threshold\":5.0,\"evaluatedDatapoints\":[{\"timestamp\":\"2023-08-04T12:30:00.000+0000\"},{\"timestamp\":\"2023-08-04T12:29:00.000+0000\"},{\"timestamp\":\"2023-08-04T12:28:00.000+0000\"},{\"timestamp\":\"2023-08-04T12:27:00.000+0000\"},{\"timestamp\":\"2023-08-04T12:26:00.000+0000\"}]}", + "timestamp": "2023-08-04T12:31:29.595+0000" + }, + "configuration": { + "description": "Metric Alarm to test Lambda actions", + "metrics": [ + { + "id": "1234e046-06f0-a3da-9534-EXAMPLEe4c", + "metricStat": { + "metric": { + "namespace": "AWS/Logs", + "name": "CallCount", + "dimensions": { + "InstanceId": "i-12345678" + } + }, + "period": 60, + "stat": "Average", + "unit": "Percent" + }, + "returnData": True + } + ] + } + } +} \ No newline at end of file From 81ec680a7e5e39dac50ed90bd20ffe47ed848ae7 Mon Sep 17 00:00:00 2001 From: Mark Sailes Date: Thu, 20 Jun 2024 22:11:41 +0100 Subject: [PATCH 2/2] Separated the events to two different Java classes Moved the tests to the test module --- aws-lambda-java-events/README.md | 2 + aws-lambda-java-events/pom.xml | 12 -- ...ava => CloudWatchCompositeAlarmEvent.java} | 54 +++---- .../events/CloudWatchMetricAlarmEvent.java | 99 +++++++++++++ .../events/CloudWatchAlarmEventTest.java | 58 -------- .../lambda/runtime/tests/EventLoader.java | 8 + .../lambda/runtime/tests/EventLoaderTest.java | 137 +++++++++++++++++- .../resources/cloudwatch_composite_alarm.json | 0 .../resources/cloudwatch_metric_alarm.json | 2 +- 9 files changed, 265 insertions(+), 107 deletions(-) rename aws-lambda-java-events/src/main/java/com/amazonaws/services/lambda/runtime/events/{CloudWatchAlarmEvent.java => CloudWatchCompositeAlarmEvent.java} (64%) create mode 100644 aws-lambda-java-events/src/main/java/com/amazonaws/services/lambda/runtime/events/CloudWatchMetricAlarmEvent.java delete mode 100644 aws-lambda-java-events/src/test/java/com/amazonaws/services/lambda/runtime/events/CloudWatchAlarmEventTest.java rename aws-lambda-java-events/src/test/resources/cloudwatch-composite-alarm.json => aws-lambda-java-tests/src/test/resources/cloudwatch_composite_alarm.json (100%) rename aws-lambda-java-events/src/test/resources/cloudwatch-metric-alarm.json => aws-lambda-java-tests/src/test/resources/cloudwatch_metric_alarm.json (98%) diff --git a/aws-lambda-java-events/README.md b/aws-lambda-java-events/README.md index 8c60b3a2..c0d90d85 100644 --- a/aws-lambda-java-events/README.md +++ b/aws-lambda-java-events/README.md @@ -16,7 +16,9 @@ * `AppSyncLambdaAuthorizerResponse` * `CloudFormationCustomResourceEvent` * `CloudFrontEvent` +* `CloudWatchCompositeAlarmEvent` * `CloudWatchLogsEvent` +* `CloudWatchMetricAlarmEvent` * `CodeCommitEvent` * `CognitoEvent` * `CognitoUserPoolCreateAuthChallengeEvent` diff --git a/aws-lambda-java-events/pom.xml b/aws-lambda-java-events/pom.xml index 59e1d388..4abea0f8 100644 --- a/aws-lambda-java-events/pom.xml +++ b/aws-lambda-java-events/pom.xml @@ -71,18 +71,6 @@ 2.36.1 test - - org.skyscreamer - jsonassert - 1.5.0 - test - - - com.amazonaws - aws-lambda-java-serialization - 1.1.5 - test - org.projectlombok diff --git a/aws-lambda-java-events/src/main/java/com/amazonaws/services/lambda/runtime/events/CloudWatchAlarmEvent.java b/aws-lambda-java-events/src/main/java/com/amazonaws/services/lambda/runtime/events/CloudWatchCompositeAlarmEvent.java similarity index 64% rename from aws-lambda-java-events/src/main/java/com/amazonaws/services/lambda/runtime/events/CloudWatchAlarmEvent.java rename to aws-lambda-java-events/src/main/java/com/amazonaws/services/lambda/runtime/events/CloudWatchCompositeAlarmEvent.java index 66fb9590..d4090b55 100644 --- a/aws-lambda-java-events/src/main/java/com/amazonaws/services/lambda/runtime/events/CloudWatchAlarmEvent.java +++ b/aws-lambda-java-events/src/main/java/com/amazonaws/services/lambda/runtime/events/CloudWatchCompositeAlarmEvent.java @@ -5,15 +5,16 @@ import lombok.Data; import lombok.NoArgsConstructor; -import java.util.List; -import java.util.Map; - +/** + * Represents an CloudWatch Composite Alarm event. This event occurs when a composite alarm is triggered. + * + * @see Using Amazon CloudWatch alarms + */ @Data @Builder(setterPrefix = "with") @NoArgsConstructor @AllArgsConstructor -public class CloudWatchAlarmEvent { - +public class CloudWatchCompositeAlarmEvent { private String source; private String alarmArn; private String accountId; @@ -28,7 +29,7 @@ public class CloudWatchAlarmEvent { public static class AlarmData { private String alarmName; private State state; - private State previousState; + private PreviousState previousState; private Configuration configuration; } @@ -36,49 +37,34 @@ public static class AlarmData { @Builder(setterPrefix = "with") @NoArgsConstructor @AllArgsConstructor - private static class State { + public static class State { private String value; private String reason; private String reasonData; private String timestamp; - private String actionsSuppressedBy; - private String actionsSuppressedReason; } @Data @Builder(setterPrefix = "with") @NoArgsConstructor @AllArgsConstructor - private static class Configuration { - private String description; - private List metrics; - private Boolean returnData; - - private String alarmRule; - private String actionsSuppressor; - private Integer actionsSuppressorWaitPeriod; - private Integer actionsSuppressorExtensionPeriod; - } - - @Data - @Builder(setterPrefix = "with") - @NoArgsConstructor - @AllArgsConstructor - private static class Metric { - private String id; - private MetricStat metricStat; - private Integer period; - private String stat; - private String unit; + public static class PreviousState { + private String value; + private String reason; + private String reasonData; + private String timestamp; + private String actionsSuppressedBy; + private String actionsSuppressedReason; } @Data @Builder(setterPrefix = "with") @NoArgsConstructor @AllArgsConstructor - private static class MetricStat { - private String namespace; - private String name; - private Map dimensions; + public static class Configuration { + private String alarmRule; + private String actionsSuppressor; + private Integer actionsSuppressorWaitPeriod; + private Integer actionsSuppressorExtensionPeriod; } } diff --git a/aws-lambda-java-events/src/main/java/com/amazonaws/services/lambda/runtime/events/CloudWatchMetricAlarmEvent.java b/aws-lambda-java-events/src/main/java/com/amazonaws/services/lambda/runtime/events/CloudWatchMetricAlarmEvent.java new file mode 100644 index 00000000..2b5f503c --- /dev/null +++ b/aws-lambda-java-events/src/main/java/com/amazonaws/services/lambda/runtime/events/CloudWatchMetricAlarmEvent.java @@ -0,0 +1,99 @@ +package com.amazonaws.services.lambda.runtime.events; + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.util.List; +import java.util.Map; + +/** + * Represents an CloudWatch Metric Alarm event. This event occurs when a metric alarm is triggered. + * + * @see Using Amazon CloudWatch alarms + */ +@Data +@Builder(setterPrefix = "with") +@NoArgsConstructor +@AllArgsConstructor +public class CloudWatchMetricAlarmEvent { + private String source; + private String alarmArn; + private String accountId; + private String time; + private String region; + private AlarmData alarmData; + + @Data + @Builder(setterPrefix = "with") + @NoArgsConstructor + @AllArgsConstructor + public static class AlarmData { + private String alarmName; + private State state; + private PreviousState previousState; + private Configuration configuration; + } + + @Data + @Builder(setterPrefix = "with") + @NoArgsConstructor + @AllArgsConstructor + public static class State { + private String value; + private String reason; + private String timestamp; + } + + @Data + @Builder(setterPrefix = "with") + @NoArgsConstructor + @AllArgsConstructor + public static class PreviousState { + private String value; + private String reason; + private String reasonData; + private String timestamp; + } + + @Data + @Builder(setterPrefix = "with") + @NoArgsConstructor + @AllArgsConstructor + public static class Configuration { + private String description; + private List metrics; + } + + @Data + @Builder(setterPrefix = "with") + @NoArgsConstructor + @AllArgsConstructor + public static class Metric { + private String id; + private MetricStat metricStat; + private Boolean returnData; + } + + @Data + @Builder(setterPrefix = "with") + @NoArgsConstructor + @AllArgsConstructor + public static class MetricStat { + private MetricDetail metric; + private Integer period; + private String stat; + private String unit; + } + + @Data + @Builder(setterPrefix = "with") + @NoArgsConstructor + @AllArgsConstructor + public static class MetricDetail { + private String namespace; + private String name; + private Map dimensions; + } +} diff --git a/aws-lambda-java-events/src/test/java/com/amazonaws/services/lambda/runtime/events/CloudWatchAlarmEventTest.java b/aws-lambda-java-events/src/test/java/com/amazonaws/services/lambda/runtime/events/CloudWatchAlarmEventTest.java deleted file mode 100644 index 63a20955..00000000 --- a/aws-lambda-java-events/src/test/java/com/amazonaws/services/lambda/runtime/events/CloudWatchAlarmEventTest.java +++ /dev/null @@ -1,58 +0,0 @@ -package com.amazonaws.services.lambda.runtime.events; - -import com.amazonaws.services.lambda.runtime.serialization.PojoSerializer; -import com.amazonaws.services.lambda.runtime.serialization.factories.JacksonFactory; -import org.json.JSONException; -import org.junit.jupiter.api.Test; - -import java.io.ByteArrayOutputStream; -import java.io.IOException; -import java.nio.charset.StandardCharsets; -import java.nio.file.Files; -import java.nio.file.Path; -import java.nio.file.Paths; - -import static org.skyscreamer.jsonassert.JSONAssert.assertEquals; -import static org.skyscreamer.jsonassert.JSONCompareMode.STRICT; - -public class CloudWatchAlarmEventTest { - - JacksonFactory jacksonFactory = JacksonFactory.getInstance(); - - @Test - public void serdeCloudWatchCompositeAlarmEvent() throws JSONException { - String expected = readResource("cloudwatch-composite-alarm.json"); - String actual = deserializeSerializeJsonToString(expected, CloudWatchAlarmEvent.class); - - assertEquals(expected, actual, STRICT); - } - - @Test - public void serdeCloudWatchMetricAlarmEvent() throws JSONException { - String expected = readResource("cloudwatch-composite-alarm.json"); - String actual = deserializeSerializeJsonToString(expected, CloudWatchAlarmEvent.class); - - assertEquals(expected, actual, STRICT); - } - - private String deserializeSerializeJsonToString(String expected, Class modelClass) { - PojoSerializer serializer = jacksonFactory.getSerializer(modelClass); - T event = serializer.fromJson(expected); - - ByteArrayOutputStream baos = new ByteArrayOutputStream(); - serializer.toJson(event, baos); - - return new String(baos.toByteArray(), StandardCharsets.UTF_8); - } - - private String readResource(String name) { - Path filePath = Paths.get("src", "test", "resources", name); - byte[] bytes = new byte[0]; - try { - bytes = Files.readAllBytes(filePath); - } catch (IOException e) { - e.printStackTrace(); - } - return new String(bytes, StandardCharsets.UTF_8); - } -} \ No newline at end of file diff --git a/aws-lambda-java-tests/src/main/java/com/amazonaws/services/lambda/runtime/tests/EventLoader.java b/aws-lambda-java-tests/src/main/java/com/amazonaws/services/lambda/runtime/tests/EventLoader.java index aa600749..86886ea2 100644 --- a/aws-lambda-java-tests/src/main/java/com/amazonaws/services/lambda/runtime/tests/EventLoader.java +++ b/aws-lambda-java-tests/src/main/java/com/amazonaws/services/lambda/runtime/tests/EventLoader.java @@ -45,10 +45,18 @@ public static CloudFrontEvent loadCloudFrontEvent(String filename) { return loadEvent(filename, CloudFrontEvent.class); } + public static CloudWatchCompositeAlarmEvent loadCloudWatchCompositeAlarmEvent(String filename) { + return loadEvent(filename, CloudWatchCompositeAlarmEvent.class); + } + public static CloudWatchLogsEvent loadCloudWatchLogsEvent(String filename) { return loadEvent(filename, CloudWatchLogsEvent.class); } + public static CloudWatchMetricAlarmEvent loadCloudWatchMetricAlarmEvent(String filename) { + return loadEvent(filename, CloudWatchMetricAlarmEvent.class); + } + public static CodeCommitEvent loadCodeCommitEvent(String filename) { return loadEvent(filename, CodeCommitEvent.class); } diff --git a/aws-lambda-java-tests/src/test/java/com/amazonaws/services/lambda/runtime/tests/EventLoaderTest.java b/aws-lambda-java-tests/src/test/java/com/amazonaws/services/lambda/runtime/tests/EventLoaderTest.java index 1c9d17e1..70da98a5 100644 --- a/aws-lambda-java-tests/src/test/java/com/amazonaws/services/lambda/runtime/tests/EventLoaderTest.java +++ b/aws-lambda-java-tests/src/test/java/com/amazonaws/services/lambda/runtime/tests/EventLoaderTest.java @@ -1,6 +1,37 @@ /* Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved. */ package com.amazonaws.services.lambda.runtime.tests; +import com.amazonaws.services.lambda.runtime.events.APIGatewayCustomAuthorizerEvent; +import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent; +import com.amazonaws.services.lambda.runtime.events.APIGatewayV2CustomAuthorizerEvent; +import com.amazonaws.services.lambda.runtime.events.APIGatewayV2HTTPEvent; +import com.amazonaws.services.lambda.runtime.events.ActiveMQEvent; +import com.amazonaws.services.lambda.runtime.events.ApplicationLoadBalancerRequestEvent; +import com.amazonaws.services.lambda.runtime.events.CloudFormationCustomResourceEvent; +import com.amazonaws.services.lambda.runtime.events.CloudFrontEvent; +import com.amazonaws.services.lambda.runtime.events.CloudWatchCompositeAlarmEvent; +import com.amazonaws.services.lambda.runtime.events.CloudWatchCompositeAlarmEvent.AlarmData; +import com.amazonaws.services.lambda.runtime.events.CloudWatchCompositeAlarmEvent.Configuration; +import com.amazonaws.services.lambda.runtime.events.CloudWatchCompositeAlarmEvent.PreviousState; +import com.amazonaws.services.lambda.runtime.events.CloudWatchCompositeAlarmEvent.State; +import com.amazonaws.services.lambda.runtime.events.CloudWatchLogsEvent; +import com.amazonaws.services.lambda.runtime.events.CloudWatchMetricAlarmEvent; +import com.amazonaws.services.lambda.runtime.events.CodeCommitEvent; +import com.amazonaws.services.lambda.runtime.events.CognitoUserPoolPreTokenGenerationEventV2; +import com.amazonaws.services.lambda.runtime.events.ConfigEvent; +import com.amazonaws.services.lambda.runtime.events.ConnectEvent; +import com.amazonaws.services.lambda.runtime.events.DynamodbEvent; +import com.amazonaws.services.lambda.runtime.events.KafkaEvent; +import com.amazonaws.services.lambda.runtime.events.KinesisEvent; +import com.amazonaws.services.lambda.runtime.events.KinesisFirehoseEvent; +import com.amazonaws.services.lambda.runtime.events.LambdaDestinationEvent; +import com.amazonaws.services.lambda.runtime.events.LexEvent; +import com.amazonaws.services.lambda.runtime.events.RabbitMQEvent; +import com.amazonaws.services.lambda.runtime.events.S3Event; +import com.amazonaws.services.lambda.runtime.events.SNSEvent; +import com.amazonaws.services.lambda.runtime.events.SQSEvent; +import com.amazonaws.services.lambda.runtime.events.ScheduledEvent; +import com.amazonaws.services.lambda.runtime.events.SecretsManagerRotationEvent; import com.amazonaws.services.lambda.runtime.events.models.dynamodb.AttributeValue; import com.amazonaws.services.lambda.runtime.events.models.dynamodb.Record; import com.amazonaws.services.lambda.runtime.events.models.dynamodb.StreamRecord; @@ -15,8 +46,6 @@ import static java.time.Instant.ofEpochSecond; import static org.assertj.core.api.Assertions.*; -import com.amazonaws.services.lambda.runtime.events.*; - public class EventLoaderTest { @Test @@ -376,4 +405,108 @@ public void testLoadCognitoUserPoolPreTokenGenerationEventV2() { String[] requestScopes = request.getScopes(); assertThat("aws.cognito.signin.user.admin").isEqualTo(requestScopes[0]); } + + @Test + public void testCloudWatchCompositeAlarmEvent() { + CloudWatchCompositeAlarmEvent event = EventLoader.loadCloudWatchCompositeAlarmEvent("cloudwatch_composite_alarm.json"); + assertThat(event).isNotNull(); + assertThat(event) + .returns("aws.cloudwatch", from(CloudWatchCompositeAlarmEvent::getSource)) + .returns("arn:aws:cloudwatch:us-east-1:111122223333:alarm:SuppressionDemo.Main", from(CloudWatchCompositeAlarmEvent::getAlarmArn)) + .returns("111122223333", from(CloudWatchCompositeAlarmEvent::getAccountId)) + .returns("2023-08-04T12:56:46.138+0000", from(CloudWatchCompositeAlarmEvent::getTime)) + .returns("us-east-1", from(CloudWatchCompositeAlarmEvent::getRegion)); + + AlarmData alarmData = event.getAlarmData(); + assertThat(alarmData).isNotNull(); + assertThat(alarmData) + .returns("CompositeDemo.Main", from(AlarmData::getAlarmName)); + + State state = alarmData.getState(); + assertThat(state).isNotNull(); + assertThat(state) + .returns("ALARM", from(State::getValue)) + .returns("arn:aws:cloudwatch:us-east-1:111122223333:alarm:CompositeDemo.FirstChild transitioned to ALARM at Friday 04 August, 2023 12:54:46 UTC", from(State::getReason)) + .returns("{\"triggeringAlarms\":[{\"arn\":\"arn:aws:cloudwatch:us-east-1:111122223333:alarm:CompositeDemo.FirstChild\",\"state\":{\"value\":\"ALARM\",\"timestamp\":\"2023-08-04T12:54:46.138+0000\"}}]}", from(State::getReasonData)) + .returns("2023-08-04T12:56:46.138+0000", from(State::getTimestamp)); + + PreviousState previousState = alarmData.getPreviousState(); + assertThat(previousState).isNotNull(); + assertThat(previousState) + .returns("ALARM", from(PreviousState::getValue)) + .returns("arn:aws:cloudwatch:us-east-1:111122223333:alarm:CompositeDemo.FirstChild transitioned to ALARM at Friday 04 August, 2023 12:54:46 UTC", from(PreviousState::getReason)) + .returns("{\"triggeringAlarms\":[{\"arn\":\"arn:aws:cloudwatch:us-east-1:111122223333:alarm:CompositeDemo.FirstChild\",\"state\":{\"value\":\"ALARM\",\"timestamp\":\"2023-08-04T12:54:46.138+0000\"}}]}", from(PreviousState::getReasonData)) + .returns("2023-08-04T12:54:46.138+0000", from(PreviousState::getTimestamp)) + .returns("WaitPeriod", from(PreviousState::getActionsSuppressedBy)) + .returns("Actions suppressed by WaitPeriod", from(PreviousState::getActionsSuppressedReason)); + + Configuration configuration = alarmData.getConfiguration(); + assertThat(configuration).isNotNull(); + assertThat(configuration) + .returns("ALARM(CompositeDemo.FirstChild) OR ALARM(CompositeDemo.SecondChild)", from(Configuration::getAlarmRule)) + .returns("CompositeDemo.ActionsSuppressor", from(Configuration::getActionsSuppressor)) + .returns(120, from(Configuration::getActionsSuppressorWaitPeriod)) + .returns(180, from(Configuration::getActionsSuppressorExtensionPeriod)); + } + + @Test + public void testCloudWatchMetricAlarmEvent() { + CloudWatchMetricAlarmEvent event = EventLoader.loadCloudWatchMetricAlarmEvent("cloudwatch_metric_alarm.json"); + assertThat(event).isNotNull(); + assertThat(event) + .returns("aws.cloudwatch", from(CloudWatchMetricAlarmEvent::getSource)) + .returns("arn:aws:cloudwatch:us-east-1:444455556666:alarm:lambda-demo-metric-alarm", from(CloudWatchMetricAlarmEvent::getAlarmArn)) + .returns("444455556666", from(CloudWatchMetricAlarmEvent::getAccountId)) + .returns("2023-08-04T12:36:15.490+0000", from(CloudWatchMetricAlarmEvent::getTime)) + .returns("us-east-1", from(CloudWatchMetricAlarmEvent::getRegion)); + + CloudWatchMetricAlarmEvent.AlarmData alarmData = event.getAlarmData(); + assertThat(alarmData).isNotNull(); + assertThat(alarmData) + .returns("lambda-demo-metric-alarm", from(CloudWatchMetricAlarmEvent.AlarmData::getAlarmName)); + + CloudWatchMetricAlarmEvent.State state = alarmData.getState(); + assertThat(state).isNotNull(); + assertThat(state) + .returns("ALARM", from(CloudWatchMetricAlarmEvent.State::getValue)) + .returns("test", from(CloudWatchMetricAlarmEvent.State::getReason)) + .returns("2023-08-04T12:36:15.490+0000", from(CloudWatchMetricAlarmEvent.State::getTimestamp)); + + CloudWatchMetricAlarmEvent.PreviousState previousState = alarmData.getPreviousState(); + assertThat(previousState).isNotNull(); + assertThat(previousState) + .returns("INSUFFICIENT_DATA", from(CloudWatchMetricAlarmEvent.PreviousState::getValue)) + .returns("Insufficient Data: 5 datapoints were unknown.", from(CloudWatchMetricAlarmEvent.PreviousState::getReason)) + .returns("{\"version\":\"1.0\",\"queryDate\":\"2023-08-04T12:31:29.591+0000\",\"statistic\":\"Average\",\"period\":60,\"recentDatapoints\":[],\"threshold\":5.0,\"evaluatedDatapoints\":[{\"timestamp\":\"2023-08-04T12:30:00.000+0000\"},{\"timestamp\":\"2023-08-04T12:29:00.000+0000\"},{\"timestamp\":\"2023-08-04T12:28:00.000+0000\"},{\"timestamp\":\"2023-08-04T12:27:00.000+0000\"},{\"timestamp\":\"2023-08-04T12:26:00.000+0000\"}]}", from(CloudWatchMetricAlarmEvent.PreviousState::getReasonData)) + .returns("2023-08-04T12:31:29.595+0000", from(CloudWatchMetricAlarmEvent.PreviousState::getTimestamp)); + + CloudWatchMetricAlarmEvent.Configuration configuration = alarmData.getConfiguration(); + assertThat(configuration).isNotNull(); + assertThat(configuration) + .returns("Metric Alarm to test Lambda actions", from(CloudWatchMetricAlarmEvent.Configuration::getDescription)); + + List metrics = configuration.getMetrics(); + assertThat(metrics).hasSize(1); + CloudWatchMetricAlarmEvent.Metric metric = metrics.get(0); + assertThat(metric) + .returns("1234e046-06f0-a3da-9534-EXAMPLEe4c", from(CloudWatchMetricAlarmEvent.Metric::getId)); + + CloudWatchMetricAlarmEvent.MetricStat metricStat = metric.getMetricStat(); + assertThat(metricStat).isNotNull(); + assertThat(metricStat) + .returns(60, from(CloudWatchMetricAlarmEvent.MetricStat::getPeriod)) + .returns("Average", from(CloudWatchMetricAlarmEvent.MetricStat::getStat)) + .returns("Percent", from(CloudWatchMetricAlarmEvent.MetricStat::getUnit)); + + CloudWatchMetricAlarmEvent.MetricDetail metricDetail = metricStat.getMetric(); + assertThat(metricDetail).isNotNull(); + assertThat(metricDetail) + .returns("AWS/Logs", from(CloudWatchMetricAlarmEvent.MetricDetail::getNamespace)) + .returns("CallCount", from(CloudWatchMetricAlarmEvent.MetricDetail::getName)); + + Map dimensions = metricDetail.getDimensions(); + assertThat(dimensions).isNotEmpty().hasSize(1); + assertThat(dimensions) + .contains(entry("InstanceId", "i-12345678")); + } } diff --git a/aws-lambda-java-events/src/test/resources/cloudwatch-composite-alarm.json b/aws-lambda-java-tests/src/test/resources/cloudwatch_composite_alarm.json similarity index 100% rename from aws-lambda-java-events/src/test/resources/cloudwatch-composite-alarm.json rename to aws-lambda-java-tests/src/test/resources/cloudwatch_composite_alarm.json diff --git a/aws-lambda-java-events/src/test/resources/cloudwatch-metric-alarm.json b/aws-lambda-java-tests/src/test/resources/cloudwatch_metric_alarm.json similarity index 98% rename from aws-lambda-java-events/src/test/resources/cloudwatch-metric-alarm.json rename to aws-lambda-java-tests/src/test/resources/cloudwatch_metric_alarm.json index 8d7de148..61b4187b 100644 --- a/aws-lambda-java-events/src/test/resources/cloudwatch-metric-alarm.json +++ b/aws-lambda-java-tests/src/test/resources/cloudwatch_metric_alarm.json @@ -34,7 +34,7 @@ "stat": "Average", "unit": "Percent" }, - "returnData": True + "returnData": true } ] }