From 0753b4becea7ac5fe5fadddf37645506775d575f Mon Sep 17 00:00:00 2001 From: Wil Simpson Date: Wed, 11 Dec 2024 16:18:45 -0500 Subject: [PATCH] bug: updated mocks --- .../character/characterbus/mocks/service.go | 15 +++++ .../gameserver/dimensionbus/mocks/service.go | 15 +++++ pkg/bus/gameserver/mapbus/mocks/repository.go | 60 +++++++++--------- pkg/bus/gameserver/mapbus/mocks/service.go | 61 ++++++++++++++----- 4 files changed, 104 insertions(+), 47 deletions(-) diff --git a/pkg/bus/character/characterbus/mocks/service.go b/pkg/bus/character/characterbus/mocks/service.go index 5e2b576..f4b0707 100644 --- a/pkg/bus/character/characterbus/mocks/service.go +++ b/pkg/bus/character/characterbus/mocks/service.go @@ -13,6 +13,7 @@ import ( context "context" reflect "reflect" + bus "github.com/ShatteredRealms/go-common-service/pkg/bus" characterbus "github.com/ShatteredRealms/go-common-service/pkg/bus/character/characterbus" gomock "go.uber.org/mock/gomock" ) @@ -86,6 +87,20 @@ func (mr *MockServiceMockRecorder) GetCharacters(ctx any) *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCharacters", reflect.TypeOf((*MockService)(nil).GetCharacters), ctx) } +// GetReader mocks base method. +func (m *MockService) GetReader() bus.MessageBusReader[characterbus.Message] { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetReader") + ret0, _ := ret[0].(bus.MessageBusReader[characterbus.Message]) + return ret0 +} + +// GetReader indicates an expected call of GetReader. +func (mr *MockServiceMockRecorder) GetReader() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReader", reflect.TypeOf((*MockService)(nil).GetReader)) +} + // IsProcessing mocks base method. func (m *MockService) IsProcessing() bool { m.ctrl.T.Helper() diff --git a/pkg/bus/gameserver/dimensionbus/mocks/service.go b/pkg/bus/gameserver/dimensionbus/mocks/service.go index 90ff2a6..c9e1174 100644 --- a/pkg/bus/gameserver/dimensionbus/mocks/service.go +++ b/pkg/bus/gameserver/dimensionbus/mocks/service.go @@ -13,6 +13,7 @@ import ( context "context" reflect "reflect" + bus "github.com/ShatteredRealms/go-common-service/pkg/bus" dimensionbus "github.com/ShatteredRealms/go-common-service/pkg/bus/gameserver/dimensionbus" gomock "go.uber.org/mock/gomock" ) @@ -71,6 +72,20 @@ func (mr *MockServiceMockRecorder) GetDimensions(ctx any) *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDimensions", reflect.TypeOf((*MockService)(nil).GetDimensions), ctx) } +// GetReader mocks base method. +func (m *MockService) GetReader() bus.MessageBusReader[dimensionbus.Message] { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetReader") + ret0, _ := ret[0].(bus.MessageBusReader[dimensionbus.Message]) + return ret0 +} + +// GetReader indicates an expected call of GetReader. +func (mr *MockServiceMockRecorder) GetReader() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReader", reflect.TypeOf((*MockService)(nil).GetReader)) +} + // IsProcessing mocks base method. func (m *MockService) IsProcessing() bool { m.ctrl.T.Helper() diff --git a/pkg/bus/gameserver/mapbus/mocks/repository.go b/pkg/bus/gameserver/mapbus/mocks/repository.go index e44dddf..a947dcc 100644 --- a/pkg/bus/gameserver/mapbus/mocks/repository.go +++ b/pkg/bus/gameserver/mapbus/mocks/repository.go @@ -41,62 +41,60 @@ func (m *MockRepository) EXPECT() *MockRepositoryMockRecorder { return m.recorder } -// CreateMap mocks base method. -func (m *MockRepository) CreateMap(ctx context.Context, dimensionId string) (*mapbus.Map, error) { +// Delete mocks base method. +func (m *MockRepository) Delete(ctx context.Context, id string) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateMap", ctx, dimensionId) - ret0, _ := ret[0].(*mapbus.Map) - ret1, _ := ret[1].(error) - return ret0, ret1 + ret := m.ctrl.Call(m, "Delete", ctx, id) + ret0, _ := ret[0].(error) + return ret0 } -// CreateMap indicates an expected call of CreateMap. -func (mr *MockRepositoryMockRecorder) CreateMap(ctx, dimensionId any) *gomock.Call { +// Delete indicates an expected call of Delete. +func (mr *MockRepositoryMockRecorder) Delete(ctx, id any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMap", reflect.TypeOf((*MockRepository)(nil).CreateMap), ctx, dimensionId) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockRepository)(nil).Delete), ctx, id) } -// DeleteMap mocks base method. -func (m *MockRepository) DeleteMap(ctx context.Context, dimensionId string) (*mapbus.Map, error) { +// GetAll mocks base method. +func (m *MockRepository) GetAll(ctx context.Context) (*mapbus.Maps, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteMap", ctx, dimensionId) - ret0, _ := ret[0].(*mapbus.Map) + ret := m.ctrl.Call(m, "GetAll", ctx) + ret0, _ := ret[0].(*mapbus.Maps) ret1, _ := ret[1].(error) return ret0, ret1 } -// DeleteMap indicates an expected call of DeleteMap. -func (mr *MockRepositoryMockRecorder) DeleteMap(ctx, dimensionId any) *gomock.Call { +// GetAll indicates an expected call of GetAll. +func (mr *MockRepositoryMockRecorder) GetAll(ctx any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMap", reflect.TypeOf((*MockRepository)(nil).DeleteMap), ctx, dimensionId) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAll", reflect.TypeOf((*MockRepository)(nil).GetAll), ctx) } -// GetMapById mocks base method. -func (m *MockRepository) GetMapById(ctx context.Context, dimensionId string) (*mapbus.Map, error) { +// GetById mocks base method. +func (m *MockRepository) GetById(ctx context.Context, dimensionId string) (*mapbus.Map, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetMapById", ctx, dimensionId) + ret := m.ctrl.Call(m, "GetById", ctx, dimensionId) ret0, _ := ret[0].(*mapbus.Map) ret1, _ := ret[1].(error) return ret0, ret1 } -// GetMapById indicates an expected call of GetMapById. -func (mr *MockRepositoryMockRecorder) GetMapById(ctx, dimensionId any) *gomock.Call { +// GetById indicates an expected call of GetById. +func (mr *MockRepositoryMockRecorder) GetById(ctx, dimensionId any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMapById", reflect.TypeOf((*MockRepository)(nil).GetMapById), ctx, dimensionId) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetById", reflect.TypeOf((*MockRepository)(nil).GetById), ctx, dimensionId) } -// GetMaps mocks base method. -func (m *MockRepository) GetMaps(ctx context.Context) (*mapbus.Maps, error) { +// Save mocks base method. +func (m *MockRepository) Save(ctx context.Context, data mapbus.Message) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetMaps", ctx) - ret0, _ := ret[0].(*mapbus.Maps) - ret1, _ := ret[1].(error) - return ret0, ret1 + ret := m.ctrl.Call(m, "Save", ctx, data) + ret0, _ := ret[0].(error) + return ret0 } -// GetMaps indicates an expected call of GetMaps. -func (mr *MockRepositoryMockRecorder) GetMaps(ctx any) *gomock.Call { +// Save indicates an expected call of Save. +func (mr *MockRepositoryMockRecorder) Save(ctx, data any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaps", reflect.TypeOf((*MockRepository)(nil).GetMaps), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockRepository)(nil).Save), ctx, data) } diff --git a/pkg/bus/gameserver/mapbus/mocks/service.go b/pkg/bus/gameserver/mapbus/mocks/service.go index b9ed571..4bcc81a 100644 --- a/pkg/bus/gameserver/mapbus/mocks/service.go +++ b/pkg/bus/gameserver/mapbus/mocks/service.go @@ -13,6 +13,7 @@ import ( context "context" reflect "reflect" + bus "github.com/ShatteredRealms/go-common-service/pkg/bus" mapbus "github.com/ShatteredRealms/go-common-service/pkg/bus/gameserver/mapbus" gomock "go.uber.org/mock/gomock" ) @@ -42,18 +43,18 @@ func (m *MockService) EXPECT() *MockServiceMockRecorder { } // GetMapById mocks base method. -func (m *MockService) GetMapById(ctx context.Context, mId string) (*mapbus.Map, error) { +func (m *MockService) GetMapById(ctx context.Context, mapId string) (*mapbus.Map, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetMapById", ctx, mId) + ret := m.ctrl.Call(m, "GetMapById", ctx, mapId) ret0, _ := ret[0].(*mapbus.Map) ret1, _ := ret[1].(error) return ret0, ret1 } // GetMapById indicates an expected call of GetMapById. -func (mr *MockServiceMockRecorder) GetMapById(ctx, mId any) *gomock.Call { +func (mr *MockServiceMockRecorder) GetMapById(ctx, mapId any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMapById", reflect.TypeOf((*MockService)(nil).GetMapById), ctx, mId) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMapById", reflect.TypeOf((*MockService)(nil).GetMapById), ctx, mapId) } // GetMaps mocks base method. @@ -71,26 +72,54 @@ func (mr *MockServiceMockRecorder) GetMaps(ctx any) *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaps", reflect.TypeOf((*MockService)(nil).GetMaps), ctx) } -// StartProcessingBus mocks base method. -func (m *MockService) StartProcessingBus(ctx context.Context) { +// GetReader mocks base method. +func (m *MockService) GetReader() bus.MessageBusReader[mapbus.Message] { m.ctrl.T.Helper() - m.ctrl.Call(m, "StartProcessingBus", ctx) + ret := m.ctrl.Call(m, "GetReader") + ret0, _ := ret[0].(bus.MessageBusReader[mapbus.Message]) + return ret0 } -// StartProcessingBus indicates an expected call of StartProcessingBus. -func (mr *MockServiceMockRecorder) StartProcessingBus(ctx any) *gomock.Call { +// GetReader indicates an expected call of GetReader. +func (mr *MockServiceMockRecorder) GetReader() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartProcessingBus", reflect.TypeOf((*MockService)(nil).StartProcessingBus), ctx) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReader", reflect.TypeOf((*MockService)(nil).GetReader)) } -// StopProcessingBus mocks base method. -func (m *MockService) StopProcessingBus() { +// IsProcessing mocks base method. +func (m *MockService) IsProcessing() bool { m.ctrl.T.Helper() - m.ctrl.Call(m, "StopProcessingBus") + ret := m.ctrl.Call(m, "IsProcessing") + ret0, _ := ret[0].(bool) + return ret0 } -// StopProcessingBus indicates an expected call of StopProcessingBus. -func (mr *MockServiceMockRecorder) StopProcessingBus() *gomock.Call { +// IsProcessing indicates an expected call of IsProcessing. +func (mr *MockServiceMockRecorder) IsProcessing() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopProcessingBus", reflect.TypeOf((*MockService)(nil).StopProcessingBus)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsProcessing", reflect.TypeOf((*MockService)(nil).IsProcessing)) +} + +// StartProcessing mocks base method. +func (m *MockService) StartProcessing(ctx context.Context) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "StartProcessing", ctx) +} + +// StartProcessing indicates an expected call of StartProcessing. +func (mr *MockServiceMockRecorder) StartProcessing(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartProcessing", reflect.TypeOf((*MockService)(nil).StartProcessing), ctx) +} + +// StopProcessing mocks base method. +func (m *MockService) StopProcessing() { + m.ctrl.T.Helper() + m.ctrl.Call(m, "StopProcessing") +} + +// StopProcessing indicates an expected call of StopProcessing. +func (mr *MockServiceMockRecorder) StopProcessing() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopProcessing", reflect.TypeOf((*MockService)(nil).StopProcessing)) }