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// 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.
2983// The first argument is typically a *testing.T value.
2984func NewMockSessionRepository(t interface {
2985	mock.TestingT
2986	Cleanup(func())
2987}) *MockSessionRepository {
2988	mock := &MockSessionRepository{}
2989	mock.Mock.Test(t)
2990
2991	t.Cleanup(func() { mock.AssertExpectations(t) })
2992
2993	return mock
2994}
2995
2996// MockSessionRepository is an autogenerated mock type for the SessionRepository type
2997type MockSessionRepository struct {
2998	mock.Mock
2999}
3000
3001type MockSessionRepository_Expecter struct {
3002	mock *mock.Mock
3003}
3004
3005func (_m *MockSessionRepository) EXPECT() *MockSessionRepository_Expecter {
3006	return &MockSessionRepository_Expecter{mock: &_m.Mock}
3007}
3008
3009// Delete provides a mock function for the type MockSessionRepository
3010func (_mock *MockSessionRepository) Delete(ctx context.Context, id entity.SessionID) error {
3011	ret := _mock.Called(ctx, id)
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, entity.SessionID) error); ok {
3019		r0 = returnFunc(ctx, id)
3020	} else {
3021		r0 = ret.Error(0)
3022	}
3023	return r0
3024}
3025
3026// MockSessionRepository_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
3027type MockSessionRepository_Delete_Call struct {
3028	*mock.Call
3029}
3030
3031// Delete is a helper method to define mock.On call
3032//   - ctx context.Context
3033//   - id entity.SessionID
3034func (_e *MockSessionRepository_Expecter) Delete(ctx interface{}, id interface{}) *MockSessionRepository_Delete_Call {
3035	return &MockSessionRepository_Delete_Call{Call: _e.mock.On("Delete", ctx, id)}
3036}
3037
3038func (_c *MockSessionRepository_Delete_Call) Run(run func(ctx context.Context, id entity.SessionID)) *MockSessionRepository_Delete_Call {
3039	_c.Call.Run(func(args mock.Arguments) {
3040		var arg0 context.Context
3041		if args[0] != nil {
3042			arg0 = args[0].(context.Context)
3043		}
3044		var arg1 entity.SessionID
3045		if args[1] != nil {
3046			arg1 = args[1].(entity.SessionID)
3047		}
3048		run(
3049			arg0,
3050			arg1,
3051		)
3052	})
3053	return _c
3054}
3055
3056func (_c *MockSessionRepository_Delete_Call) Return(err error) *MockSessionRepository_Delete_Call {
3057	_c.Call.Return(err)
3058	return _c
3059}
3060
3061func (_c *MockSessionRepository_Delete_Call) RunAndReturn(run func(ctx context.Context, id entity.SessionID) error) *MockSessionRepository_Delete_Call {
3062	_c.Call.Return(run)
3063	return _c
3064}
3065
3066// DeleteExitedBefore provides a mock function for the type MockSessionRepository
3067func (_mock *MockSessionRepository) DeleteExitedBefore(ctx context.Context, cutoff time.Time) (int64, error) {
3068	ret := _mock.Called(ctx, cutoff)
3069
3070	if len(ret) == 0 {
3071		panic("no return value specified for DeleteExitedBefore")
3072	}
3073
3074	var r0 int64
3075	var r1 error
3076	if returnFunc, ok := ret.Get(0).(func(context.Context, time.Time) (int64, error)); ok {
3077		return returnFunc(ctx, cutoff)
3078	}
3079	if returnFunc, ok := ret.Get(0).(func(context.Context, time.Time) int64); ok {
3080		r0 = returnFunc(ctx, cutoff)
3081	} else {
3082		r0 = ret.Get(0).(int64)
3083	}
3084	if returnFunc, ok := ret.Get(1).(func(context.Context, time.Time) error); ok {
3085		r1 = returnFunc(ctx, cutoff)
3086	} else {
3087		r1 = ret.Error(1)
3088	}
3089	return r0, r1
3090}
3091
3092// MockSessionRepository_DeleteExitedBefore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteExitedBefore'
3093type MockSessionRepository_DeleteExitedBefore_Call struct {
3094	*mock.Call
3095}
3096
3097// DeleteExitedBefore is a helper method to define mock.On call
3098//   - ctx context.Context
3099//   - cutoff time.Time
3100func (_e *MockSessionRepository_Expecter) DeleteExitedBefore(ctx interface{}, cutoff interface{}) *MockSessionRepository_DeleteExitedBefore_Call {
3101	return &MockSessionRepository_DeleteExitedBefore_Call{Call: _e.mock.On("DeleteExitedBefore", ctx, cutoff)}
3102}
3103
3104func (_c *MockSessionRepository_DeleteExitedBefore_Call) Run(run func(ctx context.Context, cutoff time.Time)) *MockSessionRepository_DeleteExitedBefore_Call {
3105	_c.Call.Run(func(args mock.Arguments) {
3106		var arg0 context.Context
3107		if args[0] != nil {
3108			arg0 = args[0].(context.Context)
3109		}
3110		var arg1 time.Time
3111		if args[1] != nil {
3112			arg1 = args[1].(time.Time)
3113		}
3114		run(
3115			arg0,
3116			arg1,
3117		)
3118	})
3119	return _c
3120}
3121
3122func (_c *MockSessionRepository_DeleteExitedBefore_Call) Return(n int64, err error) *MockSessionRepository_DeleteExitedBefore_Call {
3123	_c.Call.Return(n, err)
3124	return _c
3125}
3126
3127func (_c *MockSessionRepository_DeleteExitedBefore_Call) RunAndReturn(run func(ctx context.Context, cutoff time.Time) (int64, error)) *MockSessionRepository_DeleteExitedBefore_Call {
3128	_c.Call.Return(run)
3129	return _c
3130}
3131
3132// DeleteOldestExited provides a mock function for the type MockSessionRepository
3133func (_mock *MockSessionRepository) DeleteOldestExited(ctx context.Context, keepCount int) (int64, error) {
3134	ret := _mock.Called(ctx, keepCount)
3135
3136	if len(ret) == 0 {
3137		panic("no return value specified for DeleteOldestExited")
3138	}
3139
3140	var r0 int64
3141	var r1 error
3142	if returnFunc, ok := ret.Get(0).(func(context.Context, int) (int64, error)); ok {
3143		return returnFunc(ctx, keepCount)
3144	}
3145	if returnFunc, ok := ret.Get(0).(func(context.Context, int) int64); ok {
3146		r0 = returnFunc(ctx, keepCount)
3147	} else {
3148		r0 = ret.Get(0).(int64)
3149	}
3150	if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
3151		r1 = returnFunc(ctx, keepCount)
3152	} else {
3153		r1 = ret.Error(1)
3154	}
3155	return r0, r1
3156}
3157
3158// MockSessionRepository_DeleteOldestExited_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteOldestExited'
3159type MockSessionRepository_DeleteOldestExited_Call struct {
3160	*mock.Call
3161}
3162
3163// DeleteOldestExited is a helper method to define mock.On call
3164//   - ctx context.Context
3165//   - keepCount int
3166func (_e *MockSessionRepository_Expecter) DeleteOldestExited(ctx interface{}, keepCount interface{}) *MockSessionRepository_DeleteOldestExited_Call {
3167	return &MockSessionRepository_DeleteOldestExited_Call{Call: _e.mock.On("DeleteOldestExited", ctx, keepCount)}
3168}
3169
3170func (_c *MockSessionRepository_DeleteOldestExited_Call) Run(run func(ctx context.Context, keepCount int)) *MockSessionRepository_DeleteOldestExited_Call {
3171	_c.Call.Run(func(args mock.Arguments) {
3172		var arg0 context.Context
3173		if args[0] != nil {
3174			arg0 = args[0].(context.Context)
3175		}
3176		var arg1 int
3177		if args[1] != nil {
3178			arg1 = args[1].(int)
3179		}
3180		run(
3181			arg0,
3182			arg1,
3183		)
3184	})
3185	return _c
3186}
3187
3188func (_c *MockSessionRepository_DeleteOldestExited_Call) Return(n int64, err error) *MockSessionRepository_DeleteOldestExited_Call {
3189	_c.Call.Return(n, err)
3190	return _c
3191}
3192
3193func (_c *MockSessionRepository_DeleteOldestExited_Call) RunAndReturn(run func(ctx context.Context, keepCount int) (int64, error)) *MockSessionRepository_DeleteOldestExited_Call {
3194	_c.Call.Return(run)
3195	return _c
3196}
3197
3198// FindByID provides a mock function for the type MockSessionRepository
3199func (_mock *MockSessionRepository) FindByID(ctx context.Context, id entity.SessionID) (*entity.Session, error) {
3200	ret := _mock.Called(ctx, id)
3201
3202	if len(ret) == 0 {
3203		panic("no return value specified for FindByID")
3204	}
3205
3206	var r0 *entity.Session
3207	var r1 error
3208	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID) (*entity.Session, error)); ok {
3209		return returnFunc(ctx, id)
3210	}
3211	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID) *entity.Session); ok {
3212		r0 = returnFunc(ctx, id)
3213	} else {
3214		if ret.Get(0) != nil {
3215			r0 = ret.Get(0).(*entity.Session)
3216		}
3217	}
3218	if returnFunc, ok := ret.Get(1).(func(context.Context, entity.SessionID) error); ok {
3219		r1 = returnFunc(ctx, id)
3220	} else {
3221		r1 = ret.Error(1)
3222	}
3223	return r0, r1
3224}
3225
3226// MockSessionRepository_FindByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByID'
3227type MockSessionRepository_FindByID_Call struct {
3228	*mock.Call
3229}
3230
3231// FindByID is a helper method to define mock.On call
3232//   - ctx context.Context
3233//   - id entity.SessionID
3234func (_e *MockSessionRepository_Expecter) FindByID(ctx interface{}, id interface{}) *MockSessionRepository_FindByID_Call {
3235	return &MockSessionRepository_FindByID_Call{Call: _e.mock.On("FindByID", ctx, id)}
3236}
3237
3238func (_c *MockSessionRepository_FindByID_Call) Run(run func(ctx context.Context, id entity.SessionID)) *MockSessionRepository_FindByID_Call {
3239	_c.Call.Run(func(args mock.Arguments) {
3240		var arg0 context.Context
3241		if args[0] != nil {
3242			arg0 = args[0].(context.Context)
3243		}
3244		var arg1 entity.SessionID
3245		if args[1] != nil {
3246			arg1 = args[1].(entity.SessionID)
3247		}
3248		run(
3249			arg0,
3250			arg1,
3251		)
3252	})
3253	return _c
3254}
3255
3256func (_c *MockSessionRepository_FindByID_Call) Return(session *entity.Session, err error) *MockSessionRepository_FindByID_Call {
3257	_c.Call.Return(session, err)
3258	return _c
3259}
3260
3261func (_c *MockSessionRepository_FindByID_Call) RunAndReturn(run func(ctx context.Context, id entity.SessionID) (*entity.Session, error)) *MockSessionRepository_FindByID_Call {
3262	_c.Call.Return(run)
3263	return _c
3264}
3265
3266// GetActive provides a mock function for the type MockSessionRepository
3267func (_mock *MockSessionRepository) GetActive(ctx context.Context) (*entity.Session, error) {
3268	ret := _mock.Called(ctx)
3269
3270	if len(ret) == 0 {
3271		panic("no return value specified for GetActive")
3272	}
3273
3274	var r0 *entity.Session
3275	var r1 error
3276	if returnFunc, ok := ret.Get(0).(func(context.Context) (*entity.Session, error)); ok {
3277		return returnFunc(ctx)
3278	}
3279	if returnFunc, ok := ret.Get(0).(func(context.Context) *entity.Session); ok {
3280		r0 = returnFunc(ctx)
3281	} else {
3282		if ret.Get(0) != nil {
3283			r0 = ret.Get(0).(*entity.Session)
3284		}
3285	}
3286	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
3287		r1 = returnFunc(ctx)
3288	} else {
3289		r1 = ret.Error(1)
3290	}
3291	return r0, r1
3292}
3293
3294// MockSessionRepository_GetActive_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetActive'
3295type MockSessionRepository_GetActive_Call struct {
3296	*mock.Call
3297}
3298
3299// GetActive is a helper method to define mock.On call
3300//   - ctx context.Context
3301func (_e *MockSessionRepository_Expecter) GetActive(ctx interface{}) *MockSessionRepository_GetActive_Call {
3302	return &MockSessionRepository_GetActive_Call{Call: _e.mock.On("GetActive", ctx)}
3303}
3304
3305func (_c *MockSessionRepository_GetActive_Call) Run(run func(ctx context.Context)) *MockSessionRepository_GetActive_Call {
3306	_c.Call.Run(func(args mock.Arguments) {
3307		var arg0 context.Context
3308		if args[0] != nil {
3309			arg0 = args[0].(context.Context)
3310		}
3311		run(
3312			arg0,
3313		)
3314	})
3315	return _c
3316}
3317
3318func (_c *MockSessionRepository_GetActive_Call) Return(session *entity.Session, err error) *MockSessionRepository_GetActive_Call {
3319	_c.Call.Return(session, err)
3320	return _c
3321}
3322
3323func (_c *MockSessionRepository_GetActive_Call) RunAndReturn(run func(ctx context.Context) (*entity.Session, error)) *MockSessionRepository_GetActive_Call {
3324	_c.Call.Return(run)
3325	return _c
3326}
3327
3328// GetRecent provides a mock function for the type MockSessionRepository
3329func (_mock *MockSessionRepository) GetRecent(ctx context.Context, limit int) ([]*entity.Session, error) {
3330	ret := _mock.Called(ctx, limit)
3331
3332	if len(ret) == 0 {
3333		panic("no return value specified for GetRecent")
3334	}
3335
3336	var r0 []*entity.Session
3337	var r1 error
3338	if returnFunc, ok := ret.Get(0).(func(context.Context, int) ([]*entity.Session, error)); ok {
3339		return returnFunc(ctx, limit)
3340	}
3341	if returnFunc, ok := ret.Get(0).(func(context.Context, int) []*entity.Session); ok {
3342		r0 = returnFunc(ctx, limit)
3343	} else {
3344		if ret.Get(0) != nil {
3345			r0 = ret.Get(0).([]*entity.Session)
3346		}
3347	}
3348	if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
3349		r1 = returnFunc(ctx, limit)
3350	} else {
3351		r1 = ret.Error(1)
3352	}
3353	return r0, r1
3354}
3355
3356// MockSessionRepository_GetRecent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRecent'
3357type MockSessionRepository_GetRecent_Call struct {
3358	*mock.Call
3359}
3360
3361// GetRecent is a helper method to define mock.On call
3362//   - ctx context.Context
3363//   - limit int
3364func (_e *MockSessionRepository_Expecter) GetRecent(ctx interface{}, limit interface{}) *MockSessionRepository_GetRecent_Call {
3365	return &MockSessionRepository_GetRecent_Call{Call: _e.mock.On("GetRecent", ctx, limit)}
3366}
3367
3368func (_c *MockSessionRepository_GetRecent_Call) Run(run func(ctx context.Context, limit int)) *MockSessionRepository_GetRecent_Call {
3369	_c.Call.Run(func(args mock.Arguments) {
3370		var arg0 context.Context
3371		if args[0] != nil {
3372			arg0 = args[0].(context.Context)
3373		}
3374		var arg1 int
3375		if args[1] != nil {
3376			arg1 = args[1].(int)
3377		}
3378		run(
3379			arg0,
3380			arg1,
3381		)
3382	})
3383	return _c
3384}
3385
3386func (_c *MockSessionRepository_GetRecent_Call) Return(sessions []*entity.Session, err error) *MockSessionRepository_GetRecent_Call {
3387	_c.Call.Return(sessions, err)
3388	return _c
3389}
3390
3391func (_c *MockSessionRepository_GetRecent_Call) RunAndReturn(run func(ctx context.Context, limit int) ([]*entity.Session, error)) *MockSessionRepository_GetRecent_Call {
3392	_c.Call.Return(run)
3393	return _c
3394}
3395
3396// MarkEnded provides a mock function for the type MockSessionRepository
3397func (_mock *MockSessionRepository) MarkEnded(ctx context.Context, id entity.SessionID, endedAt time.Time) error {
3398	ret := _mock.Called(ctx, id, endedAt)
3399
3400	if len(ret) == 0 {
3401		panic("no return value specified for MarkEnded")
3402	}
3403
3404	var r0 error
3405	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID, time.Time) error); ok {
3406		r0 = returnFunc(ctx, id, endedAt)
3407	} else {
3408		r0 = ret.Error(0)
3409	}
3410	return r0
3411}
3412
3413// MockSessionRepository_MarkEnded_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MarkEnded'
3414type MockSessionRepository_MarkEnded_Call struct {
3415	*mock.Call
3416}
3417
3418// MarkEnded is a helper method to define mock.On call
3419//   - ctx context.Context
3420//   - id entity.SessionID
3421//   - endedAt time.Time
3422func (_e *MockSessionRepository_Expecter) MarkEnded(ctx interface{}, id interface{}, endedAt interface{}) *MockSessionRepository_MarkEnded_Call {
3423	return &MockSessionRepository_MarkEnded_Call{Call: _e.mock.On("MarkEnded", ctx, id, endedAt)}
3424}
3425
3426func (_c *MockSessionRepository_MarkEnded_Call) Run(run func(ctx context.Context, id entity.SessionID, endedAt time.Time)) *MockSessionRepository_MarkEnded_Call {
3427	_c.Call.Run(func(args mock.Arguments) {
3428		var arg0 context.Context
3429		if args[0] != nil {
3430			arg0 = args[0].(context.Context)
3431		}
3432		var arg1 entity.SessionID
3433		if args[1] != nil {
3434			arg1 = args[1].(entity.SessionID)
3435		}
3436		var arg2 time.Time
3437		if args[2] != nil {
3438			arg2 = args[2].(time.Time)
3439		}
3440		run(
3441			arg0,
3442			arg1,
3443			arg2,
3444		)
3445	})
3446	return _c
3447}
3448
3449func (_c *MockSessionRepository_MarkEnded_Call) Return(err error) *MockSessionRepository_MarkEnded_Call {
3450	_c.Call.Return(err)
3451	return _c
3452}
3453
3454func (_c *MockSessionRepository_MarkEnded_Call) RunAndReturn(run func(ctx context.Context, id entity.SessionID, endedAt time.Time) error) *MockSessionRepository_MarkEnded_Call {
3455	_c.Call.Return(run)
3456	return _c
3457}
3458
3459// Save provides a mock function for the type MockSessionRepository
3460func (_mock *MockSessionRepository) Save(ctx context.Context, session *entity.Session) error {
3461	ret := _mock.Called(ctx, session)
3462
3463	if len(ret) == 0 {
3464		panic("no return value specified for Save")
3465	}
3466
3467	var r0 error
3468	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.Session) error); ok {
3469		r0 = returnFunc(ctx, session)
3470	} else {
3471		r0 = ret.Error(0)
3472	}
3473	return r0
3474}
3475
3476// MockSessionRepository_Save_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Save'
3477type MockSessionRepository_Save_Call struct {
3478	*mock.Call
3479}
3480
3481// Save is a helper method to define mock.On call
3482//   - ctx context.Context
3483//   - session *entity.Session
3484func (_e *MockSessionRepository_Expecter) Save(ctx interface{}, session interface{}) *MockSessionRepository_Save_Call {
3485	return &MockSessionRepository_Save_Call{Call: _e.mock.On("Save", ctx, session)}
3486}
3487
3488func (_c *MockSessionRepository_Save_Call) Run(run func(ctx context.Context, session *entity.Session)) *MockSessionRepository_Save_Call {
3489	_c.Call.Run(func(args mock.Arguments) {
3490		var arg0 context.Context
3491		if args[0] != nil {
3492			arg0 = args[0].(context.Context)
3493		}
3494		var arg1 *entity.Session
3495		if args[1] != nil {
3496			arg1 = args[1].(*entity.Session)
3497		}
3498		run(
3499			arg0,
3500			arg1,
3501		)
3502	})
3503	return _c
3504}
3505
3506func (_c *MockSessionRepository_Save_Call) Return(err error) *MockSessionRepository_Save_Call {
3507	_c.Call.Return(err)
3508	return _c
3509}
3510
3511func (_c *MockSessionRepository_Save_Call) RunAndReturn(run func(ctx context.Context, session *entity.Session) error) *MockSessionRepository_Save_Call {
3512	_c.Call.Return(run)
3513	return _c
3514}
3515
3516// 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.
3517// The first argument is typically a *testing.T value.
3518func NewMockSessionStateRepository(t interface {
3519	mock.TestingT
3520	Cleanup(func())
3521}) *MockSessionStateRepository {
3522	mock := &MockSessionStateRepository{}
3523	mock.Mock.Test(t)
3524
3525	t.Cleanup(func() { mock.AssertExpectations(t) })
3526
3527	return mock
3528}
3529
3530// MockSessionStateRepository is an autogenerated mock type for the SessionStateRepository type
3531type MockSessionStateRepository struct {
3532	mock.Mock
3533}
3534
3535type MockSessionStateRepository_Expecter struct {
3536	mock *mock.Mock
3537}
3538
3539func (_m *MockSessionStateRepository) EXPECT() *MockSessionStateRepository_Expecter {
3540	return &MockSessionStateRepository_Expecter{mock: &_m.Mock}
3541}
3542
3543// DeleteSnapshot provides a mock function for the type MockSessionStateRepository
3544func (_mock *MockSessionStateRepository) DeleteSnapshot(ctx context.Context, sessionID entity.SessionID) error {
3545	ret := _mock.Called(ctx, sessionID)
3546
3547	if len(ret) == 0 {
3548		panic("no return value specified for DeleteSnapshot")
3549	}
3550
3551	var r0 error
3552	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID) error); ok {
3553		r0 = returnFunc(ctx, sessionID)
3554	} else {
3555		r0 = ret.Error(0)
3556	}
3557	return r0
3558}
3559
3560// MockSessionStateRepository_DeleteSnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteSnapshot'
3561type MockSessionStateRepository_DeleteSnapshot_Call struct {
3562	*mock.Call
3563}
3564
3565// DeleteSnapshot is a helper method to define mock.On call
3566//   - ctx context.Context
3567//   - sessionID entity.SessionID
3568func (_e *MockSessionStateRepository_Expecter) DeleteSnapshot(ctx interface{}, sessionID interface{}) *MockSessionStateRepository_DeleteSnapshot_Call {
3569	return &MockSessionStateRepository_DeleteSnapshot_Call{Call: _e.mock.On("DeleteSnapshot", ctx, sessionID)}
3570}
3571
3572func (_c *MockSessionStateRepository_DeleteSnapshot_Call) Run(run func(ctx context.Context, sessionID entity.SessionID)) *MockSessionStateRepository_DeleteSnapshot_Call {
3573	_c.Call.Run(func(args mock.Arguments) {
3574		var arg0 context.Context
3575		if args[0] != nil {
3576			arg0 = args[0].(context.Context)
3577		}
3578		var arg1 entity.SessionID
3579		if args[1] != nil {
3580			arg1 = args[1].(entity.SessionID)
3581		}
3582		run(
3583			arg0,
3584			arg1,
3585		)
3586	})
3587	return _c
3588}
3589
3590func (_c *MockSessionStateRepository_DeleteSnapshot_Call) Return(err error) *MockSessionStateRepository_DeleteSnapshot_Call {
3591	_c.Call.Return(err)
3592	return _c
3593}
3594
3595func (_c *MockSessionStateRepository_DeleteSnapshot_Call) RunAndReturn(run func(ctx context.Context, sessionID entity.SessionID) error) *MockSessionStateRepository_DeleteSnapshot_Call {
3596	_c.Call.Return(run)
3597	return _c
3598}
3599
3600// GetAllSnapshots provides a mock function for the type MockSessionStateRepository
3601func (_mock *MockSessionStateRepository) GetAllSnapshots(ctx context.Context) ([]*entity.SessionState, error) {
3602	ret := _mock.Called(ctx)
3603
3604	if len(ret) == 0 {
3605		panic("no return value specified for GetAllSnapshots")
3606	}
3607
3608	var r0 []*entity.SessionState
3609	var r1 error
3610	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*entity.SessionState, error)); ok {
3611		return returnFunc(ctx)
3612	}
3613	if returnFunc, ok := ret.Get(0).(func(context.Context) []*entity.SessionState); ok {
3614		r0 = returnFunc(ctx)
3615	} else {
3616		if ret.Get(0) != nil {
3617			r0 = ret.Get(0).([]*entity.SessionState)
3618		}
3619	}
3620	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
3621		r1 = returnFunc(ctx)
3622	} else {
3623		r1 = ret.Error(1)
3624	}
3625	return r0, r1
3626}
3627
3628// MockSessionStateRepository_GetAllSnapshots_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllSnapshots'
3629type MockSessionStateRepository_GetAllSnapshots_Call struct {
3630	*mock.Call
3631}
3632
3633// GetAllSnapshots is a helper method to define mock.On call
3634//   - ctx context.Context
3635func (_e *MockSessionStateRepository_Expecter) GetAllSnapshots(ctx interface{}) *MockSessionStateRepository_GetAllSnapshots_Call {
3636	return &MockSessionStateRepository_GetAllSnapshots_Call{Call: _e.mock.On("GetAllSnapshots", ctx)}
3637}
3638
3639func (_c *MockSessionStateRepository_GetAllSnapshots_Call) Run(run func(ctx context.Context)) *MockSessionStateRepository_GetAllSnapshots_Call {
3640	_c.Call.Run(func(args mock.Arguments) {
3641		var arg0 context.Context
3642		if args[0] != nil {
3643			arg0 = args[0].(context.Context)
3644		}
3645		run(
3646			arg0,
3647		)
3648	})
3649	return _c
3650}
3651
3652func (_c *MockSessionStateRepository_GetAllSnapshots_Call) Return(sessionStates []*entity.SessionState, err error) *MockSessionStateRepository_GetAllSnapshots_Call {
3653	_c.Call.Return(sessionStates, err)
3654	return _c
3655}
3656
3657func (_c *MockSessionStateRepository_GetAllSnapshots_Call) RunAndReturn(run func(ctx context.Context) ([]*entity.SessionState, error)) *MockSessionStateRepository_GetAllSnapshots_Call {
3658	_c.Call.Return(run)
3659	return _c
3660}
3661
3662// GetSnapshot provides a mock function for the type MockSessionStateRepository
3663func (_mock *MockSessionStateRepository) GetSnapshot(ctx context.Context, sessionID entity.SessionID) (*entity.SessionState, error) {
3664	ret := _mock.Called(ctx, sessionID)
3665
3666	if len(ret) == 0 {
3667		panic("no return value specified for GetSnapshot")
3668	}
3669
3670	var r0 *entity.SessionState
3671	var r1 error
3672	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID) (*entity.SessionState, error)); ok {
3673		return returnFunc(ctx, sessionID)
3674	}
3675	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID) *entity.SessionState); ok {
3676		r0 = returnFunc(ctx, sessionID)
3677	} else {
3678		if ret.Get(0) != nil {
3679			r0 = ret.Get(0).(*entity.SessionState)
3680		}
3681	}
3682	if returnFunc, ok := ret.Get(1).(func(context.Context, entity.SessionID) error); ok {
3683		r1 = returnFunc(ctx, sessionID)
3684	} else {
3685		r1 = ret.Error(1)
3686	}
3687	return r0, r1
3688}
3689
3690// MockSessionStateRepository_GetSnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSnapshot'
3691type MockSessionStateRepository_GetSnapshot_Call struct {
3692	*mock.Call
3693}
3694
3695// GetSnapshot is a helper method to define mock.On call
3696//   - ctx context.Context
3697//   - sessionID entity.SessionID
3698func (_e *MockSessionStateRepository_Expecter) GetSnapshot(ctx interface{}, sessionID interface{}) *MockSessionStateRepository_GetSnapshot_Call {
3699	return &MockSessionStateRepository_GetSnapshot_Call{Call: _e.mock.On("GetSnapshot", ctx, sessionID)}
3700}
3701
3702func (_c *MockSessionStateRepository_GetSnapshot_Call) Run(run func(ctx context.Context, sessionID entity.SessionID)) *MockSessionStateRepository_GetSnapshot_Call {
3703	_c.Call.Run(func(args mock.Arguments) {
3704		var arg0 context.Context
3705		if args[0] != nil {
3706			arg0 = args[0].(context.Context)
3707		}
3708		var arg1 entity.SessionID
3709		if args[1] != nil {
3710			arg1 = args[1].(entity.SessionID)
3711		}
3712		run(
3713			arg0,
3714			arg1,
3715		)
3716	})
3717	return _c
3718}
3719
3720func (_c *MockSessionStateRepository_GetSnapshot_Call) Return(sessionState *entity.SessionState, err error) *MockSessionStateRepository_GetSnapshot_Call {
3721	_c.Call.Return(sessionState, err)
3722	return _c
3723}
3724
3725func (_c *MockSessionStateRepository_GetSnapshot_Call) RunAndReturn(run func(ctx context.Context, sessionID entity.SessionID) (*entity.SessionState, error)) *MockSessionStateRepository_GetSnapshot_Call {
3726	_c.Call.Return(run)
3727	return _c
3728}
3729
3730// GetTotalSnapshotsSize provides a mock function for the type MockSessionStateRepository
3731func (_mock *MockSessionStateRepository) GetTotalSnapshotsSize(ctx context.Context) (int64, error) {
3732	ret := _mock.Called(ctx)
3733
3734	if len(ret) == 0 {
3735		panic("no return value specified for GetTotalSnapshotsSize")
3736	}
3737
3738	var r0 int64
3739	var r1 error
3740	if returnFunc, ok := ret.Get(0).(func(context.Context) (int64, error)); ok {
3741		return returnFunc(ctx)
3742	}
3743	if returnFunc, ok := ret.Get(0).(func(context.Context) int64); ok {
3744		r0 = returnFunc(ctx)
3745	} else {
3746		r0 = ret.Get(0).(int64)
3747	}
3748	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
3749		r1 = returnFunc(ctx)
3750	} else {
3751		r1 = ret.Error(1)
3752	}
3753	return r0, r1
3754}
3755
3756// MockSessionStateRepository_GetTotalSnapshotsSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTotalSnapshotsSize'
3757type MockSessionStateRepository_GetTotalSnapshotsSize_Call struct {
3758	*mock.Call
3759}
3760
3761// GetTotalSnapshotsSize is a helper method to define mock.On call
3762//   - ctx context.Context
3763func (_e *MockSessionStateRepository_Expecter) GetTotalSnapshotsSize(ctx interface{}) *MockSessionStateRepository_GetTotalSnapshotsSize_Call {
3764	return &MockSessionStateRepository_GetTotalSnapshotsSize_Call{Call: _e.mock.On("GetTotalSnapshotsSize", ctx)}
3765}
3766
3767func (_c *MockSessionStateRepository_GetTotalSnapshotsSize_Call) Run(run func(ctx context.Context)) *MockSessionStateRepository_GetTotalSnapshotsSize_Call {
3768	_c.Call.Run(func(args mock.Arguments) {
3769		var arg0 context.Context
3770		if args[0] != nil {
3771			arg0 = args[0].(context.Context)
3772		}
3773		run(
3774			arg0,
3775		)
3776	})
3777	return _c
3778}
3779
3780func (_c *MockSessionStateRepository_GetTotalSnapshotsSize_Call) Return(n int64, err error) *MockSessionStateRepository_GetTotalSnapshotsSize_Call {
3781	_c.Call.Return(n, err)
3782	return _c
3783}
3784
3785func (_c *MockSessionStateRepository_GetTotalSnapshotsSize_Call) RunAndReturn(run func(ctx context.Context) (int64, error)) *MockSessionStateRepository_GetTotalSnapshotsSize_Call {
3786	_c.Call.Return(run)
3787	return _c
3788}
3789
3790// SaveSnapshot provides a mock function for the type MockSessionStateRepository
3791func (_mock *MockSessionStateRepository) SaveSnapshot(ctx context.Context, state *entity.SessionState) error {
3792	ret := _mock.Called(ctx, state)
3793
3794	if len(ret) == 0 {
3795		panic("no return value specified for SaveSnapshot")
3796	}
3797
3798	var r0 error
3799	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.SessionState) error); ok {
3800		r0 = returnFunc(ctx, state)
3801	} else {
3802		r0 = ret.Error(0)
3803	}
3804	return r0
3805}
3806
3807// MockSessionStateRepository_SaveSnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveSnapshot'
3808type MockSessionStateRepository_SaveSnapshot_Call struct {
3809	*mock.Call
3810}
3811
3812// SaveSnapshot is a helper method to define mock.On call
3813//   - ctx context.Context
3814//   - state *entity.SessionState
3815func (_e *MockSessionStateRepository_Expecter) SaveSnapshot(ctx interface{}, state interface{}) *MockSessionStateRepository_SaveSnapshot_Call {
3816	return &MockSessionStateRepository_SaveSnapshot_Call{Call: _e.mock.On("SaveSnapshot", ctx, state)}
3817}
3818
3819func (_c *MockSessionStateRepository_SaveSnapshot_Call) Run(run func(ctx context.Context, state *entity.SessionState)) *MockSessionStateRepository_SaveSnapshot_Call {
3820	_c.Call.Run(func(args mock.Arguments) {
3821		var arg0 context.Context
3822		if args[0] != nil {
3823			arg0 = args[0].(context.Context)
3824		}
3825		var arg1 *entity.SessionState
3826		if args[1] != nil {
3827			arg1 = args[1].(*entity.SessionState)
3828		}
3829		run(
3830			arg0,
3831			arg1,
3832		)
3833	})
3834	return _c
3835}
3836
3837func (_c *MockSessionStateRepository_SaveSnapshot_Call) Return(err error) *MockSessionStateRepository_SaveSnapshot_Call {
3838	_c.Call.Return(err)
3839	return _c
3840}
3841
3842func (_c *MockSessionStateRepository_SaveSnapshot_Call) RunAndReturn(run func(ctx context.Context, state *entity.SessionState) error) *MockSessionStateRepository_SaveSnapshot_Call {
3843	_c.Call.Return(run)
3844	return _c
3845}
3846
3847// 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.
3848// The first argument is typically a *testing.T value.
3849func NewMockZoomRepository(t interface {
3850	mock.TestingT
3851	Cleanup(func())
3852}) *MockZoomRepository {
3853	mock := &MockZoomRepository{}
3854	mock.Mock.Test(t)
3855
3856	t.Cleanup(func() { mock.AssertExpectations(t) })
3857
3858	return mock
3859}
3860
3861// MockZoomRepository is an autogenerated mock type for the ZoomRepository type
3862type MockZoomRepository struct {
3863	mock.Mock
3864}
3865
3866type MockZoomRepository_Expecter struct {
3867	mock *mock.Mock
3868}
3869
3870func (_m *MockZoomRepository) EXPECT() *MockZoomRepository_Expecter {
3871	return &MockZoomRepository_Expecter{mock: &_m.Mock}
3872}
3873
3874// Delete provides a mock function for the type MockZoomRepository
3875func (_mock *MockZoomRepository) Delete(ctx context.Context, domain string) error {
3876	ret := _mock.Called(ctx, domain)
3877
3878	if len(ret) == 0 {
3879		panic("no return value specified for Delete")
3880	}
3881
3882	var r0 error
3883	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
3884		r0 = returnFunc(ctx, domain)
3885	} else {
3886		r0 = ret.Error(0)
3887	}
3888	return r0
3889}
3890
3891// MockZoomRepository_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
3892type MockZoomRepository_Delete_Call struct {
3893	*mock.Call
3894}
3895
3896// Delete is a helper method to define mock.On call
3897//   - ctx context.Context
3898//   - domain string
3899func (_e *MockZoomRepository_Expecter) Delete(ctx interface{}, domain interface{}) *MockZoomRepository_Delete_Call {
3900	return &MockZoomRepository_Delete_Call{Call: _e.mock.On("Delete", ctx, domain)}
3901}
3902
3903func (_c *MockZoomRepository_Delete_Call) Run(run func(ctx context.Context, domain string)) *MockZoomRepository_Delete_Call {
3904	_c.Call.Run(func(args mock.Arguments) {
3905		var arg0 context.Context
3906		if args[0] != nil {
3907			arg0 = args[0].(context.Context)
3908		}
3909		var arg1 string
3910		if args[1] != nil {
3911			arg1 = args[1].(string)
3912		}
3913		run(
3914			arg0,
3915			arg1,
3916		)
3917	})
3918	return _c
3919}
3920
3921func (_c *MockZoomRepository_Delete_Call) Return(err error) *MockZoomRepository_Delete_Call {
3922	_c.Call.Return(err)
3923	return _c
3924}
3925
3926func (_c *MockZoomRepository_Delete_Call) RunAndReturn(run func(ctx context.Context, domain string) error) *MockZoomRepository_Delete_Call {
3927	_c.Call.Return(run)
3928	return _c
3929}
3930
3931// Get provides a mock function for the type MockZoomRepository
3932func (_mock *MockZoomRepository) Get(ctx context.Context, domain string) (*entity.ZoomLevel, error) {
3933	ret := _mock.Called(ctx, domain)
3934
3935	if len(ret) == 0 {
3936		panic("no return value specified for Get")
3937	}
3938
3939	var r0 *entity.ZoomLevel
3940	var r1 error
3941	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*entity.ZoomLevel, error)); ok {
3942		return returnFunc(ctx, domain)
3943	}
3944	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *entity.ZoomLevel); ok {
3945		r0 = returnFunc(ctx, domain)
3946	} else {
3947		if ret.Get(0) != nil {
3948			r0 = ret.Get(0).(*entity.ZoomLevel)
3949		}
3950	}
3951	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
3952		r1 = returnFunc(ctx, domain)
3953	} else {
3954		r1 = ret.Error(1)
3955	}
3956	return r0, r1
3957}
3958
3959// MockZoomRepository_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'
3960type MockZoomRepository_Get_Call struct {
3961	*mock.Call
3962}
3963
3964// Get is a helper method to define mock.On call
3965//   - ctx context.Context
3966//   - domain string
3967func (_e *MockZoomRepository_Expecter) Get(ctx interface{}, domain interface{}) *MockZoomRepository_Get_Call {
3968	return &MockZoomRepository_Get_Call{Call: _e.mock.On("Get", ctx, domain)}
3969}
3970
3971func (_c *MockZoomRepository_Get_Call) Run(run func(ctx context.Context, domain string)) *MockZoomRepository_Get_Call {
3972	_c.Call.Run(func(args mock.Arguments) {
3973		var arg0 context.Context
3974		if args[0] != nil {
3975			arg0 = args[0].(context.Context)
3976		}
3977		var arg1 string
3978		if args[1] != nil {
3979			arg1 = args[1].(string)
3980		}
3981		run(
3982			arg0,
3983			arg1,
3984		)
3985	})
3986	return _c
3987}
3988
3989func (_c *MockZoomRepository_Get_Call) Return(zoomLevel *entity.ZoomLevel, err error) *MockZoomRepository_Get_Call {
3990	_c.Call.Return(zoomLevel, err)
3991	return _c
3992}
3993
3994func (_c *MockZoomRepository_Get_Call) RunAndReturn(run func(ctx context.Context, domain string) (*entity.ZoomLevel, error)) *MockZoomRepository_Get_Call {
3995	_c.Call.Return(run)
3996	return _c
3997}
3998
3999// GetAll provides a mock function for the type MockZoomRepository
4000func (_mock *MockZoomRepository) GetAll(ctx context.Context) ([]*entity.ZoomLevel, error) {
4001	ret := _mock.Called(ctx)
4002
4003	if len(ret) == 0 {
4004		panic("no return value specified for GetAll")
4005	}
4006
4007	var r0 []*entity.ZoomLevel
4008	var r1 error
4009	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*entity.ZoomLevel, error)); ok {
4010		return returnFunc(ctx)
4011	}
4012	if returnFunc, ok := ret.Get(0).(func(context.Context) []*entity.ZoomLevel); ok {
4013		r0 = returnFunc(ctx)
4014	} else {
4015		if ret.Get(0) != nil {
4016			r0 = ret.Get(0).([]*entity.ZoomLevel)
4017		}
4018	}
4019	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
4020		r1 = returnFunc(ctx)
4021	} else {
4022		r1 = ret.Error(1)
4023	}
4024	return r0, r1
4025}
4026
4027// MockZoomRepository_GetAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAll'
4028type MockZoomRepository_GetAll_Call struct {
4029	*mock.Call
4030}
4031
4032// GetAll is a helper method to define mock.On call
4033//   - ctx context.Context
4034func (_e *MockZoomRepository_Expecter) GetAll(ctx interface{}) *MockZoomRepository_GetAll_Call {
4035	return &MockZoomRepository_GetAll_Call{Call: _e.mock.On("GetAll", ctx)}
4036}
4037
4038func (_c *MockZoomRepository_GetAll_Call) Run(run func(ctx context.Context)) *MockZoomRepository_GetAll_Call {
4039	_c.Call.Run(func(args mock.Arguments) {
4040		var arg0 context.Context
4041		if args[0] != nil {
4042			arg0 = args[0].(context.Context)
4043		}
4044		run(
4045			arg0,
4046		)
4047	})
4048	return _c
4049}
4050
4051func (_c *MockZoomRepository_GetAll_Call) Return(zoomLevels []*entity.ZoomLevel, err error) *MockZoomRepository_GetAll_Call {
4052	_c.Call.Return(zoomLevels, err)
4053	return _c
4054}
4055
4056func (_c *MockZoomRepository_GetAll_Call) RunAndReturn(run func(ctx context.Context) ([]*entity.ZoomLevel, error)) *MockZoomRepository_GetAll_Call {
4057	_c.Call.Return(run)
4058	return _c
4059}
4060
4061// Set provides a mock function for the type MockZoomRepository
4062func (_mock *MockZoomRepository) Set(ctx context.Context, level *entity.ZoomLevel) error {
4063	ret := _mock.Called(ctx, level)
4064
4065	if len(ret) == 0 {
4066		panic("no return value specified for Set")
4067	}
4068
4069	var r0 error
4070	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.ZoomLevel) error); ok {
4071		r0 = returnFunc(ctx, level)
4072	} else {
4073		r0 = ret.Error(0)
4074	}
4075	return r0
4076}
4077
4078// MockZoomRepository_Set_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Set'
4079type MockZoomRepository_Set_Call struct {
4080	*mock.Call
4081}
4082
4083// Set is a helper method to define mock.On call
4084//   - ctx context.Context
4085//   - level *entity.ZoomLevel
4086func (_e *MockZoomRepository_Expecter) Set(ctx interface{}, level interface{}) *MockZoomRepository_Set_Call {
4087	return &MockZoomRepository_Set_Call{Call: _e.mock.On("Set", ctx, level)}
4088}
4089
4090func (_c *MockZoomRepository_Set_Call) Run(run func(ctx context.Context, level *entity.ZoomLevel)) *MockZoomRepository_Set_Call {
4091	_c.Call.Run(func(args mock.Arguments) {
4092		var arg0 context.Context
4093		if args[0] != nil {
4094			arg0 = args[0].(context.Context)
4095		}
4096		var arg1 *entity.ZoomLevel
4097		if args[1] != nil {
4098			arg1 = args[1].(*entity.ZoomLevel)
4099		}
4100		run(
4101			arg0,
4102			arg1,
4103		)
4104	})
4105	return _c
4106}
4107
4108func (_c *MockZoomRepository_Set_Call) Return(err error) *MockZoomRepository_Set_Call {
4109	_c.Call.Return(err)
4110	return _c
4111}
4112
4113func (_c *MockZoomRepository_Set_Call) RunAndReturn(run func(ctx context.Context, level *entity.ZoomLevel) error) *MockZoomRepository_Set_Call {
4114	_c.Call.Return(run)
4115	return _c
4116}