merch-tracker-v2/merch-api
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
merch-api/internal/merch/mock_Repository.go

1568 lines
52 KiB
Go
Raw Normal View History

mock tests
2026-03-13 21:18:16 +03:00
// Code generated by mockery v2.53.6. DO NOT EDIT.
package merch
import (
context "context"
sql "database/sql"
mock "github.com/stretchr/testify/mock"
time "time"
)
// MockRepository is an autogenerated mock type for the Repository type
type MockRepository struct {
mock.Mock
}
type MockRepository_Expecter struct {
mock *mock.Mock
}
func (_m *MockRepository) EXPECT() *MockRepository_Expecter {
return &MockRepository_Expecter{mock: &_m.Mock}
}
// attachLabel provides a mock function with given fields: ctx, userId, label
func (_m *MockRepository) attachLabel(ctx context.Context, userId int64, label *LabelLink) error {
ret := _m.Called(ctx, userId, label)
if len(ret) == 0 {
panic("no return value specified for attachLabel")
}
var r0 error
if rf, ok := ret.Get(0).(func(context.Context, int64, *LabelLink) error); ok {
r0 = rf(ctx, userId, label)
} else {
r0 = ret.Error(0)
}
return r0
}
// MockRepository_attachLabel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'attachLabel'
type MockRepository_attachLabel_Call struct {
*mock.Call
}
// attachLabel is a helper method to define mock.On call
// - ctx context.Context
// - userId int64
// - label *LabelLink
func (_e *MockRepository_Expecter) attachLabel(ctx interface{}, userId interface{}, label interface{}) *MockRepository_attachLabel_Call {
return &MockRepository_attachLabel_Call{Call: _e.mock.On("attachLabel", ctx, userId, label)}
}
func (_c *MockRepository_attachLabel_Call) Run(run func(ctx context.Context, userId int64, label *LabelLink)) *MockRepository_attachLabel_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(int64), args[2].(*LabelLink))
})
return _c
}
func (_c *MockRepository_attachLabel_Call) Return(_a0 error) *MockRepository_attachLabel_Call {
_c.Call.Return(_a0)
return _c
}
func (_c *MockRepository_attachLabel_Call) RunAndReturn(run func(context.Context, int64, *LabelLink) error) *MockRepository_attachLabel_Call {
_c.Call.Return(run)
return _c
}
// createLabel provides a mock function with given fields: ctx, userId, label
func (_m *MockRepository) createLabel(ctx context.Context, userId int64, label *Label) error {
ret := _m.Called(ctx, userId, label)
if len(ret) == 0 {
panic("no return value specified for createLabel")
}
var r0 error
if rf, ok := ret.Get(0).(func(context.Context, int64, *Label) error); ok {
r0 = rf(ctx, userId, label)
} else {
r0 = ret.Error(0)
}
return r0
}
// MockRepository_createLabel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'createLabel'
type MockRepository_createLabel_Call struct {
*mock.Call
}
// createLabel is a helper method to define mock.On call
// - ctx context.Context
// - userId int64
// - label *Label
func (_e *MockRepository_Expecter) createLabel(ctx interface{}, userId interface{}, label interface{}) *MockRepository_createLabel_Call {
return &MockRepository_createLabel_Call{Call: _e.mock.On("createLabel", ctx, userId, label)}
}
func (_c *MockRepository_createLabel_Call) Run(run func(ctx context.Context, userId int64, label *Label)) *MockRepository_createLabel_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(int64), args[2].(*Label))
})
return _c
}
func (_c *MockRepository_createLabel_Call) Return(_a0 error) *MockRepository_createLabel_Call {
_c.Call.Return(_a0)
return _c
}
func (_c *MockRepository_createLabel_Call) RunAndReturn(run func(context.Context, int64, *Label) error) *MockRepository_createLabel_Call {
_c.Call.Return(run)
return _c
}
// createMerch provides a mock function with given fields: ctx, merch, extra
func (_m *MockRepository) createMerch(ctx context.Context, merch *Merch, extra []ExtraData) error {
ret := _m.Called(ctx, merch, extra)
if len(ret) == 0 {
panic("no return value specified for createMerch")
}
var r0 error
if rf, ok := ret.Get(0).(func(context.Context, *Merch, []ExtraData) error); ok {
r0 = rf(ctx, merch, extra)
} else {
r0 = ret.Error(0)
}
return r0
}
// MockRepository_createMerch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'createMerch'
type MockRepository_createMerch_Call struct {
*mock.Call
}
// createMerch is a helper method to define mock.On call
// - ctx context.Context
// - merch *Merch
// - extra []ExtraData
func (_e *MockRepository_Expecter) createMerch(ctx interface{}, merch interface{}, extra interface{}) *MockRepository_createMerch_Call {
return &MockRepository_createMerch_Call{Call: _e.mock.On("createMerch", ctx, merch, extra)}
}
func (_c *MockRepository_createMerch_Call) Run(run func(ctx context.Context, merch *Merch, extra []ExtraData)) *MockRepository_createMerch_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(*Merch), args[2].([]ExtraData))
})
return _c
}
func (_c *MockRepository_createMerch_Call) Return(_a0 error) *MockRepository_createMerch_Call {
_c.Call.Return(_a0)
return _c
}
func (_c *MockRepository_createMerch_Call) RunAndReturn(run func(context.Context, *Merch, []ExtraData) error) *MockRepository_createMerch_Call {
_c.Call.Return(run)
return _c
}
// createOrigin provides a mock function with given fields: ctx, origin
func (_m *MockRepository) createOrigin(ctx context.Context, origin *Origin) error {
ret := _m.Called(ctx, origin)
if len(ret) == 0 {
panic("no return value specified for createOrigin")
}
var r0 error
if rf, ok := ret.Get(0).(func(context.Context, *Origin) error); ok {
r0 = rf(ctx, origin)
} else {
r0 = ret.Error(0)
}
return r0
}
// MockRepository_createOrigin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'createOrigin'
type MockRepository_createOrigin_Call struct {
*mock.Call
}
// createOrigin is a helper method to define mock.On call
// - ctx context.Context
// - origin *Origin
func (_e *MockRepository_Expecter) createOrigin(ctx interface{}, origin interface{}) *MockRepository_createOrigin_Call {
return &MockRepository_createOrigin_Call{Call: _e.mock.On("createOrigin", ctx, origin)}
}
func (_c *MockRepository_createOrigin_Call) Run(run func(ctx context.Context, origin *Origin)) *MockRepository_createOrigin_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(*Origin))
})
return _c
}
func (_c *MockRepository_createOrigin_Call) Return(_a0 error) *MockRepository_createOrigin_Call {
_c.Call.Return(_a0)
return _c
}
func (_c *MockRepository_createOrigin_Call) RunAndReturn(run func(context.Context, *Origin) error) *MockRepository_createOrigin_Call {
_c.Call.Return(run)
return _c
}
// deleteLabel provides a mock function with given fields: ctx, userId, labelUuid, now
func (_m *MockRepository) deleteLabel(ctx context.Context, userId int64, labelUuid string, now sql.NullTime) error {
ret := _m.Called(ctx, userId, labelUuid, now)
if len(ret) == 0 {
panic("no return value specified for deleteLabel")
}
var r0 error
if rf, ok := ret.Get(0).(func(context.Context, int64, string, sql.NullTime) error); ok {
r0 = rf(ctx, userId, labelUuid, now)
} else {
r0 = ret.Error(0)
}
return r0
}
// MockRepository_deleteLabel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'deleteLabel'
type MockRepository_deleteLabel_Call struct {
*mock.Call
}
// deleteLabel is a helper method to define mock.On call
// - ctx context.Context
// - userId int64
// - labelUuid string
// - now sql.NullTime
func (_e *MockRepository_Expecter) deleteLabel(ctx interface{}, userId interface{}, labelUuid interface{}, now interface{}) *MockRepository_deleteLabel_Call {
return &MockRepository_deleteLabel_Call{Call: _e.mock.On("deleteLabel", ctx, userId, labelUuid, now)}
}
func (_c *MockRepository_deleteLabel_Call) Run(run func(ctx context.Context, userId int64, labelUuid string, now sql.NullTime)) *MockRepository_deleteLabel_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(int64), args[2].(string), args[3].(sql.NullTime))
})
return _c
}
func (_c *MockRepository_deleteLabel_Call) Return(_a0 error) *MockRepository_deleteLabel_Call {
_c.Call.Return(_a0)
return _c
}
func (_c *MockRepository_deleteLabel_Call) RunAndReturn(run func(context.Context, int64, string, sql.NullTime) error) *MockRepository_deleteLabel_Call {
_c.Call.Return(run)
return _c
}
// deleteOneMerchRecord provides a mock function with given fields: ctx, userId, merchUuid, delTime
func (_m *MockRepository) deleteOneMerchRecord(ctx context.Context, userId int64, merchUuid string, delTime time.Time) error {
ret := _m.Called(ctx, userId, merchUuid, delTime)
if len(ret) == 0 {
panic("no return value specified for deleteOneMerchRecord")
}
var r0 error
if rf, ok := ret.Get(0).(func(context.Context, int64, string, time.Time) error); ok {
r0 = rf(ctx, userId, merchUuid, delTime)
} else {
r0 = ret.Error(0)
}
return r0
}
// MockRepository_deleteOneMerchRecord_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'deleteOneMerchRecord'
type MockRepository_deleteOneMerchRecord_Call struct {
*mock.Call
}
// deleteOneMerchRecord is a helper method to define mock.On call
// - ctx context.Context
// - userId int64
// - merchUuid string
// - delTime time.Time
func (_e *MockRepository_Expecter) deleteOneMerchRecord(ctx interface{}, userId interface{}, merchUuid interface{}, delTime interface{}) *MockRepository_deleteOneMerchRecord_Call {
return &MockRepository_deleteOneMerchRecord_Call{Call: _e.mock.On("deleteOneMerchRecord", ctx, userId, merchUuid, delTime)}
}
func (_c *MockRepository_deleteOneMerchRecord_Call) Run(run func(ctx context.Context, userId int64, merchUuid string, delTime time.Time)) *MockRepository_deleteOneMerchRecord_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(int64), args[2].(string), args[3].(time.Time))
})
return _c
}
func (_c *MockRepository_deleteOneMerchRecord_Call) Return(_a0 error) *MockRepository_deleteOneMerchRecord_Call {
_c.Call.Return(_a0)
return _c
}
func (_c *MockRepository_deleteOneMerchRecord_Call) RunAndReturn(run func(context.Context, int64, string, time.Time) error) *MockRepository_deleteOneMerchRecord_Call {
_c.Call.Return(run)
return _c
}
// deleteOriginByName provides a mock function with given fields: ctx, name, deletedAt
func (_m *MockRepository) deleteOriginByName(ctx context.Context, name string, deletedAt sql.NullTime) error {
ret := _m.Called(ctx, name, deletedAt)
if len(ret) == 0 {
panic("no return value specified for deleteOriginByName")
}
var r0 error
if rf, ok := ret.Get(0).(func(context.Context, string, sql.NullTime) error); ok {
r0 = rf(ctx, name, deletedAt)
} else {
r0 = ret.Error(0)
}
return r0
}
// MockRepository_deleteOriginByName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'deleteOriginByName'
type MockRepository_deleteOriginByName_Call struct {
*mock.Call
}
// deleteOriginByName is a helper method to define mock.On call
// - ctx context.Context
// - name string
// - deletedAt sql.NullTime
func (_e *MockRepository_Expecter) deleteOriginByName(ctx interface{}, name interface{}, deletedAt interface{}) *MockRepository_deleteOriginByName_Call {
return &MockRepository_deleteOriginByName_Call{Call: _e.mock.On("deleteOriginByName", ctx, name, deletedAt)}
}
func (_c *MockRepository_deleteOriginByName_Call) Run(run func(ctx context.Context, name string, deletedAt sql.NullTime)) *MockRepository_deleteOriginByName_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(string), args[2].(sql.NullTime))
})
return _c
}
func (_c *MockRepository_deleteOriginByName_Call) Return(_a0 error) *MockRepository_deleteOriginByName_Call {
_c.Call.Return(_a0)
return _c
}
func (_c *MockRepository_deleteOriginByName_Call) RunAndReturn(run func(context.Context, string, sql.NullTime) error) *MockRepository_deleteOriginByName_Call {
_c.Call.Return(run)
return _c
}
// deleteZeroPrices provides a mock function with given fields: ctx, userId, now, list
func (_m *MockRepository) deleteZeroPrices(ctx context.Context, userId int64, now sql.NullTime, list []int64) error {
ret := _m.Called(ctx, userId, now, list)
if len(ret) == 0 {
panic("no return value specified for deleteZeroPrices")
}
var r0 error
if rf, ok := ret.Get(0).(func(context.Context, int64, sql.NullTime, []int64) error); ok {
r0 = rf(ctx, userId, now, list)
} else {
r0 = ret.Error(0)
}
return r0
}
// MockRepository_deleteZeroPrices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'deleteZeroPrices'
type MockRepository_deleteZeroPrices_Call struct {
*mock.Call
}
// deleteZeroPrices is a helper method to define mock.On call
// - ctx context.Context
// - userId int64
// - now sql.NullTime
// - list []int64
func (_e *MockRepository_Expecter) deleteZeroPrices(ctx interface{}, userId interface{}, now interface{}, list interface{}) *MockRepository_deleteZeroPrices_Call {
return &MockRepository_deleteZeroPrices_Call{Call: _e.mock.On("deleteZeroPrices", ctx, userId, now, list)}
}
func (_c *MockRepository_deleteZeroPrices_Call) Run(run func(ctx context.Context, userId int64, now sql.NullTime, list []int64)) *MockRepository_deleteZeroPrices_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(int64), args[2].(sql.NullTime), args[3].([]int64))
})
return _c
}
func (_c *MockRepository_deleteZeroPrices_Call) Return(_a0 error) *MockRepository_deleteZeroPrices_Call {
_c.Call.Return(_a0)
return _c
}
func (_c *MockRepository_deleteZeroPrices_Call) RunAndReturn(run func(context.Context, int64, sql.NullTime, []int64) error) *MockRepository_deleteZeroPrices_Call {
_c.Call.Return(run)
return _c
}
// deleteZeroPricesPeriod provides a mock function with given fields: ctx, userId, start, end, now
func (_m *MockRepository) deleteZeroPricesPeriod(ctx context.Context, userId int64, start time.Time, end time.Time, now sql.NullTime) error {
ret := _m.Called(ctx, userId, start, end, now)
if len(ret) == 0 {
panic("no return value specified for deleteZeroPricesPeriod")
}
var r0 error
if rf, ok := ret.Get(0).(func(context.Context, int64, time.Time, time.Time, sql.NullTime) error); ok {
r0 = rf(ctx, userId, start, end, now)
} else {
r0 = ret.Error(0)
}
return r0
}
// MockRepository_deleteZeroPricesPeriod_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'deleteZeroPricesPeriod'
type MockRepository_deleteZeroPricesPeriod_Call struct {
*mock.Call
}
// deleteZeroPricesPeriod is a helper method to define mock.On call
// - ctx context.Context
// - userId int64
// - start time.Time
// - end time.Time
// - now sql.NullTime
func (_e *MockRepository_Expecter) deleteZeroPricesPeriod(ctx interface{}, userId interface{}, start interface{}, end interface{}, now interface{}) *MockRepository_deleteZeroPricesPeriod_Call {
return &MockRepository_deleteZeroPricesPeriod_Call{Call: _e.mock.On("deleteZeroPricesPeriod", ctx, userId, start, end, now)}
}
func (_c *MockRepository_deleteZeroPricesPeriod_Call) Run(run func(ctx context.Context, userId int64, start time.Time, end time.Time, now sql.NullTime)) *MockRepository_deleteZeroPricesPeriod_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(int64), args[2].(time.Time), args[3].(time.Time), args[4].(sql.NullTime))
})
return _c
}
func (_c *MockRepository_deleteZeroPricesPeriod_Call) Return(_a0 error) *MockRepository_deleteZeroPricesPeriod_Call {
_c.Call.Return(_a0)
return _c
}
func (_c *MockRepository_deleteZeroPricesPeriod_Call) RunAndReturn(run func(context.Context, int64, time.Time, time.Time, sql.NullTime) error) *MockRepository_deleteZeroPricesPeriod_Call {
_c.Call.Return(run)
return _c
}
// detachLabel provides a mock function with given fields: ctx, userId, label
func (_m *MockRepository) detachLabel(ctx context.Context, userId int64, label *LabelLink) error {
ret := _m.Called(ctx, userId, label)
if len(ret) == 0 {
panic("no return value specified for detachLabel")
}
var r0 error
if rf, ok := ret.Get(0).(func(context.Context, int64, *LabelLink) error); ok {
r0 = rf(ctx, userId, label)
} else {
r0 = ret.Error(0)
}
return r0
}
// MockRepository_detachLabel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'detachLabel'
type MockRepository_detachLabel_Call struct {
*mock.Call
}
// detachLabel is a helper method to define mock.On call
// - ctx context.Context
// - userId int64
// - label *LabelLink
func (_e *MockRepository_Expecter) detachLabel(ctx interface{}, userId interface{}, label interface{}) *MockRepository_detachLabel_Call {
return &MockRepository_detachLabel_Call{Call: _e.mock.On("detachLabel", ctx, userId, label)}
}
func (_c *MockRepository_detachLabel_Call) Run(run func(ctx context.Context, userId int64, label *LabelLink)) *MockRepository_detachLabel_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(int64), args[2].(*LabelLink))
})
return _c
}
func (_c *MockRepository_detachLabel_Call) Return(_a0 error) *MockRepository_detachLabel_Call {
_c.Call.Return(_a0)
return _c
}
func (_c *MockRepository_detachLabel_Call) RunAndReturn(run func(context.Context, int64, *LabelLink) error) *MockRepository_detachLabel_Call {
_c.Call.Return(run)
return _c
}
// getAllUserMerch provides a mock function with given fields: ctx, userId
func (_m *MockRepository) getAllUserMerch(ctx context.Context, userId int64) ([]Merch, error) {
ret := _m.Called(ctx, userId)
if len(ret) == 0 {
panic("no return value specified for getAllUserMerch")
}
var r0 []Merch
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, int64) ([]Merch, error)); ok {
return rf(ctx, userId)
}
if rf, ok := ret.Get(0).(func(context.Context, int64) []Merch); ok {
r0 = rf(ctx, userId)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]Merch)
}
}
if rf, ok := ret.Get(1).(func(context.Context, int64) error); ok {
r1 = rf(ctx, userId)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockRepository_getAllUserMerch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'getAllUserMerch'
type MockRepository_getAllUserMerch_Call struct {
*mock.Call
}
// getAllUserMerch is a helper method to define mock.On call
// - ctx context.Context
// - userId int64
func (_e *MockRepository_Expecter) getAllUserMerch(ctx interface{}, userId interface{}) *MockRepository_getAllUserMerch_Call {
return &MockRepository_getAllUserMerch_Call{Call: _e.mock.On("getAllUserMerch", ctx, userId)}
}
func (_c *MockRepository_getAllUserMerch_Call) Run(run func(ctx context.Context, userId int64)) *MockRepository_getAllUserMerch_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(int64))
})
return _c
}
func (_c *MockRepository_getAllUserMerch_Call) Return(_a0 []Merch, _a1 error) *MockRepository_getAllUserMerch_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockRepository_getAllUserMerch_Call) RunAndReturn(run func(context.Context, int64) ([]Merch, error)) *MockRepository_getAllUserMerch_Call {
_c.Call.Return(run)
return _c
}
// getAttachedLabelsByUuid provides a mock function with given fields: ctx, userId, merchUuid
func (_m *MockRepository) getAttachedLabelsByUuid(ctx context.Context, userId int64, merchUuid string) ([]string, error) {
ret := _m.Called(ctx, userId, merchUuid)
if len(ret) == 0 {
panic("no return value specified for getAttachedLabelsByUuid")
}
var r0 []string
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, int64, string) ([]string, error)); ok {
return rf(ctx, userId, merchUuid)
}
if rf, ok := ret.Get(0).(func(context.Context, int64, string) []string); ok {
r0 = rf(ctx, userId, merchUuid)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]string)
}
}
if rf, ok := ret.Get(1).(func(context.Context, int64, string) error); ok {
r1 = rf(ctx, userId, merchUuid)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockRepository_getAttachedLabelsByUuid_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'getAttachedLabelsByUuid'
type MockRepository_getAttachedLabelsByUuid_Call struct {
*mock.Call
}
// getAttachedLabelsByUuid is a helper method to define mock.On call
// - ctx context.Context
// - userId int64
// - merchUuid string
func (_e *MockRepository_Expecter) getAttachedLabelsByUuid(ctx interface{}, userId interface{}, merchUuid interface{}) *MockRepository_getAttachedLabelsByUuid_Call {
return &MockRepository_getAttachedLabelsByUuid_Call{Call: _e.mock.On("getAttachedLabelsByUuid", ctx, userId, merchUuid)}
}
func (_c *MockRepository_getAttachedLabelsByUuid_Call) Run(run func(ctx context.Context, userId int64, merchUuid string)) *MockRepository_getAttachedLabelsByUuid_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(int64), args[2].(string))
})
return _c
}
func (_c *MockRepository_getAttachedLabelsByUuid_Call) Return(_a0 []string, _a1 error) *MockRepository_getAttachedLabelsByUuid_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockRepository_getAttachedLabelsByUuid_Call) RunAndReturn(run func(context.Context, int64, string) ([]string, error)) *MockRepository_getAttachedLabelsByUuid_Call {
_c.Call.Return(run)
return _c
}
// getDistinctPrices provides a mock function with given fields: ctx, userId, merchUuid, days
func (_m *MockRepository) getDistinctPrices(ctx context.Context, userId int64, merchUuid string, days time.Time) ([]Price, error) {
ret := _m.Called(ctx, userId, merchUuid, days)
if len(ret) == 0 {
panic("no return value specified for getDistinctPrices")
}
var r0 []Price
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, int64, string, time.Time) ([]Price, error)); ok {
return rf(ctx, userId, merchUuid, days)
}
if rf, ok := ret.Get(0).(func(context.Context, int64, string, time.Time) []Price); ok {
r0 = rf(ctx, userId, merchUuid, days)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]Price)
}
}
if rf, ok := ret.Get(1).(func(context.Context, int64, string, time.Time) error); ok {
r1 = rf(ctx, userId, merchUuid, days)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockRepository_getDistinctPrices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'getDistinctPrices'
type MockRepository_getDistinctPrices_Call struct {
*mock.Call
}
// getDistinctPrices is a helper method to define mock.On call
// - ctx context.Context
// - userId int64
// - merchUuid string
// - days time.Time
func (_e *MockRepository_Expecter) getDistinctPrices(ctx interface{}, userId interface{}, merchUuid interface{}, days interface{}) *MockRepository_getDistinctPrices_Call {
return &MockRepository_getDistinctPrices_Call{Call: _e.mock.On("getDistinctPrices", ctx, userId, merchUuid, days)}
}
func (_c *MockRepository_getDistinctPrices_Call) Run(run func(ctx context.Context, userId int64, merchUuid string, days time.Time)) *MockRepository_getDistinctPrices_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(int64), args[2].(string), args[3].(time.Time))
})
return _c
}
func (_c *MockRepository_getDistinctPrices_Call) Return(_a0 []Price, _a1 error) *MockRepository_getDistinctPrices_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockRepository_getDistinctPrices_Call) RunAndReturn(run func(context.Context, int64, string, time.Time) ([]Price, error)) *MockRepository_getDistinctPrices_Call {
_c.Call.Return(run)
return _c
}
// getLabels provides a mock function with given fields: ctx, userId
func (_m *MockRepository) getLabels(ctx context.Context, userId int64) ([]LabelsList, error) {
ret := _m.Called(ctx, userId)
if len(ret) == 0 {
panic("no return value specified for getLabels")
}
var r0 []LabelsList
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, int64) ([]LabelsList, error)); ok {
return rf(ctx, userId)
}
if rf, ok := ret.Get(0).(func(context.Context, int64) []LabelsList); ok {
r0 = rf(ctx, userId)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]LabelsList)
}
}
if rf, ok := ret.Get(1).(func(context.Context, int64) error); ok {
r1 = rf(ctx, userId)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockRepository_getLabels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'getLabels'
type MockRepository_getLabels_Call struct {
*mock.Call
}
// getLabels is a helper method to define mock.On call
// - ctx context.Context
// - userId int64
func (_e *MockRepository_Expecter) getLabels(ctx interface{}, userId interface{}) *MockRepository_getLabels_Call {
return &MockRepository_getLabels_Call{Call: _e.mock.On("getLabels", ctx, userId)}
}
func (_c *MockRepository_getLabels_Call) Run(run func(ctx context.Context, userId int64)) *MockRepository_getLabels_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(int64))
})
return _c
}
func (_c *MockRepository_getLabels_Call) Return(_a0 []LabelsList, _a1 error) *MockRepository_getLabels_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockRepository_getLabels_Call) RunAndReturn(run func(context.Context, int64) ([]LabelsList, error)) *MockRepository_getLabels_Call {
_c.Call.Return(run)
return _c
}
// getMany provides a mock function with given fields: ctx, userId
func (_m *MockRepository) getMany(ctx context.Context, userId int64) ([]getMerchInternal, error) {
ret := _m.Called(ctx, userId)
if len(ret) == 0 {
panic("no return value specified for getMany")
}
var r0 []getMerchInternal
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, int64) ([]getMerchInternal, error)); ok {
return rf(ctx, userId)
}
if rf, ok := ret.Get(0).(func(context.Context, int64) []getMerchInternal); ok {
r0 = rf(ctx, userId)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]getMerchInternal)
}
}
if rf, ok := ret.Get(1).(func(context.Context, int64) error); ok {
r1 = rf(ctx, userId)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockRepository_getMany_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'getMany'
type MockRepository_getMany_Call struct {
*mock.Call
}
// getMany is a helper method to define mock.On call
// - ctx context.Context
// - userId int64
func (_e *MockRepository_Expecter) getMany(ctx interface{}, userId interface{}) *MockRepository_getMany_Call {
return &MockRepository_getMany_Call{Call: _e.mock.On("getMany", ctx, userId)}
}
func (_c *MockRepository_getMany_Call) Run(run func(ctx context.Context, userId int64)) *MockRepository_getMany_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(int64))
})
return _c
}
func (_c *MockRepository_getMany_Call) Return(_a0 []getMerchInternal, _a1 error) *MockRepository_getMany_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockRepository_getMany_Call) RunAndReturn(run func(context.Context, int64) ([]getMerchInternal, error)) *MockRepository_getMany_Call {
_c.Call.Return(run)
return _c
}
// getManyAttachedLabelsByList provides a mock function with given fields: ctx, userId, list
func (_m *MockRepository) getManyAttachedLabelsByList(ctx context.Context, userId int64, list []int64) (map[int64][]string, error) {
ret := _m.Called(ctx, userId, list)
if len(ret) == 0 {
panic("no return value specified for getManyAttachedLabelsByList")
}
var r0 map[int64][]string
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, int64, []int64) (map[int64][]string, error)); ok {
return rf(ctx, userId, list)
}
if rf, ok := ret.Get(0).(func(context.Context, int64, []int64) map[int64][]string); ok {
r0 = rf(ctx, userId, list)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(map[int64][]string)
}
}
if rf, ok := ret.Get(1).(func(context.Context, int64, []int64) error); ok {
r1 = rf(ctx, userId, list)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockRepository_getManyAttachedLabelsByList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'getManyAttachedLabelsByList'
type MockRepository_getManyAttachedLabelsByList_Call struct {
*mock.Call
}
// getManyAttachedLabelsByList is a helper method to define mock.On call
// - ctx context.Context
// - userId int64
// - list []int64
func (_e *MockRepository_Expecter) getManyAttachedLabelsByList(ctx interface{}, userId interface{}, list interface{}) *MockRepository_getManyAttachedLabelsByList_Call {
return &MockRepository_getManyAttachedLabelsByList_Call{Call: _e.mock.On("getManyAttachedLabelsByList", ctx, userId, list)}
}
func (_c *MockRepository_getManyAttachedLabelsByList_Call) Run(run func(ctx context.Context, userId int64, list []int64)) *MockRepository_getManyAttachedLabelsByList_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(int64), args[2].([]int64))
})
return _c
}
func (_c *MockRepository_getManyAttachedLabelsByList_Call) Return(_a0 map[int64][]string, _a1 error) *MockRepository_getManyAttachedLabelsByList_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockRepository_getManyAttachedLabelsByList_Call) RunAndReturn(run func(context.Context, int64, []int64) (map[int64][]string, error)) *MockRepository_getManyAttachedLabelsByList_Call {
_c.Call.Return(run)
return _c
}
// getMerchIdByUuid provides a mock function with given fields: ctx, userId, uuid
func (_m *MockRepository) getMerchIdByUuid(ctx context.Context, userId int64, uuid string) (int64, error) {
ret := _m.Called(ctx, userId, uuid)
if len(ret) == 0 {
panic("no return value specified for getMerchIdByUuid")
}
var r0 int64
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, int64, string) (int64, error)); ok {
return rf(ctx, userId, uuid)
}
if rf, ok := ret.Get(0).(func(context.Context, int64, string) int64); ok {
r0 = rf(ctx, userId, uuid)
} else {
r0 = ret.Get(0).(int64)
}
if rf, ok := ret.Get(1).(func(context.Context, int64, string) error); ok {
r1 = rf(ctx, userId, uuid)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockRepository_getMerchIdByUuid_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'getMerchIdByUuid'
type MockRepository_getMerchIdByUuid_Call struct {
*mock.Call
}
// getMerchIdByUuid is a helper method to define mock.On call
// - ctx context.Context
// - userId int64
// - uuid string
func (_e *MockRepository_Expecter) getMerchIdByUuid(ctx interface{}, userId interface{}, uuid interface{}) *MockRepository_getMerchIdByUuid_Call {
return &MockRepository_getMerchIdByUuid_Call{Call: _e.mock.On("getMerchIdByUuid", ctx, userId, uuid)}
}
func (_c *MockRepository_getMerchIdByUuid_Call) Run(run func(ctx context.Context, userId int64, uuid string)) *MockRepository_getMerchIdByUuid_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(int64), args[2].(string))
})
return _c
}
func (_c *MockRepository_getMerchIdByUuid_Call) Return(_a0 int64, _a1 error) *MockRepository_getMerchIdByUuid_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockRepository_getMerchIdByUuid_Call) RunAndReturn(run func(context.Context, int64, string) (int64, error)) *MockRepository_getMerchIdByUuid_Call {
_c.Call.Return(run)
return _c
}
// getMerchUuidMap provides a mock function with given fields: ctx, merchUuids
func (_m *MockRepository) getMerchUuidMap(ctx context.Context, merchUuids []string) (map[string]int64, error) {
ret := _m.Called(ctx, merchUuids)
if len(ret) == 0 {
panic("no return value specified for getMerchUuidMap")
}
var r0 map[string]int64
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, []string) (map[string]int64, error)); ok {
return rf(ctx, merchUuids)
}
if rf, ok := ret.Get(0).(func(context.Context, []string) map[string]int64); ok {
r0 = rf(ctx, merchUuids)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(map[string]int64)
}
}
if rf, ok := ret.Get(1).(func(context.Context, []string) error); ok {
r1 = rf(ctx, merchUuids)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockRepository_getMerchUuidMap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'getMerchUuidMap'
type MockRepository_getMerchUuidMap_Call struct {
*mock.Call
}
// getMerchUuidMap is a helper method to define mock.On call
// - ctx context.Context
// - merchUuids []string
func (_e *MockRepository_Expecter) getMerchUuidMap(ctx interface{}, merchUuids interface{}) *MockRepository_getMerchUuidMap_Call {
return &MockRepository_getMerchUuidMap_Call{Call: _e.mock.On("getMerchUuidMap", ctx, merchUuids)}
}
func (_c *MockRepository_getMerchUuidMap_Call) Run(run func(ctx context.Context, merchUuids []string)) *MockRepository_getMerchUuidMap_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].([]string))
})
return _c
}
func (_c *MockRepository_getMerchUuidMap_Call) Return(_a0 map[string]int64, _a1 error) *MockRepository_getMerchUuidMap_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockRepository_getMerchUuidMap_Call) RunAndReturn(run func(context.Context, []string) (map[string]int64, error)) *MockRepository_getMerchUuidMap_Call {
_c.Call.Return(run)
return _c
}
// getOrigins provides a mock function with given fields: ctx
func (_m *MockRepository) getOrigins(ctx context.Context) ([]Origin, error) {
ret := _m.Called(ctx)
if len(ret) == 0 {
panic("no return value specified for getOrigins")
}
var r0 []Origin
var r1 error
if rf, ok := ret.Get(0).(func(context.Context) ([]Origin, error)); ok {
return rf(ctx)
}
if rf, ok := ret.Get(0).(func(context.Context) []Origin); ok {
r0 = rf(ctx)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]Origin)
}
}
if rf, ok := ret.Get(1).(func(context.Context) error); ok {
r1 = rf(ctx)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockRepository_getOrigins_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'getOrigins'
type MockRepository_getOrigins_Call struct {
*mock.Call
}
// getOrigins is a helper method to define mock.On call
// - ctx context.Context
func (_e *MockRepository_Expecter) getOrigins(ctx interface{}) *MockRepository_getOrigins_Call {
return &MockRepository_getOrigins_Call{Call: _e.mock.On("getOrigins", ctx)}
}
func (_c *MockRepository_getOrigins_Call) Run(run func(ctx context.Context)) *MockRepository_getOrigins_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context))
})
return _c
}
func (_c *MockRepository_getOrigins_Call) Return(_a0 []Origin, _a1 error) *MockRepository_getOrigins_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockRepository_getOrigins_Call) RunAndReturn(run func(context.Context) ([]Origin, error)) *MockRepository_getOrigins_Call {
_c.Call.Return(run)
return _c
}
// getPricesWithDays provides a mock function with given fields: ctx, userId, days
func (_m *MockRepository) getPricesWithDays(ctx context.Context, userId int64, days time.Time) ([]Price, error) {
ret := _m.Called(ctx, userId, days)
if len(ret) == 0 {
panic("no return value specified for getPricesWithDays")
}
var r0 []Price
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, int64, time.Time) ([]Price, error)); ok {
return rf(ctx, userId, days)
}
if rf, ok := ret.Get(0).(func(context.Context, int64, time.Time) []Price); ok {
r0 = rf(ctx, userId, days)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]Price)
}
}
if rf, ok := ret.Get(1).(func(context.Context, int64, time.Time) error); ok {
r1 = rf(ctx, userId, days)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockRepository_getPricesWithDays_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'getPricesWithDays'
type MockRepository_getPricesWithDays_Call struct {
*mock.Call
}
// getPricesWithDays is a helper method to define mock.On call
// - ctx context.Context
// - userId int64
// - days time.Time
func (_e *MockRepository_Expecter) getPricesWithDays(ctx interface{}, userId interface{}, days interface{}) *MockRepository_getPricesWithDays_Call {
return &MockRepository_getPricesWithDays_Call{Call: _e.mock.On("getPricesWithDays", ctx, userId, days)}
}
func (_c *MockRepository_getPricesWithDays_Call) Run(run func(ctx context.Context, userId int64, days time.Time)) *MockRepository_getPricesWithDays_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(int64), args[2].(time.Time))
})
return _c
}
func (_c *MockRepository_getPricesWithDays_Call) Return(_a0 []Price, _a1 error) *MockRepository_getPricesWithDays_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockRepository_getPricesWithDays_Call) RunAndReturn(run func(context.Context, int64, time.Time) ([]Price, error)) *MockRepository_getPricesWithDays_Call {
_c.Call.Return(run)
return _c
}
update
2026-03-16 21:09:29 +03:00
// getSingleMerch provides a mock function with given fields: ctx, userId, merchUuid
func (_m *MockRepository) getSingleMerch(ctx context.Context, userId int64, merchUuid string) (*Merch, error) {
ret := _m.Called(ctx, userId, merchUuid)
if len(ret) == 0 {
panic("no return value specified for getSingleMerch")
}
var r0 *Merch
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, int64, string) (*Merch, error)); ok {
return rf(ctx, userId, merchUuid)
}
if rf, ok := ret.Get(0).(func(context.Context, int64, string) *Merch); ok {
r0 = rf(ctx, userId, merchUuid)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*Merch)
}
}
if rf, ok := ret.Get(1).(func(context.Context, int64, string) error); ok {
r1 = rf(ctx, userId, merchUuid)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockRepository_getSingleMerch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'getSingleMerch'
type MockRepository_getSingleMerch_Call struct {
*mock.Call
}
// getSingleMerch is a helper method to define mock.On call
// - ctx context.Context
// - userId int64
// - merchUuid string
func (_e *MockRepository_Expecter) getSingleMerch(ctx interface{}, userId interface{}, merchUuid interface{}) *MockRepository_getSingleMerch_Call {
return &MockRepository_getSingleMerch_Call{Call: _e.mock.On("getSingleMerch", ctx, userId, merchUuid)}
}
func (_c *MockRepository_getSingleMerch_Call) Run(run func(ctx context.Context, userId int64, merchUuid string)) *MockRepository_getSingleMerch_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(int64), args[2].(string))
})
return _c
}
func (_c *MockRepository_getSingleMerch_Call) Return(_a0 *Merch, _a1 error) *MockRepository_getSingleMerch_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockRepository_getSingleMerch_Call) RunAndReturn(run func(context.Context, int64, string) (*Merch, error)) *MockRepository_getSingleMerch_Call {
_c.Call.Return(run)
return _c
}
// getSingleMerchExtraData provides a mock function with given fields: ctx, merchId
func (_m *MockRepository) getSingleMerchExtraData(ctx context.Context, merchId int64) ([]originLink, error) {
ret := _m.Called(ctx, merchId)
if len(ret) == 0 {
panic("no return value specified for getSingleMerchExtraData")
}
var r0 []originLink
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, int64) ([]originLink, error)); ok {
return rf(ctx, merchId)
}
if rf, ok := ret.Get(0).(func(context.Context, int64) []originLink); ok {
r0 = rf(ctx, merchId)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]originLink)
}
}
if rf, ok := ret.Get(1).(func(context.Context, int64) error); ok {
r1 = rf(ctx, merchId)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockRepository_getSingleMerchExtraData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'getSingleMerchExtraData'
type MockRepository_getSingleMerchExtraData_Call struct {
*mock.Call
}
// getSingleMerchExtraData is a helper method to define mock.On call
// - ctx context.Context
// - merchId int64
func (_e *MockRepository_Expecter) getSingleMerchExtraData(ctx interface{}, merchId interface{}) *MockRepository_getSingleMerchExtraData_Call {
return &MockRepository_getSingleMerchExtraData_Call{Call: _e.mock.On("getSingleMerchExtraData", ctx, merchId)}
}
func (_c *MockRepository_getSingleMerchExtraData_Call) Run(run func(ctx context.Context, merchId int64)) *MockRepository_getSingleMerchExtraData_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(int64))
})
return _c
}
func (_c *MockRepository_getSingleMerchExtraData_Call) Return(_a0 []originLink, _a1 error) *MockRepository_getSingleMerchExtraData_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockRepository_getSingleMerchExtraData_Call) RunAndReturn(run func(context.Context, int64) ([]originLink, error)) *MockRepository_getSingleMerchExtraData_Call {
_c.Call.Return(run)
return _c
}
mock tests
2026-03-13 21:18:16 +03:00
// getTaskData provides a mock function with given fields: ctx
func (_m *MockRepository) getTaskData(ctx context.Context) ([]taskData, error) {
ret := _m.Called(ctx)
if len(ret) == 0 {
panic("no return value specified for getTaskData")
}
var r0 []taskData
var r1 error
if rf, ok := ret.Get(0).(func(context.Context) ([]taskData, error)); ok {
return rf(ctx)
}
if rf, ok := ret.Get(0).(func(context.Context) []taskData); ok {
r0 = rf(ctx)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]taskData)
}
}
if rf, ok := ret.Get(1).(func(context.Context) error); ok {
r1 = rf(ctx)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockRepository_getTaskData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'getTaskData'
type MockRepository_getTaskData_Call struct {
*mock.Call
}
// getTaskData is a helper method to define mock.On call
// - ctx context.Context
func (_e *MockRepository_Expecter) getTaskData(ctx interface{}) *MockRepository_getTaskData_Call {
return &MockRepository_getTaskData_Call{Call: _e.mock.On("getTaskData", ctx)}
}
func (_c *MockRepository_getTaskData_Call) Run(run func(ctx context.Context)) *MockRepository_getTaskData_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context))
})
return _c
}
func (_c *MockRepository_getTaskData_Call) Return(_a0 []taskData, _a1 error) *MockRepository_getTaskData_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockRepository_getTaskData_Call) RunAndReturn(run func(context.Context) ([]taskData, error)) *MockRepository_getTaskData_Call {
_c.Call.Return(run)
return _c
}
// getZeroPrices provides a mock function with given fields: ctx, userId
func (_m *MockRepository) getZeroPrices(ctx context.Context, userId int64) ([]ZeroPrice, error) {
ret := _m.Called(ctx, userId)
if len(ret) == 0 {
panic("no return value specified for getZeroPrices")
}
var r0 []ZeroPrice
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, int64) ([]ZeroPrice, error)); ok {
return rf(ctx, userId)
}
if rf, ok := ret.Get(0).(func(context.Context, int64) []ZeroPrice); ok {
r0 = rf(ctx, userId)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]ZeroPrice)
}
}
if rf, ok := ret.Get(1).(func(context.Context, int64) error); ok {
r1 = rf(ctx, userId)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockRepository_getZeroPrices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'getZeroPrices'
type MockRepository_getZeroPrices_Call struct {
*mock.Call
}
// getZeroPrices is a helper method to define mock.On call
// - ctx context.Context
// - userId int64
func (_e *MockRepository_Expecter) getZeroPrices(ctx interface{}, userId interface{}) *MockRepository_getZeroPrices_Call {
return &MockRepository_getZeroPrices_Call{Call: _e.mock.On("getZeroPrices", ctx, userId)}
}
func (_c *MockRepository_getZeroPrices_Call) Run(run func(ctx context.Context, userId int64)) *MockRepository_getZeroPrices_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(int64))
})
return _c
}
func (_c *MockRepository_getZeroPrices_Call) Return(_a0 []ZeroPrice, _a1 error) *MockRepository_getZeroPrices_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockRepository_getZeroPrices_Call) RunAndReturn(run func(context.Context, int64) ([]ZeroPrice, error)) *MockRepository_getZeroPrices_Call {
_c.Call.Return(run)
return _c
}
// insertPrices provides a mock function with given fields: ctx, prices
func (_m *MockRepository) insertPrices(ctx context.Context, prices []Price) error {
ret := _m.Called(ctx, prices)
if len(ret) == 0 {
panic("no return value specified for insertPrices")
}
var r0 error
if rf, ok := ret.Get(0).(func(context.Context, []Price) error); ok {
r0 = rf(ctx, prices)
} else {
r0 = ret.Error(0)
}
return r0
}
// MockRepository_insertPrices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'insertPrices'
type MockRepository_insertPrices_Call struct {
*mock.Call
}
// insertPrices is a helper method to define mock.On call
// - ctx context.Context
// - prices []Price
func (_e *MockRepository_Expecter) insertPrices(ctx interface{}, prices interface{}) *MockRepository_insertPrices_Call {
return &MockRepository_insertPrices_Call{Call: _e.mock.On("insertPrices", ctx, prices)}
}
func (_c *MockRepository_insertPrices_Call) Run(run func(ctx context.Context, prices []Price)) *MockRepository_insertPrices_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].([]Price))
})
return _c
}
func (_c *MockRepository_insertPrices_Call) Return(_a0 error) *MockRepository_insertPrices_Call {
_c.Call.Return(_a0)
return _c
}
func (_c *MockRepository_insertPrices_Call) RunAndReturn(run func(context.Context, []Price) error) *MockRepository_insertPrices_Call {
_c.Call.Return(run)
return _c
}
// updateExtraData provides a mock function with given fields: ctx, merchId, insertData
func (_m *MockRepository) updateExtraData(ctx context.Context, merchId int64, insertData []ExtraData) ([]ExtraData, error) {
ret := _m.Called(ctx, merchId, insertData)
if len(ret) == 0 {
panic("no return value specified for updateExtraData")
}
var r0 []ExtraData
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, int64, []ExtraData) ([]ExtraData, error)); ok {
return rf(ctx, merchId, insertData)
}
if rf, ok := ret.Get(0).(func(context.Context, int64, []ExtraData) []ExtraData); ok {
r0 = rf(ctx, merchId, insertData)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]ExtraData)
}
}
if rf, ok := ret.Get(1).(func(context.Context, int64, []ExtraData) error); ok {
r1 = rf(ctx, merchId, insertData)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockRepository_updateExtraData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'updateExtraData'
type MockRepository_updateExtraData_Call struct {
*mock.Call
}
// updateExtraData is a helper method to define mock.On call
// - ctx context.Context
// - merchId int64
// - insertData []ExtraData
func (_e *MockRepository_Expecter) updateExtraData(ctx interface{}, merchId interface{}, insertData interface{}) *MockRepository_updateExtraData_Call {
return &MockRepository_updateExtraData_Call{Call: _e.mock.On("updateExtraData", ctx, merchId, insertData)}
}
func (_c *MockRepository_updateExtraData_Call) Run(run func(ctx context.Context, merchId int64, insertData []ExtraData)) *MockRepository_updateExtraData_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(int64), args[2].([]ExtraData))
})
return _c
}
func (_c *MockRepository_updateExtraData_Call) Return(_a0 []ExtraData, _a1 error) *MockRepository_updateExtraData_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockRepository_updateExtraData_Call) RunAndReturn(run func(context.Context, int64, []ExtraData) ([]ExtraData, error)) *MockRepository_updateExtraData_Call {
_c.Call.Return(run)
return _c
}
// updateLabel provides a mock function with given fields: ctx, userId, label
func (_m *MockRepository) updateLabel(ctx context.Context, userId int64, label *Label) error {
ret := _m.Called(ctx, userId, label)
if len(ret) == 0 {
panic("no return value specified for updateLabel")
}
var r0 error
if rf, ok := ret.Get(0).(func(context.Context, int64, *Label) error); ok {
r0 = rf(ctx, userId, label)
} else {
r0 = ret.Error(0)
}
return r0
}
// MockRepository_updateLabel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'updateLabel'
type MockRepository_updateLabel_Call struct {
*mock.Call
}
// updateLabel is a helper method to define mock.On call
// - ctx context.Context
// - userId int64
// - label *Label
func (_e *MockRepository_Expecter) updateLabel(ctx interface{}, userId interface{}, label interface{}) *MockRepository_updateLabel_Call {
return &MockRepository_updateLabel_Call{Call: _e.mock.On("updateLabel", ctx, userId, label)}
}
func (_c *MockRepository_updateLabel_Call) Run(run func(ctx context.Context, userId int64, label *Label)) *MockRepository_updateLabel_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(int64), args[2].(*Label))
})
return _c
}
func (_c *MockRepository_updateLabel_Call) Return(_a0 error) *MockRepository_updateLabel_Call {
_c.Call.Return(_a0)
return _c
}
func (_c *MockRepository_updateLabel_Call) RunAndReturn(run func(context.Context, int64, *Label) error) *MockRepository_updateLabel_Call {
_c.Call.Return(run)
return _c
}
// updateMerch provides a mock function with given fields: ctx, userId, merch
func (_m *MockRepository) updateMerch(ctx context.Context, userId int64, merch *updateMerchDTO) (*merchDTO, error) {
ret := _m.Called(ctx, userId, merch)
if len(ret) == 0 {
panic("no return value specified for updateMerch")
}
var r0 *merchDTO
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, int64, *updateMerchDTO) (*merchDTO, error)); ok {
return rf(ctx, userId, merch)
}
if rf, ok := ret.Get(0).(func(context.Context, int64, *updateMerchDTO) *merchDTO); ok {
r0 = rf(ctx, userId, merch)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*merchDTO)
}
}
if rf, ok := ret.Get(1).(func(context.Context, int64, *updateMerchDTO) error); ok {
r1 = rf(ctx, userId, merch)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockRepository_updateMerch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'updateMerch'
type MockRepository_updateMerch_Call struct {
*mock.Call
}
// updateMerch is a helper method to define mock.On call
// - ctx context.Context
// - userId int64
// - merch *updateMerchDTO
func (_e *MockRepository_Expecter) updateMerch(ctx interface{}, userId interface{}, merch interface{}) *MockRepository_updateMerch_Call {
return &MockRepository_updateMerch_Call{Call: _e.mock.On("updateMerch", ctx, userId, merch)}
}
func (_c *MockRepository_updateMerch_Call) Run(run func(ctx context.Context, userId int64, merch *updateMerchDTO)) *MockRepository_updateMerch_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(int64), args[2].(*updateMerchDTO))
})
return _c
}
func (_c *MockRepository_updateMerch_Call) Return(_a0 *merchDTO, _a1 error) *MockRepository_updateMerch_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockRepository_updateMerch_Call) RunAndReturn(run func(context.Context, int64, *updateMerchDTO) (*merchDTO, error)) *MockRepository_updateMerch_Call {
_c.Call.Return(run)
return _c
}
// NewMockRepository creates a new instance of MockRepository. 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 NewMockRepository(t interface {
mock.TestingT
Cleanup(func())
}) *MockRepository {
mock := &MockRepository{}
mock.Mock.Test(t)
t.Cleanup(func() { mock.AssertExpectations(t) })
return mock
}
Reference in a new issue Copy permalink