IWF-472: Fix all the panic and enable test coverage

.github/workflows/ci-all-tests.yml

@@ -23,4 +23,6 @@ jobs:
         if: always()
         uses: jwalton/gh-docker-logs@v2
       - name: Upload coverage reports to Codecov
-        uses: codecov/codecov-action@v3
+        uses: codecov/codecov-action@v5
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

Makefile

@@ -189,9 +189,7 @@ ci-temporal-integ-test-disable-sticky:
 	$Q go test -v ./integ -run "(?i)^Test[${startsWith}]" -cover -coverprofile coverage.out -coverpkg ./service/... -search=false -cadence=false -dependencyWaitSeconds=60 -disableStickyCache
 
 ci-all-tests:
- 	# Fails CI when used with -coverprofile flag due to tests that panic; see https://go.dev/doc/build-cover#panicprof
- 	# $Q go test -v ./... -timeout 15m -cover -coverprofile coverage.out -coverpkg ./service/...
-	$Q go test -v ./... -timeout 15m
+	$Q go test -v ./... -timeout 15m -cover -coverprofile coverage.out -coverpkg ./service/...
 
 integTestsNoSearch:
 	$Q go test -v ./integ -search=false -timeout 15m

integ/any_command_close_test.go

@@ -55,7 +55,7 @@ func TestAnyCommandCloseWorkflowCadenceContinueAsNew(t *testing.T) {
 func doTestAnyCommandCloseWorkflow(t *testing.T, backendType service.BackendType, config *iwfidl.WorkflowConfig) {
 	// start test workflow server
 	wfHandler := anycommandclose.NewHandler()
-	closeFunc1 := startWorkflowWorker(wfHandler)
+	closeFunc1 := startWorkflowWorker(wfHandler, t)
 	defer closeFunc1()
 
 	closeFunc2 := startIwfService(backendType)
@@ -81,7 +81,7 @@ func doTestAnyCommandCloseWorkflow(t *testing.T, backendType service.BackendType
 			WorkflowConfigOverride: config,
 		},
 	}).Execute()
-	panicAtHttpError(err, httpResp)
+	failTestAtHttpError(err, httpResp, t)
 
 	signalValue := iwfidl.EncodedObject{
 		Encoding: iwfidl.PtrString("json"),
@@ -94,14 +94,14 @@ func doTestAnyCommandCloseWorkflow(t *testing.T, backendType service.BackendType
 		SignalChannelName: anycommandclose.SignalName2,
 		SignalValue:       &signalValue,
 	}).Execute()
-	panicAtHttpError(err, httpResp)
+	failTestAtHttpError(err, httpResp, t)
 
 	// wait for the workflow
 	reqWait := apiClient.DefaultApi.ApiV1WorkflowGetWithWaitPost(context.Background())
 	_, httpResp, err = reqWait.WorkflowGetRequest(iwfidl.WorkflowGetRequest{
 		WorkflowId: wfId,
 	}).Execute()
-	panicAtHttpError(err, httpResp)
+	failTestAtHttpError(err, httpResp, t)
 
 	history, data := wfHandler.GetTestResult()
 	assertions := assert.New(t)

integ/any_command_combination_test.go

@@ -3,6 +3,7 @@ package integ
 import (
 	"context"
 	"encoding/json"
+	"github.com/indeedeng/iwf/integ/helpers"
 	"github.com/indeedeng/iwf/service/common/ptr"
 	"strconv"
 	"testing"
@@ -59,7 +60,7 @@ func doTestAnyCommandCombinationWorkflow(t *testing.T, backendType service.Backe
 	assertions := assert.New(t)
 	// start test workflow server
 	wfHandler := anycommandconbination.NewHandler()
-	closeFunc1 := startWorkflowWorker(wfHandler)
+	closeFunc1 := startWorkflowWorker(wfHandler, t)
 	defer closeFunc1()
 
 	closeFunc2 := startIwfService(backendType)
@@ -85,7 +86,7 @@ func doTestAnyCommandCombinationWorkflow(t *testing.T, backendType service.Backe
 			WorkflowConfigOverride: config,
 		},
 	}).Execute()
-	panicAtHttpError(err, httpResp)
+	failTestAtHttpError(err, httpResp, t)
 
 	signalValue := iwfidl.EncodedObject{
 		Encoding: iwfidl.PtrString("json"),
@@ -99,13 +100,13 @@ func doTestAnyCommandCombinationWorkflow(t *testing.T, backendType service.Backe
 		SignalChannelName: anycommandconbination.SignalNameAndId1,
 		SignalValue:       &signalValue,
 	}).Execute()
-	panicAtHttpError(err, httpResp)
+	failTestAtHttpError(err, httpResp, t)
 	httpResp, err = req2.WorkflowSignalRequest(iwfidl.WorkflowSignalRequest{
 		WorkflowId:        wfId,
 		SignalChannelName: anycommandconbination.SignalNameAndId1,
 		SignalValue:       &signalValue,
 	}).Execute()
-	panicAtHttpError(err, httpResp)
+	failTestAtHttpError(err, httpResp, t)
 
 	// skip the timer for S1
 	time.Sleep(time.Second * 5) // wait for a few seconds so that timer is ready to be skipped
@@ -115,7 +116,7 @@ func doTestAnyCommandCombinationWorkflow(t *testing.T, backendType service.Backe
 		WorkflowStateExecutionId: "S1-1",
 		TimerCommandId:           iwfidl.PtrString(anycommandconbination.TimerId1),
 	}).Execute()
-	panicAtHttpError(err, httpResp)
+	failTestAtHttpError(err, httpResp, t)
 
 	// now it should be running at S2
 	// Future: we can check it is already done S1
@@ -126,46 +127,46 @@ func doTestAnyCommandCombinationWorkflow(t *testing.T, backendType service.Backe
 		SignalChannelName: anycommandconbination.SignalNameAndId1,
 		SignalValue:       &signalValue,
 	}).Execute()
-	panicAtHttpError(err, httpResp)
+	failTestAtHttpError(err, httpResp, t)
 
 	// wait and check the workflow, it should be still running
 	time.Sleep(time.Second)
 	reqDesc := apiClient.DefaultApi.ApiV1WorkflowGetPost(context.Background())
 	descResp, httpResp, err := reqDesc.WorkflowGetRequest(iwfidl.WorkflowGetRequest{
 		WorkflowId: wfId,
 	}).Execute()
-	panicAtHttpError(err, httpResp)
+	failTestAtHttpError(err, httpResp, t)
 	assertions.Equal(iwfidl.RUNNING, descResp.GetWorkflowStatus())
 
 	httpResp, err = req2.WorkflowSignalRequest(iwfidl.WorkflowSignalRequest{
 		WorkflowId:        wfId,
 		SignalChannelName: anycommandconbination.SignalNameAndId3,
 		SignalValue:       &signalValue,
 	}).Execute()
-	panicAtHttpError(err, httpResp)
+	failTestAtHttpError(err, httpResp, t)
 
 	// send 2nd signal for s2
 	httpResp, err = req2.WorkflowSignalRequest(iwfidl.WorkflowSignalRequest{
 		WorkflowId:        wfId,
 		SignalChannelName: anycommandconbination.SignalNameAndId2,
 		SignalValue:       &signalValue,
 	}).Execute()
-	panicAtHttpError(err, httpResp)
+	failTestAtHttpError(err, httpResp, t)
 
 	// workflow should be completed now
 	if config == nil {
 		time.Sleep(time.Second)
 		descResp, httpResp, err = reqDesc.WorkflowGetRequest(iwfidl.WorkflowGetRequest{
 			WorkflowId: wfId,
 		}).Execute()
-		panicAtHttpError(err, httpResp)
+		failTestAtHttpError(err, httpResp, t)
 		assertions.Equal(iwfidl.COMPLETED, descResp.GetWorkflowStatus())
 	} else {
 		reqWait := apiClient.DefaultApi.ApiV1WorkflowGetWithWaitPost(context.Background())
 		respWait, httpResp, err := reqWait.WorkflowGetRequest(iwfidl.WorkflowGetRequest{
 			WorkflowId: wfId,
 		}).Execute()
-		panicAtHttpErrorOrWorkflowUncompleted(err, httpResp, respWait)
+		failTestAtHttpErrorOrWorkflowUncompleted(err, httpResp, respWait, t)
 	}
 
 	history, data := wfHandler.GetTestResult()
@@ -189,7 +190,7 @@ func doTestAnyCommandCombinationWorkflow(t *testing.T, backendType service.Backe
 		"\"stateStartApiSucceeded\":true}"
 	err = json.Unmarshal([]byte(s1ResultJsonStr), &s1CommandResults)
 	if err != nil {
-		panic(err)
+		helpers.FailTestWithError(err, t)
 	}
 	s2ResultsJsonStr := "{\"signalResults\":[" +
 		"{\"commandId\":\"test-signal-name1\",\"signalChannelName\":\"test-signal-name1\",\"signalRequestStatus\":\"RECEIVED\",\"signalValue\":{\"data\":\"test-data-1\",\"encoding\":\"json\"}}, " +
@@ -201,7 +202,7 @@ func doTestAnyCommandCombinationWorkflow(t *testing.T, backendType service.Backe
 		"\"stateStartApiSucceeded\":true}"
 	err = json.Unmarshal([]byte(s2ResultsJsonStr), &s2CommandResults)
 	if err != nil {
-		panic(err)
+		helpers.FailTestWithError(err, t)
 	}
 	expectedData := map[string]interface{}{
 		"s1_commandResults": s1CommandResults,

integ/any_timer_signal_test.go

@@ -55,7 +55,7 @@ func TestAnyTimerSignalWorkflowCadenceContinueAsNew(t *testing.T) {
 func doTestAnyTimerSignalWorkflow(t *testing.T, backendType service.BackendType, config *iwfidl.WorkflowConfig) {
 	// start test workflow server
 	wfHandler := anytimersignal.NewHandler()
-	closeFunc1 := startWorkflowWorker(wfHandler)
+	closeFunc1 := startWorkflowWorker(wfHandler, t)
 	defer closeFunc1()
 
 	closeFunc2 := startIwfService(backendType)
@@ -83,7 +83,7 @@ func doTestAnyTimerSignalWorkflow(t *testing.T, backendType service.BackendType,
 			WorkflowConfigOverride: config,
 		},
 	}).Execute()
-	panicAtHttpError(err, httpResp)
+	failTestAtHttpError(err, httpResp, t)
 
 	// wait for 3 secs and send the signal
 	time.Sleep(time.Second * 3)
@@ -97,14 +97,14 @@ func doTestAnyTimerSignalWorkflow(t *testing.T, backendType service.BackendType,
 		SignalChannelName: anytimersignal.SignalName,
 		SignalValue:       &signalValue,
 	}).Execute()
-	panicAtHttpError(err, httpResp)
+	failTestAtHttpError(err, httpResp, t)
 
 	// wait for the workflow
 	reqWait := apiClient.DefaultApi.ApiV1WorkflowGetWithWaitPost(context.Background())
 	_, httpResp, err = reqWait.WorkflowGetRequest(iwfidl.WorkflowGetRequest{
 		WorkflowId: wfId,
 	}).Execute()
-	panicAtHttpError(err, httpResp)
+	failTestAtHttpError(err, httpResp, t)
 
 	history, data := wfHandler.GetTestResult()
 	assertions := assert.New(t)

integ/basic_test.go

@@ -47,7 +47,7 @@ func TestBasicWorkflowCadence(t *testing.T) {
 func doTestBasicWorkflow(t *testing.T, backendType service.BackendType, config *iwfidl.WorkflowConfig) {
 	// start test workflow server
 	wfHandler := basic.NewHandler()
-	closeFunc1 := startWorkflowWorker(wfHandler)
+	closeFunc1 := startWorkflowWorker(wfHandler, t)
 	defer closeFunc1()
 
 	_, closeFunc2 := startIwfServiceByConfig(IwfServiceTestConfig{
@@ -107,7 +107,7 @@ func doTestBasicWorkflow(t *testing.T, backendType service.BackendType, config *
 		},
 	}
 	_, httpResp, err := req.WorkflowStartRequest(startReq).Execute()
-	panicAtHttpError(err, httpResp)
+	failTestAtHttpError(err, httpResp, t)
 
 	// start it again should return already started error
 	_, _, err = req.WorkflowStartRequest(startReq).Execute()
@@ -126,7 +126,7 @@ func doTestBasicWorkflow(t *testing.T, backendType service.BackendType, config *
 	resp2, httpResp, err := req2.WorkflowGetRequest(iwfidl.WorkflowGetRequest{
 		WorkflowId: wfId,
 	}).Execute()
-	panicAtHttpError(err, httpResp)
+	failTestAtHttpError(err, httpResp, t)
 
 	// use a wrong workflowId to test the error case
 	_, _, err = req2.WorkflowGetRequest(iwfidl.WorkflowGetRequest{

integ/conditional_close_test.go

@@ -66,7 +66,7 @@ func doTestConditionalForceCompleteOnChannelEmptyWorkflow(
 	assertions := assert.New(t)
 	// start test workflow server
 	wfHandler := conditionalClose.NewHandler()
-	closeFunc1 := startWorkflowWorkerWithRpc(wfHandler)
+	closeFunc1 := startWorkflowWorkerWithRpc(wfHandler, t)
 	defer closeFunc1()
 
 	_, closeFunc2 := startIwfServiceWithClient(backendType)
@@ -105,7 +105,7 @@ func doTestConditionalForceCompleteOnChannelEmptyWorkflow(
 	}
 
 	_, httpResp, err := req.WorkflowStartRequest(startReq).Execute()
-	panicAtHttpError(err, httpResp)
+	failTestAtHttpError(err, httpResp, t)
 
 	// wait for a second so that query handler is ready for executing PRC
 	time.Sleep(time.Second)
@@ -126,7 +126,7 @@ func doTestConditionalForceCompleteOnChannelEmptyWorkflow(
 			}).Execute()
 		}
 
-		panicAtHttpError(err, httpResp)
+		failTestAtHttpError(err, httpResp, t)
 		if i == 0 {
 			// wait for a second so that the workflow is in execute state
 			time.Sleep(time.Second)
@@ -138,7 +138,7 @@ func doTestConditionalForceCompleteOnChannelEmptyWorkflow(
 	resp2, httpResp, err := req2.WorkflowGetRequest(iwfidl.WorkflowGetRequest{
 		WorkflowId: wfId,
 	}).Execute()
-	panicAtHttpError(err, httpResp)
+	failTestAtHttpError(err, httpResp, t)
 
 	history, _ := wfHandler.GetTestResult()
 

integ/create_test.go

@@ -3,6 +3,7 @@ package integ
 import (
 	"context"
 	"github.com/indeedeng/iwf/gen/iwfidl"
+	"github.com/indeedeng/iwf/integ/helpers"
 	"github.com/indeedeng/iwf/integ/workflow/rpc"
 	"github.com/indeedeng/iwf/service"
 	"github.com/stretchr/testify/assert"
@@ -55,7 +56,7 @@ func doTestCreateWithoutStartingState(t *testing.T, backendType service.BackendT
 	assertions := assert.New(t)
 	// start test workflow server
 	wfHandler := rpc.NewHandler()
-	closeFunc1 := startWorkflowWorkerWithRpc(wfHandler)
+	closeFunc1 := startWorkflowWorkerWithRpc(wfHandler, t)
 	defer closeFunc1()
 
 	uclient, closeFunc2 := startIwfServiceWithClient(backendType)
@@ -82,13 +83,13 @@ func doTestCreateWithoutStartingState(t *testing.T, backendType service.BackendT
 			WorkflowConfigOverride: config,
 		},
 	}).Execute()
-	panicAtHttpError(err, httpResp)
+	failTestAtHttpError(err, httpResp, t)
 
 	// workflow shouldn't executed any state
 	var dump service.DebugDumpResponse
 	err = uclient.QueryWorkflow(context.Background(), &dump, wfId, "", service.DebugDumpQueryType)
 	if err != nil {
-		panic(err)
+		helpers.FailTestWithError(err, t)
 	}
 	assertions.Equal(service.StateExecutionCounterInfo{
 		StateIdStartedCount:            make(map[string]int),
@@ -110,14 +111,14 @@ func doTestCreateWithoutStartingState(t *testing.T, backendType service.BackendT
 		},
 		TimeoutSeconds: iwfidl.PtrInt32(2),
 	}).Execute()
-	panicAtHttpError(err, httpResp)
+	failTestAtHttpError(err, httpResp, t)
 
 	// wait for the workflow
 	reqWait := apiClient.DefaultApi.ApiV1WorkflowGetWithWaitPost(context.Background())
 	respWait, httpResp, err := reqWait.WorkflowGetRequest(iwfidl.WorkflowGetRequest{
 		WorkflowId: wfId,
 	}).Execute()
-	panicAtHttpErrorOrWorkflowUncompleted(err, httpResp, respWait)
+	failTestAtHttpErrorOrWorkflowUncompleted(err, httpResp, respWait, t)
 
 	history, _ := wfHandler.GetTestResult()
 	assertions.Equalf(map[string]int64{

integ/deadend_test.go

@@ -55,7 +55,7 @@ func doTestDeadEndWorkflow(t *testing.T, backendType service.BackendType, config
 	assertions := assert.New(t)
 	// start test workflow server
 	wfHandler := deadend.NewHandler()
-	closeFunc1 := startWorkflowWorkerWithRpc(wfHandler)
+	closeFunc1 := startWorkflowWorkerWithRpc(wfHandler, t)
 	defer closeFunc1()
 
 	_, closeFunc2 := startIwfServiceWithClient(backendType)
@@ -82,7 +82,7 @@ func doTestDeadEndWorkflow(t *testing.T, backendType service.BackendType, config
 			WorkflowConfigOverride: config,
 		},
 	}).Execute()
-	panicAtHttpError(err, httpResp)
+	failTestAtHttpError(err, httpResp, t)
 
 	reqRpc := apiClient.DefaultApi.ApiV1WorkflowRpcPost(context.Background())
 
@@ -93,15 +93,15 @@ func doTestDeadEndWorkflow(t *testing.T, backendType service.BackendType, config
 			WorkflowId: wfId,
 			RpcName:    deadend.RPCWriteData,
 		}).Execute()
-		panicAtHttpError(err, httpResp)
+		failTestAtHttpError(err, httpResp, t)
 	}
 
 	if config != nil {
 		reqDesc := apiClient.DefaultApi.ApiV1WorkflowGetPost(context.Background())
 		descResp, httpResp, err := reqDesc.WorkflowGetRequest(iwfidl.WorkflowGetRequest{
 			WorkflowId: wfId,
 		}).Execute()
-		panicAtHttpError(err, httpResp)
+		failTestAtHttpError(err, httpResp, t)
 		assertions.True(startResp.GetWorkflowRunId() != descResp.GetWorkflowRunId())
 	}
 
@@ -112,7 +112,7 @@ func doTestDeadEndWorkflow(t *testing.T, backendType service.BackendType, config
 			WorkflowId: wfId,
 			RpcName:    deadend.RPCTriggerState,
 		}).Execute()
-		panicAtHttpError(err, httpResp)
+		failTestAtHttpError(err, httpResp, t)
 	}
 
 	time.Sleep(time.Second * 2)
@@ -121,7 +121,7 @@ func doTestDeadEndWorkflow(t *testing.T, backendType service.BackendType, config
 	httpResp, err = reqCancel.WorkflowStopRequest(iwfidl.WorkflowStopRequest{
 		WorkflowId: wfId,
 	}).Execute()
-	panicAtHttpError(err, httpResp)
+	failTestAtHttpError(err, httpResp, t)
 
 	history, _ := wfHandler.GetTestResult()
 	assertions.Equalf(map[string]int64{

integ/get_with_wait_timeout_test.go

@@ -39,7 +39,7 @@ func doTestWorkflowWithWaitTimeout(t *testing.T, backendType service.BackendType
 
 	// start test workflow server
 	wfHandler := signal.NewHandler()
-	closeFunc1 := startWorkflowWorker(wfHandler)
+	closeFunc1 := startWorkflowWorker(wfHandler, t)
 	defer closeFunc1()
 
 	closeFunc2 := startIwfService(backendType)
@@ -65,7 +65,7 @@ func doTestWorkflowWithWaitTimeout(t *testing.T, backendType service.BackendType
 			WorkflowConfigOverride: config,
 		},
 	}).Execute()
-	panicAtHttpError(err, httpResp)
+	failTestAtHttpError(err, httpResp, t)
 
 	// wait for the workflow
 	reqWait := apiClient.DefaultApi.ApiV1WorkflowGetWithWaitPost(context.Background())