@justworkflowit/cdk-constructs 0.0.189 → 0.0.190

package/dist/__tests__/workflowEngine.test.js

@@ -199,4 +199,141 @@ describe('Workflow Engine Integration Tests', () => {
         expect(stateAfterStep1.executionHistory[0].stepName).toBe(step1Name);
         expect(stateAfterStep1.executionHistory[0]?.output?.status).toBe('success');
     });
+    test('should reject invalid workflow definition with malformed JSON', () => {
+        const invalidJson = '{ "workflowName": "invalid", "steps": [';
+        expect(() => {
+            new engine_1.JustWorkflowItEngine({
+                workflowDefinition: invalidJson,
+                stepExecutors,
+            });
+        }).toThrow();
+    });
+    test('should reject workflow definition with missing required fields', () => {
+        const workflowMissingSteps = {
+            workflowName: 'missingSteps',
+            // steps field is missing
+        };
+        expect(() => {
+            new engine_1.JustWorkflowItEngine({
+                workflowDefinition: JSON.stringify(workflowMissingSteps),
+                stepExecutors,
+            });
+        }).toThrow();
+    });
+    test('should reject workflow definition with invalid step structure', () => {
+        const workflowWithInvalidStep = {
+            workflowName: 'invalidStep',
+            steps: [
+                {
+                    // Missing required 'name' field
+                    retries: 2,
+                    timeoutSeconds: 1000,
+                    transitionToStep: null,
+                    integrationDetails: {
+                        type: simpleIntegration,
+                    },
+                },
+            ],
+            definitions: {},
+        };
+        expect(() => {
+            new engine_1.JustWorkflowItEngine({
+                workflowDefinition: JSON.stringify(workflowWithInvalidStep),
+                stepExecutors,
+            });
+        }).toThrow();
+    });
+    test('should reject workflow definition with non-existent step executor type', () => {
+        const workflowWithBadExecutorType = {
+            workflowName: 'badExecutorType',
+            steps: [
+                {
+                    name: 'testStep',
+                    retries: 2,
+                    timeoutSeconds: 1000,
+                    transitionToStep: null,
+                    integrationDetails: {
+                        type: 'nonExistentExecutorType',
+                        inputDefinition: {
+                            $ref: '#/definitions/testInput',
+                        },
+                        outputDefinition: {
+                            $ref: '#/definitions/testOutput',
+                        },
+                    },
+                },
+            ],
+            definitions: {
+                testInput: {
+                    type: 'object',
+                    properties: {},
+                    additionalProperties: false,
+                },
+                testOutput: {
+                    type: 'object',
+                    properties: {},
+                    additionalProperties: false,
+                },
+            },
+        };
+        expect(() => {
+            new engine_1.JustWorkflowItEngine({
+                workflowDefinition: JSON.stringify(workflowWithBadExecutorType),
+                stepExecutors,
+            });
+        }).toThrow();
+    });
+    test('should reject workflow definition with invalid reference in input transformer', () => {
+        const workflowWithInvalidTransformer = {
+            workflowName: 'invalidTransformer',
+            steps: [
+                {
+                    name: 'testStep',
+                    retries: 2,
+                    timeoutSeconds: 1000,
+                    transitionToStep: null,
+                    integrationDetails: {
+                        type: simpleIntegration,
+                        inputDefinition: {
+                            $ref: '#/definitions/testInput',
+                        },
+                        outputDefinition: {
+                            $ref: '#/definitions/testOutput',
+                        },
+                        inputTransformer: {
+                            fieldset: [
+                                {
+                                    from: 'nonExistentStep.someProperty',
+                                    to: 'outputProperty',
+                                },
+                            ],
+                        },
+                    },
+                },
+            ],
+            definitions: {
+                testInput: {
+                    type: 'object',
+                    properties: {
+                        outputProperty: {
+                            type: 'string',
+                        },
+                    },
+                    required: ['outputProperty'],
+                    additionalProperties: false,
+                },
+                testOutput: {
+                    type: 'object',
+                    properties: {},
+                    additionalProperties: false,
+                },
+            },
+        };
+        expect(() => {
+            new engine_1.JustWorkflowItEngine({
+                workflowDefinition: JSON.stringify(workflowWithInvalidTransformer),
+                stepExecutors,
+            });
+        }).toThrow();
+    });
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@justworkflowit/cdk-constructs",
   "description": "",
-  "version": "0.0.189",
+  "version": "0.0.190",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "publishConfig": {