From 1f120fd69dd28c4eb9ace83fee0e971ee28b92c2 Mon Sep 17 00:00:00 2001 From: agautam478 <72432016+agautam478@users.noreply.github.com> Date: Thu, 4 Apr 2024 14:42:44 -0700 Subject: [PATCH 1/6] Last methods for nosql_execution_Store.go covered (#5868) * Last methods for nosql_execution_Store.go covered * Minor update --- .../nosql/nosql_execution_store_test.go | 174 +++++++++++++++++- 1 file changed, 173 insertions(+), 1 deletion(-) diff --git a/common/persistence/nosql/nosql_execution_store_test.go b/common/persistence/nosql/nosql_execution_store_test.go index 0a87c7ed9c4..60e52035909 100644 --- a/common/persistence/nosql/nosql_execution_store_test.go +++ b/common/persistence/nosql/nosql_execution_store_test.go @@ -1052,7 +1052,6 @@ func TestNosqlExecutionStore(t *testing.T) { for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { ctrl := gomock.NewController(t) - defer ctrl.Finish() store := tc.setupMock(ctrl) err := tc.testFunc(store) @@ -1067,6 +1066,179 @@ func TestNosqlExecutionStore(t *testing.T) { } } +func TestDeleteReplicationTaskFromDLQ(t *testing.T) { + ctx := context.Background() + shardID := 1 + + tests := []struct { + name string + sourceCluster string + taskID int64 + setupMock func(*nosqlplugin.MockDB) + expectedError error + }{ + { + name: "success", + sourceCluster: "sourceCluster", + taskID: 1, + setupMock: func(mockDB *nosqlplugin.MockDB) { + mockDB.EXPECT(). + DeleteReplicationDLQTask(ctx, shardID, "sourceCluster", int64(1)). + Return(nil) + }, + expectedError: nil, + }, + { + name: "database error", + sourceCluster: "sourceCluster", + taskID: 1, + setupMock: func(mockDB *nosqlplugin.MockDB) { + mockDB.EXPECT().IsNotFoundError(gomock.Any()).Return(true).AnyTimes() + mockDB.EXPECT(). + DeleteReplicationDLQTask(ctx, shardID, "sourceCluster", int64(1)). + Return(errors.New("database error")) + }, + expectedError: &types.InternalServiceError{Message: "database error"}, + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + controller := gomock.NewController(t) + + mockDB := nosqlplugin.NewMockDB(controller) + store := newTestNosqlExecutionStore(mockDB, log.NewNoop()) + + tc.setupMock(mockDB) + + err := store.DeleteReplicationTaskFromDLQ(ctx, &persistence.DeleteReplicationTaskFromDLQRequest{ + SourceClusterName: tc.sourceCluster, + TaskID: tc.taskID, + }) + + if tc.expectedError != nil { + require.ErrorAs(t, err, &tc.expectedError) + } else { + require.NoError(t, err) + } + }) + } +} + +func TestRangeDeleteReplicationTaskFromDLQ(t *testing.T) { + ctx := context.Background() + shardID := 1 + + tests := []struct { + name string + sourceCluster string + exclusiveBeginID int64 + inclusiveEndID int64 + setupMock func(*nosqlplugin.MockDB) + expectedError error + }{ + { + name: "success", + sourceCluster: "sourceCluster", + exclusiveBeginID: 1, + inclusiveEndID: 100, + setupMock: func(mockDB *nosqlplugin.MockDB) { + mockDB.EXPECT(). + RangeDeleteReplicationDLQTasks(ctx, shardID, "sourceCluster", int64(1), int64(100)). + Return(nil) + }, + expectedError: nil, + }, + { + name: "database error", + sourceCluster: "sourceCluster", + exclusiveBeginID: 1, + inclusiveEndID: 100, + setupMock: func(mockDB *nosqlplugin.MockDB) { + mockDB.EXPECT().IsNotFoundError(gomock.Any()).Return(true).AnyTimes() + mockDB.EXPECT(). + RangeDeleteReplicationDLQTasks(ctx, shardID, "sourceCluster", int64(1), int64(100)). + Return(errors.New("database error")) + }, + expectedError: &types.InternalServiceError{Message: "database error"}, + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + controller := gomock.NewController(t) + + mockDB := nosqlplugin.NewMockDB(controller) + store := newTestNosqlExecutionStore(mockDB, log.NewNoop()) + + tc.setupMock(mockDB) + + _, err := store.RangeDeleteReplicationTaskFromDLQ(ctx, &persistence.RangeDeleteReplicationTaskFromDLQRequest{ + SourceClusterName: tc.sourceCluster, + ExclusiveBeginTaskID: tc.exclusiveBeginID, + InclusiveEndTaskID: tc.inclusiveEndID, + }) + + if tc.expectedError != nil { + require.ErrorAs(t, err, &tc.expectedError) + } else { + require.NoError(t, err) + } + }) + } +} + +func TestCreateFailoverMarkerTasks(t *testing.T) { + ctx := context.Background() + shardID := 1 + + tests := []struct { + name string + rangeID int64 + markers []*persistence.FailoverMarkerTask + setupMock func(*nosqlplugin.MockDB) + expectedError error + }{ + { + name: "success", + rangeID: 123, + markers: []*persistence.FailoverMarkerTask{ + { + TaskData: persistence.TaskData{}, + DomainID: "testDomainID", + }, + }, + setupMock: func(mockDB *nosqlplugin.MockDB) { + mockDB.EXPECT(). + InsertReplicationTask(ctx, gomock.Any(), nosqlplugin.ShardCondition{ShardID: shardID, RangeID: 123}). + Return(nil) + }, + expectedError: nil, + }, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + controller := gomock.NewController(t) + + mockDB := nosqlplugin.NewMockDB(controller) + store := newTestNosqlExecutionStore(mockDB, log.NewNoop()) + + tc.setupMock(mockDB) + + err := store.CreateFailoverMarkerTasks(ctx, &persistence.CreateFailoverMarkersRequest{ + RangeID: tc.rangeID, + Markers: tc.markers, + }) + + if tc.expectedError != nil { + require.ErrorAs(t, err, &tc.expectedError) + } else { + require.NoError(t, err) + } + }) + } +} + func newCreateWorkflowExecutionRequest() *persistence.InternalCreateWorkflowExecutionRequest { return &persistence.InternalCreateWorkflowExecutionRequest{ RangeID: 123, From 64cc6d85b3d8ae7a1b91506daa2244a1eb015244 Mon Sep 17 00:00:00 2001 From: Ilya Ozherelyev Date: Fri, 5 Apr 2024 00:07:07 +0200 Subject: [PATCH 2/6] stop redirection for deprecated domains (#5863) * [frontend] Stop redirecting deprecated domains --- common/taskTokenSerializerInterfaces.go | 8 ++ .../templates/clusterredirection.tmpl | 46 ++---- .../clusterredirection/api_generated.go | 132 ++++++++---------- .../wrappers/clusterredirection/api_test.go | 6 - .../clusterredirection/callwrappers.go | 77 ++++++++++ .../wrappers/clusterredirection/policy.go | 6 + .../clusterredirection/policy_test.go | 103 +++++++++++++- 7 files changed, 258 insertions(+), 120 deletions(-) create mode 100644 service/frontend/wrappers/clusterredirection/callwrappers.go diff --git a/common/taskTokenSerializerInterfaces.go b/common/taskTokenSerializerInterfaces.go index 107a35b1646..6afeb67ae69 100644 --- a/common/taskTokenSerializerInterfaces.go +++ b/common/taskTokenSerializerInterfaces.go @@ -48,3 +48,11 @@ type ( TaskID string `json:"taskId"` } ) + +func (t TaskToken) GetDomainID() string { + return t.DomainID +} + +func (t QueryTaskToken) GetDomainID() string { + return t.DomainID +} diff --git a/service/frontend/templates/clusterredirection.tmpl b/service/frontend/templates/clusterredirection.tmpl index 91313c69b37..5adb51dd025 100644 --- a/service/frontend/templates/clusterredirection.tmpl +++ b/service/frontend/templates/clusterredirection.tmpl @@ -1,12 +1,10 @@ import ( "context" - "time" "go.uber.org/yarpc" "github.com/uber/cadence/common" "github.com/uber/cadence/common/config" - "github.com/uber/cadence/common/log" "github.com/uber/cadence/common/metrics" "github.com/uber/cadence/common/resource" "github.com/uber/cadence/common/types" @@ -65,20 +63,27 @@ func (handler *clusterRedirectionHandler) {{$method.Declaration}} { var apiName = "{{$method.Name}}" var cluster string + {{$policyMethod := "WithDomainNameRedirect"}} + {{$domain := printf "%s.GetDomain()" (index $method.Params 1).Name}} + {{- if has $method.Name $domainIDAPIs}} + token := domainIDGetter(noopdomainIDGetter{}) + {{- end}} scope, startTime := handler.beforeCall(metrics.DCRedirection{{$method.Name}}Scope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + {{- if has $method.Name $domainIDAPIs}} + handler.afterCall(recover(), scope, startTime, "", token.GetDomainID(), cluster, &err) + {{- else}} + handler.afterCall(recover(), scope, startTime, {{$domain}}, "", cluster, &err) + {{- end}} }() - {{$policyMethod := "WithDomainNameRedirect"}} - {{$domain := printf "%s.GetDomain()" (index $method.Params 1).Name}} {{if has $method.Name $domainIDAPIs}} {{$policyMethod = "WithDomainIDRedirect"}} - {{$domain = "token.DomainID"}} + {{$domain = "token.GetDomainID()"}} {{if has $method.Name $queryTaskTokenAPIs}} - token, err := handler.tokenSerializer.DeserializeQueryTaskToken({{(index $method.Params 1).Name}}.TaskToken) + token, err = handler.tokenSerializer.DeserializeQueryTaskToken({{(index $method.Params 1).Name}}.TaskToken) {{- else}} - token, err := handler.tokenSerializer.Deserialize({{(index $method.Params 1).Name}}.TaskToken) + token, err = handler.tokenSerializer.Deserialize({{(index $method.Params 1).Name}}.TaskToken) {{- end}} if err != nil { {{- if eq (len $method.Results) 1}} @@ -123,7 +128,7 @@ func (handler *clusterRedirectionHandler) QueryWorkflow( } scope, startTime := handler.beforeCall(metrics.DCRedirectionQueryWorkflowScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &retError) + handler.afterCall(recover(), scope, startTime, request.GetDomain(), "", cluster, &retError) }() err = handler.redirectionPolicy.WithDomainNameRedirect(ctx, request.GetDomain(), apiName, func(targetDC string) error { @@ -140,26 +145,3 @@ func (handler *clusterRedirectionHandler) QueryWorkflow( return resp, err } - -func (handler *clusterRedirectionHandler) beforeCall( - scope int, -) (metrics.Scope, time.Time) { - return handler.GetMetricsClient().Scope(scope), handler.GetTimeSource().Now() -} - -func (handler *clusterRedirectionHandler) afterCall( - recovered interface{}, - scope metrics.Scope, - startTime time.Time, - cluster string, - retError *error, -) { - log.CapturePanic(recovered, handler.GetLogger(), retError) - - scope = scope.Tagged(metrics.TargetClusterTag(cluster)) - scope.IncCounter(metrics.CadenceDcRedirectionClientRequests) - scope.RecordTimer(metrics.CadenceDcRedirectionClientLatency, handler.GetTimeSource().Now().Sub(startTime)) - if *retError != nil { - scope.IncCounter(metrics.CadenceDcRedirectionClientFailures) - } -} diff --git a/service/frontend/wrappers/clusterredirection/api_generated.go b/service/frontend/wrappers/clusterredirection/api_generated.go index 4c43e378d8a..68374a096d6 100644 --- a/service/frontend/wrappers/clusterredirection/api_generated.go +++ b/service/frontend/wrappers/clusterredirection/api_generated.go @@ -28,13 +28,11 @@ package clusterredirection import ( "context" - "time" "go.uber.org/yarpc" "github.com/uber/cadence/common" "github.com/uber/cadence/common/config" - "github.com/uber/cadence/common/log" "github.com/uber/cadence/common/metrics" "github.com/uber/cadence/common/resource" "github.com/uber/cadence/common/types" @@ -85,7 +83,7 @@ func (handler *clusterRedirectionHandler) CountWorkflowExecutions(ctx context.Co scope, startTime := handler.beforeCall(metrics.DCRedirectionCountWorkflowExecutionsScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, cp1.GetDomain(), "", cluster, &err) }() err = handler.redirectionPolicy.WithDomainNameRedirect(ctx, cp1.GetDomain(), apiName, func(targetDC string) error { @@ -117,7 +115,7 @@ func (handler *clusterRedirectionHandler) DescribeTaskList(ctx context.Context, scope, startTime := handler.beforeCall(metrics.DCRedirectionDescribeTaskListScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, dp1.GetDomain(), "", cluster, &err) }() err = handler.redirectionPolicy.WithDomainNameRedirect(ctx, dp1.GetDomain(), apiName, func(targetDC string) error { @@ -141,7 +139,7 @@ func (handler *clusterRedirectionHandler) DescribeWorkflowExecution(ctx context. scope, startTime := handler.beforeCall(metrics.DCRedirectionDescribeWorkflowExecutionScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, dp1.GetDomain(), "", cluster, &err) }() err = handler.redirectionPolicy.WithDomainNameRedirect(ctx, dp1.GetDomain(), apiName, func(targetDC string) error { @@ -173,7 +171,7 @@ func (handler *clusterRedirectionHandler) GetTaskListsByDomain(ctx context.Conte scope, startTime := handler.beforeCall(metrics.DCRedirectionGetTaskListsByDomainScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, gp1.GetDomain(), "", cluster, &err) }() err = handler.redirectionPolicy.WithDomainNameRedirect(ctx, gp1.GetDomain(), apiName, func(targetDC string) error { @@ -197,7 +195,7 @@ func (handler *clusterRedirectionHandler) GetWorkflowExecutionHistory(ctx contex scope, startTime := handler.beforeCall(metrics.DCRedirectionGetWorkflowExecutionHistoryScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, gp1.GetDomain(), "", cluster, &err) }() err = handler.redirectionPolicy.WithDomainNameRedirect(ctx, gp1.GetDomain(), apiName, func(targetDC string) error { @@ -225,7 +223,7 @@ func (handler *clusterRedirectionHandler) ListArchivedWorkflowExecutions(ctx con scope, startTime := handler.beforeCall(metrics.DCRedirectionListArchivedWorkflowExecutionsScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, lp1.GetDomain(), "", cluster, &err) }() err = handler.redirectionPolicy.WithDomainNameRedirect(ctx, lp1.GetDomain(), apiName, func(targetDC string) error { @@ -249,7 +247,7 @@ func (handler *clusterRedirectionHandler) ListClosedWorkflowExecutions(ctx conte scope, startTime := handler.beforeCall(metrics.DCRedirectionListClosedWorkflowExecutionsScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, lp1.GetDomain(), "", cluster, &err) }() err = handler.redirectionPolicy.WithDomainNameRedirect(ctx, lp1.GetDomain(), apiName, func(targetDC string) error { @@ -277,7 +275,7 @@ func (handler *clusterRedirectionHandler) ListOpenWorkflowExecutions(ctx context scope, startTime := handler.beforeCall(metrics.DCRedirectionListOpenWorkflowExecutionsScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, lp1.GetDomain(), "", cluster, &err) }() err = handler.redirectionPolicy.WithDomainNameRedirect(ctx, lp1.GetDomain(), apiName, func(targetDC string) error { @@ -301,7 +299,7 @@ func (handler *clusterRedirectionHandler) ListTaskListPartitions(ctx context.Con scope, startTime := handler.beforeCall(metrics.DCRedirectionListTaskListPartitionsScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, lp1.GetDomain(), "", cluster, &err) }() err = handler.redirectionPolicy.WithDomainNameRedirect(ctx, lp1.GetDomain(), apiName, func(targetDC string) error { @@ -325,7 +323,7 @@ func (handler *clusterRedirectionHandler) ListWorkflowExecutions(ctx context.Con scope, startTime := handler.beforeCall(metrics.DCRedirectionListWorkflowExecutionsScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, lp1.GetDomain(), "", cluster, &err) }() err = handler.redirectionPolicy.WithDomainNameRedirect(ctx, lp1.GetDomain(), apiName, func(targetDC string) error { @@ -349,7 +347,7 @@ func (handler *clusterRedirectionHandler) PollForActivityTask(ctx context.Contex scope, startTime := handler.beforeCall(metrics.DCRedirectionPollForActivityTaskScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, pp1.GetDomain(), "", cluster, &err) }() err = handler.redirectionPolicy.WithDomainNameRedirect(ctx, pp1.GetDomain(), apiName, func(targetDC string) error { @@ -373,7 +371,7 @@ func (handler *clusterRedirectionHandler) PollForDecisionTask(ctx context.Contex scope, startTime := handler.beforeCall(metrics.DCRedirectionPollForDecisionTaskScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, pp1.GetDomain(), "", cluster, &err) }() err = handler.redirectionPolicy.WithDomainNameRedirect(ctx, pp1.GetDomain(), apiName, func(targetDC string) error { @@ -395,17 +393,18 @@ func (handler *clusterRedirectionHandler) RecordActivityTaskHeartbeat(ctx contex var apiName = "RecordActivityTaskHeartbeat" var cluster string + token := domainIDGetter(noopdomainIDGetter{}) scope, startTime := handler.beforeCall(metrics.DCRedirectionRecordActivityTaskHeartbeatScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, "", token.GetDomainID(), cluster, &err) }() - token, err := handler.tokenSerializer.Deserialize(rp1.TaskToken) + token, err = handler.tokenSerializer.Deserialize(rp1.TaskToken) if err != nil { return nil, err } - err = handler.redirectionPolicy.WithDomainIDRedirect(ctx, token.DomainID, apiName, func(targetDC string) error { + err = handler.redirectionPolicy.WithDomainIDRedirect(ctx, token.GetDomainID(), apiName, func(targetDC string) error { cluster = targetDC switch { case targetDC == handler.currentClusterName: @@ -426,7 +425,7 @@ func (handler *clusterRedirectionHandler) RecordActivityTaskHeartbeatByID(ctx co scope, startTime := handler.beforeCall(metrics.DCRedirectionRecordActivityTaskHeartbeatByIDScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, rp1.GetDomain(), "", cluster, &err) }() err = handler.redirectionPolicy.WithDomainNameRedirect(ctx, rp1.GetDomain(), apiName, func(targetDC string) error { @@ -450,7 +449,7 @@ func (handler *clusterRedirectionHandler) RefreshWorkflowTasks(ctx context.Conte scope, startTime := handler.beforeCall(metrics.DCRedirectionRefreshWorkflowTasksScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, rp1.GetDomain(), "", cluster, &err) }() err = handler.redirectionPolicy.WithDomainNameRedirect(ctx, rp1.GetDomain(), apiName, func(targetDC string) error { @@ -478,7 +477,7 @@ func (handler *clusterRedirectionHandler) RequestCancelWorkflowExecution(ctx con scope, startTime := handler.beforeCall(metrics.DCRedirectionRequestCancelWorkflowExecutionScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, rp1.GetDomain(), "", cluster, &err) }() err = handler.redirectionPolicy.WithDomainNameRedirect(ctx, rp1.GetDomain(), apiName, func(targetDC string) error { @@ -502,7 +501,7 @@ func (handler *clusterRedirectionHandler) ResetStickyTaskList(ctx context.Contex scope, startTime := handler.beforeCall(metrics.DCRedirectionResetStickyTaskListScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, rp1.GetDomain(), "", cluster, &err) }() err = handler.redirectionPolicy.WithDomainNameRedirect(ctx, rp1.GetDomain(), apiName, func(targetDC string) error { @@ -526,7 +525,7 @@ func (handler *clusterRedirectionHandler) ResetWorkflowExecution(ctx context.Con scope, startTime := handler.beforeCall(metrics.DCRedirectionResetWorkflowExecutionScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, rp1.GetDomain(), "", cluster, &err) }() err = handler.redirectionPolicy.WithDomainNameRedirect(ctx, rp1.GetDomain(), apiName, func(targetDC string) error { @@ -548,17 +547,18 @@ func (handler *clusterRedirectionHandler) RespondActivityTaskCanceled(ctx contex var apiName = "RespondActivityTaskCanceled" var cluster string + token := domainIDGetter(noopdomainIDGetter{}) scope, startTime := handler.beforeCall(metrics.DCRedirectionRespondActivityTaskCanceledScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, "", token.GetDomainID(), cluster, &err) }() - token, err := handler.tokenSerializer.Deserialize(rp1.TaskToken) + token, err = handler.tokenSerializer.Deserialize(rp1.TaskToken) if err != nil { return err } - err = handler.redirectionPolicy.WithDomainIDRedirect(ctx, token.DomainID, apiName, func(targetDC string) error { + err = handler.redirectionPolicy.WithDomainIDRedirect(ctx, token.GetDomainID(), apiName, func(targetDC string) error { cluster = targetDC switch { case targetDC == handler.currentClusterName: @@ -579,7 +579,7 @@ func (handler *clusterRedirectionHandler) RespondActivityTaskCanceledByID(ctx co scope, startTime := handler.beforeCall(metrics.DCRedirectionRespondActivityTaskCanceledByIDScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, rp1.GetDomain(), "", cluster, &err) }() err = handler.redirectionPolicy.WithDomainNameRedirect(ctx, rp1.GetDomain(), apiName, func(targetDC string) error { @@ -601,17 +601,18 @@ func (handler *clusterRedirectionHandler) RespondActivityTaskCompleted(ctx conte var apiName = "RespondActivityTaskCompleted" var cluster string + token := domainIDGetter(noopdomainIDGetter{}) scope, startTime := handler.beforeCall(metrics.DCRedirectionRespondActivityTaskCompletedScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, "", token.GetDomainID(), cluster, &err) }() - token, err := handler.tokenSerializer.Deserialize(rp1.TaskToken) + token, err = handler.tokenSerializer.Deserialize(rp1.TaskToken) if err != nil { return err } - err = handler.redirectionPolicy.WithDomainIDRedirect(ctx, token.DomainID, apiName, func(targetDC string) error { + err = handler.redirectionPolicy.WithDomainIDRedirect(ctx, token.GetDomainID(), apiName, func(targetDC string) error { cluster = targetDC switch { case targetDC == handler.currentClusterName: @@ -632,7 +633,7 @@ func (handler *clusterRedirectionHandler) RespondActivityTaskCompletedByID(ctx c scope, startTime := handler.beforeCall(metrics.DCRedirectionRespondActivityTaskCompletedByIDScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, rp1.GetDomain(), "", cluster, &err) }() err = handler.redirectionPolicy.WithDomainNameRedirect(ctx, rp1.GetDomain(), apiName, func(targetDC string) error { @@ -654,17 +655,18 @@ func (handler *clusterRedirectionHandler) RespondActivityTaskFailed(ctx context. var apiName = "RespondActivityTaskFailed" var cluster string + token := domainIDGetter(noopdomainIDGetter{}) scope, startTime := handler.beforeCall(metrics.DCRedirectionRespondActivityTaskFailedScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, "", token.GetDomainID(), cluster, &err) }() - token, err := handler.tokenSerializer.Deserialize(rp1.TaskToken) + token, err = handler.tokenSerializer.Deserialize(rp1.TaskToken) if err != nil { return err } - err = handler.redirectionPolicy.WithDomainIDRedirect(ctx, token.DomainID, apiName, func(targetDC string) error { + err = handler.redirectionPolicy.WithDomainIDRedirect(ctx, token.GetDomainID(), apiName, func(targetDC string) error { cluster = targetDC switch { case targetDC == handler.currentClusterName: @@ -685,7 +687,7 @@ func (handler *clusterRedirectionHandler) RespondActivityTaskFailedByID(ctx cont scope, startTime := handler.beforeCall(metrics.DCRedirectionRespondActivityTaskFailedByIDScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, rp1.GetDomain(), "", cluster, &err) }() err = handler.redirectionPolicy.WithDomainNameRedirect(ctx, rp1.GetDomain(), apiName, func(targetDC string) error { @@ -707,17 +709,18 @@ func (handler *clusterRedirectionHandler) RespondDecisionTaskCompleted(ctx conte var apiName = "RespondDecisionTaskCompleted" var cluster string + token := domainIDGetter(noopdomainIDGetter{}) scope, startTime := handler.beforeCall(metrics.DCRedirectionRespondDecisionTaskCompletedScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, "", token.GetDomainID(), cluster, &err) }() - token, err := handler.tokenSerializer.Deserialize(rp1.TaskToken) + token, err = handler.tokenSerializer.Deserialize(rp1.TaskToken) if err != nil { return nil, err } - err = handler.redirectionPolicy.WithDomainIDRedirect(ctx, token.DomainID, apiName, func(targetDC string) error { + err = handler.redirectionPolicy.WithDomainIDRedirect(ctx, token.GetDomainID(), apiName, func(targetDC string) error { cluster = targetDC switch { case targetDC == handler.currentClusterName: @@ -736,17 +739,18 @@ func (handler *clusterRedirectionHandler) RespondDecisionTaskFailed(ctx context. var apiName = "RespondDecisionTaskFailed" var cluster string + token := domainIDGetter(noopdomainIDGetter{}) scope, startTime := handler.beforeCall(metrics.DCRedirectionRespondDecisionTaskFailedScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, "", token.GetDomainID(), cluster, &err) }() - token, err := handler.tokenSerializer.Deserialize(rp1.TaskToken) + token, err = handler.tokenSerializer.Deserialize(rp1.TaskToken) if err != nil { return err } - err = handler.redirectionPolicy.WithDomainIDRedirect(ctx, token.DomainID, apiName, func(targetDC string) error { + err = handler.redirectionPolicy.WithDomainIDRedirect(ctx, token.GetDomainID(), apiName, func(targetDC string) error { cluster = targetDC switch { case targetDC == handler.currentClusterName: @@ -765,17 +769,18 @@ func (handler *clusterRedirectionHandler) RespondQueryTaskCompleted(ctx context. var apiName = "RespondQueryTaskCompleted" var cluster string + token := domainIDGetter(noopdomainIDGetter{}) scope, startTime := handler.beforeCall(metrics.DCRedirectionRespondQueryTaskCompletedScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, "", token.GetDomainID(), cluster, &err) }() - token, err := handler.tokenSerializer.DeserializeQueryTaskToken(rp1.TaskToken) + token, err = handler.tokenSerializer.DeserializeQueryTaskToken(rp1.TaskToken) if err != nil { return err } - err = handler.redirectionPolicy.WithDomainIDRedirect(ctx, token.DomainID, apiName, func(targetDC string) error { + err = handler.redirectionPolicy.WithDomainIDRedirect(ctx, token.GetDomainID(), apiName, func(targetDC string) error { cluster = targetDC switch { case targetDC == handler.currentClusterName: @@ -796,7 +801,7 @@ func (handler *clusterRedirectionHandler) RestartWorkflowExecution(ctx context.C scope, startTime := handler.beforeCall(metrics.DCRedirectionRestartWorkflowExecutionScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, rp1.GetDomain(), "", cluster, &err) }() err = handler.redirectionPolicy.WithDomainNameRedirect(ctx, rp1.GetDomain(), apiName, func(targetDC string) error { @@ -820,7 +825,7 @@ func (handler *clusterRedirectionHandler) ScanWorkflowExecutions(ctx context.Con scope, startTime := handler.beforeCall(metrics.DCRedirectionScanWorkflowExecutionsScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, lp1.GetDomain(), "", cluster, &err) }() err = handler.redirectionPolicy.WithDomainNameRedirect(ctx, lp1.GetDomain(), apiName, func(targetDC string) error { @@ -844,7 +849,7 @@ func (handler *clusterRedirectionHandler) SignalWithStartWorkflowExecution(ctx c scope, startTime := handler.beforeCall(metrics.DCRedirectionSignalWithStartWorkflowExecutionScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, sp1.GetDomain(), "", cluster, &err) }() err = handler.redirectionPolicy.WithDomainNameRedirect(ctx, sp1.GetDomain(), apiName, func(targetDC string) error { @@ -868,7 +873,7 @@ func (handler *clusterRedirectionHandler) SignalWithStartWorkflowExecutionAsync( scope, startTime := handler.beforeCall(metrics.DCRedirectionSignalWithStartWorkflowExecutionAsyncScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, sp1.GetDomain(), "", cluster, &err) }() err = handler.redirectionPolicy.WithDomainNameRedirect(ctx, sp1.GetDomain(), apiName, func(targetDC string) error { @@ -892,7 +897,7 @@ func (handler *clusterRedirectionHandler) SignalWorkflowExecution(ctx context.Co scope, startTime := handler.beforeCall(metrics.DCRedirectionSignalWorkflowExecutionScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, sp1.GetDomain(), "", cluster, &err) }() err = handler.redirectionPolicy.WithDomainNameRedirect(ctx, sp1.GetDomain(), apiName, func(targetDC string) error { @@ -916,7 +921,7 @@ func (handler *clusterRedirectionHandler) StartWorkflowExecution(ctx context.Con scope, startTime := handler.beforeCall(metrics.DCRedirectionStartWorkflowExecutionScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, sp1.GetDomain(), "", cluster, &err) }() err = handler.redirectionPolicy.WithDomainNameRedirect(ctx, sp1.GetDomain(), apiName, func(targetDC string) error { @@ -940,7 +945,7 @@ func (handler *clusterRedirectionHandler) StartWorkflowExecutionAsync(ctx contex scope, startTime := handler.beforeCall(metrics.DCRedirectionStartWorkflowExecutionAsyncScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, sp1.GetDomain(), "", cluster, &err) }() err = handler.redirectionPolicy.WithDomainNameRedirect(ctx, sp1.GetDomain(), apiName, func(targetDC string) error { @@ -964,7 +969,7 @@ func (handler *clusterRedirectionHandler) TerminateWorkflowExecution(ctx context scope, startTime := handler.beforeCall(metrics.DCRedirectionTerminateWorkflowExecutionScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &err) + handler.afterCall(recover(), scope, startTime, tp1.GetDomain(), "", cluster, &err) }() err = handler.redirectionPolicy.WithDomainNameRedirect(ctx, tp1.GetDomain(), apiName, func(targetDC string) error { @@ -1002,7 +1007,7 @@ func (handler *clusterRedirectionHandler) QueryWorkflow( } scope, startTime := handler.beforeCall(metrics.DCRedirectionQueryWorkflowScope) defer func() { - handler.afterCall(recover(), scope, startTime, cluster, &retError) + handler.afterCall(recover(), scope, startTime, request.GetDomain(), "", cluster, &retError) }() err = handler.redirectionPolicy.WithDomainNameRedirect(ctx, request.GetDomain(), apiName, func(targetDC string) error { @@ -1019,26 +1024,3 @@ func (handler *clusterRedirectionHandler) QueryWorkflow( return resp, err } - -func (handler *clusterRedirectionHandler) beforeCall( - scope int, -) (metrics.Scope, time.Time) { - return handler.GetMetricsClient().Scope(scope), handler.GetTimeSource().Now() -} - -func (handler *clusterRedirectionHandler) afterCall( - recovered interface{}, - scope metrics.Scope, - startTime time.Time, - cluster string, - retError *error, -) { - log.CapturePanic(recovered, handler.GetLogger(), retError) - - scope = scope.Tagged(metrics.TargetClusterTag(cluster)) - scope.IncCounter(metrics.CadenceDcRedirectionClientRequests) - scope.RecordTimer(metrics.CadenceDcRedirectionClientLatency, handler.GetTimeSource().Now().Sub(startTime)) - if *retError != nil { - scope.IncCounter(metrics.CadenceDcRedirectionClientFailures) - } -} diff --git a/service/frontend/wrappers/clusterredirection/api_test.go b/service/frontend/wrappers/clusterredirection/api_test.go index 56db199c10e..4273da5af54 100644 --- a/service/frontend/wrappers/clusterredirection/api_test.go +++ b/service/frontend/wrappers/clusterredirection/api_test.go @@ -78,12 +78,6 @@ func TestClusterRedirectionHandlerSuite(t *testing.T) { suite.Run(t, s) } -func (s *clusterRedirectionHandlerSuite) SetupSuite() { -} - -func (s *clusterRedirectionHandlerSuite) TearDownSuite() { -} - func (s *clusterRedirectionHandlerSuite) SetupTest() { s.Assertions = require.New(s.T()) diff --git a/service/frontend/wrappers/clusterredirection/callwrappers.go b/service/frontend/wrappers/clusterredirection/callwrappers.go new file mode 100644 index 00000000000..0aec0759515 --- /dev/null +++ b/service/frontend/wrappers/clusterredirection/callwrappers.go @@ -0,0 +1,77 @@ +// The MIT License (MIT) + +// Copyright (c) 2017-2020 Uber Technologies Inc. + +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +package clusterredirection + +import ( + "time" + + "github.com/uber/cadence/common/log" + "github.com/uber/cadence/common/log/tag" + "github.com/uber/cadence/common/metrics" +) + +type ( + domainIDGetter interface { + GetDomainID() string + } +) + +func (handler *clusterRedirectionHandler) beforeCall( + scope int, +) (metrics.Scope, time.Time) { + return handler.GetMetricsClient().Scope(scope), handler.GetTimeSource().Now() +} + +func (handler *clusterRedirectionHandler) afterCall( + recovered interface{}, + scope metrics.Scope, + startTime time.Time, + domainName string, + domainID string, + cluster string, + retError *error, +) { + var extraTags []tag.Tag + if domainName != "" { + extraTags = append(extraTags, tag.WorkflowDomainName(domainName)) + } + if domainID != "" { + extraTags = append(extraTags, tag.WorkflowDomainID(domainID)) + } + log.CapturePanic(recovered, handler.GetLogger().WithTags(extraTags...), retError) + + scope = scope.Tagged(metrics.TargetClusterTag(cluster)) + scope.IncCounter(metrics.CadenceDcRedirectionClientRequests) + scope.RecordTimer(metrics.CadenceDcRedirectionClientLatency, handler.GetTimeSource().Now().Sub(startTime)) + if *retError != nil { + scope.IncCounter(metrics.CadenceDcRedirectionClientFailures) + } +} + +// noopdomainIDGetter is a domainIDGetter that always returns empty string. +// it is used for extraction of domainID from domainIDGetter in case of token extraction failure. +type noopdomainIDGetter struct{} + +func (noopdomainIDGetter) GetDomainID() string { + return "" +} diff --git a/service/frontend/wrappers/clusterredirection/policy.go b/service/frontend/wrappers/clusterredirection/policy.go index 227d36bbc6e..dde78e4b9b4 100644 --- a/service/frontend/wrappers/clusterredirection/policy.go +++ b/service/frontend/wrappers/clusterredirection/policy.go @@ -194,6 +194,9 @@ func (policy *selectedOrAllAPIsForwardingRedirectionPolicy) WithDomainIDRedirect if err != nil { return err } + if domainEntry.IsDeprecatedOrDeleted() { + return fmt.Errorf("domain %v is deprecated or deleted", domainEntry.GetInfo().Name) + } return policy.withRedirect(ctx, domainEntry, apiName, call) } @@ -203,6 +206,9 @@ func (policy *selectedOrAllAPIsForwardingRedirectionPolicy) WithDomainNameRedire if err != nil { return err } + if domainEntry.IsDeprecatedOrDeleted() { + return fmt.Errorf("domain %v is deprecated or deleted", domainName) + } return policy.withRedirect(ctx, domainEntry, apiName, call) } diff --git a/service/frontend/wrappers/clusterredirection/policy_test.go b/service/frontend/wrappers/clusterredirection/policy_test.go index f7733ce2c93..aa3d1d280ef 100644 --- a/service/frontend/wrappers/clusterredirection/policy_test.go +++ b/service/frontend/wrappers/clusterredirection/policy_test.go @@ -69,13 +69,6 @@ func TestNoopDCRedirectionPolicySuite(t *testing.T) { suite.Run(t, s) } -func (s *noopDCRedirectionPolicySuite) SetupSuite() { -} - -func (s *noopDCRedirectionPolicySuite) TearDownSuite() { - -} - func (s *noopDCRedirectionPolicySuite) SetupTest() { s.Assertions = require.New(s.T()) @@ -343,6 +336,79 @@ func (s *selectedAPIsForwardingRedirectionPolicySuite) TestGetTargetDataCenter_G s.Equal(2*len(selectedAPIsForwardingRedirectionPolicyAPIAllowlist), alternativeClustercallCount) } +func (s *selectedAPIsForwardingRedirectionPolicySuite) TestGetTargetDataCenter_GlobalDomain_NoDomainInCache() { + currentClustercallCount := 0 + alternativeClustercallCount := 0 + callFn := func(targetCluster string) error { + switch targetCluster { + case s.currentClusterName: + currentClustercallCount++ + return nil + case s.alternativeClusterName: + alternativeClustercallCount++ + return &types.DomainNotActiveError{ + CurrentCluster: s.alternativeClusterName, + ActiveCluster: s.currentClusterName, + } + default: + panic(fmt.Sprintf("unknown cluster name %v", targetCluster)) + } + } + + expectedErr := fmt.Errorf("some random error") + s.mockDomainCache.EXPECT().GetDomainByID(s.domainID).Return(nil, expectedErr).Times(len(selectedAPIsForwardingRedirectionPolicyAPIAllowlist)) + s.mockDomainCache.EXPECT().GetDomain(s.domainName).Return(nil, expectedErr).Times(len(selectedAPIsForwardingRedirectionPolicyAPIAllowlist)) + + for apiName := range selectedAPIsForwardingRedirectionPolicyAPIAllowlist { + err := s.policy.WithDomainIDRedirect(context.Background(), s.domainID, apiName, callFn) + s.Error(err) + s.Equal(expectedErr.Error(), err.Error()) + + err = s.policy.WithDomainNameRedirect(context.Background(), s.domainName, apiName, callFn) + s.Error(err) + s.Equal(expectedErr.Error(), err.Error()) + } + + // Ensure there were no calls to the target clusters + s.Equal(0, currentClustercallCount) + s.Equal(0, alternativeClustercallCount) +} + +func (s *selectedAPIsForwardingRedirectionPolicySuite) TestGetTargetDataCenter_GlobalDomain_Forwarding_DeprecatedDomain() { + s.setupGlobalDeprecatedDomainWithTwoReplicationCluster(true, false) + + currentClustercallCount := 0 + alternativeClustercallCount := 0 + callFn := func(targetCluster string) error { + switch targetCluster { + case s.currentClusterName: + currentClustercallCount++ + return nil + case s.alternativeClusterName: + alternativeClustercallCount++ + return &types.DomainNotActiveError{ + CurrentCluster: s.alternativeClusterName, + ActiveCluster: s.currentClusterName, + } + default: + panic(fmt.Sprintf("unknown cluster name %v", targetCluster)) + } + } + + for apiName := range selectedAPIsForwardingRedirectionPolicyAPIAllowlist { + err := s.policy.WithDomainIDRedirect(context.Background(), s.domainID, apiName, callFn) + s.Error(err) + s.Equal(fmt.Sprintf("domain %v is deprecated or deleted", s.domainName), err.Error()) + + err = s.policy.WithDomainNameRedirect(context.Background(), s.domainName, apiName, callFn) + s.Error(err) + s.Equal(fmt.Sprintf("domain %v is deprecated or deleted", s.domainName), err.Error()) + } + + s.Equal(0, currentClustercallCount) + s.Equal(0, alternativeClustercallCount) +} + func (s *selectedAPIsForwardingRedirectionPolicySuite) setupLocalDomain() { domainEntry := cache.NewLocalDomainCacheEntryForTest( &persistence.DomainInfo{ID: s.domainID, Name: s.domainName}, @@ -376,3 +442,26 @@ func (s *selectedAPIsForwardingRedirectionPolicySuite) setupGlobalDomainWithTwoR s.mockDomainCache.EXPECT().GetDomain(s.domainName).Return(domainEntry, nil).AnyTimes() s.mockConfig.EnableDomainNotActiveAutoForwarding = dynamicconfig.GetBoolPropertyFnFilteredByDomain(forwardingEnabled) } + +func (s *selectedAPIsForwardingRedirectionPolicySuite) setupGlobalDeprecatedDomainWithTwoReplicationCluster(forwardingEnabled bool, isRecordActive bool) { + activeCluster := s.alternativeClusterName + if isRecordActive { + activeCluster = s.currentClusterName + } + domainEntry := cache.NewGlobalDomainCacheEntryForTest( + &persistence.DomainInfo{ID: s.domainID, Name: s.domainName, Status: persistence.DomainStatusDeprecated}, + &persistence.DomainConfig{Retention: 1}, + &persistence.DomainReplicationConfig{ + ActiveClusterName: activeCluster, + Clusters: []*persistence.ClusterReplicationConfig{ + {ClusterName: cluster.TestCurrentClusterName}, + {ClusterName: cluster.TestAlternativeClusterName}, + }, + }, + 1234, // not used + ) + + s.mockDomainCache.EXPECT().GetDomainByID(s.domainID).Return(domainEntry, nil).AnyTimes() + s.mockDomainCache.EXPECT().GetDomain(s.domainName).Return(domainEntry, nil).AnyTimes() + s.mockConfig.EnableDomainNotActiveAutoForwarding = dynamicconfig.GetBoolPropertyFnFilteredByDomain(forwardingEnabled) +} From 8f3248c517719e10114821277fd617599b4aa020 Mon Sep 17 00:00:00 2001 From: bowen xiao Date: Thu, 4 Apr 2024 15:29:32 -0700 Subject: [PATCH 3/6] Add unit test for triple manager and renaming a variable in pinot dual manager test (#5869) * renaming variables in pinot dual manager test; unit test for setup functions in triple manager * reformat --- .../pinotVisibilityTripleManager_test.go | 62 -- .../pinot_visibility_dual_manager_test.go | 596 +++++++++--------- ....go => pinot_visibility_triple_manager.go} | 0 .../pinot_visibility_triple_manager_test.go | 204 ++++++ 4 files changed, 502 insertions(+), 360 deletions(-) delete mode 100644 common/persistence/pinotVisibilityTripleManager_test.go rename common/persistence/{pinotVisibilityTripleManager.go => pinot_visibility_triple_manager.go} (100%) create mode 100644 common/persistence/pinot_visibility_triple_manager_test.go diff --git a/common/persistence/pinotVisibilityTripleManager_test.go b/common/persistence/pinotVisibilityTripleManager_test.go deleted file mode 100644 index 016a04ec405..00000000000 --- a/common/persistence/pinotVisibilityTripleManager_test.go +++ /dev/null @@ -1,62 +0,0 @@ -// The MIT License (MIT) - -// Copyright (c) 2017-2020 Uber Technologies Inc. - -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in all -// copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -// SOFTWARE. - -package persistence - -import ( - "testing" - - "github.com/stretchr/testify/assert" -) - -func TestFilterAttrPrefix(t *testing.T) { - tests := map[string]struct { - expectedInput string - expectedOutput string - }{ - "Case1: empty input": { - expectedInput: "", - expectedOutput: "", - }, - "Case2: filtered input": { - expectedInput: "`Attr.CustomIntField` = 12", - expectedOutput: "CustomIntField = 12", - }, - "Case3: complex input": { - expectedInput: "WorkflowID = 'test-wf' and (`Attr.CustomIntField` = 12 or `Attr.CustomStringField` = 'a-b-c' and WorkflowType = 'wf-type')", - expectedOutput: "WorkflowID = 'test-wf' and (CustomIntField = 12 or CustomStringField = 'a-b-c' and WorkflowType = 'wf-type')", - }, - "Case4: false positive case": { - expectedInput: "`Attr.CustomStringField` = '`Attr.ABCtesting'", - expectedOutput: "CustomStringField = 'ABCtesting'", // this is supposed to be CustomStringField = '`Attr.ABCtesting' - }, - } - - for name, test := range tests { - t.Run(name, func(t *testing.T) { - assert.NotPanics(t, func() { - actualOutput := filterAttrPrefix(test.expectedInput) - assert.Equal(t, test.expectedOutput, actualOutput) - }) - }) - } -} diff --git a/common/persistence/pinot_visibility_dual_manager_test.go b/common/persistence/pinot_visibility_dual_manager_test.go index 149c6460b5f..fbc8f860a08 100644 --- a/common/persistence/pinot_visibility_dual_manager_test.go +++ b/common/persistence/pinot_visibility_dual_manager_test.go @@ -40,23 +40,23 @@ func TestNewPinotVisibilityDualManager(t *testing.T) { ctrl := gomock.NewController(t) tests := map[string]struct { - mockDBVisibilityManager VisibilityManager - mockESVisibilityManager VisibilityManager + mockDBVisibilityManager VisibilityManager + mockPinotVisibilityManager VisibilityManager }{ "Case1: nil case": { - mockDBVisibilityManager: nil, - mockESVisibilityManager: nil, + mockDBVisibilityManager: nil, + mockPinotVisibilityManager: nil, }, "Case2: success case": { - mockDBVisibilityManager: NewMockVisibilityManager(ctrl), - mockESVisibilityManager: NewMockVisibilityManager(ctrl), + mockDBVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), }, } for name, test := range tests { t.Run(name, func(t *testing.T) { assert.NotPanics(t, func() { - NewPinotVisibilityDualManager(test.mockDBVisibilityManager, test.mockESVisibilityManager, nil, nil, log.NewNoop()) + NewPinotVisibilityDualManager(test.mockDBVisibilityManager, test.mockPinotVisibilityManager, nil, nil, log.NewNoop()) }) }) } @@ -67,10 +67,10 @@ func TestPinotDualManagerClose(t *testing.T) { ctrl := gomock.NewController(t) tests := map[string]struct { - mockDBVisibilityManager VisibilityManager - mockESVisibilityManager VisibilityManager - mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) - mockESVisibilityManagerAccordance func(mockESVisibilityManager *MockVisibilityManager) + mockDBVisibilityManager VisibilityManager + mockPinotVisibilityManager VisibilityManager + mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) + mockPinotVisibilityManagerAccordance func(mockPinotVisibilityManager *MockVisibilityManager) }{ "Case1-1: success case with DB visibility is not nil": { mockDBVisibilityManager: NewMockVisibilityManager(ctrl), @@ -79,9 +79,9 @@ func TestPinotDualManagerClose(t *testing.T) { }, }, "Case1-2: success case with ES visibility is not nil": { - mockESVisibilityManager: NewMockVisibilityManager(ctrl), - mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { - mockESVisibilityManager.EXPECT().Close().Return().Times(1) + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { + mockPinotVisibilityManager.EXPECT().Close().Return().Times(1) }, }, } @@ -90,10 +90,10 @@ func TestPinotDualManagerClose(t *testing.T) { if test.mockDBVisibilityManager != nil { test.mockDBVisibilityManagerAccordance(test.mockDBVisibilityManager.(*MockVisibilityManager)) } - if test.mockESVisibilityManager != nil { - test.mockESVisibilityManagerAccordance(test.mockESVisibilityManager.(*MockVisibilityManager)) + if test.mockPinotVisibilityManager != nil { + test.mockPinotVisibilityManagerAccordance(test.mockPinotVisibilityManager.(*MockVisibilityManager)) } - visibilityManager := NewPinotVisibilityDualManager(test.mockDBVisibilityManager, test.mockESVisibilityManager, nil, nil, log.NewNoop()) + visibilityManager := NewPinotVisibilityDualManager(test.mockDBVisibilityManager, test.mockPinotVisibilityManager, nil, nil, log.NewNoop()) assert.NotPanics(t, func() { visibilityManager.Close() }) @@ -106,10 +106,10 @@ func TestPinotDualManagerGetName(t *testing.T) { ctrl := gomock.NewController(t) tests := map[string]struct { - mockDBVisibilityManager VisibilityManager - mockESVisibilityManager VisibilityManager - mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) - mockESVisibilityManagerAccordance func(mockESVisibilityManager *MockVisibilityManager) + mockDBVisibilityManager VisibilityManager + mockPinotVisibilityManager VisibilityManager + mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) + mockPinotVisibilityManagerAccordance func(mockPinotVisibilityManager *MockVisibilityManager) }{ "Case1-1: success case with DB visibility is not nil": { mockDBVisibilityManager: NewMockVisibilityManager(ctrl), @@ -119,9 +119,9 @@ func TestPinotDualManagerGetName(t *testing.T) { }, }, "Case1-2: success case with ES visibility is not nil": { - mockESVisibilityManager: NewMockVisibilityManager(ctrl), - mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { - mockESVisibilityManager.EXPECT().GetName().Return(testTableName).Times(1) + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { + mockPinotVisibilityManager.EXPECT().GetName().Return(testTableName).Times(1) }, }, } @@ -130,10 +130,10 @@ func TestPinotDualManagerGetName(t *testing.T) { if test.mockDBVisibilityManager != nil { test.mockDBVisibilityManagerAccordance(test.mockDBVisibilityManager.(*MockVisibilityManager)) } - if test.mockESVisibilityManager != nil { - test.mockESVisibilityManagerAccordance(test.mockESVisibilityManager.(*MockVisibilityManager)) + if test.mockPinotVisibilityManager != nil { + test.mockPinotVisibilityManagerAccordance(test.mockPinotVisibilityManager.(*MockVisibilityManager)) } - visibilityManager := NewPinotVisibilityDualManager(test.mockDBVisibilityManager, test.mockESVisibilityManager, nil, nil, log.NewNoop()) + visibilityManager := NewPinotVisibilityDualManager(test.mockDBVisibilityManager, test.mockPinotVisibilityManager, nil, nil, log.NewNoop()) assert.NotPanics(t, func() { visibilityManager.GetName() @@ -149,13 +149,13 @@ func TestPinotDualRecordWorkflowExecutionStarted(t *testing.T) { ctrl := gomock.NewController(t) tests := map[string]struct { - request *RecordWorkflowExecutionStartedRequest - mockDBVisibilityManager VisibilityManager - mockESVisibilityManager VisibilityManager - mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) - mockESVisibilityManagerAccordance func(mockESVisibilityManager *MockVisibilityManager) - advancedVisibilityWritingMode dynamicconfig.StringPropertyFn - expectedError error + request *RecordWorkflowExecutionStartedRequest + mockDBVisibilityManager VisibilityManager + mockPinotVisibilityManager VisibilityManager + mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) + mockPinotVisibilityManagerAccordance func(mockPinotVisibilityManager *MockVisibilityManager) + advancedVisibilityWritingMode dynamicconfig.StringPropertyFn + expectedError error }{ "Case1-1: success case with DB visibility is not nil": { request: request, @@ -167,10 +167,10 @@ func TestPinotDualRecordWorkflowExecutionStarted(t *testing.T) { expectedError: nil, }, "Case1-2: success case with ES visibility is not nil": { - request: request, - mockESVisibilityManager: NewMockVisibilityManager(ctrl), - mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { - mockESVisibilityManager.EXPECT().RecordWorkflowExecutionStarted(gomock.Any(), gomock.Any()).Return(nil).Times(1) + request: request, + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { + mockPinotVisibilityManager.EXPECT().RecordWorkflowExecutionStarted(gomock.Any(), gomock.Any()).Return(nil).Times(1) }, advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeOn), expectedError: nil, @@ -181,11 +181,11 @@ func TestPinotDualRecordWorkflowExecutionStarted(t *testing.T) { if test.mockDBVisibilityManager != nil { test.mockDBVisibilityManagerAccordance(test.mockDBVisibilityManager.(*MockVisibilityManager)) } - if test.mockESVisibilityManager != nil { - test.mockESVisibilityManagerAccordance(test.mockESVisibilityManager.(*MockVisibilityManager)) + if test.mockPinotVisibilityManager != nil { + test.mockPinotVisibilityManagerAccordance(test.mockPinotVisibilityManager.(*MockVisibilityManager)) } visibilityManager := NewPinotVisibilityDualManager(test.mockDBVisibilityManager, - test.mockESVisibilityManager, nil, test.advancedVisibilityWritingMode, log.NewNoop()) + test.mockPinotVisibilityManager, nil, test.advancedVisibilityWritingMode, log.NewNoop()) err := visibilityManager.RecordWorkflowExecutionStarted(context.Background(), test.request) if test.expectedError != nil { @@ -204,14 +204,14 @@ func TestPinotDualRecordWorkflowExecutionClosed(t *testing.T) { ctrl := gomock.NewController(t) tests := map[string]struct { - context context.Context - request *RecordWorkflowExecutionClosedRequest - mockDBVisibilityManager VisibilityManager - mockESVisibilityManager VisibilityManager - mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) - mockESVisibilityManagerAccordance func(mockESVisibilityManager *MockVisibilityManager) - advancedVisibilityWritingMode dynamicconfig.StringPropertyFn - expectedError error + context context.Context + request *RecordWorkflowExecutionClosedRequest + mockDBVisibilityManager VisibilityManager + mockPinotVisibilityManager VisibilityManager + mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) + mockPinotVisibilityManagerAccordance func(mockPinotVisibilityManager *MockVisibilityManager) + advancedVisibilityWritingMode dynamicconfig.StringPropertyFn + expectedError error }{ "Case0-1: error case with advancedVisibilityWritingMode is nil": { context: context.Background(), @@ -220,9 +220,9 @@ func TestPinotDualRecordWorkflowExecutionClosed(t *testing.T) { mockDBVisibilityManagerAccordance: func(mockDBVisibilityManager *MockVisibilityManager) { mockDBVisibilityManager.EXPECT().RecordWorkflowExecutionClosed(gomock.Any(), gomock.Any()).Return(nil).AnyTimes() }, - mockESVisibilityManager: NewMockVisibilityManager(ctrl), - mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { - mockESVisibilityManager.EXPECT().RecordWorkflowExecutionClosed(gomock.Any(), gomock.Any()).Return(nil).AnyTimes() + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { + mockPinotVisibilityManager.EXPECT().RecordWorkflowExecutionClosed(gomock.Any(), gomock.Any()).Return(nil).AnyTimes() }, expectedError: fmt.Errorf("error"), }, @@ -233,9 +233,9 @@ func TestPinotDualRecordWorkflowExecutionClosed(t *testing.T) { mockDBVisibilityManagerAccordance: func(mockDBVisibilityManager *MockVisibilityManager) { mockDBVisibilityManager.EXPECT().RecordWorkflowExecutionClosed(gomock.Any(), gomock.Any()).Return(nil).AnyTimes() }, - mockESVisibilityManager: NewMockVisibilityManager(ctrl), - mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { - mockESVisibilityManager.EXPECT().RecordWorkflowExecutionClosed(gomock.Any(), gomock.Any()).Return(fmt.Errorf("error")).AnyTimes() + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { + mockPinotVisibilityManager.EXPECT().RecordWorkflowExecutionClosed(gomock.Any(), gomock.Any()).Return(fmt.Errorf("error")).AnyTimes() }, advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeDual), expectedError: fmt.Errorf("error"), @@ -251,11 +251,11 @@ func TestPinotDualRecordWorkflowExecutionClosed(t *testing.T) { expectedError: nil, }, "Case1-2: success case with ES visibility is not nil": { - context: context.Background(), - request: request, - mockESVisibilityManager: NewMockVisibilityManager(ctrl), - mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { - mockESVisibilityManager.EXPECT().RecordWorkflowExecutionClosed(gomock.Any(), gomock.Any()).Return(nil).Times(1) + context: context.Background(), + request: request, + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { + mockPinotVisibilityManager.EXPECT().RecordWorkflowExecutionClosed(gomock.Any(), gomock.Any()).Return(nil).Times(1) }, advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeOn), expectedError: nil, @@ -267,19 +267,19 @@ func TestPinotDualRecordWorkflowExecutionClosed(t *testing.T) { mockDBVisibilityManagerAccordance: func(mockDBVisibilityManager *MockVisibilityManager) { mockDBVisibilityManager.EXPECT().RecordWorkflowExecutionClosed(gomock.Any(), gomock.Any()).Return(nil).Times(1) }, - mockESVisibilityManager: NewMockVisibilityManager(ctrl), - mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { - mockESVisibilityManager.EXPECT().RecordWorkflowExecutionClosed(gomock.Any(), gomock.Any()).Return(nil).Times(1) + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { + mockPinotVisibilityManager.EXPECT().RecordWorkflowExecutionClosed(gomock.Any(), gomock.Any()).Return(nil).Times(1) }, advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeDual), expectedError: nil, }, "Case2-1: choose DB visibility manager when it is nil": { - context: context.Background(), - request: request, - mockESVisibilityManager: NewMockVisibilityManager(ctrl), - mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { - mockESVisibilityManager.EXPECT().RecordWorkflowExecutionClosed(gomock.Any(), gomock.Any()).Return(nil).Times(1) + context: context.Background(), + request: request, + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { + mockPinotVisibilityManager.EXPECT().RecordWorkflowExecutionClosed(gomock.Any(), gomock.Any()).Return(nil).Times(1) }, advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeOff), }, @@ -302,11 +302,11 @@ func TestPinotDualRecordWorkflowExecutionClosed(t *testing.T) { advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeDual), }, "Case2-4: choose both when DB is nil": { - context: context.Background(), - request: request, - mockESVisibilityManager: NewMockVisibilityManager(ctrl), - mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { - mockESVisibilityManager.EXPECT().RecordWorkflowExecutionClosed(gomock.Any(), gomock.Any()).Return(nil).Times(1) + context: context.Background(), + request: request, + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { + mockPinotVisibilityManager.EXPECT().RecordWorkflowExecutionClosed(gomock.Any(), gomock.Any()).Return(nil).Times(1) }, advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeDual), }, @@ -319,11 +319,11 @@ func TestPinotDualRecordWorkflowExecutionClosed(t *testing.T) { }, }, "Case3-2: chooseVisibilityModeForAdmin when DB is nil": { - context: context.WithValue(context.Background(), VisibilityAdminDeletionKey("visibilityAdminDelete"), true), - request: request, - mockESVisibilityManager: NewMockVisibilityManager(ctrl), - mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { - mockESVisibilityManager.EXPECT().RecordWorkflowExecutionClosed(gomock.Any(), gomock.Any()).Return(nil).Times(1) + context: context.WithValue(context.Background(), VisibilityAdminDeletionKey("visibilityAdminDelete"), true), + request: request, + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { + mockPinotVisibilityManager.EXPECT().RecordWorkflowExecutionClosed(gomock.Any(), gomock.Any()).Return(nil).Times(1) }, }, "Case3-3: chooseVisibilityModeForAdmin when both are not nil": { @@ -333,9 +333,9 @@ func TestPinotDualRecordWorkflowExecutionClosed(t *testing.T) { mockDBVisibilityManagerAccordance: func(mockDBVisibilityManager *MockVisibilityManager) { mockDBVisibilityManager.EXPECT().RecordWorkflowExecutionClosed(gomock.Any(), gomock.Any()).Return(nil).Times(1) }, - mockESVisibilityManager: NewMockVisibilityManager(ctrl), - mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { - mockESVisibilityManager.EXPECT().RecordWorkflowExecutionClosed(gomock.Any(), gomock.Any()).Return(nil).Times(1) + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { + mockPinotVisibilityManager.EXPECT().RecordWorkflowExecutionClosed(gomock.Any(), gomock.Any()).Return(nil).Times(1) }, }, } @@ -344,11 +344,11 @@ func TestPinotDualRecordWorkflowExecutionClosed(t *testing.T) { if test.mockDBVisibilityManager != nil { test.mockDBVisibilityManagerAccordance(test.mockDBVisibilityManager.(*MockVisibilityManager)) } - if test.mockESVisibilityManager != nil { - test.mockESVisibilityManagerAccordance(test.mockESVisibilityManager.(*MockVisibilityManager)) + if test.mockPinotVisibilityManager != nil { + test.mockPinotVisibilityManagerAccordance(test.mockPinotVisibilityManager.(*MockVisibilityManager)) } visibilityManager := NewPinotVisibilityDualManager(test.mockDBVisibilityManager, - test.mockESVisibilityManager, nil, test.advancedVisibilityWritingMode, log.NewNoop()) + test.mockPinotVisibilityManager, nil, test.advancedVisibilityWritingMode, log.NewNoop()) err := visibilityManager.RecordWorkflowExecutionClosed(test.context, test.request) if test.expectedError != nil { @@ -379,13 +379,13 @@ func TestPinotDualRecordWorkflowExecutionUninitialized(t *testing.T) { ctrl := gomock.NewController(t) tests := map[string]struct { - request *RecordWorkflowExecutionUninitializedRequest - mockDBVisibilityManager VisibilityManager - mockESVisibilityManager VisibilityManager - mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) - mockESVisibilityManagerAccordance func(mockESVisibilityManager *MockVisibilityManager) - advancedVisibilityWritingMode dynamicconfig.StringPropertyFn - expectedError error + request *RecordWorkflowExecutionUninitializedRequest + mockDBVisibilityManager VisibilityManager + mockPinotVisibilityManager VisibilityManager + mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) + mockPinotVisibilityManagerAccordance func(mockPinotVisibilityManager *MockVisibilityManager) + advancedVisibilityWritingMode dynamicconfig.StringPropertyFn + expectedError error }{ "Case1-1: success case with DB visibility is not nil": { request: request, @@ -397,10 +397,10 @@ func TestPinotDualRecordWorkflowExecutionUninitialized(t *testing.T) { expectedError: nil, }, "Case1-2: success case with ES visibility is not nil": { - request: request, - mockESVisibilityManager: NewMockVisibilityManager(ctrl), - mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { - mockESVisibilityManager.EXPECT().RecordWorkflowExecutionUninitialized(gomock.Any(), gomock.Any()).Return(nil).Times(1) + request: request, + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { + mockPinotVisibilityManager.EXPECT().RecordWorkflowExecutionUninitialized(gomock.Any(), gomock.Any()).Return(nil).Times(1) }, advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeOn), expectedError: nil, @@ -411,11 +411,11 @@ func TestPinotDualRecordWorkflowExecutionUninitialized(t *testing.T) { if test.mockDBVisibilityManager != nil { test.mockDBVisibilityManagerAccordance(test.mockDBVisibilityManager.(*MockVisibilityManager)) } - if test.mockESVisibilityManager != nil { - test.mockESVisibilityManagerAccordance(test.mockESVisibilityManager.(*MockVisibilityManager)) + if test.mockPinotVisibilityManager != nil { + test.mockPinotVisibilityManagerAccordance(test.mockPinotVisibilityManager.(*MockVisibilityManager)) } visibilityManager := NewPinotVisibilityDualManager(test.mockDBVisibilityManager, - test.mockESVisibilityManager, nil, test.advancedVisibilityWritingMode, log.NewNoop()) + test.mockPinotVisibilityManager, nil, test.advancedVisibilityWritingMode, log.NewNoop()) err := visibilityManager.RecordWorkflowExecutionUninitialized(context.Background(), test.request) if test.expectedError != nil { @@ -434,13 +434,13 @@ func TestPinotDualUpsertWorkflowExecution(t *testing.T) { ctrl := gomock.NewController(t) tests := map[string]struct { - request *UpsertWorkflowExecutionRequest - mockDBVisibilityManager VisibilityManager - mockESVisibilityManager VisibilityManager - mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) - mockESVisibilityManagerAccordance func(mockESVisibilityManager *MockVisibilityManager) - advancedVisibilityWritingMode dynamicconfig.StringPropertyFn - expectedError error + request *UpsertWorkflowExecutionRequest + mockDBVisibilityManager VisibilityManager + mockPinotVisibilityManager VisibilityManager + mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) + mockPinotVisibilityManagerAccordance func(mockPinotVisibilityManager *MockVisibilityManager) + advancedVisibilityWritingMode dynamicconfig.StringPropertyFn + expectedError error }{ "Case1-1: success case with DB visibility is not nil": { request: request, @@ -452,10 +452,10 @@ func TestPinotDualUpsertWorkflowExecution(t *testing.T) { expectedError: nil, }, "Case1-2: success case with ES visibility is not nil": { - request: request, - mockESVisibilityManager: NewMockVisibilityManager(ctrl), - mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { - mockESVisibilityManager.EXPECT().UpsertWorkflowExecution(gomock.Any(), gomock.Any()).Return(nil).Times(1) + request: request, + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { + mockPinotVisibilityManager.EXPECT().UpsertWorkflowExecution(gomock.Any(), gomock.Any()).Return(nil).Times(1) }, advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeOn), expectedError: nil, @@ -466,11 +466,11 @@ func TestPinotDualUpsertWorkflowExecution(t *testing.T) { if test.mockDBVisibilityManager != nil { test.mockDBVisibilityManagerAccordance(test.mockDBVisibilityManager.(*MockVisibilityManager)) } - if test.mockESVisibilityManager != nil { - test.mockESVisibilityManagerAccordance(test.mockESVisibilityManager.(*MockVisibilityManager)) + if test.mockPinotVisibilityManager != nil { + test.mockPinotVisibilityManagerAccordance(test.mockPinotVisibilityManager.(*MockVisibilityManager)) } visibilityManager := NewPinotVisibilityDualManager(test.mockDBVisibilityManager, - test.mockESVisibilityManager, nil, test.advancedVisibilityWritingMode, log.NewNoop()) + test.mockPinotVisibilityManager, nil, test.advancedVisibilityWritingMode, log.NewNoop()) err := visibilityManager.UpsertWorkflowExecution(context.Background(), test.request) if test.expectedError != nil { @@ -489,13 +489,13 @@ func TestPinotDualDeleteWorkflowExecution(t *testing.T) { ctrl := gomock.NewController(t) tests := map[string]struct { - request *VisibilityDeleteWorkflowExecutionRequest - mockDBVisibilityManager VisibilityManager - mockESVisibilityManager VisibilityManager - mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) - mockESVisibilityManagerAccordance func(mockESVisibilityManager *MockVisibilityManager) - advancedVisibilityWritingMode dynamicconfig.StringPropertyFn - expectedError error + request *VisibilityDeleteWorkflowExecutionRequest + mockDBVisibilityManager VisibilityManager + mockPinotVisibilityManager VisibilityManager + mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) + mockPinotVisibilityManagerAccordance func(mockPinotVisibilityManager *MockVisibilityManager) + advancedVisibilityWritingMode dynamicconfig.StringPropertyFn + expectedError error }{ "Case1-1: success case with DB visibility is not nil": { request: request, @@ -507,10 +507,10 @@ func TestPinotDualDeleteWorkflowExecution(t *testing.T) { expectedError: nil, }, "Case1-2: success case with ES visibility is not nil": { - request: request, - mockESVisibilityManager: NewMockVisibilityManager(ctrl), - mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { - mockESVisibilityManager.EXPECT().DeleteWorkflowExecution(gomock.Any(), gomock.Any()).Return(nil).Times(1) + request: request, + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { + mockPinotVisibilityManager.EXPECT().DeleteWorkflowExecution(gomock.Any(), gomock.Any()).Return(nil).Times(1) }, advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeOn), expectedError: nil, @@ -521,11 +521,11 @@ func TestPinotDualDeleteWorkflowExecution(t *testing.T) { if test.mockDBVisibilityManager != nil { test.mockDBVisibilityManagerAccordance(test.mockDBVisibilityManager.(*MockVisibilityManager)) } - if test.mockESVisibilityManager != nil { - test.mockESVisibilityManagerAccordance(test.mockESVisibilityManager.(*MockVisibilityManager)) + if test.mockPinotVisibilityManager != nil { + test.mockPinotVisibilityManagerAccordance(test.mockPinotVisibilityManager.(*MockVisibilityManager)) } visibilityManager := NewPinotVisibilityDualManager(test.mockDBVisibilityManager, - test.mockESVisibilityManager, nil, test.advancedVisibilityWritingMode, log.NewNoop()) + test.mockPinotVisibilityManager, nil, test.advancedVisibilityWritingMode, log.NewNoop()) err := visibilityManager.DeleteWorkflowExecution(context.Background(), test.request) if test.expectedError != nil { @@ -544,13 +544,13 @@ func TestPinotDualDeleteUninitializedWorkflowExecution(t *testing.T) { ctrl := gomock.NewController(t) tests := map[string]struct { - request *VisibilityDeleteWorkflowExecutionRequest - mockDBVisibilityManager VisibilityManager - mockESVisibilityManager VisibilityManager - mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) - mockESVisibilityManagerAccordance func(mockESVisibilityManager *MockVisibilityManager) - advancedVisibilityWritingMode dynamicconfig.StringPropertyFn - expectedError error + request *VisibilityDeleteWorkflowExecutionRequest + mockDBVisibilityManager VisibilityManager + mockPinotVisibilityManager VisibilityManager + mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) + mockPinotVisibilityManagerAccordance func(mockPinotVisibilityManager *MockVisibilityManager) + advancedVisibilityWritingMode dynamicconfig.StringPropertyFn + expectedError error }{ "Case1-1: success case with DB visibility is not nil": { request: request, @@ -562,10 +562,10 @@ func TestPinotDualDeleteUninitializedWorkflowExecution(t *testing.T) { expectedError: nil, }, "Case1-2: success case with ES visibility is not nil": { - request: request, - mockESVisibilityManager: NewMockVisibilityManager(ctrl), - mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { - mockESVisibilityManager.EXPECT().DeleteUninitializedWorkflowExecution(gomock.Any(), gomock.Any()).Return(nil).Times(1) + request: request, + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { + mockPinotVisibilityManager.EXPECT().DeleteUninitializedWorkflowExecution(gomock.Any(), gomock.Any()).Return(nil).Times(1) }, advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeOn), expectedError: nil, @@ -576,11 +576,11 @@ func TestPinotDualDeleteUninitializedWorkflowExecution(t *testing.T) { if test.mockDBVisibilityManager != nil { test.mockDBVisibilityManagerAccordance(test.mockDBVisibilityManager.(*MockVisibilityManager)) } - if test.mockESVisibilityManager != nil { - test.mockESVisibilityManagerAccordance(test.mockESVisibilityManager.(*MockVisibilityManager)) + if test.mockPinotVisibilityManager != nil { + test.mockPinotVisibilityManagerAccordance(test.mockPinotVisibilityManager.(*MockVisibilityManager)) } visibilityManager := NewPinotVisibilityDualManager(test.mockDBVisibilityManager, - test.mockESVisibilityManager, nil, test.advancedVisibilityWritingMode, log.NewNoop()) + test.mockPinotVisibilityManager, nil, test.advancedVisibilityWritingMode, log.NewNoop()) err := visibilityManager.DeleteUninitializedWorkflowExecution(context.Background(), test.request) if test.expectedError != nil { @@ -601,13 +601,13 @@ func TestPinotDualListOpenWorkflowExecutions(t *testing.T) { ctrl := gomock.NewController(t) tests := map[string]struct { - request *ListWorkflowExecutionsRequest - mockDBVisibilityManager VisibilityManager - mockESVisibilityManager VisibilityManager - mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) - mockESVisibilityManagerAccordance func(mockESVisibilityManager *MockVisibilityManager) - readModeIsFromES dynamicconfig.BoolPropertyFnWithDomainFilter - expectedError error + request *ListWorkflowExecutionsRequest + mockDBVisibilityManager VisibilityManager + mockPinotVisibilityManager VisibilityManager + mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) + mockPinotVisibilityManagerAccordance func(mockPinotVisibilityManager *MockVisibilityManager) + readModeIsFromES dynamicconfig.BoolPropertyFnWithDomainFilter + expectedError error }{ "Case1-1: success case with DB visibility is not nil": { request: request, @@ -619,10 +619,10 @@ func TestPinotDualListOpenWorkflowExecutions(t *testing.T) { expectedError: nil, }, "Case1-2: success case with ES visibility is not nil": { - request: request, - mockESVisibilityManager: NewMockVisibilityManager(ctrl), - mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { - mockESVisibilityManager.EXPECT().ListOpenWorkflowExecutions(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1) + request: request, + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { + mockPinotVisibilityManager.EXPECT().ListOpenWorkflowExecutions(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1) }, readModeIsFromES: dynamicconfig.GetBoolPropertyFnFilteredByDomain(true), expectedError: nil, @@ -633,11 +633,11 @@ func TestPinotDualListOpenWorkflowExecutions(t *testing.T) { if test.mockDBVisibilityManager != nil { test.mockDBVisibilityManagerAccordance(test.mockDBVisibilityManager.(*MockVisibilityManager)) } - if test.mockESVisibilityManager != nil { - test.mockESVisibilityManagerAccordance(test.mockESVisibilityManager.(*MockVisibilityManager)) + if test.mockPinotVisibilityManager != nil { + test.mockPinotVisibilityManagerAccordance(test.mockPinotVisibilityManager.(*MockVisibilityManager)) } visibilityManager := NewPinotVisibilityDualManager(test.mockDBVisibilityManager, - test.mockESVisibilityManager, test.readModeIsFromES, nil, log.NewNoop()) + test.mockPinotVisibilityManager, test.readModeIsFromES, nil, log.NewNoop()) _, err := visibilityManager.ListOpenWorkflowExecutions(context.Background(), test.request) if test.expectedError != nil { @@ -658,13 +658,13 @@ func TestPinotDualListClosedWorkflowExecutions(t *testing.T) { ctrl := gomock.NewController(t) tests := map[string]struct { - request *ListWorkflowExecutionsRequest - mockDBVisibilityManager VisibilityManager - mockESVisibilityManager VisibilityManager - mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) - mockESVisibilityManagerAccordance func(mockESVisibilityManager *MockVisibilityManager) - readModeIsFromES dynamicconfig.BoolPropertyFnWithDomainFilter - expectedError error + request *ListWorkflowExecutionsRequest + mockDBVisibilityManager VisibilityManager + mockPinotVisibilityManager VisibilityManager + mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) + mockPinotVisibilityManagerAccordance func(mockPinotVisibilityManager *MockVisibilityManager) + readModeIsFromES dynamicconfig.BoolPropertyFnWithDomainFilter + expectedError error }{ "Case1-1: success case with DB visibility is not nil": { request: request, @@ -676,10 +676,10 @@ func TestPinotDualListClosedWorkflowExecutions(t *testing.T) { expectedError: nil, }, "Case1-2: success case with ES visibility is not nil": { - request: request, - mockESVisibilityManager: NewMockVisibilityManager(ctrl), - mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { - mockESVisibilityManager.EXPECT().ListClosedWorkflowExecutions(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1) + request: request, + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { + mockPinotVisibilityManager.EXPECT().ListClosedWorkflowExecutions(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1) }, readModeIsFromES: dynamicconfig.GetBoolPropertyFnFilteredByDomain(true), expectedError: nil, @@ -694,10 +694,10 @@ func TestPinotDualListClosedWorkflowExecutions(t *testing.T) { expectedError: nil, }, "Case2-2: success case with ES visibility is not nil and read mod is false": { - request: request, - mockESVisibilityManager: NewMockVisibilityManager(ctrl), - mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { - mockESVisibilityManager.EXPECT().ListClosedWorkflowExecutions(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1) + request: request, + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { + mockPinotVisibilityManager.EXPECT().ListClosedWorkflowExecutions(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1) }, readModeIsFromES: dynamicconfig.GetBoolPropertyFnFilteredByDomain(false), expectedError: nil, @@ -708,11 +708,11 @@ func TestPinotDualListClosedWorkflowExecutions(t *testing.T) { if test.mockDBVisibilityManager != nil { test.mockDBVisibilityManagerAccordance(test.mockDBVisibilityManager.(*MockVisibilityManager)) } - if test.mockESVisibilityManager != nil { - test.mockESVisibilityManagerAccordance(test.mockESVisibilityManager.(*MockVisibilityManager)) + if test.mockPinotVisibilityManager != nil { + test.mockPinotVisibilityManagerAccordance(test.mockPinotVisibilityManager.(*MockVisibilityManager)) } visibilityManager := NewPinotVisibilityDualManager(test.mockDBVisibilityManager, - test.mockESVisibilityManager, test.readModeIsFromES, nil, log.NewNoop()) + test.mockPinotVisibilityManager, test.readModeIsFromES, nil, log.NewNoop()) _, err := visibilityManager.ListClosedWorkflowExecutions(context.Background(), test.request) if test.expectedError != nil { @@ -735,13 +735,13 @@ func TestPinotDualListOpenWorkflowExecutionsByType(t *testing.T) { ctrl := gomock.NewController(t) tests := map[string]struct { - request *ListWorkflowExecutionsByTypeRequest - mockDBVisibilityManager VisibilityManager - mockESVisibilityManager VisibilityManager - mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) - mockESVisibilityManagerAccordance func(mockESVisibilityManager *MockVisibilityManager) - readModeIsFromES dynamicconfig.BoolPropertyFnWithDomainFilter - expectedError error + request *ListWorkflowExecutionsByTypeRequest + mockDBVisibilityManager VisibilityManager + mockPinotVisibilityManager VisibilityManager + mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) + mockPinotVisibilityManagerAccordance func(mockPinotVisibilityManager *MockVisibilityManager) + readModeIsFromES dynamicconfig.BoolPropertyFnWithDomainFilter + expectedError error }{ "Case1-1: success case with DB visibility is not nil": { request: request, @@ -753,10 +753,10 @@ func TestPinotDualListOpenWorkflowExecutionsByType(t *testing.T) { expectedError: nil, }, "Case1-2: success case with ES visibility is not nil": { - request: request, - mockESVisibilityManager: NewMockVisibilityManager(ctrl), - mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { - mockESVisibilityManager.EXPECT().ListOpenWorkflowExecutionsByType(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1) + request: request, + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { + mockPinotVisibilityManager.EXPECT().ListOpenWorkflowExecutionsByType(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1) }, readModeIsFromES: dynamicconfig.GetBoolPropertyFnFilteredByDomain(true), expectedError: nil, @@ -767,11 +767,11 @@ func TestPinotDualListOpenWorkflowExecutionsByType(t *testing.T) { if test.mockDBVisibilityManager != nil { test.mockDBVisibilityManagerAccordance(test.mockDBVisibilityManager.(*MockVisibilityManager)) } - if test.mockESVisibilityManager != nil { - test.mockESVisibilityManagerAccordance(test.mockESVisibilityManager.(*MockVisibilityManager)) + if test.mockPinotVisibilityManager != nil { + test.mockPinotVisibilityManagerAccordance(test.mockPinotVisibilityManager.(*MockVisibilityManager)) } visibilityManager := NewPinotVisibilityDualManager(test.mockDBVisibilityManager, - test.mockESVisibilityManager, test.readModeIsFromES, nil, log.NewNoop()) + test.mockPinotVisibilityManager, test.readModeIsFromES, nil, log.NewNoop()) _, err := visibilityManager.ListOpenWorkflowExecutionsByType(context.Background(), test.request) if test.expectedError != nil { @@ -794,13 +794,13 @@ func TestPinotDualListClosedWorkflowExecutionsByType(t *testing.T) { ctrl := gomock.NewController(t) tests := map[string]struct { - request *ListWorkflowExecutionsByTypeRequest - mockDBVisibilityManager VisibilityManager - mockESVisibilityManager VisibilityManager - mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) - mockESVisibilityManagerAccordance func(mockESVisibilityManager *MockVisibilityManager) - readModeIsFromES dynamicconfig.BoolPropertyFnWithDomainFilter - expectedError error + request *ListWorkflowExecutionsByTypeRequest + mockDBVisibilityManager VisibilityManager + mockPinotVisibilityManager VisibilityManager + mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) + mockPinotVisibilityManagerAccordance func(mockPinotVisibilityManager *MockVisibilityManager) + readModeIsFromES dynamicconfig.BoolPropertyFnWithDomainFilter + expectedError error }{ "Case1-1: success case with DB visibility is not nil": { request: request, @@ -812,10 +812,10 @@ func TestPinotDualListClosedWorkflowExecutionsByType(t *testing.T) { expectedError: nil, }, "Case1-2: success case with ES visibility is not nil": { - request: request, - mockESVisibilityManager: NewMockVisibilityManager(ctrl), - mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { - mockESVisibilityManager.EXPECT().ListClosedWorkflowExecutionsByType(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1) + request: request, + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { + mockPinotVisibilityManager.EXPECT().ListClosedWorkflowExecutionsByType(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1) }, readModeIsFromES: dynamicconfig.GetBoolPropertyFnFilteredByDomain(true), expectedError: nil, @@ -826,11 +826,11 @@ func TestPinotDualListClosedWorkflowExecutionsByType(t *testing.T) { if test.mockDBVisibilityManager != nil { test.mockDBVisibilityManagerAccordance(test.mockDBVisibilityManager.(*MockVisibilityManager)) } - if test.mockESVisibilityManager != nil { - test.mockESVisibilityManagerAccordance(test.mockESVisibilityManager.(*MockVisibilityManager)) + if test.mockPinotVisibilityManager != nil { + test.mockPinotVisibilityManagerAccordance(test.mockPinotVisibilityManager.(*MockVisibilityManager)) } visibilityManager := NewPinotVisibilityDualManager(test.mockDBVisibilityManager, - test.mockESVisibilityManager, test.readModeIsFromES, nil, log.NewNoop()) + test.mockPinotVisibilityManager, test.readModeIsFromES, nil, log.NewNoop()) _, err := visibilityManager.ListClosedWorkflowExecutionsByType(context.Background(), test.request) if test.expectedError != nil { @@ -853,13 +853,13 @@ func TestPinotDualListOpenWorkflowExecutionsByWorkflowID(t *testing.T) { ctrl := gomock.NewController(t) tests := map[string]struct { - request *ListWorkflowExecutionsByWorkflowIDRequest - mockDBVisibilityManager VisibilityManager - mockESVisibilityManager VisibilityManager - mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) - mockESVisibilityManagerAccordance func(mockESVisibilityManager *MockVisibilityManager) - readModeIsFromES dynamicconfig.BoolPropertyFnWithDomainFilter - expectedError error + request *ListWorkflowExecutionsByWorkflowIDRequest + mockDBVisibilityManager VisibilityManager + mockPinotVisibilityManager VisibilityManager + mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) + mockPinotVisibilityManagerAccordance func(mockPinotVisibilityManager *MockVisibilityManager) + readModeIsFromES dynamicconfig.BoolPropertyFnWithDomainFilter + expectedError error }{ "Case1-1: success case with DB visibility is not nil": { request: request, @@ -871,10 +871,10 @@ func TestPinotDualListOpenWorkflowExecutionsByWorkflowID(t *testing.T) { expectedError: nil, }, "Case1-2: success case with ES visibility is not nil": { - request: request, - mockESVisibilityManager: NewMockVisibilityManager(ctrl), - mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { - mockESVisibilityManager.EXPECT().ListOpenWorkflowExecutionsByWorkflowID(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1) + request: request, + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { + mockPinotVisibilityManager.EXPECT().ListOpenWorkflowExecutionsByWorkflowID(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1) }, readModeIsFromES: dynamicconfig.GetBoolPropertyFnFilteredByDomain(true), expectedError: nil, @@ -885,11 +885,11 @@ func TestPinotDualListOpenWorkflowExecutionsByWorkflowID(t *testing.T) { if test.mockDBVisibilityManager != nil { test.mockDBVisibilityManagerAccordance(test.mockDBVisibilityManager.(*MockVisibilityManager)) } - if test.mockESVisibilityManager != nil { - test.mockESVisibilityManagerAccordance(test.mockESVisibilityManager.(*MockVisibilityManager)) + if test.mockPinotVisibilityManager != nil { + test.mockPinotVisibilityManagerAccordance(test.mockPinotVisibilityManager.(*MockVisibilityManager)) } visibilityManager := NewPinotVisibilityDualManager(test.mockDBVisibilityManager, - test.mockESVisibilityManager, test.readModeIsFromES, nil, log.NewNoop()) + test.mockPinotVisibilityManager, test.readModeIsFromES, nil, log.NewNoop()) _, err := visibilityManager.ListOpenWorkflowExecutionsByWorkflowID(context.Background(), test.request) if test.expectedError != nil { @@ -912,13 +912,13 @@ func TestPinotDualListClosedWorkflowExecutionsByWorkflowID(t *testing.T) { ctrl := gomock.NewController(t) tests := map[string]struct { - request *ListWorkflowExecutionsByWorkflowIDRequest - mockDBVisibilityManager VisibilityManager - mockESVisibilityManager VisibilityManager - mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) - mockESVisibilityManagerAccordance func(mockESVisibilityManager *MockVisibilityManager) - readModeIsFromES dynamicconfig.BoolPropertyFnWithDomainFilter - expectedError error + request *ListWorkflowExecutionsByWorkflowIDRequest + mockDBVisibilityManager VisibilityManager + mockPinotVisibilityManager VisibilityManager + mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) + mockPinotVisibilityManagerAccordance func(mockPinotVisibilityManager *MockVisibilityManager) + readModeIsFromES dynamicconfig.BoolPropertyFnWithDomainFilter + expectedError error }{ "Case1-1: success case with DB visibility is not nil": { request: request, @@ -930,10 +930,10 @@ func TestPinotDualListClosedWorkflowExecutionsByWorkflowID(t *testing.T) { expectedError: nil, }, "Case1-2: success case with ES visibility is not nil": { - request: request, - mockESVisibilityManager: NewMockVisibilityManager(ctrl), - mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { - mockESVisibilityManager.EXPECT().ListClosedWorkflowExecutionsByWorkflowID(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1) + request: request, + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { + mockPinotVisibilityManager.EXPECT().ListClosedWorkflowExecutionsByWorkflowID(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1) }, readModeIsFromES: dynamicconfig.GetBoolPropertyFnFilteredByDomain(true), expectedError: nil, @@ -944,11 +944,11 @@ func TestPinotDualListClosedWorkflowExecutionsByWorkflowID(t *testing.T) { if test.mockDBVisibilityManager != nil { test.mockDBVisibilityManagerAccordance(test.mockDBVisibilityManager.(*MockVisibilityManager)) } - if test.mockESVisibilityManager != nil { - test.mockESVisibilityManagerAccordance(test.mockESVisibilityManager.(*MockVisibilityManager)) + if test.mockPinotVisibilityManager != nil { + test.mockPinotVisibilityManagerAccordance(test.mockPinotVisibilityManager.(*MockVisibilityManager)) } visibilityManager := NewPinotVisibilityDualManager(test.mockDBVisibilityManager, - test.mockESVisibilityManager, test.readModeIsFromES, nil, log.NewNoop()) + test.mockPinotVisibilityManager, test.readModeIsFromES, nil, log.NewNoop()) _, err := visibilityManager.ListClosedWorkflowExecutionsByWorkflowID(context.Background(), test.request) if test.expectedError != nil { @@ -971,13 +971,13 @@ func TestPinotDualListClosedWorkflowExecutionsByStatus(t *testing.T) { ctrl := gomock.NewController(t) tests := map[string]struct { - request *ListClosedWorkflowExecutionsByStatusRequest - mockDBVisibilityManager VisibilityManager - mockESVisibilityManager VisibilityManager - mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) - mockESVisibilityManagerAccordance func(mockESVisibilityManager *MockVisibilityManager) - readModeIsFromES dynamicconfig.BoolPropertyFnWithDomainFilter - expectedError error + request *ListClosedWorkflowExecutionsByStatusRequest + mockDBVisibilityManager VisibilityManager + mockPinotVisibilityManager VisibilityManager + mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) + mockPinotVisibilityManagerAccordance func(mockPinotVisibilityManager *MockVisibilityManager) + readModeIsFromES dynamicconfig.BoolPropertyFnWithDomainFilter + expectedError error }{ "Case1-1: success case with DB visibility is not nil": { request: request, @@ -989,10 +989,10 @@ func TestPinotDualListClosedWorkflowExecutionsByStatus(t *testing.T) { expectedError: nil, }, "Case1-2: success case with ES visibility is not nil": { - request: request, - mockESVisibilityManager: NewMockVisibilityManager(ctrl), - mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { - mockESVisibilityManager.EXPECT().ListClosedWorkflowExecutionsByStatus(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1) + request: request, + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { + mockPinotVisibilityManager.EXPECT().ListClosedWorkflowExecutionsByStatus(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1) }, readModeIsFromES: dynamicconfig.GetBoolPropertyFnFilteredByDomain(true), expectedError: nil, @@ -1003,11 +1003,11 @@ func TestPinotDualListClosedWorkflowExecutionsByStatus(t *testing.T) { if test.mockDBVisibilityManager != nil { test.mockDBVisibilityManagerAccordance(test.mockDBVisibilityManager.(*MockVisibilityManager)) } - if test.mockESVisibilityManager != nil { - test.mockESVisibilityManagerAccordance(test.mockESVisibilityManager.(*MockVisibilityManager)) + if test.mockPinotVisibilityManager != nil { + test.mockPinotVisibilityManagerAccordance(test.mockPinotVisibilityManager.(*MockVisibilityManager)) } visibilityManager := NewPinotVisibilityDualManager(test.mockDBVisibilityManager, - test.mockESVisibilityManager, test.readModeIsFromES, nil, log.NewNoop()) + test.mockPinotVisibilityManager, test.readModeIsFromES, nil, log.NewNoop()) _, err := visibilityManager.ListClosedWorkflowExecutionsByStatus(context.Background(), test.request) if test.expectedError != nil { @@ -1028,13 +1028,13 @@ func TestPinotDualGetClosedWorkflowExecution(t *testing.T) { ctrl := gomock.NewController(t) tests := map[string]struct { - request *GetClosedWorkflowExecutionRequest - mockDBVisibilityManager VisibilityManager - mockESVisibilityManager VisibilityManager - mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) - mockESVisibilityManagerAccordance func(mockESVisibilityManager *MockVisibilityManager) - readModeIsFromES dynamicconfig.BoolPropertyFnWithDomainFilter - expectedError error + request *GetClosedWorkflowExecutionRequest + mockDBVisibilityManager VisibilityManager + mockPinotVisibilityManager VisibilityManager + mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) + mockPinotVisibilityManagerAccordance func(mockPinotVisibilityManager *MockVisibilityManager) + readModeIsFromES dynamicconfig.BoolPropertyFnWithDomainFilter + expectedError error }{ "Case1-1: success case with DB visibility is not nil": { request: request, @@ -1046,10 +1046,10 @@ func TestPinotDualGetClosedWorkflowExecution(t *testing.T) { expectedError: nil, }, "Case1-2: success case with ES visibility is not nil": { - request: request, - mockESVisibilityManager: NewMockVisibilityManager(ctrl), - mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { - mockESVisibilityManager.EXPECT().GetClosedWorkflowExecution(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1) + request: request, + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { + mockPinotVisibilityManager.EXPECT().GetClosedWorkflowExecution(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1) }, readModeIsFromES: dynamicconfig.GetBoolPropertyFnFilteredByDomain(true), expectedError: nil, @@ -1060,11 +1060,11 @@ func TestPinotDualGetClosedWorkflowExecution(t *testing.T) { if test.mockDBVisibilityManager != nil { test.mockDBVisibilityManagerAccordance(test.mockDBVisibilityManager.(*MockVisibilityManager)) } - if test.mockESVisibilityManager != nil { - test.mockESVisibilityManagerAccordance(test.mockESVisibilityManager.(*MockVisibilityManager)) + if test.mockPinotVisibilityManager != nil { + test.mockPinotVisibilityManagerAccordance(test.mockPinotVisibilityManager.(*MockVisibilityManager)) } visibilityManager := NewPinotVisibilityDualManager(test.mockDBVisibilityManager, - test.mockESVisibilityManager, test.readModeIsFromES, nil, log.NewNoop()) + test.mockPinotVisibilityManager, test.readModeIsFromES, nil, log.NewNoop()) _, err := visibilityManager.GetClosedWorkflowExecution(context.Background(), test.request) if test.expectedError != nil { @@ -1085,13 +1085,13 @@ func TestPinotDualListWorkflowExecutions(t *testing.T) { ctrl := gomock.NewController(t) tests := map[string]struct { - request *ListWorkflowExecutionsByQueryRequest - mockDBVisibilityManager VisibilityManager - mockESVisibilityManager VisibilityManager - mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) - mockESVisibilityManagerAccordance func(mockESVisibilityManager *MockVisibilityManager) - readModeIsFromES dynamicconfig.BoolPropertyFnWithDomainFilter - expectedError error + request *ListWorkflowExecutionsByQueryRequest + mockDBVisibilityManager VisibilityManager + mockPinotVisibilityManager VisibilityManager + mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) + mockPinotVisibilityManagerAccordance func(mockPinotVisibilityManager *MockVisibilityManager) + readModeIsFromES dynamicconfig.BoolPropertyFnWithDomainFilter + expectedError error }{ "Case1-1: success case with DB visibility is not nil": { request: request, @@ -1103,10 +1103,10 @@ func TestPinotDualListWorkflowExecutions(t *testing.T) { expectedError: nil, }, "Case1-2: success case with ES visibility is not nil": { - request: request, - mockESVisibilityManager: NewMockVisibilityManager(ctrl), - mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { - mockESVisibilityManager.EXPECT().ListWorkflowExecutions(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1) + request: request, + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { + mockPinotVisibilityManager.EXPECT().ListWorkflowExecutions(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1) }, readModeIsFromES: dynamicconfig.GetBoolPropertyFnFilteredByDomain(true), expectedError: nil, @@ -1117,11 +1117,11 @@ func TestPinotDualListWorkflowExecutions(t *testing.T) { if test.mockDBVisibilityManager != nil { test.mockDBVisibilityManagerAccordance(test.mockDBVisibilityManager.(*MockVisibilityManager)) } - if test.mockESVisibilityManager != nil { - test.mockESVisibilityManagerAccordance(test.mockESVisibilityManager.(*MockVisibilityManager)) + if test.mockPinotVisibilityManager != nil { + test.mockPinotVisibilityManagerAccordance(test.mockPinotVisibilityManager.(*MockVisibilityManager)) } visibilityManager := NewPinotVisibilityDualManager(test.mockDBVisibilityManager, - test.mockESVisibilityManager, test.readModeIsFromES, nil, log.NewNoop()) + test.mockPinotVisibilityManager, test.readModeIsFromES, nil, log.NewNoop()) _, err := visibilityManager.ListWorkflowExecutions(context.Background(), test.request) if test.expectedError != nil { @@ -1142,13 +1142,13 @@ func TestPinotDualScanWorkflowExecutions(t *testing.T) { ctrl := gomock.NewController(t) tests := map[string]struct { - request *ListWorkflowExecutionsByQueryRequest - mockDBVisibilityManager VisibilityManager - mockESVisibilityManager VisibilityManager - mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) - mockESVisibilityManagerAccordance func(mockESVisibilityManager *MockVisibilityManager) - readModeIsFromES dynamicconfig.BoolPropertyFnWithDomainFilter - expectedError error + request *ListWorkflowExecutionsByQueryRequest + mockDBVisibilityManager VisibilityManager + mockPinotVisibilityManager VisibilityManager + mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) + mockPinotVisibilityManagerAccordance func(mockPinotVisibilityManager *MockVisibilityManager) + readModeIsFromES dynamicconfig.BoolPropertyFnWithDomainFilter + expectedError error }{ "Case1-1: success case with DB visibility is not nil": { request: request, @@ -1160,10 +1160,10 @@ func TestPinotDualScanWorkflowExecutions(t *testing.T) { expectedError: nil, }, "Case1-2: success case with ES visibility is not nil": { - request: request, - mockESVisibilityManager: NewMockVisibilityManager(ctrl), - mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { - mockESVisibilityManager.EXPECT().ScanWorkflowExecutions(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1) + request: request, + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { + mockPinotVisibilityManager.EXPECT().ScanWorkflowExecutions(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1) }, readModeIsFromES: dynamicconfig.GetBoolPropertyFnFilteredByDomain(true), expectedError: nil, @@ -1174,11 +1174,11 @@ func TestPinotDualScanWorkflowExecutions(t *testing.T) { if test.mockDBVisibilityManager != nil { test.mockDBVisibilityManagerAccordance(test.mockDBVisibilityManager.(*MockVisibilityManager)) } - if test.mockESVisibilityManager != nil { - test.mockESVisibilityManagerAccordance(test.mockESVisibilityManager.(*MockVisibilityManager)) + if test.mockPinotVisibilityManager != nil { + test.mockPinotVisibilityManagerAccordance(test.mockPinotVisibilityManager.(*MockVisibilityManager)) } visibilityManager := NewPinotVisibilityDualManager(test.mockDBVisibilityManager, - test.mockESVisibilityManager, test.readModeIsFromES, nil, log.NewNoop()) + test.mockPinotVisibilityManager, test.readModeIsFromES, nil, log.NewNoop()) _, err := visibilityManager.ScanWorkflowExecutions(context.Background(), test.request) if test.expectedError != nil { @@ -1198,13 +1198,13 @@ func TestPinotDualCountWorkflowExecutions(t *testing.T) { ctrl := gomock.NewController(t) tests := map[string]struct { - request *CountWorkflowExecutionsRequest - mockDBVisibilityManager VisibilityManager - mockESVisibilityManager VisibilityManager - mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) - mockESVisibilityManagerAccordance func(mockESVisibilityManager *MockVisibilityManager) - readModeIsFromES dynamicconfig.BoolPropertyFnWithDomainFilter - expectedError error + request *CountWorkflowExecutionsRequest + mockDBVisibilityManager VisibilityManager + mockPinotVisibilityManager VisibilityManager + mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) + mockPinotVisibilityManagerAccordance func(mockPinotVisibilityManager *MockVisibilityManager) + readModeIsFromES dynamicconfig.BoolPropertyFnWithDomainFilter + expectedError error }{ "Case1-1: success case with DB visibility is not nil": { request: request, @@ -1216,10 +1216,10 @@ func TestPinotDualCountWorkflowExecutions(t *testing.T) { expectedError: nil, }, "Case1-2: success case with ES visibility is not nil": { - request: request, - mockESVisibilityManager: NewMockVisibilityManager(ctrl), - mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { - mockESVisibilityManager.EXPECT().CountWorkflowExecutions(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1) + request: request, + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { + mockPinotVisibilityManager.EXPECT().CountWorkflowExecutions(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1) }, readModeIsFromES: dynamicconfig.GetBoolPropertyFnFilteredByDomain(true), expectedError: nil, @@ -1230,11 +1230,11 @@ func TestPinotDualCountWorkflowExecutions(t *testing.T) { if test.mockDBVisibilityManager != nil { test.mockDBVisibilityManagerAccordance(test.mockDBVisibilityManager.(*MockVisibilityManager)) } - if test.mockESVisibilityManager != nil { - test.mockESVisibilityManagerAccordance(test.mockESVisibilityManager.(*MockVisibilityManager)) + if test.mockPinotVisibilityManager != nil { + test.mockPinotVisibilityManagerAccordance(test.mockPinotVisibilityManager.(*MockVisibilityManager)) } visibilityManager := NewPinotVisibilityDualManager(test.mockDBVisibilityManager, - test.mockESVisibilityManager, test.readModeIsFromES, nil, log.NewNoop()) + test.mockPinotVisibilityManager, test.readModeIsFromES, nil, log.NewNoop()) _, err := visibilityManager.CountWorkflowExecutions(context.Background(), test.request) if test.expectedError != nil { diff --git a/common/persistence/pinotVisibilityTripleManager.go b/common/persistence/pinot_visibility_triple_manager.go similarity index 100% rename from common/persistence/pinotVisibilityTripleManager.go rename to common/persistence/pinot_visibility_triple_manager.go diff --git a/common/persistence/pinot_visibility_triple_manager_test.go b/common/persistence/pinot_visibility_triple_manager_test.go new file mode 100644 index 00000000000..ddebcda96ce --- /dev/null +++ b/common/persistence/pinot_visibility_triple_manager_test.go @@ -0,0 +1,204 @@ +// The MIT License (MIT) + +// Copyright (c) 2017-2020 Uber Technologies Inc. + +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +package persistence + +import ( + "testing" + + "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" + + "github.com/uber/cadence/common/log" +) + +func TestNewPinotVisibilityTripleManager(t *testing.T) { + // put this outside because need to use it as an input of the table tests + ctrl := gomock.NewController(t) + + tests := map[string]struct { + mockDBVisibilityManager VisibilityManager + mockESVisibilityManager VisibilityManager + mockPinotVisibilityManager VisibilityManager + }{ + "Case1: nil case": { + mockDBVisibilityManager: nil, + mockESVisibilityManager: nil, + mockPinotVisibilityManager: nil, + }, + "Case2: success case": { + mockDBVisibilityManager: NewMockVisibilityManager(ctrl), + mockESVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), + }, + } + + for name, test := range tests { + t.Run(name, func(t *testing.T) { + assert.NotPanics(t, func() { + NewPinotVisibilityTripleManager(test.mockDBVisibilityManager, test.mockPinotVisibilityManager, + test.mockESVisibilityManager, nil, nil, + nil, nil, log.NewNoop()) + }) + }) + } +} + +func TestPinotTripleManagerClose(t *testing.T) { + // put this outside because need to use it as an input of the table tests + ctrl := gomock.NewController(t) + + tests := map[string]struct { + mockDBVisibilityManager VisibilityManager + mockPinotVisibilityManager VisibilityManager + mockESVisibilityManager VisibilityManager + mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) + mockPinotVisibilityManagerAccordance func(mockPinotVisibilityManager *MockVisibilityManager) + mockESVisibilityManagerAccordance func(mockESVisibilityManager *MockVisibilityManager) + }{ + "Case1-1: success case with DB visibility is not nil": { + mockDBVisibilityManager: NewMockVisibilityManager(ctrl), + mockDBVisibilityManagerAccordance: func(mockDBVisibilityManager *MockVisibilityManager) { + mockDBVisibilityManager.EXPECT().Close().Return().Times(1) + }, + }, + "Case1-2: success case with ES visibility is not nil": { + mockESVisibilityManager: NewMockVisibilityManager(ctrl), + mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { + mockESVisibilityManager.EXPECT().Close().Return().Times(1) + }, + }, + "Case1-3: success case with pinot visibility is not nil": { + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { + mockPinotVisibilityManager.EXPECT().Close().Return().Times(1) + }, + }, + } + for name, test := range tests { + t.Run(name, func(t *testing.T) { + if test.mockDBVisibilityManager != nil { + test.mockDBVisibilityManagerAccordance(test.mockDBVisibilityManager.(*MockVisibilityManager)) + } + if test.mockPinotVisibilityManager != nil { + test.mockPinotVisibilityManagerAccordance(test.mockPinotVisibilityManager.(*MockVisibilityManager)) + } + if test.mockESVisibilityManager != nil { + test.mockESVisibilityManagerAccordance(test.mockESVisibilityManager.(*MockVisibilityManager)) + } + + visibilityManager := NewPinotVisibilityTripleManager(test.mockDBVisibilityManager, test.mockPinotVisibilityManager, + test.mockESVisibilityManager, nil, nil, + nil, nil, log.NewNoop()) + assert.NotPanics(t, func() { + visibilityManager.Close() + }) + }) + } +} + +func TestPinotTripleManagerGetName(t *testing.T) { + // put this outside because need to use it as an input of the table tests + ctrl := gomock.NewController(t) + + tests := map[string]struct { + mockDBVisibilityManager VisibilityManager + mockESVisibilityManager VisibilityManager + mockPinotVisibilityManager VisibilityManager + mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) + mockPinotVisibilityManagerAccordance func(mockPinotVisibilityManager *MockVisibilityManager) + mockESVisibilityManagerAccordance func(mockESVisibilityManager *MockVisibilityManager) + }{ + "Case1-1: success case with DB visibility is not nil": { + mockDBVisibilityManager: NewMockVisibilityManager(ctrl), + mockDBVisibilityManagerAccordance: func(mockDBVisibilityManager *MockVisibilityManager) { + mockDBVisibilityManager.EXPECT().GetName().Return(testTableName).Times(1) + + }, + }, + "Case1-2: success case with ES visibility is not nil": { + mockESVisibilityManager: NewMockVisibilityManager(ctrl), + mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { + mockESVisibilityManager.EXPECT().GetName().Return(testTableName).Times(1) + }, + }, + "Case1-3: success case with pinot visibility is not nil": { + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { + mockPinotVisibilityManager.EXPECT().GetName().Return(testTableName).Times(1) + }, + }, + } + for name, test := range tests { + t.Run(name, func(t *testing.T) { + if test.mockDBVisibilityManager != nil { + test.mockDBVisibilityManagerAccordance(test.mockDBVisibilityManager.(*MockVisibilityManager)) + } + if test.mockPinotVisibilityManager != nil { + test.mockPinotVisibilityManagerAccordance(test.mockPinotVisibilityManager.(*MockVisibilityManager)) + } + if test.mockESVisibilityManager != nil { + test.mockESVisibilityManagerAccordance(test.mockESVisibilityManager.(*MockVisibilityManager)) + } + visibilityManager := NewPinotVisibilityTripleManager(test.mockDBVisibilityManager, test.mockPinotVisibilityManager, + test.mockESVisibilityManager, nil, nil, + nil, nil, log.NewNoop()) + + assert.NotPanics(t, func() { + visibilityManager.GetName() + }) + }) + } +} + +func TestFilterAttrPrefix(t *testing.T) { + tests := map[string]struct { + expectedInput string + expectedOutput string + }{ + "Case1: empty input": { + expectedInput: "", + expectedOutput: "", + }, + "Case2: filtered input": { + expectedInput: "`Attr.CustomIntField` = 12", + expectedOutput: "CustomIntField = 12", + }, + "Case3: complex input": { + expectedInput: "WorkflowID = 'test-wf' and (`Attr.CustomIntField` = 12 or `Attr.CustomStringField` = 'a-b-c' and WorkflowType = 'wf-type')", + expectedOutput: "WorkflowID = 'test-wf' and (CustomIntField = 12 or CustomStringField = 'a-b-c' and WorkflowType = 'wf-type')", + }, + "Case4: false positive case": { + expectedInput: "`Attr.CustomStringField` = '`Attr.ABCtesting'", + expectedOutput: "CustomStringField = 'ABCtesting'", // this is supposed to be CustomStringField = '`Attr.ABCtesting' + }, + } + + for name, test := range tests { + t.Run(name, func(t *testing.T) { + assert.NotPanics(t, func() { + actualOutput := filterAttrPrefix(test.expectedInput) + assert.Equal(t, test.expectedOutput, actualOutput) + }) + }) + } +} From e040206a074095c327c3260eb4da2714c4634ba6 Mon Sep 17 00:00:00 2001 From: Abhishek Jha Date: Thu, 4 Apr 2024 16:06:44 -0700 Subject: [PATCH 4/6] Tests for failover watcher (#5864) * Tests for failover watcher * Stopped the watcher to avoid leaking goroutine * Added TimeSource for current time and using mockedTimeSource for test --- common/domain/failover_watcher.go | 4 +- common/domain/failover_watcher_test.go | 77 +++++++++++++++++++++++++- 2 files changed, 78 insertions(+), 3 deletions(-) diff --git a/common/domain/failover_watcher.go b/common/domain/failover_watcher.go index 25a9965e989..e93d5b3e569 100644 --- a/common/domain/failover_watcher.go +++ b/common/domain/failover_watcher.go @@ -119,7 +119,7 @@ func (p *failoverWatcherImpl) Stop() { func (p *failoverWatcherImpl) refreshDomainLoop() { - timer := time.NewTimer(backoff.JitDuration( + timer := p.timeSource.NewTimer(backoff.JitDuration( p.refreshInterval(), p.refreshJitter(), )) @@ -129,7 +129,7 @@ func (p *failoverWatcherImpl) refreshDomainLoop() { select { case <-p.shutdownChan: return - case <-timer.C: + case <-timer.Chan(): domains := p.domainCache.GetAllDomain() for _, domain := range domains { p.handleFailoverTimeout(domain) diff --git a/common/domain/failover_watcher_test.go b/common/domain/failover_watcher_test.go index 6239e8fd5bd..3aadbdb7562 100644 --- a/common/domain/failover_watcher_test.go +++ b/common/domain/failover_watcher_test.go @@ -21,6 +21,7 @@ package domain import ( + "errors" "log" "os" "testing" @@ -76,7 +77,7 @@ func (s *failoverWatcherSuite) SetupTest() { s.controller = gomock.NewController(s.T()) s.mockDomainCache = cache.NewMockDomainCache(s.controller) - s.timeSource = clock.NewRealTimeSource() + s.timeSource = clock.NewMockedTimeSource() s.mockMetadataMgr = &mocks.MetadataManager{} s.mockMetadataMgr.On("GetMetadata", mock.Anything).Return(&persistence.GetMetadataResponse{ @@ -243,3 +244,77 @@ func (s *failoverWatcherSuite) TestHandleFailoverTimeout() { ) s.watcher.handleFailoverTimeout(domainEntry) } + +func (s *failoverWatcherSuite) TestStart() { + s.Assertions.Equal(common.DaemonStatusInitialized, s.watcher.status) + s.watcher.Start() + s.Assertions.Equal(common.DaemonStatusStarted, s.watcher.status) + + // Verify that calling Start again does not change the status + s.watcher.Start() + s.Assertions.Equal(common.DaemonStatusStarted, s.watcher.status) + s.watcher.Stop() +} + +func (s *failoverWatcherSuite) TestIsUpdateDomainRetryable() { + testCases := []struct { + name string + inputErr error + wantRetry bool + }{ + {"nil error", nil, true}, + {"non-nil error", errors.New("some error"), true}, + } + + for _, tc := range testCases { + s.Run(tc.name, func() { + retry := isUpdateDomainRetryable(tc.inputErr) + s.Equal(tc.wantRetry, retry) + }) + } +} + +func (s *failoverWatcherSuite) TestRefreshDomainLoop() { + + domainName := "testDomain" + domainID := uuid.New() + failoverEndTime := common.Int64Ptr(time.Now().Add(-time.Hour).UnixNano()) // 1 hour in the past + mockTimeSource, _ := s.timeSource.(clock.MockedTimeSource) + + domainInfo := &persistence.DomainInfo{ID: domainID, Name: domainName} + domainConfig := &persistence.DomainConfig{Retention: 1, EmitMetric: true} + replicationConfig := &persistence.DomainReplicationConfig{ActiveClusterName: "active", Clusters: []*persistence.ClusterReplicationConfig{{ClusterName: "active"}}} + domainEntry := cache.NewDomainCacheEntryForTest(domainInfo, domainConfig, true, replicationConfig, 1, failoverEndTime) + + domainsMap := map[string]*cache.DomainCacheEntry{domainID: domainEntry} + s.mockDomainCache.EXPECT().GetAllDomain().Return(domainsMap).AnyTimes() + + s.mockMetadataMgr.On("GetMetadata", mock.Anything).Return(&persistence.GetMetadataResponse{NotificationVersion: 1}, nil).Maybe() + + s.mockMetadataMgr.On("GetDomain", mock.Anything, mock.AnythingOfType("*persistence.GetDomainRequest")).Return(&persistence.GetDomainResponse{ + Info: domainInfo, + Config: domainConfig, + ReplicationConfig: replicationConfig, + IsGlobalDomain: true, + ConfigVersion: 1, + FailoverVersion: 1, + FailoverNotificationVersion: 1, + FailoverEndTime: failoverEndTime, + NotificationVersion: 1, + }, nil).Once() + + s.mockMetadataMgr.On("UpdateDomain", mock.Anything, mock.Anything).Return(nil).Once() + + s.watcher.Start() + + // Delay to allow loop to start + time.Sleep(1 * time.Second) + mockTimeSource.Advance(12 * time.Second) + // Now stop the watcher, which should trigger the shutdown case in refreshDomainLoop + s.watcher.Stop() + + // Enough time for shutdown process to complete + time.Sleep(1 * time.Second) + + s.mockMetadataMgr.AssertExpectations(s.T()) +} From cf0f9a59f0c70ba3a3932cffa0fd3524212f549a Mon Sep 17 00:00:00 2001 From: Zijian Date: Thu, 4 Apr 2024 16:31:34 -0700 Subject: [PATCH 5/6] Revert codecov change (#5866) --- codecov.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/codecov.yml b/codecov.yml index 911650aa592..ec0a45dae55 100644 --- a/codecov.yml +++ b/codecov.yml @@ -19,6 +19,9 @@ coverage: if_ci_failed: ignore # require the CI to pass before setting the status patch: default: + target: 85% # specify the target coverage for each commit status + # option: "auto" (compare against parent commit or pull request base) + # option: "X%" a static target percentage to hit threshold: 0% # allow the coverage drop by x% before marking as failure comment: layout: "header, files, footer" From 9af0e32dd88b7a2e308db81d0b09e13a1b252ba8 Mon Sep 17 00:00:00 2001 From: agautam478 <72432016+agautam478@users.noreply.github.com> Date: Thu, 4 Apr 2024 16:56:14 -0700 Subject: [PATCH 6/6] Covered the missed lines in the nosql_execution_utils.go (#5871) --- .../nosql/nosql_execution_store_util_test.go | 257 +++++++++++++++++- 1 file changed, 250 insertions(+), 7 deletions(-) diff --git a/common/persistence/nosql/nosql_execution_store_util_test.go b/common/persistence/nosql/nosql_execution_store_util_test.go index c0b62938055..59180fd2095 100644 --- a/common/persistence/nosql/nosql_execution_store_util_test.go +++ b/common/persistence/nosql/nosql_execution_store_util_test.go @@ -205,7 +205,6 @@ func TestNosqlExecutionStoreUtils(t *testing.T) { for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { mockCtrl := gomock.NewController(t) - defer mockCtrl.Finish() mockDB := nosqlplugin.NewMockDB(mockCtrl) store := newTestNosqlExecutionStore(mockDB, log.NewNoop()) @@ -255,12 +254,109 @@ func TestPrepareTasksForWorkflowTxn(t *testing.T) { assert.Nil(t, tasks) }, }, + { + name: "PrepareTimerTasksForWorkflowTxn - Zero Tasks", + setupStore: func(store *nosqlExecutionStore) ([]*nosqlplugin.TimerTask, error) { + return store.prepareTimerTasksForWorkflowTxn("domainID", "workflowID", "runID", []persistence.Task{}) + }, + validate: func(t *testing.T, tasks []*nosqlplugin.TimerTask, err error) { + assert.NoError(t, err) + assert.Empty(t, tasks) + }, + }, + { + name: "PrepareTimerTasksForWorkflowTxn - ActivityTimeoutTask", + setupStore: func(store *nosqlExecutionStore) ([]*nosqlplugin.TimerTask, error) { + timerTasks := []persistence.Task{ + &persistence.ActivityTimeoutTask{ + TaskData: persistence.TaskData{ + Version: 1, + TaskID: 2, + VisibilityTimestamp: time.Now(), + }, + EventID: 3, + Attempt: 2, + }, + } + return store.prepareTimerTasksForWorkflowTxn("domainID", "workflowID", "runID", timerTasks) + }, + validate: func(t *testing.T, tasks []*nosqlplugin.TimerTask, err error) { + assert.NoError(t, err) + assert.Len(t, tasks, 1) + assert.Equal(t, int64(3), tasks[0].EventID) + assert.Equal(t, int64(2), tasks[0].ScheduleAttempt) + }, + }, + { + name: "PrepareTimerTasksForWorkflowTxn - UserTimerTask", + setupStore: func(store *nosqlExecutionStore) ([]*nosqlplugin.TimerTask, error) { + timerTasks := []persistence.Task{ + &persistence.UserTimerTask{ + TaskData: persistence.TaskData{ + Version: 1, + TaskID: 3, + VisibilityTimestamp: time.Now(), + }, + EventID: 4, + }, + } + return store.prepareTimerTasksForWorkflowTxn("domainID", "workflowID", "runID", timerTasks) + }, + validate: func(t *testing.T, tasks []*nosqlplugin.TimerTask, err error) { + assert.NoError(t, err) + assert.Len(t, tasks, 1) + assert.Equal(t, int64(4), tasks[0].EventID) + }, + }, + { + name: "PrepareTimerTasksForWorkflowTxn - ActivityRetryTimerTask", + setupStore: func(store *nosqlExecutionStore) ([]*nosqlplugin.TimerTask, error) { + timerTasks := []persistence.Task{ + &persistence.ActivityRetryTimerTask{ + TaskData: persistence.TaskData{ + Version: 1, + TaskID: 4, + VisibilityTimestamp: time.Now(), + }, + EventID: 5, + Attempt: 3, + }, + } + return store.prepareTimerTasksForWorkflowTxn("domainID", "workflowID", "runID", timerTasks) + }, + validate: func(t *testing.T, tasks []*nosqlplugin.TimerTask, err error) { + assert.NoError(t, err) + assert.Len(t, tasks, 1) + assert.Equal(t, int64(5), tasks[0].EventID) + assert.Equal(t, int64(3), tasks[0].ScheduleAttempt) + }, + }, + { + name: "PrepareTimerTasksForWorkflowTxn - WorkflowBackoffTimerTask", + setupStore: func(store *nosqlExecutionStore) ([]*nosqlplugin.TimerTask, error) { + timerTasks := []persistence.Task{ + &persistence.WorkflowBackoffTimerTask{ + TaskData: persistence.TaskData{ + Version: 1, + TaskID: 5, + VisibilityTimestamp: time.Now(), + }, + EventID: 6, + }, + } + return store.prepareTimerTasksForWorkflowTxn("domainID", "workflowID", "runID", timerTasks) + }, + validate: func(t *testing.T, tasks []*nosqlplugin.TimerTask, err error) { + assert.NoError(t, err) + assert.Len(t, tasks, 1) + assert.Equal(t, int64(6), tasks[0].EventID) + }, + }, } for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { mockCtrl := gomock.NewController(t) - defer mockCtrl.Finish() mockDB := nosqlplugin.NewMockDB(mockCtrl) store := newTestNosqlExecutionStore(mockDB, log.NewNoop()) @@ -273,7 +369,6 @@ func TestPrepareTasksForWorkflowTxn(t *testing.T) { func TestPrepareReplicationTasksForWorkflowTxn(t *testing.T) { mockCtrl := gomock.NewController(t) - defer mockCtrl.Finish() mockDB := nosqlplugin.NewMockDB(mockCtrl) store := newTestNosqlExecutionStore(mockDB, log.NewNoop()) @@ -316,6 +411,52 @@ func TestPrepareReplicationTasksForWorkflowTxn(t *testing.T) { assert.Nil(t, tasks) }, }, + { + name: "PrepareReplicationTasksForWorkflowTxn - SyncActivityTask", + setupStore: func(store *nosqlExecutionStore) ([]*nosqlplugin.ReplicationTask, error) { + replicationTasks := []persistence.Task{ + &persistence.SyncActivityTask{ + TaskData: persistence.TaskData{ + Version: 2, + VisibilityTimestamp: time.Now(), + TaskID: 2, + }, + ScheduledID: 123, + }, + } + return store.prepareReplicationTasksForWorkflowTxn("domainID", "workflowID", "runID", replicationTasks) + }, + validate: func(t *testing.T, tasks []*nosqlplugin.ReplicationTask, err error) { + assert.NoError(t, err) + assert.Len(t, tasks, 1) + task := tasks[0] + assert.Equal(t, persistence.ReplicationTaskTypeSyncActivity, task.TaskType) + assert.Equal(t, int64(123), task.ScheduledID) + }, + }, + { + name: "PrepareReplicationTasksForWorkflowTxn - FailoverMarkerTask", + setupStore: func(store *nosqlExecutionStore) ([]*nosqlplugin.ReplicationTask, error) { + replicationTasks := []persistence.Task{ + &persistence.FailoverMarkerTask{ + TaskData: persistence.TaskData{ + Version: 3, + VisibilityTimestamp: time.Now(), + TaskID: 3, + }, + DomainID: "domainID", + }, + } + return store.prepareReplicationTasksForWorkflowTxn("domainID", "workflowID", "runID", replicationTasks) + }, + validate: func(t *testing.T, tasks []*nosqlplugin.ReplicationTask, err error) { + assert.NoError(t, err) + assert.Len(t, tasks, 1) + task := tasks[0] + assert.Equal(t, persistence.ReplicationTaskTypeFailoverMarker, task.TaskType) + assert.Equal(t, "domainID", task.DomainID) + }, + }, } for _, tc := range testCases { @@ -328,7 +469,6 @@ func TestPrepareReplicationTasksForWorkflowTxn(t *testing.T) { func TestPrepareCrossClusterTasksForWorkflowTxn(t *testing.T) { mockCtrl := gomock.NewController(t) - defer mockCtrl.Finish() mockDB := nosqlplugin.NewMockDB(mockCtrl) store := newTestNosqlExecutionStore(mockDB, log.NewNoop()) @@ -369,6 +509,112 @@ func TestPrepareCrossClusterTasksForWorkflowTxn(t *testing.T) { assert.Nil(t, tasks) }, }, + { + name: "CrossClusterCancelExecutionTask - Success", + setupStore: func(store *nosqlExecutionStore) ([]*nosqlplugin.CrossClusterTask, error) { + crossClusterTasks := []persistence.Task{ + &persistence.CrossClusterCancelExecutionTask{ + CancelExecutionTask: persistence.CancelExecutionTask{ + TaskData: persistence.TaskData{ + TaskID: 1001, + }, + TargetDomainID: "targetDomainID-cancel", + TargetWorkflowID: "targetWorkflowID-cancel", + TargetRunID: "targetRunID-cancel", + TargetChildWorkflowOnly: true, + InitiatedID: 1001, + }, + TargetCluster: "targetCluster-cancel", + }, + } + return store.prepareCrossClusterTasksForWorkflowTxn("domainID", "workflowID", "runID", crossClusterTasks) + }, + validate: func(t *testing.T, tasks []*nosqlplugin.CrossClusterTask, err error) { + assert.NoError(t, err) + assert.Len(t, tasks, 1) + task := tasks[0] + assert.Equal(t, "targetCluster-cancel", task.TargetCluster) + assert.Equal(t, int64(1001), task.TransferTask.ScheduleID) + }, + }, + { + name: "CrossClusterSignalExecutionTask - Success", + setupStore: func(store *nosqlExecutionStore) ([]*nosqlplugin.CrossClusterTask, error) { + crossClusterTasks := []persistence.Task{ + &persistence.CrossClusterSignalExecutionTask{ + SignalExecutionTask: persistence.SignalExecutionTask{ + TaskData: persistence.TaskData{ + TaskID: 1002, + }, + TargetDomainID: "targetDomainID-signal", + TargetWorkflowID: "targetWorkflowID-signal", + TargetRunID: "targetRunID-signal", + TargetChildWorkflowOnly: true, + InitiatedID: 1002, + }, + TargetCluster: "targetCluster-signal", + }, + } + return store.prepareCrossClusterTasksForWorkflowTxn("domainID", "workflowID", "runID", crossClusterTasks) + }, + validate: func(t *testing.T, tasks []*nosqlplugin.CrossClusterTask, err error) { + assert.NoError(t, err) + assert.Len(t, tasks, 1) + task := tasks[0] + assert.Equal(t, "targetCluster-signal", task.TargetCluster) + assert.Equal(t, int64(1002), task.TransferTask.ScheduleID) + }, + }, + { + name: "CrossClusterRecordChildExecutionCompletedTask - Success", + setupStore: func(store *nosqlExecutionStore) ([]*nosqlplugin.CrossClusterTask, error) { + crossClusterTasks := []persistence.Task{ + &persistence.CrossClusterRecordChildExecutionCompletedTask{ + RecordChildExecutionCompletedTask: persistence.RecordChildExecutionCompletedTask{ + TaskData: persistence.TaskData{ + TaskID: 1003, + }, + TargetDomainID: "targetDomainID-record", + TargetWorkflowID: "targetWorkflowID-record", + TargetRunID: "targetRunID-record", + }, + TargetCluster: "targetCluster-record", + }, + } + return store.prepareCrossClusterTasksForWorkflowTxn("domainID", "workflowID", "runID", crossClusterTasks) + }, + validate: func(t *testing.T, tasks []*nosqlplugin.CrossClusterTask, err error) { + assert.NoError(t, err) + assert.Len(t, tasks, 1) + task := tasks[0] + assert.Equal(t, "targetCluster-record", task.TargetCluster) + }, + }, + { + name: "CrossClusterApplyParentClosePolicyTask - Success", + setupStore: func(store *nosqlExecutionStore) ([]*nosqlplugin.CrossClusterTask, error) { + crossClusterTasks := []persistence.Task{ + &persistence.CrossClusterApplyParentClosePolicyTask{ + ApplyParentClosePolicyTask: persistence.ApplyParentClosePolicyTask{ + TaskData: persistence.TaskData{ + TaskID: 1004, + }, + TargetDomainIDs: map[string]struct{}{"targetDomainID-apply-close": {}}, + }, + TargetCluster: "targetCluster-apply-close", + }, + } + return store.prepareCrossClusterTasksForWorkflowTxn("domainID", "workflowID", "runID", crossClusterTasks) + }, + validate: func(t *testing.T, tasks []*nosqlplugin.CrossClusterTask, err error) { + assert.NoError(t, err) + assert.Len(t, tasks, 1) + task := tasks[0] + assert.Equal(t, "targetCluster-apply-close", task.TargetCluster) + _, exists := task.TransferTask.TargetDomainIDs["targetDomainID-apply-close"] + assert.True(t, exists) + }, + }, } for _, tc := range testCases { @@ -381,7 +627,6 @@ func TestPrepareCrossClusterTasksForWorkflowTxn(t *testing.T) { func TestPrepareNoSQLTasksForWorkflowTxn(t *testing.T) { mockCtrl := gomock.NewController(t) - defer mockCtrl.Finish() mockDB := nosqlplugin.NewMockDB(mockCtrl) store := newTestNosqlExecutionStore(mockDB, log.NewNoop()) @@ -465,7 +710,6 @@ func TestPrepareTransferTasksForWorkflowTxn(t *testing.T) { for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { mockCtrl := gomock.NewController(t) - defer mockCtrl.Finish() mockDB := nosqlplugin.NewMockDB(mockCtrl) store := newTestNosqlExecutionStore(mockDB, log.NewNoop()) @@ -888,7 +1132,6 @@ func TestNosqlExecutionStoreUtilsExtended(t *testing.T) { for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { mockCtrl := gomock.NewController(t) - defer mockCtrl.Finish() mockDB := nosqlplugin.NewMockDB(mockCtrl) store := newTestNosqlExecutionStore(mockDB, log.NewNoop())