Merge pull request #51 from antmendoza/support-creation-function-object

Support the creation of function object

Author: tsurdilo

spec/applicantrequest.json

@@ -7,7 +7,8 @@
   "functions": [
     {
       "name": "sendRejectionEmailFunction",
-      "operation": "http://myapis.org/applicationapi.json#emailRejection"
+      "operation": "http://myapis.org/applicationapi.json#emailRejection",
+      "type": "rest"
     }
   ],
   "states":[
@@ -51,4 +52,4 @@
       "end": true
     }
   ]
-}
+}

spec/function-builder.spec.ts

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2021-Present The Serverless Workflow Specification Authors
+ * <p>
+ * 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
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * 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 {FunctionBuilder} from '../src';
+
+
+describe("FunctionBuilder", () => {
+	
+	
+	it("should throws an error if mandatory fields are not set ", () => {
+		
+		expect(() => new FunctionBuilder().build()).toThrowError();
+		
+		expect(() => new FunctionBuilder()
+			.withName("")
+			.withOperation("")
+			.build())
+			.toThrowError();
+		
+		expect(() => new FunctionBuilder()
+			.withOperation("http://myapis.org/applicationapi.json#emailRejection")
+			.build())
+			.toThrowError();
+		
+		expect(() => new FunctionBuilder()
+			.withName("functionName")
+			.build())
+			.toThrowError();
+	});
+	
+	
+	it("should generate a populated object with default type value", () => {
+		expect(new FunctionBuilder()
+			.withName("functionName")
+			.withOperation("http://myapis.org/applicationapi.json#emailRejection")
+			.build()).toEqual(
+			{
+				name: "functionName",
+				operation: "http://myapis.org/applicationapi.json#emailRejection",
+				type: "rest",
+			},
+		);
+		
+	});
+	
+	it("should generate a populated object with default type value", () => {
+		expect(new FunctionBuilder()
+			.withName("functionName")
+			.withOperation("file#serviceName#method")
+			.withType("rpc")
+			.build()).toEqual(
+			{
+				name: "functionName",
+				operation: "file#serviceName#method",
+				type: "rpc",
+			},
+		);
+		
+	});
+	
+});
+
+

spec/workflow.builder.spec.ts

@@ -111,10 +111,9 @@ describe("workflow builder", () => {
 
 		const workflowValidator = new WorkflowValidator({});
 		spyOn(workflowValidator, 'isValid')
-			.and.returnValue(false).and.callThrough();
+			.and.returnValue(false);
 		spyOn(workflowValidator, 'validate')
-			.and.returnValue(new ValidationErrors([new ValidationError("any error")]))
-			.and.callThrough();
+			.and.returnValue(new ValidationErrors([new ValidationError("any error")]));
 
 		const validatorFactory = new ValidatorFactory();
 		spyOn(validatorFactory, 'workflowValidator')

src/model/function.builder.ts

@@ -14,24 +14,48 @@
  * limitations under the License.
  *
  */
-import {FunctionType} from "./types";
+import {Function, FunctionType} from "./types";
 
 export class FunctionBuilder {
-    // @ts-ignore
-    private model: FunctionType = {};
-
-    withName(value: string): FunctionBuilder {
-        this.model.name = value;
-        return this;
-    }
-
-    withOperation(value: string): FunctionBuilder {
-        this.model.operation = value;
-        return this;
-    }
-
-    build() {
-        //TODO validate
-        return this.model;
-    }
+	
+	// @ts-ignore
+	private model: Function = {
+		type: "rest",
+	};
+	
+	withName(value: string): FunctionBuilder {
+		this.model.name = value;
+		return this;
+	}
+	
+	withOperation(value: string): FunctionBuilder {
+		this.model.operation = value;
+		return this;
+	}
+	
+	withType(value: FunctionType): any {
+		this.model.type = value;
+		return this;
+	}
+	
+	build(): Function {
+		
+		
+		const errors: string[] = [];
+		
+		if (!this.model.name) {
+			errors.push("Field name can not be undefined or empty");
+		}
+		
+		if (!this.model.operation) {
+			errors.push("Field operation can not be undefined or empty");
+		}
+		
+		if (errors.length > 0) {
+			throw new Error(errors.map(e => e).join("; "));
+		}
+		
+		return this.model;
+	}
+	
 }

src/model/types.ts

@@ -109,7 +109,8 @@ export type ActionType = {
 export type ActionsType = ActionType[];
 
 
-export type FunctionType = {
+export type FunctionType = "rest" | "rpc" | "expression";
+export type Function = {
 	/**
 	 * Unique function name
 	 */
@@ -121,13 +122,13 @@ export type FunctionType = {
 	/**
 	 * Defines the function type. Is either `rest`, `rpc` or `expression`. Default is `rest`
 	 */
-	type?: "rest" | "rpc" | "expression";
+	type?: FunctionType;
 };
 
 export type FunctionsDef = | string
 	| [
-	FunctionType,
-	...FunctionType[]
+	Function,
+	...Function[]
 ];
 export type StatesType = [
 	(