mocks.go RawHistoryFolder

1// Code generated by mockery; DO NOT EDIT.
2// github.com/vektra/mockery
3// template: testify
4
5package mocks
6
7import (
8	"context"
9	"time"
10
11	"github.com/bnema/dumber/internal/domain/entity"
12	mock "github.com/stretchr/testify/mock"
13)
14
15// NewMockFavoriteRepository creates a new instance of MockFavoriteRepository. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
16// The first argument is typically a *testing.T value.
17func NewMockFavoriteRepository(t interface {
18	mock.TestingT
19	Cleanup(func())
20}) *MockFavoriteRepository {
21	mock := &MockFavoriteRepository{}
22	mock.Mock.Test(t)
23
24	t.Cleanup(func() { mock.AssertExpectations(t) })
25
26	return mock
27}
28
29// MockFavoriteRepository is an autogenerated mock type for the FavoriteRepository type
30type MockFavoriteRepository struct {
31	mock.Mock
32}
33
34type MockFavoriteRepository_Expecter struct {
35	mock *mock.Mock
36}
37
38func (_m *MockFavoriteRepository) EXPECT() *MockFavoriteRepository_Expecter {
39	return &MockFavoriteRepository_Expecter{mock: &_m.Mock}
40}
41
42// Delete provides a mock function for the type MockFavoriteRepository
43func (_mock *MockFavoriteRepository) Delete(ctx context.Context, id entity.FavoriteID) error {
44	ret := _mock.Called(ctx, id)
45
46	if len(ret) == 0 {
47		panic("no return value specified for Delete")
48	}
49
50	var r0 error
51	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FavoriteID) error); ok {
52		r0 = returnFunc(ctx, id)
53	} else {
54		r0 = ret.Error(0)
55	}
56	return r0
57}
58
59// MockFavoriteRepository_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
60type MockFavoriteRepository_Delete_Call struct {
61	*mock.Call
62}
63
64// Delete is a helper method to define mock.On call
65//   - ctx context.Context
66//   - id entity.FavoriteID
67func (_e *MockFavoriteRepository_Expecter) Delete(ctx interface{}, id interface{}) *MockFavoriteRepository_Delete_Call {
68	return &MockFavoriteRepository_Delete_Call{Call: _e.mock.On("Delete", ctx, id)}
69}
70
71func (_c *MockFavoriteRepository_Delete_Call) Run(run func(ctx context.Context, id entity.FavoriteID)) *MockFavoriteRepository_Delete_Call {
72	_c.Call.Run(func(args mock.Arguments) {
73		var arg0 context.Context
74		if args[0] != nil {
75			arg0 = args[0].(context.Context)
76		}
77		var arg1 entity.FavoriteID
78		if args[1] != nil {
79			arg1 = args[1].(entity.FavoriteID)
80		}
81		run(
82			arg0,
83			arg1,
84		)
85	})
86	return _c
87}
88
89func (_c *MockFavoriteRepository_Delete_Call) Return(err error) *MockFavoriteRepository_Delete_Call {
90	_c.Call.Return(err)
91	return _c
92}
93
94func (_c *MockFavoriteRepository_Delete_Call) RunAndReturn(run func(ctx context.Context, id entity.FavoriteID) error) *MockFavoriteRepository_Delete_Call {
95	_c.Call.Return(run)
96	return _c
97}
98
99// FindByID provides a mock function for the type MockFavoriteRepository
100func (_mock *MockFavoriteRepository) FindByID(ctx context.Context, id entity.FavoriteID) (*entity.Favorite, error) {
101	ret := _mock.Called(ctx, id)
102
103	if len(ret) == 0 {
104		panic("no return value specified for FindByID")
105	}
106
107	var r0 *entity.Favorite
108	var r1 error
109	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FavoriteID) (*entity.Favorite, error)); ok {
110		return returnFunc(ctx, id)
111	}
112	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FavoriteID) *entity.Favorite); ok {
113		r0 = returnFunc(ctx, id)
114	} else {
115		if ret.Get(0) != nil {
116			r0 = ret.Get(0).(*entity.Favorite)
117		}
118	}
119	if returnFunc, ok := ret.Get(1).(func(context.Context, entity.FavoriteID) error); ok {
120		r1 = returnFunc(ctx, id)
121	} else {
122		r1 = ret.Error(1)
123	}
124	return r0, r1
125}
126
127// MockFavoriteRepository_FindByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByID'
128type MockFavoriteRepository_FindByID_Call struct {
129	*mock.Call
130}
131
132// FindByID is a helper method to define mock.On call
133//   - ctx context.Context
134//   - id entity.FavoriteID
135func (_e *MockFavoriteRepository_Expecter) FindByID(ctx interface{}, id interface{}) *MockFavoriteRepository_FindByID_Call {
136	return &MockFavoriteRepository_FindByID_Call{Call: _e.mock.On("FindByID", ctx, id)}
137}
138
139func (_c *MockFavoriteRepository_FindByID_Call) Run(run func(ctx context.Context, id entity.FavoriteID)) *MockFavoriteRepository_FindByID_Call {
140	_c.Call.Run(func(args mock.Arguments) {
141		var arg0 context.Context
142		if args[0] != nil {
143			arg0 = args[0].(context.Context)
144		}
145		var arg1 entity.FavoriteID
146		if args[1] != nil {
147			arg1 = args[1].(entity.FavoriteID)
148		}
149		run(
150			arg0,
151			arg1,
152		)
153	})
154	return _c
155}
156
157func (_c *MockFavoriteRepository_FindByID_Call) Return(favorite *entity.Favorite, err error) *MockFavoriteRepository_FindByID_Call {
158	_c.Call.Return(favorite, err)
159	return _c
160}
161
162func (_c *MockFavoriteRepository_FindByID_Call) RunAndReturn(run func(ctx context.Context, id entity.FavoriteID) (*entity.Favorite, error)) *MockFavoriteRepository_FindByID_Call {
163	_c.Call.Return(run)
164	return _c
165}
166
167// FindByURL provides a mock function for the type MockFavoriteRepository
168func (_mock *MockFavoriteRepository) FindByURL(ctx context.Context, url string) (*entity.Favorite, error) {
169	ret := _mock.Called(ctx, url)
170
171	if len(ret) == 0 {
172		panic("no return value specified for FindByURL")
173	}
174
175	var r0 *entity.Favorite
176	var r1 error
177	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*entity.Favorite, error)); ok {
178		return returnFunc(ctx, url)
179	}
180	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *entity.Favorite); ok {
181		r0 = returnFunc(ctx, url)
182	} else {
183		if ret.Get(0) != nil {
184			r0 = ret.Get(0).(*entity.Favorite)
185		}
186	}
187	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
188		r1 = returnFunc(ctx, url)
189	} else {
190		r1 = ret.Error(1)
191	}
192	return r0, r1
193}
194
195// MockFavoriteRepository_FindByURL_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByURL'
196type MockFavoriteRepository_FindByURL_Call struct {
197	*mock.Call
198}
199
200// FindByURL is a helper method to define mock.On call
201//   - ctx context.Context
202//   - url string
203func (_e *MockFavoriteRepository_Expecter) FindByURL(ctx interface{}, url interface{}) *MockFavoriteRepository_FindByURL_Call {
204	return &MockFavoriteRepository_FindByURL_Call{Call: _e.mock.On("FindByURL", ctx, url)}
205}
206
207func (_c *MockFavoriteRepository_FindByURL_Call) Run(run func(ctx context.Context, url string)) *MockFavoriteRepository_FindByURL_Call {
208	_c.Call.Run(func(args mock.Arguments) {
209		var arg0 context.Context
210		if args[0] != nil {
211			arg0 = args[0].(context.Context)
212		}
213		var arg1 string
214		if args[1] != nil {
215			arg1 = args[1].(string)
216		}
217		run(
218			arg0,
219			arg1,
220		)
221	})
222	return _c
223}
224
225func (_c *MockFavoriteRepository_FindByURL_Call) Return(favorite *entity.Favorite, err error) *MockFavoriteRepository_FindByURL_Call {
226	_c.Call.Return(favorite, err)
227	return _c
228}
229
230func (_c *MockFavoriteRepository_FindByURL_Call) RunAndReturn(run func(ctx context.Context, url string) (*entity.Favorite, error)) *MockFavoriteRepository_FindByURL_Call {
231	_c.Call.Return(run)
232	return _c
233}
234
235// GetAll provides a mock function for the type MockFavoriteRepository
236func (_mock *MockFavoriteRepository) GetAll(ctx context.Context) ([]*entity.Favorite, error) {
237	ret := _mock.Called(ctx)
238
239	if len(ret) == 0 {
240		panic("no return value specified for GetAll")
241	}
242
243	var r0 []*entity.Favorite
244	var r1 error
245	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*entity.Favorite, error)); ok {
246		return returnFunc(ctx)
247	}
248	if returnFunc, ok := ret.Get(0).(func(context.Context) []*entity.Favorite); ok {
249		r0 = returnFunc(ctx)
250	} else {
251		if ret.Get(0) != nil {
252			r0 = ret.Get(0).([]*entity.Favorite)
253		}
254	}
255	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
256		r1 = returnFunc(ctx)
257	} else {
258		r1 = ret.Error(1)
259	}
260	return r0, r1
261}
262
263// MockFavoriteRepository_GetAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAll'
264type MockFavoriteRepository_GetAll_Call struct {
265	*mock.Call
266}
267
268// GetAll is a helper method to define mock.On call
269//   - ctx context.Context
270func (_e *MockFavoriteRepository_Expecter) GetAll(ctx interface{}) *MockFavoriteRepository_GetAll_Call {
271	return &MockFavoriteRepository_GetAll_Call{Call: _e.mock.On("GetAll", ctx)}
272}
273
274func (_c *MockFavoriteRepository_GetAll_Call) Run(run func(ctx context.Context)) *MockFavoriteRepository_GetAll_Call {
275	_c.Call.Run(func(args mock.Arguments) {
276		var arg0 context.Context
277		if args[0] != nil {
278			arg0 = args[0].(context.Context)
279		}
280		run(
281			arg0,
282		)
283	})
284	return _c
285}
286
287func (_c *MockFavoriteRepository_GetAll_Call) Return(favorites []*entity.Favorite, err error) *MockFavoriteRepository_GetAll_Call {
288	_c.Call.Return(favorites, err)
289	return _c
290}
291
292func (_c *MockFavoriteRepository_GetAll_Call) RunAndReturn(run func(ctx context.Context) ([]*entity.Favorite, error)) *MockFavoriteRepository_GetAll_Call {
293	_c.Call.Return(run)
294	return _c
295}
296
297// GetByFolder provides a mock function for the type MockFavoriteRepository
298func (_mock *MockFavoriteRepository) GetByFolder(ctx context.Context, folderID *entity.FolderID) ([]*entity.Favorite, error) {
299	ret := _mock.Called(ctx, folderID)
300
301	if len(ret) == 0 {
302		panic("no return value specified for GetByFolder")
303	}
304
305	var r0 []*entity.Favorite
306	var r1 error
307	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.FolderID) ([]*entity.Favorite, error)); ok {
308		return returnFunc(ctx, folderID)
309	}
310	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.FolderID) []*entity.Favorite); ok {
311		r0 = returnFunc(ctx, folderID)
312	} else {
313		if ret.Get(0) != nil {
314			r0 = ret.Get(0).([]*entity.Favorite)
315		}
316	}
317	if returnFunc, ok := ret.Get(1).(func(context.Context, *entity.FolderID) error); ok {
318		r1 = returnFunc(ctx, folderID)
319	} else {
320		r1 = ret.Error(1)
321	}
322	return r0, r1
323}
324
325// MockFavoriteRepository_GetByFolder_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetByFolder'
326type MockFavoriteRepository_GetByFolder_Call struct {
327	*mock.Call
328}
329
330// GetByFolder is a helper method to define mock.On call
331//   - ctx context.Context
332//   - folderID *entity.FolderID
333func (_e *MockFavoriteRepository_Expecter) GetByFolder(ctx interface{}, folderID interface{}) *MockFavoriteRepository_GetByFolder_Call {
334	return &MockFavoriteRepository_GetByFolder_Call{Call: _e.mock.On("GetByFolder", ctx, folderID)}
335}
336
337func (_c *MockFavoriteRepository_GetByFolder_Call) Run(run func(ctx context.Context, folderID *entity.FolderID)) *MockFavoriteRepository_GetByFolder_Call {
338	_c.Call.Run(func(args mock.Arguments) {
339		var arg0 context.Context
340		if args[0] != nil {
341			arg0 = args[0].(context.Context)
342		}
343		var arg1 *entity.FolderID
344		if args[1] != nil {
345			arg1 = args[1].(*entity.FolderID)
346		}
347		run(
348			arg0,
349			arg1,
350		)
351	})
352	return _c
353}
354
355func (_c *MockFavoriteRepository_GetByFolder_Call) Return(favorites []*entity.Favorite, err error) *MockFavoriteRepository_GetByFolder_Call {
356	_c.Call.Return(favorites, err)
357	return _c
358}
359
360func (_c *MockFavoriteRepository_GetByFolder_Call) RunAndReturn(run func(ctx context.Context, folderID *entity.FolderID) ([]*entity.Favorite, error)) *MockFavoriteRepository_GetByFolder_Call {
361	_c.Call.Return(run)
362	return _c
363}
364
365// GetByShortcut provides a mock function for the type MockFavoriteRepository
366func (_mock *MockFavoriteRepository) GetByShortcut(ctx context.Context, key int) (*entity.Favorite, error) {
367	ret := _mock.Called(ctx, key)
368
369	if len(ret) == 0 {
370		panic("no return value specified for GetByShortcut")
371	}
372
373	var r0 *entity.Favorite
374	var r1 error
375	if returnFunc, ok := ret.Get(0).(func(context.Context, int) (*entity.Favorite, error)); ok {
376		return returnFunc(ctx, key)
377	}
378	if returnFunc, ok := ret.Get(0).(func(context.Context, int) *entity.Favorite); ok {
379		r0 = returnFunc(ctx, key)
380	} else {
381		if ret.Get(0) != nil {
382			r0 = ret.Get(0).(*entity.Favorite)
383		}
384	}
385	if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
386		r1 = returnFunc(ctx, key)
387	} else {
388		r1 = ret.Error(1)
389	}
390	return r0, r1
391}
392
393// MockFavoriteRepository_GetByShortcut_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetByShortcut'
394type MockFavoriteRepository_GetByShortcut_Call struct {
395	*mock.Call
396}
397
398// GetByShortcut is a helper method to define mock.On call
399//   - ctx context.Context
400//   - key int
401func (_e *MockFavoriteRepository_Expecter) GetByShortcut(ctx interface{}, key interface{}) *MockFavoriteRepository_GetByShortcut_Call {
402	return &MockFavoriteRepository_GetByShortcut_Call{Call: _e.mock.On("GetByShortcut", ctx, key)}
403}
404
405func (_c *MockFavoriteRepository_GetByShortcut_Call) Run(run func(ctx context.Context, key int)) *MockFavoriteRepository_GetByShortcut_Call {
406	_c.Call.Run(func(args mock.Arguments) {
407		var arg0 context.Context
408		if args[0] != nil {
409			arg0 = args[0].(context.Context)
410		}
411		var arg1 int
412		if args[1] != nil {
413			arg1 = args[1].(int)
414		}
415		run(
416			arg0,
417			arg1,
418		)
419	})
420	return _c
421}
422
423func (_c *MockFavoriteRepository_GetByShortcut_Call) Return(favorite *entity.Favorite, err error) *MockFavoriteRepository_GetByShortcut_Call {
424	_c.Call.Return(favorite, err)
425	return _c
426}
427
428func (_c *MockFavoriteRepository_GetByShortcut_Call) RunAndReturn(run func(ctx context.Context, key int) (*entity.Favorite, error)) *MockFavoriteRepository_GetByShortcut_Call {
429	_c.Call.Return(run)
430	return _c
431}
432
433// Save provides a mock function for the type MockFavoriteRepository
434func (_mock *MockFavoriteRepository) Save(ctx context.Context, fav *entity.Favorite) error {
435	ret := _mock.Called(ctx, fav)
436
437	if len(ret) == 0 {
438		panic("no return value specified for Save")
439	}
440
441	var r0 error
442	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.Favorite) error); ok {
443		r0 = returnFunc(ctx, fav)
444	} else {
445		r0 = ret.Error(0)
446	}
447	return r0
448}
449
450// MockFavoriteRepository_Save_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Save'
451type MockFavoriteRepository_Save_Call struct {
452	*mock.Call
453}
454
455// Save is a helper method to define mock.On call
456//   - ctx context.Context
457//   - fav *entity.Favorite
458func (_e *MockFavoriteRepository_Expecter) Save(ctx interface{}, fav interface{}) *MockFavoriteRepository_Save_Call {
459	return &MockFavoriteRepository_Save_Call{Call: _e.mock.On("Save", ctx, fav)}
460}
461
462func (_c *MockFavoriteRepository_Save_Call) Run(run func(ctx context.Context, fav *entity.Favorite)) *MockFavoriteRepository_Save_Call {
463	_c.Call.Run(func(args mock.Arguments) {
464		var arg0 context.Context
465		if args[0] != nil {
466			arg0 = args[0].(context.Context)
467		}
468		var arg1 *entity.Favorite
469		if args[1] != nil {
470			arg1 = args[1].(*entity.Favorite)
471		}
472		run(
473			arg0,
474			arg1,
475		)
476	})
477	return _c
478}
479
480func (_c *MockFavoriteRepository_Save_Call) Return(err error) *MockFavoriteRepository_Save_Call {
481	_c.Call.Return(err)
482	return _c
483}
484
485func (_c *MockFavoriteRepository_Save_Call) RunAndReturn(run func(ctx context.Context, fav *entity.Favorite) error) *MockFavoriteRepository_Save_Call {
486	_c.Call.Return(run)
487	return _c
488}
489
490// SetFolder provides a mock function for the type MockFavoriteRepository
491func (_mock *MockFavoriteRepository) SetFolder(ctx context.Context, id entity.FavoriteID, folderID *entity.FolderID) error {
492	ret := _mock.Called(ctx, id, folderID)
493
494	if len(ret) == 0 {
495		panic("no return value specified for SetFolder")
496	}
497
498	var r0 error
499	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FavoriteID, *entity.FolderID) error); ok {
500		r0 = returnFunc(ctx, id, folderID)
501	} else {
502		r0 = ret.Error(0)
503	}
504	return r0
505}
506
507// MockFavoriteRepository_SetFolder_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFolder'
508type MockFavoriteRepository_SetFolder_Call struct {
509	*mock.Call
510}
511
512// SetFolder is a helper method to define mock.On call
513//   - ctx context.Context
514//   - id entity.FavoriteID
515//   - folderID *entity.FolderID
516func (_e *MockFavoriteRepository_Expecter) SetFolder(ctx interface{}, id interface{}, folderID interface{}) *MockFavoriteRepository_SetFolder_Call {
517	return &MockFavoriteRepository_SetFolder_Call{Call: _e.mock.On("SetFolder", ctx, id, folderID)}
518}
519
520func (_c *MockFavoriteRepository_SetFolder_Call) Run(run func(ctx context.Context, id entity.FavoriteID, folderID *entity.FolderID)) *MockFavoriteRepository_SetFolder_Call {
521	_c.Call.Run(func(args mock.Arguments) {
522		var arg0 context.Context
523		if args[0] != nil {
524			arg0 = args[0].(context.Context)
525		}
526		var arg1 entity.FavoriteID
527		if args[1] != nil {
528			arg1 = args[1].(entity.FavoriteID)
529		}
530		var arg2 *entity.FolderID
531		if args[2] != nil {
532			arg2 = args[2].(*entity.FolderID)
533		}
534		run(
535			arg0,
536			arg1,
537			arg2,
538		)
539	})
540	return _c
541}
542
543func (_c *MockFavoriteRepository_SetFolder_Call) Return(err error) *MockFavoriteRepository_SetFolder_Call {
544	_c.Call.Return(err)
545	return _c
546}
547
548func (_c *MockFavoriteRepository_SetFolder_Call) RunAndReturn(run func(ctx context.Context, id entity.FavoriteID, folderID *entity.FolderID) error) *MockFavoriteRepository_SetFolder_Call {
549	_c.Call.Return(run)
550	return _c
551}
552
553// SetShortcut provides a mock function for the type MockFavoriteRepository
554func (_mock *MockFavoriteRepository) SetShortcut(ctx context.Context, id entity.FavoriteID, key *int) error {
555	ret := _mock.Called(ctx, id, key)
556
557	if len(ret) == 0 {
558		panic("no return value specified for SetShortcut")
559	}
560
561	var r0 error
562	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FavoriteID, *int) error); ok {
563		r0 = returnFunc(ctx, id, key)
564	} else {
565		r0 = ret.Error(0)
566	}
567	return r0
568}
569
570// MockFavoriteRepository_SetShortcut_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetShortcut'
571type MockFavoriteRepository_SetShortcut_Call struct {
572	*mock.Call
573}
574
575// SetShortcut is a helper method to define mock.On call
576//   - ctx context.Context
577//   - id entity.FavoriteID
578//   - key *int
579func (_e *MockFavoriteRepository_Expecter) SetShortcut(ctx interface{}, id interface{}, key interface{}) *MockFavoriteRepository_SetShortcut_Call {
580	return &MockFavoriteRepository_SetShortcut_Call{Call: _e.mock.On("SetShortcut", ctx, id, key)}
581}
582
583func (_c *MockFavoriteRepository_SetShortcut_Call) Run(run func(ctx context.Context, id entity.FavoriteID, key *int)) *MockFavoriteRepository_SetShortcut_Call {
584	_c.Call.Run(func(args mock.Arguments) {
585		var arg0 context.Context
586		if args[0] != nil {
587			arg0 = args[0].(context.Context)
588		}
589		var arg1 entity.FavoriteID
590		if args[1] != nil {
591			arg1 = args[1].(entity.FavoriteID)
592		}
593		var arg2 *int
594		if args[2] != nil {
595			arg2 = args[2].(*int)
596		}
597		run(
598			arg0,
599			arg1,
600			arg2,
601		)
602	})
603	return _c
604}
605
606func (_c *MockFavoriteRepository_SetShortcut_Call) Return(err error) *MockFavoriteRepository_SetShortcut_Call {
607	_c.Call.Return(err)
608	return _c
609}
610
611func (_c *MockFavoriteRepository_SetShortcut_Call) RunAndReturn(run func(ctx context.Context, id entity.FavoriteID, key *int) error) *MockFavoriteRepository_SetShortcut_Call {
612	_c.Call.Return(run)
613	return _c
614}
615
616// UpdatePosition provides a mock function for the type MockFavoriteRepository
617func (_mock *MockFavoriteRepository) UpdatePosition(ctx context.Context, id entity.FavoriteID, position int) error {
618	ret := _mock.Called(ctx, id, position)
619
620	if len(ret) == 0 {
621		panic("no return value specified for UpdatePosition")
622	}
623
624	var r0 error
625	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FavoriteID, int) error); ok {
626		r0 = returnFunc(ctx, id, position)
627	} else {
628		r0 = ret.Error(0)
629	}
630	return r0
631}
632
633// MockFavoriteRepository_UpdatePosition_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePosition'
634type MockFavoriteRepository_UpdatePosition_Call struct {
635	*mock.Call
636}
637
638// UpdatePosition is a helper method to define mock.On call
639//   - ctx context.Context
640//   - id entity.FavoriteID
641//   - position int
642func (_e *MockFavoriteRepository_Expecter) UpdatePosition(ctx interface{}, id interface{}, position interface{}) *MockFavoriteRepository_UpdatePosition_Call {
643	return &MockFavoriteRepository_UpdatePosition_Call{Call: _e.mock.On("UpdatePosition", ctx, id, position)}
644}
645
646func (_c *MockFavoriteRepository_UpdatePosition_Call) Run(run func(ctx context.Context, id entity.FavoriteID, position int)) *MockFavoriteRepository_UpdatePosition_Call {
647	_c.Call.Run(func(args mock.Arguments) {
648		var arg0 context.Context
649		if args[0] != nil {
650			arg0 = args[0].(context.Context)
651		}
652		var arg1 entity.FavoriteID
653		if args[1] != nil {
654			arg1 = args[1].(entity.FavoriteID)
655		}
656		var arg2 int
657		if args[2] != nil {
658			arg2 = args[2].(int)
659		}
660		run(
661			arg0,
662			arg1,
663			arg2,
664		)
665	})
666	return _c
667}
668
669func (_c *MockFavoriteRepository_UpdatePosition_Call) Return(err error) *MockFavoriteRepository_UpdatePosition_Call {
670	_c.Call.Return(err)
671	return _c
672}
673
674func (_c *MockFavoriteRepository_UpdatePosition_Call) RunAndReturn(run func(ctx context.Context, id entity.FavoriteID, position int) error) *MockFavoriteRepository_UpdatePosition_Call {
675	_c.Call.Return(run)
676	return _c
677}
678
679// NewMockFolderRepository creates a new instance of MockFolderRepository. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
680// The first argument is typically a *testing.T value.
681func NewMockFolderRepository(t interface {
682	mock.TestingT
683	Cleanup(func())
684}) *MockFolderRepository {
685	mock := &MockFolderRepository{}
686	mock.Mock.Test(t)
687
688	t.Cleanup(func() { mock.AssertExpectations(t) })
689
690	return mock
691}
692
693// MockFolderRepository is an autogenerated mock type for the FolderRepository type
694type MockFolderRepository struct {
695	mock.Mock
696}
697
698type MockFolderRepository_Expecter struct {
699	mock *mock.Mock
700}
701
702func (_m *MockFolderRepository) EXPECT() *MockFolderRepository_Expecter {
703	return &MockFolderRepository_Expecter{mock: &_m.Mock}
704}
705
706// Delete provides a mock function for the type MockFolderRepository
707func (_mock *MockFolderRepository) Delete(ctx context.Context, id entity.FolderID) error {
708	ret := _mock.Called(ctx, id)
709
710	if len(ret) == 0 {
711		panic("no return value specified for Delete")
712	}
713
714	var r0 error
715	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FolderID) error); ok {
716		r0 = returnFunc(ctx, id)
717	} else {
718		r0 = ret.Error(0)
719	}
720	return r0
721}
722
723// MockFolderRepository_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
724type MockFolderRepository_Delete_Call struct {
725	*mock.Call
726}
727
728// Delete is a helper method to define mock.On call
729//   - ctx context.Context
730//   - id entity.FolderID
731func (_e *MockFolderRepository_Expecter) Delete(ctx interface{}, id interface{}) *MockFolderRepository_Delete_Call {
732	return &MockFolderRepository_Delete_Call{Call: _e.mock.On("Delete", ctx, id)}
733}
734
735func (_c *MockFolderRepository_Delete_Call) Run(run func(ctx context.Context, id entity.FolderID)) *MockFolderRepository_Delete_Call {
736	_c.Call.Run(func(args mock.Arguments) {
737		var arg0 context.Context
738		if args[0] != nil {
739			arg0 = args[0].(context.Context)
740		}
741		var arg1 entity.FolderID
742		if args[1] != nil {
743			arg1 = args[1].(entity.FolderID)
744		}
745		run(
746			arg0,
747			arg1,
748		)
749	})
750	return _c
751}
752
753func (_c *MockFolderRepository_Delete_Call) Return(err error) *MockFolderRepository_Delete_Call {
754	_c.Call.Return(err)
755	return _c
756}
757
758func (_c *MockFolderRepository_Delete_Call) RunAndReturn(run func(ctx context.Context, id entity.FolderID) error) *MockFolderRepository_Delete_Call {
759	_c.Call.Return(run)
760	return _c
761}
762
763// FindByID provides a mock function for the type MockFolderRepository
764func (_mock *MockFolderRepository) FindByID(ctx context.Context, id entity.FolderID) (*entity.Folder, error) {
765	ret := _mock.Called(ctx, id)
766
767	if len(ret) == 0 {
768		panic("no return value specified for FindByID")
769	}
770
771	var r0 *entity.Folder
772	var r1 error
773	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FolderID) (*entity.Folder, error)); ok {
774		return returnFunc(ctx, id)
775	}
776	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FolderID) *entity.Folder); ok {
777		r0 = returnFunc(ctx, id)
778	} else {
779		if ret.Get(0) != nil {
780			r0 = ret.Get(0).(*entity.Folder)
781		}
782	}
783	if returnFunc, ok := ret.Get(1).(func(context.Context, entity.FolderID) error); ok {
784		r1 = returnFunc(ctx, id)
785	} else {
786		r1 = ret.Error(1)
787	}
788	return r0, r1
789}
790
791// MockFolderRepository_FindByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByID'
792type MockFolderRepository_FindByID_Call struct {
793	*mock.Call
794}
795
796// FindByID is a helper method to define mock.On call
797//   - ctx context.Context
798//   - id entity.FolderID
799func (_e *MockFolderRepository_Expecter) FindByID(ctx interface{}, id interface{}) *MockFolderRepository_FindByID_Call {
800	return &MockFolderRepository_FindByID_Call{Call: _e.mock.On("FindByID", ctx, id)}
801}
802
803func (_c *MockFolderRepository_FindByID_Call) Run(run func(ctx context.Context, id entity.FolderID)) *MockFolderRepository_FindByID_Call {
804	_c.Call.Run(func(args mock.Arguments) {
805		var arg0 context.Context
806		if args[0] != nil {
807			arg0 = args[0].(context.Context)
808		}
809		var arg1 entity.FolderID
810		if args[1] != nil {
811			arg1 = args[1].(entity.FolderID)
812		}
813		run(
814			arg0,
815			arg1,
816		)
817	})
818	return _c
819}
820
821func (_c *MockFolderRepository_FindByID_Call) Return(folder *entity.Folder, err error) *MockFolderRepository_FindByID_Call {
822	_c.Call.Return(folder, err)
823	return _c
824}
825
826func (_c *MockFolderRepository_FindByID_Call) RunAndReturn(run func(ctx context.Context, id entity.FolderID) (*entity.Folder, error)) *MockFolderRepository_FindByID_Call {
827	_c.Call.Return(run)
828	return _c
829}
830
831// GetAll provides a mock function for the type MockFolderRepository
832func (_mock *MockFolderRepository) GetAll(ctx context.Context) ([]*entity.Folder, error) {
833	ret := _mock.Called(ctx)
834
835	if len(ret) == 0 {
836		panic("no return value specified for GetAll")
837	}
838
839	var r0 []*entity.Folder
840	var r1 error
841	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*entity.Folder, error)); ok {
842		return returnFunc(ctx)
843	}
844	if returnFunc, ok := ret.Get(0).(func(context.Context) []*entity.Folder); ok {
845		r0 = returnFunc(ctx)
846	} else {
847		if ret.Get(0) != nil {
848			r0 = ret.Get(0).([]*entity.Folder)
849		}
850	}
851	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
852		r1 = returnFunc(ctx)
853	} else {
854		r1 = ret.Error(1)
855	}
856	return r0, r1
857}
858
859// MockFolderRepository_GetAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAll'
860type MockFolderRepository_GetAll_Call struct {
861	*mock.Call
862}
863
864// GetAll is a helper method to define mock.On call
865//   - ctx context.Context
866func (_e *MockFolderRepository_Expecter) GetAll(ctx interface{}) *MockFolderRepository_GetAll_Call {
867	return &MockFolderRepository_GetAll_Call{Call: _e.mock.On("GetAll", ctx)}
868}
869
870func (_c *MockFolderRepository_GetAll_Call) Run(run func(ctx context.Context)) *MockFolderRepository_GetAll_Call {
871	_c.Call.Run(func(args mock.Arguments) {
872		var arg0 context.Context
873		if args[0] != nil {
874			arg0 = args[0].(context.Context)
875		}
876		run(
877			arg0,
878		)
879	})
880	return _c
881}
882
883func (_c *MockFolderRepository_GetAll_Call) Return(folders []*entity.Folder, err error) *MockFolderRepository_GetAll_Call {
884	_c.Call.Return(folders, err)
885	return _c
886}
887
888func (_c *MockFolderRepository_GetAll_Call) RunAndReturn(run func(ctx context.Context) ([]*entity.Folder, error)) *MockFolderRepository_GetAll_Call {
889	_c.Call.Return(run)
890	return _c
891}
892
893// GetChildren provides a mock function for the type MockFolderRepository
894func (_mock *MockFolderRepository) GetChildren(ctx context.Context, parentID *entity.FolderID) ([]*entity.Folder, error) {
895	ret := _mock.Called(ctx, parentID)
896
897	if len(ret) == 0 {
898		panic("no return value specified for GetChildren")
899	}
900
901	var r0 []*entity.Folder
902	var r1 error
903	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.FolderID) ([]*entity.Folder, error)); ok {
904		return returnFunc(ctx, parentID)
905	}
906	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.FolderID) []*entity.Folder); ok {
907		r0 = returnFunc(ctx, parentID)
908	} else {
909		if ret.Get(0) != nil {
910			r0 = ret.Get(0).([]*entity.Folder)
911		}
912	}
913	if returnFunc, ok := ret.Get(1).(func(context.Context, *entity.FolderID) error); ok {
914		r1 = returnFunc(ctx, parentID)
915	} else {
916		r1 = ret.Error(1)
917	}
918	return r0, r1
919}
920
921// MockFolderRepository_GetChildren_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetChildren'
922type MockFolderRepository_GetChildren_Call struct {
923	*mock.Call
924}
925
926// GetChildren is a helper method to define mock.On call
927//   - ctx context.Context
928//   - parentID *entity.FolderID
929func (_e *MockFolderRepository_Expecter) GetChildren(ctx interface{}, parentID interface{}) *MockFolderRepository_GetChildren_Call {
930	return &MockFolderRepository_GetChildren_Call{Call: _e.mock.On("GetChildren", ctx, parentID)}
931}
932
933func (_c *MockFolderRepository_GetChildren_Call) Run(run func(ctx context.Context, parentID *entity.FolderID)) *MockFolderRepository_GetChildren_Call {
934	_c.Call.Run(func(args mock.Arguments) {
935		var arg0 context.Context
936		if args[0] != nil {
937			arg0 = args[0].(context.Context)
938		}
939		var arg1 *entity.FolderID
940		if args[1] != nil {
941			arg1 = args[1].(*entity.FolderID)
942		}
943		run(
944			arg0,
945			arg1,
946		)
947	})
948	return _c
949}
950
951func (_c *MockFolderRepository_GetChildren_Call) Return(folders []*entity.Folder, err error) *MockFolderRepository_GetChildren_Call {
952	_c.Call.Return(folders, err)
953	return _c
954}
955
956func (_c *MockFolderRepository_GetChildren_Call) RunAndReturn(run func(ctx context.Context, parentID *entity.FolderID) ([]*entity.Folder, error)) *MockFolderRepository_GetChildren_Call {
957	_c.Call.Return(run)
958	return _c
959}
960
961// Save provides a mock function for the type MockFolderRepository
962func (_mock *MockFolderRepository) Save(ctx context.Context, folder *entity.Folder) error {
963	ret := _mock.Called(ctx, folder)
964
965	if len(ret) == 0 {
966		panic("no return value specified for Save")
967	}
968
969	var r0 error
970	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.Folder) error); ok {
971		r0 = returnFunc(ctx, folder)
972	} else {
973		r0 = ret.Error(0)
974	}
975	return r0
976}
977
978// MockFolderRepository_Save_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Save'
979type MockFolderRepository_Save_Call struct {
980	*mock.Call
981}
982
983// Save is a helper method to define mock.On call
984//   - ctx context.Context
985//   - folder *entity.Folder
986func (_e *MockFolderRepository_Expecter) Save(ctx interface{}, folder interface{}) *MockFolderRepository_Save_Call {
987	return &MockFolderRepository_Save_Call{Call: _e.mock.On("Save", ctx, folder)}
988}
989
990func (_c *MockFolderRepository_Save_Call) Run(run func(ctx context.Context, folder *entity.Folder)) *MockFolderRepository_Save_Call {
991	_c.Call.Run(func(args mock.Arguments) {
992		var arg0 context.Context
993		if args[0] != nil {
994			arg0 = args[0].(context.Context)
995		}
996		var arg1 *entity.Folder
997		if args[1] != nil {
998			arg1 = args[1].(*entity.Folder)
999		}
1000		run(
1001			arg0,
1002			arg1,
1003		)
1004	})
1005	return _c
1006}
1007
1008func (_c *MockFolderRepository_Save_Call) Return(err error) *MockFolderRepository_Save_Call {
1009	_c.Call.Return(err)
1010	return _c
1011}
1012
1013func (_c *MockFolderRepository_Save_Call) RunAndReturn(run func(ctx context.Context, folder *entity.Folder) error) *MockFolderRepository_Save_Call {
1014	_c.Call.Return(run)
1015	return _c
1016}
1017
1018// UpdatePosition provides a mock function for the type MockFolderRepository
1019func (_mock *MockFolderRepository) UpdatePosition(ctx context.Context, id entity.FolderID, position int) error {
1020	ret := _mock.Called(ctx, id, position)
1021
1022	if len(ret) == 0 {
1023		panic("no return value specified for UpdatePosition")
1024	}
1025
1026	var r0 error
1027	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FolderID, int) error); ok {
1028		r0 = returnFunc(ctx, id, position)
1029	} else {
1030		r0 = ret.Error(0)
1031	}
1032	return r0
1033}
1034
1035// MockFolderRepository_UpdatePosition_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePosition'
1036type MockFolderRepository_UpdatePosition_Call struct {
1037	*mock.Call
1038}
1039
1040// UpdatePosition is a helper method to define mock.On call
1041//   - ctx context.Context
1042//   - id entity.FolderID
1043//   - position int
1044func (_e *MockFolderRepository_Expecter) UpdatePosition(ctx interface{}, id interface{}, position interface{}) *MockFolderRepository_UpdatePosition_Call {
1045	return &MockFolderRepository_UpdatePosition_Call{Call: _e.mock.On("UpdatePosition", ctx, id, position)}
1046}
1047
1048func (_c *MockFolderRepository_UpdatePosition_Call) Run(run func(ctx context.Context, id entity.FolderID, position int)) *MockFolderRepository_UpdatePosition_Call {
1049	_c.Call.Run(func(args mock.Arguments) {
1050		var arg0 context.Context
1051		if args[0] != nil {
1052			arg0 = args[0].(context.Context)
1053		}
1054		var arg1 entity.FolderID
1055		if args[1] != nil {
1056			arg1 = args[1].(entity.FolderID)
1057		}
1058		var arg2 int
1059		if args[2] != nil {
1060			arg2 = args[2].(int)
1061		}
1062		run(
1063			arg0,
1064			arg1,
1065			arg2,
1066		)
1067	})
1068	return _c
1069}
1070
1071func (_c *MockFolderRepository_UpdatePosition_Call) Return(err error) *MockFolderRepository_UpdatePosition_Call {
1072	_c.Call.Return(err)
1073	return _c
1074}
1075
1076func (_c *MockFolderRepository_UpdatePosition_Call) RunAndReturn(run func(ctx context.Context, id entity.FolderID, position int) error) *MockFolderRepository_UpdatePosition_Call {
1077	_c.Call.Return(run)
1078	return _c
1079}
1080
1081// NewMockTagRepository creates a new instance of MockTagRepository. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
1082// The first argument is typically a *testing.T value.
1083func NewMockTagRepository(t interface {
1084	mock.TestingT
1085	Cleanup(func())
1086}) *MockTagRepository {
1087	mock := &MockTagRepository{}
1088	mock.Mock.Test(t)
1089
1090	t.Cleanup(func() { mock.AssertExpectations(t) })
1091
1092	return mock
1093}
1094
1095// MockTagRepository is an autogenerated mock type for the TagRepository type
1096type MockTagRepository struct {
1097	mock.Mock
1098}
1099
1100type MockTagRepository_Expecter struct {
1101	mock *mock.Mock
1102}
1103
1104func (_m *MockTagRepository) EXPECT() *MockTagRepository_Expecter {
1105	return &MockTagRepository_Expecter{mock: &_m.Mock}
1106}
1107
1108// AssignToFavorite provides a mock function for the type MockTagRepository
1109func (_mock *MockTagRepository) AssignToFavorite(ctx context.Context, tagID entity.TagID, favID entity.FavoriteID) error {
1110	ret := _mock.Called(ctx, tagID, favID)
1111
1112	if len(ret) == 0 {
1113		panic("no return value specified for AssignToFavorite")
1114	}
1115
1116	var r0 error
1117	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.TagID, entity.FavoriteID) error); ok {
1118		r0 = returnFunc(ctx, tagID, favID)
1119	} else {
1120		r0 = ret.Error(0)
1121	}
1122	return r0
1123}
1124
1125// MockTagRepository_AssignToFavorite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssignToFavorite'
1126type MockTagRepository_AssignToFavorite_Call struct {
1127	*mock.Call
1128}
1129
1130// AssignToFavorite is a helper method to define mock.On call
1131//   - ctx context.Context
1132//   - tagID entity.TagID
1133//   - favID entity.FavoriteID
1134func (_e *MockTagRepository_Expecter) AssignToFavorite(ctx interface{}, tagID interface{}, favID interface{}) *MockTagRepository_AssignToFavorite_Call {
1135	return &MockTagRepository_AssignToFavorite_Call{Call: _e.mock.On("AssignToFavorite", ctx, tagID, favID)}
1136}
1137
1138func (_c *MockTagRepository_AssignToFavorite_Call) Run(run func(ctx context.Context, tagID entity.TagID, favID entity.FavoriteID)) *MockTagRepository_AssignToFavorite_Call {
1139	_c.Call.Run(func(args mock.Arguments) {
1140		var arg0 context.Context
1141		if args[0] != nil {
1142			arg0 = args[0].(context.Context)
1143		}
1144		var arg1 entity.TagID
1145		if args[1] != nil {
1146			arg1 = args[1].(entity.TagID)
1147		}
1148		var arg2 entity.FavoriteID
1149		if args[2] != nil {
1150			arg2 = args[2].(entity.FavoriteID)
1151		}
1152		run(
1153			arg0,
1154			arg1,
1155			arg2,
1156		)
1157	})
1158	return _c
1159}
1160
1161func (_c *MockTagRepository_AssignToFavorite_Call) Return(err error) *MockTagRepository_AssignToFavorite_Call {
1162	_c.Call.Return(err)
1163	return _c
1164}
1165
1166func (_c *MockTagRepository_AssignToFavorite_Call) RunAndReturn(run func(ctx context.Context, tagID entity.TagID, favID entity.FavoriteID) error) *MockTagRepository_AssignToFavorite_Call {
1167	_c.Call.Return(run)
1168	return _c
1169}
1170
1171// Delete provides a mock function for the type MockTagRepository
1172func (_mock *MockTagRepository) Delete(ctx context.Context, id entity.TagID) error {
1173	ret := _mock.Called(ctx, id)
1174
1175	if len(ret) == 0 {
1176		panic("no return value specified for Delete")
1177	}
1178
1179	var r0 error
1180	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.TagID) error); ok {
1181		r0 = returnFunc(ctx, id)
1182	} else {
1183		r0 = ret.Error(0)
1184	}
1185	return r0
1186}
1187
1188// MockTagRepository_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
1189type MockTagRepository_Delete_Call struct {
1190	*mock.Call
1191}
1192
1193// Delete is a helper method to define mock.On call
1194//   - ctx context.Context
1195//   - id entity.TagID
1196func (_e *MockTagRepository_Expecter) Delete(ctx interface{}, id interface{}) *MockTagRepository_Delete_Call {
1197	return &MockTagRepository_Delete_Call{Call: _e.mock.On("Delete", ctx, id)}
1198}
1199
1200func (_c *MockTagRepository_Delete_Call) Run(run func(ctx context.Context, id entity.TagID)) *MockTagRepository_Delete_Call {
1201	_c.Call.Run(func(args mock.Arguments) {
1202		var arg0 context.Context
1203		if args[0] != nil {
1204			arg0 = args[0].(context.Context)
1205		}
1206		var arg1 entity.TagID
1207		if args[1] != nil {
1208			arg1 = args[1].(entity.TagID)
1209		}
1210		run(
1211			arg0,
1212			arg1,
1213		)
1214	})
1215	return _c
1216}
1217
1218func (_c *MockTagRepository_Delete_Call) Return(err error) *MockTagRepository_Delete_Call {
1219	_c.Call.Return(err)
1220	return _c
1221}
1222
1223func (_c *MockTagRepository_Delete_Call) RunAndReturn(run func(ctx context.Context, id entity.TagID) error) *MockTagRepository_Delete_Call {
1224	_c.Call.Return(run)
1225	return _c
1226}
1227
1228// FindByID provides a mock function for the type MockTagRepository
1229func (_mock *MockTagRepository) FindByID(ctx context.Context, id entity.TagID) (*entity.Tag, error) {
1230	ret := _mock.Called(ctx, id)
1231
1232	if len(ret) == 0 {
1233		panic("no return value specified for FindByID")
1234	}
1235
1236	var r0 *entity.Tag
1237	var r1 error
1238	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.TagID) (*entity.Tag, error)); ok {
1239		return returnFunc(ctx, id)
1240	}
1241	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.TagID) *entity.Tag); ok {
1242		r0 = returnFunc(ctx, id)
1243	} else {
1244		if ret.Get(0) != nil {
1245			r0 = ret.Get(0).(*entity.Tag)
1246		}
1247	}
1248	if returnFunc, ok := ret.Get(1).(func(context.Context, entity.TagID) error); ok {
1249		r1 = returnFunc(ctx, id)
1250	} else {
1251		r1 = ret.Error(1)
1252	}
1253	return r0, r1
1254}
1255
1256// MockTagRepository_FindByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByID'
1257type MockTagRepository_FindByID_Call struct {
1258	*mock.Call
1259}
1260
1261// FindByID is a helper method to define mock.On call
1262//   - ctx context.Context
1263//   - id entity.TagID
1264func (_e *MockTagRepository_Expecter) FindByID(ctx interface{}, id interface{}) *MockTagRepository_FindByID_Call {
1265	return &MockTagRepository_FindByID_Call{Call: _e.mock.On("FindByID", ctx, id)}
1266}
1267
1268func (_c *MockTagRepository_FindByID_Call) Run(run func(ctx context.Context, id entity.TagID)) *MockTagRepository_FindByID_Call {
1269	_c.Call.Run(func(args mock.Arguments) {
1270		var arg0 context.Context
1271		if args[0] != nil {
1272			arg0 = args[0].(context.Context)
1273		}
1274		var arg1 entity.TagID
1275		if args[1] != nil {
1276			arg1 = args[1].(entity.TagID)
1277		}
1278		run(
1279			arg0,
1280			arg1,
1281		)
1282	})
1283	return _c
1284}
1285
1286func (_c *MockTagRepository_FindByID_Call) Return(tag *entity.Tag, err error) *MockTagRepository_FindByID_Call {
1287	_c.Call.Return(tag, err)
1288	return _c
1289}
1290
1291func (_c *MockTagRepository_FindByID_Call) RunAndReturn(run func(ctx context.Context, id entity.TagID) (*entity.Tag, error)) *MockTagRepository_FindByID_Call {
1292	_c.Call.Return(run)
1293	return _c
1294}
1295
1296// FindByName provides a mock function for the type MockTagRepository
1297func (_mock *MockTagRepository) FindByName(ctx context.Context, name string) (*entity.Tag, error) {
1298	ret := _mock.Called(ctx, name)
1299
1300	if len(ret) == 0 {
1301		panic("no return value specified for FindByName")
1302	}
1303
1304	var r0 *entity.Tag
1305	var r1 error
1306	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*entity.Tag, error)); ok {
1307		return returnFunc(ctx, name)
1308	}
1309	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *entity.Tag); ok {
1310		r0 = returnFunc(ctx, name)
1311	} else {
1312		if ret.Get(0) != nil {
1313			r0 = ret.Get(0).(*entity.Tag)
1314		}
1315	}
1316	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
1317		r1 = returnFunc(ctx, name)
1318	} else {
1319		r1 = ret.Error(1)
1320	}
1321	return r0, r1
1322}
1323
1324// MockTagRepository_FindByName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByName'
1325type MockTagRepository_FindByName_Call struct {
1326	*mock.Call
1327}
1328
1329// FindByName is a helper method to define mock.On call
1330//   - ctx context.Context
1331//   - name string
1332func (_e *MockTagRepository_Expecter) FindByName(ctx interface{}, name interface{}) *MockTagRepository_FindByName_Call {
1333	return &MockTagRepository_FindByName_Call{Call: _e.mock.On("FindByName", ctx, name)}
1334}
1335
1336func (_c *MockTagRepository_FindByName_Call) Run(run func(ctx context.Context, name string)) *MockTagRepository_FindByName_Call {
1337	_c.Call.Run(func(args mock.Arguments) {
1338		var arg0 context.Context
1339		if args[0] != nil {
1340			arg0 = args[0].(context.Context)
1341		}
1342		var arg1 string
1343		if args[1] != nil {
1344			arg1 = args[1].(string)
1345		}
1346		run(
1347			arg0,
1348			arg1,
1349		)
1350	})
1351	return _c
1352}
1353
1354func (_c *MockTagRepository_FindByName_Call) Return(tag *entity.Tag, err error) *MockTagRepository_FindByName_Call {
1355	_c.Call.Return(tag, err)
1356	return _c
1357}
1358
1359func (_c *MockTagRepository_FindByName_Call) RunAndReturn(run func(ctx context.Context, name string) (*entity.Tag, error)) *MockTagRepository_FindByName_Call {
1360	_c.Call.Return(run)
1361	return _c
1362}
1363
1364// GetAll provides a mock function for the type MockTagRepository
1365func (_mock *MockTagRepository) GetAll(ctx context.Context) ([]*entity.Tag, error) {
1366	ret := _mock.Called(ctx)
1367
1368	if len(ret) == 0 {
1369		panic("no return value specified for GetAll")
1370	}
1371
1372	var r0 []*entity.Tag
1373	var r1 error
1374	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*entity.Tag, error)); ok {
1375		return returnFunc(ctx)
1376	}
1377	if returnFunc, ok := ret.Get(0).(func(context.Context) []*entity.Tag); ok {
1378		r0 = returnFunc(ctx)
1379	} else {
1380		if ret.Get(0) != nil {
1381			r0 = ret.Get(0).([]*entity.Tag)
1382		}
1383	}
1384	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1385		r1 = returnFunc(ctx)
1386	} else {
1387		r1 = ret.Error(1)
1388	}
1389	return r0, r1
1390}
1391
1392// MockTagRepository_GetAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAll'
1393type MockTagRepository_GetAll_Call struct {
1394	*mock.Call
1395}
1396
1397// GetAll is a helper method to define mock.On call
1398//   - ctx context.Context
1399func (_e *MockTagRepository_Expecter) GetAll(ctx interface{}) *MockTagRepository_GetAll_Call {
1400	return &MockTagRepository_GetAll_Call{Call: _e.mock.On("GetAll", ctx)}
1401}
1402
1403func (_c *MockTagRepository_GetAll_Call) Run(run func(ctx context.Context)) *MockTagRepository_GetAll_Call {
1404	_c.Call.Run(func(args mock.Arguments) {
1405		var arg0 context.Context
1406		if args[0] != nil {
1407			arg0 = args[0].(context.Context)
1408		}
1409		run(
1410			arg0,
1411		)
1412	})
1413	return _c
1414}
1415
1416func (_c *MockTagRepository_GetAll_Call) Return(tags []*entity.Tag, err error) *MockTagRepository_GetAll_Call {
1417	_c.Call.Return(tags, err)
1418	return _c
1419}
1420
1421func (_c *MockTagRepository_GetAll_Call) RunAndReturn(run func(ctx context.Context) ([]*entity.Tag, error)) *MockTagRepository_GetAll_Call {
1422	_c.Call.Return(run)
1423	return _c
1424}
1425
1426// GetForFavorite provides a mock function for the type MockTagRepository
1427func (_mock *MockTagRepository) GetForFavorite(ctx context.Context, favID entity.FavoriteID) ([]*entity.Tag, error) {
1428	ret := _mock.Called(ctx, favID)
1429
1430	if len(ret) == 0 {
1431		panic("no return value specified for GetForFavorite")
1432	}
1433
1434	var r0 []*entity.Tag
1435	var r1 error
1436	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FavoriteID) ([]*entity.Tag, error)); ok {
1437		return returnFunc(ctx, favID)
1438	}
1439	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FavoriteID) []*entity.Tag); ok {
1440		r0 = returnFunc(ctx, favID)
1441	} else {
1442		if ret.Get(0) != nil {
1443			r0 = ret.Get(0).([]*entity.Tag)
1444		}
1445	}
1446	if returnFunc, ok := ret.Get(1).(func(context.Context, entity.FavoriteID) error); ok {
1447		r1 = returnFunc(ctx, favID)
1448	} else {
1449		r1 = ret.Error(1)
1450	}
1451	return r0, r1
1452}
1453
1454// MockTagRepository_GetForFavorite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetForFavorite'
1455type MockTagRepository_GetForFavorite_Call struct {
1456	*mock.Call
1457}
1458
1459// GetForFavorite is a helper method to define mock.On call
1460//   - ctx context.Context
1461//   - favID entity.FavoriteID
1462func (_e *MockTagRepository_Expecter) GetForFavorite(ctx interface{}, favID interface{}) *MockTagRepository_GetForFavorite_Call {
1463	return &MockTagRepository_GetForFavorite_Call{Call: _e.mock.On("GetForFavorite", ctx, favID)}
1464}
1465
1466func (_c *MockTagRepository_GetForFavorite_Call) Run(run func(ctx context.Context, favID entity.FavoriteID)) *MockTagRepository_GetForFavorite_Call {
1467	_c.Call.Run(func(args mock.Arguments) {
1468		var arg0 context.Context
1469		if args[0] != nil {
1470			arg0 = args[0].(context.Context)
1471		}
1472		var arg1 entity.FavoriteID
1473		if args[1] != nil {
1474			arg1 = args[1].(entity.FavoriteID)
1475		}
1476		run(
1477			arg0,
1478			arg1,
1479		)
1480	})
1481	return _c
1482}
1483
1484func (_c *MockTagRepository_GetForFavorite_Call) Return(tags []*entity.Tag, err error) *MockTagRepository_GetForFavorite_Call {
1485	_c.Call.Return(tags, err)
1486	return _c
1487}
1488
1489func (_c *MockTagRepository_GetForFavorite_Call) RunAndReturn(run func(ctx context.Context, favID entity.FavoriteID) ([]*entity.Tag, error)) *MockTagRepository_GetForFavorite_Call {
1490	_c.Call.Return(run)
1491	return _c
1492}
1493
1494// RemoveFromFavorite provides a mock function for the type MockTagRepository
1495func (_mock *MockTagRepository) RemoveFromFavorite(ctx context.Context, tagID entity.TagID, favID entity.FavoriteID) error {
1496	ret := _mock.Called(ctx, tagID, favID)
1497
1498	if len(ret) == 0 {
1499		panic("no return value specified for RemoveFromFavorite")
1500	}
1501
1502	var r0 error
1503	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.TagID, entity.FavoriteID) error); ok {
1504		r0 = returnFunc(ctx, tagID, favID)
1505	} else {
1506		r0 = ret.Error(0)
1507	}
1508	return r0
1509}
1510
1511// MockTagRepository_RemoveFromFavorite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveFromFavorite'
1512type MockTagRepository_RemoveFromFavorite_Call struct {
1513	*mock.Call
1514}
1515
1516// RemoveFromFavorite is a helper method to define mock.On call
1517//   - ctx context.Context
1518//   - tagID entity.TagID
1519//   - favID entity.FavoriteID
1520func (_e *MockTagRepository_Expecter) RemoveFromFavorite(ctx interface{}, tagID interface{}, favID interface{}) *MockTagRepository_RemoveFromFavorite_Call {
1521	return &MockTagRepository_RemoveFromFavorite_Call{Call: _e.mock.On("RemoveFromFavorite", ctx, tagID, favID)}
1522}
1523
1524func (_c *MockTagRepository_RemoveFromFavorite_Call) Run(run func(ctx context.Context, tagID entity.TagID, favID entity.FavoriteID)) *MockTagRepository_RemoveFromFavorite_Call {
1525	_c.Call.Run(func(args mock.Arguments) {
1526		var arg0 context.Context
1527		if args[0] != nil {
1528			arg0 = args[0].(context.Context)
1529		}
1530		var arg1 entity.TagID
1531		if args[1] != nil {
1532			arg1 = args[1].(entity.TagID)
1533		}
1534		var arg2 entity.FavoriteID
1535		if args[2] != nil {
1536			arg2 = args[2].(entity.FavoriteID)
1537		}
1538		run(
1539			arg0,
1540			arg1,
1541			arg2,
1542		)
1543	})
1544	return _c
1545}
1546
1547func (_c *MockTagRepository_RemoveFromFavorite_Call) Return(err error) *MockTagRepository_RemoveFromFavorite_Call {
1548	_c.Call.Return(err)
1549	return _c
1550}
1551
1552func (_c *MockTagRepository_RemoveFromFavorite_Call) RunAndReturn(run func(ctx context.Context, tagID entity.TagID, favID entity.FavoriteID) error) *MockTagRepository_RemoveFromFavorite_Call {
1553	_c.Call.Return(run)
1554	return _c
1555}
1556
1557// Save provides a mock function for the type MockTagRepository
1558func (_mock *MockTagRepository) Save(ctx context.Context, tag *entity.Tag) error {
1559	ret := _mock.Called(ctx, tag)
1560
1561	if len(ret) == 0 {
1562		panic("no return value specified for Save")
1563	}
1564
1565	var r0 error
1566	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.Tag) error); ok {
1567		r0 = returnFunc(ctx, tag)
1568	} else {
1569		r0 = ret.Error(0)
1570	}
1571	return r0
1572}
1573
1574// MockTagRepository_Save_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Save'
1575type MockTagRepository_Save_Call struct {
1576	*mock.Call
1577}
1578
1579// Save is a helper method to define mock.On call
1580//   - ctx context.Context
1581//   - tag *entity.Tag
1582func (_e *MockTagRepository_Expecter) Save(ctx interface{}, tag interface{}) *MockTagRepository_Save_Call {
1583	return &MockTagRepository_Save_Call{Call: _e.mock.On("Save", ctx, tag)}
1584}
1585
1586func (_c *MockTagRepository_Save_Call) Run(run func(ctx context.Context, tag *entity.Tag)) *MockTagRepository_Save_Call {
1587	_c.Call.Run(func(args mock.Arguments) {
1588		var arg0 context.Context
1589		if args[0] != nil {
1590			arg0 = args[0].(context.Context)
1591		}
1592		var arg1 *entity.Tag
1593		if args[1] != nil {
1594			arg1 = args[1].(*entity.Tag)
1595		}
1596		run(
1597			arg0,
1598			arg1,
1599		)
1600	})
1601	return _c
1602}
1603
1604func (_c *MockTagRepository_Save_Call) Return(err error) *MockTagRepository_Save_Call {
1605	_c.Call.Return(err)
1606	return _c
1607}
1608
1609func (_c *MockTagRepository_Save_Call) RunAndReturn(run func(ctx context.Context, tag *entity.Tag) error) *MockTagRepository_Save_Call {
1610	_c.Call.Return(run)
1611	return _c
1612}
1613
1614// NewMockContentWhitelistRepository creates a new instance of MockContentWhitelistRepository. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
1615// The first argument is typically a *testing.T value.
1616func NewMockContentWhitelistRepository(t interface {
1617	mock.TestingT
1618	Cleanup(func())
1619}) *MockContentWhitelistRepository {
1620	mock := &MockContentWhitelistRepository{}
1621	mock.Mock.Test(t)
1622
1623	t.Cleanup(func() { mock.AssertExpectations(t) })
1624
1625	return mock
1626}
1627
1628// MockContentWhitelistRepository is an autogenerated mock type for the ContentWhitelistRepository type
1629type MockContentWhitelistRepository struct {
1630	mock.Mock
1631}
1632
1633type MockContentWhitelistRepository_Expecter struct {
1634	mock *mock.Mock
1635}
1636
1637func (_m *MockContentWhitelistRepository) EXPECT() *MockContentWhitelistRepository_Expecter {
1638	return &MockContentWhitelistRepository_Expecter{mock: &_m.Mock}
1639}
1640
1641// Add provides a mock function for the type MockContentWhitelistRepository
1642func (_mock *MockContentWhitelistRepository) Add(ctx context.Context, domain string) error {
1643	ret := _mock.Called(ctx, domain)
1644
1645	if len(ret) == 0 {
1646		panic("no return value specified for Add")
1647	}
1648
1649	var r0 error
1650	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
1651		r0 = returnFunc(ctx, domain)
1652	} else {
1653		r0 = ret.Error(0)
1654	}
1655	return r0
1656}
1657
1658// MockContentWhitelistRepository_Add_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Add'
1659type MockContentWhitelistRepository_Add_Call struct {
1660	*mock.Call
1661}
1662
1663// Add is a helper method to define mock.On call
1664//   - ctx context.Context
1665//   - domain string
1666func (_e *MockContentWhitelistRepository_Expecter) Add(ctx interface{}, domain interface{}) *MockContentWhitelistRepository_Add_Call {
1667	return &MockContentWhitelistRepository_Add_Call{Call: _e.mock.On("Add", ctx, domain)}
1668}
1669
1670func (_c *MockContentWhitelistRepository_Add_Call) Run(run func(ctx context.Context, domain string)) *MockContentWhitelistRepository_Add_Call {
1671	_c.Call.Run(func(args mock.Arguments) {
1672		var arg0 context.Context
1673		if args[0] != nil {
1674			arg0 = args[0].(context.Context)
1675		}
1676		var arg1 string
1677		if args[1] != nil {
1678			arg1 = args[1].(string)
1679		}
1680		run(
1681			arg0,
1682			arg1,
1683		)
1684	})
1685	return _c
1686}
1687
1688func (_c *MockContentWhitelistRepository_Add_Call) Return(err error) *MockContentWhitelistRepository_Add_Call {
1689	_c.Call.Return(err)
1690	return _c
1691}
1692
1693func (_c *MockContentWhitelistRepository_Add_Call) RunAndReturn(run func(ctx context.Context, domain string) error) *MockContentWhitelistRepository_Add_Call {
1694	_c.Call.Return(run)
1695	return _c
1696}
1697
1698// Contains provides a mock function for the type MockContentWhitelistRepository
1699func (_mock *MockContentWhitelistRepository) Contains(ctx context.Context, domain string) (bool, error) {
1700	ret := _mock.Called(ctx, domain)
1701
1702	if len(ret) == 0 {
1703		panic("no return value specified for Contains")
1704	}
1705
1706	var r0 bool
1707	var r1 error
1708	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (bool, error)); ok {
1709		return returnFunc(ctx, domain)
1710	}
1711	if returnFunc, ok := ret.Get(0).(func(context.Context, string) bool); ok {
1712		r0 = returnFunc(ctx, domain)
1713	} else {
1714		r0 = ret.Get(0).(bool)
1715	}
1716	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
1717		r1 = returnFunc(ctx, domain)
1718	} else {
1719		r1 = ret.Error(1)
1720	}
1721	return r0, r1
1722}
1723
1724// MockContentWhitelistRepository_Contains_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Contains'
1725type MockContentWhitelistRepository_Contains_Call struct {
1726	*mock.Call
1727}
1728
1729// Contains is a helper method to define mock.On call
1730//   - ctx context.Context
1731//   - domain string
1732func (_e *MockContentWhitelistRepository_Expecter) Contains(ctx interface{}, domain interface{}) *MockContentWhitelistRepository_Contains_Call {
1733	return &MockContentWhitelistRepository_Contains_Call{Call: _e.mock.On("Contains", ctx, domain)}
1734}
1735
1736func (_c *MockContentWhitelistRepository_Contains_Call) Run(run func(ctx context.Context, domain string)) *MockContentWhitelistRepository_Contains_Call {
1737	_c.Call.Run(func(args mock.Arguments) {
1738		var arg0 context.Context
1739		if args[0] != nil {
1740			arg0 = args[0].(context.Context)
1741		}
1742		var arg1 string
1743		if args[1] != nil {
1744			arg1 = args[1].(string)
1745		}
1746		run(
1747			arg0,
1748			arg1,
1749		)
1750	})
1751	return _c
1752}
1753
1754func (_c *MockContentWhitelistRepository_Contains_Call) Return(b bool, err error) *MockContentWhitelistRepository_Contains_Call {
1755	_c.Call.Return(b, err)
1756	return _c
1757}
1758
1759func (_c *MockContentWhitelistRepository_Contains_Call) RunAndReturn(run func(ctx context.Context, domain string) (bool, error)) *MockContentWhitelistRepository_Contains_Call {
1760	_c.Call.Return(run)
1761	return _c
1762}
1763
1764// GetAll provides a mock function for the type MockContentWhitelistRepository
1765func (_mock *MockContentWhitelistRepository) GetAll(ctx context.Context) ([]string, error) {
1766	ret := _mock.Called(ctx)
1767
1768	if len(ret) == 0 {
1769		panic("no return value specified for GetAll")
1770	}
1771
1772	var r0 []string
1773	var r1 error
1774	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]string, error)); ok {
1775		return returnFunc(ctx)
1776	}
1777	if returnFunc, ok := ret.Get(0).(func(context.Context) []string); ok {
1778		r0 = returnFunc(ctx)
1779	} else {
1780		if ret.Get(0) != nil {
1781			r0 = ret.Get(0).([]string)
1782		}
1783	}
1784	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1785		r1 = returnFunc(ctx)
1786	} else {
1787		r1 = ret.Error(1)
1788	}
1789	return r0, r1
1790}
1791
1792// MockContentWhitelistRepository_GetAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAll'
1793type MockContentWhitelistRepository_GetAll_Call struct {
1794	*mock.Call
1795}
1796
1797// GetAll is a helper method to define mock.On call
1798//   - ctx context.Context
1799func (_e *MockContentWhitelistRepository_Expecter) GetAll(ctx interface{}) *MockContentWhitelistRepository_GetAll_Call {
1800	return &MockContentWhitelistRepository_GetAll_Call{Call: _e.mock.On("GetAll", ctx)}
1801}
1802
1803func (_c *MockContentWhitelistRepository_GetAll_Call) Run(run func(ctx context.Context)) *MockContentWhitelistRepository_GetAll_Call {
1804	_c.Call.Run(func(args mock.Arguments) {
1805		var arg0 context.Context
1806		if args[0] != nil {
1807			arg0 = args[0].(context.Context)
1808		}
1809		run(
1810			arg0,
1811		)
1812	})
1813	return _c
1814}
1815
1816func (_c *MockContentWhitelistRepository_GetAll_Call) Return(strings []string, err error) *MockContentWhitelistRepository_GetAll_Call {
1817	_c.Call.Return(strings, err)
1818	return _c
1819}
1820
1821func (_c *MockContentWhitelistRepository_GetAll_Call) RunAndReturn(run func(ctx context.Context) ([]string, error)) *MockContentWhitelistRepository_GetAll_Call {
1822	_c.Call.Return(run)
1823	return _c
1824}
1825
1826// Remove provides a mock function for the type MockContentWhitelistRepository
1827func (_mock *MockContentWhitelistRepository) Remove(ctx context.Context, domain string) error {
1828	ret := _mock.Called(ctx, domain)
1829
1830	if len(ret) == 0 {
1831		panic("no return value specified for Remove")
1832	}
1833
1834	var r0 error
1835	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
1836		r0 = returnFunc(ctx, domain)
1837	} else {
1838		r0 = ret.Error(0)
1839	}
1840	return r0
1841}
1842
1843// MockContentWhitelistRepository_Remove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Remove'
1844type MockContentWhitelistRepository_Remove_Call struct {
1845	*mock.Call
1846}
1847
1848// Remove is a helper method to define mock.On call
1849//   - ctx context.Context
1850//   - domain string
1851func (_e *MockContentWhitelistRepository_Expecter) Remove(ctx interface{}, domain interface{}) *MockContentWhitelistRepository_Remove_Call {
1852	return &MockContentWhitelistRepository_Remove_Call{Call: _e.mock.On("Remove", ctx, domain)}
1853}
1854
1855func (_c *MockContentWhitelistRepository_Remove_Call) Run(run func(ctx context.Context, domain string)) *MockContentWhitelistRepository_Remove_Call {
1856	_c.Call.Run(func(args mock.Arguments) {
1857		var arg0 context.Context
1858		if args[0] != nil {
1859			arg0 = args[0].(context.Context)
1860		}
1861		var arg1 string
1862		if args[1] != nil {
1863			arg1 = args[1].(string)
1864		}
1865		run(
1866			arg0,
1867			arg1,
1868		)
1869	})
1870	return _c
1871}
1872
1873func (_c *MockContentWhitelistRepository_Remove_Call) Return(err error) *MockContentWhitelistRepository_Remove_Call {
1874	_c.Call.Return(err)
1875	return _c
1876}
1877
1878func (_c *MockContentWhitelistRepository_Remove_Call) RunAndReturn(run func(ctx context.Context, domain string) error) *MockContentWhitelistRepository_Remove_Call {
1879	_c.Call.Return(run)
1880	return _c
1881}
1882
1883// NewMockHistoryRepository creates a new instance of MockHistoryRepository. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
1884// The first argument is typically a *testing.T value.
1885func NewMockHistoryRepository(t interface {
1886	mock.TestingT
1887	Cleanup(func())
1888}) *MockHistoryRepository {
1889	mock := &MockHistoryRepository{}
1890	mock.Mock.Test(t)
1891
1892	t.Cleanup(func() { mock.AssertExpectations(t) })
1893
1894	return mock
1895}
1896
1897// MockHistoryRepository is an autogenerated mock type for the HistoryRepository type
1898type MockHistoryRepository struct {
1899	mock.Mock
1900}
1901
1902type MockHistoryRepository_Expecter struct {
1903	mock *mock.Mock
1904}
1905
1906func (_m *MockHistoryRepository) EXPECT() *MockHistoryRepository_Expecter {
1907	return &MockHistoryRepository_Expecter{mock: &_m.Mock}
1908}
1909
1910// Delete provides a mock function for the type MockHistoryRepository
1911func (_mock *MockHistoryRepository) Delete(ctx context.Context, id int64) error {
1912	ret := _mock.Called(ctx, id)
1913
1914	if len(ret) == 0 {
1915		panic("no return value specified for Delete")
1916	}
1917
1918	var r0 error
1919	if returnFunc, ok := ret.Get(0).(func(context.Context, int64) error); ok {
1920		r0 = returnFunc(ctx, id)
1921	} else {
1922		r0 = ret.Error(0)
1923	}
1924	return r0
1925}
1926
1927// MockHistoryRepository_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
1928type MockHistoryRepository_Delete_Call struct {
1929	*mock.Call
1930}
1931
1932// Delete is a helper method to define mock.On call
1933//   - ctx context.Context
1934//   - id int64
1935func (_e *MockHistoryRepository_Expecter) Delete(ctx interface{}, id interface{}) *MockHistoryRepository_Delete_Call {
1936	return &MockHistoryRepository_Delete_Call{Call: _e.mock.On("Delete", ctx, id)}
1937}
1938
1939func (_c *MockHistoryRepository_Delete_Call) Run(run func(ctx context.Context, id int64)) *MockHistoryRepository_Delete_Call {
1940	_c.Call.Run(func(args mock.Arguments) {
1941		var arg0 context.Context
1942		if args[0] != nil {
1943			arg0 = args[0].(context.Context)
1944		}
1945		var arg1 int64
1946		if args[1] != nil {
1947			arg1 = args[1].(int64)
1948		}
1949		run(
1950			arg0,
1951			arg1,
1952		)
1953	})
1954	return _c
1955}
1956
1957func (_c *MockHistoryRepository_Delete_Call) Return(err error) *MockHistoryRepository_Delete_Call {
1958	_c.Call.Return(err)
1959	return _c
1960}
1961
1962func (_c *MockHistoryRepository_Delete_Call) RunAndReturn(run func(ctx context.Context, id int64) error) *MockHistoryRepository_Delete_Call {
1963	_c.Call.Return(run)
1964	return _c
1965}
1966
1967// DeleteAll provides a mock function for the type MockHistoryRepository
1968func (_mock *MockHistoryRepository) DeleteAll(ctx context.Context) error {
1969	ret := _mock.Called(ctx)
1970
1971	if len(ret) == 0 {
1972		panic("no return value specified for DeleteAll")
1973	}
1974
1975	var r0 error
1976	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
1977		r0 = returnFunc(ctx)
1978	} else {
1979		r0 = ret.Error(0)
1980	}
1981	return r0
1982}
1983
1984// MockHistoryRepository_DeleteAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAll'
1985type MockHistoryRepository_DeleteAll_Call struct {
1986	*mock.Call
1987}
1988
1989// DeleteAll is a helper method to define mock.On call
1990//   - ctx context.Context
1991func (_e *MockHistoryRepository_Expecter) DeleteAll(ctx interface{}) *MockHistoryRepository_DeleteAll_Call {
1992	return &MockHistoryRepository_DeleteAll_Call{Call: _e.mock.On("DeleteAll", ctx)}
1993}
1994
1995func (_c *MockHistoryRepository_DeleteAll_Call) Run(run func(ctx context.Context)) *MockHistoryRepository_DeleteAll_Call {
1996	_c.Call.Run(func(args mock.Arguments) {
1997		var arg0 context.Context
1998		if args[0] != nil {
1999			arg0 = args[0].(context.Context)
2000		}
2001		run(
2002			arg0,
2003		)
2004	})
2005	return _c
2006}
2007
2008func (_c *MockHistoryRepository_DeleteAll_Call) Return(err error) *MockHistoryRepository_DeleteAll_Call {
2009	_c.Call.Return(err)
2010	return _c
2011}
2012
2013func (_c *MockHistoryRepository_DeleteAll_Call) RunAndReturn(run func(ctx context.Context) error) *MockHistoryRepository_DeleteAll_Call {
2014	_c.Call.Return(run)
2015	return _c
2016}
2017
2018// DeleteByDomain provides a mock function for the type MockHistoryRepository
2019func (_mock *MockHistoryRepository) DeleteByDomain(ctx context.Context, domain string) error {
2020	ret := _mock.Called(ctx, domain)
2021
2022	if len(ret) == 0 {
2023		panic("no return value specified for DeleteByDomain")
2024	}
2025
2026	var r0 error
2027	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
2028		r0 = returnFunc(ctx, domain)
2029	} else {
2030		r0 = ret.Error(0)
2031	}
2032	return r0
2033}
2034
2035// MockHistoryRepository_DeleteByDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteByDomain'
2036type MockHistoryRepository_DeleteByDomain_Call struct {
2037	*mock.Call
2038}
2039
2040// DeleteByDomain is a helper method to define mock.On call
2041//   - ctx context.Context
2042//   - domain string
2043func (_e *MockHistoryRepository_Expecter) DeleteByDomain(ctx interface{}, domain interface{}) *MockHistoryRepository_DeleteByDomain_Call {
2044	return &MockHistoryRepository_DeleteByDomain_Call{Call: _e.mock.On("DeleteByDomain", ctx, domain)}
2045}
2046
2047func (_c *MockHistoryRepository_DeleteByDomain_Call) Run(run func(ctx context.Context, domain string)) *MockHistoryRepository_DeleteByDomain_Call {
2048	_c.Call.Run(func(args mock.Arguments) {
2049		var arg0 context.Context
2050		if args[0] != nil {
2051			arg0 = args[0].(context.Context)
2052		}
2053		var arg1 string
2054		if args[1] != nil {
2055			arg1 = args[1].(string)
2056		}
2057		run(
2058			arg0,
2059			arg1,
2060		)
2061	})
2062	return _c
2063}
2064
2065func (_c *MockHistoryRepository_DeleteByDomain_Call) Return(err error) *MockHistoryRepository_DeleteByDomain_Call {
2066	_c.Call.Return(err)
2067	return _c
2068}
2069
2070func (_c *MockHistoryRepository_DeleteByDomain_Call) RunAndReturn(run func(ctx context.Context, domain string) error) *MockHistoryRepository_DeleteByDomain_Call {
2071	_c.Call.Return(run)
2072	return _c
2073}
2074
2075// DeleteOlderThan provides a mock function for the type MockHistoryRepository
2076func (_mock *MockHistoryRepository) DeleteOlderThan(ctx context.Context, before time.Time) error {
2077	ret := _mock.Called(ctx, before)
2078
2079	if len(ret) == 0 {
2080		panic("no return value specified for DeleteOlderThan")
2081	}
2082
2083	var r0 error
2084	if returnFunc, ok := ret.Get(0).(func(context.Context, time.Time) error); ok {
2085		r0 = returnFunc(ctx, before)
2086	} else {
2087		r0 = ret.Error(0)
2088	}
2089	return r0
2090}
2091
2092// MockHistoryRepository_DeleteOlderThan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteOlderThan'
2093type MockHistoryRepository_DeleteOlderThan_Call struct {
2094	*mock.Call
2095}
2096
2097// DeleteOlderThan is a helper method to define mock.On call
2098//   - ctx context.Context
2099//   - before time.Time
2100func (_e *MockHistoryRepository_Expecter) DeleteOlderThan(ctx interface{}, before interface{}) *MockHistoryRepository_DeleteOlderThan_Call {
2101	return &MockHistoryRepository_DeleteOlderThan_Call{Call: _e.mock.On("DeleteOlderThan", ctx, before)}
2102}
2103
2104func (_c *MockHistoryRepository_DeleteOlderThan_Call) Run(run func(ctx context.Context, before time.Time)) *MockHistoryRepository_DeleteOlderThan_Call {
2105	_c.Call.Run(func(args mock.Arguments) {
2106		var arg0 context.Context
2107		if args[0] != nil {
2108			arg0 = args[0].(context.Context)
2109		}
2110		var arg1 time.Time
2111		if args[1] != nil {
2112			arg1 = args[1].(time.Time)
2113		}
2114		run(
2115			arg0,
2116			arg1,
2117		)
2118	})
2119	return _c
2120}
2121
2122func (_c *MockHistoryRepository_DeleteOlderThan_Call) Return(err error) *MockHistoryRepository_DeleteOlderThan_Call {
2123	_c.Call.Return(err)
2124	return _c
2125}
2126
2127func (_c *MockHistoryRepository_DeleteOlderThan_Call) RunAndReturn(run func(ctx context.Context, before time.Time) error) *MockHistoryRepository_DeleteOlderThan_Call {
2128	_c.Call.Return(run)
2129	return _c
2130}
2131
2132// FindByURL provides a mock function for the type MockHistoryRepository
2133func (_mock *MockHistoryRepository) FindByURL(ctx context.Context, url string) (*entity.HistoryEntry, error) {
2134	ret := _mock.Called(ctx, url)
2135
2136	if len(ret) == 0 {
2137		panic("no return value specified for FindByURL")
2138	}
2139
2140	var r0 *entity.HistoryEntry
2141	var r1 error
2142	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*entity.HistoryEntry, error)); ok {
2143		return returnFunc(ctx, url)
2144	}
2145	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *entity.HistoryEntry); ok {
2146		r0 = returnFunc(ctx, url)
2147	} else {
2148		if ret.Get(0) != nil {
2149			r0 = ret.Get(0).(*entity.HistoryEntry)
2150		}
2151	}
2152	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
2153		r1 = returnFunc(ctx, url)
2154	} else {
2155		r1 = ret.Error(1)
2156	}
2157	return r0, r1
2158}
2159
2160// MockHistoryRepository_FindByURL_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByURL'
2161type MockHistoryRepository_FindByURL_Call struct {
2162	*mock.Call
2163}
2164
2165// FindByURL is a helper method to define mock.On call
2166//   - ctx context.Context
2167//   - url string
2168func (_e *MockHistoryRepository_Expecter) FindByURL(ctx interface{}, url interface{}) *MockHistoryRepository_FindByURL_Call {
2169	return &MockHistoryRepository_FindByURL_Call{Call: _e.mock.On("FindByURL", ctx, url)}
2170}
2171
2172func (_c *MockHistoryRepository_FindByURL_Call) Run(run func(ctx context.Context, url string)) *MockHistoryRepository_FindByURL_Call {
2173	_c.Call.Run(func(args mock.Arguments) {
2174		var arg0 context.Context
2175		if args[0] != nil {
2176			arg0 = args[0].(context.Context)
2177		}
2178		var arg1 string
2179		if args[1] != nil {
2180			arg1 = args[1].(string)
2181		}
2182		run(
2183			arg0,
2184			arg1,
2185		)
2186	})
2187	return _c
2188}
2189
2190func (_c *MockHistoryRepository_FindByURL_Call) Return(historyEntry *entity.HistoryEntry, err error) *MockHistoryRepository_FindByURL_Call {
2191	_c.Call.Return(historyEntry, err)
2192	return _c
2193}
2194
2195func (_c *MockHistoryRepository_FindByURL_Call) RunAndReturn(run func(ctx context.Context, url string) (*entity.HistoryEntry, error)) *MockHistoryRepository_FindByURL_Call {
2196	_c.Call.Return(run)
2197	return _c
2198}
2199
2200// GetAllMostVisited provides a mock function for the type MockHistoryRepository
2201func (_mock *MockHistoryRepository) GetAllMostVisited(ctx context.Context) ([]*entity.HistoryEntry, error) {
2202	ret := _mock.Called(ctx)
2203
2204	if len(ret) == 0 {
2205		panic("no return value specified for GetAllMostVisited")
2206	}
2207
2208	var r0 []*entity.HistoryEntry
2209	var r1 error
2210	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*entity.HistoryEntry, error)); ok {
2211		return returnFunc(ctx)
2212	}
2213	if returnFunc, ok := ret.Get(0).(func(context.Context) []*entity.HistoryEntry); ok {
2214		r0 = returnFunc(ctx)
2215	} else {
2216		if ret.Get(0) != nil {
2217			r0 = ret.Get(0).([]*entity.HistoryEntry)
2218		}
2219	}
2220	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
2221		r1 = returnFunc(ctx)
2222	} else {
2223		r1 = ret.Error(1)
2224	}
2225	return r0, r1
2226}
2227
2228// MockHistoryRepository_GetAllMostVisited_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllMostVisited'
2229type MockHistoryRepository_GetAllMostVisited_Call struct {
2230	*mock.Call
2231}
2232
2233// GetAllMostVisited is a helper method to define mock.On call
2234//   - ctx context.Context
2235func (_e *MockHistoryRepository_Expecter) GetAllMostVisited(ctx interface{}) *MockHistoryRepository_GetAllMostVisited_Call {
2236	return &MockHistoryRepository_GetAllMostVisited_Call{Call: _e.mock.On("GetAllMostVisited", ctx)}
2237}
2238
2239func (_c *MockHistoryRepository_GetAllMostVisited_Call) Run(run func(ctx context.Context)) *MockHistoryRepository_GetAllMostVisited_Call {
2240	_c.Call.Run(func(args mock.Arguments) {
2241		var arg0 context.Context
2242		if args[0] != nil {
2243			arg0 = args[0].(context.Context)
2244		}
2245		run(
2246			arg0,
2247		)
2248	})
2249	return _c
2250}
2251
2252func (_c *MockHistoryRepository_GetAllMostVisited_Call) Return(historyEntrys []*entity.HistoryEntry, err error) *MockHistoryRepository_GetAllMostVisited_Call {
2253	_c.Call.Return(historyEntrys, err)
2254	return _c
2255}
2256
2257func (_c *MockHistoryRepository_GetAllMostVisited_Call) RunAndReturn(run func(ctx context.Context) ([]*entity.HistoryEntry, error)) *MockHistoryRepository_GetAllMostVisited_Call {
2258	_c.Call.Return(run)
2259	return _c
2260}
2261
2262// GetAllRecentHistory provides a mock function for the type MockHistoryRepository
2263func (_mock *MockHistoryRepository) GetAllRecentHistory(ctx context.Context) ([]*entity.HistoryEntry, error) {
2264	ret := _mock.Called(ctx)
2265
2266	if len(ret) == 0 {
2267		panic("no return value specified for GetAllRecentHistory")
2268	}
2269
2270	var r0 []*entity.HistoryEntry
2271	var r1 error
2272	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*entity.HistoryEntry, error)); ok {
2273		return returnFunc(ctx)
2274	}
2275	if returnFunc, ok := ret.Get(0).(func(context.Context) []*entity.HistoryEntry); ok {
2276		r0 = returnFunc(ctx)
2277	} else {
2278		if ret.Get(0) != nil {
2279			r0 = ret.Get(0).([]*entity.HistoryEntry)
2280		}
2281	}
2282	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
2283		r1 = returnFunc(ctx)
2284	} else {
2285		r1 = ret.Error(1)
2286	}
2287	return r0, r1
2288}
2289
2290// MockHistoryRepository_GetAllRecentHistory_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllRecentHistory'
2291type MockHistoryRepository_GetAllRecentHistory_Call struct {
2292	*mock.Call
2293}
2294
2295// GetAllRecentHistory is a helper method to define mock.On call
2296//   - ctx context.Context
2297func (_e *MockHistoryRepository_Expecter) GetAllRecentHistory(ctx interface{}) *MockHistoryRepository_GetAllRecentHistory_Call {
2298	return &MockHistoryRepository_GetAllRecentHistory_Call{Call: _e.mock.On("GetAllRecentHistory", ctx)}
2299}
2300
2301func (_c *MockHistoryRepository_GetAllRecentHistory_Call) Run(run func(ctx context.Context)) *MockHistoryRepository_GetAllRecentHistory_Call {
2302	_c.Call.Run(func(args mock.Arguments) {
2303		var arg0 context.Context
2304		if args[0] != nil {
2305			arg0 = args[0].(context.Context)
2306		}
2307		run(
2308			arg0,
2309		)
2310	})
2311	return _c
2312}
2313
2314func (_c *MockHistoryRepository_GetAllRecentHistory_Call) Return(historyEntrys []*entity.HistoryEntry, err error) *MockHistoryRepository_GetAllRecentHistory_Call {
2315	_c.Call.Return(historyEntrys, err)
2316	return _c
2317}
2318
2319func (_c *MockHistoryRepository_GetAllRecentHistory_Call) RunAndReturn(run func(ctx context.Context) ([]*entity.HistoryEntry, error)) *MockHistoryRepository_GetAllRecentHistory_Call {
2320	_c.Call.Return(run)
2321	return _c
2322}
2323
2324// GetDailyVisitCount provides a mock function for the type MockHistoryRepository
2325func (_mock *MockHistoryRepository) GetDailyVisitCount(ctx context.Context, daysAgo string) ([]*entity.DailyVisitCount, error) {
2326	ret := _mock.Called(ctx, daysAgo)
2327
2328	if len(ret) == 0 {
2329		panic("no return value specified for GetDailyVisitCount")
2330	}
2331
2332	var r0 []*entity.DailyVisitCount
2333	var r1 error
2334	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]*entity.DailyVisitCount, error)); ok {
2335		return returnFunc(ctx, daysAgo)
2336	}
2337	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []*entity.DailyVisitCount); ok {
2338		r0 = returnFunc(ctx, daysAgo)
2339	} else {
2340		if ret.Get(0) != nil {
2341			r0 = ret.Get(0).([]*entity.DailyVisitCount)
2342		}
2343	}
2344	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
2345		r1 = returnFunc(ctx, daysAgo)
2346	} else {
2347		r1 = ret.Error(1)
2348	}
2349	return r0, r1
2350}
2351
2352// MockHistoryRepository_GetDailyVisitCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDailyVisitCount'
2353type MockHistoryRepository_GetDailyVisitCount_Call struct {
2354	*mock.Call
2355}
2356
2357// GetDailyVisitCount is a helper method to define mock.On call
2358//   - ctx context.Context
2359//   - daysAgo string
2360func (_e *MockHistoryRepository_Expecter) GetDailyVisitCount(ctx interface{}, daysAgo interface{}) *MockHistoryRepository_GetDailyVisitCount_Call {
2361	return &MockHistoryRepository_GetDailyVisitCount_Call{Call: _e.mock.On("GetDailyVisitCount", ctx, daysAgo)}
2362}
2363
2364func (_c *MockHistoryRepository_GetDailyVisitCount_Call) Run(run func(ctx context.Context, daysAgo string)) *MockHistoryRepository_GetDailyVisitCount_Call {
2365	_c.Call.Run(func(args mock.Arguments) {
2366		var arg0 context.Context
2367		if args[0] != nil {
2368			arg0 = args[0].(context.Context)
2369		}
2370		var arg1 string
2371		if args[1] != nil {
2372			arg1 = args[1].(string)
2373		}
2374		run(
2375			arg0,
2376			arg1,
2377		)
2378	})
2379	return _c
2380}
2381
2382func (_c *MockHistoryRepository_GetDailyVisitCount_Call) Return(dailyVisitCounts []*entity.DailyVisitCount, err error) *MockHistoryRepository_GetDailyVisitCount_Call {
2383	_c.Call.Return(dailyVisitCounts, err)
2384	return _c
2385}
2386
2387func (_c *MockHistoryRepository_GetDailyVisitCount_Call) RunAndReturn(run func(ctx context.Context, daysAgo string) ([]*entity.DailyVisitCount, error)) *MockHistoryRepository_GetDailyVisitCount_Call {
2388	_c.Call.Return(run)
2389	return _c
2390}
2391
2392// GetDomainStats provides a mock function for the type MockHistoryRepository
2393func (_mock *MockHistoryRepository) GetDomainStats(ctx context.Context, limit int) ([]*entity.DomainStat, error) {
2394	ret := _mock.Called(ctx, limit)
2395
2396	if len(ret) == 0 {
2397		panic("no return value specified for GetDomainStats")
2398	}
2399
2400	var r0 []*entity.DomainStat
2401	var r1 error
2402	if returnFunc, ok := ret.Get(0).(func(context.Context, int) ([]*entity.DomainStat, error)); ok {
2403		return returnFunc(ctx, limit)
2404	}
2405	if returnFunc, ok := ret.Get(0).(func(context.Context, int) []*entity.DomainStat); ok {
2406		r0 = returnFunc(ctx, limit)
2407	} else {
2408		if ret.Get(0) != nil {
2409			r0 = ret.Get(0).([]*entity.DomainStat)
2410		}
2411	}
2412	if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
2413		r1 = returnFunc(ctx, limit)
2414	} else {
2415		r1 = ret.Error(1)
2416	}
2417	return r0, r1
2418}
2419
2420// MockHistoryRepository_GetDomainStats_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDomainStats'
2421type MockHistoryRepository_GetDomainStats_Call struct {
2422	*mock.Call
2423}
2424
2425// GetDomainStats is a helper method to define mock.On call
2426//   - ctx context.Context
2427//   - limit int
2428func (_e *MockHistoryRepository_Expecter) GetDomainStats(ctx interface{}, limit interface{}) *MockHistoryRepository_GetDomainStats_Call {
2429	return &MockHistoryRepository_GetDomainStats_Call{Call: _e.mock.On("GetDomainStats", ctx, limit)}
2430}
2431
2432func (_c *MockHistoryRepository_GetDomainStats_Call) Run(run func(ctx context.Context, limit int)) *MockHistoryRepository_GetDomainStats_Call {
2433	_c.Call.Run(func(args mock.Arguments) {
2434		var arg0 context.Context
2435		if args[0] != nil {
2436			arg0 = args[0].(context.Context)
2437		}
2438		var arg1 int
2439		if args[1] != nil {
2440			arg1 = args[1].(int)
2441		}
2442		run(
2443			arg0,
2444			arg1,
2445		)
2446	})
2447	return _c
2448}
2449
2450func (_c *MockHistoryRepository_GetDomainStats_Call) Return(domainStats []*entity.DomainStat, err error) *MockHistoryRepository_GetDomainStats_Call {
2451	_c.Call.Return(domainStats, err)
2452	return _c
2453}
2454
2455func (_c *MockHistoryRepository_GetDomainStats_Call) RunAndReturn(run func(ctx context.Context, limit int) ([]*entity.DomainStat, error)) *MockHistoryRepository_GetDomainStats_Call {
2456	_c.Call.Return(run)
2457	return _c
2458}
2459
2460// GetHourlyDistribution provides a mock function for the type MockHistoryRepository
2461func (_mock *MockHistoryRepository) GetHourlyDistribution(ctx context.Context) ([]*entity.HourlyDistribution, error) {
2462	ret := _mock.Called(ctx)
2463
2464	if len(ret) == 0 {
2465		panic("no return value specified for GetHourlyDistribution")
2466	}
2467
2468	var r0 []*entity.HourlyDistribution
2469	var r1 error
2470	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*entity.HourlyDistribution, error)); ok {
2471		return returnFunc(ctx)
2472	}
2473	if returnFunc, ok := ret.Get(0).(func(context.Context) []*entity.HourlyDistribution); ok {
2474		r0 = returnFunc(ctx)
2475	} else {
2476		if ret.Get(0) != nil {
2477			r0 = ret.Get(0).([]*entity.HourlyDistribution)
2478		}
2479	}
2480	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
2481		r1 = returnFunc(ctx)
2482	} else {
2483		r1 = ret.Error(1)
2484	}
2485	return r0, r1
2486}
2487
2488// MockHistoryRepository_GetHourlyDistribution_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHourlyDistribution'
2489type MockHistoryRepository_GetHourlyDistribution_Call struct {
2490	*mock.Call
2491}
2492
2493// GetHourlyDistribution is a helper method to define mock.On call
2494//   - ctx context.Context
2495func (_e *MockHistoryRepository_Expecter) GetHourlyDistribution(ctx interface{}) *MockHistoryRepository_GetHourlyDistribution_Call {
2496	return &MockHistoryRepository_GetHourlyDistribution_Call{Call: _e.mock.On("GetHourlyDistribution", ctx)}
2497}
2498
2499func (_c *MockHistoryRepository_GetHourlyDistribution_Call) Run(run func(ctx context.Context)) *MockHistoryRepository_GetHourlyDistribution_Call {
2500	_c.Call.Run(func(args mock.Arguments) {
2501		var arg0 context.Context
2502		if args[0] != nil {
2503			arg0 = args[0].(context.Context)
2504		}
2505		run(
2506			arg0,
2507		)
2508	})
2509	return _c
2510}
2511
2512func (_c *MockHistoryRepository_GetHourlyDistribution_Call) Return(hourlyDistributions []*entity.HourlyDistribution, err error) *MockHistoryRepository_GetHourlyDistribution_Call {
2513	_c.Call.Return(hourlyDistributions, err)
2514	return _c
2515}
2516
2517func (_c *MockHistoryRepository_GetHourlyDistribution_Call) RunAndReturn(run func(ctx context.Context) ([]*entity.HourlyDistribution, error)) *MockHistoryRepository_GetHourlyDistribution_Call {
2518	_c.Call.Return(run)
2519	return _c
2520}
2521
2522// GetMostVisited provides a mock function for the type MockHistoryRepository
2523func (_mock *MockHistoryRepository) GetMostVisited(ctx context.Context, days int) ([]*entity.HistoryEntry, error) {
2524	ret := _mock.Called(ctx, days)
2525
2526	if len(ret) == 0 {
2527		panic("no return value specified for GetMostVisited")
2528	}
2529
2530	var r0 []*entity.HistoryEntry
2531	var r1 error
2532	if returnFunc, ok := ret.Get(0).(func(context.Context, int) ([]*entity.HistoryEntry, error)); ok {
2533		return returnFunc(ctx, days)
2534	}
2535	if returnFunc, ok := ret.Get(0).(func(context.Context, int) []*entity.HistoryEntry); ok {
2536		r0 = returnFunc(ctx, days)
2537	} else {
2538		if ret.Get(0) != nil {
2539			r0 = ret.Get(0).([]*entity.HistoryEntry)
2540		}
2541	}
2542	if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
2543		r1 = returnFunc(ctx, days)
2544	} else {
2545		r1 = ret.Error(1)
2546	}
2547	return r0, r1
2548}
2549
2550// MockHistoryRepository_GetMostVisited_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMostVisited'
2551type MockHistoryRepository_GetMostVisited_Call struct {
2552	*mock.Call
2553}
2554
2555// GetMostVisited is a helper method to define mock.On call
2556//   - ctx context.Context
2557//   - days int
2558func (_e *MockHistoryRepository_Expecter) GetMostVisited(ctx interface{}, days interface{}) *MockHistoryRepository_GetMostVisited_Call {
2559	return &MockHistoryRepository_GetMostVisited_Call{Call: _e.mock.On("GetMostVisited", ctx, days)}
2560}
2561
2562func (_c *MockHistoryRepository_GetMostVisited_Call) Run(run func(ctx context.Context, days int)) *MockHistoryRepository_GetMostVisited_Call {
2563	_c.Call.Run(func(args mock.Arguments) {
2564		var arg0 context.Context
2565		if args[0] != nil {
2566			arg0 = args[0].(context.Context)
2567		}
2568		var arg1 int
2569		if args[1] != nil {
2570			arg1 = args[1].(int)
2571		}
2572		run(
2573			arg0,
2574			arg1,
2575		)
2576	})
2577	return _c
2578}
2579
2580func (_c *MockHistoryRepository_GetMostVisited_Call) Return(historyEntrys []*entity.HistoryEntry, err error) *MockHistoryRepository_GetMostVisited_Call {
2581	_c.Call.Return(historyEntrys, err)
2582	return _c
2583}
2584
2585func (_c *MockHistoryRepository_GetMostVisited_Call) RunAndReturn(run func(ctx context.Context, days int) ([]*entity.HistoryEntry, error)) *MockHistoryRepository_GetMostVisited_Call {
2586	_c.Call.Return(run)
2587	return _c
2588}
2589
2590// GetRecent provides a mock function for the type MockHistoryRepository
2591func (_mock *MockHistoryRepository) GetRecent(ctx context.Context, limit int, offset int) ([]*entity.HistoryEntry, error) {
2592	ret := _mock.Called(ctx, limit, offset)
2593
2594	if len(ret) == 0 {
2595		panic("no return value specified for GetRecent")
2596	}
2597
2598	var r0 []*entity.HistoryEntry
2599	var r1 error
2600	if returnFunc, ok := ret.Get(0).(func(context.Context, int, int) ([]*entity.HistoryEntry, error)); ok {
2601		return returnFunc(ctx, limit, offset)
2602	}
2603	if returnFunc, ok := ret.Get(0).(func(context.Context, int, int) []*entity.HistoryEntry); ok {
2604		r0 = returnFunc(ctx, limit, offset)
2605	} else {
2606		if ret.Get(0) != nil {
2607			r0 = ret.Get(0).([]*entity.HistoryEntry)
2608		}
2609	}
2610	if returnFunc, ok := ret.Get(1).(func(context.Context, int, int) error); ok {
2611		r1 = returnFunc(ctx, limit, offset)
2612	} else {
2613		r1 = ret.Error(1)
2614	}
2615	return r0, r1
2616}
2617
2618// MockHistoryRepository_GetRecent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRecent'
2619type MockHistoryRepository_GetRecent_Call struct {
2620	*mock.Call
2621}
2622
2623// GetRecent is a helper method to define mock.On call
2624//   - ctx context.Context
2625//   - limit int
2626//   - offset int
2627func (_e *MockHistoryRepository_Expecter) GetRecent(ctx interface{}, limit interface{}, offset interface{}) *MockHistoryRepository_GetRecent_Call {
2628	return &MockHistoryRepository_GetRecent_Call{Call: _e.mock.On("GetRecent", ctx, limit, offset)}
2629}
2630
2631func (_c *MockHistoryRepository_GetRecent_Call) Run(run func(ctx context.Context, limit int, offset int)) *MockHistoryRepository_GetRecent_Call {
2632	_c.Call.Run(func(args mock.Arguments) {
2633		var arg0 context.Context
2634		if args[0] != nil {
2635			arg0 = args[0].(context.Context)
2636		}
2637		var arg1 int
2638		if args[1] != nil {
2639			arg1 = args[1].(int)
2640		}
2641		var arg2 int
2642		if args[2] != nil {
2643			arg2 = args[2].(int)
2644		}
2645		run(
2646			arg0,
2647			arg1,
2648			arg2,
2649		)
2650	})
2651	return _c
2652}
2653
2654func (_c *MockHistoryRepository_GetRecent_Call) Return(historyEntrys []*entity.HistoryEntry, err error) *MockHistoryRepository_GetRecent_Call {
2655	_c.Call.Return(historyEntrys, err)
2656	return _c
2657}
2658
2659func (_c *MockHistoryRepository_GetRecent_Call) RunAndReturn(run func(ctx context.Context, limit int, offset int) ([]*entity.HistoryEntry, error)) *MockHistoryRepository_GetRecent_Call {
2660	_c.Call.Return(run)
2661	return _c
2662}
2663
2664// GetRecentSince provides a mock function for the type MockHistoryRepository
2665func (_mock *MockHistoryRepository) GetRecentSince(ctx context.Context, days int) ([]*entity.HistoryEntry, error) {
2666	ret := _mock.Called(ctx, days)
2667
2668	if len(ret) == 0 {
2669		panic("no return value specified for GetRecentSince")
2670	}
2671
2672	var r0 []*entity.HistoryEntry
2673	var r1 error
2674	if returnFunc, ok := ret.Get(0).(func(context.Context, int) ([]*entity.HistoryEntry, error)); ok {
2675		return returnFunc(ctx, days)
2676	}
2677	if returnFunc, ok := ret.Get(0).(func(context.Context, int) []*entity.HistoryEntry); ok {
2678		r0 = returnFunc(ctx, days)
2679	} else {
2680		if ret.Get(0) != nil {
2681			r0 = ret.Get(0).([]*entity.HistoryEntry)
2682		}
2683	}
2684	if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
2685		r1 = returnFunc(ctx, days)
2686	} else {
2687		r1 = ret.Error(1)
2688	}
2689	return r0, r1
2690}
2691
2692// MockHistoryRepository_GetRecentSince_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRecentSince'
2693type MockHistoryRepository_GetRecentSince_Call struct {
2694	*mock.Call
2695}
2696
2697// GetRecentSince is a helper method to define mock.On call
2698//   - ctx context.Context
2699//   - days int
2700func (_e *MockHistoryRepository_Expecter) GetRecentSince(ctx interface{}, days interface{}) *MockHistoryRepository_GetRecentSince_Call {
2701	return &MockHistoryRepository_GetRecentSince_Call{Call: _e.mock.On("GetRecentSince", ctx, days)}
2702}
2703
2704func (_c *MockHistoryRepository_GetRecentSince_Call) Run(run func(ctx context.Context, days int)) *MockHistoryRepository_GetRecentSince_Call {
2705	_c.Call.Run(func(args mock.Arguments) {
2706		var arg0 context.Context
2707		if args[0] != nil {
2708			arg0 = args[0].(context.Context)
2709		}
2710		var arg1 int
2711		if args[1] != nil {
2712			arg1 = args[1].(int)
2713		}
2714		run(
2715			arg0,
2716			arg1,
2717		)
2718	})
2719	return _c
2720}
2721
2722func (_c *MockHistoryRepository_GetRecentSince_Call) Return(historyEntrys []*entity.HistoryEntry, err error) *MockHistoryRepository_GetRecentSince_Call {
2723	_c.Call.Return(historyEntrys, err)
2724	return _c
2725}
2726
2727func (_c *MockHistoryRepository_GetRecentSince_Call) RunAndReturn(run func(ctx context.Context, days int) ([]*entity.HistoryEntry, error)) *MockHistoryRepository_GetRecentSince_Call {
2728	_c.Call.Return(run)
2729	return _c
2730}
2731
2732// GetStats provides a mock function for the type MockHistoryRepository
2733func (_mock *MockHistoryRepository) GetStats(ctx context.Context) (*entity.HistoryStats, error) {
2734	ret := _mock.Called(ctx)
2735
2736	if len(ret) == 0 {
2737		panic("no return value specified for GetStats")
2738	}
2739
2740	var r0 *entity.HistoryStats
2741	var r1 error
2742	if returnFunc, ok := ret.Get(0).(func(context.Context) (*entity.HistoryStats, error)); ok {
2743		return returnFunc(ctx)
2744	}
2745	if returnFunc, ok := ret.Get(0).(func(context.Context) *entity.HistoryStats); ok {
2746		r0 = returnFunc(ctx)
2747	} else {
2748		if ret.Get(0) != nil {
2749			r0 = ret.Get(0).(*entity.HistoryStats)
2750		}
2751	}
2752	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
2753		r1 = returnFunc(ctx)
2754	} else {
2755		r1 = ret.Error(1)
2756	}
2757	return r0, r1
2758}
2759
2760// MockHistoryRepository_GetStats_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStats'
2761type MockHistoryRepository_GetStats_Call struct {
2762	*mock.Call
2763}
2764
2765// GetStats is a helper method to define mock.On call
2766//   - ctx context.Context
2767func (_e *MockHistoryRepository_Expecter) GetStats(ctx interface{}) *MockHistoryRepository_GetStats_Call {
2768	return &MockHistoryRepository_GetStats_Call{Call: _e.mock.On("GetStats", ctx)}
2769}
2770
2771func (_c *MockHistoryRepository_GetStats_Call) Run(run func(ctx context.Context)) *MockHistoryRepository_GetStats_Call {
2772	_c.Call.Run(func(args mock.Arguments) {
2773		var arg0 context.Context
2774		if args[0] != nil {
2775			arg0 = args[0].(context.Context)
2776		}
2777		run(
2778			arg0,
2779		)
2780	})
2781	return _c
2782}
2783
2784func (_c *MockHistoryRepository_GetStats_Call) Return(historyStats *entity.HistoryStats, err error) *MockHistoryRepository_GetStats_Call {
2785	_c.Call.Return(historyStats, err)
2786	return _c
2787}
2788
2789func (_c *MockHistoryRepository_GetStats_Call) RunAndReturn(run func(ctx context.Context) (*entity.HistoryStats, error)) *MockHistoryRepository_GetStats_Call {
2790	_c.Call.Return(run)
2791	return _c
2792}
2793
2794// IncrementVisitCount provides a mock function for the type MockHistoryRepository
2795func (_mock *MockHistoryRepository) IncrementVisitCount(ctx context.Context, url string) error {
2796	ret := _mock.Called(ctx, url)
2797
2798	if len(ret) == 0 {
2799		panic("no return value specified for IncrementVisitCount")
2800	}
2801
2802	var r0 error
2803	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
2804		r0 = returnFunc(ctx, url)
2805	} else {
2806		r0 = ret.Error(0)
2807	}
2808	return r0
2809}
2810
2811// MockHistoryRepository_IncrementVisitCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IncrementVisitCount'
2812type MockHistoryRepository_IncrementVisitCount_Call struct {
2813	*mock.Call
2814}
2815
2816// IncrementVisitCount is a helper method to define mock.On call
2817//   - ctx context.Context
2818//   - url string
2819func (_e *MockHistoryRepository_Expecter) IncrementVisitCount(ctx interface{}, url interface{}) *MockHistoryRepository_IncrementVisitCount_Call {
2820	return &MockHistoryRepository_IncrementVisitCount_Call{Call: _e.mock.On("IncrementVisitCount", ctx, url)}
2821}
2822
2823func (_c *MockHistoryRepository_IncrementVisitCount_Call) Run(run func(ctx context.Context, url string)) *MockHistoryRepository_IncrementVisitCount_Call {
2824	_c.Call.Run(func(args mock.Arguments) {
2825		var arg0 context.Context
2826		if args[0] != nil {
2827			arg0 = args[0].(context.Context)
2828		}
2829		var arg1 string
2830		if args[1] != nil {
2831			arg1 = args[1].(string)
2832		}
2833		run(
2834			arg0,
2835			arg1,
2836		)
2837	})
2838	return _c
2839}
2840
2841func (_c *MockHistoryRepository_IncrementVisitCount_Call) Return(err error) *MockHistoryRepository_IncrementVisitCount_Call {
2842	_c.Call.Return(err)
2843	return _c
2844}
2845
2846func (_c *MockHistoryRepository_IncrementVisitCount_Call) RunAndReturn(run func(ctx context.Context, url string) error) *MockHistoryRepository_IncrementVisitCount_Call {
2847	_c.Call.Return(run)
2848	return _c
2849}
2850
2851// Save provides a mock function for the type MockHistoryRepository
2852func (_mock *MockHistoryRepository) Save(ctx context.Context, entry *entity.HistoryEntry) error {
2853	ret := _mock.Called(ctx, entry)
2854
2855	if len(ret) == 0 {
2856		panic("no return value specified for Save")
2857	}
2858
2859	var r0 error
2860	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.HistoryEntry) error); ok {
2861		r0 = returnFunc(ctx, entry)
2862	} else {
2863		r0 = ret.Error(0)
2864	}
2865	return r0
2866}
2867
2868// MockHistoryRepository_Save_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Save'
2869type MockHistoryRepository_Save_Call struct {
2870	*mock.Call
2871}
2872
2873// Save is a helper method to define mock.On call
2874//   - ctx context.Context
2875//   - entry *entity.HistoryEntry
2876func (_e *MockHistoryRepository_Expecter) Save(ctx interface{}, entry interface{}) *MockHistoryRepository_Save_Call {
2877	return &MockHistoryRepository_Save_Call{Call: _e.mock.On("Save", ctx, entry)}
2878}
2879
2880func (_c *MockHistoryRepository_Save_Call) Run(run func(ctx context.Context, entry *entity.HistoryEntry)) *MockHistoryRepository_Save_Call {
2881	_c.Call.Run(func(args mock.Arguments) {
2882		var arg0 context.Context
2883		if args[0] != nil {
2884			arg0 = args[0].(context.Context)
2885		}
2886		var arg1 *entity.HistoryEntry
2887		if args[1] != nil {
2888			arg1 = args[1].(*entity.HistoryEntry)
2889		}
2890		run(
2891			arg0,
2892			arg1,
2893		)
2894	})
2895	return _c
2896}
2897
2898func (_c *MockHistoryRepository_Save_Call) Return(err error) *MockHistoryRepository_Save_Call {
2899	_c.Call.Return(err)
2900	return _c
2901}
2902
2903func (_c *MockHistoryRepository_Save_Call) RunAndReturn(run func(ctx context.Context, entry *entity.HistoryEntry) error) *MockHistoryRepository_Save_Call {
2904	_c.Call.Return(run)
2905	return _c
2906}
2907
2908// Search provides a mock function for the type MockHistoryRepository
2909func (_mock *MockHistoryRepository) Search(ctx context.Context, query string, limit int) ([]entity.HistoryMatch, error) {
2910	ret := _mock.Called(ctx, query, limit)
2911
2912	if len(ret) == 0 {
2913		panic("no return value specified for Search")
2914	}
2915
2916	var r0 []entity.HistoryMatch
2917	var r1 error
2918	if returnFunc, ok := ret.Get(0).(func(context.Context, string, int) ([]entity.HistoryMatch, error)); ok {
2919		return returnFunc(ctx, query, limit)
2920	}
2921	if returnFunc, ok := ret.Get(0).(func(context.Context, string, int) []entity.HistoryMatch); ok {
2922		r0 = returnFunc(ctx, query, limit)
2923	} else {
2924		if ret.Get(0) != nil {
2925			r0 = ret.Get(0).([]entity.HistoryMatch)
2926		}
2927	}
2928	if returnFunc, ok := ret.Get(1).(func(context.Context, string, int) error); ok {
2929		r1 = returnFunc(ctx, query, limit)
2930	} else {
2931		r1 = ret.Error(1)
2932	}
2933	return r0, r1
2934}
2935
2936// MockHistoryRepository_Search_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Search'
2937type MockHistoryRepository_Search_Call struct {
2938	*mock.Call
2939}
2940
2941// Search is a helper method to define mock.On call
2942//   - ctx context.Context
2943//   - query string
2944//   - limit int
2945func (_e *MockHistoryRepository_Expecter) Search(ctx interface{}, query interface{}, limit interface{}) *MockHistoryRepository_Search_Call {
2946	return &MockHistoryRepository_Search_Call{Call: _e.mock.On("Search", ctx, query, limit)}
2947}
2948
2949func (_c *MockHistoryRepository_Search_Call) Run(run func(ctx context.Context, query string, limit int)) *MockHistoryRepository_Search_Call {
2950	_c.Call.Run(func(args mock.Arguments) {
2951		var arg0 context.Context
2952		if args[0] != nil {
2953			arg0 = args[0].(context.Context)
2954		}
2955		var arg1 string
2956		if args[1] != nil {
2957			arg1 = args[1].(string)
2958		}
2959		var arg2 int
2960		if args[2] != nil {
2961			arg2 = args[2].(int)
2962		}
2963		run(
2964			arg0,
2965			arg1,
2966			arg2,
2967		)
2968	})
2969	return _c
2970}
2971
2972func (_c *MockHistoryRepository_Search_Call) Return(historyMatchs []entity.HistoryMatch, err error) *MockHistoryRepository_Search_Call {
2973	_c.Call.Return(historyMatchs, err)
2974	return _c
2975}
2976
2977func (_c *MockHistoryRepository_Search_Call) RunAndReturn(run func(ctx context.Context, query string, limit int) ([]entity.HistoryMatch, error)) *MockHistoryRepository_Search_Call {
2978	_c.Call.Return(run)
2979	return _c
2980}
2981
2982// NewMockPermissionRepository creates a new instance of MockPermissionRepository. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
2983// The first argument is typically a *testing.T value.
2984func NewMockPermissionRepository(t interface {
2985	mock.TestingT
2986	Cleanup(func())
2987}) *MockPermissionRepository {
2988	mock := &MockPermissionRepository{}
2989	mock.Mock.Test(t)
2990
2991	t.Cleanup(func() { mock.AssertExpectations(t) })
2992
2993	return mock
2994}
2995
2996// MockPermissionRepository is an autogenerated mock type for the PermissionRepository type
2997type MockPermissionRepository struct {
2998	mock.Mock
2999}
3000
3001type MockPermissionRepository_Expecter struct {
3002	mock *mock.Mock
3003}
3004
3005func (_m *MockPermissionRepository) EXPECT() *MockPermissionRepository_Expecter {
3006	return &MockPermissionRepository_Expecter{mock: &_m.Mock}
3007}
3008
3009// Delete provides a mock function for the type MockPermissionRepository
3010func (_mock *MockPermissionRepository) Delete(ctx context.Context, origin string, permType entity.PermissionType) error {
3011	ret := _mock.Called(ctx, origin, permType)
3012
3013	if len(ret) == 0 {
3014		panic("no return value specified for Delete")
3015	}
3016
3017	var r0 error
3018	if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.PermissionType) error); ok {
3019		r0 = returnFunc(ctx, origin, permType)
3020	} else {
3021		r0 = ret.Error(0)
3022	}
3023	return r0
3024}
3025
3026// MockPermissionRepository_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
3027type MockPermissionRepository_Delete_Call struct {
3028	*mock.Call
3029}
3030
3031// Delete is a helper method to define mock.On call
3032//   - ctx context.Context
3033//   - origin string
3034//   - permType entity.PermissionType
3035func (_e *MockPermissionRepository_Expecter) Delete(ctx interface{}, origin interface{}, permType interface{}) *MockPermissionRepository_Delete_Call {
3036	return &MockPermissionRepository_Delete_Call{Call: _e.mock.On("Delete", ctx, origin, permType)}
3037}
3038
3039func (_c *MockPermissionRepository_Delete_Call) Run(run func(ctx context.Context, origin string, permType entity.PermissionType)) *MockPermissionRepository_Delete_Call {
3040	_c.Call.Run(func(args mock.Arguments) {
3041		var arg0 context.Context
3042		if args[0] != nil {
3043			arg0 = args[0].(context.Context)
3044		}
3045		var arg1 string
3046		if args[1] != nil {
3047			arg1 = args[1].(string)
3048		}
3049		var arg2 entity.PermissionType
3050		if args[2] != nil {
3051			arg2 = args[2].(entity.PermissionType)
3052		}
3053		run(
3054			arg0,
3055			arg1,
3056			arg2,
3057		)
3058	})
3059	return _c
3060}
3061
3062func (_c *MockPermissionRepository_Delete_Call) Return(err error) *MockPermissionRepository_Delete_Call {
3063	_c.Call.Return(err)
3064	return _c
3065}
3066
3067func (_c *MockPermissionRepository_Delete_Call) RunAndReturn(run func(ctx context.Context, origin string, permType entity.PermissionType) error) *MockPermissionRepository_Delete_Call {
3068	_c.Call.Return(run)
3069	return _c
3070}
3071
3072// Get provides a mock function for the type MockPermissionRepository
3073func (_mock *MockPermissionRepository) Get(ctx context.Context, origin string, permType entity.PermissionType) (*entity.PermissionRecord, error) {
3074	ret := _mock.Called(ctx, origin, permType)
3075
3076	if len(ret) == 0 {
3077		panic("no return value specified for Get")
3078	}
3079
3080	var r0 *entity.PermissionRecord
3081	var r1 error
3082	if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.PermissionType) (*entity.PermissionRecord, error)); ok {
3083		return returnFunc(ctx, origin, permType)
3084	}
3085	if returnFunc, ok := ret.Get(0).(func(context.Context, string, entity.PermissionType) *entity.PermissionRecord); ok {
3086		r0 = returnFunc(ctx, origin, permType)
3087	} else {
3088		if ret.Get(0) != nil {
3089			r0 = ret.Get(0).(*entity.PermissionRecord)
3090		}
3091	}
3092	if returnFunc, ok := ret.Get(1).(func(context.Context, string, entity.PermissionType) error); ok {
3093		r1 = returnFunc(ctx, origin, permType)
3094	} else {
3095		r1 = ret.Error(1)
3096	}
3097	return r0, r1
3098}
3099
3100// MockPermissionRepository_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'
3101type MockPermissionRepository_Get_Call struct {
3102	*mock.Call
3103}
3104
3105// Get is a helper method to define mock.On call
3106//   - ctx context.Context
3107//   - origin string
3108//   - permType entity.PermissionType
3109func (_e *MockPermissionRepository_Expecter) Get(ctx interface{}, origin interface{}, permType interface{}) *MockPermissionRepository_Get_Call {
3110	return &MockPermissionRepository_Get_Call{Call: _e.mock.On("Get", ctx, origin, permType)}
3111}
3112
3113func (_c *MockPermissionRepository_Get_Call) Run(run func(ctx context.Context, origin string, permType entity.PermissionType)) *MockPermissionRepository_Get_Call {
3114	_c.Call.Run(func(args mock.Arguments) {
3115		var arg0 context.Context
3116		if args[0] != nil {
3117			arg0 = args[0].(context.Context)
3118		}
3119		var arg1 string
3120		if args[1] != nil {
3121			arg1 = args[1].(string)
3122		}
3123		var arg2 entity.PermissionType
3124		if args[2] != nil {
3125			arg2 = args[2].(entity.PermissionType)
3126		}
3127		run(
3128			arg0,
3129			arg1,
3130			arg2,
3131		)
3132	})
3133	return _c
3134}
3135
3136func (_c *MockPermissionRepository_Get_Call) Return(permissionRecord *entity.PermissionRecord, err error) *MockPermissionRepository_Get_Call {
3137	_c.Call.Return(permissionRecord, err)
3138	return _c
3139}
3140
3141func (_c *MockPermissionRepository_Get_Call) RunAndReturn(run func(ctx context.Context, origin string, permType entity.PermissionType) (*entity.PermissionRecord, error)) *MockPermissionRepository_Get_Call {
3142	_c.Call.Return(run)
3143	return _c
3144}
3145
3146// GetAll provides a mock function for the type MockPermissionRepository
3147func (_mock *MockPermissionRepository) GetAll(ctx context.Context, origin string) ([]*entity.PermissionRecord, error) {
3148	ret := _mock.Called(ctx, origin)
3149
3150	if len(ret) == 0 {
3151		panic("no return value specified for GetAll")
3152	}
3153
3154	var r0 []*entity.PermissionRecord
3155	var r1 error
3156	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]*entity.PermissionRecord, error)); ok {
3157		return returnFunc(ctx, origin)
3158	}
3159	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []*entity.PermissionRecord); ok {
3160		r0 = returnFunc(ctx, origin)
3161	} else {
3162		if ret.Get(0) != nil {
3163			r0 = ret.Get(0).([]*entity.PermissionRecord)
3164		}
3165	}
3166	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
3167		r1 = returnFunc(ctx, origin)
3168	} else {
3169		r1 = ret.Error(1)
3170	}
3171	return r0, r1
3172}
3173
3174// MockPermissionRepository_GetAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAll'
3175type MockPermissionRepository_GetAll_Call struct {
3176	*mock.Call
3177}
3178
3179// GetAll is a helper method to define mock.On call
3180//   - ctx context.Context
3181//   - origin string
3182func (_e *MockPermissionRepository_Expecter) GetAll(ctx interface{}, origin interface{}) *MockPermissionRepository_GetAll_Call {
3183	return &MockPermissionRepository_GetAll_Call{Call: _e.mock.On("GetAll", ctx, origin)}
3184}
3185
3186func (_c *MockPermissionRepository_GetAll_Call) Run(run func(ctx context.Context, origin string)) *MockPermissionRepository_GetAll_Call {
3187	_c.Call.Run(func(args mock.Arguments) {
3188		var arg0 context.Context
3189		if args[0] != nil {
3190			arg0 = args[0].(context.Context)
3191		}
3192		var arg1 string
3193		if args[1] != nil {
3194			arg1 = args[1].(string)
3195		}
3196		run(
3197			arg0,
3198			arg1,
3199		)
3200	})
3201	return _c
3202}
3203
3204func (_c *MockPermissionRepository_GetAll_Call) Return(permissionRecords []*entity.PermissionRecord, err error) *MockPermissionRepository_GetAll_Call {
3205	_c.Call.Return(permissionRecords, err)
3206	return _c
3207}
3208
3209func (_c *MockPermissionRepository_GetAll_Call) RunAndReturn(run func(ctx context.Context, origin string) ([]*entity.PermissionRecord, error)) *MockPermissionRepository_GetAll_Call {
3210	_c.Call.Return(run)
3211	return _c
3212}
3213
3214// Set provides a mock function for the type MockPermissionRepository
3215func (_mock *MockPermissionRepository) Set(ctx context.Context, record *entity.PermissionRecord) error {
3216	ret := _mock.Called(ctx, record)
3217
3218	if len(ret) == 0 {
3219		panic("no return value specified for Set")
3220	}
3221
3222	var r0 error
3223	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.PermissionRecord) error); ok {
3224		r0 = returnFunc(ctx, record)
3225	} else {
3226		r0 = ret.Error(0)
3227	}
3228	return r0
3229}
3230
3231// MockPermissionRepository_Set_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Set'
3232type MockPermissionRepository_Set_Call struct {
3233	*mock.Call
3234}
3235
3236// Set is a helper method to define mock.On call
3237//   - ctx context.Context
3238//   - record *entity.PermissionRecord
3239func (_e *MockPermissionRepository_Expecter) Set(ctx interface{}, record interface{}) *MockPermissionRepository_Set_Call {
3240	return &MockPermissionRepository_Set_Call{Call: _e.mock.On("Set", ctx, record)}
3241}
3242
3243func (_c *MockPermissionRepository_Set_Call) Run(run func(ctx context.Context, record *entity.PermissionRecord)) *MockPermissionRepository_Set_Call {
3244	_c.Call.Run(func(args mock.Arguments) {
3245		var arg0 context.Context
3246		if args[0] != nil {
3247			arg0 = args[0].(context.Context)
3248		}
3249		var arg1 *entity.PermissionRecord
3250		if args[1] != nil {
3251			arg1 = args[1].(*entity.PermissionRecord)
3252		}
3253		run(
3254			arg0,
3255			arg1,
3256		)
3257	})
3258	return _c
3259}
3260
3261func (_c *MockPermissionRepository_Set_Call) Return(err error) *MockPermissionRepository_Set_Call {
3262	_c.Call.Return(err)
3263	return _c
3264}
3265
3266func (_c *MockPermissionRepository_Set_Call) RunAndReturn(run func(ctx context.Context, record *entity.PermissionRecord) error) *MockPermissionRepository_Set_Call {
3267	_c.Call.Return(run)
3268	return _c
3269}
3270
3271// NewMockSessionRepository creates a new instance of MockSessionRepository. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
3272// The first argument is typically a *testing.T value.
3273func NewMockSessionRepository(t interface {
3274	mock.TestingT
3275	Cleanup(func())
3276}) *MockSessionRepository {
3277	mock := &MockSessionRepository{}
3278	mock.Mock.Test(t)
3279
3280	t.Cleanup(func() { mock.AssertExpectations(t) })
3281
3282	return mock
3283}
3284
3285// MockSessionRepository is an autogenerated mock type for the SessionRepository type
3286type MockSessionRepository struct {
3287	mock.Mock
3288}
3289
3290type MockSessionRepository_Expecter struct {
3291	mock *mock.Mock
3292}
3293
3294func (_m *MockSessionRepository) EXPECT() *MockSessionRepository_Expecter {
3295	return &MockSessionRepository_Expecter{mock: &_m.Mock}
3296}
3297
3298// Delete provides a mock function for the type MockSessionRepository
3299func (_mock *MockSessionRepository) Delete(ctx context.Context, id entity.SessionID) error {
3300	ret := _mock.Called(ctx, id)
3301
3302	if len(ret) == 0 {
3303		panic("no return value specified for Delete")
3304	}
3305
3306	var r0 error
3307	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID) error); ok {
3308		r0 = returnFunc(ctx, id)
3309	} else {
3310		r0 = ret.Error(0)
3311	}
3312	return r0
3313}
3314
3315// MockSessionRepository_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
3316type MockSessionRepository_Delete_Call struct {
3317	*mock.Call
3318}
3319
3320// Delete is a helper method to define mock.On call
3321//   - ctx context.Context
3322//   - id entity.SessionID
3323func (_e *MockSessionRepository_Expecter) Delete(ctx interface{}, id interface{}) *MockSessionRepository_Delete_Call {
3324	return &MockSessionRepository_Delete_Call{Call: _e.mock.On("Delete", ctx, id)}
3325}
3326
3327func (_c *MockSessionRepository_Delete_Call) Run(run func(ctx context.Context, id entity.SessionID)) *MockSessionRepository_Delete_Call {
3328	_c.Call.Run(func(args mock.Arguments) {
3329		var arg0 context.Context
3330		if args[0] != nil {
3331			arg0 = args[0].(context.Context)
3332		}
3333		var arg1 entity.SessionID
3334		if args[1] != nil {
3335			arg1 = args[1].(entity.SessionID)
3336		}
3337		run(
3338			arg0,
3339			arg1,
3340		)
3341	})
3342	return _c
3343}
3344
3345func (_c *MockSessionRepository_Delete_Call) Return(err error) *MockSessionRepository_Delete_Call {
3346	_c.Call.Return(err)
3347	return _c
3348}
3349
3350func (_c *MockSessionRepository_Delete_Call) RunAndReturn(run func(ctx context.Context, id entity.SessionID) error) *MockSessionRepository_Delete_Call {
3351	_c.Call.Return(run)
3352	return _c
3353}
3354
3355// DeleteExitedBefore provides a mock function for the type MockSessionRepository
3356func (_mock *MockSessionRepository) DeleteExitedBefore(ctx context.Context, cutoff time.Time) (int64, error) {
3357	ret := _mock.Called(ctx, cutoff)
3358
3359	if len(ret) == 0 {
3360		panic("no return value specified for DeleteExitedBefore")
3361	}
3362
3363	var r0 int64
3364	var r1 error
3365	if returnFunc, ok := ret.Get(0).(func(context.Context, time.Time) (int64, error)); ok {
3366		return returnFunc(ctx, cutoff)
3367	}
3368	if returnFunc, ok := ret.Get(0).(func(context.Context, time.Time) int64); ok {
3369		r0 = returnFunc(ctx, cutoff)
3370	} else {
3371		r0 = ret.Get(0).(int64)
3372	}
3373	if returnFunc, ok := ret.Get(1).(func(context.Context, time.Time) error); ok {
3374		r1 = returnFunc(ctx, cutoff)
3375	} else {
3376		r1 = ret.Error(1)
3377	}
3378	return r0, r1
3379}
3380
3381// MockSessionRepository_DeleteExitedBefore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteExitedBefore'
3382type MockSessionRepository_DeleteExitedBefore_Call struct {
3383	*mock.Call
3384}
3385
3386// DeleteExitedBefore is a helper method to define mock.On call
3387//   - ctx context.Context
3388//   - cutoff time.Time
3389func (_e *MockSessionRepository_Expecter) DeleteExitedBefore(ctx interface{}, cutoff interface{}) *MockSessionRepository_DeleteExitedBefore_Call {
3390	return &MockSessionRepository_DeleteExitedBefore_Call{Call: _e.mock.On("DeleteExitedBefore", ctx, cutoff)}
3391}
3392
3393func (_c *MockSessionRepository_DeleteExitedBefore_Call) Run(run func(ctx context.Context, cutoff time.Time)) *MockSessionRepository_DeleteExitedBefore_Call {
3394	_c.Call.Run(func(args mock.Arguments) {
3395		var arg0 context.Context
3396		if args[0] != nil {
3397			arg0 = args[0].(context.Context)
3398		}
3399		var arg1 time.Time
3400		if args[1] != nil {
3401			arg1 = args[1].(time.Time)
3402		}
3403		run(
3404			arg0,
3405			arg1,
3406		)
3407	})
3408	return _c
3409}
3410
3411func (_c *MockSessionRepository_DeleteExitedBefore_Call) Return(n int64, err error) *MockSessionRepository_DeleteExitedBefore_Call {
3412	_c.Call.Return(n, err)
3413	return _c
3414}
3415
3416func (_c *MockSessionRepository_DeleteExitedBefore_Call) RunAndReturn(run func(ctx context.Context, cutoff time.Time) (int64, error)) *MockSessionRepository_DeleteExitedBefore_Call {
3417	_c.Call.Return(run)
3418	return _c
3419}
3420
3421// DeleteOldestExited provides a mock function for the type MockSessionRepository
3422func (_mock *MockSessionRepository) DeleteOldestExited(ctx context.Context, keepCount int) (int64, error) {
3423	ret := _mock.Called(ctx, keepCount)
3424
3425	if len(ret) == 0 {
3426		panic("no return value specified for DeleteOldestExited")
3427	}
3428
3429	var r0 int64
3430	var r1 error
3431	if returnFunc, ok := ret.Get(0).(func(context.Context, int) (int64, error)); ok {
3432		return returnFunc(ctx, keepCount)
3433	}
3434	if returnFunc, ok := ret.Get(0).(func(context.Context, int) int64); ok {
3435		r0 = returnFunc(ctx, keepCount)
3436	} else {
3437		r0 = ret.Get(0).(int64)
3438	}
3439	if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
3440		r1 = returnFunc(ctx, keepCount)
3441	} else {
3442		r1 = ret.Error(1)
3443	}
3444	return r0, r1
3445}
3446
3447// MockSessionRepository_DeleteOldestExited_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteOldestExited'
3448type MockSessionRepository_DeleteOldestExited_Call struct {
3449	*mock.Call
3450}
3451
3452// DeleteOldestExited is a helper method to define mock.On call
3453//   - ctx context.Context
3454//   - keepCount int
3455func (_e *MockSessionRepository_Expecter) DeleteOldestExited(ctx interface{}, keepCount interface{}) *MockSessionRepository_DeleteOldestExited_Call {
3456	return &MockSessionRepository_DeleteOldestExited_Call{Call: _e.mock.On("DeleteOldestExited", ctx, keepCount)}
3457}
3458
3459func (_c *MockSessionRepository_DeleteOldestExited_Call) Run(run func(ctx context.Context, keepCount int)) *MockSessionRepository_DeleteOldestExited_Call {
3460	_c.Call.Run(func(args mock.Arguments) {
3461		var arg0 context.Context
3462		if args[0] != nil {
3463			arg0 = args[0].(context.Context)
3464		}
3465		var arg1 int
3466		if args[1] != nil {
3467			arg1 = args[1].(int)
3468		}
3469		run(
3470			arg0,
3471			arg1,
3472		)
3473	})
3474	return _c
3475}
3476
3477func (_c *MockSessionRepository_DeleteOldestExited_Call) Return(n int64, err error) *MockSessionRepository_DeleteOldestExited_Call {
3478	_c.Call.Return(n, err)
3479	return _c
3480}
3481
3482func (_c *MockSessionRepository_DeleteOldestExited_Call) RunAndReturn(run func(ctx context.Context, keepCount int) (int64, error)) *MockSessionRepository_DeleteOldestExited_Call {
3483	_c.Call.Return(run)
3484	return _c
3485}
3486
3487// FindByID provides a mock function for the type MockSessionRepository
3488func (_mock *MockSessionRepository) FindByID(ctx context.Context, id entity.SessionID) (*entity.Session, error) {
3489	ret := _mock.Called(ctx, id)
3490
3491	if len(ret) == 0 {
3492		panic("no return value specified for FindByID")
3493	}
3494
3495	var r0 *entity.Session
3496	var r1 error
3497	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID) (*entity.Session, error)); ok {
3498		return returnFunc(ctx, id)
3499	}
3500	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID) *entity.Session); ok {
3501		r0 = returnFunc(ctx, id)
3502	} else {
3503		if ret.Get(0) != nil {
3504			r0 = ret.Get(0).(*entity.Session)
3505		}
3506	}
3507	if returnFunc, ok := ret.Get(1).(func(context.Context, entity.SessionID) error); ok {
3508		r1 = returnFunc(ctx, id)
3509	} else {
3510		r1 = ret.Error(1)
3511	}
3512	return r0, r1
3513}
3514
3515// MockSessionRepository_FindByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByID'
3516type MockSessionRepository_FindByID_Call struct {
3517	*mock.Call
3518}
3519
3520// FindByID is a helper method to define mock.On call
3521//   - ctx context.Context
3522//   - id entity.SessionID
3523func (_e *MockSessionRepository_Expecter) FindByID(ctx interface{}, id interface{}) *MockSessionRepository_FindByID_Call {
3524	return &MockSessionRepository_FindByID_Call{Call: _e.mock.On("FindByID", ctx, id)}
3525}
3526
3527func (_c *MockSessionRepository_FindByID_Call) Run(run func(ctx context.Context, id entity.SessionID)) *MockSessionRepository_FindByID_Call {
3528	_c.Call.Run(func(args mock.Arguments) {
3529		var arg0 context.Context
3530		if args[0] != nil {
3531			arg0 = args[0].(context.Context)
3532		}
3533		var arg1 entity.SessionID
3534		if args[1] != nil {
3535			arg1 = args[1].(entity.SessionID)
3536		}
3537		run(
3538			arg0,
3539			arg1,
3540		)
3541	})
3542	return _c
3543}
3544
3545func (_c *MockSessionRepository_FindByID_Call) Return(session *entity.Session, err error) *MockSessionRepository_FindByID_Call {
3546	_c.Call.Return(session, err)
3547	return _c
3548}
3549
3550func (_c *MockSessionRepository_FindByID_Call) RunAndReturn(run func(ctx context.Context, id entity.SessionID) (*entity.Session, error)) *MockSessionRepository_FindByID_Call {
3551	_c.Call.Return(run)
3552	return _c
3553}
3554
3555// GetActive provides a mock function for the type MockSessionRepository
3556func (_mock *MockSessionRepository) GetActive(ctx context.Context) (*entity.Session, error) {
3557	ret := _mock.Called(ctx)
3558
3559	if len(ret) == 0 {
3560		panic("no return value specified for GetActive")
3561	}
3562
3563	var r0 *entity.Session
3564	var r1 error
3565	if returnFunc, ok := ret.Get(0).(func(context.Context) (*entity.Session, error)); ok {
3566		return returnFunc(ctx)
3567	}
3568	if returnFunc, ok := ret.Get(0).(func(context.Context) *entity.Session); ok {
3569		r0 = returnFunc(ctx)
3570	} else {
3571		if ret.Get(0) != nil {
3572			r0 = ret.Get(0).(*entity.Session)
3573		}
3574	}
3575	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
3576		r1 = returnFunc(ctx)
3577	} else {
3578		r1 = ret.Error(1)
3579	}
3580	return r0, r1
3581}
3582
3583// MockSessionRepository_GetActive_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetActive'
3584type MockSessionRepository_GetActive_Call struct {
3585	*mock.Call
3586}
3587
3588// GetActive is a helper method to define mock.On call
3589//   - ctx context.Context
3590func (_e *MockSessionRepository_Expecter) GetActive(ctx interface{}) *MockSessionRepository_GetActive_Call {
3591	return &MockSessionRepository_GetActive_Call{Call: _e.mock.On("GetActive", ctx)}
3592}
3593
3594func (_c *MockSessionRepository_GetActive_Call) Run(run func(ctx context.Context)) *MockSessionRepository_GetActive_Call {
3595	_c.Call.Run(func(args mock.Arguments) {
3596		var arg0 context.Context
3597		if args[0] != nil {
3598			arg0 = args[0].(context.Context)
3599		}
3600		run(
3601			arg0,
3602		)
3603	})
3604	return _c
3605}
3606
3607func (_c *MockSessionRepository_GetActive_Call) Return(session *entity.Session, err error) *MockSessionRepository_GetActive_Call {
3608	_c.Call.Return(session, err)
3609	return _c
3610}
3611
3612func (_c *MockSessionRepository_GetActive_Call) RunAndReturn(run func(ctx context.Context) (*entity.Session, error)) *MockSessionRepository_GetActive_Call {
3613	_c.Call.Return(run)
3614	return _c
3615}
3616
3617// GetRecent provides a mock function for the type MockSessionRepository
3618func (_mock *MockSessionRepository) GetRecent(ctx context.Context, limit int) ([]*entity.Session, error) {
3619	ret := _mock.Called(ctx, limit)
3620
3621	if len(ret) == 0 {
3622		panic("no return value specified for GetRecent")
3623	}
3624
3625	var r0 []*entity.Session
3626	var r1 error
3627	if returnFunc, ok := ret.Get(0).(func(context.Context, int) ([]*entity.Session, error)); ok {
3628		return returnFunc(ctx, limit)
3629	}
3630	if returnFunc, ok := ret.Get(0).(func(context.Context, int) []*entity.Session); ok {
3631		r0 = returnFunc(ctx, limit)
3632	} else {
3633		if ret.Get(0) != nil {
3634			r0 = ret.Get(0).([]*entity.Session)
3635		}
3636	}
3637	if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
3638		r1 = returnFunc(ctx, limit)
3639	} else {
3640		r1 = ret.Error(1)
3641	}
3642	return r0, r1
3643}
3644
3645// MockSessionRepository_GetRecent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRecent'
3646type MockSessionRepository_GetRecent_Call struct {
3647	*mock.Call
3648}
3649
3650// GetRecent is a helper method to define mock.On call
3651//   - ctx context.Context
3652//   - limit int
3653func (_e *MockSessionRepository_Expecter) GetRecent(ctx interface{}, limit interface{}) *MockSessionRepository_GetRecent_Call {
3654	return &MockSessionRepository_GetRecent_Call{Call: _e.mock.On("GetRecent", ctx, limit)}
3655}
3656
3657func (_c *MockSessionRepository_GetRecent_Call) Run(run func(ctx context.Context, limit int)) *MockSessionRepository_GetRecent_Call {
3658	_c.Call.Run(func(args mock.Arguments) {
3659		var arg0 context.Context
3660		if args[0] != nil {
3661			arg0 = args[0].(context.Context)
3662		}
3663		var arg1 int
3664		if args[1] != nil {
3665			arg1 = args[1].(int)
3666		}
3667		run(
3668			arg0,
3669			arg1,
3670		)
3671	})
3672	return _c
3673}
3674
3675func (_c *MockSessionRepository_GetRecent_Call) Return(sessions []*entity.Session, err error) *MockSessionRepository_GetRecent_Call {
3676	_c.Call.Return(sessions, err)
3677	return _c
3678}
3679
3680func (_c *MockSessionRepository_GetRecent_Call) RunAndReturn(run func(ctx context.Context, limit int) ([]*entity.Session, error)) *MockSessionRepository_GetRecent_Call {
3681	_c.Call.Return(run)
3682	return _c
3683}
3684
3685// MarkEnded provides a mock function for the type MockSessionRepository
3686func (_mock *MockSessionRepository) MarkEnded(ctx context.Context, id entity.SessionID, endedAt time.Time) error {
3687	ret := _mock.Called(ctx, id, endedAt)
3688
3689	if len(ret) == 0 {
3690		panic("no return value specified for MarkEnded")
3691	}
3692
3693	var r0 error
3694	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID, time.Time) error); ok {
3695		r0 = returnFunc(ctx, id, endedAt)
3696	} else {
3697		r0 = ret.Error(0)
3698	}
3699	return r0
3700}
3701
3702// MockSessionRepository_MarkEnded_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MarkEnded'
3703type MockSessionRepository_MarkEnded_Call struct {
3704	*mock.Call
3705}
3706
3707// MarkEnded is a helper method to define mock.On call
3708//   - ctx context.Context
3709//   - id entity.SessionID
3710//   - endedAt time.Time
3711func (_e *MockSessionRepository_Expecter) MarkEnded(ctx interface{}, id interface{}, endedAt interface{}) *MockSessionRepository_MarkEnded_Call {
3712	return &MockSessionRepository_MarkEnded_Call{Call: _e.mock.On("MarkEnded", ctx, id, endedAt)}
3713}
3714
3715func (_c *MockSessionRepository_MarkEnded_Call) Run(run func(ctx context.Context, id entity.SessionID, endedAt time.Time)) *MockSessionRepository_MarkEnded_Call {
3716	_c.Call.Run(func(args mock.Arguments) {
3717		var arg0 context.Context
3718		if args[0] != nil {
3719			arg0 = args[0].(context.Context)
3720		}
3721		var arg1 entity.SessionID
3722		if args[1] != nil {
3723			arg1 = args[1].(entity.SessionID)
3724		}
3725		var arg2 time.Time
3726		if args[2] != nil {
3727			arg2 = args[2].(time.Time)
3728		}
3729		run(
3730			arg0,
3731			arg1,
3732			arg2,
3733		)
3734	})
3735	return _c
3736}
3737
3738func (_c *MockSessionRepository_MarkEnded_Call) Return(err error) *MockSessionRepository_MarkEnded_Call {
3739	_c.Call.Return(err)
3740	return _c
3741}
3742
3743func (_c *MockSessionRepository_MarkEnded_Call) RunAndReturn(run func(ctx context.Context, id entity.SessionID, endedAt time.Time) error) *MockSessionRepository_MarkEnded_Call {
3744	_c.Call.Return(run)
3745	return _c
3746}
3747
3748// Save provides a mock function for the type MockSessionRepository
3749func (_mock *MockSessionRepository) Save(ctx context.Context, session *entity.Session) error {
3750	ret := _mock.Called(ctx, session)
3751
3752	if len(ret) == 0 {
3753		panic("no return value specified for Save")
3754	}
3755
3756	var r0 error
3757	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.Session) error); ok {
3758		r0 = returnFunc(ctx, session)
3759	} else {
3760		r0 = ret.Error(0)
3761	}
3762	return r0
3763}
3764
3765// MockSessionRepository_Save_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Save'
3766type MockSessionRepository_Save_Call struct {
3767	*mock.Call
3768}
3769
3770// Save is a helper method to define mock.On call
3771//   - ctx context.Context
3772//   - session *entity.Session
3773func (_e *MockSessionRepository_Expecter) Save(ctx interface{}, session interface{}) *MockSessionRepository_Save_Call {
3774	return &MockSessionRepository_Save_Call{Call: _e.mock.On("Save", ctx, session)}
3775}
3776
3777func (_c *MockSessionRepository_Save_Call) Run(run func(ctx context.Context, session *entity.Session)) *MockSessionRepository_Save_Call {
3778	_c.Call.Run(func(args mock.Arguments) {
3779		var arg0 context.Context
3780		if args[0] != nil {
3781			arg0 = args[0].(context.Context)
3782		}
3783		var arg1 *entity.Session
3784		if args[1] != nil {
3785			arg1 = args[1].(*entity.Session)
3786		}
3787		run(
3788			arg0,
3789			arg1,
3790		)
3791	})
3792	return _c
3793}
3794
3795func (_c *MockSessionRepository_Save_Call) Return(err error) *MockSessionRepository_Save_Call {
3796	_c.Call.Return(err)
3797	return _c
3798}
3799
3800func (_c *MockSessionRepository_Save_Call) RunAndReturn(run func(ctx context.Context, session *entity.Session) error) *MockSessionRepository_Save_Call {
3801	_c.Call.Return(run)
3802	return _c
3803}
3804
3805// NewMockSessionStateRepository creates a new instance of MockSessionStateRepository. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
3806// The first argument is typically a *testing.T value.
3807func NewMockSessionStateRepository(t interface {
3808	mock.TestingT
3809	Cleanup(func())
3810}) *MockSessionStateRepository {
3811	mock := &MockSessionStateRepository{}
3812	mock.Mock.Test(t)
3813
3814	t.Cleanup(func() { mock.AssertExpectations(t) })
3815
3816	return mock
3817}
3818
3819// MockSessionStateRepository is an autogenerated mock type for the SessionStateRepository type
3820type MockSessionStateRepository struct {
3821	mock.Mock
3822}
3823
3824type MockSessionStateRepository_Expecter struct {
3825	mock *mock.Mock
3826}
3827
3828func (_m *MockSessionStateRepository) EXPECT() *MockSessionStateRepository_Expecter {
3829	return &MockSessionStateRepository_Expecter{mock: &_m.Mock}
3830}
3831
3832// DeleteSnapshot provides a mock function for the type MockSessionStateRepository
3833func (_mock *MockSessionStateRepository) DeleteSnapshot(ctx context.Context, sessionID entity.SessionID) error {
3834	ret := _mock.Called(ctx, sessionID)
3835
3836	if len(ret) == 0 {
3837		panic("no return value specified for DeleteSnapshot")
3838	}
3839
3840	var r0 error
3841	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID) error); ok {
3842		r0 = returnFunc(ctx, sessionID)
3843	} else {
3844		r0 = ret.Error(0)
3845	}
3846	return r0
3847}
3848
3849// MockSessionStateRepository_DeleteSnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteSnapshot'
3850type MockSessionStateRepository_DeleteSnapshot_Call struct {
3851	*mock.Call
3852}
3853
3854// DeleteSnapshot is a helper method to define mock.On call
3855//   - ctx context.Context
3856//   - sessionID entity.SessionID
3857func (_e *MockSessionStateRepository_Expecter) DeleteSnapshot(ctx interface{}, sessionID interface{}) *MockSessionStateRepository_DeleteSnapshot_Call {
3858	return &MockSessionStateRepository_DeleteSnapshot_Call{Call: _e.mock.On("DeleteSnapshot", ctx, sessionID)}
3859}
3860
3861func (_c *MockSessionStateRepository_DeleteSnapshot_Call) Run(run func(ctx context.Context, sessionID entity.SessionID)) *MockSessionStateRepository_DeleteSnapshot_Call {
3862	_c.Call.Run(func(args mock.Arguments) {
3863		var arg0 context.Context
3864		if args[0] != nil {
3865			arg0 = args[0].(context.Context)
3866		}
3867		var arg1 entity.SessionID
3868		if args[1] != nil {
3869			arg1 = args[1].(entity.SessionID)
3870		}
3871		run(
3872			arg0,
3873			arg1,
3874		)
3875	})
3876	return _c
3877}
3878
3879func (_c *MockSessionStateRepository_DeleteSnapshot_Call) Return(err error) *MockSessionStateRepository_DeleteSnapshot_Call {
3880	_c.Call.Return(err)
3881	return _c
3882}
3883
3884func (_c *MockSessionStateRepository_DeleteSnapshot_Call) RunAndReturn(run func(ctx context.Context, sessionID entity.SessionID) error) *MockSessionStateRepository_DeleteSnapshot_Call {
3885	_c.Call.Return(run)
3886	return _c
3887}
3888
3889// GetAllSnapshots provides a mock function for the type MockSessionStateRepository
3890func (_mock *MockSessionStateRepository) GetAllSnapshots(ctx context.Context) ([]*entity.SessionState, error) {
3891	ret := _mock.Called(ctx)
3892
3893	if len(ret) == 0 {
3894		panic("no return value specified for GetAllSnapshots")
3895	}
3896
3897	var r0 []*entity.SessionState
3898	var r1 error
3899	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*entity.SessionState, error)); ok {
3900		return returnFunc(ctx)
3901	}
3902	if returnFunc, ok := ret.Get(0).(func(context.Context) []*entity.SessionState); ok {
3903		r0 = returnFunc(ctx)
3904	} else {
3905		if ret.Get(0) != nil {
3906			r0 = ret.Get(0).([]*entity.SessionState)
3907		}
3908	}
3909	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
3910		r1 = returnFunc(ctx)
3911	} else {
3912		r1 = ret.Error(1)
3913	}
3914	return r0, r1
3915}
3916
3917// MockSessionStateRepository_GetAllSnapshots_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllSnapshots'
3918type MockSessionStateRepository_GetAllSnapshots_Call struct {
3919	*mock.Call
3920}
3921
3922// GetAllSnapshots is a helper method to define mock.On call
3923//   - ctx context.Context
3924func (_e *MockSessionStateRepository_Expecter) GetAllSnapshots(ctx interface{}) *MockSessionStateRepository_GetAllSnapshots_Call {
3925	return &MockSessionStateRepository_GetAllSnapshots_Call{Call: _e.mock.On("GetAllSnapshots", ctx)}
3926}
3927
3928func (_c *MockSessionStateRepository_GetAllSnapshots_Call) Run(run func(ctx context.Context)) *MockSessionStateRepository_GetAllSnapshots_Call {
3929	_c.Call.Run(func(args mock.Arguments) {
3930		var arg0 context.Context
3931		if args[0] != nil {
3932			arg0 = args[0].(context.Context)
3933		}
3934		run(
3935			arg0,
3936		)
3937	})
3938	return _c
3939}
3940
3941func (_c *MockSessionStateRepository_GetAllSnapshots_Call) Return(sessionStates []*entity.SessionState, err error) *MockSessionStateRepository_GetAllSnapshots_Call {
3942	_c.Call.Return(sessionStates, err)
3943	return _c
3944}
3945
3946func (_c *MockSessionStateRepository_GetAllSnapshots_Call) RunAndReturn(run func(ctx context.Context) ([]*entity.SessionState, error)) *MockSessionStateRepository_GetAllSnapshots_Call {
3947	_c.Call.Return(run)
3948	return _c
3949}
3950
3951// GetSnapshot provides a mock function for the type MockSessionStateRepository
3952func (_mock *MockSessionStateRepository) GetSnapshot(ctx context.Context, sessionID entity.SessionID) (*entity.SessionState, error) {
3953	ret := _mock.Called(ctx, sessionID)
3954
3955	if len(ret) == 0 {
3956		panic("no return value specified for GetSnapshot")
3957	}
3958
3959	var r0 *entity.SessionState
3960	var r1 error
3961	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID) (*entity.SessionState, error)); ok {
3962		return returnFunc(ctx, sessionID)
3963	}
3964	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID) *entity.SessionState); ok {
3965		r0 = returnFunc(ctx, sessionID)
3966	} else {
3967		if ret.Get(0) != nil {
3968			r0 = ret.Get(0).(*entity.SessionState)
3969		}
3970	}
3971	if returnFunc, ok := ret.Get(1).(func(context.Context, entity.SessionID) error); ok {
3972		r1 = returnFunc(ctx, sessionID)
3973	} else {
3974		r1 = ret.Error(1)
3975	}
3976	return r0, r1
3977}
3978
3979// MockSessionStateRepository_GetSnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSnapshot'
3980type MockSessionStateRepository_GetSnapshot_Call struct {
3981	*mock.Call
3982}
3983
3984// GetSnapshot is a helper method to define mock.On call
3985//   - ctx context.Context
3986//   - sessionID entity.SessionID
3987func (_e *MockSessionStateRepository_Expecter) GetSnapshot(ctx interface{}, sessionID interface{}) *MockSessionStateRepository_GetSnapshot_Call {
3988	return &MockSessionStateRepository_GetSnapshot_Call{Call: _e.mock.On("GetSnapshot", ctx, sessionID)}
3989}
3990
3991func (_c *MockSessionStateRepository_GetSnapshot_Call) Run(run func(ctx context.Context, sessionID entity.SessionID)) *MockSessionStateRepository_GetSnapshot_Call {
3992	_c.Call.Run(func(args mock.Arguments) {
3993		var arg0 context.Context
3994		if args[0] != nil {
3995			arg0 = args[0].(context.Context)
3996		}
3997		var arg1 entity.SessionID
3998		if args[1] != nil {
3999			arg1 = args[1].(entity.SessionID)
4000		}
4001		run(
4002			arg0,
4003			arg1,
4004		)
4005	})
4006	return _c
4007}
4008
4009func (_c *MockSessionStateRepository_GetSnapshot_Call) Return(sessionState *entity.SessionState, err error) *MockSessionStateRepository_GetSnapshot_Call {
4010	_c.Call.Return(sessionState, err)
4011	return _c
4012}
4013
4014func (_c *MockSessionStateRepository_GetSnapshot_Call) RunAndReturn(run func(ctx context.Context, sessionID entity.SessionID) (*entity.SessionState, error)) *MockSessionStateRepository_GetSnapshot_Call {
4015	_c.Call.Return(run)
4016	return _c
4017}
4018
4019// GetTotalSnapshotsSize provides a mock function for the type MockSessionStateRepository
4020func (_mock *MockSessionStateRepository) GetTotalSnapshotsSize(ctx context.Context) (int64, error) {
4021	ret := _mock.Called(ctx)
4022
4023	if len(ret) == 0 {
4024		panic("no return value specified for GetTotalSnapshotsSize")
4025	}
4026
4027	var r0 int64
4028	var r1 error
4029	if returnFunc, ok := ret.Get(0).(func(context.Context) (int64, error)); ok {
4030		return returnFunc(ctx)
4031	}
4032	if returnFunc, ok := ret.Get(0).(func(context.Context) int64); ok {
4033		r0 = returnFunc(ctx)
4034	} else {
4035		r0 = ret.Get(0).(int64)
4036	}
4037	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
4038		r1 = returnFunc(ctx)
4039	} else {
4040		r1 = ret.Error(1)
4041	}
4042	return r0, r1
4043}
4044
4045// MockSessionStateRepository_GetTotalSnapshotsSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTotalSnapshotsSize'
4046type MockSessionStateRepository_GetTotalSnapshotsSize_Call struct {
4047	*mock.Call
4048}
4049
4050// GetTotalSnapshotsSize is a helper method to define mock.On call
4051//   - ctx context.Context
4052func (_e *MockSessionStateRepository_Expecter) GetTotalSnapshotsSize(ctx interface{}) *MockSessionStateRepository_GetTotalSnapshotsSize_Call {
4053	return &MockSessionStateRepository_GetTotalSnapshotsSize_Call{Call: _e.mock.On("GetTotalSnapshotsSize", ctx)}
4054}
4055
4056func (_c *MockSessionStateRepository_GetTotalSnapshotsSize_Call) Run(run func(ctx context.Context)) *MockSessionStateRepository_GetTotalSnapshotsSize_Call {
4057	_c.Call.Run(func(args mock.Arguments) {
4058		var arg0 context.Context
4059		if args[0] != nil {
4060			arg0 = args[0].(context.Context)
4061		}
4062		run(
4063			arg0,
4064		)
4065	})
4066	return _c
4067}
4068
4069func (_c *MockSessionStateRepository_GetTotalSnapshotsSize_Call) Return(n int64, err error) *MockSessionStateRepository_GetTotalSnapshotsSize_Call {
4070	_c.Call.Return(n, err)
4071	return _c
4072}
4073
4074func (_c *MockSessionStateRepository_GetTotalSnapshotsSize_Call) RunAndReturn(run func(ctx context.Context) (int64, error)) *MockSessionStateRepository_GetTotalSnapshotsSize_Call {
4075	_c.Call.Return(run)
4076	return _c
4077}
4078
4079// SaveSnapshot provides a mock function for the type MockSessionStateRepository
4080func (_mock *MockSessionStateRepository) SaveSnapshot(ctx context.Context, state *entity.SessionState) error {
4081	ret := _mock.Called(ctx, state)
4082
4083	if len(ret) == 0 {
4084		panic("no return value specified for SaveSnapshot")
4085	}
4086
4087	var r0 error
4088	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.SessionState) error); ok {
4089		r0 = returnFunc(ctx, state)
4090	} else {
4091		r0 = ret.Error(0)
4092	}
4093	return r0
4094}
4095
4096// MockSessionStateRepository_SaveSnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveSnapshot'
4097type MockSessionStateRepository_SaveSnapshot_Call struct {
4098	*mock.Call
4099}
4100
4101// SaveSnapshot is a helper method to define mock.On call
4102//   - ctx context.Context
4103//   - state *entity.SessionState
4104func (_e *MockSessionStateRepository_Expecter) SaveSnapshot(ctx interface{}, state interface{}) *MockSessionStateRepository_SaveSnapshot_Call {
4105	return &MockSessionStateRepository_SaveSnapshot_Call{Call: _e.mock.On("SaveSnapshot", ctx, state)}
4106}
4107
4108func (_c *MockSessionStateRepository_SaveSnapshot_Call) Run(run func(ctx context.Context, state *entity.SessionState)) *MockSessionStateRepository_SaveSnapshot_Call {
4109	_c.Call.Run(func(args mock.Arguments) {
4110		var arg0 context.Context
4111		if args[0] != nil {
4112			arg0 = args[0].(context.Context)
4113		}
4114		var arg1 *entity.SessionState
4115		if args[1] != nil {
4116			arg1 = args[1].(*entity.SessionState)
4117		}
4118		run(
4119			arg0,
4120			arg1,
4121		)
4122	})
4123	return _c
4124}
4125
4126func (_c *MockSessionStateRepository_SaveSnapshot_Call) Return(err error) *MockSessionStateRepository_SaveSnapshot_Call {
4127	_c.Call.Return(err)
4128	return _c
4129}
4130
4131func (_c *MockSessionStateRepository_SaveSnapshot_Call) RunAndReturn(run func(ctx context.Context, state *entity.SessionState) error) *MockSessionStateRepository_SaveSnapshot_Call {
4132	_c.Call.Return(run)
4133	return _c
4134}
4135
4136// NewMockZoomRepository creates a new instance of MockZoomRepository. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
4137// The first argument is typically a *testing.T value.
4138func NewMockZoomRepository(t interface {
4139	mock.TestingT
4140	Cleanup(func())
4141}) *MockZoomRepository {
4142	mock := &MockZoomRepository{}
4143	mock.Mock.Test(t)
4144
4145	t.Cleanup(func() { mock.AssertExpectations(t) })
4146
4147	return mock
4148}
4149
4150// MockZoomRepository is an autogenerated mock type for the ZoomRepository type
4151type MockZoomRepository struct {
4152	mock.Mock
4153}
4154
4155type MockZoomRepository_Expecter struct {
4156	mock *mock.Mock
4157}
4158
4159func (_m *MockZoomRepository) EXPECT() *MockZoomRepository_Expecter {
4160	return &MockZoomRepository_Expecter{mock: &_m.Mock}
4161}
4162
4163// Delete provides a mock function for the type MockZoomRepository
4164func (_mock *MockZoomRepository) Delete(ctx context.Context, domain string) error {
4165	ret := _mock.Called(ctx, domain)
4166
4167	if len(ret) == 0 {
4168		panic("no return value specified for Delete")
4169	}
4170
4171	var r0 error
4172	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
4173		r0 = returnFunc(ctx, domain)
4174	} else {
4175		r0 = ret.Error(0)
4176	}
4177	return r0
4178}
4179
4180// MockZoomRepository_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
4181type MockZoomRepository_Delete_Call struct {
4182	*mock.Call
4183}
4184
4185// Delete is a helper method to define mock.On call
4186//   - ctx context.Context
4187//   - domain string
4188func (_e *MockZoomRepository_Expecter) Delete(ctx interface{}, domain interface{}) *MockZoomRepository_Delete_Call {
4189	return &MockZoomRepository_Delete_Call{Call: _e.mock.On("Delete", ctx, domain)}
4190}
4191
4192func (_c *MockZoomRepository_Delete_Call) Run(run func(ctx context.Context, domain string)) *MockZoomRepository_Delete_Call {
4193	_c.Call.Run(func(args mock.Arguments) {
4194		var arg0 context.Context
4195		if args[0] != nil {
4196			arg0 = args[0].(context.Context)
4197		}
4198		var arg1 string
4199		if args[1] != nil {
4200			arg1 = args[1].(string)
4201		}
4202		run(
4203			arg0,
4204			arg1,
4205		)
4206	})
4207	return _c
4208}
4209
4210func (_c *MockZoomRepository_Delete_Call) Return(err error) *MockZoomRepository_Delete_Call {
4211	_c.Call.Return(err)
4212	return _c
4213}
4214
4215func (_c *MockZoomRepository_Delete_Call) RunAndReturn(run func(ctx context.Context, domain string) error) *MockZoomRepository_Delete_Call {
4216	_c.Call.Return(run)
4217	return _c
4218}
4219
4220// Get provides a mock function for the type MockZoomRepository
4221func (_mock *MockZoomRepository) Get(ctx context.Context, domain string) (*entity.ZoomLevel, error) {
4222	ret := _mock.Called(ctx, domain)
4223
4224	if len(ret) == 0 {
4225		panic("no return value specified for Get")
4226	}
4227
4228	var r0 *entity.ZoomLevel
4229	var r1 error
4230	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*entity.ZoomLevel, error)); ok {
4231		return returnFunc(ctx, domain)
4232	}
4233	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *entity.ZoomLevel); ok {
4234		r0 = returnFunc(ctx, domain)
4235	} else {
4236		if ret.Get(0) != nil {
4237			r0 = ret.Get(0).(*entity.ZoomLevel)
4238		}
4239	}
4240	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
4241		r1 = returnFunc(ctx, domain)
4242	} else {
4243		r1 = ret.Error(1)
4244	}
4245	return r0, r1
4246}
4247
4248// MockZoomRepository_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'
4249type MockZoomRepository_Get_Call struct {
4250	*mock.Call
4251}
4252
4253// Get is a helper method to define mock.On call
4254//   - ctx context.Context
4255//   - domain string
4256func (_e *MockZoomRepository_Expecter) Get(ctx interface{}, domain interface{}) *MockZoomRepository_Get_Call {
4257	return &MockZoomRepository_Get_Call{Call: _e.mock.On("Get", ctx, domain)}
4258}
4259
4260func (_c *MockZoomRepository_Get_Call) Run(run func(ctx context.Context, domain string)) *MockZoomRepository_Get_Call {
4261	_c.Call.Run(func(args mock.Arguments) {
4262		var arg0 context.Context
4263		if args[0] != nil {
4264			arg0 = args[0].(context.Context)
4265		}
4266		var arg1 string
4267		if args[1] != nil {
4268			arg1 = args[1].(string)
4269		}
4270		run(
4271			arg0,
4272			arg1,
4273		)
4274	})
4275	return _c
4276}
4277
4278func (_c *MockZoomRepository_Get_Call) Return(zoomLevel *entity.ZoomLevel, err error) *MockZoomRepository_Get_Call {
4279	_c.Call.Return(zoomLevel, err)
4280	return _c
4281}
4282
4283func (_c *MockZoomRepository_Get_Call) RunAndReturn(run func(ctx context.Context, domain string) (*entity.ZoomLevel, error)) *MockZoomRepository_Get_Call {
4284	_c.Call.Return(run)
4285	return _c
4286}
4287
4288// GetAll provides a mock function for the type MockZoomRepository
4289func (_mock *MockZoomRepository) GetAll(ctx context.Context) ([]*entity.ZoomLevel, error) {
4290	ret := _mock.Called(ctx)
4291
4292	if len(ret) == 0 {
4293		panic("no return value specified for GetAll")
4294	}
4295
4296	var r0 []*entity.ZoomLevel
4297	var r1 error
4298	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*entity.ZoomLevel, error)); ok {
4299		return returnFunc(ctx)
4300	}
4301	if returnFunc, ok := ret.Get(0).(func(context.Context) []*entity.ZoomLevel); ok {
4302		r0 = returnFunc(ctx)
4303	} else {
4304		if ret.Get(0) != nil {
4305			r0 = ret.Get(0).([]*entity.ZoomLevel)
4306		}
4307	}
4308	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
4309		r1 = returnFunc(ctx)
4310	} else {
4311		r1 = ret.Error(1)
4312	}
4313	return r0, r1
4314}
4315
4316// MockZoomRepository_GetAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAll'
4317type MockZoomRepository_GetAll_Call struct {
4318	*mock.Call
4319}
4320
4321// GetAll is a helper method to define mock.On call
4322//   - ctx context.Context
4323func (_e *MockZoomRepository_Expecter) GetAll(ctx interface{}) *MockZoomRepository_GetAll_Call {
4324	return &MockZoomRepository_GetAll_Call{Call: _e.mock.On("GetAll", ctx)}
4325}
4326
4327func (_c *MockZoomRepository_GetAll_Call) Run(run func(ctx context.Context)) *MockZoomRepository_GetAll_Call {
4328	_c.Call.Run(func(args mock.Arguments) {
4329		var arg0 context.Context
4330		if args[0] != nil {
4331			arg0 = args[0].(context.Context)
4332		}
4333		run(
4334			arg0,
4335		)
4336	})
4337	return _c
4338}
4339
4340func (_c *MockZoomRepository_GetAll_Call) Return(zoomLevels []*entity.ZoomLevel, err error) *MockZoomRepository_GetAll_Call {
4341	_c.Call.Return(zoomLevels, err)
4342	return _c
4343}
4344
4345func (_c *MockZoomRepository_GetAll_Call) RunAndReturn(run func(ctx context.Context) ([]*entity.ZoomLevel, error)) *MockZoomRepository_GetAll_Call {
4346	_c.Call.Return(run)
4347	return _c
4348}
4349
4350// Set provides a mock function for the type MockZoomRepository
4351func (_mock *MockZoomRepository) Set(ctx context.Context, level *entity.ZoomLevel) error {
4352	ret := _mock.Called(ctx, level)
4353
4354	if len(ret) == 0 {
4355		panic("no return value specified for Set")
4356	}
4357
4358	var r0 error
4359	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.ZoomLevel) error); ok {
4360		r0 = returnFunc(ctx, level)
4361	} else {
4362		r0 = ret.Error(0)
4363	}
4364	return r0
4365}
4366
4367// MockZoomRepository_Set_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Set'
4368type MockZoomRepository_Set_Call struct {
4369	*mock.Call
4370}
4371
4372// Set is a helper method to define mock.On call
4373//   - ctx context.Context
4374//   - level *entity.ZoomLevel
4375func (_e *MockZoomRepository_Expecter) Set(ctx interface{}, level interface{}) *MockZoomRepository_Set_Call {
4376	return &MockZoomRepository_Set_Call{Call: _e.mock.On("Set", ctx, level)}
4377}
4378
4379func (_c *MockZoomRepository_Set_Call) Run(run func(ctx context.Context, level *entity.ZoomLevel)) *MockZoomRepository_Set_Call {
4380	_c.Call.Run(func(args mock.Arguments) {
4381		var arg0 context.Context
4382		if args[0] != nil {
4383			arg0 = args[0].(context.Context)
4384		}
4385		var arg1 *entity.ZoomLevel
4386		if args[1] != nil {
4387			arg1 = args[1].(*entity.ZoomLevel)
4388		}
4389		run(
4390			arg0,
4391			arg1,
4392		)
4393	})
4394	return _c
4395}
4396
4397func (_c *MockZoomRepository_Set_Call) Return(err error) *MockZoomRepository_Set_Call {
4398	_c.Call.Return(err)
4399	return _c
4400}
4401
4402func (_c *MockZoomRepository_Set_Call) RunAndReturn(run func(ctx context.Context, level *entity.ZoomLevel) error) *MockZoomRepository_Set_Call {
4403	_c.Call.Return(run)
4404	return _c
4405}