Unmarshal state.end when boolean

model/util.go

@@ -85,6 +85,7 @@ func requiresNotNilOrEmpty(value interface{}) string {
 	return value.(string)
 }
 
+// TODO: check the places that use unmarshalString if the case changes for primitiveOrStruct.
 func unmarshalString(data []byte) (string, error) {
 	var value string
 	if err := json.Unmarshal(data, &value); err != nil {
@@ -93,6 +94,15 @@ func unmarshalString(data []byte) (string, error) {
 	return value, nil
 }
 
+func primitiveOrStruct[T any, U any](data []byte) (valStruct *U, valPrimitive T, err error) {
+	if data[0] == '{' {
+		err = json.Unmarshal(data, &valStruct)
+	} else {
+		err = json.Unmarshal(data, &valPrimitive)
+	}
+	return
+}
+
 func unmarshalKey(key string, data map[string]json.RawMessage, output interface{}) error {
 	if _, found := data[key]; found {
 		if err := json.Unmarshal(data[key], output); err != nil {

model/util_test.go

@@ -15,6 +15,7 @@
 package model
 
 import (
+	"encoding/json"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -33,3 +34,48 @@ func TestIncludePaths(t *testing.T) {
 		SetIncludePaths([]string{"1"})
 	}))
 }
+
+func Test_primitiveOrMapType(t *testing.T) {
+	type dataMap map[string]json.RawMessage
+	data := []byte(`"value":true`)
+	_, _, err := primitiveOrStruct[bool, dataMap](data)
+	assert.Error(t, err)
+
+	data = []byte(`{value":true}`)
+	_, _, err = primitiveOrStruct[bool, dataMap](data)
+	assert.Error(t, err)
+
+	data = []byte(`value":true}`)
+	_, _, err = primitiveOrStruct[bool, dataMap](data)
+	assert.Error(t, err)
+
+	data = []byte(`"true"`)
+	_, _, err = primitiveOrStruct[bool, dataMap](data)
+	assert.Error(t, err)
+
+	data = []byte(`true`)
+	valMap, valBool, err := primitiveOrStruct[bool, dataMap](data)
+	assert.NoError(t, err)
+	assert.Nil(t, valMap)
+	assert.True(t, valBool)
+
+	data = []byte(`"true"`)
+	valMap, valString, err := primitiveOrStruct[string, dataMap](data)
+	assert.NoError(t, err)
+	assert.Nil(t, valMap)
+	assert.Equal(t, `true`, valString)
+
+	data = []byte(`{"value":true}`)
+	valMap, valBool, err = primitiveOrStruct[bool, dataMap](data)
+	assert.NoError(t, err)
+	assert.NotNil(t, valMap)
+	assert.Equal(t, valMap, &dataMap{"value": []byte("true")})
+	assert.False(t, valBool)
+
+	data = []byte(`{"value": "true"}`)
+	valMap, valBool, err = primitiveOrStruct[bool, dataMap](data)
+	assert.NoError(t, err)
+	assert.NotNil(t, valMap)
+	assert.Equal(t, valMap, &dataMap{"value": []byte(`"true"`)})
+	assert.False(t, valBool)
+}

model/workflow.go

@@ -508,25 +508,17 @@ type End struct {
 
 // UnmarshalJSON ...
 func (e *End) UnmarshalJSON(data []byte) error {
-
-	endMap := make(map[string]json.RawMessage)
-	if err := json.Unmarshal(data, &endMap); err != nil {
-		e.Terminate = false
-		e.Compensate = false
-		return nil
-	}
-
-	if err := unmarshalKey("compensate", endMap, &e.Compensate); err != nil {
-		return err
-	}
-	if err := unmarshalKey("terminate", endMap, &e.Terminate); err != nil {
-		return err
-	}
-	if err := unmarshalKey("produceEvents", endMap, &e.ProduceEvents); err != nil {
+	type endUnmarshal End
+	end, endBool, err := primitiveOrStruct[bool, endUnmarshal](data)
+	if err != nil {
 		return err
 	}
-	if err := unmarshalKey("continueAs", endMap, &e.ContinueAs); err != nil {
-		return err
+
+	if end == nil {
+		e.Terminate = endBool
+		e.Compensate = false
+	} else {
+		*e = End(*end)
 	}
 
 	return nil

model/workflow_test.go

@@ -148,3 +148,57 @@ func TestContinueAsUnmarshalJSON(t *testing.T) {
 		})
 	}
 }
+
+func TestEndUnmarshalJSON(t *testing.T) {
+	type testCase struct {
+		desp   string
+		data   string
+		expect End
+		err    string
+	}
+	testCases := []testCase{
+		{
+			desp: "bool success",
+			data: `true`,
+			expect: End{
+				Terminate: true,
+			},
+			err: ``,
+		},
+		{
+			desp:   "string fail",
+			data:   `"true"`,
+			expect: End{},
+			err:    `json: cannot unmarshal string into Go value of type bool`,
+		},
+		{
+			desp: `object success`,
+			data: `{"terminate": true}`,
+			expect: End{
+				Terminate: true,
+			},
+			err: ``,
+		},
+		{
+			desp:   `object key invalid`,
+			data:   `{"terminate_parameter_invalid": true}`,
+			expect: End{},
+			err:    ``,
+		},
+	}
+	for _, tc := range testCases {
+		t.Run(tc.desp, func(t *testing.T) {
+			var v End
+			err := json.Unmarshal([]byte(tc.data), &v)
+
+			if tc.err != "" {
+				assert.Error(t, err)
+				assert.Regexp(t, tc.err, err)
+				return
+			}
+
+			assert.NoError(t, err)
+			assert.Equal(t, tc.expect, v)
+		})
+	}
+}

parser/parser_test.go

@@ -73,6 +73,8 @@ func TestFromFile(t *testing.T) {
 				assert.Equal(t, "greeting", w.ID)
 				assert.IsType(t, &model.OperationState{}, w.States[0].OperationState)
 				assert.Equal(t, "greetingFunction", w.States[0].OperationState.Actions[0].FunctionRef.RefName)
+				assert.NotNil(t, w.States[0].End)
+				assert.True(t, w.States[0].End.Terminate)
 			},
 		}, {
 			"./testdata/workflows/actiondata-defaultvalue.yaml",
@@ -82,6 +84,8 @@ func TestFromFile(t *testing.T) {
 				assert.NotNil(t, w.States[0].OperationState)
 				assert.Equal(t, true, w.States[0].OperationState.Actions[0].ActionDataFilter.UseResults)
 				assert.Equal(t, "greeting", w.States[0].OperationState.Actions[0].Name)
+				assert.NotNil(t, w.States[0].End)
+				assert.True(t, w.States[0].End.Terminate)
 			},
 		}, {
 			"./testdata/workflows/greetings.sw.yaml",
@@ -93,6 +97,7 @@ func TestFromFile(t *testing.T) {
 				assert.NotEmpty(t, w.States[0].OperationState.Actions)
 				assert.NotNil(t, w.States[0].OperationState.Actions[0].FunctionRef)
 				assert.Equal(t, "greetingFunction", w.States[0].OperationState.Actions[0].FunctionRef.RefName)
+				assert.True(t, w.States[0].End.Terminate)
 			},
 		}, {
 			"./testdata/workflows/eventbaseddataandswitch.sw.json",
@@ -105,11 +110,16 @@ func TestFromFile(t *testing.T) {
 				assert.NotNil(t, w.States[1])
 				assert.NotNil(t, w.States[1].SwitchState)
 				assert.Equal(t, "PT1H", w.States[1].SwitchState.Timeouts.EventTimeout)
+				assert.Nil(t, w.States[1].End)
+				assert.NotNil(t, w.States[2].End)
+				assert.True(t, w.States[2].End.Terminate)
 			},
 		}, {
 			"./testdata/workflows/conditionbasedstate.yaml", func(t *testing.T, w *model.Workflow) {
 				operationState := w.States[0].OperationState
 				assert.Equal(t, "${ .applicants | .age < 18 }", operationState.Actions[0].Condition)
+				assert.NotNil(t, w.States[0].End)
+				assert.True(t, w.States[0].End.Terminate)
 			},
 		}, {
 			"./testdata/workflows/eventbasedgreeting.sw.json", func(t *testing.T, w *model.Workflow) {
@@ -121,6 +131,8 @@ func TestFromFile(t *testing.T) {
 				assert.NotEmpty(t, eventState.OnEvents)
 				assert.Equal(t, "GreetingEvent", eventState.OnEvents[0].EventRefs[0])
 				assert.Equal(t, true, eventState.Exclusive)
+				assert.NotNil(t, w.States[0].End)
+				assert.True(t, w.States[0].End.Terminate)
 			},
 		}, {
 			"./testdata/workflows/eventbasedgreetingexclusive.sw.json", func(t *testing.T, w *model.Workflow) {
@@ -277,7 +289,9 @@ func TestFromFile(t *testing.T) {
 				assert.Equal(t, "0 0/15 * * * ?", w.Start.Schedule.Cron.Expression)
 				assert.Equal(t, "checkInboxFunction", w.States[0].OperationState.Actions[0].FunctionRef.RefName)
 				assert.Equal(t, "SendTextForHighPriority", w.States[0].Transition.NextState)
-				assert.False(t, w.States[1].End.Terminate)
+				assert.Nil(t, w.States[0].End)
+				assert.NotNil(t, w.States[1].End)
+				assert.True(t, w.States[1].End.Terminate)
 			},
 		}, {
 			"./testdata/workflows/applicationrequest-issue16.sw.yaml", func(t *testing.T, w *model.Workflow) {
@@ -553,7 +567,6 @@ func TestFromFile(t *testing.T) {
 			file.name, func(t *testing.T) {
 				workflow, err := FromFile(file.name)
 				if assert.NoError(t, err, "Test File %s", file.name) {
-
 					assert.NotNil(t, workflow, "Test File %s", file.name)
 					file.f(t, workflow)
 				}
@@ -623,17 +636,24 @@ states:
       "data": {
 		"result": "Hello World!"
 	  },
-	  "end": true
-    }
+	  "transition": "Next Hello State"
+    },
+	{
+		"name": "Next Hello State",
+		"type": "inject",
+		"data": {
+		  "result": "Next Hello World!"
+		},
+		"end": true
+	  }
   ]
 }
 `))
 		assert.Nil(t, err)
 		assert.NotNil(t, workflow.Auth)
 
-		// TODO correctly marshall end: true (fixed by https://github.com/serverlessworkflow/sdk-go/pull/147)
 		b, _ := json.Marshal(workflow)
-		assert.Equal(t, "{\"id\":\"applicantrequest\",\"name\":\"Applicant Request Decision Workflow\",\"description\":\"Determine if applicant request is valid\",\"version\":\"1.0\",\"start\":{\"stateName\":\"CheckApplication\"},\"specVersion\":\"0.8\",\"expressionLang\":\"jq\",\"auth\":[{\"name\":\"testAuth\",\"scheme\":\"bearer\",\"properties\":{\"token\":\"test_token\"}},{\"name\":\"testAuth2\",\"scheme\":\"basic\",\"properties\":{\"username\":\"test_user\",\"password\":\"test_pwd\"}}],\"states\":[{\"name\":\"Hello State\",\"type\":\"inject\",\"end\":{},\"data\":{\"result\":\"Hello World!\"}}]}",
+		assert.Equal(t, "{\"id\":\"applicantrequest\",\"name\":\"Applicant Request Decision Workflow\",\"description\":\"Determine if applicant request is valid\",\"version\":\"1.0\",\"start\":{\"stateName\":\"CheckApplication\"},\"specVersion\":\"0.8\",\"expressionLang\":\"jq\",\"auth\":[{\"name\":\"testAuth\",\"scheme\":\"bearer\",\"properties\":{\"token\":\"test_token\"}},{\"name\":\"testAuth2\",\"scheme\":\"basic\",\"properties\":{\"username\":\"test_user\",\"password\":\"test_pwd\"}}],\"states\":[{\"name\":\"Hello State\",\"type\":\"inject\",\"transition\":{\"nextState\":\"Next Hello State\"},\"data\":{\"result\":\"Hello World!\"}},{\"name\":\"Next Hello State\",\"type\":\"inject\",\"end\":{\"terminate\":true},\"data\":{\"result\":\"Next Hello World!\"}}]}",
 			string(b))
 
 	})
@@ -664,7 +684,7 @@ states:
 		assert.NotNil(t, workflow.Auth)
 
 		b, _ := json.Marshal(workflow)
-		assert.Equal(t, "{\"id\":\"applicantrequest\",\"name\":\"Applicant Request Decision Workflow\",\"description\":\"Determine if applicant request is valid\",\"version\":\"1.0\",\"start\":{\"stateName\":\"CheckApplication\"},\"specVersion\":\"0.8\",\"expressionLang\":\"jq\",\"auth\":[{\"name\":\"testAuth\",\"scheme\":\"bearer\",\"properties\":{\"token\":\"test_token\"}},{\"name\":\"testAuth2\",\"scheme\":\"basic\",\"properties\":{\"username\":\"test_user\",\"password\":\"test_pwd\"}}],\"states\":[{\"name\":\"Hello State\",\"type\":\"inject\",\"end\":{},\"data\":{\"result\":\"Hello World!\"}}]}",
+		assert.Equal(t, "{\"id\":\"applicantrequest\",\"name\":\"Applicant Request Decision Workflow\",\"description\":\"Determine if applicant request is valid\",\"version\":\"1.0\",\"start\":{\"stateName\":\"CheckApplication\"},\"specVersion\":\"0.8\",\"expressionLang\":\"jq\",\"auth\":[{\"name\":\"testAuth\",\"scheme\":\"bearer\",\"properties\":{\"token\":\"test_token\"}},{\"name\":\"testAuth2\",\"scheme\":\"basic\",\"properties\":{\"username\":\"test_user\",\"password\":\"test_pwd\"}}],\"states\":[{\"name\":\"Hello State\",\"type\":\"inject\",\"end\":{\"terminate\":true},\"data\":{\"result\":\"Hello World!\"}}]}",
 			string(b))
 
 	})