feat(examples): add simple invoke tests (#207)

*Issue #, if available:*

*Description of changes:*

Adding simple invoke tests with:
- durable handler
- non-durable handler
- failing handler
- named step with payload

Additionally:
- updating language SDK to accept calling invoke with no input, since
the API supports it
- enable registering non-durable functions in testing library for
invoke, since the API supports it


By submitting this pull request, I confirm that you can use, modify,
copy, and redistribute this contribution, under the terms of your
choice.

Author: anthonyting

packages/aws-durable-execution-sdk-js-examples/scripts/deploy-lambda.ts

@@ -16,6 +16,7 @@ import {
   ResourceNotFoundException,
   ResourceConflictException,
   UpdateFunctionConfigurationCommandInput,
+  DeleteFunctionCommand,
 } from "@aws-sdk/client-lambda";
 import { ExamplesWithConfig } from "../src/types";
 import catalog from "@aws/durable-execution-sdk-js-examples/catalog";
@@ -214,10 +215,13 @@ async function createFunction(
     Handler: exampleConfig.handler,
     Description: exampleConfig.description,
     Code: { ZipFile: zipBuffer },
-    DurableConfig: {
-      RetentionPeriodInDays: exampleConfig.durableConfig.RetentionPeriodInDays,
-      ExecutionTimeout: exampleConfig.durableConfig.ExecutionTimeout,
-    },
+    DurableConfig: exampleConfig.durableConfig
+      ? {
+          RetentionPeriodInDays:
+            exampleConfig.durableConfig.RetentionPeriodInDays,
+          ExecutionTimeout: exampleConfig.durableConfig.ExecutionTimeout,
+        }
+      : undefined,
     Timeout: 60,
     MemorySize: 128,
     Environment: {
@@ -243,12 +247,10 @@ async function updateFunction(
 ): Promise<void> {
   console.log(`Deploying function: ${functionName} (updating existing)`);
 
-  const currentRetention =
-    currentConfig.DurableConfig?.RetentionPeriodInDays || "none";
-  const currentTimeout =
-    currentConfig.DurableConfig?.ExecutionTimeout || "none";
-  const targetRetention = exampleConfig.durableConfig.RetentionPeriodInDays;
-  const targetTimeout = exampleConfig.durableConfig.ExecutionTimeout;
+  const currentRetention = currentConfig.DurableConfig?.RetentionPeriodInDays;
+  const currentTimeout = currentConfig.DurableConfig?.ExecutionTimeout;
+  const targetRetention = exampleConfig.durableConfig?.RetentionPeriodInDays;
+  const targetTimeout = exampleConfig.durableConfig?.ExecutionTimeout;
 
   console.log("Function exists with current DurableConfig:");
   console.log(`  Current Retention: ${currentRetention} days`);
@@ -330,10 +332,10 @@ async function main(): Promise<void> {
       console.log(`  Runtime: ${runtime}`);
     }
     console.log(
-      `  Retention: ${exampleConfig.durableConfig.RetentionPeriodInDays} days`,
+      `  Retention: ${exampleConfig.durableConfig?.RetentionPeriodInDays} days`,
     );
     console.log(
-      `  Timeout: ${exampleConfig.durableConfig.ExecutionTimeout} seconds`,
+      `  Timeout: ${exampleConfig.durableConfig?.ExecutionTimeout} seconds`,
     );
 
     // Validate zip file exists
@@ -346,27 +348,34 @@ async function main(): Promise<void> {
     });
 
     console.log("Checking if function exists...");
-    const functionExists = await checkFunctionExists(
-      lambdaClient,
-      functionName,
-    );
+    let functionExists = await checkFunctionExists(lambdaClient, functionName);
+    let currentConfig: GetFunctionConfigurationCommandOutput;
 
     const zipFile = `${example}.zip`;
 
     const selectedRuntime = mapRuntimeToEnum(runtime);
 
     if (functionExists) {
-      const currentConfig = await getCurrentConfiguration(
-        lambdaClient,
-        functionName,
-      );
+      currentConfig = await getCurrentConfiguration(lambdaClient, functionName);
+      if (!!currentConfig.DurableConfig !== !!exampleConfig.durableConfig) {
+        console.log("Deleting function since durable changed");
+        await lambdaClient.send(
+          new DeleteFunctionCommand({
+            FunctionName: functionName,
+          }),
+        );
+        functionExists = false;
+      }
+    }
+
+    if (functionExists) {
       await updateFunction(
         lambdaClient,
         functionName,
         exampleConfig,
         zipFile,
         env,
-        currentConfig,
+        currentConfig!,
         selectedRuntime,
       );
     } else {

packages/aws-durable-execution-sdk-js-examples/src/examples/invoke/simple/invoke-simple.test.ts

@@ -0,0 +1,111 @@
+import { LocalDurableTestRunner } from "@aws/durable-execution-sdk-js-testing";
+import { createTests } from "../../../utils/test-helper";
+import { handler } from "./invoke-simple";
+import { handler as namedWaitHandler } from "../../wait/named/wait-named";
+import { handler as handlerErrorHandler } from "../../handler-error/handler-error";
+import { handler as nonDurableHandler } from "../../non-durable/non-durable";
+import { handler as namedStepHandler } from "../../step/named/step-named";
+
+createTests({
+  name: "invoke-simple",
+  functionName: "invoke-simple",
+  handler,
+  tests: function (runner, _, functionNameMap) {
+    it("should run invoke with basic wait state", async () => {
+      if (runner instanceof LocalDurableTestRunner) {
+        runner.registerDurableFunction(
+          functionNameMap.getFunctionName("wait-named"),
+          namedWaitHandler,
+        );
+      }
+
+      const result = await runner.run({
+        payload: {
+          functionName: functionNameMap.getFunctionName("wait-named"),
+        },
+      });
+      expect(result.getResult()).toBe("wait finished");
+    });
+
+    it("should run invoke with step and payload", async () => {
+      if (runner instanceof LocalDurableTestRunner) {
+        runner.registerDurableFunction(
+          functionNameMap.getFunctionName("step-named"),
+          namedStepHandler,
+        );
+      }
+
+      const result = await runner.run({
+        payload: {
+          functionName: functionNameMap.getFunctionName("step-named"),
+          payload: {
+            data: "data from parent",
+          },
+        },
+      });
+      expect(result.getResult()).toEqual("processed: data from parent");
+    });
+
+    it("should run invoke with child function failure", async () => {
+      if (runner instanceof LocalDurableTestRunner) {
+        runner.registerDurableFunction(
+          functionNameMap.getFunctionName("handler-error"),
+          handlerErrorHandler,
+        );
+      }
+
+      const result = await runner.run({
+        payload: {
+          functionName: functionNameMap.getFunctionName("handler-error"),
+        },
+      });
+      expect(result.getError()).toEqual({
+        errorMessage: "Intentional handler failure",
+        errorType: "InvokeError",
+      });
+    });
+
+    it("should run invoke with non-durable function success", async () => {
+      if (runner instanceof LocalDurableTestRunner) {
+        runner.registerFunction(
+          functionNameMap.getFunctionName("non-durable"),
+          nonDurableHandler,
+        );
+      }
+
+      const result = await runner.run({
+        payload: {
+          functionName: functionNameMap.getFunctionName("non-durable"),
+        },
+      });
+      expect(result.getResult()).toEqual({
+        status: 200,
+        body: JSON.stringify({
+          message: "Hello from Lambda!",
+        }),
+      });
+    });
+
+    it("should run invoke with non-durable function failure", async () => {
+      if (runner instanceof LocalDurableTestRunner) {
+        runner.registerFunction(
+          functionNameMap.getFunctionName("non-durable"),
+          nonDurableHandler,
+        );
+      }
+
+      const result = await runner.run({
+        payload: {
+          functionName: functionNameMap.getFunctionName("non-durable"),
+          payload: {
+            failure: true,
+          },
+        },
+      });
+      expect(result.getError()).toEqual({
+        errorMessage: "This is a failure",
+        errorType: "InvokeError",
+      });
+    });
+  },
+});

packages/aws-durable-execution-sdk-js-examples/src/examples/invoke/simple/invoke-simple.ts

@@ -0,0 +1,24 @@
+import {
+  DurableContext,
+  withDurableExecution,
+} from "@aws/durable-execution-sdk-js";
+import { ExampleConfig } from "../../../types";
+
+export const config: ExampleConfig = {
+  name: "Invoke Simple",
+  description:
+    "Demonstrates a simple invoke, returning the result of the invoke",
+};
+
+export const handler = withDurableExecution(
+  async (
+    event: {
+      functionName: string;
+      payload: Record<string, any>;
+    },
+    context: DurableContext,
+  ) => {
+    const result = await context.invoke(event.functionName, event.payload);
+    return result;
+  },
+);

packages/aws-durable-execution-sdk-js-examples/src/examples/non-durable/non-durable.ts

@@ -0,0 +1,20 @@
+import { ExampleConfig } from "../../types";
+
+export const config: ExampleConfig = {
+  name: "Non-Durable",
+  description: "A simple non-durable function used for testing.",
+  durableConfig: null,
+};
+
+export const handler = async (event: { failure: boolean }) => {
+  if (event.failure) {
+    throw new Error("This is a failure");
+  }
+
+  await new Promise((resolve) => setTimeout(resolve, 1000));
+
+  return {
+    status: 200,
+    body: JSON.stringify({ message: "Hello from Lambda!" }),
+  };
+};

packages/aws-durable-execution-sdk-js-examples/src/types/index.ts

@@ -5,13 +5,12 @@ export interface ExampleConfig {
   description?: string;
   /**
    * The durable config of the function. By default, RetentionPeriodInDays will be set to 7 days
-   * and ExecutionTimeout will be set to 60 seconds.
+   * and ExecutionTimeout will be set to 60 seconds. Null if function is not durable.
    */
-  durableConfig?: DurableConfig;
+  durableConfig?: DurableConfig | null;
 }
 
 export type ExamplesWithConfig = ExampleConfig & {
-  durableConfig: DurableConfig;
   path: string;
   handler: string;
 };

packages/aws-durable-execution-sdk-js-examples/src/utils/examples.ts

@@ -46,12 +46,18 @@ export class Examples {
         ? config.description
         : undefined;
 
+    const durableConfig =
+      "durableConfig" in config && typeof config.durableConfig === "object"
+        ? config.durableConfig
+        : undefined;
+
     return {
       name: config.name,
       description,
       path: examplePath,
       handler: handlerName,
-      durableConfig: DEFAULT_DURABLE_CONFIG,
+      durableConfig:
+        durableConfig === undefined ? DEFAULT_DURABLE_CONFIG : durableConfig,
     };
   }
 

packages/aws-durable-execution-sdk-js-examples/src/utils/test-helper.ts

@@ -7,20 +7,41 @@ import {
   InvocationType,
 } from "@aws/durable-execution-sdk-js-testing";
 
+type TestCallback<ResultType> = (
+  runner: DurableTestRunner<DurableOperation<unknown>, ResultType>,
+  isCloud: boolean,
+  functionNameMap: FunctionNameMap,
+) => void;
+
 export interface TestDefinition<ResultType> {
   name: string;
   functionName: string;
   handler: LocalTestRunnerHandlerFunction;
-  tests: (
-    runner: DurableTestRunner<DurableOperation<unknown>, ResultType>,
-    isCloud: boolean,
-  ) => void;
+  tests: TestCallback<ResultType>;
   invocationType?: InvocationType;
   localRunnerConfig?: {
     skipTime?: boolean;
   };
 }
 
+export interface FunctionNameMap {
+  getFunctionName(functionName: string): string;
+}
+
+class CloudFunctionNameMap implements FunctionNameMap {
+  constructor(private readonly functionNameMap: Record<string, string>) {}
+
+  getFunctionName(functionName: string): string {
+    return this.functionNameMap[functionName];
+  }
+}
+
+class LocalFunctionNameMap implements FunctionNameMap {
+  getFunctionName(functionName: string): string {
+    return functionName;
+  }
+}
+
 /**
  * Creates tests that automatically run with the appropriate test runner
  * based on the environment variables passed in.
@@ -32,7 +53,10 @@ export function createTests<ResultType>(testDef: TestDefinition<ResultType>) {
       throw new Error("FUNCTION_NAME_MAP is not set for integration tests");
     }
 
-    const functionNames = JSON.parse(process.env.FUNCTION_NAME_MAP!);
+    const functionNames = JSON.parse(process.env.FUNCTION_NAME_MAP!) as Record<
+      string,
+      string
+    >;
     const functionName = functionNames[testDef.functionName];
     if (!functionName) {
       throw new Error(
@@ -57,7 +81,7 @@ export function createTests<ResultType>(testDef: TestDefinition<ResultType>) {
     });
 
     describe(`${testDef.name} (cloud)`, () => {
-      testDef.tests(runner, true);
+      testDef.tests(runner, true, new CloudFunctionNameMap(functionNames));
     });
     return;
   }
@@ -81,6 +105,6 @@ export function createTests<ResultType>(testDef: TestDefinition<ResultType>) {
       runner.reset();
     });
 
-    testDef.tests(runner, false);
+    testDef.tests(runner, false, new LocalFunctionNameMap());
   });
 }