mirror of
https://github.com/sablierapp/sablier.git
synced 2026-01-02 11:07:25 +01:00
311 lines
8.8 KiB
Go
311 lines
8.8 KiB
Go
// Code generated by mockery v2.47.0. DO NOT EDIT.
|
|
|
|
package mock
|
|
|
|
import (
|
|
context "context"
|
|
|
|
provider "github.com/sablierapp/sablier/pkg/provider"
|
|
mock "github.com/stretchr/testify/mock"
|
|
|
|
sablier "github.com/sablierapp/sablier/pkg/sablier"
|
|
)
|
|
|
|
// MockProvider is an autogenerated mock type for the Provider type
|
|
type MockProvider struct {
|
|
mock.Mock
|
|
}
|
|
|
|
type MockProvider_Expecter struct {
|
|
mock *mock.Mock
|
|
}
|
|
|
|
func (_m *MockProvider) EXPECT() *MockProvider_Expecter {
|
|
return &MockProvider_Expecter{mock: &_m.Mock}
|
|
}
|
|
|
|
// Events provides a mock function with given fields: ctx
|
|
func (_m *MockProvider) Events(ctx context.Context) (<-chan sablier.Message, <-chan error) {
|
|
ret := _m.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Events")
|
|
}
|
|
|
|
var r0 <-chan sablier.Message
|
|
var r1 <-chan error
|
|
if rf, ok := ret.Get(0).(func(context.Context) (<-chan sablier.Message, <-chan error)); ok {
|
|
return rf(ctx)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context) <-chan sablier.Message); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(<-chan sablier.Message)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context) <-chan error); ok {
|
|
r1 = rf(ctx)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(<-chan error)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockProvider_Events_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Events'
|
|
type MockProvider_Events_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Events is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
func (_e *MockProvider_Expecter) Events(ctx interface{}) *MockProvider_Events_Call {
|
|
return &MockProvider_Events_Call{Call: _e.mock.On("Events", ctx)}
|
|
}
|
|
|
|
func (_c *MockProvider_Events_Call) Run(run func(ctx context.Context)) *MockProvider_Events_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockProvider_Events_Call) Return(_a0 <-chan sablier.Message, _a1 <-chan error) *MockProvider_Events_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockProvider_Events_Call) RunAndReturn(run func(context.Context) (<-chan sablier.Message, <-chan error)) *MockProvider_Events_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Info provides a mock function with given fields: ctx, name
|
|
func (_m *MockProvider) Info(ctx context.Context, name string) (sablier.InstanceInfo, error) {
|
|
ret := _m.Called(ctx, name)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Info")
|
|
}
|
|
|
|
var r0 sablier.InstanceInfo
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) (sablier.InstanceInfo, error)); ok {
|
|
return rf(ctx, name)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) sablier.InstanceInfo); ok {
|
|
r0 = rf(ctx, name)
|
|
} else {
|
|
r0 = ret.Get(0).(sablier.InstanceInfo)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = rf(ctx, name)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockProvider_Info_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Info'
|
|
type MockProvider_Info_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Info is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - name string
|
|
func (_e *MockProvider_Expecter) Info(ctx interface{}, name interface{}) *MockProvider_Info_Call {
|
|
return &MockProvider_Info_Call{Call: _e.mock.On("Info", ctx, name)}
|
|
}
|
|
|
|
func (_c *MockProvider_Info_Call) Run(run func(ctx context.Context, name string)) *MockProvider_Info_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockProvider_Info_Call) Return(_a0 sablier.InstanceInfo, _a1 error) *MockProvider_Info_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockProvider_Info_Call) RunAndReturn(run func(context.Context, string) (sablier.InstanceInfo, error)) *MockProvider_Info_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// List provides a mock function with given fields: ctx, opts
|
|
func (_m *MockProvider) List(ctx context.Context, opts provider.ListOptions) ([]sablier.InstanceConfig, error) {
|
|
ret := _m.Called(ctx, opts)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for List")
|
|
}
|
|
|
|
var r0 []sablier.InstanceConfig
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, provider.ListOptions) ([]sablier.InstanceConfig, error)); ok {
|
|
return rf(ctx, opts)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, provider.ListOptions) []sablier.InstanceConfig); ok {
|
|
r0 = rf(ctx, opts)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]sablier.InstanceConfig)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, provider.ListOptions) error); ok {
|
|
r1 = rf(ctx, opts)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockProvider_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List'
|
|
type MockProvider_List_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// List is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - opts provider.ListOptions
|
|
func (_e *MockProvider_Expecter) List(ctx interface{}, opts interface{}) *MockProvider_List_Call {
|
|
return &MockProvider_List_Call{Call: _e.mock.On("List", ctx, opts)}
|
|
}
|
|
|
|
func (_c *MockProvider_List_Call) Run(run func(ctx context.Context, opts provider.ListOptions)) *MockProvider_List_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(provider.ListOptions))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockProvider_List_Call) Return(_a0 []sablier.InstanceConfig, _a1 error) *MockProvider_List_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockProvider_List_Call) RunAndReturn(run func(context.Context, provider.ListOptions) ([]sablier.InstanceConfig, error)) *MockProvider_List_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Start provides a mock function with given fields: ctx, name, opts
|
|
func (_m *MockProvider) Start(ctx context.Context, name string, opts provider.StartOptions) error {
|
|
ret := _m.Called(ctx, name, opts)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Start")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, provider.StartOptions) error); ok {
|
|
r0 = rf(ctx, name, opts)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockProvider_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start'
|
|
type MockProvider_Start_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Start is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - name string
|
|
// - opts provider.StartOptions
|
|
func (_e *MockProvider_Expecter) Start(ctx interface{}, name interface{}, opts interface{}) *MockProvider_Start_Call {
|
|
return &MockProvider_Start_Call{Call: _e.mock.On("Start", ctx, name, opts)}
|
|
}
|
|
|
|
func (_c *MockProvider_Start_Call) Run(run func(ctx context.Context, name string, opts provider.StartOptions)) *MockProvider_Start_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string), args[2].(provider.StartOptions))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockProvider_Start_Call) Return(_a0 error) *MockProvider_Start_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockProvider_Start_Call) RunAndReturn(run func(context.Context, string, provider.StartOptions) error) *MockProvider_Start_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Stop provides a mock function with given fields: ctx, name
|
|
func (_m *MockProvider) Stop(ctx context.Context, name string) error {
|
|
ret := _m.Called(ctx, name)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Stop")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
|
|
r0 = rf(ctx, name)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockProvider_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
|
|
type MockProvider_Stop_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Stop is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - name string
|
|
func (_e *MockProvider_Expecter) Stop(ctx interface{}, name interface{}) *MockProvider_Stop_Call {
|
|
return &MockProvider_Stop_Call{Call: _e.mock.On("Stop", ctx, name)}
|
|
}
|
|
|
|
func (_c *MockProvider_Stop_Call) Run(run func(ctx context.Context, name string)) *MockProvider_Stop_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockProvider_Stop_Call) Return(_a0 error) *MockProvider_Stop_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockProvider_Stop_Call) RunAndReturn(run func(context.Context, string) error) *MockProvider_Stop_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// NewMockProvider creates a new instance of MockProvider. 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 NewMockProvider(t interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}) *MockProvider {
|
|
mock := &MockProvider{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|