refactor(testing-sdk): change operation storage to register operations on base class and use API interfaces (#89)

*Issue #, if available:*

DAR-SDK-305

*Description of changes:*

Refactoring operation storage to use API interfaces, and to register
operations on the base class.

This will allow for the cloud runner to call APIs such as
SendCallbackSuccess, and to register operations before the cloud runner
starts.

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-testing/src/test-runner/cloud/__tests__/cloud-durable-test-runner.test.ts

@@ -149,7 +149,8 @@ describe("CloudDurableTestRunner", () => {
       expect(IndexedOperations).toHaveBeenCalledWith([]);
       expect(OperationStorage).toHaveBeenCalledWith(
         mockWaitManager,
-        mockIndexedOperations
+        mockIndexedOperations,
+        expect.any(Object)
       );
     });
   });
@@ -396,6 +397,7 @@ describe("CloudDurableTestRunner", () => {
         expect(OperationWithData).toHaveBeenCalledWith(
           mockWaitManager,
           mockIndexedOperations,
+          expect.any(Object),
           mockOperation
         );
         expect(result).toBe(mockOperationWithData);
@@ -416,6 +418,7 @@ describe("CloudDurableTestRunner", () => {
         expect(OperationWithData).toHaveBeenCalledWith(
           mockWaitManager,
           mockIndexedOperations,
+          expect.any(Object),
           mockOperation
         );
         expect(result).toBe(mockOperationWithData);
@@ -439,6 +442,7 @@ describe("CloudDurableTestRunner", () => {
         expect(OperationWithData).toHaveBeenCalledWith(
           mockWaitManager,
           mockIndexedOperations,
+          expect.any(Object),
           mockOperation
         );
         expect(result).toBe(mockOperationWithData);
@@ -459,6 +463,7 @@ describe("CloudDurableTestRunner", () => {
         expect(OperationWithData).toHaveBeenCalledWith(
           mockWaitManager,
           mockIndexedOperations,
+          expect.any(Object),
           mockOperation
         );
         expect(result).toBe(mockOperationWithData);

packages/aws-durable-execution-sdk-js-testing/src/test-runner/cloud/cloud-durable-test-runner.ts

@@ -17,6 +17,10 @@ import {
 import { OperationWaitManager } from "../local/operations/operation-wait-manager";
 import { ResultFormatter } from "../local/result-formatter";
 import { historyEventsToOperationEvents } from "./utils/process-history-events/process-history-events";
+import {
+  createDurableApiClient,
+  DurableApiClient,
+} from "../common/create-durable-api-client";
 
 export interface CloudDurableTestRunnerParameters {
   functionName: string;
@@ -31,17 +35,21 @@ export class CloudDurableTestRunner<ResultType>
   private readonly formatter = new ResultFormatter<ResultType>();
   private readonly waitManager = new OperationWaitManager();
   private readonly indexedOperations = new IndexedOperations([]);
-  private readonly operationStorage = new OperationStorage(
-    this.waitManager,
-    this.indexedOperations
-  );
+  private readonly operationStorage: OperationStorage;
+  private readonly durableApiClient: DurableApiClient;
   private history: GetDurableExecutionHistoryResponse | undefined;
 
   constructor({
     functionName: functionArn,
     config,
   }: CloudDurableTestRunnerParameters) {
     this.client = new LambdaClient(config ?? {});
+    this.durableApiClient = createDurableApiClient(() => this.client);
+    this.operationStorage = new OperationStorage(
+      this.waitManager,
+      this.indexedOperations,
+      this.durableApiClient
+    );
     this.functionArn = functionArn;
   }
 
@@ -99,6 +107,7 @@ export class CloudDurableTestRunner<ResultType>
     return new OperationWithData(
       this.waitManager,
       this.indexedOperations,
+      this.durableApiClient,
       this.indexedOperations.getByIndex(index)
     );
   }
@@ -109,13 +118,15 @@ export class CloudDurableTestRunner<ResultType>
     return new OperationWithData(
       this.waitManager,
       this.indexedOperations,
+      this.durableApiClient,
       this.indexedOperations.getByNameAndIndex(name, index)
     );
   }
   getOperationById<T>(id: string): OperationWithData<T> {
     return new OperationWithData(
       this.waitManager,
       this.indexedOperations,
+      this.durableApiClient,
       this.indexedOperations.getById(id)
     );
   }

packages/aws-durable-execution-sdk-js-testing/src/test-runner/common/__tests__/create-durable-api-client.test.ts

@@ -0,0 +1,81 @@
+import {
+  LambdaClient,
+  SendDurableExecutionCallbackFailureCommand,
+  SendDurableExecutionCallbackHeartbeatCommand,
+  SendDurableExecutionCallbackSuccessCommand,
+} from "@aws-sdk/client-lambda";
+import { createDurableApiClient } from "../create-durable-api-client";
+
+describe("create-durable-api-client", () => {
+  const client = {
+    send: jest.fn(),
+  } as unknown as LambdaClient;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should create client with expected properties", () => {
+    expect(createDurableApiClient(() => client)).toEqual({
+      sendCallbackSuccess: expect.any(Function),
+      sendCallbackFailure: expect.any(Function),
+      sendCallbackHeartbeat: expect.any(Function),
+    });
+  });
+
+  it("should call correct API for sendCallbackSuccess", async () => {
+    const apiClient = createDurableApiClient(() => client);
+    await apiClient.sendCallbackSuccess({
+      CallbackId: "CallbackId",
+    });
+
+    expect(client.send).toHaveBeenCalledWith(
+      expect.any(SendDurableExecutionCallbackSuccessCommand)
+    );
+    expect(client.send).toHaveBeenCalledWith(
+      expect.objectContaining({
+        input: {
+          CallbackId: "CallbackId",
+        },
+      })
+    );
+  });
+
+  it("should call correct API for sendCallbackFailure", async () => {
+    const apiClient = createDurableApiClient(() => client);
+
+    await apiClient.sendCallbackFailure({
+      CallbackId: "CallbackId",
+    });
+
+    expect(client.send).toHaveBeenCalledWith(
+      expect.any(SendDurableExecutionCallbackFailureCommand)
+    );
+    expect(client.send).toHaveBeenCalledWith(
+      expect.objectContaining({
+        input: {
+          CallbackId: "CallbackId",
+        },
+      })
+    );
+  });
+
+  it("should call correct API for sendCallbackHeartbeat", async () => {
+    const apiClient = createDurableApiClient(() => client);
+
+    await apiClient.sendCallbackHeartbeat({
+      CallbackId: "CallbackId",
+    });
+
+    expect(client.send).toHaveBeenCalledWith(
+      expect.any(SendDurableExecutionCallbackHeartbeatCommand)
+    );
+    expect(client.send).toHaveBeenCalledWith(
+      expect.objectContaining({
+        input: {
+          CallbackId: "CallbackId",
+        },
+      })
+    );
+  });
+});