mocks.*Application_Expecter.GetShows - Code Metrics - cronnoss/tk-api - Measure and Improve Code Quality continuously with Scrutinizer

mocks.*Application_Expecter.GetShows A
last analyzed 2024-09-17 15:27 UTC

↳ Parent: internal/server/mocks/application_mock.go

Complexity

Conditions

Size

Total Lines	2
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	2
dl	0
loc	2
rs	10
c	0
b	0
f	0
nop	1

// Code generated by mockery v2.43.2. DO NOT EDIT.

package mocks

import (
	context "context"

	models "github.com/cronnoss/tk-api/internal/storage/models"
	mock "github.com/stretchr/testify/mock"
)

// Application is an autogenerated mock type for the Application type
type Application struct {
	mock.Mock
}

type Application_Expecter struct {
	mock *mock.Mock
}

func (_m *Application) EXPECT() *Application_Expecter {
	return &Application_Expecter{mock: &_m.Mock}
}

// CreateEvent provides a mock function with given fields: ctx, event
func (_m *Application) CreateEvent(ctx context.Context, event models.Event) (models.Event, error) {
	ret := _m.Called(ctx, event)

	if len(ret) == 0 {
		panic("no return value specified for CreateEvent")
	}

	var r0 models.Event
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, models.Event) (models.Event, error)); ok {
		return rf(ctx, event)
	}
	if rf, ok := ret.Get(0).(func(context.Context, models.Event) models.Event); ok {
		r0 = rf(ctx, event)
	} else {
		r0 = ret.Get(0).(models.Event)
	}

	if rf, ok := ret.Get(1).(func(context.Context, models.Event) error); ok {
		r1 = rf(ctx, event)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Application_CreateEvent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateEvent'
type Application_CreateEvent_Call struct {
	*mock.Call
}

// CreateEvent is a helper method to define mock.On call
//   - ctx context.Context
//   - event models.Event
func (_e *Application_Expecter) CreateEvent(ctx interface{}, event interface{}) *Application_CreateEvent_Call {
	return &Application_CreateEvent_Call{Call: _e.mock.On("CreateEvent", ctx, event)}
}

func (_c *Application_CreateEvent_Call) Run(run func(ctx context.Context, event models.Event)) *Application_CreateEvent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(models.Event))
	})
	return _c
}

func (_c *Application_CreateEvent_Call) Return(_a0 models.Event, _a1 error) *Application_CreateEvent_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Application_CreateEvent_Call) RunAndReturn(run func(context.Context, models.Event) (models.Event, error)) *Application_CreateEvent_Call {
	_c.Call.Return(run)
	return _c
}

// CreateEvents provides a mock function with given fields: ctx, events
func (_m *Application) CreateEvents(ctx context.Context, events []models.Event) ([]models.Event, error) {
	ret := _m.Called(ctx, events)

	if len(ret) == 0 {
		panic("no return value specified for CreateEvents")
	}

	var r0 []models.Event
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, []models.Event) ([]models.Event, error)); ok {
		return rf(ctx, events)
	}
	if rf, ok := ret.Get(0).(func(context.Context, []models.Event) []models.Event); ok {
		r0 = rf(ctx, events)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]models.Event)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, []models.Event) error); ok {
		r1 = rf(ctx, events)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Application_CreateEvents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateEvents'
type Application_CreateEvents_Call struct {
	*mock.Call
}

// CreateEvents is a helper method to define mock.On call
//   - ctx context.Context
//   - events []models.Event
func (_e *Application_Expecter) CreateEvents(ctx interface{}, events interface{}) *Application_CreateEvents_Call {
	return &Application_CreateEvents_Call{Call: _e.mock.On("CreateEvents", ctx, events)}
}

func (_c *Application_CreateEvents_Call) Run(run func(ctx context.Context, events []models.Event)) *Application_CreateEvents_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]models.Event))
	})
	return _c
}

func (_c *Application_CreateEvents_Call) Return(_a0 []models.Event, _a1 error) *Application_CreateEvents_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Application_CreateEvents_Call) RunAndReturn(run func(context.Context, []models.Event) ([]models.Event, error)) *Application_CreateEvents_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePlace provides a mock function with given fields: ctx, place
func (_m *Application) CreatePlace(ctx context.Context, place models.Place) (models.Place, error) {
	ret := _m.Called(ctx, place)

	if len(ret) == 0 {
		panic("no return value specified for CreatePlace")
	}

	var r0 models.Place
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, models.Place) (models.Place, error)); ok {
		return rf(ctx, place)
	}
	if rf, ok := ret.Get(0).(func(context.Context, models.Place) models.Place); ok {
		r0 = rf(ctx, place)
	} else {
		r0 = ret.Get(0).(models.Place)
	}

	if rf, ok := ret.Get(1).(func(context.Context, models.Place) error); ok {
		r1 = rf(ctx, place)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Application_CreatePlace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePlace'
type Application_CreatePlace_Call struct {
	*mock.Call
}

// CreatePlace is a helper method to define mock.On call
//   - ctx context.Context
//   - place models.Place
func (_e *Application_Expecter) CreatePlace(ctx interface{}, place interface{}) *Application_CreatePlace_Call {
	return &Application_CreatePlace_Call{Call: _e.mock.On("CreatePlace", ctx, place)}
}

func (_c *Application_CreatePlace_Call) Run(run func(ctx context.Context, place models.Place)) *Application_CreatePlace_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(models.Place))
	})
	return _c
}

func (_c *Application_CreatePlace_Call) Return(_a0 models.Place, _a1 error) *Application_CreatePlace_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Application_CreatePlace_Call) RunAndReturn(run func(context.Context, models.Place) (models.Place, error)) *Application_CreatePlace_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePlaces provides a mock function with given fields: ctx, places
func (_m *Application) CreatePlaces(ctx context.Context, places []models.Place) ([]models.Place, error) {
	ret := _m.Called(ctx, places)

	if len(ret) == 0 {
		panic("no return value specified for CreatePlaces")
	}

	var r0 []models.Place
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, []models.Place) ([]models.Place, error)); ok {
		return rf(ctx, places)
	}
	if rf, ok := ret.Get(0).(func(context.Context, []models.Place) []models.Place); ok {
		r0 = rf(ctx, places)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]models.Place)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, []models.Place) error); ok {
		r1 = rf(ctx, places)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Application_CreatePlaces_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePlaces'
type Application_CreatePlaces_Call struct {
	*mock.Call
}

// CreatePlaces is a helper method to define mock.On call
//   - ctx context.Context
//   - places []models.Place
func (_e *Application_Expecter) CreatePlaces(ctx interface{}, places interface{}) *Application_CreatePlaces_Call {
	return &Application_CreatePlaces_Call{Call: _e.mock.On("CreatePlaces", ctx, places)}
}

func (_c *Application_CreatePlaces_Call) Run(run func(ctx context.Context, places []models.Place)) *Application_CreatePlaces_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]models.Place))
	})
	return _c
}

func (_c *Application_CreatePlaces_Call) Return(_a0 []models.Place, _a1 error) *Application_CreatePlaces_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Application_CreatePlaces_Call) RunAndReturn(run func(context.Context, []models.Place) ([]models.Place, error)) *Application_CreatePlaces_Call {
	_c.Call.Return(run)
	return _c
}

// CreateShow provides a mock function with given fields: ctx, shows
func (_m *Application) CreateShow(ctx context.Context, shows models.Show) (models.Show, error) {
	ret := _m.Called(ctx, shows)

	if len(ret) == 0 {
		panic("no return value specified for CreateShow")
	}

	var r0 models.Show
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, models.Show) (models.Show, error)); ok {
		return rf(ctx, shows)
	}
	if rf, ok := ret.Get(0).(func(context.Context, models.Show) models.Show); ok {
		r0 = rf(ctx, shows)
	} else {
		r0 = ret.Get(0).(models.Show)
	}

	if rf, ok := ret.Get(1).(func(context.Context, models.Show) error); ok {
		r1 = rf(ctx, shows)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Application_CreateShow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateShow'
type Application_CreateShow_Call struct {
	*mock.Call
}

// CreateShow is a helper method to define mock.On call
//   - ctx context.Context
//   - shows models.Show
func (_e *Application_Expecter) CreateShow(ctx interface{}, shows interface{}) *Application_CreateShow_Call {
	return &Application_CreateShow_Call{Call: _e.mock.On("CreateShow", ctx, shows)}
}

func (_c *Application_CreateShow_Call) Run(run func(ctx context.Context, shows models.Show)) *Application_CreateShow_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(models.Show))
	})
	return _c
}

func (_c *Application_CreateShow_Call) Return(_a0 models.Show, _a1 error) *Application_CreateShow_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Application_CreateShow_Call) RunAndReturn(run func(context.Context, models.Show) (models.Show, error)) *Application_CreateShow_Call {
	_c.Call.Return(run)
	return _c
}

// CreateShows provides a mock function with given fields: ctx, shows
func (_m *Application) CreateShows(ctx context.Context, shows []models.Show) ([]models.Show, error) {
	ret := _m.Called(ctx, shows)

	if len(ret) == 0 {
		panic("no return value specified for CreateShows")
	}

	var r0 []models.Show
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, []models.Show) ([]models.Show, error)); ok {
		return rf(ctx, shows)
	}
	if rf, ok := ret.Get(0).(func(context.Context, []models.Show) []models.Show); ok {
		r0 = rf(ctx, shows)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]models.Show)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, []models.Show) error); ok {
		r1 = rf(ctx, shows)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Application_CreateShows_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateShows'
type Application_CreateShows_Call struct {
	*mock.Call
}

// CreateShows is a helper method to define mock.On call
//   - ctx context.Context
//   - shows []models.Show
func (_e *Application_Expecter) CreateShows(ctx interface{}, shows interface{}) *Application_CreateShows_Call {
	return &Application_CreateShows_Call{Call: _e.mock.On("CreateShows", ctx, shows)}
}

func (_c *Application_CreateShows_Call) Run(run func(ctx context.Context, shows []models.Show)) *Application_CreateShows_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]models.Show))
	})
	return _c
}

func (_c *Application_CreateShows_Call) Return(_a0 []models.Show, _a1 error) *Application_CreateShows_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Application_CreateShows_Call) RunAndReturn(run func(context.Context, []models.Show) ([]models.Show, error)) *Application_CreateShows_Call {
	_c.Call.Return(run)
	return _c
}

// GetEvents provides a mock function with given fields: ctx
func (_m *Application) GetEvents(ctx context.Context) ([]models.Event, error) {
	ret := _m.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for GetEvents")
	}

	var r0 []models.Event
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) ([]models.Event, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) []models.Event); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]models.Event)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Application_GetEvents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEvents'
type Application_GetEvents_Call struct {
	*mock.Call
}

// GetEvents is a helper method to define mock.On call
//   - ctx context.Context
func (_e *Application_Expecter) GetEvents(ctx interface{}) *Application_GetEvents_Call {
	return &Application_GetEvents_Call{Call: _e.mock.On("GetEvents", ctx)}
}

func (_c *Application_GetEvents_Call) Run(run func(ctx context.Context)) *Application_GetEvents_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *Application_GetEvents_Call) Return(_a0 []models.Event, _a1 error) *Application_GetEvents_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Application_GetEvents_Call) RunAndReturn(run func(context.Context) ([]models.Event, error)) *Application_GetEvents_Call {
	_c.Call.Return(run)
	return _c
}

// GetPlaces provides a mock function with given fields: ctx
func (_m *Application) GetPlaces(ctx context.Context) ([]models.Place, error) {
	ret := _m.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for GetPlaces")
	}

	var r0 []models.Place
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) ([]models.Place, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) []models.Place); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]models.Place)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Application_GetPlaces_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPlaces'
type Application_GetPlaces_Call struct {
	*mock.Call
}

// GetPlaces is a helper method to define mock.On call
//   - ctx context.Context
func (_e *Application_Expecter) GetPlaces(ctx interface{}) *Application_GetPlaces_Call {
	return &Application_GetPlaces_Call{Call: _e.mock.On("GetPlaces", ctx)}
}

func (_c *Application_GetPlaces_Call) Run(run func(ctx context.Context)) *Application_GetPlaces_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *Application_GetPlaces_Call) Return(_a0 []models.Place, _a1 error) *Application_GetPlaces_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Application_GetPlaces_Call) RunAndReturn(run func(context.Context) ([]models.Place, error)) *Application_GetPlaces_Call {
	_c.Call.Return(run)
	return _c
}

// GetShows provides a mock function with given fields: ctx
func (_m *Application) GetShows(ctx context.Context) ([]models.Show, error) {
	ret := _m.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for GetShows")
	}

	var r0 []models.Show
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) ([]models.Show, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) []models.Show); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]models.Show)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Application_GetShows_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetShows'
type Application_GetShows_Call struct {
	*mock.Call
}

// GetShows is a helper method to define mock.On call
//   - ctx context.Context
func (_e *Application_Expecter) GetShows(ctx interface{}) *Application_GetShows_Call {
	return &Application_GetShows_Call{Call: _e.mock.On("GetShows", ctx)}
}

func (_c *Application_GetShows_Call) Run(run func(ctx context.Context)) *Application_GetShows_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *Application_GetShows_Call) Return(_a0 []models.Show, _a1 error) *Application_GetShows_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Application_GetShows_Call) RunAndReturn(run func(context.Context) ([]models.Show, error)) *Application_GetShows_Call {
	_c.Call.Return(run)
	return _c
}

// NewApplication creates a new instance of Application. 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 NewApplication(t interface {
	mock.TestingT
	Cleanup(func())
}) *Application {
	mock := &Application{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}


1			// Code generated by mockery v2.43.2. DO NOT EDIT.
2
3			package mocks
4
5			import (
6			context "context"
7
8			models "github.com/cronnoss/tk-api/internal/storage/models"
9			mock "github.com/stretchr/testify/mock"
10			)
11
12			// Application is an autogenerated mock type for the Application type
13			type Application struct {
14			mock.Mock
15			}
16
17			type Application_Expecter struct {
18			mock *mock.Mock
19			}
20
21			func (_m Application) EXPECT() Application_Expecter {
22			return &Application_Expecter{mock: &_m.Mock}
23			}
24
25			// CreateEvent provides a mock function with given fields: ctx, event
26			func (_m *Application) CreateEvent(ctx context.Context, event models.Event) (models.Event, error) {
27			ret := _m.Called(ctx, event)
28
29			if len(ret) == 0 {
30			panic("no return value specified for CreateEvent")
31			}
32
33			var r0 models.Event
34			var r1 error
35			if rf, ok := ret.Get(0).(func(context.Context, models.Event) (models.Event, error)); ok {
36			return rf(ctx, event)
37			}
38			if rf, ok := ret.Get(0).(func(context.Context, models.Event) models.Event); ok {
39			r0 = rf(ctx, event)
40			} else {
41			r0 = ret.Get(0).(models.Event)
42			}
43
44			if rf, ok := ret.Get(1).(func(context.Context, models.Event) error); ok {
45			r1 = rf(ctx, event)
46			} else {
47			r1 = ret.Error(1)
48			}
49
50			return r0, r1
51			}
52
53			// Application_CreateEvent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateEvent'
54			type Application_CreateEvent_Call struct {
55			*mock.Call
56			}
57
58			// CreateEvent is a helper method to define mock.On call
59			// - ctx context.Context
60			// - event models.Event
61			func (_e Application_Expecter) CreateEvent(ctx interface{}, event interface{}) Application_CreateEvent_Call {
62			return &Application_CreateEvent_Call{Call: _e.mock.On("CreateEvent", ctx, event)}
63			}
64
65			func (_c Application_CreateEvent_Call) Run(run func(ctx context.Context, event models.Event)) Application_CreateEvent_Call {
66			_c.Call.Run(func(args mock.Arguments) {
67			run(args[0].(context.Context), args[1].(models.Event))
68			})
69			return _c
70			}
71
72			func (_c Application_CreateEvent_Call) Return(_a0 models.Event, _a1 error) Application_CreateEvent_Call {
73			_c.Call.Return(_a0, _a1)
74			return _c
75			}
76
77			func (_c Application_CreateEvent_Call) RunAndReturn(run func(context.Context, models.Event) (models.Event, error)) Application_CreateEvent_Call {
78			_c.Call.Return(run)
79			return _c
80			}
81
82			// CreateEvents provides a mock function with given fields: ctx, events
83			func (_m *Application) CreateEvents(ctx context.Context, events []models.Event) ([]models.Event, error) {
84			ret := _m.Called(ctx, events)
85
86			if len(ret) == 0 {
87			panic("no return value specified for CreateEvents")
88			}
89
90			var r0 []models.Event
91			var r1 error
92			if rf, ok := ret.Get(0).(func(context.Context, []models.Event) ([]models.Event, error)); ok {
93			return rf(ctx, events)
94			}
95			if rf, ok := ret.Get(0).(func(context.Context, []models.Event) []models.Event); ok {
96			r0 = rf(ctx, events)
97			} else {
98			if ret.Get(0) != nil {
99			r0 = ret.Get(0).([]models.Event)
100			}
101			}
102
103			if rf, ok := ret.Get(1).(func(context.Context, []models.Event) error); ok {
104			r1 = rf(ctx, events)
105			} else {
106			r1 = ret.Error(1)
107			}
108
109			return r0, r1
110			}
111
112			// Application_CreateEvents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateEvents'
113			type Application_CreateEvents_Call struct {
114			*mock.Call
115			}
116
117			// CreateEvents is a helper method to define mock.On call
118			// - ctx context.Context
119			// - events []models.Event
120			func (_e Application_Expecter) CreateEvents(ctx interface{}, events interface{}) Application_CreateEvents_Call {
121			return &Application_CreateEvents_Call{Call: _e.mock.On("CreateEvents", ctx, events)}
122			}
123
124			func (_c Application_CreateEvents_Call) Run(run func(ctx context.Context, events []models.Event)) Application_CreateEvents_Call {
125			_c.Call.Run(func(args mock.Arguments) {
126			run(args[0].(context.Context), args[1].([]models.Event))
127			})
128			return _c
129			}
130
131			func (_c Application_CreateEvents_Call) Return(_a0 []models.Event, _a1 error) Application_CreateEvents_Call {
132			_c.Call.Return(_a0, _a1)
133			return _c
134			}
135
136			func (_c Application_CreateEvents_Call) RunAndReturn(run func(context.Context, []models.Event) ([]models.Event, error)) Application_CreateEvents_Call {
137			_c.Call.Return(run)
138			return _c
139			}
140
141			// CreatePlace provides a mock function with given fields: ctx, place
142			func (_m *Application) CreatePlace(ctx context.Context, place models.Place) (models.Place, error) {
143			ret := _m.Called(ctx, place)
144
145			if len(ret) == 0 {
146			panic("no return value specified for CreatePlace")
147			}
148
149			var r0 models.Place
150			var r1 error
151			if rf, ok := ret.Get(0).(func(context.Context, models.Place) (models.Place, error)); ok {
152			return rf(ctx, place)
153			}
154			if rf, ok := ret.Get(0).(func(context.Context, models.Place) models.Place); ok {
155			r0 = rf(ctx, place)
156			} else {
157			r0 = ret.Get(0).(models.Place)
158			}
159
160			if rf, ok := ret.Get(1).(func(context.Context, models.Place) error); ok {
161			r1 = rf(ctx, place)
162			} else {
163			r1 = ret.Error(1)
164			}
165
166			return r0, r1
167			}
168
169			// Application_CreatePlace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePlace'
170			type Application_CreatePlace_Call struct {
171			*mock.Call
172			}
173
174			// CreatePlace is a helper method to define mock.On call
175			// - ctx context.Context
176			// - place models.Place
177			func (_e Application_Expecter) CreatePlace(ctx interface{}, place interface{}) Application_CreatePlace_Call {
178			return &Application_CreatePlace_Call{Call: _e.mock.On("CreatePlace", ctx, place)}
179			}
180
181			func (_c Application_CreatePlace_Call) Run(run func(ctx context.Context, place models.Place)) Application_CreatePlace_Call {
182			_c.Call.Run(func(args mock.Arguments) {
183			run(args[0].(context.Context), args[1].(models.Place))
184			})
185			return _c
186			}
187
188			func (_c Application_CreatePlace_Call) Return(_a0 models.Place, _a1 error) Application_CreatePlace_Call {
189			_c.Call.Return(_a0, _a1)
190			return _c
191			}
192
193			func (_c Application_CreatePlace_Call) RunAndReturn(run func(context.Context, models.Place) (models.Place, error)) Application_CreatePlace_Call {
194			_c.Call.Return(run)
195			return _c
196			}
197
198			// CreatePlaces provides a mock function with given fields: ctx, places
199			func (_m *Application) CreatePlaces(ctx context.Context, places []models.Place) ([]models.Place, error) {
200			ret := _m.Called(ctx, places)
201
202			if len(ret) == 0 {
203			panic("no return value specified for CreatePlaces")
204			}
205
206			var r0 []models.Place
207			var r1 error
208			if rf, ok := ret.Get(0).(func(context.Context, []models.Place) ([]models.Place, error)); ok {
209			return rf(ctx, places)
210			}
211			if rf, ok := ret.Get(0).(func(context.Context, []models.Place) []models.Place); ok {
212			r0 = rf(ctx, places)
213			} else {
214			if ret.Get(0) != nil {
215			r0 = ret.Get(0).([]models.Place)
216			}
217			}
218
219			if rf, ok := ret.Get(1).(func(context.Context, []models.Place) error); ok {
220			r1 = rf(ctx, places)
221			} else {
222			r1 = ret.Error(1)
223			}
224
225			return r0, r1
226			}
227
228			// Application_CreatePlaces_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePlaces'
229			type Application_CreatePlaces_Call struct {
230			*mock.Call
231			}
232
233			// CreatePlaces is a helper method to define mock.On call
234			// - ctx context.Context
235			// - places []models.Place
236			func (_e Application_Expecter) CreatePlaces(ctx interface{}, places interface{}) Application_CreatePlaces_Call {
237			return &Application_CreatePlaces_Call{Call: _e.mock.On("CreatePlaces", ctx, places)}
238			}
239
240			func (_c Application_CreatePlaces_Call) Run(run func(ctx context.Context, places []models.Place)) Application_CreatePlaces_Call {
241			_c.Call.Run(func(args mock.Arguments) {
242			run(args[0].(context.Context), args[1].([]models.Place))
243			})
244			return _c
245			}
246
247			func (_c Application_CreatePlaces_Call) Return(_a0 []models.Place, _a1 error) Application_CreatePlaces_Call {
248			_c.Call.Return(_a0, _a1)
249			return _c
250			}
251
252			func (_c Application_CreatePlaces_Call) RunAndReturn(run func(context.Context, []models.Place) ([]models.Place, error)) Application_CreatePlaces_Call {
253			_c.Call.Return(run)
254			return _c
255			}
256
257			// CreateShow provides a mock function with given fields: ctx, shows
258			func (_m *Application) CreateShow(ctx context.Context, shows models.Show) (models.Show, error) {
259			ret := _m.Called(ctx, shows)
260
261			if len(ret) == 0 {
262			panic("no return value specified for CreateShow")
263			}
264
265			var r0 models.Show
266			var r1 error
267			if rf, ok := ret.Get(0).(func(context.Context, models.Show) (models.Show, error)); ok {
268			return rf(ctx, shows)
269			}
270			if rf, ok := ret.Get(0).(func(context.Context, models.Show) models.Show); ok {
271			r0 = rf(ctx, shows)
272			} else {
273			r0 = ret.Get(0).(models.Show)
274			}
275
276			if rf, ok := ret.Get(1).(func(context.Context, models.Show) error); ok {
277			r1 = rf(ctx, shows)
278			} else {
279			r1 = ret.Error(1)
280			}
281
282			return r0, r1
283			}
284
285			// Application_CreateShow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateShow'
286			type Application_CreateShow_Call struct {
287			*mock.Call
288			}
289
290			// CreateShow is a helper method to define mock.On call
291			// - ctx context.Context
292			// - shows models.Show
293			func (_e Application_Expecter) CreateShow(ctx interface{}, shows interface{}) Application_CreateShow_Call {
294			return &Application_CreateShow_Call{Call: _e.mock.On("CreateShow", ctx, shows)}
295			}
296
297			func (_c Application_CreateShow_Call) Run(run func(ctx context.Context, shows models.Show)) Application_CreateShow_Call {
298			_c.Call.Run(func(args mock.Arguments) {
299			run(args[0].(context.Context), args[1].(models.Show))
300			})
301			return _c
302			}
303
304			func (_c Application_CreateShow_Call) Return(_a0 models.Show, _a1 error) Application_CreateShow_Call {
305			_c.Call.Return(_a0, _a1)
306			return _c
307			}
308
309			func (_c Application_CreateShow_Call) RunAndReturn(run func(context.Context, models.Show) (models.Show, error)) Application_CreateShow_Call {
310			_c.Call.Return(run)
311			return _c
312			}
313
314			// CreateShows provides a mock function with given fields: ctx, shows
315			func (_m *Application) CreateShows(ctx context.Context, shows []models.Show) ([]models.Show, error) {
316			ret := _m.Called(ctx, shows)
317
318			if len(ret) == 0 {
319			panic("no return value specified for CreateShows")
320			}
321
322			var r0 []models.Show
323			var r1 error
324			if rf, ok := ret.Get(0).(func(context.Context, []models.Show) ([]models.Show, error)); ok {
325			return rf(ctx, shows)
326			}
327			if rf, ok := ret.Get(0).(func(context.Context, []models.Show) []models.Show); ok {
328			r0 = rf(ctx, shows)
329			} else {
330			if ret.Get(0) != nil {
331			r0 = ret.Get(0).([]models.Show)
332			}
333			}
334
335			if rf, ok := ret.Get(1).(func(context.Context, []models.Show) error); ok {
336			r1 = rf(ctx, shows)
337			} else {
338			r1 = ret.Error(1)
339			}
340
341			return r0, r1
342			}
343
344			// Application_CreateShows_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateShows'
345			type Application_CreateShows_Call struct {
346			*mock.Call
347			}
348
349			// CreateShows is a helper method to define mock.On call
350			// - ctx context.Context
351			// - shows []models.Show
352			func (_e Application_Expecter) CreateShows(ctx interface{}, shows interface{}) Application_CreateShows_Call {
353			return &Application_CreateShows_Call{Call: _e.mock.On("CreateShows", ctx, shows)}
354			}
355
356			func (_c Application_CreateShows_Call) Run(run func(ctx context.Context, shows []models.Show)) Application_CreateShows_Call {
357			_c.Call.Run(func(args mock.Arguments) {
358			run(args[0].(context.Context), args[1].([]models.Show))
359			})
360			return _c
361			}
362
363			func (_c Application_CreateShows_Call) Return(_a0 []models.Show, _a1 error) Application_CreateShows_Call {
364			_c.Call.Return(_a0, _a1)
365			return _c
366			}
367
368			func (_c Application_CreateShows_Call) RunAndReturn(run func(context.Context, []models.Show) ([]models.Show, error)) Application_CreateShows_Call {
369			_c.Call.Return(run)
370			return _c
371			}
372
373			// GetEvents provides a mock function with given fields: ctx
374			func (_m *Application) GetEvents(ctx context.Context) ([]models.Event, error) {
375			ret := _m.Called(ctx)
376
377			if len(ret) == 0 {
378			panic("no return value specified for GetEvents")
379			}
380
381			var r0 []models.Event
382			var r1 error
383			if rf, ok := ret.Get(0).(func(context.Context) ([]models.Event, error)); ok {
384			return rf(ctx)
385			}
386			if rf, ok := ret.Get(0).(func(context.Context) []models.Event); ok {
387			r0 = rf(ctx)
388			} else {
389			if ret.Get(0) != nil {
390			r0 = ret.Get(0).([]models.Event)
391			}
392			}
393
394			if rf, ok := ret.Get(1).(func(context.Context) error); ok {
395			r1 = rf(ctx)
396			} else {
397			r1 = ret.Error(1)
398			}
399
400			return r0, r1
401			}
402
403			// Application_GetEvents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEvents'
404			type Application_GetEvents_Call struct {
405			*mock.Call
406			}
407
408			// GetEvents is a helper method to define mock.On call
409			// - ctx context.Context
410			func (_e Application_Expecter) GetEvents(ctx interface{}) Application_GetEvents_Call {
411			return &Application_GetEvents_Call{Call: _e.mock.On("GetEvents", ctx)}
412			}
413
414			func (_c Application_GetEvents_Call) Run(run func(ctx context.Context)) Application_GetEvents_Call {
415			_c.Call.Run(func(args mock.Arguments) {
416			run(args[0].(context.Context))
417			})
418			return _c
419			}
420
421			func (_c Application_GetEvents_Call) Return(_a0 []models.Event, _a1 error) Application_GetEvents_Call {
422			_c.Call.Return(_a0, _a1)
423			return _c
424			}
425
426			func (_c Application_GetEvents_Call) RunAndReturn(run func(context.Context) ([]models.Event, error)) Application_GetEvents_Call {
427			_c.Call.Return(run)
428			return _c
429			}
430
431			// GetPlaces provides a mock function with given fields: ctx
432			func (_m *Application) GetPlaces(ctx context.Context) ([]models.Place, error) {
433			ret := _m.Called(ctx)
434
435			if len(ret) == 0 {
436			panic("no return value specified for GetPlaces")
437			}
438
439			var r0 []models.Place
440			var r1 error
441			if rf, ok := ret.Get(0).(func(context.Context) ([]models.Place, error)); ok {
442			return rf(ctx)
443			}
444			if rf, ok := ret.Get(0).(func(context.Context) []models.Place); ok {
445			r0 = rf(ctx)
446			} else {
447			if ret.Get(0) != nil {
448			r0 = ret.Get(0).([]models.Place)
449			}
450			}
451
452			if rf, ok := ret.Get(1).(func(context.Context) error); ok {
453			r1 = rf(ctx)
454			} else {
455			r1 = ret.Error(1)
456			}
457
458			return r0, r1
459			}
460
461			// Application_GetPlaces_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPlaces'
462			type Application_GetPlaces_Call struct {
463			*mock.Call
464			}
465
466			// GetPlaces is a helper method to define mock.On call
467			// - ctx context.Context
468			func (_e Application_Expecter) GetPlaces(ctx interface{}) Application_GetPlaces_Call {
469			return &Application_GetPlaces_Call{Call: _e.mock.On("GetPlaces", ctx)}
470			}
471
472			func (_c Application_GetPlaces_Call) Run(run func(ctx context.Context)) Application_GetPlaces_Call {
473			_c.Call.Run(func(args mock.Arguments) {
474			run(args[0].(context.Context))
475			})
476			return _c
477			}
478
479			func (_c Application_GetPlaces_Call) Return(_a0 []models.Place, _a1 error) Application_GetPlaces_Call {
480			_c.Call.Return(_a0, _a1)
481			return _c
482			}
483
484			func (_c Application_GetPlaces_Call) RunAndReturn(run func(context.Context) ([]models.Place, error)) Application_GetPlaces_Call {
485			_c.Call.Return(run)
486			return _c
487			}
488
489			// GetShows provides a mock function with given fields: ctx
490			func (_m *Application) GetShows(ctx context.Context) ([]models.Show, error) {
491			ret := _m.Called(ctx)
492
493			if len(ret) == 0 {
494			panic("no return value specified for GetShows")
495			}
496
497			var r0 []models.Show
498			var r1 error
499			if rf, ok := ret.Get(0).(func(context.Context) ([]models.Show, error)); ok {
500			return rf(ctx)
501			}
502			if rf, ok := ret.Get(0).(func(context.Context) []models.Show); ok {
503			r0 = rf(ctx)
504			} else {
505			if ret.Get(0) != nil {
506			r0 = ret.Get(0).([]models.Show)
507			}
508			}
509
510			if rf, ok := ret.Get(1).(func(context.Context) error); ok {
511			r1 = rf(ctx)
512			} else {
513			r1 = ret.Error(1)
514			}
515
516			return r0, r1
517			}
518
519			// Application_GetShows_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetShows'
520			type Application_GetShows_Call struct {
521			*mock.Call
522			}
523
524			// GetShows is a helper method to define mock.On call
525			// - ctx context.Context
526			func (_e Application_Expecter) GetShows(ctx interface{}) Application_GetShows_Call {
527			return &Application_GetShows_Call{Call: _e.mock.On("GetShows", ctx)}
528			}
529
530			func (_c Application_GetShows_Call) Run(run func(ctx context.Context)) Application_GetShows_Call {
531			_c.Call.Run(func(args mock.Arguments) {
532			run(args[0].(context.Context))
533			})
534			return _c
535			}
536
537			func (_c Application_GetShows_Call) Return(_a0 []models.Show, _a1 error) Application_GetShows_Call {
538			_c.Call.Return(_a0, _a1)
539			return _c
540			}
541
542			func (_c Application_GetShows_Call) RunAndReturn(run func(context.Context) ([]models.Show, error)) Application_GetShows_Call {
543			_c.Call.Return(run)
544			return _c
545			}
546
547			// NewApplication creates a new instance of Application. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
548			// The first argument is typically a *testing.T value.
549			func NewApplication(t interface {
550			mock.TestingT
551			Cleanup(func())
552			}) *Application {
553			mock := &Application{}
554			mock.Mock.Test(t)
555
556			t.Cleanup(func() { mock.AssertExpectations(t) })
557
558			return mock
559			}
560

cronnoss / tk-api

mocks.*Application_Expecter.GetShows A last analyzed 2024-09-17 15:27 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

mocks.*Application_Expecter.GetShows A
last analyzed 2024-09-17 15:27 UTC