Add waiting loop until execution completes and some refactoring

Author: Jordi Macià

typescript-test-samples/step-functions-local/README.md

@@ -27,7 +27,6 @@ current applications.
   - [Key Files in the Project](#key-files-in-the-project)
 - [Sample project description](#sample-project-description)
 - [Unit Test](#unit-test)
-- [Integration Test](#integration-test)
 
 ---
 

typescript-test-samples/step-functions-local/metadata.json

@@ -5,7 +5,6 @@
   "language": "TypeScript",
   "type": ["Unit"],
   "diagram": "/images/stepfunctions_local_test.png",
-  "framework": "SAM",
   "services": ["sfn"],
   "git_repo_url": "https://github.com/aws-samples/serverless-test-samples",
   "pattern_source": "AWS",

typescript-test-samples/step-functions-local/src/tests/sfnLocal/step-functions-local.test.ts

@@ -16,7 +16,8 @@ import {
     StartExecutionCommandOutput, 
     CreateStateMachineCommand, 
     CreateStateMachineCommandOutput, 
-    GetExecutionHistoryCommand, 
+    GetExecutionHistoryCommand,
+    GetExecutionHistoryCommandOutput, 
     HistoryEvent 
 } from "@aws-sdk/client-sfn";
 import { StepFunctionsConstants } from './step-functions-constants';
@@ -37,40 +38,10 @@ describe('lead-generation', () => {
 
         let container: StartedTestContainer;
         let sfnClient: SFNClient;
-        let createStateMachineResponse: CreateStateMachineCommandOutput;
         let stateMachineArn: string;
 
         beforeAll(async () => {
-
-            // Launch StepFunctionLocal with testcontainers
-            container = await new GenericContainer('amazon/aws-stepfunctions-local')
-                .withExposedPorts(8083)
-                .withCopyFilesToContainer([{ 
-                    source: StepFunctionsConstants.mockFileHostPath, 
-                    target: StepFunctionsConstants.mockFileContainerPath
-                  }])
-                .withEnvironment({ SFN_MOCK_CONFIG: StepFunctionsConstants.mockFileContainerPath })
-                .withDefaultLogDriver()
-                .withWaitStrategy(Wait.forLogMessage("Starting server on port 8083"))
-                .start();
-
-            // Set up Step Function client with test container URL
-            sfnClient = new SFNClient({ 
-                endpoint: `http://${container.getHost()}:${container.getMappedPort(8083)}`
-            });                
-
-            // Important to avoid non-deterministic behavior, waiting for container to spin up
-            await sleep(2);         
-
-            // Create state machine
-            createStateMachineResponse = await sfnClient.send(new CreateStateMachineCommand({
-                name: StepFunctionsConstants.STATE_MACHINE_NAME,
-                definition: StepFunctionsConstants.STATE_MACHINE_ASL,
-                roleArn: StepFunctionsConstants.DUMMY_ROLE
-            }));
-
-            stateMachineArn = createStateMachineResponse.stateMachineArn as string;
-
+            ({ container, sfnClient, stateMachineArn } = await setupStepFunctionsLocal());
         });
 
         afterAll(async () => {
@@ -91,48 +62,21 @@ describe('lead-generation', () => {
         });
 
         it('Test Happy Path Scenario', async () => {
-            const executionName: string = "happyPathExecution";
-            const executionResponse: StartExecutionCommandOutput = await sfnClient.send(new StartExecutionCommand({
-                name: executionName,
-                stateMachineArn: `${stateMachineArn}#HappyPathTest`,
-                input: StepFunctionsConstants.EVENT_JSON_STRING
-            }));
-            
-            expect(executionResponse.executionArn).not.toBeNull();
-            
-            // IMP: Wait until above execution completes in docker
-            await sleep(2);
-
-            const historyResponse = await sfnClient.send(new GetExecutionHistoryCommand({
-                executionArn: executionResponse.executionArn
-            }));
 
+            const historyResponse: GetExecutionHistoryCommandOutput = await manageExecution(sfnClient, stateMachineArn, "happyPathExecution", "HappyPathTest");
             expect(historyResponse).toBeDefined();
 
             const results = historyResponse.events?.filter((event) => {
                 return ((event.type == "TaskStateExited") && (event.stateExitedEventDetails?.name == "CustomerAddedToFollowup"))
             });
-
             expect(results?.length).toBe(1);
 
         });
 
         it('Test Negative Sentiment Scenario', async () => {
-            const executionName: string = "negativeSentimentExecution";
-            const executionResponse: StartExecutionCommandOutput = await sfnClient.send(new StartExecutionCommand({
-                name: executionName,
-                stateMachineArn: `${stateMachineArn}#NegativeSentimentTest`,
-                input: StepFunctionsConstants.EVENT_JSON_STRING
-            }));
-            
-            expect(executionResponse.executionArn).not.toBeNull();
-            
-            // IMP: Wait until above execution completes in docker
-            await sleep(2);
-
-            const historyResponse = await sfnClient.send(new GetExecutionHistoryCommand({
-                executionArn: executionResponse.executionArn
-            }));
+
+            const historyResponse: GetExecutionHistoryCommandOutput = await manageExecution(sfnClient, stateMachineArn, "negativeSentimentExecution", "NegativeSentimentTest");
+            expect(historyResponse).toBeDefined();
 
             const results = historyResponse.events?.filter((event) => {
                 return ((event.type == "TaskStateExited") && (event.stateExitedEventDetails?.name == "NegativeSentimentDetected"))
@@ -143,21 +87,9 @@ describe('lead-generation', () => {
         });
 
         it('Test Retry on Service Exception', async () => {
-            const executionName: string = "retryExecution";
-            const executionResponse: StartExecutionCommandOutput = await sfnClient.send(new StartExecutionCommand({
-                name: executionName,
-                stateMachineArn: `${stateMachineArn}#RetryOnServiceExceptionTest`,
-                input: StepFunctionsConstants.EVENT_JSON_STRING
-            }));
-            
-            expect(executionResponse.executionArn).not.toBeNull();
-            
-            // IMP: State Machine has retries with exponential backoff, therefore 4 seconds
-            await sleep(4);
-
-            const historyResponse = await sfnClient.send(new GetExecutionHistoryCommand({
-                executionArn: executionResponse.executionArn
-            }))
+
+            const historyResponse: GetExecutionHistoryCommandOutput = await manageExecution(sfnClient, stateMachineArn, "retryExecution", "RetryOnServiceExceptionTest");
+            expect(historyResponse).toBeDefined();
 
             const results: HistoryEvent[] | undefined = historyResponse.events?.filter((event) => {
                 return (
@@ -178,8 +110,86 @@ describe('lead-generation', () => {
     });
 });
 
-function sleep(seconds) {
+async function setupStepFunctionsLocal() {
+
+    // Launch StepFunctionLocal with testcontainers
+    const container: StartedTestContainer = await createTestContainer();       
+
+    // Set up Step Function client with test container URL
+    const sfnClient: SFNClient = new SFNClient({ 
+        endpoint: `http://${container.getHost()}:${container.getMappedPort(8083)}`
+    });                
+
+    // Create state machine
+    const createStateMachineResponse: CreateStateMachineCommandOutput = await sfnClient.send(new CreateStateMachineCommand({
+        name: StepFunctionsConstants.STATE_MACHINE_NAME,
+        definition: StepFunctionsConstants.STATE_MACHINE_ASL,
+        roleArn: StepFunctionsConstants.DUMMY_ROLE
+    }));
+
+    const stateMachineArn: string = createStateMachineResponse.stateMachineArn as string;
+
+    return { container, sfnClient, stateMachineArn }
+
+}
+
+async function createTestContainer(): Promise<StartedTestContainer> {
+
+    const container: StartedTestContainer = await new GenericContainer('amazon/aws-stepfunctions-local')
+    .withExposedPorts(8083)
+    .withCopyFilesToContainer([{ 
+        source: StepFunctionsConstants.mockFileHostPath, 
+        target: StepFunctionsConstants.mockFileContainerPath
+      }])
+    .withEnvironment({ SFN_MOCK_CONFIG: StepFunctionsConstants.mockFileContainerPath })
+    .withDefaultLogDriver()
+    .withWaitStrategy(Wait.forLogMessage("Starting server on port 8083"))
+    .start();
+
+    // Important to avoid non-deterministic behavior, waiting for container to spin up
+    await sleep(2000);
+
+    return container;
+
+}
+
+async function manageExecution(sfnClient: SFNClient, stateMachineArn: string, executionName: string, test: string): Promise<GetExecutionHistoryCommandOutput> {
+
+    const executionResponse = await sfnClient.send(new StartExecutionCommand({
+        name: executionName,
+        stateMachineArn: `${stateMachineArn}#${test}`,
+        input: StepFunctionsConstants.EVENT_JSON_STRING
+    }));
+
+    return await untilExecutionCompletes(sfnClient, executionResponse);
+}
+
+async function untilExecutionCompletes(sfnClient: SFNClient, executionResponse: StartExecutionCommandOutput): Promise<GetExecutionHistoryCommandOutput> {
+
+    let historyResponse: GetExecutionHistoryCommandOutput;
+
+    do {
+        // IMP: allow some time for the execution to complete in docker
+        await sleep(1000);
+
+        historyResponse = await sfnClient.send(new GetExecutionHistoryCommand({
+            executionArn: executionResponse.executionArn
+        }));
+
+    // cycle back if not yet completed
+    } while (!executionSucceeded(historyResponse));
+
+    return historyResponse;
+}
+
+function executionSucceeded(historyResponse: any): boolean {
+    const succeeded = historyResponse.events.filter(event => event.type == 'ExecutionSucceeded');
+    return succeeded.length == 1;
+}
+
+function sleep(milliseconds: number) {
     return new Promise((resolve) => {
-        setTimeout(() => { resolve('') }, seconds*1000)
+        setTimeout(() => { resolve('') }, milliseconds)
     })
-}
+}
+