From 3c0951f20f01f25dd6b699f8bbe6e79c319500dd Mon Sep 17 00:00:00 2001 From: Bowen Xiao Date: Thu, 4 Apr 2024 16:57:21 -0700 Subject: [PATCH 1/2] Add unit test for Write-functions in triple manager; rename variables in pinot dual manager --- .../pinot_visibility_dual_manager_test.go | 48 +- .../pinot_visibility_triple_manager_test.go | 687 ++++++++++++++++++ 2 files changed, 711 insertions(+), 24 deletions(-) diff --git a/common/persistence/pinot_visibility_dual_manager_test.go b/common/persistence/pinot_visibility_dual_manager_test.go index fbc8f860a08..385696da8b4 100644 --- a/common/persistence/pinot_visibility_dual_manager_test.go +++ b/common/persistence/pinot_visibility_dual_manager_test.go @@ -78,7 +78,7 @@ func TestPinotDualManagerClose(t *testing.T) { mockDBVisibilityManager.EXPECT().Close().Return().Times(1) }, }, - "Case1-2: success case with ES visibility is not nil": { + "Case1-2: success case with Pinot visibility is not nil": { mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { mockPinotVisibilityManager.EXPECT().Close().Return().Times(1) @@ -118,7 +118,7 @@ func TestPinotDualManagerGetName(t *testing.T) { }, }, - "Case1-2: success case with ES visibility is not nil": { + "Case1-2: success case with Pinot visibility is not nil": { mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { mockPinotVisibilityManager.EXPECT().GetName().Return(testTableName).Times(1) @@ -166,7 +166,7 @@ func TestPinotDualRecordWorkflowExecutionStarted(t *testing.T) { advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeOff), expectedError: nil, }, - "Case1-2: success case with ES visibility is not nil": { + "Case1-2: success case with Pinot visibility is not nil": { request: request, mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { @@ -226,7 +226,7 @@ func TestPinotDualRecordWorkflowExecutionClosed(t *testing.T) { }, expectedError: fmt.Errorf("error"), }, - "Case0-2: error case with ES has errors in dual mode": { + "Case0-2: error case with Pinot has errors in dual mode": { context: context.Background(), request: request, mockDBVisibilityManager: NewMockVisibilityManager(ctrl), @@ -250,7 +250,7 @@ func TestPinotDualRecordWorkflowExecutionClosed(t *testing.T) { advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeOff), expectedError: nil, }, - "Case1-2: success case with ES visibility is not nil": { + "Case1-2: success case with Pinot visibility is not nil": { context: context.Background(), request: request, mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), @@ -283,7 +283,7 @@ func TestPinotDualRecordWorkflowExecutionClosed(t *testing.T) { }, advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeOff), }, - "Case2-2: choose ES visibility manager when it is nil": { + "Case2-2: choose Pinot visibility manager when it is nil": { context: context.Background(), request: request, mockDBVisibilityManager: NewMockVisibilityManager(ctrl), @@ -292,7 +292,7 @@ func TestPinotDualRecordWorkflowExecutionClosed(t *testing.T) { }, advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeOn), }, - "Case2-3: choose both when ES is nil": { + "Case2-3: choose both when Pinot is nil": { context: context.Background(), request: request, mockDBVisibilityManager: NewMockVisibilityManager(ctrl), @@ -310,7 +310,7 @@ func TestPinotDualRecordWorkflowExecutionClosed(t *testing.T) { }, advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeDual), }, - "Case3-1: chooseVisibilityModeForAdmin when ES is nil": { + "Case3-1: chooseVisibilityModeForAdmin when Pinot is nil": { context: context.WithValue(context.Background(), VisibilityAdminDeletionKey("visibilityAdminDelete"), true), request: request, mockDBVisibilityManager: NewMockVisibilityManager(ctrl), @@ -396,7 +396,7 @@ func TestPinotDualRecordWorkflowExecutionUninitialized(t *testing.T) { advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeOff), expectedError: nil, }, - "Case1-2: success case with ES visibility is not nil": { + "Case1-2: success case with Pinot visibility is not nil": { request: request, mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { @@ -451,7 +451,7 @@ func TestPinotDualUpsertWorkflowExecution(t *testing.T) { advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeOff), expectedError: nil, }, - "Case1-2: success case with ES visibility is not nil": { + "Case1-2: success case with Pinot visibility is not nil": { request: request, mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { @@ -506,7 +506,7 @@ func TestPinotDualDeleteWorkflowExecution(t *testing.T) { advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeOff), expectedError: nil, }, - "Case1-2: success case with ES visibility is not nil": { + "Case1-2: success case with Pinot visibility is not nil": { request: request, mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { @@ -561,7 +561,7 @@ func TestPinotDualDeleteUninitializedWorkflowExecution(t *testing.T) { advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeOff), expectedError: nil, }, - "Case1-2: success case with ES visibility is not nil": { + "Case1-2: success case with Pinot visibility is not nil": { request: request, mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { @@ -618,7 +618,7 @@ func TestPinotDualListOpenWorkflowExecutions(t *testing.T) { readModeIsFromES: dynamicconfig.GetBoolPropertyFnFilteredByDomain(true), expectedError: nil, }, - "Case1-2: success case with ES visibility is not nil": { + "Case1-2: success case with Pinot visibility is not nil": { request: request, mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { @@ -675,7 +675,7 @@ func TestPinotDualListClosedWorkflowExecutions(t *testing.T) { readModeIsFromES: dynamicconfig.GetBoolPropertyFnFilteredByDomain(true), expectedError: nil, }, - "Case1-2: success case with ES visibility is not nil": { + "Case1-2: success case with Pinot visibility is not nil": { request: request, mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { @@ -693,7 +693,7 @@ func TestPinotDualListClosedWorkflowExecutions(t *testing.T) { readModeIsFromES: dynamicconfig.GetBoolPropertyFnFilteredByDomain(false), expectedError: nil, }, - "Case2-2: success case with ES visibility is not nil and read mod is false": { + "Case2-2: success case with Pinot visibility is not nil and read mod is false": { request: request, mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { @@ -752,7 +752,7 @@ func TestPinotDualListOpenWorkflowExecutionsByType(t *testing.T) { readModeIsFromES: dynamicconfig.GetBoolPropertyFnFilteredByDomain(true), expectedError: nil, }, - "Case1-2: success case with ES visibility is not nil": { + "Case1-2: success case with Pinot visibility is not nil": { request: request, mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { @@ -811,7 +811,7 @@ func TestPinotDualListClosedWorkflowExecutionsByType(t *testing.T) { readModeIsFromES: dynamicconfig.GetBoolPropertyFnFilteredByDomain(true), expectedError: nil, }, - "Case1-2: success case with ES visibility is not nil": { + "Case1-2: success case with Pinot visibility is not nil": { request: request, mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { @@ -870,7 +870,7 @@ func TestPinotDualListOpenWorkflowExecutionsByWorkflowID(t *testing.T) { readModeIsFromES: dynamicconfig.GetBoolPropertyFnFilteredByDomain(true), expectedError: nil, }, - "Case1-2: success case with ES visibility is not nil": { + "Case1-2: success case with Pinot visibility is not nil": { request: request, mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { @@ -929,7 +929,7 @@ func TestPinotDualListClosedWorkflowExecutionsByWorkflowID(t *testing.T) { readModeIsFromES: dynamicconfig.GetBoolPropertyFnFilteredByDomain(true), expectedError: nil, }, - "Case1-2: success case with ES visibility is not nil": { + "Case1-2: success case with Pinot visibility is not nil": { request: request, mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { @@ -988,7 +988,7 @@ func TestPinotDualListClosedWorkflowExecutionsByStatus(t *testing.T) { readModeIsFromES: dynamicconfig.GetBoolPropertyFnFilteredByDomain(true), expectedError: nil, }, - "Case1-2: success case with ES visibility is not nil": { + "Case1-2: success case with Pinot visibility is not nil": { request: request, mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { @@ -1045,7 +1045,7 @@ func TestPinotDualGetClosedWorkflowExecution(t *testing.T) { readModeIsFromES: dynamicconfig.GetBoolPropertyFnFilteredByDomain(true), expectedError: nil, }, - "Case1-2: success case with ES visibility is not nil": { + "Case1-2: success case with Pinot visibility is not nil": { request: request, mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { @@ -1102,7 +1102,7 @@ func TestPinotDualListWorkflowExecutions(t *testing.T) { readModeIsFromES: dynamicconfig.GetBoolPropertyFnFilteredByDomain(true), expectedError: nil, }, - "Case1-2: success case with ES visibility is not nil": { + "Case1-2: success case with Pinot visibility is not nil": { request: request, mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { @@ -1159,7 +1159,7 @@ func TestPinotDualScanWorkflowExecutions(t *testing.T) { readModeIsFromES: dynamicconfig.GetBoolPropertyFnFilteredByDomain(true), expectedError: nil, }, - "Case1-2: success case with ES visibility is not nil": { + "Case1-2: success case with Pinot visibility is not nil": { request: request, mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { @@ -1215,7 +1215,7 @@ func TestPinotDualCountWorkflowExecutions(t *testing.T) { readModeIsFromES: dynamicconfig.GetBoolPropertyFnFilteredByDomain(true), expectedError: nil, }, - "Case1-2: success case with ES visibility is not nil": { + "Case1-2: success case with Pinot visibility is not nil": { request: request, mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { diff --git a/common/persistence/pinot_visibility_triple_manager_test.go b/common/persistence/pinot_visibility_triple_manager_test.go index ddebcda96ce..d4427cea1f4 100644 --- a/common/persistence/pinot_visibility_triple_manager_test.go +++ b/common/persistence/pinot_visibility_triple_manager_test.go @@ -23,6 +23,10 @@ package persistence import ( + "context" + "fmt" + "github.com/uber/cadence/common" + "github.com/uber/cadence/common/dynamicconfig" "testing" "github.com/golang/mock/gomock" @@ -170,6 +174,689 @@ func TestPinotTripleManagerGetName(t *testing.T) { } } +func TestPinotTripleRecordWorkflowExecutionStarted(t *testing.T) { + request := &RecordWorkflowExecutionStartedRequest{} + + // put this outside because need to use it as an input of the table tests + ctrl := gomock.NewController(t) + + tests := map[string]struct { + request *RecordWorkflowExecutionStartedRequest + mockDBVisibilityManager VisibilityManager + mockESVisibilityManager VisibilityManager + mockPinotVisibilityManager VisibilityManager + mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) + mockPinotVisibilityManagerAccordance func(mockPinotVisibilityManager *MockVisibilityManager) + mockESVisibilityManagerAccordance func(mockESVisibilityManager *MockVisibilityManager) + advancedVisibilityWritingMode dynamicconfig.StringPropertyFn + expectedError error + }{ + "Case1-1: success case with DB visibility is not nil": { + request: request, + mockDBVisibilityManager: NewMockVisibilityManager(ctrl), + mockDBVisibilityManagerAccordance: func(mockDBVisibilityManager *MockVisibilityManager) { + mockDBVisibilityManager.EXPECT().RecordWorkflowExecutionStarted(gomock.Any(), gomock.Any()).Return(nil).Times(1) + }, + advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeOff), + 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) + }, + advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeOn), + expectedError: nil, + }, + "Case1-3: success case with pinot visibility is not nil": { + 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), + }, + } + 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, + test.advancedVisibilityWritingMode, nil, log.NewNoop()) + + err := visibilityManager.RecordWorkflowExecutionStarted(context.Background(), test.request) + if test.expectedError != nil { + assert.Error(t, err) + } else { + assert.NoError(t, err) + } + }) + } +} + +func TestPinotTripleRecordWorkflowExecutionClosed(t *testing.T) { + request := &RecordWorkflowExecutionClosedRequest{} + + // put this outside because need to use it as an input of the table tests + ctrl := gomock.NewController(t) + + tests := map[string]struct { + context context.Context + request *RecordWorkflowExecutionClosedRequest + mockDBVisibilityManager VisibilityManager + mockESVisibilityManager VisibilityManager + mockPinotVisibilityManager VisibilityManager + mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) + mockPinotVisibilityManagerAccordance func(mockPinotVisibilityManager *MockVisibilityManager) + mockESVisibilityManagerAccordance func(mockESVisibilityManager *MockVisibilityManager) + advancedVisibilityWritingMode dynamicconfig.StringPropertyFn + expectedError error + }{ + "Case0-1: error case with advancedVisibilityWritingMode is nil": { + context: context.Background(), + request: request, + mockDBVisibilityManager: NewMockVisibilityManager(ctrl), + mockDBVisibilityManagerAccordance: func(mockDBVisibilityManager *MockVisibilityManager) { + mockDBVisibilityManager.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"), + }, + "Case0-2: error case with ES has errors in dual mode": { + context: context.Background(), + request: request, + mockDBVisibilityManager: NewMockVisibilityManager(ctrl), + 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"), + }, + "Case0-3: error case with ES has errors in On mode with Pinot is not nil": { + context: context.Background(), + request: request, + 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.AdvancedVisibilityWritingModeOn), + expectedError: fmt.Errorf("error"), + }, + "Case0-4: error case with Pinot has errors in On mode": { + context: context.Background(), + request: request, + 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(fmt.Errorf("error")).AnyTimes() + }, + advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeOn), + expectedError: fmt.Errorf("error"), + }, + "Case0-5: error case with Pinot has errors in Triple mode": { + context: context.Background(), + request: request, + 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(fmt.Errorf("error")).AnyTimes() + }, + advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeTriple), + expectedError: fmt.Errorf("error"), + }, + "Case0-6: error case with ES has errors in Triple mode": { + context: context.Background(), + request: request, + 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(nil).AnyTimes() + }, + advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeTriple), + expectedError: fmt.Errorf("error"), + }, + "Case1-1: success case with DB visibility is not nil": { + context: context.Background(), + request: request, + mockDBVisibilityManager: NewMockVisibilityManager(ctrl), + mockDBVisibilityManagerAccordance: func(mockDBVisibilityManager *MockVisibilityManager) { + mockDBVisibilityManager.EXPECT().RecordWorkflowExecutionClosed(gomock.Any(), gomock.Any()).Return(nil).Times(1) + }, + advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeOff), + 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) + }, + advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeOn), + expectedError: nil, + }, + "Case1-3: success case with pinot visibility is not nil": { + 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), + }, + "Case1-4: success case with dual manager": { + context: context.Background(), + request: request, + mockDBVisibilityManager: NewMockVisibilityManager(ctrl), + mockDBVisibilityManagerAccordance: func(mockDBVisibilityManager *MockVisibilityManager) { + mockDBVisibilityManager.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, + }, + "Case1-5: success case with dual manager when ES and Pinot are not nil": { + context: context.Background(), + request: request, + mockDBVisibilityManager: NewMockVisibilityManager(ctrl), + mockDBVisibilityManagerAccordance: func(mockDBVisibilityManager *MockVisibilityManager) { + mockDBVisibilityManager.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) + }, + mockESVisibilityManager: NewMockVisibilityManager(ctrl), + mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { + mockESVisibilityManager.EXPECT().RecordWorkflowExecutionClosed(gomock.Any(), gomock.Any()).Return(nil).AnyTimes() + }, + advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeDual), + expectedError: nil, + }, + "Case1-6: success case with triple write when ES and Pinot are not nil": { + context: context.Background(), + request: request, + mockDBVisibilityManager: NewMockVisibilityManager(ctrl), + mockDBVisibilityManagerAccordance: func(mockDBVisibilityManager *MockVisibilityManager) { + mockDBVisibilityManager.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) + }, + mockESVisibilityManager: NewMockVisibilityManager(ctrl), + mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { + mockESVisibilityManager.EXPECT().RecordWorkflowExecutionClosed(gomock.Any(), gomock.Any()).Return(nil).AnyTimes() + }, + advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeTriple), + expectedError: nil, + }, + "Case1-7: success case with triple write when ES and Pinot are nil": { + context: context.Background(), + request: request, + mockDBVisibilityManager: NewMockVisibilityManager(ctrl), + mockDBVisibilityManagerAccordance: func(mockDBVisibilityManager *MockVisibilityManager) { + mockDBVisibilityManager.EXPECT().RecordWorkflowExecutionClosed(gomock.Any(), gomock.Any()).Return(nil).Times(1) + }, + advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeTriple), + expectedError: nil, + }, + "Case1-8: success case with triple write when db is nil": { + context: context.Background(), + request: request, + mockPinotVisibilityManager: NewMockVisibilityManager(ctrl), + mockPinotVisibilityManagerAccordance: func(mockPinotVisibilityManager *MockVisibilityManager) { + mockPinotVisibilityManager.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).AnyTimes() + }, + advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeTriple), + expectedError: nil, + }, + "Case2-1: choose DB visibility manager when it is nil": { + 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), + }, + "Case2-2: choose ES visibility manager when it is nil": { + context: context.Background(), + request: request, + mockDBVisibilityManager: NewMockVisibilityManager(ctrl), + mockDBVisibilityManagerAccordance: func(mockDBVisibilityManager *MockVisibilityManager) { + mockDBVisibilityManager.EXPECT().RecordWorkflowExecutionClosed(gomock.Any(), gomock.Any()).Return(nil).Times(1) + }, + advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeOn), + }, + "Case2-3: choose both when ES is nil": { + context: context.Background(), + request: request, + mockDBVisibilityManager: NewMockVisibilityManager(ctrl), + mockDBVisibilityManagerAccordance: func(mockDBVisibilityManager *MockVisibilityManager) { + mockDBVisibilityManager.EXPECT().RecordWorkflowExecutionClosed(gomock.Any(), gomock.Any()).Return(nil).Times(1) + }, + advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeDual), + }, + "Case2-4: choose both when DB is nil": { + 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), + }, + "Case3-1: chooseVisibilityModeForAdmin when ES is nil": { + context: context.WithValue(context.Background(), VisibilityAdminDeletionKey("visibilityAdminDelete"), true), + request: request, + mockDBVisibilityManager: NewMockVisibilityManager(ctrl), + mockDBVisibilityManagerAccordance: func(mockDBVisibilityManager *MockVisibilityManager) { + mockDBVisibilityManager.EXPECT().RecordWorkflowExecutionClosed(gomock.Any(), gomock.Any()).Return(nil).Times(1) + }, + }, + "Case3-2: chooseVisibilityModeForAdmin when DB is nil": { + 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": { + context: context.WithValue(context.Background(), VisibilityAdminDeletionKey("visibilityAdminDelete"), true), + request: request, + mockDBVisibilityManager: NewMockVisibilityManager(ctrl), + mockDBVisibilityManagerAccordance: func(mockDBVisibilityManager *MockVisibilityManager) { + mockDBVisibilityManager.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) + }, + }, + "Case3-3: chooseVisibilityModeForAdmin when triple are not nil": { + context: context.WithValue(context.Background(), VisibilityAdminDeletionKey("visibilityAdminDelete"), true), + request: request, + mockDBVisibilityManager: NewMockVisibilityManager(ctrl), + mockDBVisibilityManagerAccordance: func(mockDBVisibilityManager *MockVisibilityManager) { + mockDBVisibilityManager.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) + }, + mockESVisibilityManager: NewMockVisibilityManager(ctrl), + mockESVisibilityManagerAccordance: func(mockESVisibilityManager *MockVisibilityManager) { + mockESVisibilityManager.EXPECT().RecordWorkflowExecutionClosed(gomock.Any(), gomock.Any()).Return(nil).AnyTimes() + }, + }, + } + 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, + test.advancedVisibilityWritingMode, nil, log.NewNoop()) + + err := visibilityManager.RecordWorkflowExecutionClosed(test.context, test.request) + if test.expectedError != nil { + assert.Error(t, err) + } else { + assert.NoError(t, err) + } + }) + } +} + +// test an edge case +func TestPinotTripleChooseVisibilityModeForAdmin(t *testing.T) { + ctrl := gomock.NewController(t) + dbManager := NewMockVisibilityManager(ctrl) + esManager := NewMockVisibilityManager(ctrl) + pntManager := NewMockVisibilityManager(ctrl) + mgr := NewPinotVisibilityTripleManager(dbManager, pntManager, esManager, nil, nil, + nil, nil, log.NewNoop()) + tripleManager := mgr.(*pinotVisibilityTripleManager) + tripleManager.dbVisibilityManager = nil + tripleManager.pinotVisibilityManager = nil + tripleManager.esVisibilityManager = nil + assert.Equal(t, "INVALID_ADMIN_MODE", tripleManager.chooseVisibilityModeForAdmin()) +} + +func TestPinotTripleRecordWorkflowExecutionUninitialized(t *testing.T) { + request := &RecordWorkflowExecutionUninitializedRequest{} + + // put this outside because need to use it as an input of the table tests + ctrl := gomock.NewController(t) + + tests := map[string]struct { + request *RecordWorkflowExecutionUninitializedRequest + mockDBVisibilityManager VisibilityManager + mockESVisibilityManager VisibilityManager + mockPinotVisibilityManager VisibilityManager + mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) + mockPinotVisibilityManagerAccordance func(mockPinotVisibilityManager *MockVisibilityManager) + mockESVisibilityManagerAccordance func(mockESVisibilityManager *MockVisibilityManager) + advancedVisibilityWritingMode dynamicconfig.StringPropertyFn + expectedError error + }{ + "Case1-1: success case with DB visibility is not nil": { + request: request, + mockDBVisibilityManager: NewMockVisibilityManager(ctrl), + mockDBVisibilityManagerAccordance: func(mockDBVisibilityManager *MockVisibilityManager) { + mockDBVisibilityManager.EXPECT().RecordWorkflowExecutionUninitialized(gomock.Any(), gomock.Any()).Return(nil).Times(1) + }, + advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeOff), + expectedError: nil, + }, + "Case1-2: success case with Pinot visibility is not nil": { + 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, + }, + "Case1-3: 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) + }, + advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeOn), + expectedError: nil, + }, + } + 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, + test.advancedVisibilityWritingMode, nil, log.NewNoop()) + + err := visibilityManager.RecordWorkflowExecutionUninitialized(context.Background(), test.request) + if test.expectedError != nil { + assert.Error(t, err) + } else { + assert.NoError(t, err) + } + }) + } +} + +func TestPinotTripleUpsertWorkflowExecution(t *testing.T) { + request := &UpsertWorkflowExecutionRequest{} + + // put this outside because need to use it as an input of the table tests + ctrl := gomock.NewController(t) + + tests := map[string]struct { + request *UpsertWorkflowExecutionRequest + mockDBVisibilityManager VisibilityManager + mockESVisibilityManager VisibilityManager + mockPinotVisibilityManager VisibilityManager + mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) + mockPinotVisibilityManagerAccordance func(mockPinotVisibilityManager *MockVisibilityManager) + mockESVisibilityManagerAccordance func(mockESVisibilityManager *MockVisibilityManager) + advancedVisibilityWritingMode dynamicconfig.StringPropertyFn + expectedError error + }{ + "Case1-1: success case with DB visibility is not nil": { + request: request, + mockDBVisibilityManager: NewMockVisibilityManager(ctrl), + mockDBVisibilityManagerAccordance: func(mockDBVisibilityManager *MockVisibilityManager) { + mockDBVisibilityManager.EXPECT().UpsertWorkflowExecution(gomock.Any(), gomock.Any()).Return(nil).Times(1) + }, + advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeOff), + expectedError: nil, + }, + "Case1-2: success case with Pinot visibility is not nil": { + 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, + }, + "Case1-3: 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) + }, + advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeOn), + expectedError: nil, + }, + } + 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, + test.advancedVisibilityWritingMode, nil, log.NewNoop()) + + err := visibilityManager.UpsertWorkflowExecution(context.Background(), test.request) + if test.expectedError != nil { + assert.Error(t, err) + } else { + assert.NoError(t, err) + } + }) + } +} + +func TestPinotTripleDeleteWorkflowExecution(t *testing.T) { + request := &VisibilityDeleteWorkflowExecutionRequest{} + + // put this outside because need to use it as an input of the table tests + ctrl := gomock.NewController(t) + + tests := map[string]struct { + request *VisibilityDeleteWorkflowExecutionRequest + mockDBVisibilityManager VisibilityManager + mockESVisibilityManager VisibilityManager + mockPinotVisibilityManager VisibilityManager + mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) + mockPinotVisibilityManagerAccordance func(mockPinotVisibilityManager *MockVisibilityManager) + mockESVisibilityManagerAccordance func(mockESVisibilityManager *MockVisibilityManager) + advancedVisibilityWritingMode dynamicconfig.StringPropertyFn + expectedError error + }{ + "Case1-1: success case with DB visibility is not nil": { + request: request, + mockDBVisibilityManager: NewMockVisibilityManager(ctrl), + mockDBVisibilityManagerAccordance: func(mockDBVisibilityManager *MockVisibilityManager) { + mockDBVisibilityManager.EXPECT().DeleteWorkflowExecution(gomock.Any(), gomock.Any()).Return(nil).Times(1) + }, + advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeOff), + expectedError: nil, + }, + "Case1-2: success case with Pinot visibility is not nil": { + 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, + }, + "Case1-3: 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) + }, + advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeOn), + expectedError: nil, + }, + } + 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, + test.advancedVisibilityWritingMode, nil, log.NewNoop()) + + err := visibilityManager.DeleteWorkflowExecution(context.Background(), test.request) + if test.expectedError != nil { + assert.Error(t, err) + } else { + assert.NoError(t, err) + } + }) + } +} + +func TestPinotTripleDeleteUninitializedWorkflowExecution(t *testing.T) { + request := &VisibilityDeleteWorkflowExecutionRequest{} + + // put this outside because need to use it as an input of the table tests + ctrl := gomock.NewController(t) + + tests := map[string]struct { + request *VisibilityDeleteWorkflowExecutionRequest + mockDBVisibilityManager VisibilityManager + mockESVisibilityManager VisibilityManager + mockPinotVisibilityManager VisibilityManager + mockDBVisibilityManagerAccordance func(mockDBVisibilityManager *MockVisibilityManager) + mockPinotVisibilityManagerAccordance func(mockPinotVisibilityManager *MockVisibilityManager) + mockESVisibilityManagerAccordance func(mockESVisibilityManager *MockVisibilityManager) + advancedVisibilityWritingMode dynamicconfig.StringPropertyFn + expectedError error + }{ + "Case1-1: success case with DB visibility is not nil": { + request: request, + mockDBVisibilityManager: NewMockVisibilityManager(ctrl), + mockDBVisibilityManagerAccordance: func(mockDBVisibilityManager *MockVisibilityManager) { + mockDBVisibilityManager.EXPECT().DeleteUninitializedWorkflowExecution(gomock.Any(), gomock.Any()).Return(nil).Times(1) + }, + advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeOff), + expectedError: nil, + }, + "Case1-2: success case with Pinot visibility is not nil": { + 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, + }, + "Case1-3: 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) + }, + advancedVisibilityWritingMode: dynamicconfig.GetStringPropertyFn(common.AdvancedVisibilityWritingModeOn), + expectedError: nil, + }, + } + 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, + test.advancedVisibilityWritingMode, nil, log.NewNoop()) + + err := visibilityManager.DeleteUninitializedWorkflowExecution(context.Background(), test.request) + if test.expectedError != nil { + assert.Error(t, err) + } else { + assert.NoError(t, err) + } + }) + } +} + func TestFilterAttrPrefix(t *testing.T) { tests := map[string]struct { expectedInput string From 3c7809370e1d3585d6c892fab589ea1acb0a4eae Mon Sep 17 00:00:00 2001 From: Bowen Xiao Date: Thu, 4 Apr 2024 17:30:40 -0700 Subject: [PATCH 2/2] reformat --- common/persistence/pinot_visibility_triple_manager_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/common/persistence/pinot_visibility_triple_manager_test.go b/common/persistence/pinot_visibility_triple_manager_test.go index d4427cea1f4..b7b6b2e3c28 100644 --- a/common/persistence/pinot_visibility_triple_manager_test.go +++ b/common/persistence/pinot_visibility_triple_manager_test.go @@ -25,13 +25,13 @@ package persistence import ( "context" "fmt" - "github.com/uber/cadence/common" - "github.com/uber/cadence/common/dynamicconfig" "testing" "github.com/golang/mock/gomock" "github.com/stretchr/testify/assert" + "github.com/uber/cadence/common" + "github.com/uber/cadence/common/dynamicconfig" "github.com/uber/cadence/common/log" )