Merge pull request #112 from antmendoza/add_validationError_class

validate method return proprietary class

Author: antmendoza

src/lib/validation-error.ts

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2021-Present The Serverless Workflow Specification Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * oUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import { DefinedError } from 'ajv';
+
+export class ValidationError {
+  readonly message: string;
+  
+  constructor(readonly error: DefinedError) {
+    this.message = `invalid: ${error.instancePath} | ${error.schemaPath} | ${error.message}`;
+  }
+}

src/lib/workflow-validator.ts

@@ -15,29 +15,27 @@
  *
  */
 
-import { DefinedError, ValidateFunction } from 'ajv';
+import { ValidateFunction, DefinedError } from 'ajv';
 import { Specification } from './definitions';
 import { validators } from './validators';
+import { ValidationError } from './validation-error';
 
 export class WorkflowValidator {
   /** The validation errors after running validate(), if any */
-  errors: DefinedError[] | never[] = [];
-  /** The validate function */
-  private validateFn: ValidateFunction<Specification.Workflow>;
+  readonly errors: ValidationError[] | never[] = [];
+
+  /** Whether the workflow is valid or not */
+  readonly isValid: boolean;
+
   /**
    * Creates a new WorkflowValidator for the provided workflow
    * @param {Workflow} workflow The workflow to validate
    */
   constructor(private workflow: Specification.Workflow) {
-    this.validateFn = validators.get('Workflow') as ValidateFunction<Specification.Workflow>;
-  }
-  /**
-   * Validates the workflow, populates the errors if any
-   * @returns {boolean} If the workflow is valid or not
-   */
-  validate(): boolean {
-    const isValid = this.validateFn(this.workflow);
-    this.errors = this.validateFn.errors as DefinedError[];
-    return isValid;
+    const validateFn = validators.get('Workflow') as ValidateFunction<Specification.Workflow>;
+    this.isValid = validateFn(this.workflow);
+    if (validateFn.errors) {
+      this.errors = validateFn.errors.map((error) => new ValidationError(error as DefinedError));
+    }
   }
 }

src/serverless-workflow-sdk.ts

@@ -15,6 +15,7 @@
  *
  */
 
+export * from './lib/validation-error';
 export * from './lib/workflow-converter';
 export * from './lib/workflow-validator';
 export * from './lib/validators';

tests/workflow-validator.spec.ts

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2021-Present The Serverless Workflow Specification Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+import { ValidationError, WorkflowValidator } from '../src/';
+import { Workflow } from '../src/lib/definitions/workflow';
+
+describe('workflow-validator', () => {
+  it('should return errors instance of ValidationError if the workflow provided is not valid', () => {
+    // @ts-ignore
+    const workflow = {
+      id: 'helloworld',
+      name: 'Hello World Workflow',
+      version: '1.0',
+      description: 'Inject Hello World',
+      start: 'Hello State',
+      states: [],
+    } as Workflow;
+
+    const workflowValidator = new WorkflowValidator(workflow);
+    expect(workflowValidator.isValid).toBeFalsy('Expected isValid to be false');
+    expect(workflowValidator.errors.length).toBe(1);
+    expect(workflowValidator.errors[0].constructor === ValidationError).toBeTruthy(
+      'Expected errors to be instance of ValidationError'
+    );
+    expect(workflowValidator.errors[0].message).toMatch("states");
+
+  });
+
+  it('should have no errors if the workflow is valid', () => {
+    const workflow = {
+      id: 'helloworld',
+      version: '1.0',
+      name: 'Hello World Workflow',
+      description: 'Inject Hello World',
+      start: 'Hello State',
+      states: [
+        {
+          name: 'Hello State',
+          type: 'inject',
+          data: {
+            result: 'Hello World!',
+          },
+          end: true,
+        },
+      ],
+    } as Workflow;
+
+    const workflowValidator = new WorkflowValidator(workflow);
+    expect(workflowValidator.errors.length).toBe(0);
+    expect(workflowValidator.isValid).toBeTruthy('Expected isValid to be true');
+  });
+});