From 99bc8dc609e3f1d4a5d72c4df09d36068fe083ad Mon Sep 17 00:00:00 2001 From: KentHsu Date: Wed, 1 May 2024 21:34:45 +0800 Subject: [PATCH 01/15] tests: mockgen mock_client file Signed-off-by: KentHsu --- actor/mock_client/mock_client.go | 864 +++++++++++++++++++++++++++++++ 1 file changed, 864 insertions(+) create mode 100644 actor/mock_client/mock_client.go diff --git a/actor/mock_client/mock_client.go b/actor/mock_client/mock_client.go new file mode 100644 index 00000000..4035ba71 --- /dev/null +++ b/actor/mock_client/mock_client.go @@ -0,0 +1,864 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: ./client/client.go + +// Package mock_client is a generated GoMock package. +package mock_client + +import ( + context "context" + io "io" + reflect "reflect" + time "time" + + runtime "github.com/dapr/dapr/pkg/proto/runtime/v1" + actor "github.com/dapr/go-sdk/actor" + config "github.com/dapr/go-sdk/actor/config" + client "github.com/dapr/go-sdk/client" + gomock "github.com/golang/mock/gomock" + grpc "google.golang.org/grpc" +) + +// MockClient is a mock of Client interface. +type MockClient struct { + ctrl *gomock.Controller + recorder *MockClientMockRecorder +} + +// MockClientMockRecorder is the mock recorder for MockClient. +type MockClientMockRecorder struct { + mock *MockClient +} + +// NewMockClient creates a new mock instance. +func NewMockClient(ctrl *gomock.Controller) *MockClient { + mock := &MockClient{ctrl: ctrl} + mock.recorder = &MockClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockClient) EXPECT() *MockClientMockRecorder { + return m.recorder +} + +// Close mocks base method. +func (m *MockClient) Close() { + m.ctrl.T.Helper() + m.ctrl.Call(m, "Close") +} + +// Close indicates an expected call of Close. +func (mr *MockClientMockRecorder) Close() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockClient)(nil).Close)) +} + +// Decrypt mocks base method. +func (m *MockClient) Decrypt(ctx context.Context, in io.Reader, opts client.DecryptOptions) (io.Reader, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Decrypt", ctx, in, opts) + ret0, _ := ret[0].(io.Reader) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Decrypt indicates an expected call of Decrypt. +func (mr *MockClientMockRecorder) Decrypt(ctx, in, opts interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Decrypt", reflect.TypeOf((*MockClient)(nil).Decrypt), ctx, in, opts) +} + +// DeleteBulkState mocks base method. +func (m *MockClient) DeleteBulkState(ctx context.Context, storeName string, keys []string, meta map[string]string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteBulkState", ctx, storeName, keys, meta) + ret0, _ := ret[0].(error) + return ret0 +} + +// DeleteBulkState indicates an expected call of DeleteBulkState. +func (mr *MockClientMockRecorder) DeleteBulkState(ctx, storeName, keys, meta interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBulkState", reflect.TypeOf((*MockClient)(nil).DeleteBulkState), ctx, storeName, keys, meta) +} + +// DeleteBulkStateItems mocks base method. +func (m *MockClient) DeleteBulkStateItems(ctx context.Context, storeName string, items []*client.DeleteStateItem) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteBulkStateItems", ctx, storeName, items) + ret0, _ := ret[0].(error) + return ret0 +} + +// DeleteBulkStateItems indicates an expected call of DeleteBulkStateItems. +func (mr *MockClientMockRecorder) DeleteBulkStateItems(ctx, storeName, items interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBulkStateItems", reflect.TypeOf((*MockClient)(nil).DeleteBulkStateItems), ctx, storeName, items) +} + +// DeleteState mocks base method. +func (m *MockClient) DeleteState(ctx context.Context, storeName, key string, meta map[string]string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteState", ctx, storeName, key, meta) + ret0, _ := ret[0].(error) + return ret0 +} + +// DeleteState indicates an expected call of DeleteState. +func (mr *MockClientMockRecorder) DeleteState(ctx, storeName, key, meta interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteState", reflect.TypeOf((*MockClient)(nil).DeleteState), ctx, storeName, key, meta) +} + +// DeleteStateWithETag mocks base method. +func (m *MockClient) DeleteStateWithETag(ctx context.Context, storeName, key string, etag *client.ETag, meta map[string]string, opts *client.StateOptions) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteStateWithETag", ctx, storeName, key, etag, meta, opts) + ret0, _ := ret[0].(error) + return ret0 +} + +// DeleteStateWithETag indicates an expected call of DeleteStateWithETag. +func (mr *MockClientMockRecorder) DeleteStateWithETag(ctx, storeName, key, etag, meta, opts interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStateWithETag", reflect.TypeOf((*MockClient)(nil).DeleteStateWithETag), ctx, storeName, key, etag, meta, opts) +} + +// Encrypt mocks base method. +func (m *MockClient) Encrypt(ctx context.Context, in io.Reader, opts client.EncryptOptions) (io.Reader, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Encrypt", ctx, in, opts) + ret0, _ := ret[0].(io.Reader) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Encrypt indicates an expected call of Encrypt. +func (mr *MockClientMockRecorder) Encrypt(ctx, in, opts interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Encrypt", reflect.TypeOf((*MockClient)(nil).Encrypt), ctx, in, opts) +} + +// ExecuteStateTransaction mocks base method. +func (m *MockClient) ExecuteStateTransaction(ctx context.Context, storeName string, meta map[string]string, ops []*client.StateOperation) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExecuteStateTransaction", ctx, storeName, meta, ops) + ret0, _ := ret[0].(error) + return ret0 +} + +// ExecuteStateTransaction indicates an expected call of ExecuteStateTransaction. +func (mr *MockClientMockRecorder) ExecuteStateTransaction(ctx, storeName, meta, ops interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteStateTransaction", reflect.TypeOf((*MockClient)(nil).ExecuteStateTransaction), ctx, storeName, meta, ops) +} + +// GetActorState mocks base method. +func (m *MockClient) GetActorState(ctx context.Context, req *client.GetActorStateRequest) (*client.GetActorStateResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetActorState", ctx, req) + ret0, _ := ret[0].(*client.GetActorStateResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetActorState indicates an expected call of GetActorState. +func (mr *MockClientMockRecorder) GetActorState(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetActorState", reflect.TypeOf((*MockClient)(nil).GetActorState), ctx, req) +} + +// GetBulkSecret mocks base method. +func (m *MockClient) GetBulkSecret(ctx context.Context, storeName string, meta map[string]string) (map[string]map[string]string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetBulkSecret", ctx, storeName, meta) + ret0, _ := ret[0].(map[string]map[string]string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBulkSecret indicates an expected call of GetBulkSecret. +func (mr *MockClientMockRecorder) GetBulkSecret(ctx, storeName, meta interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBulkSecret", reflect.TypeOf((*MockClient)(nil).GetBulkSecret), ctx, storeName, meta) +} + +// GetBulkState mocks base method. +func (m *MockClient) GetBulkState(ctx context.Context, storeName string, keys []string, meta map[string]string, parallelism int32) ([]*client.BulkStateItem, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetBulkState", ctx, storeName, keys, meta, parallelism) + ret0, _ := ret[0].([]*client.BulkStateItem) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBulkState indicates an expected call of GetBulkState. +func (mr *MockClientMockRecorder) GetBulkState(ctx, storeName, keys, meta, parallelism interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBulkState", reflect.TypeOf((*MockClient)(nil).GetBulkState), ctx, storeName, keys, meta, parallelism) +} + +// GetConfigurationItem mocks base method. +func (m *MockClient) GetConfigurationItem(ctx context.Context, storeName, key string, opts ...client.ConfigurationOpt) (*client.ConfigurationItem, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, storeName, key} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetConfigurationItem", varargs...) + ret0, _ := ret[0].(*client.ConfigurationItem) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetConfigurationItem indicates an expected call of GetConfigurationItem. +func (mr *MockClientMockRecorder) GetConfigurationItem(ctx, storeName, key interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, storeName, key}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfigurationItem", reflect.TypeOf((*MockClient)(nil).GetConfigurationItem), varargs...) +} + +// GetConfigurationItems mocks base method. +func (m *MockClient) GetConfigurationItems(ctx context.Context, storeName string, keys []string, opts ...client.ConfigurationOpt) (map[string]*client.ConfigurationItem, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, storeName, keys} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetConfigurationItems", varargs...) + ret0, _ := ret[0].(map[string]*client.ConfigurationItem) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetConfigurationItems indicates an expected call of GetConfigurationItems. +func (mr *MockClientMockRecorder) GetConfigurationItems(ctx, storeName, keys interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, storeName, keys}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfigurationItems", reflect.TypeOf((*MockClient)(nil).GetConfigurationItems), varargs...) +} + +// GetMetadata mocks base method. +func (m *MockClient) GetMetadata(ctx context.Context) (*client.GetMetadataResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetMetadata", ctx) + ret0, _ := ret[0].(*client.GetMetadataResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetMetadata indicates an expected call of GetMetadata. +func (mr *MockClientMockRecorder) GetMetadata(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetadata", reflect.TypeOf((*MockClient)(nil).GetMetadata), ctx) +} + +// GetSecret mocks base method. +func (m *MockClient) GetSecret(ctx context.Context, storeName, key string, meta map[string]string) (map[string]string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetSecret", ctx, storeName, key, meta) + ret0, _ := ret[0].(map[string]string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetSecret indicates an expected call of GetSecret. +func (mr *MockClientMockRecorder) GetSecret(ctx, storeName, key, meta interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecret", reflect.TypeOf((*MockClient)(nil).GetSecret), ctx, storeName, key, meta) +} + +// GetState mocks base method. +func (m *MockClient) GetState(ctx context.Context, storeName, key string, meta map[string]string) (*client.StateItem, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetState", ctx, storeName, key, meta) + ret0, _ := ret[0].(*client.StateItem) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetState indicates an expected call of GetState. +func (mr *MockClientMockRecorder) GetState(ctx, storeName, key, meta interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetState", reflect.TypeOf((*MockClient)(nil).GetState), ctx, storeName, key, meta) +} + +// GetStateWithConsistency mocks base method. +func (m *MockClient) GetStateWithConsistency(ctx context.Context, storeName, key string, meta map[string]string, sc client.StateConsistency) (*client.StateItem, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetStateWithConsistency", ctx, storeName, key, meta, sc) + ret0, _ := ret[0].(*client.StateItem) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetStateWithConsistency indicates an expected call of GetStateWithConsistency. +func (mr *MockClientMockRecorder) GetStateWithConsistency(ctx, storeName, key, meta, sc interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStateWithConsistency", reflect.TypeOf((*MockClient)(nil).GetStateWithConsistency), ctx, storeName, key, meta, sc) +} + +// GetWorkflowBeta1 mocks base method. +func (m *MockClient) GetWorkflowBeta1(ctx context.Context, req *client.GetWorkflowRequest) (*client.GetWorkflowResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetWorkflowBeta1", ctx, req) + ret0, _ := ret[0].(*client.GetWorkflowResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetWorkflowBeta1 indicates an expected call of GetWorkflowBeta1. +func (mr *MockClientMockRecorder) GetWorkflowBeta1(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowBeta1", reflect.TypeOf((*MockClient)(nil).GetWorkflowBeta1), ctx, req) +} + +// GrpcClient mocks base method. +func (m *MockClient) GrpcClient() runtime.DaprClient { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GrpcClient") + ret0, _ := ret[0].(runtime.DaprClient) + return ret0 +} + +// GrpcClient indicates an expected call of GrpcClient. +func (mr *MockClientMockRecorder) GrpcClient() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GrpcClient", reflect.TypeOf((*MockClient)(nil).GrpcClient)) +} + +// GrpcClientConn mocks base method. +func (m *MockClient) GrpcClientConn() *grpc.ClientConn { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GrpcClientConn") + ret0, _ := ret[0].(*grpc.ClientConn) + return ret0 +} + +// GrpcClientConn indicates an expected call of GrpcClientConn. +func (mr *MockClientMockRecorder) GrpcClientConn() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GrpcClientConn", reflect.TypeOf((*MockClient)(nil).GrpcClientConn)) +} + +// ImplActorClientStub mocks base method. +func (m *MockClient) ImplActorClientStub(actorClientStub actor.Client, opt ...config.Option) { + m.ctrl.T.Helper() + varargs := []interface{}{actorClientStub} + for _, a := range opt { + varargs = append(varargs, a) + } + m.ctrl.Call(m, "ImplActorClientStub", varargs...) +} + +// ImplActorClientStub indicates an expected call of ImplActorClientStub. +func (mr *MockClientMockRecorder) ImplActorClientStub(actorClientStub interface{}, opt ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{actorClientStub}, opt...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImplActorClientStub", reflect.TypeOf((*MockClient)(nil).ImplActorClientStub), varargs...) +} + +// InvokeActor mocks base method. +func (m *MockClient) InvokeActor(ctx context.Context, req *client.InvokeActorRequest) (*client.InvokeActorResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InvokeActor", ctx, req) + ret0, _ := ret[0].(*client.InvokeActorResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// InvokeActor indicates an expected call of InvokeActor. +func (mr *MockClientMockRecorder) InvokeActor(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeActor", reflect.TypeOf((*MockClient)(nil).InvokeActor), ctx, req) +} + +// InvokeBinding mocks base method. +func (m *MockClient) InvokeBinding(ctx context.Context, in *client.InvokeBindingRequest) (*client.BindingEvent, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InvokeBinding", ctx, in) + ret0, _ := ret[0].(*client.BindingEvent) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// InvokeBinding indicates an expected call of InvokeBinding. +func (mr *MockClientMockRecorder) InvokeBinding(ctx, in interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeBinding", reflect.TypeOf((*MockClient)(nil).InvokeBinding), ctx, in) +} + +// InvokeMethod mocks base method. +func (m *MockClient) InvokeMethod(ctx context.Context, appID, methodName, verb string) ([]byte, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InvokeMethod", ctx, appID, methodName, verb) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// InvokeMethod indicates an expected call of InvokeMethod. +func (mr *MockClientMockRecorder) InvokeMethod(ctx, appID, methodName, verb interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeMethod", reflect.TypeOf((*MockClient)(nil).InvokeMethod), ctx, appID, methodName, verb) +} + +// InvokeMethodWithContent mocks base method. +func (m *MockClient) InvokeMethodWithContent(ctx context.Context, appID, methodName, verb string, content *client.DataContent) ([]byte, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InvokeMethodWithContent", ctx, appID, methodName, verb, content) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// InvokeMethodWithContent indicates an expected call of InvokeMethodWithContent. +func (mr *MockClientMockRecorder) InvokeMethodWithContent(ctx, appID, methodName, verb, content interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeMethodWithContent", reflect.TypeOf((*MockClient)(nil).InvokeMethodWithContent), ctx, appID, methodName, verb, content) +} + +// InvokeMethodWithCustomContent mocks base method. +func (m *MockClient) InvokeMethodWithCustomContent(ctx context.Context, appID, methodName, verb, contentType string, content interface{}) ([]byte, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InvokeMethodWithCustomContent", ctx, appID, methodName, verb, contentType, content) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// InvokeMethodWithCustomContent indicates an expected call of InvokeMethodWithCustomContent. +func (mr *MockClientMockRecorder) InvokeMethodWithCustomContent(ctx, appID, methodName, verb, contentType, content interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeMethodWithCustomContent", reflect.TypeOf((*MockClient)(nil).InvokeMethodWithCustomContent), ctx, appID, methodName, verb, contentType, content) +} + +// InvokeOutputBinding mocks base method. +func (m *MockClient) InvokeOutputBinding(ctx context.Context, in *client.InvokeBindingRequest) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InvokeOutputBinding", ctx, in) + ret0, _ := ret[0].(error) + return ret0 +} + +// InvokeOutputBinding indicates an expected call of InvokeOutputBinding. +func (mr *MockClientMockRecorder) InvokeOutputBinding(ctx, in interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeOutputBinding", reflect.TypeOf((*MockClient)(nil).InvokeOutputBinding), ctx, in) +} + +// PauseWorkflowBeta1 mocks base method. +func (m *MockClient) PauseWorkflowBeta1(ctx context.Context, req *client.PauseWorkflowRequest) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PauseWorkflowBeta1", ctx, req) + ret0, _ := ret[0].(error) + return ret0 +} + +// PauseWorkflowBeta1 indicates an expected call of PauseWorkflowBeta1. +func (mr *MockClientMockRecorder) PauseWorkflowBeta1(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PauseWorkflowBeta1", reflect.TypeOf((*MockClient)(nil).PauseWorkflowBeta1), ctx, req) +} + +// PublishEvent mocks base method. +func (m *MockClient) PublishEvent(ctx context.Context, pubsubName, topicName string, data interface{}, opts ...client.PublishEventOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, pubsubName, topicName, data} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PublishEvent", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// PublishEvent indicates an expected call of PublishEvent. +func (mr *MockClientMockRecorder) PublishEvent(ctx, pubsubName, topicName, data interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, pubsubName, topicName, data}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishEvent", reflect.TypeOf((*MockClient)(nil).PublishEvent), varargs...) +} + +// PublishEventfromCustomContent mocks base method. +func (m *MockClient) PublishEventfromCustomContent(ctx context.Context, pubsubName, topicName string, data interface{}) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PublishEventfromCustomContent", ctx, pubsubName, topicName, data) + ret0, _ := ret[0].(error) + return ret0 +} + +// PublishEventfromCustomContent indicates an expected call of PublishEventfromCustomContent. +func (mr *MockClientMockRecorder) PublishEventfromCustomContent(ctx, pubsubName, topicName, data interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishEventfromCustomContent", reflect.TypeOf((*MockClient)(nil).PublishEventfromCustomContent), ctx, pubsubName, topicName, data) +} + +// PublishEvents mocks base method. +func (m *MockClient) PublishEvents(ctx context.Context, pubsubName, topicName string, events []interface{}, opts ...client.PublishEventsOption) client.PublishEventsResponse { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, pubsubName, topicName, events} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PublishEvents", varargs...) + ret0, _ := ret[0].(client.PublishEventsResponse) + return ret0 +} + +// PublishEvents indicates an expected call of PublishEvents. +func (mr *MockClientMockRecorder) PublishEvents(ctx, pubsubName, topicName, events interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, pubsubName, topicName, events}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishEvents", reflect.TypeOf((*MockClient)(nil).PublishEvents), varargs...) +} + +// PurgeWorkflowBeta1 mocks base method. +func (m *MockClient) PurgeWorkflowBeta1(ctx context.Context, req *client.PurgeWorkflowRequest) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PurgeWorkflowBeta1", ctx, req) + ret0, _ := ret[0].(error) + return ret0 +} + +// PurgeWorkflowBeta1 indicates an expected call of PurgeWorkflowBeta1. +func (mr *MockClientMockRecorder) PurgeWorkflowBeta1(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurgeWorkflowBeta1", reflect.TypeOf((*MockClient)(nil).PurgeWorkflowBeta1), ctx, req) +} + +// QueryStateAlpha1 mocks base method. +func (m *MockClient) QueryStateAlpha1(ctx context.Context, storeName, query string, meta map[string]string) (*client.QueryResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryStateAlpha1", ctx, storeName, query, meta) + ret0, _ := ret[0].(*client.QueryResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryStateAlpha1 indicates an expected call of QueryStateAlpha1. +func (mr *MockClientMockRecorder) QueryStateAlpha1(ctx, storeName, query, meta interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryStateAlpha1", reflect.TypeOf((*MockClient)(nil).QueryStateAlpha1), ctx, storeName, query, meta) +} + +// RaiseEventWorkflowBeta1 mocks base method. +func (m *MockClient) RaiseEventWorkflowBeta1(ctx context.Context, req *client.RaiseEventWorkflowRequest) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RaiseEventWorkflowBeta1", ctx, req) + ret0, _ := ret[0].(error) + return ret0 +} + +// RaiseEventWorkflowBeta1 indicates an expected call of RaiseEventWorkflowBeta1. +func (mr *MockClientMockRecorder) RaiseEventWorkflowBeta1(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RaiseEventWorkflowBeta1", reflect.TypeOf((*MockClient)(nil).RaiseEventWorkflowBeta1), ctx, req) +} + +// RegisterActorReminder mocks base method. +func (m *MockClient) RegisterActorReminder(ctx context.Context, req *client.RegisterActorReminderRequest) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RegisterActorReminder", ctx, req) + ret0, _ := ret[0].(error) + return ret0 +} + +// RegisterActorReminder indicates an expected call of RegisterActorReminder. +func (mr *MockClientMockRecorder) RegisterActorReminder(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterActorReminder", reflect.TypeOf((*MockClient)(nil).RegisterActorReminder), ctx, req) +} + +// RegisterActorTimer mocks base method. +func (m *MockClient) RegisterActorTimer(ctx context.Context, req *client.RegisterActorTimerRequest) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RegisterActorTimer", ctx, req) + ret0, _ := ret[0].(error) + return ret0 +} + +// RegisterActorTimer indicates an expected call of RegisterActorTimer. +func (mr *MockClientMockRecorder) RegisterActorTimer(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterActorTimer", reflect.TypeOf((*MockClient)(nil).RegisterActorTimer), ctx, req) +} + +// ResumeWorkflowBeta1 mocks base method. +func (m *MockClient) ResumeWorkflowBeta1(ctx context.Context, req *client.ResumeWorkflowRequest) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResumeWorkflowBeta1", ctx, req) + ret0, _ := ret[0].(error) + return ret0 +} + +// ResumeWorkflowBeta1 indicates an expected call of ResumeWorkflowBeta1. +func (mr *MockClientMockRecorder) ResumeWorkflowBeta1(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeWorkflowBeta1", reflect.TypeOf((*MockClient)(nil).ResumeWorkflowBeta1), ctx, req) +} + +// SaveBulkState mocks base method. +func (m *MockClient) SaveBulkState(ctx context.Context, storeName string, items ...*client.SetStateItem) error { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, storeName} + for _, a := range items { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SaveBulkState", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// SaveBulkState indicates an expected call of SaveBulkState. +func (mr *MockClientMockRecorder) SaveBulkState(ctx, storeName interface{}, items ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, storeName}, items...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveBulkState", reflect.TypeOf((*MockClient)(nil).SaveBulkState), varargs...) +} + +// SaveState mocks base method. +func (m *MockClient) SaveState(ctx context.Context, storeName, key string, data []byte, meta map[string]string, so ...client.StateOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, storeName, key, data, meta} + for _, a := range so { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SaveState", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// SaveState indicates an expected call of SaveState. +func (mr *MockClientMockRecorder) SaveState(ctx, storeName, key, data, meta interface{}, so ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, storeName, key, data, meta}, so...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveState", reflect.TypeOf((*MockClient)(nil).SaveState), varargs...) +} + +// SaveStateTransactionally mocks base method. +func (m *MockClient) SaveStateTransactionally(ctx context.Context, actorType, actorID string, operations []*client.ActorStateOperation) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SaveStateTransactionally", ctx, actorType, actorID, operations) + ret0, _ := ret[0].(error) + return ret0 +} + +// SaveStateTransactionally indicates an expected call of SaveStateTransactionally. +func (mr *MockClientMockRecorder) SaveStateTransactionally(ctx, actorType, actorID, operations interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveStateTransactionally", reflect.TypeOf((*MockClient)(nil).SaveStateTransactionally), ctx, actorType, actorID, operations) +} + +// SaveStateWithETag mocks base method. +func (m *MockClient) SaveStateWithETag(ctx context.Context, storeName, key string, data []byte, etag string, meta map[string]string, so ...client.StateOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, storeName, key, data, etag, meta} + for _, a := range so { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SaveStateWithETag", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// SaveStateWithETag indicates an expected call of SaveStateWithETag. +func (mr *MockClientMockRecorder) SaveStateWithETag(ctx, storeName, key, data, etag, meta interface{}, so ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, storeName, key, data, etag, meta}, so...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveStateWithETag", reflect.TypeOf((*MockClient)(nil).SaveStateWithETag), varargs...) +} + +// SetMetadata mocks base method. +func (m *MockClient) SetMetadata(ctx context.Context, key, value string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetMetadata", ctx, key, value) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetMetadata indicates an expected call of SetMetadata. +func (mr *MockClientMockRecorder) SetMetadata(ctx, key, value interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMetadata", reflect.TypeOf((*MockClient)(nil).SetMetadata), ctx, key, value) +} + +// Shutdown mocks base method. +func (m *MockClient) Shutdown(ctx context.Context) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Shutdown", ctx) + ret0, _ := ret[0].(error) + return ret0 +} + +// Shutdown indicates an expected call of Shutdown. +func (mr *MockClientMockRecorder) Shutdown(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockClient)(nil).Shutdown), ctx) +} + +// StartWorkflowBeta1 mocks base method. +func (m *MockClient) StartWorkflowBeta1(ctx context.Context, req *client.StartWorkflowRequest) (*client.StartWorkflowResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartWorkflowBeta1", ctx, req) + ret0, _ := ret[0].(*client.StartWorkflowResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartWorkflowBeta1 indicates an expected call of StartWorkflowBeta1. +func (mr *MockClientMockRecorder) StartWorkflowBeta1(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartWorkflowBeta1", reflect.TypeOf((*MockClient)(nil).StartWorkflowBeta1), ctx, req) +} + +// SubscribeConfigurationItems mocks base method. +func (m *MockClient) SubscribeConfigurationItems(ctx context.Context, storeName string, keys []string, handler client.ConfigurationHandleFunction, opts ...client.ConfigurationOpt) (string, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, storeName, keys, handler} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SubscribeConfigurationItems", varargs...) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SubscribeConfigurationItems indicates an expected call of SubscribeConfigurationItems. +func (mr *MockClientMockRecorder) SubscribeConfigurationItems(ctx, storeName, keys, handler interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, storeName, keys, handler}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeConfigurationItems", reflect.TypeOf((*MockClient)(nil).SubscribeConfigurationItems), varargs...) +} + +// TerminateWorkflowBeta1 mocks base method. +func (m *MockClient) TerminateWorkflowBeta1(ctx context.Context, req *client.TerminateWorkflowRequest) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TerminateWorkflowBeta1", ctx, req) + ret0, _ := ret[0].(error) + return ret0 +} + +// TerminateWorkflowBeta1 indicates an expected call of TerminateWorkflowBeta1. +func (mr *MockClientMockRecorder) TerminateWorkflowBeta1(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateWorkflowBeta1", reflect.TypeOf((*MockClient)(nil).TerminateWorkflowBeta1), ctx, req) +} + +// TryLockAlpha1 mocks base method. +func (m *MockClient) TryLockAlpha1(ctx context.Context, storeName string, request *client.LockRequest) (*client.LockResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TryLockAlpha1", ctx, storeName, request) + ret0, _ := ret[0].(*client.LockResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TryLockAlpha1 indicates an expected call of TryLockAlpha1. +func (mr *MockClientMockRecorder) TryLockAlpha1(ctx, storeName, request interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryLockAlpha1", reflect.TypeOf((*MockClient)(nil).TryLockAlpha1), ctx, storeName, request) +} + +// UnlockAlpha1 mocks base method. +func (m *MockClient) UnlockAlpha1(ctx context.Context, storeName string, request *client.UnlockRequest) (*client.UnlockResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UnlockAlpha1", ctx, storeName, request) + ret0, _ := ret[0].(*client.UnlockResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UnlockAlpha1 indicates an expected call of UnlockAlpha1. +func (mr *MockClientMockRecorder) UnlockAlpha1(ctx, storeName, request interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnlockAlpha1", reflect.TypeOf((*MockClient)(nil).UnlockAlpha1), ctx, storeName, request) +} + +// UnregisterActorReminder mocks base method. +func (m *MockClient) UnregisterActorReminder(ctx context.Context, req *client.UnregisterActorReminderRequest) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UnregisterActorReminder", ctx, req) + ret0, _ := ret[0].(error) + return ret0 +} + +// UnregisterActorReminder indicates an expected call of UnregisterActorReminder. +func (mr *MockClientMockRecorder) UnregisterActorReminder(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnregisterActorReminder", reflect.TypeOf((*MockClient)(nil).UnregisterActorReminder), ctx, req) +} + +// UnregisterActorTimer mocks base method. +func (m *MockClient) UnregisterActorTimer(ctx context.Context, req *client.UnregisterActorTimerRequest) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UnregisterActorTimer", ctx, req) + ret0, _ := ret[0].(error) + return ret0 +} + +// UnregisterActorTimer indicates an expected call of UnregisterActorTimer. +func (mr *MockClientMockRecorder) UnregisterActorTimer(ctx, req interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnregisterActorTimer", reflect.TypeOf((*MockClient)(nil).UnregisterActorTimer), ctx, req) +} + +// UnsubscribeConfigurationItems mocks base method. +func (m *MockClient) UnsubscribeConfigurationItems(ctx context.Context, storeName, id string, opts ...client.ConfigurationOpt) error { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, storeName, id} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UnsubscribeConfigurationItems", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// UnsubscribeConfigurationItems indicates an expected call of UnsubscribeConfigurationItems. +func (mr *MockClientMockRecorder) UnsubscribeConfigurationItems(ctx, storeName, id interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, storeName, id}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnsubscribeConfigurationItems", reflect.TypeOf((*MockClient)(nil).UnsubscribeConfigurationItems), varargs...) +} + +// Wait mocks base method. +func (m *MockClient) Wait(ctx context.Context, timeout time.Duration) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Wait", ctx, timeout) + ret0, _ := ret[0].(error) + return ret0 +} + +// Wait indicates an expected call of Wait. +func (mr *MockClientMockRecorder) Wait(ctx, timeout interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Wait", reflect.TypeOf((*MockClient)(nil).Wait), ctx, timeout) +} + +// WithAuthToken mocks base method. +func (m *MockClient) WithAuthToken(token string) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "WithAuthToken", token) +} + +// WithAuthToken indicates an expected call of WithAuthToken. +func (mr *MockClientMockRecorder) WithAuthToken(token interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithAuthToken", reflect.TypeOf((*MockClient)(nil).WithAuthToken), token) +} + +// WithTraceID mocks base method. +func (m *MockClient) WithTraceID(ctx context.Context, id string) context.Context { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WithTraceID", ctx, id) + ret0, _ := ret[0].(context.Context) + return ret0 +} + +// WithTraceID indicates an expected call of WithTraceID. +func (mr *MockClientMockRecorder) WithTraceID(ctx, id interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithTraceID", reflect.TypeOf((*MockClient)(nil).WithTraceID), ctx, id) +} From 977a3e5f9b7d40f2aaceeae0da40c2676b6be362 Mon Sep 17 00:00:00 2001 From: KentHsu Date: Wed, 1 May 2024 21:36:05 +0800 Subject: [PATCH 02/15] fix: fix setWithTTL method Signed-off-by: KentHsu --- actor/state/state_manager.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/actor/state/state_manager.go b/actor/state/state_manager.go index 0bae7c9a..ef8e4cfd 100644 --- a/actor/state/state_manager.go +++ b/actor/state/state_manager.go @@ -167,7 +167,7 @@ func (s *stateManagerCtx) SetWithTTL(_ context.Context, stateName string, value if metadata.Kind == None || metadata.Kind == Remove { metadata.Kind = Update } - s.stateChangeTracker.Store(stateName, NewChangeMetadata(metadata.Kind, value)) + s.stateChangeTracker.Store(stateName, NewChangeMetadata(metadata.Kind, value).WithTTL(ttl)) return nil } s.stateChangeTracker.Store(stateName, (&ChangeMetadata{ From e1eaf71b7aae6b03bc5e5b79efd05a6c4f557171 Mon Sep 17 00:00:00 2001 From: KentHsu Date: Wed, 1 May 2024 21:37:04 +0800 Subject: [PATCH 03/15] tests: add tests for stateManagerCtx Signed-off-by: KentHsu --- actor/state/state_manager_test.go | 609 ++++++++++++++++++++++++++++++ 1 file changed, 609 insertions(+) create mode 100644 actor/state/state_manager_test.go diff --git a/actor/state/state_manager_test.go b/actor/state/state_manager_test.go new file mode 100644 index 00000000..a80de422 --- /dev/null +++ b/actor/state/state_manager_test.go @@ -0,0 +1,609 @@ +/* +Copyright 2021 The Dapr Authors +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package state + +import ( + "context" + "errors" + "reflect" + "testing" + "time" + + "github.com/dapr/go-sdk/actor/mock" + "github.com/dapr/go-sdk/actor/mock_client" + "github.com/dapr/go-sdk/client" + "github.com/golang/mock/gomock" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +const ( + testState = "state" + testValue = "value" + testTTL = time.Second * 3600 +) + +func newMockStateManager(t *testing.T) *stateManagerCtx { + ctrl := gomock.NewController(t) + return &stateManagerCtx{ + actorTypeName: "test", + actorID: "fn", + stateAsyncProvider: &DaprStateAsyncProvider{ + daprClient: mock_client.NewMockClient(ctrl), + stateSerializer: mock.NewMockCodec(ctrl), + }, + } +} + +func newGetActorStateRequest(sm *stateManagerCtx, key string) *client.GetActorStateRequest { + return &client.GetActorStateRequest{ + ActorType: sm.actorTypeName, + ActorID: sm.actorID, + KeyName: key, + } +} + +func newGetActorStateResponse(data []byte) *client.GetActorStateResponse { + return &client.GetActorStateResponse{Data: data} +} + +func TestAdd_EmptyStateName(t *testing.T) { + ctx := context.Background() + sm := newMockStateManager(t) + err := sm.Add(ctx, "", testValue) + assert.Error(t, err) +} + +func TestAdd_WithCachedStateChange(t *testing.T) { + ctx := context.Background() + + tests := []struct { + name string + kind ChangeKind + shouldErr bool + }{ + {"state change kind None", None, true}, + {"state change kind Add", Add, true}, + {"state change kind Update", Update, true}, + {"state change kind Remove", Remove, false}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + sm := newMockStateManager(t) + sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.kind, Value: testValue}) + mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) + mockRequest := newGetActorStateRequest(sm, testState) + mockResult := newGetActorStateResponse([]byte("result")) + mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(mockResult, nil) + + err := sm.Add(ctx, testState, testValue) + if tt.shouldErr { + assert.Error(t, err) + } else { + require.NoError(t, err) + + val, ok := sm.stateChangeTracker.Load(testState) + require.True(t, ok) + + metadata := val.(*ChangeMetadata) + assert.Equal(t, metadata.Kind, Update) + assert.Equal(t, metadata.Value, testValue) + } + }) + } +} + +func TestAdd_WithoutCachedStateChange(t *testing.T) { + ctx := context.Background() + + tests := []struct { + name string + stateProviderErr bool + duplicateState bool + }{ + {"state provider returns error", true, false}, + {"state provider returns data", false, true}, + {"successfully add new state", false, false}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + sm := newMockStateManager(t) + mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) + mockRequest := newGetActorStateRequest(sm, testState) + mockResult := newGetActorStateResponse([]byte("result")) + if tt.stateProviderErr { + mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(nil, errors.New("mockErr")) + } else { + if tt.duplicateState { + mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(mockResult, nil) + } else { + mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(nil, nil) + } + } + + err := sm.Add(ctx, testState, testValue) + if tt.stateProviderErr || tt.duplicateState { + assert.Error(t, err) + } else { + require.NoError(t, err) + + val, ok := sm.stateChangeTracker.Load(testState) + require.True(t, ok) + + metadata := val.(*ChangeMetadata) + assert.Equal(t, metadata.Kind, Add) + assert.Equal(t, metadata.Value, testValue) + } + }) + } +} + +func TestGet_EmptyStateName(t *testing.T) { + ctx := context.Background() + sm := newMockStateManager(t) + err := sm.Get(ctx, "", testValue) + assert.Error(t, err) +} + +func TestGet_WithCachedStateChange(t *testing.T) { + ctx := context.Background() + + tests := []struct { + name string + kind ChangeKind + shouldErr bool + }{ + {"state change kind None", None, false}, + {"state change kind Add", Add, false}, + {"state change kind Update", Update, false}, + {"state change kind Remove", Remove, true}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + sm := newMockStateManager(t) + sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.kind, Value: testValue}) + + var reply string + err := sm.Get(ctx, testState, &reply) + if tt.shouldErr { + assert.Error(t, err) + } else { + assert.NoError(t, err) + assert.Equal(t, reply, testValue) + } + }) + } +} + +func TestGet_WithoutCachedStateChange(t *testing.T) { + ctx := context.Background() + + tests := []struct { + name string + shouldErr bool + }{ + {"state provider returns error", true}, + {"state provider returns data", false}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + sm := newMockStateManager(t) + mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) + mockCodec := sm.stateAsyncProvider.stateSerializer.(*mock.MockCodec) + mockRequest := newGetActorStateRequest(sm, testState) + mockResult := newGetActorStateResponse([]byte("result")) + if tt.shouldErr { + mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(nil, errors.New("mockErr")) + } else { + mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(mockResult, nil) + mockCodec.EXPECT().Unmarshal(mockResult.Data, testValue) + } + + err := sm.Get(ctx, testState, testValue) + if tt.shouldErr { + require.Error(t, err) + } else { + require.NoError(t, err) + } + + val, ok := sm.stateChangeTracker.Load(testState) + require.True(t, ok) + + metadata := val.(*ChangeMetadata) + assert.Equal(t, metadata.Kind, None) + assert.Equal(t, metadata.Value, testValue) + }) + } +} + +func TestSet_EmptyStateName(t *testing.T) { + ctx := context.Background() + sm := newMockStateManager(t) + err := sm.Set(ctx, "", testValue) + assert.Error(t, err) +} + +func TestSet_WithCachedStateChange(t *testing.T) { + ctx := context.Background() + + tests := []struct { + name string + initKind ChangeKind + expectKind ChangeKind + }{ + {"state change kind None", None, Update}, + {"state change kind Add", Add, Add}, + {"state change kind Update", Update, Update}, + {"state change kind Remove", Remove, Update}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + sm := newMockStateManager(t) + sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.initKind, Value: testValue}) + + err := sm.Set(ctx, testState, testValue) + require.NoError(t, err) + + val, ok := sm.stateChangeTracker.Load(testState) + require.True(t, ok) + + metadata := val.(*ChangeMetadata) + assert.Equal(t, metadata.Kind, tt.expectKind) + assert.Equal(t, metadata.Value, testValue) + }) + } +} + +func TestSet_WithoutCachedStateChange(t *testing.T) { + ctx := context.Background() + sm := newMockStateManager(t) + + err := sm.Set(ctx, testState, testValue) + require.NoError(t, err) + + val, ok := sm.stateChangeTracker.Load(testState) + require.True(t, ok) + + metadata := val.(*ChangeMetadata) + assert.Equal(t, metadata.Kind, Add) + assert.Equal(t, metadata.Value, testValue) +} + +func TestSetWithTTL_EmptyStateName(t *testing.T) { + ctx := context.Background() + sm := newMockStateManager(t) + err := sm.SetWithTTL(ctx, "", testValue, testTTL) + assert.Error(t, err) +} + +func TestSetWithTTL_NegativeTTL(t *testing.T) { + ctx := context.Background() + sm := newMockStateManager(t) + err := sm.SetWithTTL(ctx, testState, testValue, -testTTL) + assert.Error(t, err) +} + +func TestSetWithTTL_WithCachedStateChange(t *testing.T) { + ctx := context.Background() + + tests := []struct { + name string + initKind ChangeKind + expectKind ChangeKind + }{ + {"state change kind None", None, Update}, + {"state change kind Add", Add, Add}, + {"state change kind Update", Update, Update}, + {"state change kind Remove", Remove, Update}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + sm := newMockStateManager(t) + sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.initKind, Value: testValue}) + + err := sm.SetWithTTL(ctx, testState, testValue, testTTL) + require.NoError(t, err) + + val, ok := sm.stateChangeTracker.Load(testState) + require.True(t, ok) + + metadata := val.(*ChangeMetadata) + assert.Equal(t, metadata.Kind, tt.expectKind) + assert.Equal(t, metadata.Value, testValue) + assert.Equal(t, *metadata.TTL, testTTL) + }) + } +} + +func TestSetWithTTL_WithoutCachedStateChange(t *testing.T) { + ctx := context.Background() + sm := newMockStateManager(t) + + err := sm.SetWithTTL(ctx, testState, testValue, testTTL) + require.NoError(t, err) + + val, ok := sm.stateChangeTracker.Load(testState) + require.True(t, ok) + + metadata := val.(*ChangeMetadata) + assert.Equal(t, metadata.Kind, Add) + assert.Equal(t, metadata.Value, testValue) + assert.Equal(t, *metadata.TTL, testTTL) +} + +func TestRemove_EmptyStateName(t *testing.T) { + ctx := context.Background() + sm := newMockStateManager(t) + err := sm.Remove(ctx, "") + assert.Error(t, err) +} + +func TestRemove_WithCachedStateChange(t *testing.T) { + ctx := context.Background() + + tests := []struct { + name string + kind ChangeKind + inCache bool + }{ + {"state change kind None", None, true}, + {"state change kind Add", Add, false}, + {"state change kind Update", Update, false}, + {"state change kind Remove", Remove, true}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + sm := newMockStateManager(t) + sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.kind, Value: testValue}) + + err := sm.Remove(ctx, testState) + require.NoError(t, err) + + val, ok := sm.stateChangeTracker.Load(testState) + if tt.inCache { + assert.Equal(t, val.(*ChangeMetadata).Kind, Remove) + assert.True(t, ok) + } else { + assert.Nil(t, val) + assert.False(t, ok) + } + }) + } +} + +func TestRemove_WithoutCachedStateChange(t *testing.T) { + ctx := context.Background() + mockResult := newGetActorStateResponse([]byte("result")) + mockErr := errors.New("mockErr") + + tests := []struct { + name string + mockFunc func(sm *stateManagerCtx, mc *mock_client.MockClient) + }{ + {"state provider returns error", func(sm *stateManagerCtx, mc *mock_client.MockClient) { + mc.EXPECT().GetActorState(ctx, newGetActorStateRequest(sm, testState)).Return(nil, mockErr) + }}, + {"state provider returns data", func(sm *stateManagerCtx, mc *mock_client.MockClient) { + mc.EXPECT().GetActorState(ctx, newGetActorStateRequest(sm, testState)).Return(mockResult, nil) + }}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + sm := newMockStateManager(t) + mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) + tt.mockFunc(sm, mockClient) + err := sm.Remove(ctx, testState) + assert.NoError(t, err) + }) + } +} + +func TestContains_EmptyStateName(t *testing.T) { + ctx := context.Background() + sm := newMockStateManager(t) + res, err := sm.Contains(ctx, "") + assert.False(t, res) + assert.Error(t, err) +} + +func TestContains_WithCachedStateChange(t *testing.T) { + ctx := context.Background() + + tests := []struct { + name string + kind ChangeKind + expected bool + }{ + {"state change kind None", None, true}, + {"state change kind Add", Add, true}, + {"state change kind Update", Update, true}, + {"state change kind Remove", Remove, false}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + sm := newMockStateManager(t) + sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.kind, Value: testValue}) + + result, err := sm.Contains(ctx, testState) + assert.Equal(t, result, tt.expected) + assert.NoError(t, err) + }) + } +} + +func TestContains_WithoutCachedStateChange(t *testing.T) { + ctx := context.Background() + + tests := []struct { + name string + shouldErr bool + }{ + {"state provider returns error", true}, + {"state provider returns data", false}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + sm := newMockStateManager(t) + mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) + mockRequest := newGetActorStateRequest(sm, testState) + mockResult := newGetActorStateResponse([]byte("result")) + if tt.shouldErr { + mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(nil, errors.New("mockErr")) + } else { + mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(mockResult, nil) + } + + result, err := sm.Contains(ctx, testState) + if tt.shouldErr { + assert.Error(t, err) + assert.False(t, result) + } else { + assert.NoError(t, err) + assert.True(t, result) + } + }) + } +} + +func TestSave_SingleCachedStateChange(t *testing.T) { + ctx := context.Background() + + tests := []struct { + name string + stateChanges *ChangeMetadata + }{ + {"no state change", nil}, + {"state change kind None", &ChangeMetadata{Kind: None, Value: testValue}}, + {"state change kind Add", &ChangeMetadata{Kind: Add, Value: testValue}}, + {"state change kind Update", &ChangeMetadata{Kind: Update, Value: testValue}}, + {"state change kind Remove", &ChangeMetadata{Kind: Remove, Value: testValue}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + sm := newMockStateManager(t) + mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) + mockCodec := sm.stateAsyncProvider.stateSerializer.(*mock.MockCodec) + if tt.stateChanges != nil { + sm.stateChangeTracker.Store(testState, tt.stateChanges) + + if tt.stateChanges.Kind == Remove { + mockClient.EXPECT().SaveStateTransactionally(ctx, sm.actorTypeName, sm.actorID, gomock.Len(1)) + } else if tt.stateChanges.Kind == Add || tt.stateChanges.Kind == Update { + mockClient.EXPECT().SaveStateTransactionally(ctx, sm.actorTypeName, sm.actorID, gomock.Len(1)) + mockCodec.EXPECT().Marshal(tt.stateChanges.Value) + } + } + + err := sm.Save(ctx) + assert.Nil(t, err) + }) + } +} + +func TestSave_MultipleCachedStateChanges(t *testing.T) { + ctx := context.Background() + sm := newMockStateManager(t) + mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) + mockCodec := sm.stateAsyncProvider.stateSerializer.(*mock.MockCodec) + + stateChanges := []struct { + stateName string + value string + kind ChangeKind + }{ + {"stateNone", "valueNone", None}, + {"stateAdd", "valueAdd", Add}, + {"stateUpdate", "valueUpdate", Update}, + {"stateRemove", "valueRemove", Remove}, + } + for _, sc := range stateChanges { + sm.stateChangeTracker.Store(sc.stateName, &ChangeMetadata{Kind: sc.kind, Value: sc.value}) + } + + // 3 operations: 1 Add, 1 Update, 1 Remove + mockClient.EXPECT().SaveStateTransactionally(ctx, sm.actorTypeName, sm.actorID, gomock.Len(3)) + // 2 times: 1 Add, 1 Update + mockCodec.EXPECT().Marshal(gomock.Any()).Times(2) + + err := sm.Save(ctx) + assert.Nil(t, err) +} + +func TestFlush(t *testing.T) { + ctx := context.Background() + sm := newMockStateManager(t) + stateChanges := []struct { + stateName string + value string + kind ChangeKind + }{ + {"stateNone", "valueNone", None}, + {"stateAdd", "valueAdd", Add}, + {"stateUpdate", "valueUpdate", Update}, + {"stateRemove", "valueRemove", Remove}, + } + for _, sc := range stateChanges { + sm.stateChangeTracker.Store(sc.stateName, &ChangeMetadata{Kind: sc.kind, Value: sc.value}) + } + + sm.Flush(ctx) + + for _, sc := range stateChanges { + val, ok := sm.stateChangeTracker.Load(sc.stateName) + if sc.kind == Remove { + assert.Nil(t, val) + assert.False(t, ok) + } else { + metadata := val.(*ChangeMetadata) + assert.Equal(t, metadata.Kind, None) + assert.Equal(t, metadata.Value, sc.value) + assert.True(t, ok) + } + } +} + +func TestNewActorStateManagerContext(t *testing.T) { + type args struct { + actorTypeName string + actorID string + stateAsyncProvider *DaprStateAsyncProvider + } + tests := []struct { + name string + args args + want *stateManagerCtx + }{ + { + name: "init", + args: args{ + actorTypeName: "test", + actorID: "fn", + stateAsyncProvider: &DaprStateAsyncProvider{}, + }, + want: &stateManagerCtx{ + actorTypeName: "test", + actorID: "fn", + stateAsyncProvider: &DaprStateAsyncProvider{}, + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := NewActorStateManagerContext(tt.args.actorTypeName, tt.args.actorID, tt.args.stateAsyncProvider); !reflect.DeepEqual(got, tt.want) { + t.Errorf("NewActorStateManagerContext() = %v, want %v", got, tt.want) + } + }) + } +} From a2693e41ba29def0cf70af5813d18c97000b2ece Mon Sep 17 00:00:00 2001 From: KentHsu Date: Thu, 2 May 2024 08:52:28 +0800 Subject: [PATCH 04/15] tests: fix testifylint error Signed-off-by: KentHsu --- actor/state/state_manager_test.go | 78 +++++++++++++++---------------- 1 file changed, 39 insertions(+), 39 deletions(-) diff --git a/actor/state/state_manager_test.go b/actor/state/state_manager_test.go index a80de422..a045b69b 100644 --- a/actor/state/state_manager_test.go +++ b/actor/state/state_manager_test.go @@ -23,8 +23,8 @@ import ( "github.com/dapr/go-sdk/actor/mock" "github.com/dapr/go-sdk/actor/mock_client" "github.com/dapr/go-sdk/client" - "github.com/golang/mock/gomock" + "github.com/golang/mock/gomock" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) @@ -63,7 +63,7 @@ func TestAdd_EmptyStateName(t *testing.T) { ctx := context.Background() sm := newMockStateManager(t) err := sm.Add(ctx, "", testValue) - assert.Error(t, err) + require.Error(t, err) } func TestAdd_WithCachedStateChange(t *testing.T) { @@ -90,7 +90,7 @@ func TestAdd_WithCachedStateChange(t *testing.T) { err := sm.Add(ctx, testState, testValue) if tt.shouldErr { - assert.Error(t, err) + require.Error(t, err) } else { require.NoError(t, err) @@ -98,8 +98,8 @@ func TestAdd_WithCachedStateChange(t *testing.T) { require.True(t, ok) metadata := val.(*ChangeMetadata) - assert.Equal(t, metadata.Kind, Update) - assert.Equal(t, metadata.Value, testValue) + assert.Equal(t, Update, metadata.Kind) + assert.Equal(t, testValue, metadata.Value) } }) } @@ -135,7 +135,7 @@ func TestAdd_WithoutCachedStateChange(t *testing.T) { err := sm.Add(ctx, testState, testValue) if tt.stateProviderErr || tt.duplicateState { - assert.Error(t, err) + require.Error(t, err) } else { require.NoError(t, err) @@ -143,8 +143,8 @@ func TestAdd_WithoutCachedStateChange(t *testing.T) { require.True(t, ok) metadata := val.(*ChangeMetadata) - assert.Equal(t, metadata.Kind, Add) - assert.Equal(t, metadata.Value, testValue) + assert.Equal(t, Add, metadata.Kind) + assert.Equal(t, testValue, metadata.Value) } }) } @@ -154,7 +154,7 @@ func TestGet_EmptyStateName(t *testing.T) { ctx := context.Background() sm := newMockStateManager(t) err := sm.Get(ctx, "", testValue) - assert.Error(t, err) + require.Error(t, err) } func TestGet_WithCachedStateChange(t *testing.T) { @@ -178,10 +178,10 @@ func TestGet_WithCachedStateChange(t *testing.T) { var reply string err := sm.Get(ctx, testState, &reply) if tt.shouldErr { - assert.Error(t, err) + require.Error(t, err) } else { - assert.NoError(t, err) - assert.Equal(t, reply, testValue) + require.NoError(t, err) + assert.Equal(t, testValue, reply) } }) } @@ -222,8 +222,8 @@ func TestGet_WithoutCachedStateChange(t *testing.T) { require.True(t, ok) metadata := val.(*ChangeMetadata) - assert.Equal(t, metadata.Kind, None) - assert.Equal(t, metadata.Value, testValue) + assert.Equal(t, None, metadata.Kind) + assert.Equal(t, testValue, metadata.Value) }) } } @@ -232,7 +232,7 @@ func TestSet_EmptyStateName(t *testing.T) { ctx := context.Background() sm := newMockStateManager(t) err := sm.Set(ctx, "", testValue) - assert.Error(t, err) + require.Error(t, err) } func TestSet_WithCachedStateChange(t *testing.T) { @@ -260,8 +260,8 @@ func TestSet_WithCachedStateChange(t *testing.T) { require.True(t, ok) metadata := val.(*ChangeMetadata) - assert.Equal(t, metadata.Kind, tt.expectKind) - assert.Equal(t, metadata.Value, testValue) + assert.Equal(t, tt.expectKind, metadata.Kind) + assert.Equal(t, testValue, metadata.Value) }) } } @@ -277,22 +277,22 @@ func TestSet_WithoutCachedStateChange(t *testing.T) { require.True(t, ok) metadata := val.(*ChangeMetadata) - assert.Equal(t, metadata.Kind, Add) - assert.Equal(t, metadata.Value, testValue) + assert.Equal(t, Add, metadata.Kind) + assert.Equal(t, testValue, metadata.Value) } func TestSetWithTTL_EmptyStateName(t *testing.T) { ctx := context.Background() sm := newMockStateManager(t) err := sm.SetWithTTL(ctx, "", testValue, testTTL) - assert.Error(t, err) + require.Error(t, err) } func TestSetWithTTL_NegativeTTL(t *testing.T) { ctx := context.Background() sm := newMockStateManager(t) err := sm.SetWithTTL(ctx, testState, testValue, -testTTL) - assert.Error(t, err) + require.Error(t, err) } func TestSetWithTTL_WithCachedStateChange(t *testing.T) { @@ -320,9 +320,9 @@ func TestSetWithTTL_WithCachedStateChange(t *testing.T) { require.True(t, ok) metadata := val.(*ChangeMetadata) - assert.Equal(t, metadata.Kind, tt.expectKind) - assert.Equal(t, metadata.Value, testValue) - assert.Equal(t, *metadata.TTL, testTTL) + assert.Equal(t, tt.expectKind, metadata.Kind) + assert.Equal(t, testValue, metadata.Value) + assert.Equal(t, testTTL, *metadata.TTL) }) } } @@ -338,16 +338,16 @@ func TestSetWithTTL_WithoutCachedStateChange(t *testing.T) { require.True(t, ok) metadata := val.(*ChangeMetadata) - assert.Equal(t, metadata.Kind, Add) - assert.Equal(t, metadata.Value, testValue) - assert.Equal(t, *metadata.TTL, testTTL) + assert.Equal(t, Add, metadata.Kind) + assert.Equal(t, testValue, metadata.Value) + assert.Equal(t, testTTL, *metadata.TTL) } func TestRemove_EmptyStateName(t *testing.T) { ctx := context.Background() sm := newMockStateManager(t) err := sm.Remove(ctx, "") - assert.Error(t, err) + require.Error(t, err) } func TestRemove_WithCachedStateChange(t *testing.T) { @@ -373,7 +373,7 @@ func TestRemove_WithCachedStateChange(t *testing.T) { val, ok := sm.stateChangeTracker.Load(testState) if tt.inCache { - assert.Equal(t, val.(*ChangeMetadata).Kind, Remove) + assert.Equal(t, Remove, val.(*ChangeMetadata).Kind) assert.True(t, ok) } else { assert.Nil(t, val) @@ -405,7 +405,7 @@ func TestRemove_WithoutCachedStateChange(t *testing.T) { mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) tt.mockFunc(sm, mockClient) err := sm.Remove(ctx, testState) - assert.NoError(t, err) + require.NoError(t, err) }) } } @@ -414,8 +414,8 @@ func TestContains_EmptyStateName(t *testing.T) { ctx := context.Background() sm := newMockStateManager(t) res, err := sm.Contains(ctx, "") + require.Error(t, err) assert.False(t, res) - assert.Error(t, err) } func TestContains_WithCachedStateChange(t *testing.T) { @@ -437,8 +437,8 @@ func TestContains_WithCachedStateChange(t *testing.T) { sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.kind, Value: testValue}) result, err := sm.Contains(ctx, testState) - assert.Equal(t, result, tt.expected) - assert.NoError(t, err) + require.NoError(t, err) + assert.Equal(t, tt.expected, result) }) } } @@ -467,10 +467,10 @@ func TestContains_WithoutCachedStateChange(t *testing.T) { result, err := sm.Contains(ctx, testState) if tt.shouldErr { - assert.Error(t, err) + require.Error(t, err) assert.False(t, result) } else { - assert.NoError(t, err) + require.NoError(t, err) assert.True(t, result) } }) @@ -507,7 +507,7 @@ func TestSave_SingleCachedStateChange(t *testing.T) { } err := sm.Save(ctx) - assert.Nil(t, err) + require.NoError(t, err) }) } } @@ -538,7 +538,7 @@ func TestSave_MultipleCachedStateChanges(t *testing.T) { mockCodec.EXPECT().Marshal(gomock.Any()).Times(2) err := sm.Save(ctx) - assert.Nil(t, err) + require.NoError(t, err) } func TestFlush(t *testing.T) { @@ -567,9 +567,9 @@ func TestFlush(t *testing.T) { assert.False(t, ok) } else { metadata := val.(*ChangeMetadata) - assert.Equal(t, metadata.Kind, None) - assert.Equal(t, metadata.Value, sc.value) assert.True(t, ok) + assert.Equal(t, None, metadata.Kind) + assert.Equal(t, sc.value, metadata.Value) } } } From 69de03d301c899cdf9d8fef30ece7365de60d516 Mon Sep 17 00:00:00 2001 From: KentHsu Date: Fri, 3 May 2024 00:27:55 +0800 Subject: [PATCH 05/15] tests: add newStateManager and rename newStateManagerCtx Signed-off-by: KentHsu --- actor/state/state_manager_test.go | 57 ++++++++++++++++++------------- 1 file changed, 34 insertions(+), 23 deletions(-) diff --git a/actor/state/state_manager_test.go b/actor/state/state_manager_test.go index a045b69b..e7501b6a 100644 --- a/actor/state/state_manager_test.go +++ b/actor/state/state_manager_test.go @@ -35,7 +35,13 @@ const ( testTTL = time.Second * 3600 ) -func newMockStateManager(t *testing.T) *stateManagerCtx { +func newMockStateManager(t *testing.T) *stateManager { + return &stateManager{ + stateManagerCtx: newMockStateManagerCtx(t), + } +} + +func newMockStateManagerCtx(t *testing.T) *stateManagerCtx { ctrl := gomock.NewController(t) return &stateManagerCtx{ actorTypeName: "test", @@ -59,9 +65,14 @@ func newGetActorStateResponse(data []byte) *client.GetActorStateResponse { return &client.GetActorStateResponse{Data: data} } +func TestStateManagerWithContext(t *testing.T) { + sm := newMockStateManager(t) + assert.Equal(t, sm.WithContext(), sm.stateManagerCtx) +} + func TestAdd_EmptyStateName(t *testing.T) { ctx := context.Background() - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) err := sm.Add(ctx, "", testValue) require.Error(t, err) } @@ -81,7 +92,7 @@ func TestAdd_WithCachedStateChange(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.kind, Value: testValue}) mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) mockRequest := newGetActorStateRequest(sm, testState) @@ -119,7 +130,7 @@ func TestAdd_WithoutCachedStateChange(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) mockRequest := newGetActorStateRequest(sm, testState) mockResult := newGetActorStateResponse([]byte("result")) @@ -152,7 +163,7 @@ func TestAdd_WithoutCachedStateChange(t *testing.T) { func TestGet_EmptyStateName(t *testing.T) { ctx := context.Background() - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) err := sm.Get(ctx, "", testValue) require.Error(t, err) } @@ -172,7 +183,7 @@ func TestGet_WithCachedStateChange(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.kind, Value: testValue}) var reply string @@ -199,7 +210,7 @@ func TestGet_WithoutCachedStateChange(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) mockCodec := sm.stateAsyncProvider.stateSerializer.(*mock.MockCodec) mockRequest := newGetActorStateRequest(sm, testState) @@ -230,7 +241,7 @@ func TestGet_WithoutCachedStateChange(t *testing.T) { func TestSet_EmptyStateName(t *testing.T) { ctx := context.Background() - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) err := sm.Set(ctx, "", testValue) require.Error(t, err) } @@ -250,7 +261,7 @@ func TestSet_WithCachedStateChange(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.initKind, Value: testValue}) err := sm.Set(ctx, testState, testValue) @@ -268,7 +279,7 @@ func TestSet_WithCachedStateChange(t *testing.T) { func TestSet_WithoutCachedStateChange(t *testing.T) { ctx := context.Background() - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) err := sm.Set(ctx, testState, testValue) require.NoError(t, err) @@ -283,14 +294,14 @@ func TestSet_WithoutCachedStateChange(t *testing.T) { func TestSetWithTTL_EmptyStateName(t *testing.T) { ctx := context.Background() - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) err := sm.SetWithTTL(ctx, "", testValue, testTTL) require.Error(t, err) } func TestSetWithTTL_NegativeTTL(t *testing.T) { ctx := context.Background() - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) err := sm.SetWithTTL(ctx, testState, testValue, -testTTL) require.Error(t, err) } @@ -310,7 +321,7 @@ func TestSetWithTTL_WithCachedStateChange(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.initKind, Value: testValue}) err := sm.SetWithTTL(ctx, testState, testValue, testTTL) @@ -329,7 +340,7 @@ func TestSetWithTTL_WithCachedStateChange(t *testing.T) { func TestSetWithTTL_WithoutCachedStateChange(t *testing.T) { ctx := context.Background() - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) err := sm.SetWithTTL(ctx, testState, testValue, testTTL) require.NoError(t, err) @@ -345,7 +356,7 @@ func TestSetWithTTL_WithoutCachedStateChange(t *testing.T) { func TestRemove_EmptyStateName(t *testing.T) { ctx := context.Background() - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) err := sm.Remove(ctx, "") require.Error(t, err) } @@ -365,7 +376,7 @@ func TestRemove_WithCachedStateChange(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.kind, Value: testValue}) err := sm.Remove(ctx, testState) @@ -401,7 +412,7 @@ func TestRemove_WithoutCachedStateChange(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) tt.mockFunc(sm, mockClient) err := sm.Remove(ctx, testState) @@ -412,7 +423,7 @@ func TestRemove_WithoutCachedStateChange(t *testing.T) { func TestContains_EmptyStateName(t *testing.T) { ctx := context.Background() - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) res, err := sm.Contains(ctx, "") require.Error(t, err) assert.False(t, res) @@ -433,7 +444,7 @@ func TestContains_WithCachedStateChange(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.kind, Value: testValue}) result, err := sm.Contains(ctx, testState) @@ -455,7 +466,7 @@ func TestContains_WithoutCachedStateChange(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) mockRequest := newGetActorStateRequest(sm, testState) mockResult := newGetActorStateResponse([]byte("result")) @@ -492,7 +503,7 @@ func TestSave_SingleCachedStateChange(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) mockCodec := sm.stateAsyncProvider.stateSerializer.(*mock.MockCodec) if tt.stateChanges != nil { @@ -514,7 +525,7 @@ func TestSave_SingleCachedStateChange(t *testing.T) { func TestSave_MultipleCachedStateChanges(t *testing.T) { ctx := context.Background() - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) mockCodec := sm.stateAsyncProvider.stateSerializer.(*mock.MockCodec) @@ -543,7 +554,7 @@ func TestSave_MultipleCachedStateChanges(t *testing.T) { func TestFlush(t *testing.T) { ctx := context.Background() - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) stateChanges := []struct { stateName string value string From 9481caf8aa12ce78231b611a3b5497f46416a398 Mon Sep 17 00:00:00 2001 From: KentHsu Date: Fri, 3 May 2024 01:07:36 +0800 Subject: [PATCH 06/15] tests: add tests for both stateManager and stateManagerCtx Signed-off-by: KentHsu --- actor/state/state_manager_test.go | 426 ++++++++++++++++++++++-------- 1 file changed, 313 insertions(+), 113 deletions(-) diff --git a/actor/state/state_manager_test.go b/actor/state/state_manager_test.go index e7501b6a..cee5bd6f 100644 --- a/actor/state/state_manager_test.go +++ b/actor/state/state_manager_test.go @@ -72,8 +72,10 @@ func TestStateManagerWithContext(t *testing.T) { func TestAdd_EmptyStateName(t *testing.T) { ctx := context.Background() - sm := newMockStateManagerCtx(t) - err := sm.Add(ctx, "", testValue) + sm := newMockStateManager(t) + err := sm.Add("", testValue) + require.Error(t, err) + err = sm.stateManagerCtx.Add(ctx, "", testValue) require.Error(t, err) } @@ -84,22 +86,33 @@ func TestAdd_WithCachedStateChange(t *testing.T) { name string kind ChangeKind shouldErr bool + context context.Context }{ - {"state change kind None", None, true}, - {"state change kind Add", Add, true}, - {"state change kind Update", Update, true}, - {"state change kind Remove", Remove, false}, + {"state change kind None", None, true, nil}, + {"state change kind Add", Add, true, nil}, + {"state change kind Update", Update, true, nil}, + {"state change kind Remove", Remove, false, nil}, + {"context state change kind None", None, true, ctx}, + {"context state change kind Add", Add, true, ctx}, + {"context state change kind Update", Update, true, ctx}, + {"context state change kind Remove", Remove, false, ctx}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManagerCtx(t) + sm := newMockStateManager(t) sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.kind, Value: testValue}) mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) - mockRequest := newGetActorStateRequest(sm, testState) + mockRequest := newGetActorStateRequest(sm.stateManagerCtx, testState) mockResult := newGetActorStateResponse([]byte("result")) mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(mockResult, nil) - err := sm.Add(ctx, testState, testValue) + var err error + if tt.context == nil { + err = sm.Add(testState, testValue) + } else { + err = sm.stateManagerCtx.Add(tt.context, testState, testValue) + } + if tt.shouldErr { require.Error(t, err) } else { @@ -123,16 +136,20 @@ func TestAdd_WithoutCachedStateChange(t *testing.T) { name string stateProviderErr bool duplicateState bool + context context.Context }{ - {"state provider returns error", true, false}, - {"state provider returns data", false, true}, - {"successfully add new state", false, false}, + {"state provider returns error", true, false, nil}, + {"state provider returns data", false, true, nil}, + {"successfully add new state", false, false, nil}, + {"context state provider returns error", true, false, ctx}, + {"context state provider returns data", false, true, ctx}, + {"context successfully add new state", false, false, ctx}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManagerCtx(t) + sm := newMockStateManager(t) mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) - mockRequest := newGetActorStateRequest(sm, testState) + mockRequest := newGetActorStateRequest(sm.stateManagerCtx, testState) mockResult := newGetActorStateResponse([]byte("result")) if tt.stateProviderErr { mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(nil, errors.New("mockErr")) @@ -144,7 +161,13 @@ func TestAdd_WithoutCachedStateChange(t *testing.T) { } } - err := sm.Add(ctx, testState, testValue) + var err error + if tt.context == nil { + err = sm.Add(testState, testValue) + } else { + err = sm.stateManagerCtx.Add(tt.context, testState, testValue) + } + if tt.stateProviderErr || tt.duplicateState { require.Error(t, err) } else { @@ -163,8 +186,10 @@ func TestAdd_WithoutCachedStateChange(t *testing.T) { func TestGet_EmptyStateName(t *testing.T) { ctx := context.Background() - sm := newMockStateManagerCtx(t) - err := sm.Get(ctx, "", testValue) + sm := newMockStateManager(t) + err := sm.Get("", testValue) + require.Error(t, err) + err = sm.stateManagerCtx.Get(ctx, "", testValue) require.Error(t, err) } @@ -175,19 +200,30 @@ func TestGet_WithCachedStateChange(t *testing.T) { name string kind ChangeKind shouldErr bool + context context.Context }{ - {"state change kind None", None, false}, - {"state change kind Add", Add, false}, - {"state change kind Update", Update, false}, - {"state change kind Remove", Remove, true}, + {"state change kind None", None, false, nil}, + {"state change kind Add", Add, false, nil}, + {"state change kind Update", Update, false, nil}, + {"state change kind Remove", Remove, true, nil}, + {"context state change kind None", None, false, ctx}, + {"context state change kind Add", Add, false, ctx}, + {"context state change kind Update", Update, false, ctx}, + {"context state change kind Remove", Remove, true, ctx}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManagerCtx(t) + sm := newMockStateManager(t) sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.kind, Value: testValue}) + var err error var reply string - err := sm.Get(ctx, testState, &reply) + if tt.context == nil { + err = sm.Get(testState, &reply) + } else { + err = sm.stateManagerCtx.Get(tt.context, testState, &reply) + } + if tt.shouldErr { require.Error(t, err) } else { @@ -204,16 +240,19 @@ func TestGet_WithoutCachedStateChange(t *testing.T) { tests := []struct { name string shouldErr bool + context context.Context }{ - {"state provider returns error", true}, - {"state provider returns data", false}, + {"state provider returns error", true, nil}, + {"state provider returns data", false, nil}, + {"context state provider returns error", true, ctx}, + {"context state provider returns data", false, ctx}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManagerCtx(t) + sm := newMockStateManager(t) mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) mockCodec := sm.stateAsyncProvider.stateSerializer.(*mock.MockCodec) - mockRequest := newGetActorStateRequest(sm, testState) + mockRequest := newGetActorStateRequest(sm.stateManagerCtx, testState) mockResult := newGetActorStateResponse([]byte("result")) if tt.shouldErr { mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(nil, errors.New("mockErr")) @@ -222,7 +261,13 @@ func TestGet_WithoutCachedStateChange(t *testing.T) { mockCodec.EXPECT().Unmarshal(mockResult.Data, testValue) } - err := sm.Get(ctx, testState, testValue) + var err error + if tt.context == nil { + err = sm.Get(testState, testValue) + } else { + err = sm.stateManagerCtx.Get(tt.context, testState, testValue) + } + if tt.shouldErr { require.Error(t, err) } else { @@ -241,8 +286,10 @@ func TestGet_WithoutCachedStateChange(t *testing.T) { func TestSet_EmptyStateName(t *testing.T) { ctx := context.Background() - sm := newMockStateManagerCtx(t) - err := sm.Set(ctx, "", testValue) + sm := newMockStateManager(t) + err := sm.Set("", testValue) + require.Error(t, err) + err = sm.stateManagerCtx.Set(ctx, "", testValue) require.Error(t, err) } @@ -253,19 +300,29 @@ func TestSet_WithCachedStateChange(t *testing.T) { name string initKind ChangeKind expectKind ChangeKind + context context.Context }{ - {"state change kind None", None, Update}, - {"state change kind Add", Add, Add}, - {"state change kind Update", Update, Update}, - {"state change kind Remove", Remove, Update}, + {"state change kind None", None, Update, nil}, + {"state change kind Add", Add, Add, nil}, + {"state change kind Update", Update, Update, nil}, + {"state change kind Remove", Remove, Update, nil}, + {"context state change kind None", None, Update, ctx}, + {"context state change kind Add", Add, Add, ctx}, + {"context state change kind Update", Update, Update, ctx}, + {"context state change kind Remove", Remove, Update, ctx}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManagerCtx(t) + sm := newMockStateManager(t) sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.initKind, Value: testValue}) - err := sm.Set(ctx, testState, testValue) - require.NoError(t, err) + if tt.context == nil { + err := sm.Set(testState, testValue) + require.NoError(t, err) + } else { + err := sm.stateManagerCtx.Set(tt.context, testState, testValue) + require.NoError(t, err) + } val, ok := sm.stateChangeTracker.Load(testState) require.True(t, ok) @@ -279,17 +336,34 @@ func TestSet_WithCachedStateChange(t *testing.T) { func TestSet_WithoutCachedStateChange(t *testing.T) { ctx := context.Background() - sm := newMockStateManagerCtx(t) - err := sm.Set(ctx, testState, testValue) - require.NoError(t, err) + tests := []struct { + name string + context context.Context + }{ + {"without context", nil}, + {"with context", ctx}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + sm := newMockStateManager(t) - val, ok := sm.stateChangeTracker.Load(testState) - require.True(t, ok) + if tt.context == nil { + err := sm.Set(testState, testValue) + require.NoError(t, err) + } else { + err := sm.stateManagerCtx.Set(tt.context, testState, testValue) + require.NoError(t, err) + } - metadata := val.(*ChangeMetadata) - assert.Equal(t, Add, metadata.Kind) - assert.Equal(t, testValue, metadata.Value) + val, ok := sm.stateChangeTracker.Load(testState) + require.True(t, ok) + + metadata := val.(*ChangeMetadata) + assert.Equal(t, Add, metadata.Kind) + assert.Equal(t, testValue, metadata.Value) + }) + } } func TestSetWithTTL_EmptyStateName(t *testing.T) { @@ -356,8 +430,10 @@ func TestSetWithTTL_WithoutCachedStateChange(t *testing.T) { func TestRemove_EmptyStateName(t *testing.T) { ctx := context.Background() - sm := newMockStateManagerCtx(t) - err := sm.Remove(ctx, "") + sm := newMockStateManager(t) + err := sm.Remove("") + require.Error(t, err) + err = sm.stateManagerCtx.Remove(ctx, "") require.Error(t, err) } @@ -368,19 +444,29 @@ func TestRemove_WithCachedStateChange(t *testing.T) { name string kind ChangeKind inCache bool + context context.Context }{ - {"state change kind None", None, true}, - {"state change kind Add", Add, false}, - {"state change kind Update", Update, false}, - {"state change kind Remove", Remove, true}, + {"state change kind None", None, true, nil}, + {"state change kind Add", Add, false, nil}, + {"state change kind Update", Update, false, nil}, + {"state change kind Remove", Remove, true, nil}, + {"context state change kind None", None, true, ctx}, + {"context state change kind Add", Add, false, ctx}, + {"context state change kind Update", Update, false, ctx}, + {"context state change kind Remove", Remove, true, ctx}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManagerCtx(t) + sm := newMockStateManager(t) sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.kind, Value: testValue}) - err := sm.Remove(ctx, testState) - require.NoError(t, err) + if tt.context == nil { + err := sm.Remove(testState) + require.NoError(t, err) + } else { + err := sm.stateManagerCtx.Remove(tt.context, testState) + require.NoError(t, err) + } val, ok := sm.stateChangeTracker.Load(testState) if tt.inCache { @@ -402,29 +488,58 @@ func TestRemove_WithoutCachedStateChange(t *testing.T) { tests := []struct { name string mockFunc func(sm *stateManagerCtx, mc *mock_client.MockClient) + context context.Context }{ - {"state provider returns error", func(sm *stateManagerCtx, mc *mock_client.MockClient) { - mc.EXPECT().GetActorState(ctx, newGetActorStateRequest(sm, testState)).Return(nil, mockErr) - }}, - {"state provider returns data", func(sm *stateManagerCtx, mc *mock_client.MockClient) { - mc.EXPECT().GetActorState(ctx, newGetActorStateRequest(sm, testState)).Return(mockResult, nil) - }}, + { + "state provider returns error", + func(sm *stateManagerCtx, mc *mock_client.MockClient) { + mc.EXPECT().GetActorState(ctx, newGetActorStateRequest(sm, testState)).Return(nil, mockErr) + }, + nil, + }, + { + "state provider returns data", + func(sm *stateManagerCtx, mc *mock_client.MockClient) { + mc.EXPECT().GetActorState(ctx, newGetActorStateRequest(sm, testState)).Return(mockResult, nil) + }, + nil}, + { + "state provider returns error", + func(sm *stateManagerCtx, mc *mock_client.MockClient) { + mc.EXPECT().GetActorState(ctx, newGetActorStateRequest(sm, testState)).Return(nil, mockErr) + }, + ctx}, + { + "state provider returns data", + func(sm *stateManagerCtx, mc *mock_client.MockClient) { + mc.EXPECT().GetActorState(ctx, newGetActorStateRequest(sm, testState)).Return(mockResult, nil) + }, + ctx}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManagerCtx(t) + sm := newMockStateManager(t) mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) - tt.mockFunc(sm, mockClient) - err := sm.Remove(ctx, testState) - require.NoError(t, err) + tt.mockFunc(sm.stateManagerCtx, mockClient) + + if tt.context == nil { + err := sm.Remove(testState) + require.NoError(t, err) + } else { + err := sm.stateManagerCtx.Remove(tt.context, testState) + require.NoError(t, err) + } }) } } func TestContains_EmptyStateName(t *testing.T) { ctx := context.Background() - sm := newMockStateManagerCtx(t) - res, err := sm.Contains(ctx, "") + sm := newMockStateManager(t) + res, err := sm.Contains("") + require.Error(t, err) + assert.False(t, res) + res, err = sm.stateManagerCtx.Contains(ctx, "") require.Error(t, err) assert.False(t, res) } @@ -436,20 +551,31 @@ func TestContains_WithCachedStateChange(t *testing.T) { name string kind ChangeKind expected bool + context context.Context }{ - {"state change kind None", None, true}, - {"state change kind Add", Add, true}, - {"state change kind Update", Update, true}, - {"state change kind Remove", Remove, false}, + {"state change kind None", None, true, nil}, + {"state change kind Add", Add, true, nil}, + {"state change kind Update", Update, true, nil}, + {"state change kind Remove", Remove, false, nil}, + {"context state change kind None", None, true, ctx}, + {"context state change kind Add", Add, true, ctx}, + {"context state change kind Update", Update, true, ctx}, + {"context state change kind Remove", Remove, false, ctx}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManagerCtx(t) + sm := newMockStateManager(t) sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.kind, Value: testValue}) - result, err := sm.Contains(ctx, testState) - require.NoError(t, err) - assert.Equal(t, tt.expected, result) + if tt.context == nil { + result, err := sm.Contains(testState) + require.NoError(t, err) + assert.Equal(t, tt.expected, result) + } else { + result, err := sm.stateManagerCtx.Contains(tt.context, testState) + require.NoError(t, err) + assert.Equal(t, tt.expected, result) + } }) } } @@ -460,15 +586,18 @@ func TestContains_WithoutCachedStateChange(t *testing.T) { tests := []struct { name string shouldErr bool + context context.Context }{ - {"state provider returns error", true}, - {"state provider returns data", false}, + {"state provider returns error", true, nil}, + {"state provider returns data", false, nil}, + {"context state provider returns error", true, ctx}, + {"context state provider returns data", false, ctx}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManagerCtx(t) + sm := newMockStateManager(t) mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) - mockRequest := newGetActorStateRequest(sm, testState) + mockRequest := newGetActorStateRequest(sm.stateManagerCtx, testState) mockResult := newGetActorStateResponse([]byte("result")) if tt.shouldErr { mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(nil, errors.New("mockErr")) @@ -476,7 +605,14 @@ func TestContains_WithoutCachedStateChange(t *testing.T) { mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(mockResult, nil) } - result, err := sm.Contains(ctx, testState) + var result bool + var err error + if tt.context == nil { + result, err = sm.Contains(testState) + } else { + result, err = sm.stateManagerCtx.Contains(tt.context, testState) + } + if tt.shouldErr { require.Error(t, err) assert.False(t, result) @@ -494,16 +630,21 @@ func TestSave_SingleCachedStateChange(t *testing.T) { tests := []struct { name string stateChanges *ChangeMetadata + context context.Context }{ - {"no state change", nil}, - {"state change kind None", &ChangeMetadata{Kind: None, Value: testValue}}, - {"state change kind Add", &ChangeMetadata{Kind: Add, Value: testValue}}, - {"state change kind Update", &ChangeMetadata{Kind: Update, Value: testValue}}, - {"state change kind Remove", &ChangeMetadata{Kind: Remove, Value: testValue}}, + {"no state change", nil, nil}, + {"state change kind None", &ChangeMetadata{Kind: None, Value: testValue}, nil}, + {"state change kind Add", &ChangeMetadata{Kind: Add, Value: testValue}, nil}, + {"state change kind Update", &ChangeMetadata{Kind: Update, Value: testValue}, nil}, + {"state change kind Remove", &ChangeMetadata{Kind: Remove, Value: testValue}, nil}, + {"context state change kind None", &ChangeMetadata{Kind: None, Value: testValue}, ctx}, + {"context state change kind Add", &ChangeMetadata{Kind: Add, Value: testValue}, ctx}, + {"context state change kind Update", &ChangeMetadata{Kind: Update, Value: testValue}, ctx}, + {"context state change kind Remove", &ChangeMetadata{Kind: Remove, Value: testValue}, ctx}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManagerCtx(t) + sm := newMockStateManager(t) mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) mockCodec := sm.stateAsyncProvider.stateSerializer.(*mock.MockCodec) if tt.stateChanges != nil { @@ -517,15 +658,20 @@ func TestSave_SingleCachedStateChange(t *testing.T) { } } - err := sm.Save(ctx) - require.NoError(t, err) + if tt.context == nil { + err := sm.Save() + require.NoError(t, err) + } else { + err := sm.stateManagerCtx.Save(tt.context) + require.NoError(t, err) + } }) } } func TestSave_MultipleCachedStateChanges(t *testing.T) { ctx := context.Background() - sm := newMockStateManagerCtx(t) + sm := newMockStateManager(t) mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) mockCodec := sm.stateAsyncProvider.stateSerializer.(*mock.MockCodec) @@ -548,40 +694,94 @@ func TestSave_MultipleCachedStateChanges(t *testing.T) { // 2 times: 1 Add, 1 Update mockCodec.EXPECT().Marshal(gomock.Any()).Times(2) - err := sm.Save(ctx) + err := sm.Save() + require.NoError(t, err) + err = sm.stateManagerCtx.Save(ctx) require.NoError(t, err) } func TestFlush(t *testing.T) { ctx := context.Background() - sm := newMockStateManagerCtx(t) - stateChanges := []struct { - stateName string - value string - kind ChangeKind + + tests := []struct { + name string + context context.Context }{ - {"stateNone", "valueNone", None}, - {"stateAdd", "valueAdd", Add}, - {"stateUpdate", "valueUpdate", Update}, - {"stateRemove", "valueRemove", Remove}, - } - for _, sc := range stateChanges { - sm.stateChangeTracker.Store(sc.stateName, &ChangeMetadata{Kind: sc.kind, Value: sc.value}) + {"no context", nil}, + {"context", ctx}, } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + sm := newMockStateManager(t) + stateChanges := []struct { + stateName string + value string + kind ChangeKind + }{ + {"stateNone", "valueNone", None}, + {"stateAdd", "valueAdd", Add}, + {"stateUpdate", "valueUpdate", Update}, + {"stateRemove", "valueRemove", Remove}, + } + for _, sc := range stateChanges { + sm.stateChangeTracker.Store(sc.stateName, &ChangeMetadata{Kind: sc.kind, Value: sc.value}) + } - sm.Flush(ctx) + if tt.context == nil { + sm.Flush() + } else { + sm.stateManagerCtx.Flush(tt.context) + } - for _, sc := range stateChanges { - val, ok := sm.stateChangeTracker.Load(sc.stateName) - if sc.kind == Remove { - assert.Nil(t, val) - assert.False(t, ok) - } else { - metadata := val.(*ChangeMetadata) - assert.True(t, ok) - assert.Equal(t, None, metadata.Kind) - assert.Equal(t, sc.value, metadata.Value) - } + for _, sc := range stateChanges { + val, ok := sm.stateChangeTracker.Load(sc.stateName) + if sc.kind == Remove { + assert.Nil(t, val) + assert.False(t, ok) + } else { + metadata := val.(*ChangeMetadata) + assert.True(t, ok) + assert.Equal(t, None, metadata.Kind) + assert.Equal(t, sc.value, metadata.Value) + } + } + }) + } +} + +func TestNewActorStateManager(t *testing.T) { + type args struct { + actorTypeName string + actorID string + stateAsyncProvider *DaprStateAsyncProvider + } + tests := []struct { + name string + args args + want *stateManager + }{ + { + name: "init", + args: args{ + actorTypeName: "test", + actorID: "fn", + stateAsyncProvider: &DaprStateAsyncProvider{}, + }, + want: &stateManager{ + &stateManagerCtx{ + actorTypeName: "test", + actorID: "fn", + stateAsyncProvider: &DaprStateAsyncProvider{}, + }, + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := NewActorStateManager(tt.args.actorTypeName, tt.args.actorID, tt.args.stateAsyncProvider); !reflect.DeepEqual(got, tt.want) { + t.Errorf("NewActorStateManager() = %v, want %v", got, tt.want) + } + }) } } From c41850fa3fe28ca5d6d70f579f8ade310f2cf78d Mon Sep 17 00:00:00 2001 From: KentHsu Date: Fri, 3 May 2024 01:11:49 +0800 Subject: [PATCH 07/15] Revert "tests: add tests for both stateManager and stateManagerCtx" This reverts commit 9481caf8aa12ce78231b611a3b5497f46416a398. Signed-off-by: KentHsu --- actor/state/state_manager_test.go | 426 ++++++++---------------------- 1 file changed, 113 insertions(+), 313 deletions(-) diff --git a/actor/state/state_manager_test.go b/actor/state/state_manager_test.go index cee5bd6f..e7501b6a 100644 --- a/actor/state/state_manager_test.go +++ b/actor/state/state_manager_test.go @@ -72,10 +72,8 @@ func TestStateManagerWithContext(t *testing.T) { func TestAdd_EmptyStateName(t *testing.T) { ctx := context.Background() - sm := newMockStateManager(t) - err := sm.Add("", testValue) - require.Error(t, err) - err = sm.stateManagerCtx.Add(ctx, "", testValue) + sm := newMockStateManagerCtx(t) + err := sm.Add(ctx, "", testValue) require.Error(t, err) } @@ -86,33 +84,22 @@ func TestAdd_WithCachedStateChange(t *testing.T) { name string kind ChangeKind shouldErr bool - context context.Context }{ - {"state change kind None", None, true, nil}, - {"state change kind Add", Add, true, nil}, - {"state change kind Update", Update, true, nil}, - {"state change kind Remove", Remove, false, nil}, - {"context state change kind None", None, true, ctx}, - {"context state change kind Add", Add, true, ctx}, - {"context state change kind Update", Update, true, ctx}, - {"context state change kind Remove", Remove, false, ctx}, + {"state change kind None", None, true}, + {"state change kind Add", Add, true}, + {"state change kind Update", Update, true}, + {"state change kind Remove", Remove, false}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.kind, Value: testValue}) mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) - mockRequest := newGetActorStateRequest(sm.stateManagerCtx, testState) + mockRequest := newGetActorStateRequest(sm, testState) mockResult := newGetActorStateResponse([]byte("result")) mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(mockResult, nil) - var err error - if tt.context == nil { - err = sm.Add(testState, testValue) - } else { - err = sm.stateManagerCtx.Add(tt.context, testState, testValue) - } - + err := sm.Add(ctx, testState, testValue) if tt.shouldErr { require.Error(t, err) } else { @@ -136,20 +123,16 @@ func TestAdd_WithoutCachedStateChange(t *testing.T) { name string stateProviderErr bool duplicateState bool - context context.Context }{ - {"state provider returns error", true, false, nil}, - {"state provider returns data", false, true, nil}, - {"successfully add new state", false, false, nil}, - {"context state provider returns error", true, false, ctx}, - {"context state provider returns data", false, true, ctx}, - {"context successfully add new state", false, false, ctx}, + {"state provider returns error", true, false}, + {"state provider returns data", false, true}, + {"successfully add new state", false, false}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) - mockRequest := newGetActorStateRequest(sm.stateManagerCtx, testState) + mockRequest := newGetActorStateRequest(sm, testState) mockResult := newGetActorStateResponse([]byte("result")) if tt.stateProviderErr { mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(nil, errors.New("mockErr")) @@ -161,13 +144,7 @@ func TestAdd_WithoutCachedStateChange(t *testing.T) { } } - var err error - if tt.context == nil { - err = sm.Add(testState, testValue) - } else { - err = sm.stateManagerCtx.Add(tt.context, testState, testValue) - } - + err := sm.Add(ctx, testState, testValue) if tt.stateProviderErr || tt.duplicateState { require.Error(t, err) } else { @@ -186,10 +163,8 @@ func TestAdd_WithoutCachedStateChange(t *testing.T) { func TestGet_EmptyStateName(t *testing.T) { ctx := context.Background() - sm := newMockStateManager(t) - err := sm.Get("", testValue) - require.Error(t, err) - err = sm.stateManagerCtx.Get(ctx, "", testValue) + sm := newMockStateManagerCtx(t) + err := sm.Get(ctx, "", testValue) require.Error(t, err) } @@ -200,30 +175,19 @@ func TestGet_WithCachedStateChange(t *testing.T) { name string kind ChangeKind shouldErr bool - context context.Context }{ - {"state change kind None", None, false, nil}, - {"state change kind Add", Add, false, nil}, - {"state change kind Update", Update, false, nil}, - {"state change kind Remove", Remove, true, nil}, - {"context state change kind None", None, false, ctx}, - {"context state change kind Add", Add, false, ctx}, - {"context state change kind Update", Update, false, ctx}, - {"context state change kind Remove", Remove, true, ctx}, + {"state change kind None", None, false}, + {"state change kind Add", Add, false}, + {"state change kind Update", Update, false}, + {"state change kind Remove", Remove, true}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.kind, Value: testValue}) - var err error var reply string - if tt.context == nil { - err = sm.Get(testState, &reply) - } else { - err = sm.stateManagerCtx.Get(tt.context, testState, &reply) - } - + err := sm.Get(ctx, testState, &reply) if tt.shouldErr { require.Error(t, err) } else { @@ -240,19 +204,16 @@ func TestGet_WithoutCachedStateChange(t *testing.T) { tests := []struct { name string shouldErr bool - context context.Context }{ - {"state provider returns error", true, nil}, - {"state provider returns data", false, nil}, - {"context state provider returns error", true, ctx}, - {"context state provider returns data", false, ctx}, + {"state provider returns error", true}, + {"state provider returns data", false}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) mockCodec := sm.stateAsyncProvider.stateSerializer.(*mock.MockCodec) - mockRequest := newGetActorStateRequest(sm.stateManagerCtx, testState) + mockRequest := newGetActorStateRequest(sm, testState) mockResult := newGetActorStateResponse([]byte("result")) if tt.shouldErr { mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(nil, errors.New("mockErr")) @@ -261,13 +222,7 @@ func TestGet_WithoutCachedStateChange(t *testing.T) { mockCodec.EXPECT().Unmarshal(mockResult.Data, testValue) } - var err error - if tt.context == nil { - err = sm.Get(testState, testValue) - } else { - err = sm.stateManagerCtx.Get(tt.context, testState, testValue) - } - + err := sm.Get(ctx, testState, testValue) if tt.shouldErr { require.Error(t, err) } else { @@ -286,10 +241,8 @@ func TestGet_WithoutCachedStateChange(t *testing.T) { func TestSet_EmptyStateName(t *testing.T) { ctx := context.Background() - sm := newMockStateManager(t) - err := sm.Set("", testValue) - require.Error(t, err) - err = sm.stateManagerCtx.Set(ctx, "", testValue) + sm := newMockStateManagerCtx(t) + err := sm.Set(ctx, "", testValue) require.Error(t, err) } @@ -300,29 +253,19 @@ func TestSet_WithCachedStateChange(t *testing.T) { name string initKind ChangeKind expectKind ChangeKind - context context.Context }{ - {"state change kind None", None, Update, nil}, - {"state change kind Add", Add, Add, nil}, - {"state change kind Update", Update, Update, nil}, - {"state change kind Remove", Remove, Update, nil}, - {"context state change kind None", None, Update, ctx}, - {"context state change kind Add", Add, Add, ctx}, - {"context state change kind Update", Update, Update, ctx}, - {"context state change kind Remove", Remove, Update, ctx}, + {"state change kind None", None, Update}, + {"state change kind Add", Add, Add}, + {"state change kind Update", Update, Update}, + {"state change kind Remove", Remove, Update}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.initKind, Value: testValue}) - if tt.context == nil { - err := sm.Set(testState, testValue) - require.NoError(t, err) - } else { - err := sm.stateManagerCtx.Set(tt.context, testState, testValue) - require.NoError(t, err) - } + err := sm.Set(ctx, testState, testValue) + require.NoError(t, err) val, ok := sm.stateChangeTracker.Load(testState) require.True(t, ok) @@ -336,34 +279,17 @@ func TestSet_WithCachedStateChange(t *testing.T) { func TestSet_WithoutCachedStateChange(t *testing.T) { ctx := context.Background() + sm := newMockStateManagerCtx(t) - tests := []struct { - name string - context context.Context - }{ - {"without context", nil}, - {"with context", ctx}, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManager(t) - - if tt.context == nil { - err := sm.Set(testState, testValue) - require.NoError(t, err) - } else { - err := sm.stateManagerCtx.Set(tt.context, testState, testValue) - require.NoError(t, err) - } + err := sm.Set(ctx, testState, testValue) + require.NoError(t, err) - val, ok := sm.stateChangeTracker.Load(testState) - require.True(t, ok) + val, ok := sm.stateChangeTracker.Load(testState) + require.True(t, ok) - metadata := val.(*ChangeMetadata) - assert.Equal(t, Add, metadata.Kind) - assert.Equal(t, testValue, metadata.Value) - }) - } + metadata := val.(*ChangeMetadata) + assert.Equal(t, Add, metadata.Kind) + assert.Equal(t, testValue, metadata.Value) } func TestSetWithTTL_EmptyStateName(t *testing.T) { @@ -430,10 +356,8 @@ func TestSetWithTTL_WithoutCachedStateChange(t *testing.T) { func TestRemove_EmptyStateName(t *testing.T) { ctx := context.Background() - sm := newMockStateManager(t) - err := sm.Remove("") - require.Error(t, err) - err = sm.stateManagerCtx.Remove(ctx, "") + sm := newMockStateManagerCtx(t) + err := sm.Remove(ctx, "") require.Error(t, err) } @@ -444,29 +368,19 @@ func TestRemove_WithCachedStateChange(t *testing.T) { name string kind ChangeKind inCache bool - context context.Context }{ - {"state change kind None", None, true, nil}, - {"state change kind Add", Add, false, nil}, - {"state change kind Update", Update, false, nil}, - {"state change kind Remove", Remove, true, nil}, - {"context state change kind None", None, true, ctx}, - {"context state change kind Add", Add, false, ctx}, - {"context state change kind Update", Update, false, ctx}, - {"context state change kind Remove", Remove, true, ctx}, + {"state change kind None", None, true}, + {"state change kind Add", Add, false}, + {"state change kind Update", Update, false}, + {"state change kind Remove", Remove, true}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.kind, Value: testValue}) - if tt.context == nil { - err := sm.Remove(testState) - require.NoError(t, err) - } else { - err := sm.stateManagerCtx.Remove(tt.context, testState) - require.NoError(t, err) - } + err := sm.Remove(ctx, testState) + require.NoError(t, err) val, ok := sm.stateChangeTracker.Load(testState) if tt.inCache { @@ -488,58 +402,29 @@ func TestRemove_WithoutCachedStateChange(t *testing.T) { tests := []struct { name string mockFunc func(sm *stateManagerCtx, mc *mock_client.MockClient) - context context.Context }{ - { - "state provider returns error", - func(sm *stateManagerCtx, mc *mock_client.MockClient) { - mc.EXPECT().GetActorState(ctx, newGetActorStateRequest(sm, testState)).Return(nil, mockErr) - }, - nil, - }, - { - "state provider returns data", - func(sm *stateManagerCtx, mc *mock_client.MockClient) { - mc.EXPECT().GetActorState(ctx, newGetActorStateRequest(sm, testState)).Return(mockResult, nil) - }, - nil}, - { - "state provider returns error", - func(sm *stateManagerCtx, mc *mock_client.MockClient) { - mc.EXPECT().GetActorState(ctx, newGetActorStateRequest(sm, testState)).Return(nil, mockErr) - }, - ctx}, - { - "state provider returns data", - func(sm *stateManagerCtx, mc *mock_client.MockClient) { - mc.EXPECT().GetActorState(ctx, newGetActorStateRequest(sm, testState)).Return(mockResult, nil) - }, - ctx}, + {"state provider returns error", func(sm *stateManagerCtx, mc *mock_client.MockClient) { + mc.EXPECT().GetActorState(ctx, newGetActorStateRequest(sm, testState)).Return(nil, mockErr) + }}, + {"state provider returns data", func(sm *stateManagerCtx, mc *mock_client.MockClient) { + mc.EXPECT().GetActorState(ctx, newGetActorStateRequest(sm, testState)).Return(mockResult, nil) + }}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) - tt.mockFunc(sm.stateManagerCtx, mockClient) - - if tt.context == nil { - err := sm.Remove(testState) - require.NoError(t, err) - } else { - err := sm.stateManagerCtx.Remove(tt.context, testState) - require.NoError(t, err) - } + tt.mockFunc(sm, mockClient) + err := sm.Remove(ctx, testState) + require.NoError(t, err) }) } } func TestContains_EmptyStateName(t *testing.T) { ctx := context.Background() - sm := newMockStateManager(t) - res, err := sm.Contains("") - require.Error(t, err) - assert.False(t, res) - res, err = sm.stateManagerCtx.Contains(ctx, "") + sm := newMockStateManagerCtx(t) + res, err := sm.Contains(ctx, "") require.Error(t, err) assert.False(t, res) } @@ -551,31 +436,20 @@ func TestContains_WithCachedStateChange(t *testing.T) { name string kind ChangeKind expected bool - context context.Context }{ - {"state change kind None", None, true, nil}, - {"state change kind Add", Add, true, nil}, - {"state change kind Update", Update, true, nil}, - {"state change kind Remove", Remove, false, nil}, - {"context state change kind None", None, true, ctx}, - {"context state change kind Add", Add, true, ctx}, - {"context state change kind Update", Update, true, ctx}, - {"context state change kind Remove", Remove, false, ctx}, + {"state change kind None", None, true}, + {"state change kind Add", Add, true}, + {"state change kind Update", Update, true}, + {"state change kind Remove", Remove, false}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.kind, Value: testValue}) - if tt.context == nil { - result, err := sm.Contains(testState) - require.NoError(t, err) - assert.Equal(t, tt.expected, result) - } else { - result, err := sm.stateManagerCtx.Contains(tt.context, testState) - require.NoError(t, err) - assert.Equal(t, tt.expected, result) - } + result, err := sm.Contains(ctx, testState) + require.NoError(t, err) + assert.Equal(t, tt.expected, result) }) } } @@ -586,18 +460,15 @@ func TestContains_WithoutCachedStateChange(t *testing.T) { tests := []struct { name string shouldErr bool - context context.Context }{ - {"state provider returns error", true, nil}, - {"state provider returns data", false, nil}, - {"context state provider returns error", true, ctx}, - {"context state provider returns data", false, ctx}, + {"state provider returns error", true}, + {"state provider returns data", false}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) - mockRequest := newGetActorStateRequest(sm.stateManagerCtx, testState) + mockRequest := newGetActorStateRequest(sm, testState) mockResult := newGetActorStateResponse([]byte("result")) if tt.shouldErr { mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(nil, errors.New("mockErr")) @@ -605,14 +476,7 @@ func TestContains_WithoutCachedStateChange(t *testing.T) { mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(mockResult, nil) } - var result bool - var err error - if tt.context == nil { - result, err = sm.Contains(testState) - } else { - result, err = sm.stateManagerCtx.Contains(tt.context, testState) - } - + result, err := sm.Contains(ctx, testState) if tt.shouldErr { require.Error(t, err) assert.False(t, result) @@ -630,21 +494,16 @@ func TestSave_SingleCachedStateChange(t *testing.T) { tests := []struct { name string stateChanges *ChangeMetadata - context context.Context }{ - {"no state change", nil, nil}, - {"state change kind None", &ChangeMetadata{Kind: None, Value: testValue}, nil}, - {"state change kind Add", &ChangeMetadata{Kind: Add, Value: testValue}, nil}, - {"state change kind Update", &ChangeMetadata{Kind: Update, Value: testValue}, nil}, - {"state change kind Remove", &ChangeMetadata{Kind: Remove, Value: testValue}, nil}, - {"context state change kind None", &ChangeMetadata{Kind: None, Value: testValue}, ctx}, - {"context state change kind Add", &ChangeMetadata{Kind: Add, Value: testValue}, ctx}, - {"context state change kind Update", &ChangeMetadata{Kind: Update, Value: testValue}, ctx}, - {"context state change kind Remove", &ChangeMetadata{Kind: Remove, Value: testValue}, ctx}, + {"no state change", nil}, + {"state change kind None", &ChangeMetadata{Kind: None, Value: testValue}}, + {"state change kind Add", &ChangeMetadata{Kind: Add, Value: testValue}}, + {"state change kind Update", &ChangeMetadata{Kind: Update, Value: testValue}}, + {"state change kind Remove", &ChangeMetadata{Kind: Remove, Value: testValue}}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) mockCodec := sm.stateAsyncProvider.stateSerializer.(*mock.MockCodec) if tt.stateChanges != nil { @@ -658,20 +517,15 @@ func TestSave_SingleCachedStateChange(t *testing.T) { } } - if tt.context == nil { - err := sm.Save() - require.NoError(t, err) - } else { - err := sm.stateManagerCtx.Save(tt.context) - require.NoError(t, err) - } + err := sm.Save(ctx) + require.NoError(t, err) }) } } func TestSave_MultipleCachedStateChanges(t *testing.T) { ctx := context.Background() - sm := newMockStateManager(t) + sm := newMockStateManagerCtx(t) mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) mockCodec := sm.stateAsyncProvider.stateSerializer.(*mock.MockCodec) @@ -694,94 +548,40 @@ func TestSave_MultipleCachedStateChanges(t *testing.T) { // 2 times: 1 Add, 1 Update mockCodec.EXPECT().Marshal(gomock.Any()).Times(2) - err := sm.Save() - require.NoError(t, err) - err = sm.stateManagerCtx.Save(ctx) + err := sm.Save(ctx) require.NoError(t, err) } func TestFlush(t *testing.T) { ctx := context.Background() - - tests := []struct { - name string - context context.Context + sm := newMockStateManagerCtx(t) + stateChanges := []struct { + stateName string + value string + kind ChangeKind }{ - {"no context", nil}, - {"context", ctx}, + {"stateNone", "valueNone", None}, + {"stateAdd", "valueAdd", Add}, + {"stateUpdate", "valueUpdate", Update}, + {"stateRemove", "valueRemove", Remove}, } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - sm := newMockStateManager(t) - stateChanges := []struct { - stateName string - value string - kind ChangeKind - }{ - {"stateNone", "valueNone", None}, - {"stateAdd", "valueAdd", Add}, - {"stateUpdate", "valueUpdate", Update}, - {"stateRemove", "valueRemove", Remove}, - } - for _, sc := range stateChanges { - sm.stateChangeTracker.Store(sc.stateName, &ChangeMetadata{Kind: sc.kind, Value: sc.value}) - } - - if tt.context == nil { - sm.Flush() - } else { - sm.stateManagerCtx.Flush(tt.context) - } - - for _, sc := range stateChanges { - val, ok := sm.stateChangeTracker.Load(sc.stateName) - if sc.kind == Remove { - assert.Nil(t, val) - assert.False(t, ok) - } else { - metadata := val.(*ChangeMetadata) - assert.True(t, ok) - assert.Equal(t, None, metadata.Kind) - assert.Equal(t, sc.value, metadata.Value) - } - } - }) + for _, sc := range stateChanges { + sm.stateChangeTracker.Store(sc.stateName, &ChangeMetadata{Kind: sc.kind, Value: sc.value}) } -} -func TestNewActorStateManager(t *testing.T) { - type args struct { - actorTypeName string - actorID string - stateAsyncProvider *DaprStateAsyncProvider - } - tests := []struct { - name string - args args - want *stateManager - }{ - { - name: "init", - args: args{ - actorTypeName: "test", - actorID: "fn", - stateAsyncProvider: &DaprStateAsyncProvider{}, - }, - want: &stateManager{ - &stateManagerCtx{ - actorTypeName: "test", - actorID: "fn", - stateAsyncProvider: &DaprStateAsyncProvider{}, - }, - }, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - if got := NewActorStateManager(tt.args.actorTypeName, tt.args.actorID, tt.args.stateAsyncProvider); !reflect.DeepEqual(got, tt.want) { - t.Errorf("NewActorStateManager() = %v, want %v", got, tt.want) - } - }) + sm.Flush(ctx) + + for _, sc := range stateChanges { + val, ok := sm.stateChangeTracker.Load(sc.stateName) + if sc.kind == Remove { + assert.Nil(t, val) + assert.False(t, ok) + } else { + metadata := val.(*ChangeMetadata) + assert.True(t, ok) + assert.Equal(t, None, metadata.Kind) + assert.Equal(t, sc.value, metadata.Value) + } } } From 644e1aa3c1780f8dad480f37274cee73053e6f29 Mon Sep 17 00:00:00 2001 From: KentHsu Date: Fri, 3 May 2024 07:31:31 +0800 Subject: [PATCH 08/15] tests: copy stateManagerCtx tests to stateManager Signed-off-by: KentHsu --- actor/state/state_manager_test.go | 520 ++++++++++++++++++++++++++++-- 1 file changed, 497 insertions(+), 23 deletions(-) diff --git a/actor/state/state_manager_test.go b/actor/state/state_manager_test.go index e7501b6a..0be32499 100644 --- a/actor/state/state_manager_test.go +++ b/actor/state/state_manager_test.go @@ -65,19 +65,457 @@ func newGetActorStateResponse(data []byte) *client.GetActorStateResponse { return &client.GetActorStateResponse{Data: data} } -func TestStateManagerWithContext(t *testing.T) { +func TestAdd_EmptyStateName(t *testing.T) { + sm := newMockStateManager(t) + err := sm.Add("", testValue) + require.Error(t, err) +} + +func TestAdd_WithCachedStateChange(t *testing.T) { + ctx := context.Background() + + tests := []struct { + name string + kind ChangeKind + shouldErr bool + }{ + {"state change kind None", None, true}, + {"state change kind Add", Add, true}, + {"state change kind Update", Update, true}, + {"state change kind Remove", Remove, false}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + sm := newMockStateManager(t) + sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.kind, Value: testValue}) + mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) + mockRequest := newGetActorStateRequest(sm.stateManagerCtx, testState) + mockResult := newGetActorStateResponse([]byte("result")) + mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(mockResult, nil) + + err := sm.Add(testState, testValue) + if tt.shouldErr { + require.Error(t, err) + } else { + require.NoError(t, err) + + val, ok := sm.stateChangeTracker.Load(testState) + require.True(t, ok) + + metadata := val.(*ChangeMetadata) + assert.Equal(t, Update, metadata.Kind) + assert.Equal(t, testValue, metadata.Value) + } + }) + } +} + +func TestAdd_WithoutCachedStateChange(t *testing.T) { + ctx := context.Background() + + tests := []struct { + name string + stateProviderErr bool + duplicateState bool + }{ + {"state provider returns error", true, false}, + {"state provider returns data", false, true}, + {"successfully add new state", false, false}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + sm := newMockStateManager(t) + mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) + mockRequest := newGetActorStateRequest(sm.stateManagerCtx, testState) + mockResult := newGetActorStateResponse([]byte("result")) + if tt.stateProviderErr { + mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(nil, errors.New("mockErr")) + } else { + if tt.duplicateState { + mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(mockResult, nil) + } else { + mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(nil, nil) + } + } + + err := sm.Add(testState, testValue) + if tt.stateProviderErr || tt.duplicateState { + require.Error(t, err) + } else { + require.NoError(t, err) + + val, ok := sm.stateChangeTracker.Load(testState) + require.True(t, ok) + + metadata := val.(*ChangeMetadata) + assert.Equal(t, Add, metadata.Kind) + assert.Equal(t, testValue, metadata.Value) + } + }) + } +} + +func TestGet_EmptyStateName(t *testing.T) { + sm := newMockStateManager(t) + err := sm.Get("", testValue) + require.Error(t, err) +} + +func TestGet_WithCachedStateChange(t *testing.T) { + tests := []struct { + name string + kind ChangeKind + shouldErr bool + }{ + {"state change kind None", None, false}, + {"state change kind Add", Add, false}, + {"state change kind Update", Update, false}, + {"state change kind Remove", Remove, true}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + sm := newMockStateManager(t) + sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.kind, Value: testValue}) + + var reply string + err := sm.Get(testState, &reply) + if tt.shouldErr { + require.Error(t, err) + } else { + require.NoError(t, err) + assert.Equal(t, testValue, reply) + } + }) + } +} + +func TestGet_WithoutCachedStateChange(t *testing.T) { + ctx := context.Background() + + tests := []struct { + name string + shouldErr bool + }{ + {"state provider returns error", true}, + {"state provider returns data", false}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + sm := newMockStateManager(t) + mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) + mockCodec := sm.stateAsyncProvider.stateSerializer.(*mock.MockCodec) + mockRequest := newGetActorStateRequest(sm.stateManagerCtx, testState) + mockResult := newGetActorStateResponse([]byte("result")) + if tt.shouldErr { + mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(nil, errors.New("mockErr")) + } else { + mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(mockResult, nil) + mockCodec.EXPECT().Unmarshal(mockResult.Data, testValue) + } + + err := sm.Get(testState, testValue) + if tt.shouldErr { + require.Error(t, err) + } else { + require.NoError(t, err) + } + + val, ok := sm.stateChangeTracker.Load(testState) + require.True(t, ok) + + metadata := val.(*ChangeMetadata) + assert.Equal(t, None, metadata.Kind) + assert.Equal(t, testValue, metadata.Value) + }) + } +} + +func TestSet_EmptyStateName(t *testing.T) { + sm := newMockStateManager(t) + err := sm.Set("", testValue) + require.Error(t, err) +} + +func TestSet_WithCachedStateChange(t *testing.T) { + tests := []struct { + name string + initKind ChangeKind + expectKind ChangeKind + }{ + {"state change kind None", None, Update}, + {"state change kind Add", Add, Add}, + {"state change kind Update", Update, Update}, + {"state change kind Remove", Remove, Update}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + sm := newMockStateManager(t) + sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.initKind, Value: testValue}) + + err := sm.Set(testState, testValue) + require.NoError(t, err) + + val, ok := sm.stateChangeTracker.Load(testState) + require.True(t, ok) + + metadata := val.(*ChangeMetadata) + assert.Equal(t, tt.expectKind, metadata.Kind) + assert.Equal(t, testValue, metadata.Value) + }) + } +} + +func TestSet_WithoutCachedStateChange(t *testing.T) { + sm := newMockStateManager(t) + + err := sm.Set(testState, testValue) + require.NoError(t, err) + + val, ok := sm.stateChangeTracker.Load(testState) + require.True(t, ok) + + metadata := val.(*ChangeMetadata) + assert.Equal(t, Add, metadata.Kind) + assert.Equal(t, testValue, metadata.Value) +} + +func TestRemove_EmptyStateName(t *testing.T) { + sm := newMockStateManager(t) + err := sm.Remove("") + require.Error(t, err) +} + +func TestRemove_WithCachedStateChange(t *testing.T) { + tests := []struct { + name string + kind ChangeKind + inCache bool + }{ + {"state change kind None", None, true}, + {"state change kind Add", Add, false}, + {"state change kind Update", Update, false}, + {"state change kind Remove", Remove, true}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + sm := newMockStateManager(t) + sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.kind, Value: testValue}) + + err := sm.Remove(testState) + require.NoError(t, err) + + val, ok := sm.stateChangeTracker.Load(testState) + if tt.inCache { + assert.Equal(t, Remove, val.(*ChangeMetadata).Kind) + assert.True(t, ok) + } else { + assert.Nil(t, val) + assert.False(t, ok) + } + }) + } +} + +func TestRemove_WithoutCachedStateChange(t *testing.T) { + ctx := context.Background() + mockResult := newGetActorStateResponse([]byte("result")) + mockErr := errors.New("mockErr") + + tests := []struct { + name string + mockFunc func(sm *stateManagerCtx, mc *mock_client.MockClient) + }{ + {"state provider returns error", func(sm *stateManagerCtx, mc *mock_client.MockClient) { + mc.EXPECT().GetActorState(ctx, newGetActorStateRequest(sm, testState)).Return(nil, mockErr) + }}, + {"state provider returns data", func(sm *stateManagerCtx, mc *mock_client.MockClient) { + mc.EXPECT().GetActorState(ctx, newGetActorStateRequest(sm, testState)).Return(mockResult, nil) + }}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + sm := newMockStateManager(t) + mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) + tt.mockFunc(sm.stateManagerCtx, mockClient) + err := sm.Remove(testState) + require.NoError(t, err) + }) + } +} + +func TestContains_EmptyStateName(t *testing.T) { + sm := newMockStateManager(t) + res, err := sm.Contains("") + require.Error(t, err) + assert.False(t, res) +} + +func TestContains_WithCachedStateChange(t *testing.T) { + tests := []struct { + name string + kind ChangeKind + expected bool + }{ + {"state change kind None", None, true}, + {"state change kind Add", Add, true}, + {"state change kind Update", Update, true}, + {"state change kind Remove", Remove, false}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + sm := newMockStateManager(t) + sm.stateChangeTracker.Store(testState, &ChangeMetadata{Kind: tt.kind, Value: testValue}) + + result, err := sm.Contains(testState) + require.NoError(t, err) + assert.Equal(t, tt.expected, result) + }) + } +} + +func TestContains_WithoutCachedStateChange(t *testing.T) { + ctx := context.Background() + + tests := []struct { + name string + shouldErr bool + }{ + {"state provider returns error", true}, + {"state provider returns data", false}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + sm := newMockStateManager(t) + mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) + mockRequest := newGetActorStateRequest(sm.stateManagerCtx, testState) + mockResult := newGetActorStateResponse([]byte("result")) + if tt.shouldErr { + mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(nil, errors.New("mockErr")) + } else { + mockClient.EXPECT().GetActorState(ctx, mockRequest).Return(mockResult, nil) + } + + result, err := sm.Contains(testState) + if tt.shouldErr { + require.Error(t, err) + assert.False(t, result) + } else { + require.NoError(t, err) + assert.True(t, result) + } + }) + } +} + +func TestSave_SingleCachedStateChange(t *testing.T) { + ctx := context.Background() + + tests := []struct { + name string + stateChanges *ChangeMetadata + }{ + {"no state change", nil}, + {"state change kind None", &ChangeMetadata{Kind: None, Value: testValue}}, + {"state change kind Add", &ChangeMetadata{Kind: Add, Value: testValue}}, + {"state change kind Update", &ChangeMetadata{Kind: Update, Value: testValue}}, + {"state change kind Remove", &ChangeMetadata{Kind: Remove, Value: testValue}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + sm := newMockStateManager(t) + mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) + mockCodec := sm.stateAsyncProvider.stateSerializer.(*mock.MockCodec) + if tt.stateChanges != nil { + sm.stateChangeTracker.Store(testState, tt.stateChanges) + + if tt.stateChanges.Kind == Remove { + mockClient.EXPECT().SaveStateTransactionally(ctx, sm.actorTypeName, sm.actorID, gomock.Len(1)) + } else if tt.stateChanges.Kind == Add || tt.stateChanges.Kind == Update { + mockClient.EXPECT().SaveStateTransactionally(ctx, sm.actorTypeName, sm.actorID, gomock.Len(1)) + mockCodec.EXPECT().Marshal(tt.stateChanges.Value) + } + } + + err := sm.Save() + require.NoError(t, err) + }) + } +} + +func TestSave_MultipleCachedStateChanges(t *testing.T) { + ctx := context.Background() + sm := newMockStateManager(t) + mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) + mockCodec := sm.stateAsyncProvider.stateSerializer.(*mock.MockCodec) + + stateChanges := []struct { + stateName string + value string + kind ChangeKind + }{ + {"stateNone", "valueNone", None}, + {"stateAdd", "valueAdd", Add}, + {"stateUpdate", "valueUpdate", Update}, + {"stateRemove", "valueRemove", Remove}, + } + for _, sc := range stateChanges { + sm.stateChangeTracker.Store(sc.stateName, &ChangeMetadata{Kind: sc.kind, Value: sc.value}) + } + + // 3 operations: 1 Add, 1 Update, 1 Remove + mockClient.EXPECT().SaveStateTransactionally(ctx, sm.actorTypeName, sm.actorID, gomock.Len(3)) + // 2 times: 1 Add, 1 Update + mockCodec.EXPECT().Marshal(gomock.Any()).Times(2) + + err := sm.Save() + require.NoError(t, err) +} + +func TestFlush(t *testing.T) { + sm := newMockStateManager(t) + stateChanges := []struct { + stateName string + value string + kind ChangeKind + }{ + {"stateNone", "valueNone", None}, + {"stateAdd", "valueAdd", Add}, + {"stateUpdate", "valueUpdate", Update}, + {"stateRemove", "valueRemove", Remove}, + } + for _, sc := range stateChanges { + sm.stateChangeTracker.Store(sc.stateName, &ChangeMetadata{Kind: sc.kind, Value: sc.value}) + } + + sm.Flush() + + for _, sc := range stateChanges { + val, ok := sm.stateChangeTracker.Load(sc.stateName) + if sc.kind == Remove { + assert.Nil(t, val) + assert.False(t, ok) + } else { + metadata := val.(*ChangeMetadata) + assert.True(t, ok) + assert.Equal(t, None, metadata.Kind) + assert.Equal(t, sc.value, metadata.Value) + } + } +} + +func TestStateManager_WithContext(t *testing.T) { sm := newMockStateManager(t) assert.Equal(t, sm.WithContext(), sm.stateManagerCtx) } -func TestAdd_EmptyStateName(t *testing.T) { +func TestAdd_EmptyStateName_Context(t *testing.T) { ctx := context.Background() sm := newMockStateManagerCtx(t) err := sm.Add(ctx, "", testValue) require.Error(t, err) } -func TestAdd_WithCachedStateChange(t *testing.T) { +func TestAdd_WithCachedStateChange_Context(t *testing.T) { ctx := context.Background() tests := []struct { @@ -116,7 +554,7 @@ func TestAdd_WithCachedStateChange(t *testing.T) { } } -func TestAdd_WithoutCachedStateChange(t *testing.T) { +func TestAdd_WithoutCachedStateChange_Context(t *testing.T) { ctx := context.Background() tests := []struct { @@ -161,14 +599,14 @@ func TestAdd_WithoutCachedStateChange(t *testing.T) { } } -func TestGet_EmptyStateName(t *testing.T) { +func TestGet_EmptyStateName_Context(t *testing.T) { ctx := context.Background() sm := newMockStateManagerCtx(t) err := sm.Get(ctx, "", testValue) require.Error(t, err) } -func TestGet_WithCachedStateChange(t *testing.T) { +func TestGet_WithCachedStateChange_Context(t *testing.T) { ctx := context.Background() tests := []struct { @@ -198,7 +636,7 @@ func TestGet_WithCachedStateChange(t *testing.T) { } } -func TestGet_WithoutCachedStateChange(t *testing.T) { +func TestGet_WithoutCachedStateChange_Context(t *testing.T) { ctx := context.Background() tests := []struct { @@ -239,14 +677,14 @@ func TestGet_WithoutCachedStateChange(t *testing.T) { } } -func TestSet_EmptyStateName(t *testing.T) { +func TestSet_EmptyStateName_Context(t *testing.T) { ctx := context.Background() sm := newMockStateManagerCtx(t) err := sm.Set(ctx, "", testValue) require.Error(t, err) } -func TestSet_WithCachedStateChange(t *testing.T) { +func TestSet_WithCachedStateChange_Context(t *testing.T) { ctx := context.Background() tests := []struct { @@ -277,7 +715,7 @@ func TestSet_WithCachedStateChange(t *testing.T) { } } -func TestSet_WithoutCachedStateChange(t *testing.T) { +func TestSet_WithoutCachedStateChange_Context(t *testing.T) { ctx := context.Background() sm := newMockStateManagerCtx(t) @@ -292,21 +730,21 @@ func TestSet_WithoutCachedStateChange(t *testing.T) { assert.Equal(t, testValue, metadata.Value) } -func TestSetWithTTL_EmptyStateName(t *testing.T) { +func TestSetWithTTL_EmptyStateName_Context(t *testing.T) { ctx := context.Background() sm := newMockStateManagerCtx(t) err := sm.SetWithTTL(ctx, "", testValue, testTTL) require.Error(t, err) } -func TestSetWithTTL_NegativeTTL(t *testing.T) { +func TestSetWithTTL_NegativeTTL_Context(t *testing.T) { ctx := context.Background() sm := newMockStateManagerCtx(t) err := sm.SetWithTTL(ctx, testState, testValue, -testTTL) require.Error(t, err) } -func TestSetWithTTL_WithCachedStateChange(t *testing.T) { +func TestSetWithTTL_WithCachedStateChange_Context(t *testing.T) { ctx := context.Background() tests := []struct { @@ -338,7 +776,7 @@ func TestSetWithTTL_WithCachedStateChange(t *testing.T) { } } -func TestSetWithTTL_WithoutCachedStateChange(t *testing.T) { +func TestSetWithTTL_WithoutCachedStateChange_Context(t *testing.T) { ctx := context.Background() sm := newMockStateManagerCtx(t) @@ -354,14 +792,14 @@ func TestSetWithTTL_WithoutCachedStateChange(t *testing.T) { assert.Equal(t, testTTL, *metadata.TTL) } -func TestRemove_EmptyStateName(t *testing.T) { +func TestRemove_EmptyStateName_Context(t *testing.T) { ctx := context.Background() sm := newMockStateManagerCtx(t) err := sm.Remove(ctx, "") require.Error(t, err) } -func TestRemove_WithCachedStateChange(t *testing.T) { +func TestRemove_WithCachedStateChange_Context(t *testing.T) { ctx := context.Background() tests := []struct { @@ -394,7 +832,7 @@ func TestRemove_WithCachedStateChange(t *testing.T) { } } -func TestRemove_WithoutCachedStateChange(t *testing.T) { +func TestRemove_WithoutCachedStateChange_Context(t *testing.T) { ctx := context.Background() mockResult := newGetActorStateResponse([]byte("result")) mockErr := errors.New("mockErr") @@ -421,7 +859,7 @@ func TestRemove_WithoutCachedStateChange(t *testing.T) { } } -func TestContains_EmptyStateName(t *testing.T) { +func TestContains_EmptyStateName_Context(t *testing.T) { ctx := context.Background() sm := newMockStateManagerCtx(t) res, err := sm.Contains(ctx, "") @@ -429,7 +867,7 @@ func TestContains_EmptyStateName(t *testing.T) { assert.False(t, res) } -func TestContains_WithCachedStateChange(t *testing.T) { +func TestContains_WithCachedStateChange_Context(t *testing.T) { ctx := context.Background() tests := []struct { @@ -454,7 +892,7 @@ func TestContains_WithCachedStateChange(t *testing.T) { } } -func TestContains_WithoutCachedStateChange(t *testing.T) { +func TestContains_WithoutCachedStateChange_Context(t *testing.T) { ctx := context.Background() tests := []struct { @@ -488,7 +926,7 @@ func TestContains_WithoutCachedStateChange(t *testing.T) { } } -func TestSave_SingleCachedStateChange(t *testing.T) { +func TestSave_SingleCachedStateChange_Context(t *testing.T) { ctx := context.Background() tests := []struct { @@ -523,7 +961,7 @@ func TestSave_SingleCachedStateChange(t *testing.T) { } } -func TestSave_MultipleCachedStateChanges(t *testing.T) { +func TestSave_MultipleCachedStateChanges_Context(t *testing.T) { ctx := context.Background() sm := newMockStateManagerCtx(t) mockClient := sm.stateAsyncProvider.daprClient.(*mock_client.MockClient) @@ -552,7 +990,7 @@ func TestSave_MultipleCachedStateChanges(t *testing.T) { require.NoError(t, err) } -func TestFlush(t *testing.T) { +func TestFlush_Context(t *testing.T) { ctx := context.Background() sm := newMockStateManagerCtx(t) stateChanges := []struct { @@ -585,6 +1023,42 @@ func TestFlush(t *testing.T) { } } +func TestNewActorStateManager(t *testing.T) { + type args struct { + actorTypeName string + actorID string + stateAsyncProvider *DaprStateAsyncProvider + } + tests := []struct { + name string + args args + want *stateManager + }{ + { + name: "init", + args: args{ + actorTypeName: "test", + actorID: "fn", + stateAsyncProvider: &DaprStateAsyncProvider{}, + }, + want: &stateManager{ + &stateManagerCtx{ + actorTypeName: "test", + actorID: "fn", + stateAsyncProvider: &DaprStateAsyncProvider{}, + }, + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := NewActorStateManager(tt.args.actorTypeName, tt.args.actorID, tt.args.stateAsyncProvider); !reflect.DeepEqual(got, tt.want) { + t.Errorf("NewActorStateManager() = %v, want %v", got, tt.want) + } + }) + } +} + func TestNewActorStateManagerContext(t *testing.T) { type args struct { actorTypeName string From 71fda3ec8ce8ed33a7d4acd3751f1a20e5242649 Mon Sep 17 00:00:00 2001 From: KentHsu Date: Fri, 3 May 2024 08:42:11 +0800 Subject: [PATCH 09/15] chore: add a new target mock in Makefile and update mock files Signed-off-by: KentHsu --- Makefile | 10 ++++++++++ actor/mock/mock_codec.go | 4 ++-- actor/mock/mock_container.go | 2 +- actor/mock/mock_manager.go | 2 +- actor/mock/mock_server.go | 17 ++++++++++++++++- 5 files changed, 30 insertions(+), 5 deletions(-) diff --git a/Makefile b/Makefile index 29365795..e36b3093 100644 --- a/Makefile +++ b/Makefile @@ -1,6 +1,8 @@ RELEASE_VERSION =v1.0.0-rc-3 GDOC_PORT =8888 GO_COMPAT_VERSION=1.21 +MOCKGEN_FORK =github.com/golang/mock/mockgen +MOCKGEN_VERSION =v1.6.0 .PHONY: all all: help @@ -57,3 +59,11 @@ check-diff: .PHONY: modtidy modtidy: go mod tidy + +.PHONY: mock +mock: ## Generates mock files + go install $(MOCKGEN_FORK)@$(MOCKGEN_VERSION) + mockgen -source ./actor/manager/manager.go -destination ./actor/mock/mock_manager.go -package mock + mockgen -source ./actor/manager/container.go -destination ./actor/mock/mock_container.go -package mock + mockgen -source ./actor/codec/codec.go -destination ./actor/mock/mock_codec.go -package mock + mockgen -source ./client/client.go -destination ./actor/mock_client/mock_client.go -package mock_client diff --git a/actor/mock/mock_codec.go b/actor/mock/mock_codec.go index b0dec5c4..ef632f63 100644 --- a/actor/mock/mock_codec.go +++ b/actor/mock/mock_codec.go @@ -1,7 +1,7 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: github.com/dapr/go-sdk/actor/codec (interfaces: Codec) +// Source: ./actor/codec/codec.go -// Package actor is a generated GoMock package. +// Package mock is a generated GoMock package. package mock import ( diff --git a/actor/mock/mock_container.go b/actor/mock/mock_container.go index ee68cade..44bb2334 100644 --- a/actor/mock/mock_container.go +++ b/actor/mock/mock_container.go @@ -1,5 +1,5 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: ../manager/container.go +// Source: ./actor/manager/container.go // Package mock is a generated GoMock package. package mock diff --git a/actor/mock/mock_manager.go b/actor/mock/mock_manager.go index 9b2ee722..b5dd8138 100644 --- a/actor/mock/mock_manager.go +++ b/actor/mock/mock_manager.go @@ -1,5 +1,5 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: ../manager/manager.go +// Source: ./actor/manager/manager.go // Package mock is a generated GoMock package. package mock diff --git a/actor/mock/mock_server.go b/actor/mock/mock_server.go index 882dca9e..7511a4ea 100644 --- a/actor/mock/mock_server.go +++ b/actor/mock/mock_server.go @@ -1,5 +1,5 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: ../actor.go +// Source: ./actor/actor.go // Package mock is a generated GoMock package. package mock @@ -7,6 +7,7 @@ package mock import ( context "context" reflect "reflect" + time "time" actor "github.com/dapr/go-sdk/actor" gomock "github.com/golang/mock/gomock" @@ -556,3 +557,17 @@ func (mr *MockStateManagerContextMockRecorder) Set(ctx, stateName, value interfa mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockStateManagerContext)(nil).Set), ctx, stateName, value) } + +// SetWithTTL mocks base method. +func (m *MockStateManagerContext) SetWithTTL(ctx context.Context, stateName string, value any, ttl time.Duration) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetWithTTL", ctx, stateName, value, ttl) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetWithTTL indicates an expected call of SetWithTTL. +func (mr *MockStateManagerContextMockRecorder) SetWithTTL(ctx, stateName, value, ttl interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWithTTL", reflect.TypeOf((*MockStateManagerContext)(nil).SetWithTTL), ctx, stateName, value, ttl) +} From be6e8ce71bdb7d2096b2f37c88321b650212803d Mon Sep 17 00:00:00 2001 From: KentHsu Date: Fri, 3 May 2024 09:57:13 +0800 Subject: [PATCH 10/15] chore: add mocks in .codecov.yaml Signed-off-by: KentHsu --- .codecov.yaml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.codecov.yaml b/.codecov.yaml index 41295cc8..ac7ffb2e 100644 --- a/.codecov.yaml +++ b/.codecov.yaml @@ -12,4 +12,6 @@ coverage: ignore: - "dapr/proto/**" - "example/**" + - "actor/mock/**" + - "actor/mock_client/**" From b29311b8d6add38614806f5e5bc8e2014d08068a Mon Sep 17 00:00:00 2001 From: KentHsu Date: Tue, 7 May 2024 00:08:08 +0800 Subject: [PATCH 11/15] Revert "chore: add mocks in .codecov.yaml" This reverts commit be6e8ce71bdb7d2096b2f37c88321b650212803d. Signed-off-by: KentHsu --- .codecov.yaml | 2 -- 1 file changed, 2 deletions(-) diff --git a/.codecov.yaml b/.codecov.yaml index ac7ffb2e..41295cc8 100644 --- a/.codecov.yaml +++ b/.codecov.yaml @@ -12,6 +12,4 @@ coverage: ignore: - "dapr/proto/**" - "example/**" - - "actor/mock/**" - - "actor/mock_client/**" From fe9860732a2805f8b859e2a590367397c3f68c9d Mon Sep 17 00:00:00 2001 From: KentHsu Date: Tue, 7 May 2024 00:08:44 +0800 Subject: [PATCH 12/15] chore: replace gomock with Uber's fork Signed-off-by: KentHsu --- Makefile | 6 +- actor/manager/container_test.go | 2 +- actor/mock/mock_codec.go | 15 ++- actor/mock/mock_container.go | 11 +- actor/mock/mock_manager.go | 27 +++-- actor/mock/mock_server.go | 45 ++++---- actor/mock_client/mock_client.go | 157 ++++++++++++++-------------- actor/runtime/actor_runtime_test.go | 2 +- actor/state/state_manager_test.go | 2 +- go.mod | 2 +- go.sum | 27 +---- 11 files changed, 149 insertions(+), 147 deletions(-) diff --git a/Makefile b/Makefile index e36b3093..705da44a 100644 --- a/Makefile +++ b/Makefile @@ -1,8 +1,8 @@ RELEASE_VERSION =v1.0.0-rc-3 GDOC_PORT =8888 GO_COMPAT_VERSION=1.21 -MOCKGEN_FORK =github.com/golang/mock/mockgen -MOCKGEN_VERSION =v1.6.0 +MOCKGEN_FORK =go.uber.org/mock/mockgen +MOCKGEN_VERSION =v0.4.0 .PHONY: all all: help @@ -62,7 +62,7 @@ modtidy: .PHONY: mock mock: ## Generates mock files - go install $(MOCKGEN_FORK)@$(MOCKGEN_VERSION) + go get $(MOCKGEN_FORK)@$(MOCKGEN_VERSION) mockgen -source ./actor/manager/manager.go -destination ./actor/mock/mock_manager.go -package mock mockgen -source ./actor/manager/container.go -destination ./actor/mock/mock_container.go -package mock mockgen -source ./actor/codec/codec.go -destination ./actor/mock/mock_codec.go -package mock diff --git a/actor/manager/container_test.go b/actor/manager/container_test.go index a31a4f21..57ea682f 100644 --- a/actor/manager/container_test.go +++ b/actor/manager/container_test.go @@ -16,9 +16,9 @@ package manager import ( "testing" - "github.com/golang/mock/gomock" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + "go.uber.org/mock/gomock" actorErr "github.com/dapr/go-sdk/actor/error" actorMock "github.com/dapr/go-sdk/actor/mock" diff --git a/actor/mock/mock_codec.go b/actor/mock/mock_codec.go index ef632f63..079c991c 100644 --- a/actor/mock/mock_codec.go +++ b/actor/mock/mock_codec.go @@ -1,5 +1,10 @@ // Code generated by MockGen. DO NOT EDIT. // Source: ./actor/codec/codec.go +// +// Generated by this command: +// +// mockgen -source ./actor/codec/codec.go -destination ./actor/mock/mock_codec.go -package mock +// // Package mock is a generated GoMock package. package mock @@ -7,7 +12,7 @@ package mock import ( reflect "reflect" - gomock "github.com/golang/mock/gomock" + gomock "go.uber.org/mock/gomock" ) // MockCodec is a mock of Codec interface. @@ -34,7 +39,7 @@ func (m *MockCodec) EXPECT() *MockCodecMockRecorder { } // Marshal mocks base method. -func (m *MockCodec) Marshal(arg0 interface{}) ([]byte, error) { +func (m *MockCodec) Marshal(arg0 any) ([]byte, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Marshal", arg0) ret0, _ := ret[0].([]byte) @@ -43,13 +48,13 @@ func (m *MockCodec) Marshal(arg0 interface{}) ([]byte, error) { } // Marshal indicates an expected call of Marshal. -func (mr *MockCodecMockRecorder) Marshal(arg0 interface{}) *gomock.Call { +func (mr *MockCodecMockRecorder) Marshal(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Marshal", reflect.TypeOf((*MockCodec)(nil).Marshal), arg0) } // Unmarshal mocks base method. -func (m *MockCodec) Unmarshal(arg0 []byte, arg1 interface{}) error { +func (m *MockCodec) Unmarshal(arg0 []byte, arg1 any) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Unmarshal", arg0, arg1) ret0, _ := ret[0].(error) @@ -57,7 +62,7 @@ func (m *MockCodec) Unmarshal(arg0 []byte, arg1 interface{}) error { } // Unmarshal indicates an expected call of Unmarshal. -func (mr *MockCodecMockRecorder) Unmarshal(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockCodecMockRecorder) Unmarshal(arg0, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unmarshal", reflect.TypeOf((*MockCodec)(nil).Unmarshal), arg0, arg1) } diff --git a/actor/mock/mock_container.go b/actor/mock/mock_container.go index 44bb2334..04efa363 100644 --- a/actor/mock/mock_container.go +++ b/actor/mock/mock_container.go @@ -1,5 +1,10 @@ // Code generated by MockGen. DO NOT EDIT. // Source: ./actor/manager/container.go +// +// Generated by this command: +// +// mockgen -source ./actor/manager/container.go -destination ./actor/mock/mock_container.go -package mock +// // Package mock is a generated GoMock package. package mock @@ -10,7 +15,7 @@ import ( actor "github.com/dapr/go-sdk/actor" error "github.com/dapr/go-sdk/actor/error" - gomock "github.com/golang/mock/gomock" + gomock "go.uber.org/mock/gomock" ) // MockActorContainer is a mock of ActorContainer interface. @@ -60,7 +65,7 @@ func (m *MockActorContainer) Invoke(methodName string, param []byte) ([]reflect. } // Invoke indicates an expected call of Invoke. -func (mr *MockActorContainerMockRecorder) Invoke(methodName, param interface{}) *gomock.Call { +func (mr *MockActorContainerMockRecorder) Invoke(methodName, param any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Invoke", reflect.TypeOf((*MockActorContainer)(nil).Invoke), methodName, param) } @@ -112,7 +117,7 @@ func (m *MockActorContainerContext) Invoke(ctx context.Context, methodName strin } // Invoke indicates an expected call of Invoke. -func (mr *MockActorContainerContextMockRecorder) Invoke(ctx, methodName, param interface{}) *gomock.Call { +func (mr *MockActorContainerContextMockRecorder) Invoke(ctx, methodName, param any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Invoke", reflect.TypeOf((*MockActorContainerContext)(nil).Invoke), ctx, methodName, param) } diff --git a/actor/mock/mock_manager.go b/actor/mock/mock_manager.go index b5dd8138..1f8bad0d 100644 --- a/actor/mock/mock_manager.go +++ b/actor/mock/mock_manager.go @@ -1,5 +1,10 @@ // Code generated by MockGen. DO NOT EDIT. // Source: ./actor/manager/manager.go +// +// Generated by this command: +// +// mockgen -source ./actor/manager/manager.go -destination ./actor/mock/mock_manager.go -package mock +// // Package mock is a generated GoMock package. package mock @@ -10,7 +15,7 @@ import ( actor "github.com/dapr/go-sdk/actor" error "github.com/dapr/go-sdk/actor/error" - gomock "github.com/golang/mock/gomock" + gomock "go.uber.org/mock/gomock" ) // MockActorManager is a mock of ActorManager interface. @@ -45,7 +50,7 @@ func (m *MockActorManager) DeactivateActor(actorID string) error.ActorErr { } // DeactivateActor indicates an expected call of DeactivateActor. -func (mr *MockActorManagerMockRecorder) DeactivateActor(actorID interface{}) *gomock.Call { +func (mr *MockActorManagerMockRecorder) DeactivateActor(actorID any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeactivateActor", reflect.TypeOf((*MockActorManager)(nil).DeactivateActor), actorID) } @@ -60,7 +65,7 @@ func (m *MockActorManager) InvokeMethod(actorID, methodName string, request []by } // InvokeMethod indicates an expected call of InvokeMethod. -func (mr *MockActorManagerMockRecorder) InvokeMethod(actorID, methodName, request interface{}) *gomock.Call { +func (mr *MockActorManagerMockRecorder) InvokeMethod(actorID, methodName, request any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeMethod", reflect.TypeOf((*MockActorManager)(nil).InvokeMethod), actorID, methodName, request) } @@ -74,7 +79,7 @@ func (m *MockActorManager) InvokeReminder(actorID, reminderName string, params [ } // InvokeReminder indicates an expected call of InvokeReminder. -func (mr *MockActorManagerMockRecorder) InvokeReminder(actorID, reminderName, params interface{}) *gomock.Call { +func (mr *MockActorManagerMockRecorder) InvokeReminder(actorID, reminderName, params any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeReminder", reflect.TypeOf((*MockActorManager)(nil).InvokeReminder), actorID, reminderName, params) } @@ -88,7 +93,7 @@ func (m *MockActorManager) InvokeTimer(actorID, timerName string, params []byte) } // InvokeTimer indicates an expected call of InvokeTimer. -func (mr *MockActorManagerMockRecorder) InvokeTimer(actorID, timerName, params interface{}) *gomock.Call { +func (mr *MockActorManagerMockRecorder) InvokeTimer(actorID, timerName, params any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeTimer", reflect.TypeOf((*MockActorManager)(nil).InvokeTimer), actorID, timerName, params) } @@ -100,7 +105,7 @@ func (m *MockActorManager) RegisterActorImplFactory(f actor.Factory) { } // RegisterActorImplFactory indicates an expected call of RegisterActorImplFactory. -func (mr *MockActorManagerMockRecorder) RegisterActorImplFactory(f interface{}) *gomock.Call { +func (mr *MockActorManagerMockRecorder) RegisterActorImplFactory(f any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterActorImplFactory", reflect.TypeOf((*MockActorManager)(nil).RegisterActorImplFactory), f) } @@ -137,7 +142,7 @@ func (m *MockActorManagerContext) DeactivateActor(ctx context.Context, actorID s } // DeactivateActor indicates an expected call of DeactivateActor. -func (mr *MockActorManagerContextMockRecorder) DeactivateActor(ctx, actorID interface{}) *gomock.Call { +func (mr *MockActorManagerContextMockRecorder) DeactivateActor(ctx, actorID any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeactivateActor", reflect.TypeOf((*MockActorManagerContext)(nil).DeactivateActor), ctx, actorID) } @@ -152,7 +157,7 @@ func (m *MockActorManagerContext) InvokeMethod(ctx context.Context, actorID, met } // InvokeMethod indicates an expected call of InvokeMethod. -func (mr *MockActorManagerContextMockRecorder) InvokeMethod(ctx, actorID, methodName, request interface{}) *gomock.Call { +func (mr *MockActorManagerContextMockRecorder) InvokeMethod(ctx, actorID, methodName, request any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeMethod", reflect.TypeOf((*MockActorManagerContext)(nil).InvokeMethod), ctx, actorID, methodName, request) } @@ -166,7 +171,7 @@ func (m *MockActorManagerContext) InvokeReminder(ctx context.Context, actorID, r } // InvokeReminder indicates an expected call of InvokeReminder. -func (mr *MockActorManagerContextMockRecorder) InvokeReminder(ctx, actorID, reminderName, params interface{}) *gomock.Call { +func (mr *MockActorManagerContextMockRecorder) InvokeReminder(ctx, actorID, reminderName, params any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeReminder", reflect.TypeOf((*MockActorManagerContext)(nil).InvokeReminder), ctx, actorID, reminderName, params) } @@ -180,7 +185,7 @@ func (m *MockActorManagerContext) InvokeTimer(ctx context.Context, actorID, time } // InvokeTimer indicates an expected call of InvokeTimer. -func (mr *MockActorManagerContextMockRecorder) InvokeTimer(ctx, actorID, timerName, params interface{}) *gomock.Call { +func (mr *MockActorManagerContextMockRecorder) InvokeTimer(ctx, actorID, timerName, params any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeTimer", reflect.TypeOf((*MockActorManagerContext)(nil).InvokeTimer), ctx, actorID, timerName, params) } @@ -192,7 +197,7 @@ func (m *MockActorManagerContext) RegisterActorImplFactory(f actor.FactoryContex } // RegisterActorImplFactory indicates an expected call of RegisterActorImplFactory. -func (mr *MockActorManagerContextMockRecorder) RegisterActorImplFactory(f interface{}) *gomock.Call { +func (mr *MockActorManagerContextMockRecorder) RegisterActorImplFactory(f any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterActorImplFactory", reflect.TypeOf((*MockActorManagerContext)(nil).RegisterActorImplFactory), f) } diff --git a/actor/mock/mock_server.go b/actor/mock/mock_server.go index 7511a4ea..4ca3ac79 100644 --- a/actor/mock/mock_server.go +++ b/actor/mock/mock_server.go @@ -1,5 +1,10 @@ // Code generated by MockGen. DO NOT EDIT. // Source: ./actor/actor.go +// +// Generated by this command: +// +// mockgen -source ./actor/actor.go -destination ./actor/mock/mock_server.go -package mock +// // Package mock is a generated GoMock package. package mock @@ -10,7 +15,7 @@ import ( time "time" actor "github.com/dapr/go-sdk/actor" - gomock "github.com/golang/mock/gomock" + gomock "go.uber.org/mock/gomock" ) // MockClient is a mock of Client interface. @@ -122,7 +127,7 @@ func (m *MockServer) SetID(arg0 string) { } // SetID indicates an expected call of SetID. -func (mr *MockServerMockRecorder) SetID(arg0 interface{}) *gomock.Call { +func (mr *MockServerMockRecorder) SetID(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetID", reflect.TypeOf((*MockServer)(nil).SetID), arg0) } @@ -134,7 +139,7 @@ func (m *MockServer) SetStateManager(arg0 actor.StateManager) { } // SetStateManager indicates an expected call of SetStateManager. -func (mr *MockServerMockRecorder) SetStateManager(arg0 interface{}) *gomock.Call { +func (mr *MockServerMockRecorder) SetStateManager(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStateManager", reflect.TypeOf((*MockServer)(nil).SetStateManager), arg0) } @@ -213,7 +218,7 @@ func (m *MockServerContext) SaveState(arg0 context.Context) error { } // SaveState indicates an expected call of SaveState. -func (mr *MockServerContextMockRecorder) SaveState(arg0 interface{}) *gomock.Call { +func (mr *MockServerContextMockRecorder) SaveState(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveState", reflect.TypeOf((*MockServerContext)(nil).SaveState), arg0) } @@ -225,7 +230,7 @@ func (m *MockServerContext) SetID(arg0 string) { } // SetID indicates an expected call of SetID. -func (mr *MockServerContextMockRecorder) SetID(arg0 interface{}) *gomock.Call { +func (mr *MockServerContextMockRecorder) SetID(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetID", reflect.TypeOf((*MockServerContext)(nil).SetID), arg0) } @@ -237,7 +242,7 @@ func (m *MockServerContext) SetStateManager(arg0 actor.StateManagerContext) { } // SetStateManager indicates an expected call of SetStateManager. -func (mr *MockServerContextMockRecorder) SetStateManager(arg0 interface{}) *gomock.Call { +func (mr *MockServerContextMockRecorder) SetStateManager(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStateManager", reflect.TypeOf((*MockServerContext)(nil).SetStateManager), arg0) } @@ -299,7 +304,7 @@ func (m *MockReminderCallee) ReminderCall(arg0 string, arg1 []byte, arg2, arg3 s } // ReminderCall indicates an expected call of ReminderCall. -func (mr *MockReminderCalleeMockRecorder) ReminderCall(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { +func (mr *MockReminderCalleeMockRecorder) ReminderCall(arg0, arg1, arg2, arg3 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReminderCall", reflect.TypeOf((*MockReminderCallee)(nil).ReminderCall), arg0, arg1, arg2, arg3) } @@ -336,7 +341,7 @@ func (m *MockStateManager) Add(stateName string, value any) error { } // Add indicates an expected call of Add. -func (mr *MockStateManagerMockRecorder) Add(stateName, value interface{}) *gomock.Call { +func (mr *MockStateManagerMockRecorder) Add(stateName, value any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockStateManager)(nil).Add), stateName, value) } @@ -351,7 +356,7 @@ func (m *MockStateManager) Contains(stateName string) (bool, error) { } // Contains indicates an expected call of Contains. -func (mr *MockStateManagerMockRecorder) Contains(stateName interface{}) *gomock.Call { +func (mr *MockStateManagerMockRecorder) Contains(stateName any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Contains", reflect.TypeOf((*MockStateManager)(nil).Contains), stateName) } @@ -377,7 +382,7 @@ func (m *MockStateManager) Get(stateName string, reply any) error { } // Get indicates an expected call of Get. -func (mr *MockStateManagerMockRecorder) Get(stateName, reply interface{}) *gomock.Call { +func (mr *MockStateManagerMockRecorder) Get(stateName, reply any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockStateManager)(nil).Get), stateName, reply) } @@ -391,7 +396,7 @@ func (m *MockStateManager) Remove(stateName string) error { } // Remove indicates an expected call of Remove. -func (mr *MockStateManagerMockRecorder) Remove(stateName interface{}) *gomock.Call { +func (mr *MockStateManagerMockRecorder) Remove(stateName any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Remove", reflect.TypeOf((*MockStateManager)(nil).Remove), stateName) } @@ -419,7 +424,7 @@ func (m *MockStateManager) Set(stateName string, value any) error { } // Set indicates an expected call of Set. -func (mr *MockStateManagerMockRecorder) Set(stateName, value interface{}) *gomock.Call { +func (mr *MockStateManagerMockRecorder) Set(stateName, value any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockStateManager)(nil).Set), stateName, value) } @@ -470,7 +475,7 @@ func (m *MockStateManagerContext) Add(ctx context.Context, stateName string, val } // Add indicates an expected call of Add. -func (mr *MockStateManagerContextMockRecorder) Add(ctx, stateName, value interface{}) *gomock.Call { +func (mr *MockStateManagerContextMockRecorder) Add(ctx, stateName, value any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockStateManagerContext)(nil).Add), ctx, stateName, value) } @@ -485,7 +490,7 @@ func (m *MockStateManagerContext) Contains(ctx context.Context, stateName string } // Contains indicates an expected call of Contains. -func (mr *MockStateManagerContextMockRecorder) Contains(ctx, stateName interface{}) *gomock.Call { +func (mr *MockStateManagerContextMockRecorder) Contains(ctx, stateName any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Contains", reflect.TypeOf((*MockStateManagerContext)(nil).Contains), ctx, stateName) } @@ -497,7 +502,7 @@ func (m *MockStateManagerContext) Flush(ctx context.Context) { } // Flush indicates an expected call of Flush. -func (mr *MockStateManagerContextMockRecorder) Flush(ctx interface{}) *gomock.Call { +func (mr *MockStateManagerContextMockRecorder) Flush(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Flush", reflect.TypeOf((*MockStateManagerContext)(nil).Flush), ctx) } @@ -511,7 +516,7 @@ func (m *MockStateManagerContext) Get(ctx context.Context, stateName string, rep } // Get indicates an expected call of Get. -func (mr *MockStateManagerContextMockRecorder) Get(ctx, stateName, reply interface{}) *gomock.Call { +func (mr *MockStateManagerContextMockRecorder) Get(ctx, stateName, reply any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockStateManagerContext)(nil).Get), ctx, stateName, reply) } @@ -525,7 +530,7 @@ func (m *MockStateManagerContext) Remove(ctx context.Context, stateName string) } // Remove indicates an expected call of Remove. -func (mr *MockStateManagerContextMockRecorder) Remove(ctx, stateName interface{}) *gomock.Call { +func (mr *MockStateManagerContextMockRecorder) Remove(ctx, stateName any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Remove", reflect.TypeOf((*MockStateManagerContext)(nil).Remove), ctx, stateName) } @@ -539,7 +544,7 @@ func (m *MockStateManagerContext) Save(ctx context.Context) error { } // Save indicates an expected call of Save. -func (mr *MockStateManagerContextMockRecorder) Save(ctx interface{}) *gomock.Call { +func (mr *MockStateManagerContextMockRecorder) Save(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockStateManagerContext)(nil).Save), ctx) } @@ -553,7 +558,7 @@ func (m *MockStateManagerContext) Set(ctx context.Context, stateName string, val } // Set indicates an expected call of Set. -func (mr *MockStateManagerContextMockRecorder) Set(ctx, stateName, value interface{}) *gomock.Call { +func (mr *MockStateManagerContextMockRecorder) Set(ctx, stateName, value any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockStateManagerContext)(nil).Set), ctx, stateName, value) } @@ -567,7 +572,7 @@ func (m *MockStateManagerContext) SetWithTTL(ctx context.Context, stateName stri } // SetWithTTL indicates an expected call of SetWithTTL. -func (mr *MockStateManagerContextMockRecorder) SetWithTTL(ctx, stateName, value, ttl interface{}) *gomock.Call { +func (mr *MockStateManagerContextMockRecorder) SetWithTTL(ctx, stateName, value, ttl any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWithTTL", reflect.TypeOf((*MockStateManagerContext)(nil).SetWithTTL), ctx, stateName, value, ttl) } diff --git a/actor/mock_client/mock_client.go b/actor/mock_client/mock_client.go index 4035ba71..b743e683 100644 --- a/actor/mock_client/mock_client.go +++ b/actor/mock_client/mock_client.go @@ -1,5 +1,10 @@ // Code generated by MockGen. DO NOT EDIT. // Source: ./client/client.go +// +// Generated by this command: +// +// mockgen -source ./client/client.go -destination ./actor/mock_client/mock_client.go -package mock_client +// // Package mock_client is a generated GoMock package. package mock_client @@ -14,7 +19,7 @@ import ( actor "github.com/dapr/go-sdk/actor" config "github.com/dapr/go-sdk/actor/config" client "github.com/dapr/go-sdk/client" - gomock "github.com/golang/mock/gomock" + gomock "go.uber.org/mock/gomock" grpc "google.golang.org/grpc" ) @@ -63,7 +68,7 @@ func (m *MockClient) Decrypt(ctx context.Context, in io.Reader, opts client.Decr } // Decrypt indicates an expected call of Decrypt. -func (mr *MockClientMockRecorder) Decrypt(ctx, in, opts interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) Decrypt(ctx, in, opts any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Decrypt", reflect.TypeOf((*MockClient)(nil).Decrypt), ctx, in, opts) } @@ -77,7 +82,7 @@ func (m *MockClient) DeleteBulkState(ctx context.Context, storeName string, keys } // DeleteBulkState indicates an expected call of DeleteBulkState. -func (mr *MockClientMockRecorder) DeleteBulkState(ctx, storeName, keys, meta interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) DeleteBulkState(ctx, storeName, keys, meta any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBulkState", reflect.TypeOf((*MockClient)(nil).DeleteBulkState), ctx, storeName, keys, meta) } @@ -91,7 +96,7 @@ func (m *MockClient) DeleteBulkStateItems(ctx context.Context, storeName string, } // DeleteBulkStateItems indicates an expected call of DeleteBulkStateItems. -func (mr *MockClientMockRecorder) DeleteBulkStateItems(ctx, storeName, items interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) DeleteBulkStateItems(ctx, storeName, items any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBulkStateItems", reflect.TypeOf((*MockClient)(nil).DeleteBulkStateItems), ctx, storeName, items) } @@ -105,7 +110,7 @@ func (m *MockClient) DeleteState(ctx context.Context, storeName, key string, met } // DeleteState indicates an expected call of DeleteState. -func (mr *MockClientMockRecorder) DeleteState(ctx, storeName, key, meta interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) DeleteState(ctx, storeName, key, meta any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteState", reflect.TypeOf((*MockClient)(nil).DeleteState), ctx, storeName, key, meta) } @@ -119,7 +124,7 @@ func (m *MockClient) DeleteStateWithETag(ctx context.Context, storeName, key str } // DeleteStateWithETag indicates an expected call of DeleteStateWithETag. -func (mr *MockClientMockRecorder) DeleteStateWithETag(ctx, storeName, key, etag, meta, opts interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) DeleteStateWithETag(ctx, storeName, key, etag, meta, opts any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStateWithETag", reflect.TypeOf((*MockClient)(nil).DeleteStateWithETag), ctx, storeName, key, etag, meta, opts) } @@ -134,7 +139,7 @@ func (m *MockClient) Encrypt(ctx context.Context, in io.Reader, opts client.Encr } // Encrypt indicates an expected call of Encrypt. -func (mr *MockClientMockRecorder) Encrypt(ctx, in, opts interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) Encrypt(ctx, in, opts any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Encrypt", reflect.TypeOf((*MockClient)(nil).Encrypt), ctx, in, opts) } @@ -148,7 +153,7 @@ func (m *MockClient) ExecuteStateTransaction(ctx context.Context, storeName stri } // ExecuteStateTransaction indicates an expected call of ExecuteStateTransaction. -func (mr *MockClientMockRecorder) ExecuteStateTransaction(ctx, storeName, meta, ops interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) ExecuteStateTransaction(ctx, storeName, meta, ops any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteStateTransaction", reflect.TypeOf((*MockClient)(nil).ExecuteStateTransaction), ctx, storeName, meta, ops) } @@ -163,7 +168,7 @@ func (m *MockClient) GetActorState(ctx context.Context, req *client.GetActorStat } // GetActorState indicates an expected call of GetActorState. -func (mr *MockClientMockRecorder) GetActorState(ctx, req interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) GetActorState(ctx, req any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetActorState", reflect.TypeOf((*MockClient)(nil).GetActorState), ctx, req) } @@ -178,7 +183,7 @@ func (m *MockClient) GetBulkSecret(ctx context.Context, storeName string, meta m } // GetBulkSecret indicates an expected call of GetBulkSecret. -func (mr *MockClientMockRecorder) GetBulkSecret(ctx, storeName, meta interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) GetBulkSecret(ctx, storeName, meta any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBulkSecret", reflect.TypeOf((*MockClient)(nil).GetBulkSecret), ctx, storeName, meta) } @@ -193,7 +198,7 @@ func (m *MockClient) GetBulkState(ctx context.Context, storeName string, keys [] } // GetBulkState indicates an expected call of GetBulkState. -func (mr *MockClientMockRecorder) GetBulkState(ctx, storeName, keys, meta, parallelism interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) GetBulkState(ctx, storeName, keys, meta, parallelism any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBulkState", reflect.TypeOf((*MockClient)(nil).GetBulkState), ctx, storeName, keys, meta, parallelism) } @@ -201,7 +206,7 @@ func (mr *MockClientMockRecorder) GetBulkState(ctx, storeName, keys, meta, paral // GetConfigurationItem mocks base method. func (m *MockClient) GetConfigurationItem(ctx context.Context, storeName, key string, opts ...client.ConfigurationOpt) (*client.ConfigurationItem, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, storeName, key} + varargs := []any{ctx, storeName, key} for _, a := range opts { varargs = append(varargs, a) } @@ -212,16 +217,16 @@ func (m *MockClient) GetConfigurationItem(ctx context.Context, storeName, key st } // GetConfigurationItem indicates an expected call of GetConfigurationItem. -func (mr *MockClientMockRecorder) GetConfigurationItem(ctx, storeName, key interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) GetConfigurationItem(ctx, storeName, key any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, storeName, key}, opts...) + varargs := append([]any{ctx, storeName, key}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfigurationItem", reflect.TypeOf((*MockClient)(nil).GetConfigurationItem), varargs...) } // GetConfigurationItems mocks base method. func (m *MockClient) GetConfigurationItems(ctx context.Context, storeName string, keys []string, opts ...client.ConfigurationOpt) (map[string]*client.ConfigurationItem, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, storeName, keys} + varargs := []any{ctx, storeName, keys} for _, a := range opts { varargs = append(varargs, a) } @@ -232,9 +237,9 @@ func (m *MockClient) GetConfigurationItems(ctx context.Context, storeName string } // GetConfigurationItems indicates an expected call of GetConfigurationItems. -func (mr *MockClientMockRecorder) GetConfigurationItems(ctx, storeName, keys interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) GetConfigurationItems(ctx, storeName, keys any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, storeName, keys}, opts...) + varargs := append([]any{ctx, storeName, keys}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfigurationItems", reflect.TypeOf((*MockClient)(nil).GetConfigurationItems), varargs...) } @@ -248,7 +253,7 @@ func (m *MockClient) GetMetadata(ctx context.Context) (*client.GetMetadataRespon } // GetMetadata indicates an expected call of GetMetadata. -func (mr *MockClientMockRecorder) GetMetadata(ctx interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) GetMetadata(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetadata", reflect.TypeOf((*MockClient)(nil).GetMetadata), ctx) } @@ -263,7 +268,7 @@ func (m *MockClient) GetSecret(ctx context.Context, storeName, key string, meta } // GetSecret indicates an expected call of GetSecret. -func (mr *MockClientMockRecorder) GetSecret(ctx, storeName, key, meta interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) GetSecret(ctx, storeName, key, meta any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecret", reflect.TypeOf((*MockClient)(nil).GetSecret), ctx, storeName, key, meta) } @@ -278,7 +283,7 @@ func (m *MockClient) GetState(ctx context.Context, storeName, key string, meta m } // GetState indicates an expected call of GetState. -func (mr *MockClientMockRecorder) GetState(ctx, storeName, key, meta interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) GetState(ctx, storeName, key, meta any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetState", reflect.TypeOf((*MockClient)(nil).GetState), ctx, storeName, key, meta) } @@ -293,7 +298,7 @@ func (m *MockClient) GetStateWithConsistency(ctx context.Context, storeName, key } // GetStateWithConsistency indicates an expected call of GetStateWithConsistency. -func (mr *MockClientMockRecorder) GetStateWithConsistency(ctx, storeName, key, meta, sc interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) GetStateWithConsistency(ctx, storeName, key, meta, sc any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStateWithConsistency", reflect.TypeOf((*MockClient)(nil).GetStateWithConsistency), ctx, storeName, key, meta, sc) } @@ -308,7 +313,7 @@ func (m *MockClient) GetWorkflowBeta1(ctx context.Context, req *client.GetWorkfl } // GetWorkflowBeta1 indicates an expected call of GetWorkflowBeta1. -func (mr *MockClientMockRecorder) GetWorkflowBeta1(ctx, req interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) GetWorkflowBeta1(ctx, req any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowBeta1", reflect.TypeOf((*MockClient)(nil).GetWorkflowBeta1), ctx, req) } @@ -344,7 +349,7 @@ func (mr *MockClientMockRecorder) GrpcClientConn() *gomock.Call { // ImplActorClientStub mocks base method. func (m *MockClient) ImplActorClientStub(actorClientStub actor.Client, opt ...config.Option) { m.ctrl.T.Helper() - varargs := []interface{}{actorClientStub} + varargs := []any{actorClientStub} for _, a := range opt { varargs = append(varargs, a) } @@ -352,9 +357,9 @@ func (m *MockClient) ImplActorClientStub(actorClientStub actor.Client, opt ...co } // ImplActorClientStub indicates an expected call of ImplActorClientStub. -func (mr *MockClientMockRecorder) ImplActorClientStub(actorClientStub interface{}, opt ...interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) ImplActorClientStub(actorClientStub any, opt ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{actorClientStub}, opt...) + varargs := append([]any{actorClientStub}, opt...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImplActorClientStub", reflect.TypeOf((*MockClient)(nil).ImplActorClientStub), varargs...) } @@ -368,7 +373,7 @@ func (m *MockClient) InvokeActor(ctx context.Context, req *client.InvokeActorReq } // InvokeActor indicates an expected call of InvokeActor. -func (mr *MockClientMockRecorder) InvokeActor(ctx, req interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) InvokeActor(ctx, req any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeActor", reflect.TypeOf((*MockClient)(nil).InvokeActor), ctx, req) } @@ -383,7 +388,7 @@ func (m *MockClient) InvokeBinding(ctx context.Context, in *client.InvokeBinding } // InvokeBinding indicates an expected call of InvokeBinding. -func (mr *MockClientMockRecorder) InvokeBinding(ctx, in interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) InvokeBinding(ctx, in any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeBinding", reflect.TypeOf((*MockClient)(nil).InvokeBinding), ctx, in) } @@ -398,7 +403,7 @@ func (m *MockClient) InvokeMethod(ctx context.Context, appID, methodName, verb s } // InvokeMethod indicates an expected call of InvokeMethod. -func (mr *MockClientMockRecorder) InvokeMethod(ctx, appID, methodName, verb interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) InvokeMethod(ctx, appID, methodName, verb any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeMethod", reflect.TypeOf((*MockClient)(nil).InvokeMethod), ctx, appID, methodName, verb) } @@ -413,13 +418,13 @@ func (m *MockClient) InvokeMethodWithContent(ctx context.Context, appID, methodN } // InvokeMethodWithContent indicates an expected call of InvokeMethodWithContent. -func (mr *MockClientMockRecorder) InvokeMethodWithContent(ctx, appID, methodName, verb, content interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) InvokeMethodWithContent(ctx, appID, methodName, verb, content any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeMethodWithContent", reflect.TypeOf((*MockClient)(nil).InvokeMethodWithContent), ctx, appID, methodName, verb, content) } // InvokeMethodWithCustomContent mocks base method. -func (m *MockClient) InvokeMethodWithCustomContent(ctx context.Context, appID, methodName, verb, contentType string, content interface{}) ([]byte, error) { +func (m *MockClient) InvokeMethodWithCustomContent(ctx context.Context, appID, methodName, verb, contentType string, content any) ([]byte, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "InvokeMethodWithCustomContent", ctx, appID, methodName, verb, contentType, content) ret0, _ := ret[0].([]byte) @@ -428,7 +433,7 @@ func (m *MockClient) InvokeMethodWithCustomContent(ctx context.Context, appID, m } // InvokeMethodWithCustomContent indicates an expected call of InvokeMethodWithCustomContent. -func (mr *MockClientMockRecorder) InvokeMethodWithCustomContent(ctx, appID, methodName, verb, contentType, content interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) InvokeMethodWithCustomContent(ctx, appID, methodName, verb, contentType, content any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeMethodWithCustomContent", reflect.TypeOf((*MockClient)(nil).InvokeMethodWithCustomContent), ctx, appID, methodName, verb, contentType, content) } @@ -442,7 +447,7 @@ func (m *MockClient) InvokeOutputBinding(ctx context.Context, in *client.InvokeB } // InvokeOutputBinding indicates an expected call of InvokeOutputBinding. -func (mr *MockClientMockRecorder) InvokeOutputBinding(ctx, in interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) InvokeOutputBinding(ctx, in any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvokeOutputBinding", reflect.TypeOf((*MockClient)(nil).InvokeOutputBinding), ctx, in) } @@ -456,15 +461,15 @@ func (m *MockClient) PauseWorkflowBeta1(ctx context.Context, req *client.PauseWo } // PauseWorkflowBeta1 indicates an expected call of PauseWorkflowBeta1. -func (mr *MockClientMockRecorder) PauseWorkflowBeta1(ctx, req interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) PauseWorkflowBeta1(ctx, req any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PauseWorkflowBeta1", reflect.TypeOf((*MockClient)(nil).PauseWorkflowBeta1), ctx, req) } // PublishEvent mocks base method. -func (m *MockClient) PublishEvent(ctx context.Context, pubsubName, topicName string, data interface{}, opts ...client.PublishEventOption) error { +func (m *MockClient) PublishEvent(ctx context.Context, pubsubName, topicName string, data any, opts ...client.PublishEventOption) error { m.ctrl.T.Helper() - varargs := []interface{}{ctx, pubsubName, topicName, data} + varargs := []any{ctx, pubsubName, topicName, data} for _, a := range opts { varargs = append(varargs, a) } @@ -474,14 +479,14 @@ func (m *MockClient) PublishEvent(ctx context.Context, pubsubName, topicName str } // PublishEvent indicates an expected call of PublishEvent. -func (mr *MockClientMockRecorder) PublishEvent(ctx, pubsubName, topicName, data interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) PublishEvent(ctx, pubsubName, topicName, data any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, pubsubName, topicName, data}, opts...) + varargs := append([]any{ctx, pubsubName, topicName, data}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishEvent", reflect.TypeOf((*MockClient)(nil).PublishEvent), varargs...) } // PublishEventfromCustomContent mocks base method. -func (m *MockClient) PublishEventfromCustomContent(ctx context.Context, pubsubName, topicName string, data interface{}) error { +func (m *MockClient) PublishEventfromCustomContent(ctx context.Context, pubsubName, topicName string, data any) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "PublishEventfromCustomContent", ctx, pubsubName, topicName, data) ret0, _ := ret[0].(error) @@ -489,15 +494,15 @@ func (m *MockClient) PublishEventfromCustomContent(ctx context.Context, pubsubNa } // PublishEventfromCustomContent indicates an expected call of PublishEventfromCustomContent. -func (mr *MockClientMockRecorder) PublishEventfromCustomContent(ctx, pubsubName, topicName, data interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) PublishEventfromCustomContent(ctx, pubsubName, topicName, data any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishEventfromCustomContent", reflect.TypeOf((*MockClient)(nil).PublishEventfromCustomContent), ctx, pubsubName, topicName, data) } // PublishEvents mocks base method. -func (m *MockClient) PublishEvents(ctx context.Context, pubsubName, topicName string, events []interface{}, opts ...client.PublishEventsOption) client.PublishEventsResponse { +func (m *MockClient) PublishEvents(ctx context.Context, pubsubName, topicName string, events []any, opts ...client.PublishEventsOption) client.PublishEventsResponse { m.ctrl.T.Helper() - varargs := []interface{}{ctx, pubsubName, topicName, events} + varargs := []any{ctx, pubsubName, topicName, events} for _, a := range opts { varargs = append(varargs, a) } @@ -507,9 +512,9 @@ func (m *MockClient) PublishEvents(ctx context.Context, pubsubName, topicName st } // PublishEvents indicates an expected call of PublishEvents. -func (mr *MockClientMockRecorder) PublishEvents(ctx, pubsubName, topicName, events interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) PublishEvents(ctx, pubsubName, topicName, events any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, pubsubName, topicName, events}, opts...) + varargs := append([]any{ctx, pubsubName, topicName, events}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishEvents", reflect.TypeOf((*MockClient)(nil).PublishEvents), varargs...) } @@ -522,7 +527,7 @@ func (m *MockClient) PurgeWorkflowBeta1(ctx context.Context, req *client.PurgeWo } // PurgeWorkflowBeta1 indicates an expected call of PurgeWorkflowBeta1. -func (mr *MockClientMockRecorder) PurgeWorkflowBeta1(ctx, req interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) PurgeWorkflowBeta1(ctx, req any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurgeWorkflowBeta1", reflect.TypeOf((*MockClient)(nil).PurgeWorkflowBeta1), ctx, req) } @@ -537,7 +542,7 @@ func (m *MockClient) QueryStateAlpha1(ctx context.Context, storeName, query stri } // QueryStateAlpha1 indicates an expected call of QueryStateAlpha1. -func (mr *MockClientMockRecorder) QueryStateAlpha1(ctx, storeName, query, meta interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) QueryStateAlpha1(ctx, storeName, query, meta any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryStateAlpha1", reflect.TypeOf((*MockClient)(nil).QueryStateAlpha1), ctx, storeName, query, meta) } @@ -551,7 +556,7 @@ func (m *MockClient) RaiseEventWorkflowBeta1(ctx context.Context, req *client.Ra } // RaiseEventWorkflowBeta1 indicates an expected call of RaiseEventWorkflowBeta1. -func (mr *MockClientMockRecorder) RaiseEventWorkflowBeta1(ctx, req interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) RaiseEventWorkflowBeta1(ctx, req any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RaiseEventWorkflowBeta1", reflect.TypeOf((*MockClient)(nil).RaiseEventWorkflowBeta1), ctx, req) } @@ -565,7 +570,7 @@ func (m *MockClient) RegisterActorReminder(ctx context.Context, req *client.Regi } // RegisterActorReminder indicates an expected call of RegisterActorReminder. -func (mr *MockClientMockRecorder) RegisterActorReminder(ctx, req interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) RegisterActorReminder(ctx, req any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterActorReminder", reflect.TypeOf((*MockClient)(nil).RegisterActorReminder), ctx, req) } @@ -579,7 +584,7 @@ func (m *MockClient) RegisterActorTimer(ctx context.Context, req *client.Registe } // RegisterActorTimer indicates an expected call of RegisterActorTimer. -func (mr *MockClientMockRecorder) RegisterActorTimer(ctx, req interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) RegisterActorTimer(ctx, req any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterActorTimer", reflect.TypeOf((*MockClient)(nil).RegisterActorTimer), ctx, req) } @@ -593,7 +598,7 @@ func (m *MockClient) ResumeWorkflowBeta1(ctx context.Context, req *client.Resume } // ResumeWorkflowBeta1 indicates an expected call of ResumeWorkflowBeta1. -func (mr *MockClientMockRecorder) ResumeWorkflowBeta1(ctx, req interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) ResumeWorkflowBeta1(ctx, req any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeWorkflowBeta1", reflect.TypeOf((*MockClient)(nil).ResumeWorkflowBeta1), ctx, req) } @@ -601,7 +606,7 @@ func (mr *MockClientMockRecorder) ResumeWorkflowBeta1(ctx, req interface{}) *gom // SaveBulkState mocks base method. func (m *MockClient) SaveBulkState(ctx context.Context, storeName string, items ...*client.SetStateItem) error { m.ctrl.T.Helper() - varargs := []interface{}{ctx, storeName} + varargs := []any{ctx, storeName} for _, a := range items { varargs = append(varargs, a) } @@ -611,16 +616,16 @@ func (m *MockClient) SaveBulkState(ctx context.Context, storeName string, items } // SaveBulkState indicates an expected call of SaveBulkState. -func (mr *MockClientMockRecorder) SaveBulkState(ctx, storeName interface{}, items ...interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) SaveBulkState(ctx, storeName any, items ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, storeName}, items...) + varargs := append([]any{ctx, storeName}, items...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveBulkState", reflect.TypeOf((*MockClient)(nil).SaveBulkState), varargs...) } // SaveState mocks base method. func (m *MockClient) SaveState(ctx context.Context, storeName, key string, data []byte, meta map[string]string, so ...client.StateOption) error { m.ctrl.T.Helper() - varargs := []interface{}{ctx, storeName, key, data, meta} + varargs := []any{ctx, storeName, key, data, meta} for _, a := range so { varargs = append(varargs, a) } @@ -630,9 +635,9 @@ func (m *MockClient) SaveState(ctx context.Context, storeName, key string, data } // SaveState indicates an expected call of SaveState. -func (mr *MockClientMockRecorder) SaveState(ctx, storeName, key, data, meta interface{}, so ...interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) SaveState(ctx, storeName, key, data, meta any, so ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, storeName, key, data, meta}, so...) + varargs := append([]any{ctx, storeName, key, data, meta}, so...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveState", reflect.TypeOf((*MockClient)(nil).SaveState), varargs...) } @@ -645,7 +650,7 @@ func (m *MockClient) SaveStateTransactionally(ctx context.Context, actorType, ac } // SaveStateTransactionally indicates an expected call of SaveStateTransactionally. -func (mr *MockClientMockRecorder) SaveStateTransactionally(ctx, actorType, actorID, operations interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) SaveStateTransactionally(ctx, actorType, actorID, operations any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveStateTransactionally", reflect.TypeOf((*MockClient)(nil).SaveStateTransactionally), ctx, actorType, actorID, operations) } @@ -653,7 +658,7 @@ func (mr *MockClientMockRecorder) SaveStateTransactionally(ctx, actorType, actor // SaveStateWithETag mocks base method. func (m *MockClient) SaveStateWithETag(ctx context.Context, storeName, key string, data []byte, etag string, meta map[string]string, so ...client.StateOption) error { m.ctrl.T.Helper() - varargs := []interface{}{ctx, storeName, key, data, etag, meta} + varargs := []any{ctx, storeName, key, data, etag, meta} for _, a := range so { varargs = append(varargs, a) } @@ -663,9 +668,9 @@ func (m *MockClient) SaveStateWithETag(ctx context.Context, storeName, key strin } // SaveStateWithETag indicates an expected call of SaveStateWithETag. -func (mr *MockClientMockRecorder) SaveStateWithETag(ctx, storeName, key, data, etag, meta interface{}, so ...interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) SaveStateWithETag(ctx, storeName, key, data, etag, meta any, so ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, storeName, key, data, etag, meta}, so...) + varargs := append([]any{ctx, storeName, key, data, etag, meta}, so...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveStateWithETag", reflect.TypeOf((*MockClient)(nil).SaveStateWithETag), varargs...) } @@ -678,7 +683,7 @@ func (m *MockClient) SetMetadata(ctx context.Context, key, value string) error { } // SetMetadata indicates an expected call of SetMetadata. -func (mr *MockClientMockRecorder) SetMetadata(ctx, key, value interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) SetMetadata(ctx, key, value any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMetadata", reflect.TypeOf((*MockClient)(nil).SetMetadata), ctx, key, value) } @@ -692,7 +697,7 @@ func (m *MockClient) Shutdown(ctx context.Context) error { } // Shutdown indicates an expected call of Shutdown. -func (mr *MockClientMockRecorder) Shutdown(ctx interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) Shutdown(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockClient)(nil).Shutdown), ctx) } @@ -707,7 +712,7 @@ func (m *MockClient) StartWorkflowBeta1(ctx context.Context, req *client.StartWo } // StartWorkflowBeta1 indicates an expected call of StartWorkflowBeta1. -func (mr *MockClientMockRecorder) StartWorkflowBeta1(ctx, req interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) StartWorkflowBeta1(ctx, req any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartWorkflowBeta1", reflect.TypeOf((*MockClient)(nil).StartWorkflowBeta1), ctx, req) } @@ -715,7 +720,7 @@ func (mr *MockClientMockRecorder) StartWorkflowBeta1(ctx, req interface{}) *gomo // SubscribeConfigurationItems mocks base method. func (m *MockClient) SubscribeConfigurationItems(ctx context.Context, storeName string, keys []string, handler client.ConfigurationHandleFunction, opts ...client.ConfigurationOpt) (string, error) { m.ctrl.T.Helper() - varargs := []interface{}{ctx, storeName, keys, handler} + varargs := []any{ctx, storeName, keys, handler} for _, a := range opts { varargs = append(varargs, a) } @@ -726,9 +731,9 @@ func (m *MockClient) SubscribeConfigurationItems(ctx context.Context, storeName } // SubscribeConfigurationItems indicates an expected call of SubscribeConfigurationItems. -func (mr *MockClientMockRecorder) SubscribeConfigurationItems(ctx, storeName, keys, handler interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) SubscribeConfigurationItems(ctx, storeName, keys, handler any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, storeName, keys, handler}, opts...) + varargs := append([]any{ctx, storeName, keys, handler}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeConfigurationItems", reflect.TypeOf((*MockClient)(nil).SubscribeConfigurationItems), varargs...) } @@ -741,7 +746,7 @@ func (m *MockClient) TerminateWorkflowBeta1(ctx context.Context, req *client.Ter } // TerminateWorkflowBeta1 indicates an expected call of TerminateWorkflowBeta1. -func (mr *MockClientMockRecorder) TerminateWorkflowBeta1(ctx, req interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) TerminateWorkflowBeta1(ctx, req any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateWorkflowBeta1", reflect.TypeOf((*MockClient)(nil).TerminateWorkflowBeta1), ctx, req) } @@ -756,7 +761,7 @@ func (m *MockClient) TryLockAlpha1(ctx context.Context, storeName string, reques } // TryLockAlpha1 indicates an expected call of TryLockAlpha1. -func (mr *MockClientMockRecorder) TryLockAlpha1(ctx, storeName, request interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) TryLockAlpha1(ctx, storeName, request any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryLockAlpha1", reflect.TypeOf((*MockClient)(nil).TryLockAlpha1), ctx, storeName, request) } @@ -771,7 +776,7 @@ func (m *MockClient) UnlockAlpha1(ctx context.Context, storeName string, request } // UnlockAlpha1 indicates an expected call of UnlockAlpha1. -func (mr *MockClientMockRecorder) UnlockAlpha1(ctx, storeName, request interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) UnlockAlpha1(ctx, storeName, request any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnlockAlpha1", reflect.TypeOf((*MockClient)(nil).UnlockAlpha1), ctx, storeName, request) } @@ -785,7 +790,7 @@ func (m *MockClient) UnregisterActorReminder(ctx context.Context, req *client.Un } // UnregisterActorReminder indicates an expected call of UnregisterActorReminder. -func (mr *MockClientMockRecorder) UnregisterActorReminder(ctx, req interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) UnregisterActorReminder(ctx, req any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnregisterActorReminder", reflect.TypeOf((*MockClient)(nil).UnregisterActorReminder), ctx, req) } @@ -799,7 +804,7 @@ func (m *MockClient) UnregisterActorTimer(ctx context.Context, req *client.Unreg } // UnregisterActorTimer indicates an expected call of UnregisterActorTimer. -func (mr *MockClientMockRecorder) UnregisterActorTimer(ctx, req interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) UnregisterActorTimer(ctx, req any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnregisterActorTimer", reflect.TypeOf((*MockClient)(nil).UnregisterActorTimer), ctx, req) } @@ -807,7 +812,7 @@ func (mr *MockClientMockRecorder) UnregisterActorTimer(ctx, req interface{}) *go // UnsubscribeConfigurationItems mocks base method. func (m *MockClient) UnsubscribeConfigurationItems(ctx context.Context, storeName, id string, opts ...client.ConfigurationOpt) error { m.ctrl.T.Helper() - varargs := []interface{}{ctx, storeName, id} + varargs := []any{ctx, storeName, id} for _, a := range opts { varargs = append(varargs, a) } @@ -817,9 +822,9 @@ func (m *MockClient) UnsubscribeConfigurationItems(ctx context.Context, storeNam } // UnsubscribeConfigurationItems indicates an expected call of UnsubscribeConfigurationItems. -func (mr *MockClientMockRecorder) UnsubscribeConfigurationItems(ctx, storeName, id interface{}, opts ...interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) UnsubscribeConfigurationItems(ctx, storeName, id any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, storeName, id}, opts...) + varargs := append([]any{ctx, storeName, id}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnsubscribeConfigurationItems", reflect.TypeOf((*MockClient)(nil).UnsubscribeConfigurationItems), varargs...) } @@ -832,7 +837,7 @@ func (m *MockClient) Wait(ctx context.Context, timeout time.Duration) error { } // Wait indicates an expected call of Wait. -func (mr *MockClientMockRecorder) Wait(ctx, timeout interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) Wait(ctx, timeout any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Wait", reflect.TypeOf((*MockClient)(nil).Wait), ctx, timeout) } @@ -844,7 +849,7 @@ func (m *MockClient) WithAuthToken(token string) { } // WithAuthToken indicates an expected call of WithAuthToken. -func (mr *MockClientMockRecorder) WithAuthToken(token interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) WithAuthToken(token any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithAuthToken", reflect.TypeOf((*MockClient)(nil).WithAuthToken), token) } @@ -858,7 +863,7 @@ func (m *MockClient) WithTraceID(ctx context.Context, id string) context.Context } // WithTraceID indicates an expected call of WithTraceID. -func (mr *MockClientMockRecorder) WithTraceID(ctx, id interface{}) *gomock.Call { +func (mr *MockClientMockRecorder) WithTraceID(ctx, id any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithTraceID", reflect.TypeOf((*MockClient)(nil).WithTraceID), ctx, id) } diff --git a/actor/runtime/actor_runtime_test.go b/actor/runtime/actor_runtime_test.go index 74bfe9c1..42439420 100644 --- a/actor/runtime/actor_runtime_test.go +++ b/actor/runtime/actor_runtime_test.go @@ -20,8 +20,8 @@ import ( actorErr "github.com/dapr/go-sdk/actor/error" actorMock "github.com/dapr/go-sdk/actor/mock" - "github.com/golang/mock/gomock" "github.com/stretchr/testify/assert" + "go.uber.org/mock/gomock" ) func TestNewActorRuntime(t *testing.T) { diff --git a/actor/state/state_manager_test.go b/actor/state/state_manager_test.go index 0be32499..541c6fe6 100644 --- a/actor/state/state_manager_test.go +++ b/actor/state/state_manager_test.go @@ -24,9 +24,9 @@ import ( "github.com/dapr/go-sdk/actor/mock_client" "github.com/dapr/go-sdk/client" - "github.com/golang/mock/gomock" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + "go.uber.org/mock/gomock" ) const ( diff --git a/go.mod b/go.mod index 5e3dfe94..a324692f 100644 --- a/go.mod +++ b/go.mod @@ -5,10 +5,10 @@ go 1.21.8 require ( github.com/dapr/dapr v1.13.0 github.com/go-chi/chi/v5 v5.0.12 - github.com/golang/mock v1.6.0 github.com/google/uuid v1.6.0 github.com/microsoft/durabletask-go v0.4.1-0.20240122160106-fb5c4c05729d github.com/stretchr/testify v1.8.4 + go.uber.org/mock v0.4.0 google.golang.org/grpc v1.62.0 google.golang.org/protobuf v1.33.0 gopkg.in/yaml.v3 v3.0.1 diff --git a/go.sum b/go.sum index 4ecdd21e..5c93a7c2 100644 --- a/go.sum +++ b/go.sum @@ -12,8 +12,6 @@ github.com/go-logr/logr v1.4.1 h1:pKouT5E8xu9zeFC39JXRDukb6JFQPXM5p5I91188VAQ= github.com/go-logr/logr v1.4.1/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= -github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc= -github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg= github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= @@ -36,44 +34,23 @@ github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRI github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= -github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= go.opentelemetry.io/otel v1.23.1 h1:Za4UzOqJYS+MUczKI320AtqZHZb7EqxO00jAHE0jmQY= go.opentelemetry.io/otel v1.23.1/go.mod h1:Td0134eafDLcTS4y+zQ26GE8u3dEuRBiBCTUIRHaikA= go.opentelemetry.io/otel/metric v1.23.1 h1:PQJmqJ9u2QaJLBOELl1cxIdPcpbwzbkjfEyelTl2rlo= go.opentelemetry.io/otel/metric v1.23.1/go.mod h1:mpG2QPlAfnK8yNhNJAxDZruU9Y1/HubbC+KyH8FaCWI= go.opentelemetry.io/otel/trace v1.23.1 h1:4LrmmEd8AU2rFvU1zegmvqW7+kWarxtNOPyeL6HmYY8= go.opentelemetry.io/otel/trace v1.23.1/go.mod h1:4IpnpJFwr1mo/6HL8XIPJaE9y0+u1KcVmuW7dwFSVrI= -golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +go.uber.org/mock v0.4.0 h1:VcM4ZOtdbR4f6VXfiOpwpVJDL6lCReaZ6mw31wqh7KU= +go.uber.org/mock v0.4.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc= golang.org/x/exp v0.0.0-20240119083558-1b970713d09a h1:Q8/wZp0KX97QFTc2ywcOE0YRjZPVIx+MXInMzdvQqcA= golang.org/x/exp v0.0.0-20240119083558-1b970713d09a/go.mod h1:idGWGoKP1toJGkd5/ig9ZLuPcZBC3ewk7SzmH0uou08= -golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= golang.org/x/net v0.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4= golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44= -golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.17.0 h1:25cE3gD+tdBA7lp7QfhuV+rJiE9YXTcS3VG1SqssI/Y= golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= -golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= -golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= -golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= -golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= google.golang.org/genproto/googleapis/rpc v0.0.0-20240205150955-31a09d347014 h1:FSL3lRCkhaPFxqi0s9o+V4UI2WTzAVOvkgbd4kVV4Wg= google.golang.org/genproto/googleapis/rpc v0.0.0-20240205150955-31a09d347014/go.mod h1:SaPjaZGWb0lPqs6Ittu0spdfrOArqji4ZdeP5IC/9N4= google.golang.org/grpc v1.62.0 h1:HQKZ/fa1bXkX1oFOvSjmZEUL8wLSaZTjCcLAlmZRtdk= From 40c60b0062d147086df8ee18c6d893f718ad9890 Mon Sep 17 00:00:00 2001 From: KentHsu Date: Tue, 7 May 2024 11:41:02 +0800 Subject: [PATCH 13/15] chore: run go mod tidy Signed-off-by: KentHsu --- go.sum | 18 ------------------ 1 file changed, 18 deletions(-) diff --git a/go.sum b/go.sum index bb5e6762..5103b32b 100644 --- a/go.sum +++ b/go.sum @@ -44,28 +44,10 @@ go.uber.org/mock v0.4.0 h1:VcM4ZOtdbR4f6VXfiOpwpVJDL6lCReaZ6mw31wqh7KU= go.uber.org/mock v0.4.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc= golang.org/x/exp v0.0.0-20240119083558-1b970713d09a h1:Q8/wZp0KX97QFTc2ywcOE0YRjZPVIx+MXInMzdvQqcA= golang.org/x/exp v0.0.0-20240119083558-1b970713d09a/go.mod h1:idGWGoKP1toJGkd5/ig9ZLuPcZBC3ewk7SzmH0uou08= -golang.org/x/net v0.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4= -golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44= -golang.org/x/sys v0.17.0 h1:25cE3gD+tdBA7lp7QfhuV+rJiE9YXTcS3VG1SqssI/Y= -golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= golang.org/x/net v0.23.0 h1:7EYJ93RZ9vYSZAIb2x3lnuvqO5zneoD6IvWjuhfxjTs= golang.org/x/net v0.23.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg= -golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.18.0 h1:DBdB3niSjOA/O0blCZBqDefyWNYveAYMNF1Wum0DYQ4= golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= -golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= -golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= From 735f1129896d5255d8e071ce70de3ab984107649 Mon Sep 17 00:00:00 2001 From: KentHsu Date: Tue, 23 Jul 2024 19:47:02 +0800 Subject: [PATCH 14/15] chore: update go.mod with Uber's gomock fork Signed-off-by: KentHsu --- go.mod | 2 +- go.sum | 27 ++------------------------- 2 files changed, 3 insertions(+), 26 deletions(-) diff --git a/go.mod b/go.mod index 3817e3b2..153bcf21 100644 --- a/go.mod +++ b/go.mod @@ -5,10 +5,10 @@ go 1.22.5 require ( github.com/dapr/dapr v1.14.0-rc.2 github.com/go-chi/chi/v5 v5.1.0 - github.com/golang/mock v1.6.0 github.com/google/uuid v1.6.0 github.com/microsoft/durabletask-go v0.5.0 github.com/stretchr/testify v1.9.0 + go.uber.org/mock v0.4.0 google.golang.org/grpc v1.65.0 google.golang.org/protobuf v1.34.2 gopkg.in/yaml.v3 v3.0.1 diff --git a/go.sum b/go.sum index cd8f26cc..ffea3972 100644 --- a/go.sum +++ b/go.sum @@ -12,8 +12,6 @@ github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY= github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= -github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc= -github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= @@ -34,43 +32,22 @@ github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRI github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= -github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= go.opentelemetry.io/otel v1.27.0 h1:9BZoF3yMK/O1AafMiQTVu0YDj5Ea4hPhxCs7sGva+cg= go.opentelemetry.io/otel v1.27.0/go.mod h1:DMpAK8fzYRzs+bi3rS5REupisuqTheUlSZJ1WnZaPAQ= go.opentelemetry.io/otel/metric v1.27.0 h1:hvj3vdEKyeCi4YaYfNjv2NUje8FqKqUY8IlF0FxV/ik= go.opentelemetry.io/otel/metric v1.27.0/go.mod h1:mVFgmRlhljgBiuk/MP/oKylr4hs85GZAylncepAX/ak= go.opentelemetry.io/otel/trace v1.27.0 h1:IqYb813p7cmbHk0a5y6pD5JPakbVfftRXABGt5/Rscw= go.opentelemetry.io/otel/trace v1.27.0/go.mod h1:6RiD1hkAprV4/q+yd2ln1HG9GoPx39SuvvstaLBl+l4= -golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +go.uber.org/mock v0.4.0 h1:VcM4ZOtdbR4f6VXfiOpwpVJDL6lCReaZ6mw31wqh7KU= +go.uber.org/mock v0.4.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc= golang.org/x/exp v0.0.0-20240613232115-7f521ea00fb8 h1:yixxcjnhBmY0nkL253HFVIm0JsFHwrHdT3Yh6szTnfY= golang.org/x/exp v0.0.0-20240613232115-7f521ea00fb8/go.mod h1:jj3sYF3dwk5D+ghuXyeI3r5MFf+NT2An6/9dOA95KSI= -golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= golang.org/x/net v0.26.0 h1:soB7SVo0PWrY4vPW/+ay0jKDNScG2X9wFeYlXIvJsOQ= golang.org/x/net v0.26.0/go.mod h1:5YKkiSynbBIh3p6iOc/vibscux0x38BZDkn8sCUPxHE= -golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.21.0 h1:rF+pYz3DAGSQAxAu1CbC7catZg4ebC4UIeIhKxBZvws= golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= -golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= -golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4= golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI= -golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= -golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= google.golang.org/genproto/googleapis/rpc v0.0.0-20240624140628-dc46fd24d27d h1:k3zyW3BYYR30e8v3x0bTDdE9vpYFjZHK+HcyqkrppWk= google.golang.org/genproto/googleapis/rpc v0.0.0-20240624140628-dc46fd24d27d/go.mod h1:Ue6ibwXGpU+dqIcODieyLOcgj7z8+IcskoNIgZxtrFY= google.golang.org/grpc v1.65.0 h1:bs/cUb4lp1G5iImFFd3u5ixQzweKizoZJAwBNLR42lc= From 4b0276c917332c2fc7f3fa3c60fd3cf1f3a2bd1b Mon Sep 17 00:00:00 2001 From: KentHsu Date: Tue, 23 Jul 2024 19:47:48 +0800 Subject: [PATCH 15/15] tests: regenerate mocks Signed-off-by: KentHsu --- actor/mock_client/mock_client.go | 73 ++++++++++++++++++++++++++++++++ 1 file changed, 73 insertions(+) diff --git a/actor/mock_client/mock_client.go b/actor/mock_client/mock_client.go index b743e683..3331f52d 100644 --- a/actor/mock_client/mock_client.go +++ b/actor/mock_client/mock_client.go @@ -101,6 +101,20 @@ func (mr *MockClientMockRecorder) DeleteBulkStateItems(ctx, storeName, items any return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBulkStateItems", reflect.TypeOf((*MockClient)(nil).DeleteBulkStateItems), ctx, storeName, items) } +// DeleteJobAlpha1 mocks base method. +func (m *MockClient) DeleteJobAlpha1(ctx context.Context, name string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteJobAlpha1", ctx, name) + ret0, _ := ret[0].(error) + return ret0 +} + +// DeleteJobAlpha1 indicates an expected call of DeleteJobAlpha1. +func (mr *MockClientMockRecorder) DeleteJobAlpha1(ctx, name any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteJobAlpha1", reflect.TypeOf((*MockClient)(nil).DeleteJobAlpha1), ctx, name) +} + // DeleteState mocks base method. func (m *MockClient) DeleteState(ctx context.Context, storeName, key string, meta map[string]string) error { m.ctrl.T.Helper() @@ -243,6 +257,21 @@ func (mr *MockClientMockRecorder) GetConfigurationItems(ctx, storeName, keys any return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfigurationItems", reflect.TypeOf((*MockClient)(nil).GetConfigurationItems), varargs...) } +// GetJobAlpha1 mocks base method. +func (m *MockClient) GetJobAlpha1(ctx context.Context, name string) (*client.Job, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetJobAlpha1", ctx, name) + ret0, _ := ret[0].(*client.Job) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetJobAlpha1 indicates an expected call of GetJobAlpha1. +func (mr *MockClientMockRecorder) GetJobAlpha1(ctx, name any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetJobAlpha1", reflect.TypeOf((*MockClient)(nil).GetJobAlpha1), ctx, name) +} + // GetMetadata mocks base method. func (m *MockClient) GetMetadata(ctx context.Context) (*client.GetMetadataResponse, error) { m.ctrl.T.Helper() @@ -674,6 +703,20 @@ func (mr *MockClientMockRecorder) SaveStateWithETag(ctx, storeName, key, data, e return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveStateWithETag", reflect.TypeOf((*MockClient)(nil).SaveStateWithETag), varargs...) } +// ScheduleJobAlpha1 mocks base method. +func (m *MockClient) ScheduleJobAlpha1(ctx context.Context, req *client.Job) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ScheduleJobAlpha1", ctx, req) + ret0, _ := ret[0].(error) + return ret0 +} + +// ScheduleJobAlpha1 indicates an expected call of ScheduleJobAlpha1. +func (mr *MockClientMockRecorder) ScheduleJobAlpha1(ctx, req any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScheduleJobAlpha1", reflect.TypeOf((*MockClient)(nil).ScheduleJobAlpha1), ctx, req) +} + // SetMetadata mocks base method. func (m *MockClient) SetMetadata(ctx context.Context, key, value string) error { m.ctrl.T.Helper() @@ -717,6 +760,21 @@ func (mr *MockClientMockRecorder) StartWorkflowBeta1(ctx, req any) *gomock.Call return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartWorkflowBeta1", reflect.TypeOf((*MockClient)(nil).StartWorkflowBeta1), ctx, req) } +// Subscribe mocks base method. +func (m *MockClient) Subscribe(ctx context.Context, opts client.SubscriptionOptions) (*client.Subscription, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Subscribe", ctx, opts) + ret0, _ := ret[0].(*client.Subscription) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Subscribe indicates an expected call of Subscribe. +func (mr *MockClientMockRecorder) Subscribe(ctx, opts any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Subscribe", reflect.TypeOf((*MockClient)(nil).Subscribe), ctx, opts) +} + // SubscribeConfigurationItems mocks base method. func (m *MockClient) SubscribeConfigurationItems(ctx context.Context, storeName string, keys []string, handler client.ConfigurationHandleFunction, opts ...client.ConfigurationOpt) (string, error) { m.ctrl.T.Helper() @@ -737,6 +795,21 @@ func (mr *MockClientMockRecorder) SubscribeConfigurationItems(ctx, storeName, ke return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeConfigurationItems", reflect.TypeOf((*MockClient)(nil).SubscribeConfigurationItems), varargs...) } +// SubscribeWithHandler mocks base method. +func (m *MockClient) SubscribeWithHandler(ctx context.Context, opts client.SubscriptionOptions, handler client.SubscriptionHandleFunction) (func() error, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SubscribeWithHandler", ctx, opts, handler) + ret0, _ := ret[0].(func() error) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SubscribeWithHandler indicates an expected call of SubscribeWithHandler. +func (mr *MockClientMockRecorder) SubscribeWithHandler(ctx, opts, handler any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeWithHandler", reflect.TypeOf((*MockClient)(nil).SubscribeWithHandler), ctx, opts, handler) +} + // TerminateWorkflowBeta1 mocks base method. func (m *MockClient) TerminateWorkflowBeta1(ctx context.Context, req *client.TerminateWorkflowRequest) error { m.ctrl.T.Helper()