From 086220dd153e9f8a2221718c296d86309777b972 Mon Sep 17 00:00:00 2001 From: SimFG Date: Fri, 20 Oct 2023 20:14:08 +0800 Subject: [PATCH] Add the mock factory of msg stream (#27834) Signed-off-by: SimFG --- pkg/Makefile | 1 + pkg/mq/msgstream/mock_msgstream_factory.go | 188 +++++++++++++++++++++ 2 files changed, 189 insertions(+) create mode 100644 pkg/mq/msgstream/mock_msgstream_factory.go diff --git a/pkg/Makefile b/pkg/Makefile index 7972c61e10..639bf54f17 100644 --- a/pkg/Makefile +++ b/pkg/Makefile @@ -13,6 +13,7 @@ getdeps: generate-mockery: getdeps $(INSTALL_PATH)/mockery --name=MsgStream --dir=$(PWD)/mq/msgstream --output=$(PWD)/mq/msgstream --filename=mock_msgstream.go --with-expecter --structname=MockMsgStream --outpkg=msgstream --inpackage + $(INSTALL_PATH)/mockery --name=Factory --dir=$(PWD)/mq/msgstream --output=$(PWD)/mq/msgstream --filename=mock_msgstream_factory.go --with-expecter --structname=MockFactory --outpkg=msgstream --inpackage $(INSTALL_PATH)/mockery --name=Client --dir=$(PWD)/mq/msgdispatcher --output=$(PWD)/mq/msgsdispatcher --filename=mock_client.go --with-expecter --structname=MockClient --outpkg=msgdispatcher --inpackage $(INSTALL_PATH)/mockery --name=Logger --dir=$(PWD)/eventlog --output=$(PWD)/eventlog --filename=mock_logger.go --with-expecter --structname=MockLogger --outpkg=eventlog --inpackage $(INSTALL_PATH)/mockery --name=MessageID --dir=$(PWD)/mq/msgstream/mqwrapper --output=$(PWD)/mq/msgstream/mqwrapper --filename=mock_id.go --with-expecter --structname=MockMessageID --outpkg=mqwrapper --inpackage diff --git a/pkg/mq/msgstream/mock_msgstream_factory.go b/pkg/mq/msgstream/mock_msgstream_factory.go new file mode 100644 index 0000000000..1d0c6ff129 --- /dev/null +++ b/pkg/mq/msgstream/mock_msgstream_factory.go @@ -0,0 +1,188 @@ +// Code generated by mockery v2.32.4. DO NOT EDIT. + +package msgstream + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" +) + +// MockFactory is an autogenerated mock type for the Factory type +type MockFactory struct { + mock.Mock +} + +type MockFactory_Expecter struct { + mock *mock.Mock +} + +func (_m *MockFactory) EXPECT() *MockFactory_Expecter { + return &MockFactory_Expecter{mock: &_m.Mock} +} + +// NewMsgStream provides a mock function with given fields: ctx +func (_m *MockFactory) NewMsgStream(ctx context.Context) (MsgStream, error) { + ret := _m.Called(ctx) + + var r0 MsgStream + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (MsgStream, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) MsgStream); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(MsgStream) + } + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockFactory_NewMsgStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewMsgStream' +type MockFactory_NewMsgStream_Call struct { + *mock.Call +} + +// NewMsgStream is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockFactory_Expecter) NewMsgStream(ctx interface{}) *MockFactory_NewMsgStream_Call { + return &MockFactory_NewMsgStream_Call{Call: _e.mock.On("NewMsgStream", ctx)} +} + +func (_c *MockFactory_NewMsgStream_Call) Run(run func(ctx context.Context)) *MockFactory_NewMsgStream_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockFactory_NewMsgStream_Call) Return(_a0 MsgStream, _a1 error) *MockFactory_NewMsgStream_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockFactory_NewMsgStream_Call) RunAndReturn(run func(context.Context) (MsgStream, error)) *MockFactory_NewMsgStream_Call { + _c.Call.Return(run) + return _c +} + +// NewMsgStreamDisposer provides a mock function with given fields: ctx +func (_m *MockFactory) NewMsgStreamDisposer(ctx context.Context) func([]string, string) error { + ret := _m.Called(ctx) + + var r0 func([]string, string) error + if rf, ok := ret.Get(0).(func(context.Context) func([]string, string) error); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(func([]string, string) error) + } + } + + return r0 +} + +// MockFactory_NewMsgStreamDisposer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewMsgStreamDisposer' +type MockFactory_NewMsgStreamDisposer_Call struct { + *mock.Call +} + +// NewMsgStreamDisposer is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockFactory_Expecter) NewMsgStreamDisposer(ctx interface{}) *MockFactory_NewMsgStreamDisposer_Call { + return &MockFactory_NewMsgStreamDisposer_Call{Call: _e.mock.On("NewMsgStreamDisposer", ctx)} +} + +func (_c *MockFactory_NewMsgStreamDisposer_Call) Run(run func(ctx context.Context)) *MockFactory_NewMsgStreamDisposer_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockFactory_NewMsgStreamDisposer_Call) Return(_a0 func([]string, string) error) *MockFactory_NewMsgStreamDisposer_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockFactory_NewMsgStreamDisposer_Call) RunAndReturn(run func(context.Context) func([]string, string) error) *MockFactory_NewMsgStreamDisposer_Call { + _c.Call.Return(run) + return _c +} + +// NewTtMsgStream provides a mock function with given fields: ctx +func (_m *MockFactory) NewTtMsgStream(ctx context.Context) (MsgStream, error) { + ret := _m.Called(ctx) + + var r0 MsgStream + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (MsgStream, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) MsgStream); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(MsgStream) + } + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockFactory_NewTtMsgStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewTtMsgStream' +type MockFactory_NewTtMsgStream_Call struct { + *mock.Call +} + +// NewTtMsgStream is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockFactory_Expecter) NewTtMsgStream(ctx interface{}) *MockFactory_NewTtMsgStream_Call { + return &MockFactory_NewTtMsgStream_Call{Call: _e.mock.On("NewTtMsgStream", ctx)} +} + +func (_c *MockFactory_NewTtMsgStream_Call) Run(run func(ctx context.Context)) *MockFactory_NewTtMsgStream_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockFactory_NewTtMsgStream_Call) Return(_a0 MsgStream, _a1 error) *MockFactory_NewTtMsgStream_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockFactory_NewTtMsgStream_Call) RunAndReturn(run func(context.Context) (MsgStream, error)) *MockFactory_NewTtMsgStream_Call { + _c.Call.Return(run) + return _c +} + +// NewMockFactory creates a new instance of MockFactory. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockFactory(t interface { + mock.TestingT + Cleanup(func()) +}) *MockFactory { + mock := &MockFactory{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +}