From 95a0c1eee417e3e452db7dcf77dc8ab623a6ab58 Mon Sep 17 00:00:00 2001 From: sankari gopalakrishnan Date: Tue, 30 Apr 2024 14:09:30 +0200 Subject: [PATCH] Adding unit tests for client/matching/client.go (#5959) * Adding unit tests for client/matching/client.go * lint --- client/matching/client_test.go | 521 ++++++++++++++++++ client/matching/loadbalancer_mock.go | 86 +++ .../{peerResolver.go => peer_resolver.go} | 18 +- client/matching/peer_resolver_mock.go | 101 ++++ ...Resolver_test.go => peer_resolver_test.go} | 0 5 files changed, 721 insertions(+), 5 deletions(-) create mode 100644 client/matching/client_test.go create mode 100644 client/matching/loadbalancer_mock.go rename client/matching/{peerResolver.go => peer_resolver.go} (85%) create mode 100644 client/matching/peer_resolver_mock.go rename client/matching/{peerResolver_test.go => peer_resolver_test.go} (100%) diff --git a/client/matching/client_test.go b/client/matching/client_test.go new file mode 100644 index 00000000000..383a430c9b9 --- /dev/null +++ b/client/matching/client_test.go @@ -0,0 +1,521 @@ +// 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 matching + +import ( + "context" + "testing" + + "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" + "go.uber.org/yarpc" + + "github.com/uber/cadence/common/persistence" + "github.com/uber/cadence/common/types" +) + +const ( + _testDomainUUID = "123" + _testDomain = "test-domain" + _testTaskList = "test-tasklist" + _testPartition = "test-partition" +) + +func TestNewClient(t *testing.T) { + ctrl := gomock.NewController(t) + client := NewMockClient(ctrl) + peerResolver := NewMockPeerResolver(ctrl) + loadbalancer := NewMockLoadBalancer(ctrl) + + c := NewClient(client, peerResolver, loadbalancer) + assert.NotNil(t, c) +} + +func TestClient_withoutResponse(t *testing.T) { + tests := []struct { + name string + op func(Client) error + mock func(*MockPeerResolver, *MockLoadBalancer, *MockClient) + wantError bool + }{ + { + name: "AddActivityTask", + op: func(c Client) error { + return c.AddActivityTask(context.Background(), testAddActivityTaskRequest()) + }, + mock: func(p *MockPeerResolver, balancer *MockLoadBalancer, c *MockClient) { + balancer.EXPECT().PickWritePartition(_testDomainUUID, types.TaskList{Name: _testTaskList}, persistence.TaskListTypeActivity, "").Return(_testPartition) + p.EXPECT().FromTaskList(_testPartition).Return("peer0", nil) + c.EXPECT().AddActivityTask(gomock.Any(), gomock.Any(), []yarpc.CallOption{yarpc.WithShardKey("peer0")}).Return(nil) + }, + }, + { + name: "AddActivityTask - Error in resolving peer", + op: func(c Client) error { + return c.AddActivityTask(context.Background(), testAddActivityTaskRequest()) + }, + mock: func(p *MockPeerResolver, balancer *MockLoadBalancer, c *MockClient) { + balancer.EXPECT().PickWritePartition(_testDomainUUID, types.TaskList{Name: _testTaskList}, persistence.TaskListTypeActivity, "").Return(_testPartition) + p.EXPECT().FromTaskList(_testPartition).Return("peer0", assert.AnError) + }, + wantError: true, + }, + { + name: "AddActivityTask - Error while adding activity task", + op: func(c Client) error { + return c.AddActivityTask(context.Background(), testAddActivityTaskRequest()) + }, + mock: func(p *MockPeerResolver, balancer *MockLoadBalancer, c *MockClient) { + balancer.EXPECT().PickWritePartition(_testDomainUUID, types.TaskList{Name: _testTaskList}, persistence.TaskListTypeActivity, "").Return(_testPartition) + p.EXPECT().FromTaskList(_testPartition).Return("peer0", nil) + c.EXPECT().AddActivityTask(gomock.Any(), gomock.Any(), []yarpc.CallOption{yarpc.WithShardKey("peer0")}).Return(assert.AnError) + }, + wantError: true, + }, + { + name: "AddDecisionTask", + op: func(c Client) error { + return c.AddDecisionTask(context.Background(), testAddDecisionTaskRequest()) + }, + mock: func(p *MockPeerResolver, balancer *MockLoadBalancer, c *MockClient) { + balancer.EXPECT().PickWritePartition(_testDomainUUID, types.TaskList{Name: _testTaskList}, persistence.TaskListTypeDecision, "").Return(_testPartition) + p.EXPECT().FromTaskList(_testPartition).Return("peer0", nil) + c.EXPECT().AddDecisionTask(gomock.Any(), gomock.Any(), []yarpc.CallOption{yarpc.WithShardKey("peer0")}).Return(nil) + }, + }, + { + name: "AddDecisionTask - Error in resolving peer", + op: func(c Client) error { + return c.AddDecisionTask(context.Background(), testAddDecisionTaskRequest()) + }, + mock: func(p *MockPeerResolver, balancer *MockLoadBalancer, c *MockClient) { + balancer.EXPECT().PickWritePartition(_testDomainUUID, types.TaskList{Name: _testTaskList}, persistence.TaskListTypeDecision, "").Return(_testPartition) + p.EXPECT().FromTaskList(_testPartition).Return("peer0", assert.AnError) + }, + wantError: true, + }, + { + name: "AddDecisionTask - Error while adding decision task", + op: func(c Client) error { + return c.AddDecisionTask(context.Background(), testAddDecisionTaskRequest()) + }, + mock: func(p *MockPeerResolver, balancer *MockLoadBalancer, c *MockClient) { + balancer.EXPECT().PickWritePartition(_testDomainUUID, types.TaskList{Name: _testTaskList}, persistence.TaskListTypeDecision, "").Return(_testPartition) + p.EXPECT().FromTaskList(_testPartition).Return("peer0", nil) + c.EXPECT().AddDecisionTask(gomock.Any(), gomock.Any(), []yarpc.CallOption{yarpc.WithShardKey("peer0")}).Return(assert.AnError) + }, + wantError: true, + }, + { + name: "RespondQueryTaskCompleted", + op: func(c Client) error { + return c.RespondQueryTaskCompleted(context.Background(), testRespondQueryTaskCompletedRequest()) + }, + mock: func(p *MockPeerResolver, balancer *MockLoadBalancer, c *MockClient) { + p.EXPECT().FromTaskList(_testTaskList).Return("peer0", nil) + c.EXPECT().RespondQueryTaskCompleted(gomock.Any(), gomock.Any(), []yarpc.CallOption{yarpc.WithShardKey("peer0")}).Return(nil) + }, + }, + { + name: "RespondQueryTaskCompleted - Error in resolving peer", + op: func(c Client) error { + return c.RespondQueryTaskCompleted(context.Background(), testRespondQueryTaskCompletedRequest()) + }, + mock: func(p *MockPeerResolver, balancer *MockLoadBalancer, c *MockClient) { + p.EXPECT().FromTaskList(_testTaskList).Return("peer0", assert.AnError) + }, + wantError: true, + }, + { + name: "RespondQueryTaskCompleted - Error while responding to completion of QueryTask", + op: func(c Client) error { + return c.RespondQueryTaskCompleted(context.Background(), testRespondQueryTaskCompletedRequest()) + }, + mock: func(p *MockPeerResolver, balancer *MockLoadBalancer, c *MockClient) { + p.EXPECT().FromTaskList(_testTaskList).Return("peer0", nil) + c.EXPECT().RespondQueryTaskCompleted(gomock.Any(), gomock.Any(), []yarpc.CallOption{yarpc.WithShardKey("peer0")}).Return(assert.AnError) + }, + wantError: true, + }, + { + name: "CancelOutstandingPoll", + op: func(c Client) error { + return c.CancelOutstandingPoll(context.Background(), testCancelOutstandingPollRequest()) + }, + mock: func(p *MockPeerResolver, balancer *MockLoadBalancer, c *MockClient) { + p.EXPECT().FromTaskList(_testTaskList).Return("peer0", nil) + c.EXPECT().CancelOutstandingPoll(gomock.Any(), gomock.Any(), []yarpc.CallOption{yarpc.WithShardKey("peer0")}).Return(nil) + }, + }, + { + name: "CancelOutstandingPoll - Error in resolving peer", + op: func(c Client) error { + return c.CancelOutstandingPoll(context.Background(), testCancelOutstandingPollRequest()) + }, + mock: func(p *MockPeerResolver, balancer *MockLoadBalancer, c *MockClient) { + p.EXPECT().FromTaskList(_testTaskList).Return("peer0", assert.AnError) + }, + wantError: true, + }, + { + name: "CancelOutstandingPoll - Error while cancelling outstanding poll", + op: func(c Client) error { + return c.CancelOutstandingPoll(context.Background(), testCancelOutstandingPollRequest()) + }, + mock: func(p *MockPeerResolver, balancer *MockLoadBalancer, c *MockClient) { + p.EXPECT().FromTaskList(_testTaskList).Return("peer0", nil) + c.EXPECT().CancelOutstandingPoll(gomock.Any(), gomock.Any(), []yarpc.CallOption{yarpc.WithShardKey("peer0")}).Return(assert.AnError) + }, + wantError: true, + }, + } + for _, tt := range tests { + tt := tt + t.Run(tt.name, func(t *testing.T) { + + // setting up client + ctrl := gomock.NewController(t) + client := NewMockClient(ctrl) + peerResolverMock := NewMockPeerResolver(ctrl) + loadbalancerMock := NewMockLoadBalancer(ctrl) + tt.mock(peerResolverMock, loadbalancerMock, client) + c := NewClient(client, peerResolverMock, loadbalancerMock) + + err := tt.op(c) + if tt.wantError { + assert.Error(t, err) + } else { + assert.NoError(t, err) + } + + }) + } +} + +func TestClient_withResponse(t *testing.T) { + tests := []struct { + name string + op func(Client) (any, error) + mock func(*MockPeerResolver, *MockLoadBalancer, *MockClient) + want any + wantError bool + }{ + { + name: "PollForActivityTask", + op: func(c Client) (any, error) { + return c.PollForActivityTask(context.Background(), testMatchingPollForActivityTaskRequest()) + }, + mock: func(p *MockPeerResolver, balancer *MockLoadBalancer, c *MockClient) { + balancer.EXPECT().PickReadPartition(_testDomainUUID, types.TaskList{Name: _testTaskList}, persistence.TaskListTypeActivity, "").Return(_testPartition) + p.EXPECT().FromTaskList(_testPartition).Return("peer0", nil) + c.EXPECT().PollForActivityTask(gomock.Any(), gomock.Any(), []yarpc.CallOption{yarpc.WithShardKey("peer0")}).Return(&types.PollForActivityTaskResponse{}, nil) + }, + want: &types.PollForActivityTaskResponse{}, + }, + { + name: "PollForActivityTask - Error in resolving peer", + op: func(c Client) (any, error) { + return c.PollForActivityTask(context.Background(), testMatchingPollForActivityTaskRequest()) + }, + mock: func(p *MockPeerResolver, balancer *MockLoadBalancer, c *MockClient) { + balancer.EXPECT().PickReadPartition(_testDomainUUID, types.TaskList{Name: _testTaskList}, persistence.TaskListTypeActivity, "").Return(_testPartition) + p.EXPECT().FromTaskList(_testPartition).Return("peer0", assert.AnError) + }, + want: nil, + wantError: true, + }, + { + name: "PollForActivityTask - Error while polling for ActivityTask", + op: func(c Client) (any, error) { + return c.PollForActivityTask(context.Background(), testMatchingPollForActivityTaskRequest()) + }, + mock: func(p *MockPeerResolver, balancer *MockLoadBalancer, c *MockClient) { + balancer.EXPECT().PickReadPartition(_testDomainUUID, types.TaskList{Name: _testTaskList}, persistence.TaskListTypeActivity, "").Return(_testPartition) + p.EXPECT().FromTaskList(_testPartition).Return("peer0", nil) + c.EXPECT().PollForActivityTask(gomock.Any(), gomock.Any(), []yarpc.CallOption{yarpc.WithShardKey("peer0")}).Return(nil, assert.AnError) + }, + want: nil, + wantError: true, + }, + { + name: "PollForDecisionTask", + op: func(c Client) (any, error) { + return c.PollForDecisionTask(context.Background(), testMatchingPollForDecisionTaskRequest()) + }, + mock: func(p *MockPeerResolver, balancer *MockLoadBalancer, c *MockClient) { + balancer.EXPECT().PickReadPartition(_testDomainUUID, types.TaskList{Name: _testTaskList}, persistence.TaskListTypeDecision, "").Return(_testPartition) + p.EXPECT().FromTaskList(_testPartition).Return("peer0", nil) + c.EXPECT().PollForDecisionTask(gomock.Any(), gomock.Any(), []yarpc.CallOption{yarpc.WithShardKey("peer0")}).Return(&types.MatchingPollForDecisionTaskResponse{}, nil) + }, + want: &types.MatchingPollForDecisionTaskResponse{}, + }, + { + name: "PollForDecisionTask - Error in resolving peer", + op: func(c Client) (any, error) { + return c.PollForDecisionTask(context.Background(), testMatchingPollForDecisionTaskRequest()) + }, + mock: func(p *MockPeerResolver, balancer *MockLoadBalancer, c *MockClient) { + balancer.EXPECT().PickReadPartition(_testDomainUUID, types.TaskList{Name: _testTaskList}, persistence.TaskListTypeDecision, "").Return(_testPartition) + p.EXPECT().FromTaskList(_testPartition).Return("peer0", assert.AnError) + }, + want: nil, + wantError: true, + }, + { + name: "PollForDecisionTask - Error while polling for DecisionTask", + op: func(c Client) (any, error) { + return c.PollForDecisionTask(context.Background(), testMatchingPollForDecisionTaskRequest()) + }, + mock: func(p *MockPeerResolver, balancer *MockLoadBalancer, c *MockClient) { + balancer.EXPECT().PickReadPartition(_testDomainUUID, types.TaskList{Name: _testTaskList}, persistence.TaskListTypeDecision, "").Return(_testPartition) + p.EXPECT().FromTaskList(_testPartition).Return("peer0", nil) + c.EXPECT().PollForDecisionTask(gomock.Any(), gomock.Any(), []yarpc.CallOption{yarpc.WithShardKey("peer0")}).Return(nil, assert.AnError) + }, + want: nil, + wantError: true, + }, + { + name: "QueryWorkflow", + op: func(c Client) (any, error) { + return c.QueryWorkflow(context.Background(), testMatchingQueryWorkflowRequest()) + }, + mock: func(p *MockPeerResolver, balancer *MockLoadBalancer, c *MockClient) { + balancer.EXPECT().PickReadPartition(_testDomainUUID, types.TaskList{Name: _testTaskList}, persistence.TaskListTypeDecision, "").Return(_testPartition) + p.EXPECT().FromTaskList(_testPartition).Return("peer0", nil) + c.EXPECT().QueryWorkflow(gomock.Any(), gomock.Any(), []yarpc.CallOption{yarpc.WithShardKey("peer0")}).Return(&types.QueryWorkflowResponse{}, nil) + }, + want: &types.QueryWorkflowResponse{}, + }, + { + name: "QueryWorkflow - Error in resolving peer", + op: func(c Client) (any, error) { + return c.QueryWorkflow(context.Background(), testMatchingQueryWorkflowRequest()) + }, + mock: func(p *MockPeerResolver, balancer *MockLoadBalancer, c *MockClient) { + balancer.EXPECT().PickReadPartition(_testDomainUUID, types.TaskList{Name: _testTaskList}, persistence.TaskListTypeDecision, "").Return(_testPartition) + p.EXPECT().FromTaskList(_testPartition).Return("peer0", assert.AnError) + }, + want: nil, + wantError: true, + }, + { + name: "QueryWorkflow - Error while querying workflow", + op: func(c Client) (any, error) { + return c.QueryWorkflow(context.Background(), testMatchingQueryWorkflowRequest()) + }, + mock: func(p *MockPeerResolver, balancer *MockLoadBalancer, c *MockClient) { + balancer.EXPECT().PickReadPartition(_testDomainUUID, types.TaskList{Name: _testTaskList}, persistence.TaskListTypeDecision, "").Return(_testPartition) + p.EXPECT().FromTaskList(_testPartition).Return("peer0", nil) + c.EXPECT().QueryWorkflow(gomock.Any(), gomock.Any(), []yarpc.CallOption{yarpc.WithShardKey("peer0")}).Return(nil, assert.AnError) + }, + want: nil, + wantError: true, + }, + { + name: "DescribeTaskList", + op: func(c Client) (any, error) { + return c.DescribeTaskList(context.Background(), testMatchingDescribeTaskListRequest()) + }, + mock: func(p *MockPeerResolver, balancer *MockLoadBalancer, c *MockClient) { + p.EXPECT().FromTaskList(_testTaskList).Return("peer0", nil) + c.EXPECT().DescribeTaskList(gomock.Any(), gomock.Any(), []yarpc.CallOption{yarpc.WithShardKey("peer0")}).Return(&types.DescribeTaskListResponse{}, nil) + }, + want: &types.DescribeTaskListResponse{}, + }, + { + name: "DescribeTaskList - Error in resolving peer", + op: func(c Client) (any, error) { + return c.DescribeTaskList(context.Background(), testMatchingDescribeTaskListRequest()) + }, + mock: func(p *MockPeerResolver, balancer *MockLoadBalancer, c *MockClient) { + p.EXPECT().FromTaskList(_testTaskList).Return("peer0", assert.AnError) + }, + want: nil, + wantError: true, + }, + { + name: "DescribeTaskList - Error while describing tasklist", + op: func(c Client) (any, error) { + return c.DescribeTaskList(context.Background(), testMatchingDescribeTaskListRequest()) + }, + mock: func(p *MockPeerResolver, balancer *MockLoadBalancer, c *MockClient) { + p.EXPECT().FromTaskList(_testTaskList).Return("peer0", nil) + c.EXPECT().DescribeTaskList(gomock.Any(), gomock.Any(), []yarpc.CallOption{yarpc.WithShardKey("peer0")}).Return(nil, assert.AnError) + }, + want: nil, + wantError: true, + }, + { + name: "ListTaskListPartitions", + op: func(c Client) (any, error) { + return c.ListTaskListPartitions(context.Background(), testMatchingListTaskListPartitionsRequest()) + }, + mock: func(p *MockPeerResolver, balancer *MockLoadBalancer, c *MockClient) { + p.EXPECT().FromTaskList(_testTaskList).Return("peer0", nil) + c.EXPECT().ListTaskListPartitions(gomock.Any(), gomock.Any(), []yarpc.CallOption{yarpc.WithShardKey("peer0")}).Return(&types.ListTaskListPartitionsResponse{}, nil) + }, + want: &types.ListTaskListPartitionsResponse{}, + }, + { + name: "ListTaskListPartitions - Error in resolving peer", + op: func(c Client) (any, error) { + return c.ListTaskListPartitions(context.Background(), testMatchingListTaskListPartitionsRequest()) + }, + mock: func(p *MockPeerResolver, balancer *MockLoadBalancer, c *MockClient) { + p.EXPECT().FromTaskList(_testTaskList).Return("peer0", assert.AnError) + }, + want: nil, + wantError: true, + }, + { + name: "ListTaskListPartitions - Error while listing tasklist partitions", + op: func(c Client) (any, error) { + return c.ListTaskListPartitions(context.Background(), testMatchingListTaskListPartitionsRequest()) + }, + mock: func(p *MockPeerResolver, balancer *MockLoadBalancer, c *MockClient) { + p.EXPECT().FromTaskList(_testTaskList).Return("peer0", nil) + c.EXPECT().ListTaskListPartitions(gomock.Any(), gomock.Any(), []yarpc.CallOption{yarpc.WithShardKey("peer0")}).Return(nil, assert.AnError) + }, + want: nil, + wantError: true, + }, + { + name: "GetTaskListsByDomain", + op: func(c Client) (any, error) { + return c.GetTaskListsByDomain(context.Background(), testGetTaskListsByDomainRequest()) + }, + mock: func(p *MockPeerResolver, balancer *MockLoadBalancer, c *MockClient) { + p.EXPECT().GetAllPeers().Return([]string{"peer0", "peer1"}, nil) + c.EXPECT().GetTaskListsByDomain(gomock.Any(), testGetTaskListsByDomainRequest(), []yarpc.CallOption{yarpc.WithShardKey("peer0")}).Return(&types.GetTaskListsByDomainResponse{}, nil) + c.EXPECT().GetTaskListsByDomain(gomock.Any(), testGetTaskListsByDomainRequest(), []yarpc.CallOption{yarpc.WithShardKey("peer1")}).Return(&types.GetTaskListsByDomainResponse{}, nil) + }, + want: &types.GetTaskListsByDomainResponse{ + DecisionTaskListMap: make(map[string]*types.DescribeTaskListResponse), + ActivityTaskListMap: make(map[string]*types.DescribeTaskListResponse), + }, + }, + { + name: "GetTaskListsByDomain - Error in resolving peer", + op: func(c Client) (any, error) { + return c.GetTaskListsByDomain(context.Background(), testGetTaskListsByDomainRequest()) + }, + mock: func(p *MockPeerResolver, balancer *MockLoadBalancer, c *MockClient) { + p.EXPECT().GetAllPeers().Return([]string{"peer0", "peer1"}, assert.AnError) + }, + want: nil, + wantError: true, + }, + } + for _, tt := range tests { + tt := tt + t.Run(tt.name, func(t *testing.T) { + + // setting up client + ctrl := gomock.NewController(t) + client := NewMockClient(ctrl) + peerResolverMock := NewMockPeerResolver(ctrl) + loadbalancerMock := NewMockLoadBalancer(ctrl) + tt.mock(peerResolverMock, loadbalancerMock, client) + c := NewClient(client, peerResolverMock, loadbalancerMock) + + res, err := tt.op(c) + if tt.wantError { + assert.Error(t, err) + assert.Nil(t, res) + } else { + assert.NoError(t, err) + assert.Equal(t, tt.want, res) + } + }) + } +} + +func testAddActivityTaskRequest() *types.AddActivityTaskRequest { + return &types.AddActivityTaskRequest{ + DomainUUID: _testDomainUUID, + TaskList: &types.TaskList{Name: _testTaskList}, + } +} + +func testAddDecisionTaskRequest() *types.AddDecisionTaskRequest { + return &types.AddDecisionTaskRequest{ + DomainUUID: _testDomainUUID, + TaskList: &types.TaskList{Name: _testTaskList}, + } +} + +func testRespondQueryTaskCompletedRequest() *types.MatchingRespondQueryTaskCompletedRequest { + return &types.MatchingRespondQueryTaskCompletedRequest{ + DomainUUID: _testDomainUUID, + TaskList: &types.TaskList{Name: _testTaskList}, + } +} + +func testCancelOutstandingPollRequest() *types.CancelOutstandingPollRequest { + return &types.CancelOutstandingPollRequest{ + DomainUUID: _testDomainUUID, + TaskList: &types.TaskList{Name: _testTaskList}, + } +} + +func testMatchingPollForActivityTaskRequest() *types.MatchingPollForActivityTaskRequest { + return &types.MatchingPollForActivityTaskRequest{ + DomainUUID: _testDomainUUID, + PollRequest: &types.PollForActivityTaskRequest{TaskList: &types.TaskList{Name: _testTaskList}}, + } +} + +func testMatchingPollForDecisionTaskRequest() *types.MatchingPollForDecisionTaskRequest { + return &types.MatchingPollForDecisionTaskRequest{ + DomainUUID: _testDomainUUID, + PollRequest: &types.PollForDecisionTaskRequest{TaskList: &types.TaskList{Name: _testTaskList}}, + } +} + +func testMatchingQueryWorkflowRequest() *types.MatchingQueryWorkflowRequest { + return &types.MatchingQueryWorkflowRequest{ + DomainUUID: _testDomainUUID, + TaskList: &types.TaskList{Name: _testTaskList}, + QueryRequest: &types.QueryWorkflowRequest{Domain: _testDomain}, + } +} + +func testMatchingDescribeTaskListRequest() *types.MatchingDescribeTaskListRequest { + return &types.MatchingDescribeTaskListRequest{ + DomainUUID: _testDomainUUID, + DescRequest: &types.DescribeTaskListRequest{TaskList: &types.TaskList{Name: _testTaskList}}, + } +} + +func testMatchingListTaskListPartitionsRequest() *types.MatchingListTaskListPartitionsRequest { + return &types.MatchingListTaskListPartitionsRequest{ + Domain: _testDomainUUID, + TaskList: &types.TaskList{Name: _testTaskList}, + } +} + +func testGetTaskListsByDomainRequest() *types.GetTaskListsByDomainRequest { + return &types.GetTaskListsByDomainRequest{ + Domain: _testDomain, + } +} diff --git a/client/matching/loadbalancer_mock.go b/client/matching/loadbalancer_mock.go new file mode 100644 index 00000000000..1866e419528 --- /dev/null +++ b/client/matching/loadbalancer_mock.go @@ -0,0 +1,86 @@ +// 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. + +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/uber/cadence/client/matching (interfaces: LoadBalancer) + +// Package matching is a generated GoMock package. +package matching + +import ( + reflect "reflect" + + gomock "github.com/golang/mock/gomock" + + types "github.com/uber/cadence/common/types" +) + +// MockLoadBalancer is a mock of LoadBalancer interface. +type MockLoadBalancer struct { + ctrl *gomock.Controller + recorder *MockLoadBalancerMockRecorder +} + +// MockLoadBalancerMockRecorder is the mock recorder for MockLoadBalancer. +type MockLoadBalancerMockRecorder struct { + mock *MockLoadBalancer +} + +// NewMockLoadBalancer creates a new mock instance. +func NewMockLoadBalancer(ctrl *gomock.Controller) *MockLoadBalancer { + mock := &MockLoadBalancer{ctrl: ctrl} + mock.recorder = &MockLoadBalancerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockLoadBalancer) EXPECT() *MockLoadBalancerMockRecorder { + return m.recorder +} + +// PickReadPartition mocks base method. +func (m *MockLoadBalancer) PickReadPartition(arg0 string, arg1 types.TaskList, arg2 int, arg3 string) string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PickReadPartition", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(string) + return ret0 +} + +// PickReadPartition indicates an expected call of PickReadPartition. +func (mr *MockLoadBalancerMockRecorder) PickReadPartition(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PickReadPartition", reflect.TypeOf((*MockLoadBalancer)(nil).PickReadPartition), arg0, arg1, arg2, arg3) +} + +// PickWritePartition mocks base method. +func (m *MockLoadBalancer) PickWritePartition(arg0 string, arg1 types.TaskList, arg2 int, arg3 string) string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PickWritePartition", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(string) + return ret0 +} + +// PickWritePartition indicates an expected call of PickWritePartition. +func (mr *MockLoadBalancerMockRecorder) PickWritePartition(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PickWritePartition", reflect.TypeOf((*MockLoadBalancer)(nil).PickWritePartition), arg0, arg1, arg2, arg3) +} diff --git a/client/matching/peerResolver.go b/client/matching/peer_resolver.go similarity index 85% rename from client/matching/peerResolver.go rename to client/matching/peer_resolver.go index 60251cf59d1..16a497a34fa 100644 --- a/client/matching/peerResolver.go +++ b/client/matching/peer_resolver.go @@ -29,14 +29,22 @@ import ( // PeerResolver is used to resolve matching peers. // Those are deployed instances of Cadence matching services that participate in the cluster ring. // The resulting peer is simply an address of form ip:port where RPC calls can be routed to. -type PeerResolver struct { +//go:generate mockgen -package $GOPACKAGE -source $GOFILE -destination peer_resolver_mock.go -package matching github.com/uber/cadence/client/matching PeerResolver + +type PeerResolver interface { + FromTaskList(taskListName string) (string, error) + GetAllPeers() ([]string, error) + FromHostAddress(hostAddress string) (string, error) +} + +type peerResolver struct { resolver membership.Resolver namedPort string // grpc or tchannel, depends on yarpc configuration } // NewPeerResolver creates a new matching peer resolver. func NewPeerResolver(membership membership.Resolver, namedPort string) PeerResolver { - return PeerResolver{ + return peerResolver{ resolver: membership, namedPort: namedPort, } @@ -45,7 +53,7 @@ func NewPeerResolver(membership membership.Resolver, namedPort string) PeerResol // FromTaskList resolves the matching peer responsible for the given task list name. // It uses our membership provider to lookup which instance currently owns the given task list. // FromHostAddress is used for further resolving. -func (pr PeerResolver) FromTaskList(taskListName string) (string, error) { +func (pr peerResolver) FromTaskList(taskListName string) (string, error) { host, err := pr.resolver.Lookup(service.Matching, taskListName) if err != nil { return "", common.ToServiceTransientError(err) @@ -56,7 +64,7 @@ func (pr PeerResolver) FromTaskList(taskListName string) (string, error) { } // GetAllPeers returns all matching service peers in the cluster ring. -func (pr PeerResolver) GetAllPeers() ([]string, error) { +func (pr peerResolver) GetAllPeers() ([]string, error) { hosts, err := pr.resolver.Members(service.Matching) if err != nil { return nil, common.ToServiceTransientError(err) @@ -75,7 +83,7 @@ func (pr PeerResolver) GetAllPeers() ([]string, error) { // FromHostAddress resolves the final matching peer responsible for the given host address. // The address may be used as is, or processed with additional address mapper. // In case of gRPC transport, the port within the address is replaced with gRPC port. -func (pr PeerResolver) FromHostAddress(hostAddress string) (string, error) { +func (pr peerResolver) FromHostAddress(hostAddress string) (string, error) { host, err := pr.resolver.LookupByAddress(service.Matching, hostAddress) if err != nil { return "", common.ToServiceTransientError(err) diff --git a/client/matching/peer_resolver_mock.go b/client/matching/peer_resolver_mock.go new file mode 100644 index 00000000000..8529494fd75 --- /dev/null +++ b/client/matching/peer_resolver_mock.go @@ -0,0 +1,101 @@ +// 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. + +// Code generated by MockGen. DO NOT EDIT. +// Source: peer_resolver.go + +// Package matching is a generated GoMock package. +package matching + +import ( + reflect "reflect" + + gomock "github.com/golang/mock/gomock" +) + +// MockPeerResolver is a mock of PeerResolver interface. +type MockPeerResolver struct { + ctrl *gomock.Controller + recorder *MockPeerResolverMockRecorder +} + +// MockPeerResolverMockRecorder is the mock recorder for MockPeerResolver. +type MockPeerResolverMockRecorder struct { + mock *MockPeerResolver +} + +// NewMockPeerResolver creates a new mock instance. +func NewMockPeerResolver(ctrl *gomock.Controller) *MockPeerResolver { + mock := &MockPeerResolver{ctrl: ctrl} + mock.recorder = &MockPeerResolverMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockPeerResolver) EXPECT() *MockPeerResolverMockRecorder { + return m.recorder +} + +// FromHostAddress mocks base method. +func (m *MockPeerResolver) FromHostAddress(hostAddress string) (string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FromHostAddress", hostAddress) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// FromHostAddress indicates an expected call of FromHostAddress. +func (mr *MockPeerResolverMockRecorder) FromHostAddress(hostAddress interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FromHostAddress", reflect.TypeOf((*MockPeerResolver)(nil).FromHostAddress), hostAddress) +} + +// FromTaskList mocks base method. +func (m *MockPeerResolver) FromTaskList(taskListName string) (string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FromTaskList", taskListName) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// FromTaskList indicates an expected call of FromTaskList. +func (mr *MockPeerResolverMockRecorder) FromTaskList(taskListName interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FromTaskList", reflect.TypeOf((*MockPeerResolver)(nil).FromTaskList), taskListName) +} + +// GetAllPeers mocks base method. +func (m *MockPeerResolver) GetAllPeers() ([]string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAllPeers") + ret0, _ := ret[0].([]string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAllPeers indicates an expected call of GetAllPeers. +func (mr *MockPeerResolverMockRecorder) GetAllPeers() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllPeers", reflect.TypeOf((*MockPeerResolver)(nil).GetAllPeers)) +} diff --git a/client/matching/peerResolver_test.go b/client/matching/peer_resolver_test.go similarity index 100% rename from client/matching/peerResolver_test.go rename to client/matching/peer_resolver_test.go