Initial commit

Author: kenfdev

.gitignore

@@ -0,0 +1 @@
+node_modules/

README.md

@@ -0,0 +1,2 @@
+# stepfunctions-testing
+

dist/index.d.ts

@@ -0,0 +1,8 @@
+export { MockedResponse } from './response';
+export { StateMachineTestDefinition } from './state-machine-test-definition';
+export { StateMachineTestCase } from './state-machine-test-case';
+export { StepFunctionsMockConfig } from './step-functions-mock-config';
+export interface JsonSerializable {
+    toJson: () => any;
+}
+export declare const isObjectEmpty: (obj: any) => any;

dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObjectEmpty = exports.StepFunctionsMockConfig = exports.StateMachineTestCase = exports.StateMachineTestDefinition = exports.MockedResponse = void 0;
+var response_1 = require("./response");
+Object.defineProperty(exports, "MockedResponse", { enumerable: true, get: function () { return response_1.MockedResponse; } });
+var state_machine_test_definition_1 = require("./state-machine-test-definition");
+Object.defineProperty(exports, "StateMachineTestDefinition", { enumerable: true, get: function () { return state_machine_test_definition_1.StateMachineTestDefinition; } });
+var state_machine_test_case_1 = require("./state-machine-test-case");
+Object.defineProperty(exports, "StateMachineTestCase", { enumerable: true, get: function () { return state_machine_test_case_1.StateMachineTestCase; } });
+var step_functions_mock_config_1 = require("./step-functions-mock-config");
+Object.defineProperty(exports, "StepFunctionsMockConfig", { enumerable: true, get: function () { return step_functions_mock_config_1.StepFunctionsMockConfig; } });
+const isObjectEmpty = (obj) => {
+    return (obj &&
+        Object.keys(obj).length === 0 &&
+        Object.getPrototypeOf(obj) === Object.prototype);
+};
+exports.isObjectEmpty = isObjectEmpty;

dist/response.d.ts

@@ -0,0 +1,14 @@
+import { JsonSerializable } from '.';
+export declare class MockedResponse implements JsonSerializable {
+    private responses;
+    private _name;
+    get name(): string;
+    constructor(name: string);
+    return<T = any>(response: T, repeat?: number): this;
+    throw(error: string, cause: string, repeat?: number): this;
+    toJson(): {
+        [x: string]: {
+            [index: string]: any;
+        };
+    };
+}

dist/response.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockedResponse = void 0;
+const statements_1 = require("./statements");
+class MockedResponseCollection {
+    collection = [];
+    add(statement, repeat) {
+        this.collection = [...this.collection, { repeat, statement }];
+    }
+    isEmpty() {
+        return this.collection.length === 0;
+    }
+    toJson() {
+        let result = {};
+        let currentResponseIndex = 0;
+        for (let i = 0; i < this.collection.length; i++) {
+            const item = this.collection[i];
+            let indexStr = currentResponseIndex.toString();
+            if (item.repeat > 0) {
+                currentResponseIndex = currentResponseIndex + item.repeat;
+                indexStr = `${indexStr}-${currentResponseIndex}`;
+            }
+            result[indexStr] = item.statement.toJson();
+            currentResponseIndex++;
+        }
+        return result;
+    }
+}
+class MockedResponse {
+    responses = new MockedResponseCollection();
+    _name;
+    get name() {
+        return this._name;
+    }
+    constructor(name) {
+        this._name = name;
+    }
+    return(response, repeat = 0) {
+        this.responses.add(new statements_1.ReturnStatement(response), repeat);
+        return this;
+    }
+    throw(error, cause, repeat = 0) {
+        this.responses.add(new statements_1.ThrowStatement(error, cause), repeat);
+        return this;
+    }
+    toJson() {
+        if (this.responses.isEmpty()) {
+            throw new Error('At least 1 return or throw response is required.');
+        }
+        return {
+            [this._name]: this.responses.toJson(),
+        };
+    }
+}
+exports.MockedResponse = MockedResponse;

dist/state-machine-test-case.d.ts

@@ -0,0 +1,18 @@
+import { JsonSerializable } from '.';
+import { MockedResponse } from './response';
+export declare class StateMachineTestCase<StateName extends string = string> implements JsonSerializable {
+    private mockedStates;
+    private _testCaseName;
+    get name(): string;
+    private _input;
+    get input(): any;
+    constructor(testCaseName: string);
+    withInput(input: any): this;
+    addMockedState(stateName: StateName, response: MockedResponse): this;
+    collectMockedResponses(): MockedResponse[];
+    toJson(): {
+        [x: string]: {
+            [key: string]: any;
+        };
+    };
+}

dist/state-machine-test-case.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateMachineTestCase = void 0;
+const _1 = require(".");
+class StateMachineTestCase {
+    mockedStates = {};
+    _testCaseName;
+    get name() {
+        return this._testCaseName;
+    }
+    _input;
+    get input() {
+        return this._input;
+    }
+    constructor(testCaseName) {
+        this._testCaseName = testCaseName;
+    }
+    withInput(input) {
+        this._input = input;
+        return this;
+    }
+    addMockedState(stateName, response) {
+        if (this.mockedStates.hasOwnProperty(stateName)) {
+            throw new Error(`The State ${stateName} is already defined`);
+        }
+        this.mockedStates[stateName] = response;
+        return this;
+    }
+    collectMockedResponses() {
+        return Object.keys(this.mockedStates).map((key) => this.mockedStates[key]); // TODO: better way to Type?
+    }
+    toJson() {
+        if ((0, _1.isObjectEmpty)(this.mockedStates)) {
+            throw new Error('At least 1 state needs to be defined');
+        }
+        const serializedMockedStates = Object.keys(this.mockedStates).reduce((acc, key) => {
+            acc[key] = this.mockedStates[key].name;
+            return acc;
+        }, {});
+        return {
+            [this._testCaseName]: serializedMockedStates,
+        };
+    }
+}
+exports.StateMachineTestCase = StateMachineTestCase;

dist/state-machine-test-definition.d.ts

@@ -0,0 +1,24 @@
+import { JsonSerializable } from '.';
+import { MockedResponse } from './response';
+import { StateMachineTestCase } from './state-machine-test-case';
+declare type TestCaseDefinitions = {
+    [key: string]: StateMachineTestCase;
+};
+export declare class StateMachineTestDefinition implements JsonSerializable {
+    private _testCaseDefinitions;
+    get testCaseDefinitions(): TestCaseDefinitions;
+    private _stateMachineName;
+    get stateMachineName(): string;
+    constructor(stateMachineName: string);
+    addTestCase(testCase: StateMachineTestCase): this;
+    collectTestCase(): StateMachineTestCase[];
+    collectMockedResponses(): MockedResponse[];
+    toJson(): {
+        [x: string]: {
+            TestCases: {
+                [key: string]: any;
+            };
+        };
+    };
+}
+export {};

dist/state-machine-test-definition.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateMachineTestDefinition = void 0;
+const _1 = require(".");
+class StateMachineTestDefinition {
+    _testCaseDefinitions = {};
+    get testCaseDefinitions() {
+        return this._testCaseDefinitions;
+    }
+    _stateMachineName;
+    get stateMachineName() {
+        return this._stateMachineName;
+    }
+    constructor(stateMachineName) {
+        this._stateMachineName = stateMachineName;
+    }
+    addTestCase(testCase) {
+        if (this._testCaseDefinitions.hasOwnProperty(testCase.name)) {
+            throw new Error(`TestCase ${testCase.name} is already defined`);
+        }
+        this._testCaseDefinitions[testCase.name] = testCase;
+        return this;
+    }
+    collectTestCase() {
+        return Object.values(this._testCaseDefinitions);
+    }
+    collectMockedResponses() {
+        return Object.keys(this._testCaseDefinitions).reduce((acc, key) => {
+            return acc.concat(this._testCaseDefinitions[key].collectMockedResponses());
+        }, []);
+    }
+    toJson() {
+        if ((0, _1.isObjectEmpty)(this._testCaseDefinitions)) {
+            throw new Error('At least 1 test case needs to be defined');
+        }
+        const serializedTestCaseDefinitions = Object.keys(this._testCaseDefinitions).reduce((acc, key) => {
+            return { ...acc, ...this._testCaseDefinitions[key].toJson() };
+        }, {});
+        return {
+            [this._stateMachineName]: {
+                TestCases: serializedTestCaseDefinitions,
+            },
+        };
+    }
+}
+exports.StateMachineTestDefinition = StateMachineTestDefinition;