aws testing endpoint

aws test event server

hot replacement lambda

hot replacement lambda cleanup

hot replacement lambda cleanup 2

lambda http finish

add gson to benchmarks

do not enable mock lambda if LambdaClint

final dev mode touches lambda

lambda native testing

comment

comment

finish it

process resources

fix banned dependency

fix banned dependency

fixes

debug lambda test mode

finish mock event initial

process res

logging remove

lambda fixes

lambda continuous testing test

Author: patriot1burke

bom/application/pom.xml

@@ -1928,6 +1928,21 @@
                 <artifactId>quarkus-amazon-common</artifactId>
                 <version>${project.version}</version>
             </dependency>
+            <dependency>
+                <groupId>io.quarkus</groupId>
+                <artifactId>quarkus-amazon-lambda-event-server</artifactId>
+                <version>${project.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>io.quarkus</groupId>
+                <artifactId>quarkus-amazon-lambda-http-event-server</artifactId>
+                <version>${project.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>io.quarkus</groupId>
+                <artifactId>quarkus-amazon-lambda-rest-event-server</artifactId>
+                <version>${project.version}</version>
+            </dependency>
             <dependency>
                 <groupId>io.quarkus</groupId>
                 <artifactId>quarkus-amazon-common-deployment</artifactId>

devtools/project-core-extension-codestarts/src/main/resources/codestarts/quarkus/examples/amazon-lambda-example/codestart.yml

@@ -11,4 +11,4 @@ language:
     dependencies:
       - io.quarkus:quarkus-amazon-lambda
     test-dependencies:
-      - io.quarkus:quarkus-test-amazon-lambda
+      - io.rest-assured:rest-assured

devtools/project-core-extension-codestarts/src/main/resources/codestarts/quarkus/examples/amazon-lambda-example/java/src/test/java/org/acme/lambda/LambdaHandlerTest.java

@@ -1,20 +1,31 @@
 package org.acme.lambda;
 
-import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
-import io.quarkus.amazon.lambda.test.LambdaClient;
 import io.quarkus.test.junit.QuarkusTest;
 
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.CoreMatchers.containsString;
+
 @QuarkusTest
 public class LambdaHandlerTest {
 
     @Test
     public void testSimpleLambdaSuccess() throws Exception {
+        // you test your lambas by invoking on http://localhost:8081
+        // this works in dev mode too
+
         Person in = new Person();
         in.setName("Stu");
-        String out = LambdaClient.invoke(String.class, in);
-        Assertions.assertEquals("Hello Stu", out);
+        given()
+                .contentType("application/json")
+                .accept("application/json")
+                .body(in)
+                .when()
+                .post()
+                .then()
+                .statusCode(200)
+                .body(containsString("Hello Stu"));
     }
 
 }

devtools/project-core-extension-codestarts/src/main/resources/codestarts/quarkus/examples/amazon-lambda-example/java/src/test/resources/application.yml

@@ -14,4 +14,4 @@ language:
     dependencies:
       - io.quarkus:quarkus-funqy-amazon-lambda
     test-dependencies:
-      - io.quarkus:quarkus-test-amazon-lambda
+      - io.rest-assured:rest-assured

devtools/project-core-extension-codestarts/src/main/resources/codestarts/quarkus/examples/funqy-amazon-lambda-example/codestart.yml

@@ -1,16 +1,31 @@
 package org.acme.funqy;
 
-import io.quarkus.amazon.lambda.test.LambdaClient;
-import io.quarkus.test.junit.QuarkusTest;
-import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
+import io.quarkus.test.junit.QuarkusTest;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.CoreMatchers.containsString;
 
 @QuarkusTest
 public class FunqyTest {
+
     @Test
-    public void testSimpleLambdaSuccess() throws Exception {
-        Person friend = new Person("Bill");
-        String out = LambdaClient.invoke(String.class, friend);
-        Assertions.assertEquals("Hello Bill", out);
+    public void testFunqyLambda() throws Exception {
+        // you test your lambas by invoking on http://localhost:8081
+        // this works in dev mode too
+
+        Person in = new Person();
+        in.setName("Bill");
+        given()
+                .contentType("application/json")
+                .accept("application/json")
+                .body(in)
+                .when()
+                .post()
+                .then()
+                .statusCode(200)
+                .body(containsString("Hello Bill"));
     }
+
 }
+

devtools/project-core-extension-codestarts/src/main/resources/codestarts/quarkus/examples/funqy-amazon-lambda-example/java/src/test/java/org/acme/funqy/FunqyTest.java

@@ -19,6 +19,7 @@ Quarkus has a different extension for each Gateway API.  The HTTP Gateway API is
 The REST Gateway API is implemented within the `quarkus-amazon-lambda-rest` extension.  If you are confused on which Gateway product to use,
 Amazon has a https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-vs-rest.html[great guide] to help you navigate this decision.
 
+Like most Quarkus extensions, the Quarkus AWS Lambda HTTP/REST extensions support Live Coding.
 
 include::./status-include.adoc[]
 
@@ -105,7 +106,82 @@ are in the the build directory:  `target/` for Maven, `build/` for Gradle.
 * `sam.jvm.yaml` - sam cli deployment script
 * `sam.native.yaml` - sam cli deployment script for native
 
-== Simulate Amazon Lambda Deployment
+== Live Coding and Simulating AWS Lambda Environment Locally
+
+In dev and test mode, Quarkus will start a mock AWS Lambda event server
+that will convert HTTP requests to the corresponding API Gateway event types and post them to the underlying
+Quarkus HTTP lambda environment for processing.  This simulates the AWS Lambda environment
+as much as possible locally without requiring tools like Docker and SAM CLI.
+
+When using Quarkus Dev Mode just invoke HTTP requests on `http://localhost:8080`
+as you normally would when testing your REST endpoints.  This request will hit the Mock Event Server and will
+be converted to the API Gateway json message that is consumed by the Quarkus Lambda Poll loop.
+
+For testing, Quarkus starts up a separate Mock Event server under port 8081.  The default port for Rest Assured is
+automatically set to 8081 by Quarkus, so you don't have to worry about setting this up.
+
+If you want to simulate more complex
+API Gateway events in your tests, then manually do an HTTP POST to `http://localhost:8080/\_lambda_` (port 8081 in test mode) with
+the raw API Gateway json events.  These events will be placed directly on the Quarkus Lambda poll loop
+for processing.  Here's an example of that:
+
+[source,java]
+----
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.CoreMatchers.equalTo;
+
+import com.amazonaws.services.lambda.runtime.events.APIGatewayV2HTTPEvent;
+
+import io.quarkus.test.junit.QuarkusTest;
+
+@QuarkusTest
+public class AmazonLambdaSimpleTestCase {
+    @Test
+    public void testJaxrsCognitoJWTSecurityContext() throws Exception {
+        APIGatewayV2HTTPEvent request = request("/security/username");
+        request.getRequestContext().setAuthorizer(new APIGatewayV2HTTPEvent.RequestContext.Authorizer());
+        request.getRequestContext().getAuthorizer().setJwt(new APIGatewayV2HTTPEvent.RequestContext.Authorizer.JWT());
+        request.getRequestContext().getAuthorizer().getJwt().setClaims(new HashMap<>());
+        request.getRequestContext().getAuthorizer().getJwt().getClaims().put("cognito:username", "Bill");
+
+        given()
+                .contentType("application/json")
+                .accept("application/json")
+                .body(request)
+                .when()
+                .post("/_lambda_")
+                .then()
+                .statusCode(200)
+                .body("body", equalTo("Bill"));
+    }
+----
+
+The above example simulates sending a Cognito principal with an HTTP request to your HTTP Lambda.
+
+If you want to hand code raw events for the AWS HTTP API, the AWS Lambda library has the request event type which is
+`com.amazonaws.services.lambda.runtime.events.APIGatewayV2HTTPEvent` and the response event type
+of `com.amazonaws.services.lambda.runtime.events.APIGatewayV2HTTPResponse`.  This corresponds
+to the `quarkus-amazon-lambda-http` extension and the AWS HTTP API.
+
+If you want to hand code raw events for the AWS REST API, Quarkus has its own implementation:  `io.quarkus.amazon.lambda.http.model.AwsProxyRequest`
+and `io.quarkus.amazon.lambda.http.model.AwsProxyResponse`.  This corresponds
+to `quarkus-amazon-lambda-rest` extension and the AWS REST API.
+
+The mock event server is also started for `@NativeImageTest` unit tests so will work
+with native binaries too.  All this provides similar functionality to the SAM CLI local testing, without the overhead of Docker.
+
+Finally, if port 8080 or port 8081 is not available on your computer, you can modify the dev
+and test mode ports with application.properties
+
+[source, subs=attributes+]
+----
+quarkus.lambda.mock-event-server.dev-port=8082
+quarkus.lambda.mock-event-server.test-port=8083
+----
+
+
+
+== Simulate Amazon Lambda Deployment with SAM CLI
 
 The AWS SAM CLI allows you to run your lambda's locally on your laptop in a simulated Lambda environment.  This requires Docker to be installed.
 After you have built your Maven project, execute this command:

devtools/project-core-extension-codestarts/src/main/resources/codestarts/quarkus/examples/funqy-amazon-lambda-example/java/src/test/resources/application.yml

@@ -14,6 +14,9 @@ Your lambdas can use injection annotations from CDI or Spring and other Quarkus
 Quarkus lambdas can be deployed using the Amazon Java Runtime, or you can build a native executable and use
 Amazon's Custom Runtime if you want a smaller memory footprint and faster cold boot startup time.
 
+Quarkus's integration with lambdas also supports Quarkus's Live Coding development cycle.  You an
+bring up your Quarkus lambda project in dev or test mode and code on your project live.
+
 include::./status-include.adoc[]
 
 == Prerequisites
@@ -330,96 +333,71 @@ dependencies {
 ----
 
 
-== Integration Testing
-The Quarkus Amazon Lambda extension has a matching test framework that provides functionality to execute standard JUnit tests on your AWS Lambda function,
-via the integration layer that Quarkus provides.  This is true for both JVM and native modes.
-It provides similar functionality to the SAM CLI, without the overhead of Docker.
-
-To illustrate, the project generated by the Maven archetype, generates a JUnit test for the `RequestHandler<?, ?>` implementation, which is shown below.
-The test replicates the execution environment, for the function that is selected for invocation, as described <<choose, above>>.
+== Live Coding and Unit/Integration Testing
+To mirror the AWS Lambda environment as closely as possible in a dev environment,
+the Quarkus Amazon Lambda extension boots up a mock AWS Lambda event server in Quarkus Dev and Test mode.
+This mock event server simulates a true AWS Lambda environment.
 
-To use the integration tests in your project there is a required property, in `src/test/resources/application.properties`. If not included, the integration tests will be in a constant loop.
+While running in Quarkus Dev Mode, you can feed events to it by doing an HTTP POST to `http://localhost:8080`.
+The mock event server will receive the events and your lambda will be invoked.  You can perform live coding on your lambda
+and changes will automatically be recompiled and available the next invocation you make.  Here's an example:
 
-[source,properties]
-----
-quarkus.lambda.enable-polling-jvm-mode=true
+[source,bash]
 ----
+$ mvn clean quarkus:dev
 
-NOTE: If you are following along with the example Maven archetype project for AWS Lambda in this guide,
-it includes the required property `quarkus.lambda.enable-polling-jvm-mode=true` in the test `application.properties`.
-
-[source,java]
+$ curl -d "{\"name\":\"John\"}" -X POST http://localhost:8080
 ----
-@QuarkusTest
-public class LambdaHandlerTest {
 
-    @Test
-    public void testSimpleLambdaSuccess() throws Exception {
-        InputObject in = new InputObject();
-        in.setGreeting("Hello");
-        in.setName("Stu");
+For your unit tests, you can also invoke on the mock event server using any HTTP client you want.  Here's an example
+using rest-assured.  Quarkus starts up a separate Mock Event server under port 8081.
+The default port for Rest Assured is automatically set to 8081 by Quarkus so you can invoke
+on this endpoint.
 
-        OutputObject out = LambdaClient.invoke(OutputObject.class, in);
 
-        Assertions.assertEquals("Hello Stu", out.getResult());
-        Assertions.assertTrue(out.getRequestId().matches("aws-request-\\d"), "Expected requestId as 'aws-request-<number>'");
-    }
-}
+[source,java]
 ----
+import org.junit.jupiter.api.Test;
 
-Similarly, if you are using a `RequestStreamHandler` implementation, you can add a matching JUnit test, like below,
-which aligns to the generated `StreamLambda` class in the generated project.
-
-Obviously, these two types of tests are mutually exclusive.  You must have a test that corresponds to the implemented AWS Lambda interfaces,
-whether `RequestHandler<?, ?>` or `RequestStreamHandler`.
+import io.quarkus.test.junit.QuarkusTest;
 
-Two versions of the Test for `RequestStreamHandler` are presented below.  You can use either, depending on
-the needs of your Unit test.  The first is obviously simpler and quicker.  Using Java streams can require more coding.
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.CoreMatchers.containsString;
 
-[source,java]
-----
 @QuarkusTest
-public class LambdaStreamHandlerTest {
-
-    private static Logger LOG = Logger.getLogger(LambdaStreamHandlerTest.class);
+public class LambdaHandlerTest {
 
     @Test
     public void testSimpleLambdaSuccess() throws Exception {
-        String out = LambdaClient.invoke(String.class, "lowercase");
-        Assertions.assertEquals("LOWERCASE", out);
-    }
-
-    @Test
-    public void testInputStreamSuccess() {
-        try {
-            String input = "{ \"name\": \"Bill\", \"greeting\": \"hello\"}";
-            InputStream inputStream = new ByteArrayInputStream(input.getBytes());
-            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
-
-            LambdaClient.invoke(inputStream, outputStream);
-
-            ByteArrayInputStream out = new ByteArrayInputStream(outputStream.toByteArray());
-            StringBuilder response = new StringBuilder();
-            int i = 0;
-            while ((i = out.read()) != -1) {
-                response.append((char)i);
-            }
-
-            Assertions.assertTrue(response.toString().contains("BILL"));
-        } catch (Exception e) {
-            Assertions.fail(e.getMessage());
-        }
+        Person in = new Person();
+        in.setName("Stu");
+        given()
+                .contentType("application/json")
+                .accept("application/json")
+                .body(in)
+                .when()
+                .post()
+                .then()
+                .statusCode(200)
+                .body(containsString("Hello Stu"));
     }
-
 }
 ----
 
-If your code uses CDI injection, this too will be executed, along with mocking functionality, see the link:getting-started-testing[Test Guide] for more details.
+The mock event server is also started for `@NativeImageTest` unit tests so will work
+with native binaries too.  All this provides similar functionality to the SAM CLI local testing, without the overhead of Docker.
 
-To add JUnit functionality for native tests, add the `@NativeImageTest` annotation to a subclass of your test class, which will execute against your native image, and can be leveraged in an IDE.
+Finally, if port 8080 or port 8081 is not available on your computer, you can modify the dev
+and test mode ports with application.properties
 
+[source, subs=attributes+]
+----
+quarkus.lambda.mock-event-server.dev-port=8082
+quarkus.lambda.mock-event-server.test-port=8083
+----
 
 == Testing with the SAM CLI
+If you do not want to use the mock event server, you can test your lambdas with SAM CLI.
 
 The https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html[AWS SAM CLI]
 allows you to run your lambdas locally on your laptop in a simulated Lambda environment.  This requires

docs/src/main/asciidoc/amazon-lambda-http.adoc

@@ -35,6 +35,10 @@
             <groupId>io.quarkus</groupId>
             <artifactId>quarkus-amazon-lambda-http</artifactId>
         </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-amazon-lambda-http-event-server</artifactId>
+        </dependency>
     </dependencies>
     <build>
         <plugins>

docs/src/main/asciidoc/amazon-lambda.adoc

@@ -15,12 +15,10 @@
 import io.quarkus.arc.deployment.AdditionalBeanBuildItem;
 import io.quarkus.deployment.annotations.BuildProducer;
 import io.quarkus.deployment.annotations.BuildStep;
-import io.quarkus.deployment.builditem.LaunchModeBuildItem;
 import io.quarkus.deployment.builditem.SystemPropertyBuildItem;
 import io.quarkus.deployment.builditem.nativeimage.ReflectiveClassBuildItem;
 import io.quarkus.deployment.pkg.builditem.ArtifactResultBuildItem;
 import io.quarkus.deployment.pkg.builditem.OutputTargetBuildItem;
-import io.quarkus.runtime.LaunchMode;
 import io.quarkus.vertx.http.deployment.RequireVirtualHttpBuildItem;
 import io.vertx.core.file.impl.FileResolver;
 
@@ -41,8 +39,8 @@ public void setupSecurity(BuildProducer<AdditionalBeanBuildItem> additionalBeans
     }
 
     @BuildStep
-    public RequireVirtualHttpBuildItem requestVirtualHttp(LaunchModeBuildItem launchMode) {
-        return launchMode.getLaunchMode() == LaunchMode.NORMAL ? RequireVirtualHttpBuildItem.MARKER : null;
+    public RequireVirtualHttpBuildItem requestVirtualHttp() {
+        return RequireVirtualHttpBuildItem.ALWAYS_VIRTUAL;
     }
 
     @BuildStep