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// DeleteSince provides a mock function for the type MockHistoryRepository
2133func (_mock *MockHistoryRepository) DeleteSince(ctx context.Context, since time.Time) error {
2134	ret := _mock.Called(ctx, since)
2135
2136	if len(ret) == 0 {
2137		panic("no return value specified for DeleteSince")
2138	}
2139
2140	var r0 error
2141	if returnFunc, ok := ret.Get(0).(func(context.Context, time.Time) error); ok {
2142		r0 = returnFunc(ctx, since)
2143	} else {
2144		r0 = ret.Error(0)
2145	}
2146	return r0
2147}
2148
2149// MockHistoryRepository_DeleteSince_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteSince'
2150type MockHistoryRepository_DeleteSince_Call struct {
2151	*mock.Call
2152}
2153
2154// DeleteSince is a helper method to define mock.On call
2155//   - ctx context.Context
2156//   - since time.Time
2157func (_e *MockHistoryRepository_Expecter) DeleteSince(ctx interface{}, since interface{}) *MockHistoryRepository_DeleteSince_Call {
2158	return &MockHistoryRepository_DeleteSince_Call{Call: _e.mock.On("DeleteSince", ctx, since)}
2159}
2160
2161func (_c *MockHistoryRepository_DeleteSince_Call) Run(run func(ctx context.Context, since time.Time)) *MockHistoryRepository_DeleteSince_Call {
2162	_c.Call.Run(func(args mock.Arguments) {
2163		var arg0 context.Context
2164		if args[0] != nil {
2165			arg0 = args[0].(context.Context)
2166		}
2167		var arg1 time.Time
2168		if args[1] != nil {
2169			arg1 = args[1].(time.Time)
2170		}
2171		run(
2172			arg0,
2173			arg1,
2174		)
2175	})
2176	return _c
2177}
2178
2179func (_c *MockHistoryRepository_DeleteSince_Call) Return(err error) *MockHistoryRepository_DeleteSince_Call {
2180	_c.Call.Return(err)
2181	return _c
2182}
2183
2184func (_c *MockHistoryRepository_DeleteSince_Call) RunAndReturn(run func(ctx context.Context, since time.Time) error) *MockHistoryRepository_DeleteSince_Call {
2185	_c.Call.Return(run)
2186	return _c
2187}
2188
2189// FindByURL provides a mock function for the type MockHistoryRepository
2190func (_mock *MockHistoryRepository) FindByURL(ctx context.Context, url string) (*entity.HistoryEntry, error) {
2191	ret := _mock.Called(ctx, url)
2192
2193	if len(ret) == 0 {
2194		panic("no return value specified for FindByURL")
2195	}
2196
2197	var r0 *entity.HistoryEntry
2198	var r1 error
2199	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*entity.HistoryEntry, error)); ok {
2200		return returnFunc(ctx, url)
2201	}
2202	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *entity.HistoryEntry); ok {
2203		r0 = returnFunc(ctx, url)
2204	} else {
2205		if ret.Get(0) != nil {
2206			r0 = ret.Get(0).(*entity.HistoryEntry)
2207		}
2208	}
2209	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
2210		r1 = returnFunc(ctx, url)
2211	} else {
2212		r1 = ret.Error(1)
2213	}
2214	return r0, r1
2215}
2216
2217// MockHistoryRepository_FindByURL_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByURL'
2218type MockHistoryRepository_FindByURL_Call struct {
2219	*mock.Call
2220}
2221
2222// FindByURL is a helper method to define mock.On call
2223//   - ctx context.Context
2224//   - url string
2225func (_e *MockHistoryRepository_Expecter) FindByURL(ctx interface{}, url interface{}) *MockHistoryRepository_FindByURL_Call {
2226	return &MockHistoryRepository_FindByURL_Call{Call: _e.mock.On("FindByURL", ctx, url)}
2227}
2228
2229func (_c *MockHistoryRepository_FindByURL_Call) Run(run func(ctx context.Context, url string)) *MockHistoryRepository_FindByURL_Call {
2230	_c.Call.Run(func(args mock.Arguments) {
2231		var arg0 context.Context
2232		if args[0] != nil {
2233			arg0 = args[0].(context.Context)
2234		}
2235		var arg1 string
2236		if args[1] != nil {
2237			arg1 = args[1].(string)
2238		}
2239		run(
2240			arg0,
2241			arg1,
2242		)
2243	})
2244	return _c
2245}
2246
2247func (_c *MockHistoryRepository_FindByURL_Call) Return(historyEntry *entity.HistoryEntry, err error) *MockHistoryRepository_FindByURL_Call {
2248	_c.Call.Return(historyEntry, err)
2249	return _c
2250}
2251
2252func (_c *MockHistoryRepository_FindByURL_Call) RunAndReturn(run func(ctx context.Context, url string) (*entity.HistoryEntry, error)) *MockHistoryRepository_FindByURL_Call {
2253	_c.Call.Return(run)
2254	return _c
2255}
2256
2257// GetAllMostVisited provides a mock function for the type MockHistoryRepository
2258func (_mock *MockHistoryRepository) GetAllMostVisited(ctx context.Context) ([]*entity.HistoryEntry, error) {
2259	ret := _mock.Called(ctx)
2260
2261	if len(ret) == 0 {
2262		panic("no return value specified for GetAllMostVisited")
2263	}
2264
2265	var r0 []*entity.HistoryEntry
2266	var r1 error
2267	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*entity.HistoryEntry, error)); ok {
2268		return returnFunc(ctx)
2269	}
2270	if returnFunc, ok := ret.Get(0).(func(context.Context) []*entity.HistoryEntry); ok {
2271		r0 = returnFunc(ctx)
2272	} else {
2273		if ret.Get(0) != nil {
2274			r0 = ret.Get(0).([]*entity.HistoryEntry)
2275		}
2276	}
2277	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
2278		r1 = returnFunc(ctx)
2279	} else {
2280		r1 = ret.Error(1)
2281	}
2282	return r0, r1
2283}
2284
2285// MockHistoryRepository_GetAllMostVisited_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllMostVisited'
2286type MockHistoryRepository_GetAllMostVisited_Call struct {
2287	*mock.Call
2288}
2289
2290// GetAllMostVisited is a helper method to define mock.On call
2291//   - ctx context.Context
2292func (_e *MockHistoryRepository_Expecter) GetAllMostVisited(ctx interface{}) *MockHistoryRepository_GetAllMostVisited_Call {
2293	return &MockHistoryRepository_GetAllMostVisited_Call{Call: _e.mock.On("GetAllMostVisited", ctx)}
2294}
2295
2296func (_c *MockHistoryRepository_GetAllMostVisited_Call) Run(run func(ctx context.Context)) *MockHistoryRepository_GetAllMostVisited_Call {
2297	_c.Call.Run(func(args mock.Arguments) {
2298		var arg0 context.Context
2299		if args[0] != nil {
2300			arg0 = args[0].(context.Context)
2301		}
2302		run(
2303			arg0,
2304		)
2305	})
2306	return _c
2307}
2308
2309func (_c *MockHistoryRepository_GetAllMostVisited_Call) Return(historyEntrys []*entity.HistoryEntry, err error) *MockHistoryRepository_GetAllMostVisited_Call {
2310	_c.Call.Return(historyEntrys, err)
2311	return _c
2312}
2313
2314func (_c *MockHistoryRepository_GetAllMostVisited_Call) RunAndReturn(run func(ctx context.Context) ([]*entity.HistoryEntry, error)) *MockHistoryRepository_GetAllMostVisited_Call {
2315	_c.Call.Return(run)
2316	return _c
2317}
2318
2319// GetAllRecentHistory provides a mock function for the type MockHistoryRepository
2320func (_mock *MockHistoryRepository) GetAllRecentHistory(ctx context.Context) ([]*entity.HistoryEntry, error) {
2321	ret := _mock.Called(ctx)
2322
2323	if len(ret) == 0 {
2324		panic("no return value specified for GetAllRecentHistory")
2325	}
2326
2327	var r0 []*entity.HistoryEntry
2328	var r1 error
2329	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*entity.HistoryEntry, error)); ok {
2330		return returnFunc(ctx)
2331	}
2332	if returnFunc, ok := ret.Get(0).(func(context.Context) []*entity.HistoryEntry); ok {
2333		r0 = returnFunc(ctx)
2334	} else {
2335		if ret.Get(0) != nil {
2336			r0 = ret.Get(0).([]*entity.HistoryEntry)
2337		}
2338	}
2339	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
2340		r1 = returnFunc(ctx)
2341	} else {
2342		r1 = ret.Error(1)
2343	}
2344	return r0, r1
2345}
2346
2347// MockHistoryRepository_GetAllRecentHistory_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllRecentHistory'
2348type MockHistoryRepository_GetAllRecentHistory_Call struct {
2349	*mock.Call
2350}
2351
2352// GetAllRecentHistory is a helper method to define mock.On call
2353//   - ctx context.Context
2354func (_e *MockHistoryRepository_Expecter) GetAllRecentHistory(ctx interface{}) *MockHistoryRepository_GetAllRecentHistory_Call {
2355	return &MockHistoryRepository_GetAllRecentHistory_Call{Call: _e.mock.On("GetAllRecentHistory", ctx)}
2356}
2357
2358func (_c *MockHistoryRepository_GetAllRecentHistory_Call) Run(run func(ctx context.Context)) *MockHistoryRepository_GetAllRecentHistory_Call {
2359	_c.Call.Run(func(args mock.Arguments) {
2360		var arg0 context.Context
2361		if args[0] != nil {
2362			arg0 = args[0].(context.Context)
2363		}
2364		run(
2365			arg0,
2366		)
2367	})
2368	return _c
2369}
2370
2371func (_c *MockHistoryRepository_GetAllRecentHistory_Call) Return(historyEntrys []*entity.HistoryEntry, err error) *MockHistoryRepository_GetAllRecentHistory_Call {
2372	_c.Call.Return(historyEntrys, err)
2373	return _c
2374}
2375
2376func (_c *MockHistoryRepository_GetAllRecentHistory_Call) RunAndReturn(run func(ctx context.Context) ([]*entity.HistoryEntry, error)) *MockHistoryRepository_GetAllRecentHistory_Call {
2377	_c.Call.Return(run)
2378	return _c
2379}
2380
2381// GetDailyVisitCount provides a mock function for the type MockHistoryRepository
2382func (_mock *MockHistoryRepository) GetDailyVisitCount(ctx context.Context, daysAgo string) ([]*entity.DailyVisitCount, error) {
2383	ret := _mock.Called(ctx, daysAgo)
2384
2385	if len(ret) == 0 {
2386		panic("no return value specified for GetDailyVisitCount")
2387	}
2388
2389	var r0 []*entity.DailyVisitCount
2390	var r1 error
2391	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]*entity.DailyVisitCount, error)); ok {
2392		return returnFunc(ctx, daysAgo)
2393	}
2394	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []*entity.DailyVisitCount); ok {
2395		r0 = returnFunc(ctx, daysAgo)
2396	} else {
2397		if ret.Get(0) != nil {
2398			r0 = ret.Get(0).([]*entity.DailyVisitCount)
2399		}
2400	}
2401	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
2402		r1 = returnFunc(ctx, daysAgo)
2403	} else {
2404		r1 = ret.Error(1)
2405	}
2406	return r0, r1
2407}
2408
2409// MockHistoryRepository_GetDailyVisitCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDailyVisitCount'
2410type MockHistoryRepository_GetDailyVisitCount_Call struct {
2411	*mock.Call
2412}
2413
2414// GetDailyVisitCount is a helper method to define mock.On call
2415//   - ctx context.Context
2416//   - daysAgo string
2417func (_e *MockHistoryRepository_Expecter) GetDailyVisitCount(ctx interface{}, daysAgo interface{}) *MockHistoryRepository_GetDailyVisitCount_Call {
2418	return &MockHistoryRepository_GetDailyVisitCount_Call{Call: _e.mock.On("GetDailyVisitCount", ctx, daysAgo)}
2419}
2420
2421func (_c *MockHistoryRepository_GetDailyVisitCount_Call) Run(run func(ctx context.Context, daysAgo string)) *MockHistoryRepository_GetDailyVisitCount_Call {
2422	_c.Call.Run(func(args mock.Arguments) {
2423		var arg0 context.Context
2424		if args[0] != nil {
2425			arg0 = args[0].(context.Context)
2426		}
2427		var arg1 string
2428		if args[1] != nil {
2429			arg1 = args[1].(string)
2430		}
2431		run(
2432			arg0,
2433			arg1,
2434		)
2435	})
2436	return _c
2437}
2438
2439func (_c *MockHistoryRepository_GetDailyVisitCount_Call) Return(dailyVisitCounts []*entity.DailyVisitCount, err error) *MockHistoryRepository_GetDailyVisitCount_Call {
2440	_c.Call.Return(dailyVisitCounts, err)
2441	return _c
2442}
2443
2444func (_c *MockHistoryRepository_GetDailyVisitCount_Call) RunAndReturn(run func(ctx context.Context, daysAgo string) ([]*entity.DailyVisitCount, error)) *MockHistoryRepository_GetDailyVisitCount_Call {
2445	_c.Call.Return(run)
2446	return _c
2447}
2448
2449// GetDomainStats provides a mock function for the type MockHistoryRepository
2450func (_mock *MockHistoryRepository) GetDomainStats(ctx context.Context, limit int) ([]*entity.DomainStat, error) {
2451	ret := _mock.Called(ctx, limit)
2452
2453	if len(ret) == 0 {
2454		panic("no return value specified for GetDomainStats")
2455	}
2456
2457	var r0 []*entity.DomainStat
2458	var r1 error
2459	if returnFunc, ok := ret.Get(0).(func(context.Context, int) ([]*entity.DomainStat, error)); ok {
2460		return returnFunc(ctx, limit)
2461	}
2462	if returnFunc, ok := ret.Get(0).(func(context.Context, int) []*entity.DomainStat); ok {
2463		r0 = returnFunc(ctx, limit)
2464	} else {
2465		if ret.Get(0) != nil {
2466			r0 = ret.Get(0).([]*entity.DomainStat)
2467		}
2468	}
2469	if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
2470		r1 = returnFunc(ctx, limit)
2471	} else {
2472		r1 = ret.Error(1)
2473	}
2474	return r0, r1
2475}
2476
2477// MockHistoryRepository_GetDomainStats_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDomainStats'
2478type MockHistoryRepository_GetDomainStats_Call struct {
2479	*mock.Call
2480}
2481
2482// GetDomainStats is a helper method to define mock.On call
2483//   - ctx context.Context
2484//   - limit int
2485func (_e *MockHistoryRepository_Expecter) GetDomainStats(ctx interface{}, limit interface{}) *MockHistoryRepository_GetDomainStats_Call {
2486	return &MockHistoryRepository_GetDomainStats_Call{Call: _e.mock.On("GetDomainStats", ctx, limit)}
2487}
2488
2489func (_c *MockHistoryRepository_GetDomainStats_Call) Run(run func(ctx context.Context, limit int)) *MockHistoryRepository_GetDomainStats_Call {
2490	_c.Call.Run(func(args mock.Arguments) {
2491		var arg0 context.Context
2492		if args[0] != nil {
2493			arg0 = args[0].(context.Context)
2494		}
2495		var arg1 int
2496		if args[1] != nil {
2497			arg1 = args[1].(int)
2498		}
2499		run(
2500			arg0,
2501			arg1,
2502		)
2503	})
2504	return _c
2505}
2506
2507func (_c *MockHistoryRepository_GetDomainStats_Call) Return(domainStats []*entity.DomainStat, err error) *MockHistoryRepository_GetDomainStats_Call {
2508	_c.Call.Return(domainStats, err)
2509	return _c
2510}
2511
2512func (_c *MockHistoryRepository_GetDomainStats_Call) RunAndReturn(run func(ctx context.Context, limit int) ([]*entity.DomainStat, error)) *MockHistoryRepository_GetDomainStats_Call {
2513	_c.Call.Return(run)
2514	return _c
2515}
2516
2517// GetHourlyDistribution provides a mock function for the type MockHistoryRepository
2518func (_mock *MockHistoryRepository) GetHourlyDistribution(ctx context.Context) ([]*entity.HourlyDistribution, error) {
2519	ret := _mock.Called(ctx)
2520
2521	if len(ret) == 0 {
2522		panic("no return value specified for GetHourlyDistribution")
2523	}
2524
2525	var r0 []*entity.HourlyDistribution
2526	var r1 error
2527	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*entity.HourlyDistribution, error)); ok {
2528		return returnFunc(ctx)
2529	}
2530	if returnFunc, ok := ret.Get(0).(func(context.Context) []*entity.HourlyDistribution); ok {
2531		r0 = returnFunc(ctx)
2532	} else {
2533		if ret.Get(0) != nil {
2534			r0 = ret.Get(0).([]*entity.HourlyDistribution)
2535		}
2536	}
2537	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
2538		r1 = returnFunc(ctx)
2539	} else {
2540		r1 = ret.Error(1)
2541	}
2542	return r0, r1
2543}
2544
2545// MockHistoryRepository_GetHourlyDistribution_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHourlyDistribution'
2546type MockHistoryRepository_GetHourlyDistribution_Call struct {
2547	*mock.Call
2548}
2549
2550// GetHourlyDistribution is a helper method to define mock.On call
2551//   - ctx context.Context
2552func (_e *MockHistoryRepository_Expecter) GetHourlyDistribution(ctx interface{}) *MockHistoryRepository_GetHourlyDistribution_Call {
2553	return &MockHistoryRepository_GetHourlyDistribution_Call{Call: _e.mock.On("GetHourlyDistribution", ctx)}
2554}
2555
2556func (_c *MockHistoryRepository_GetHourlyDistribution_Call) Run(run func(ctx context.Context)) *MockHistoryRepository_GetHourlyDistribution_Call {
2557	_c.Call.Run(func(args mock.Arguments) {
2558		var arg0 context.Context
2559		if args[0] != nil {
2560			arg0 = args[0].(context.Context)
2561		}
2562		run(
2563			arg0,
2564		)
2565	})
2566	return _c
2567}
2568
2569func (_c *MockHistoryRepository_GetHourlyDistribution_Call) Return(hourlyDistributions []*entity.HourlyDistribution, err error) *MockHistoryRepository_GetHourlyDistribution_Call {
2570	_c.Call.Return(hourlyDistributions, err)
2571	return _c
2572}
2573
2574func (_c *MockHistoryRepository_GetHourlyDistribution_Call) RunAndReturn(run func(ctx context.Context) ([]*entity.HourlyDistribution, error)) *MockHistoryRepository_GetHourlyDistribution_Call {
2575	_c.Call.Return(run)
2576	return _c
2577}
2578
2579// GetMostVisited provides a mock function for the type MockHistoryRepository
2580func (_mock *MockHistoryRepository) GetMostVisited(ctx context.Context, days int) ([]*entity.HistoryEntry, error) {
2581	ret := _mock.Called(ctx, days)
2582
2583	if len(ret) == 0 {
2584		panic("no return value specified for GetMostVisited")
2585	}
2586
2587	var r0 []*entity.HistoryEntry
2588	var r1 error
2589	if returnFunc, ok := ret.Get(0).(func(context.Context, int) ([]*entity.HistoryEntry, error)); ok {
2590		return returnFunc(ctx, days)
2591	}
2592	if returnFunc, ok := ret.Get(0).(func(context.Context, int) []*entity.HistoryEntry); ok {
2593		r0 = returnFunc(ctx, days)
2594	} else {
2595		if ret.Get(0) != nil {
2596			r0 = ret.Get(0).([]*entity.HistoryEntry)
2597		}
2598	}
2599	if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
2600		r1 = returnFunc(ctx, days)
2601	} else {
2602		r1 = ret.Error(1)
2603	}
2604	return r0, r1
2605}
2606
2607// MockHistoryRepository_GetMostVisited_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMostVisited'
2608type MockHistoryRepository_GetMostVisited_Call struct {
2609	*mock.Call
2610}
2611
2612// GetMostVisited is a helper method to define mock.On call
2613//   - ctx context.Context
2614//   - days int
2615func (_e *MockHistoryRepository_Expecter) GetMostVisited(ctx interface{}, days interface{}) *MockHistoryRepository_GetMostVisited_Call {
2616	return &MockHistoryRepository_GetMostVisited_Call{Call: _e.mock.On("GetMostVisited", ctx, days)}
2617}
2618
2619func (_c *MockHistoryRepository_GetMostVisited_Call) Run(run func(ctx context.Context, days int)) *MockHistoryRepository_GetMostVisited_Call {
2620	_c.Call.Run(func(args mock.Arguments) {
2621		var arg0 context.Context
2622		if args[0] != nil {
2623			arg0 = args[0].(context.Context)
2624		}
2625		var arg1 int
2626		if args[1] != nil {
2627			arg1 = args[1].(int)
2628		}
2629		run(
2630			arg0,
2631			arg1,
2632		)
2633	})
2634	return _c
2635}
2636
2637func (_c *MockHistoryRepository_GetMostVisited_Call) Return(historyEntrys []*entity.HistoryEntry, err error) *MockHistoryRepository_GetMostVisited_Call {
2638	_c.Call.Return(historyEntrys, err)
2639	return _c
2640}
2641
2642func (_c *MockHistoryRepository_GetMostVisited_Call) RunAndReturn(run func(ctx context.Context, days int) ([]*entity.HistoryEntry, error)) *MockHistoryRepository_GetMostVisited_Call {
2643	_c.Call.Return(run)
2644	return _c
2645}
2646
2647// GetRecent provides a mock function for the type MockHistoryRepository
2648func (_mock *MockHistoryRepository) GetRecent(ctx context.Context, limit int, offset int) ([]*entity.HistoryEntry, error) {
2649	ret := _mock.Called(ctx, limit, offset)
2650
2651	if len(ret) == 0 {
2652		panic("no return value specified for GetRecent")
2653	}
2654
2655	var r0 []*entity.HistoryEntry
2656	var r1 error
2657	if returnFunc, ok := ret.Get(0).(func(context.Context, int, int) ([]*entity.HistoryEntry, error)); ok {
2658		return returnFunc(ctx, limit, offset)
2659	}
2660	if returnFunc, ok := ret.Get(0).(func(context.Context, int, int) []*entity.HistoryEntry); ok {
2661		r0 = returnFunc(ctx, limit, offset)
2662	} else {
2663		if ret.Get(0) != nil {
2664			r0 = ret.Get(0).([]*entity.HistoryEntry)
2665		}
2666	}
2667	if returnFunc, ok := ret.Get(1).(func(context.Context, int, int) error); ok {
2668		r1 = returnFunc(ctx, limit, offset)
2669	} else {
2670		r1 = ret.Error(1)
2671	}
2672	return r0, r1
2673}
2674
2675// MockHistoryRepository_GetRecent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRecent'
2676type MockHistoryRepository_GetRecent_Call struct {
2677	*mock.Call
2678}
2679
2680// GetRecent is a helper method to define mock.On call
2681//   - ctx context.Context
2682//   - limit int
2683//   - offset int
2684func (_e *MockHistoryRepository_Expecter) GetRecent(ctx interface{}, limit interface{}, offset interface{}) *MockHistoryRepository_GetRecent_Call {
2685	return &MockHistoryRepository_GetRecent_Call{Call: _e.mock.On("GetRecent", ctx, limit, offset)}
2686}
2687
2688func (_c *MockHistoryRepository_GetRecent_Call) Run(run func(ctx context.Context, limit int, offset int)) *MockHistoryRepository_GetRecent_Call {
2689	_c.Call.Run(func(args mock.Arguments) {
2690		var arg0 context.Context
2691		if args[0] != nil {
2692			arg0 = args[0].(context.Context)
2693		}
2694		var arg1 int
2695		if args[1] != nil {
2696			arg1 = args[1].(int)
2697		}
2698		var arg2 int
2699		if args[2] != nil {
2700			arg2 = args[2].(int)
2701		}
2702		run(
2703			arg0,
2704			arg1,
2705			arg2,
2706		)
2707	})
2708	return _c
2709}
2710
2711func (_c *MockHistoryRepository_GetRecent_Call) Return(historyEntrys []*entity.HistoryEntry, err error) *MockHistoryRepository_GetRecent_Call {
2712	_c.Call.Return(historyEntrys, err)
2713	return _c
2714}
2715
2716func (_c *MockHistoryRepository_GetRecent_Call) RunAndReturn(run func(ctx context.Context, limit int, offset int) ([]*entity.HistoryEntry, error)) *MockHistoryRepository_GetRecent_Call {
2717	_c.Call.Return(run)
2718	return _c
2719}
2720
2721// GetRecentByDomain provides a mock function for the type MockHistoryRepository
2722func (_mock *MockHistoryRepository) GetRecentByDomain(ctx context.Context, domain string, limit int, offset int) ([]*entity.HistoryEntry, error) {
2723	ret := _mock.Called(ctx, domain, limit, offset)
2724
2725	if len(ret) == 0 {
2726		panic("no return value specified for GetRecentByDomain")
2727	}
2728
2729	var r0 []*entity.HistoryEntry
2730	var r1 error
2731	if returnFunc, ok := ret.Get(0).(func(context.Context, string, int, int) ([]*entity.HistoryEntry, error)); ok {
2732		return returnFunc(ctx, domain, limit, offset)
2733	}
2734	if returnFunc, ok := ret.Get(0).(func(context.Context, string, int, int) []*entity.HistoryEntry); ok {
2735		r0 = returnFunc(ctx, domain, limit, offset)
2736	} else {
2737		if ret.Get(0) != nil {
2738			r0 = ret.Get(0).([]*entity.HistoryEntry)
2739		}
2740	}
2741	if returnFunc, ok := ret.Get(1).(func(context.Context, string, int, int) error); ok {
2742		r1 = returnFunc(ctx, domain, limit, offset)
2743	} else {
2744		r1 = ret.Error(1)
2745	}
2746	return r0, r1
2747}
2748
2749// MockHistoryRepository_GetRecentByDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRecentByDomain'
2750type MockHistoryRepository_GetRecentByDomain_Call struct {
2751	*mock.Call
2752}
2753
2754// GetRecentByDomain is a helper method to define mock.On call
2755//   - ctx context.Context
2756//   - domain string
2757//   - limit int
2758//   - offset int
2759func (_e *MockHistoryRepository_Expecter) GetRecentByDomain(ctx interface{}, domain interface{}, limit interface{}, offset interface{}) *MockHistoryRepository_GetRecentByDomain_Call {
2760	return &MockHistoryRepository_GetRecentByDomain_Call{Call: _e.mock.On("GetRecentByDomain", ctx, domain, limit, offset)}
2761}
2762
2763func (_c *MockHistoryRepository_GetRecentByDomain_Call) Run(run func(ctx context.Context, domain string, limit int, offset int)) *MockHistoryRepository_GetRecentByDomain_Call {
2764	_c.Call.Run(func(args mock.Arguments) {
2765		var arg0 context.Context
2766		if args[0] != nil {
2767			arg0 = args[0].(context.Context)
2768		}
2769		var arg1 string
2770		if args[1] != nil {
2771			arg1 = args[1].(string)
2772		}
2773		var arg2 int
2774		if args[2] != nil {
2775			arg2 = args[2].(int)
2776		}
2777		var arg3 int
2778		if args[3] != nil {
2779			arg3 = args[3].(int)
2780		}
2781		run(
2782			arg0,
2783			arg1,
2784			arg2,
2785			arg3,
2786		)
2787	})
2788	return _c
2789}
2790
2791func (_c *MockHistoryRepository_GetRecentByDomain_Call) Return(historyEntrys []*entity.HistoryEntry, err error) *MockHistoryRepository_GetRecentByDomain_Call {
2792	_c.Call.Return(historyEntrys, err)
2793	return _c
2794}
2795
2796func (_c *MockHistoryRepository_GetRecentByDomain_Call) RunAndReturn(run func(ctx context.Context, domain string, limit int, offset int) ([]*entity.HistoryEntry, error)) *MockHistoryRepository_GetRecentByDomain_Call {
2797	_c.Call.Return(run)
2798	return _c
2799}
2800
2801// GetRecentSince provides a mock function for the type MockHistoryRepository
2802func (_mock *MockHistoryRepository) GetRecentSince(ctx context.Context, days int) ([]*entity.HistoryEntry, error) {
2803	ret := _mock.Called(ctx, days)
2804
2805	if len(ret) == 0 {
2806		panic("no return value specified for GetRecentSince")
2807	}
2808
2809	var r0 []*entity.HistoryEntry
2810	var r1 error
2811	if returnFunc, ok := ret.Get(0).(func(context.Context, int) ([]*entity.HistoryEntry, error)); ok {
2812		return returnFunc(ctx, days)
2813	}
2814	if returnFunc, ok := ret.Get(0).(func(context.Context, int) []*entity.HistoryEntry); ok {
2815		r0 = returnFunc(ctx, days)
2816	} else {
2817		if ret.Get(0) != nil {
2818			r0 = ret.Get(0).([]*entity.HistoryEntry)
2819		}
2820	}
2821	if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
2822		r1 = returnFunc(ctx, days)
2823	} else {
2824		r1 = ret.Error(1)
2825	}
2826	return r0, r1
2827}
2828
2829// MockHistoryRepository_GetRecentSince_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRecentSince'
2830type MockHistoryRepository_GetRecentSince_Call struct {
2831	*mock.Call
2832}
2833
2834// GetRecentSince is a helper method to define mock.On call
2835//   - ctx context.Context
2836//   - days int
2837func (_e *MockHistoryRepository_Expecter) GetRecentSince(ctx interface{}, days interface{}) *MockHistoryRepository_GetRecentSince_Call {
2838	return &MockHistoryRepository_GetRecentSince_Call{Call: _e.mock.On("GetRecentSince", ctx, days)}
2839}
2840
2841func (_c *MockHistoryRepository_GetRecentSince_Call) Run(run func(ctx context.Context, days int)) *MockHistoryRepository_GetRecentSince_Call {
2842	_c.Call.Run(func(args mock.Arguments) {
2843		var arg0 context.Context
2844		if args[0] != nil {
2845			arg0 = args[0].(context.Context)
2846		}
2847		var arg1 int
2848		if args[1] != nil {
2849			arg1 = args[1].(int)
2850		}
2851		run(
2852			arg0,
2853			arg1,
2854		)
2855	})
2856	return _c
2857}
2858
2859func (_c *MockHistoryRepository_GetRecentSince_Call) Return(historyEntrys []*entity.HistoryEntry, err error) *MockHistoryRepository_GetRecentSince_Call {
2860	_c.Call.Return(historyEntrys, err)
2861	return _c
2862}
2863
2864func (_c *MockHistoryRepository_GetRecentSince_Call) RunAndReturn(run func(ctx context.Context, days int) ([]*entity.HistoryEntry, error)) *MockHistoryRepository_GetRecentSince_Call {
2865	_c.Call.Return(run)
2866	return _c
2867}
2868
2869// GetRecentWindow provides a mock function for the type MockHistoryRepository
2870func (_mock *MockHistoryRepository) GetRecentWindow(ctx context.Context, before time.Time, after time.Time) ([]*entity.HistoryEntry, error) {
2871	ret := _mock.Called(ctx, before, after)
2872
2873	if len(ret) == 0 {
2874		panic("no return value specified for GetRecentWindow")
2875	}
2876
2877	var r0 []*entity.HistoryEntry
2878	var r1 error
2879	if returnFunc, ok := ret.Get(0).(func(context.Context, time.Time, time.Time) ([]*entity.HistoryEntry, error)); ok {
2880		return returnFunc(ctx, before, after)
2881	}
2882	if returnFunc, ok := ret.Get(0).(func(context.Context, time.Time, time.Time) []*entity.HistoryEntry); ok {
2883		r0 = returnFunc(ctx, before, after)
2884	} else {
2885		if ret.Get(0) != nil {
2886			r0 = ret.Get(0).([]*entity.HistoryEntry)
2887		}
2888	}
2889	if returnFunc, ok := ret.Get(1).(func(context.Context, time.Time, time.Time) error); ok {
2890		r1 = returnFunc(ctx, before, after)
2891	} else {
2892		r1 = ret.Error(1)
2893	}
2894	return r0, r1
2895}
2896
2897// MockHistoryRepository_GetRecentWindow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRecentWindow'
2898type MockHistoryRepository_GetRecentWindow_Call struct {
2899	*mock.Call
2900}
2901
2902// GetRecentWindow is a helper method to define mock.On call
2903//   - ctx context.Context
2904//   - before time.Time
2905//   - after time.Time
2906func (_e *MockHistoryRepository_Expecter) GetRecentWindow(ctx interface{}, before interface{}, after interface{}) *MockHistoryRepository_GetRecentWindow_Call {
2907	return &MockHistoryRepository_GetRecentWindow_Call{Call: _e.mock.On("GetRecentWindow", ctx, before, after)}
2908}
2909
2910func (_c *MockHistoryRepository_GetRecentWindow_Call) Run(run func(ctx context.Context, before time.Time, after time.Time)) *MockHistoryRepository_GetRecentWindow_Call {
2911	_c.Call.Run(func(args mock.Arguments) {
2912		var arg0 context.Context
2913		if args[0] != nil {
2914			arg0 = args[0].(context.Context)
2915		}
2916		var arg1 time.Time
2917		if args[1] != nil {
2918			arg1 = args[1].(time.Time)
2919		}
2920		var arg2 time.Time
2921		if args[2] != nil {
2922			arg2 = args[2].(time.Time)
2923		}
2924		run(
2925			arg0,
2926			arg1,
2927			arg2,
2928		)
2929	})
2930	return _c
2931}
2932
2933func (_c *MockHistoryRepository_GetRecentWindow_Call) Return(historyEntrys []*entity.HistoryEntry, err error) *MockHistoryRepository_GetRecentWindow_Call {
2934	_c.Call.Return(historyEntrys, err)
2935	return _c
2936}
2937
2938func (_c *MockHistoryRepository_GetRecentWindow_Call) RunAndReturn(run func(ctx context.Context, before time.Time, after time.Time) ([]*entity.HistoryEntry, error)) *MockHistoryRepository_GetRecentWindow_Call {
2939	_c.Call.Return(run)
2940	return _c
2941}
2942
2943// GetRecentWindowByDomain provides a mock function for the type MockHistoryRepository
2944func (_mock *MockHistoryRepository) GetRecentWindowByDomain(ctx context.Context, domain string, before time.Time, after time.Time) ([]*entity.HistoryEntry, error) {
2945	ret := _mock.Called(ctx, domain, before, after)
2946
2947	if len(ret) == 0 {
2948		panic("no return value specified for GetRecentWindowByDomain")
2949	}
2950
2951	var r0 []*entity.HistoryEntry
2952	var r1 error
2953	if returnFunc, ok := ret.Get(0).(func(context.Context, string, time.Time, time.Time) ([]*entity.HistoryEntry, error)); ok {
2954		return returnFunc(ctx, domain, before, after)
2955	}
2956	if returnFunc, ok := ret.Get(0).(func(context.Context, string, time.Time, time.Time) []*entity.HistoryEntry); ok {
2957		r0 = returnFunc(ctx, domain, before, after)
2958	} else {
2959		if ret.Get(0) != nil {
2960			r0 = ret.Get(0).([]*entity.HistoryEntry)
2961		}
2962	}
2963	if returnFunc, ok := ret.Get(1).(func(context.Context, string, time.Time, time.Time) error); ok {
2964		r1 = returnFunc(ctx, domain, before, after)
2965	} else {
2966		r1 = ret.Error(1)
2967	}
2968	return r0, r1
2969}
2970
2971// MockHistoryRepository_GetRecentWindowByDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRecentWindowByDomain'
2972type MockHistoryRepository_GetRecentWindowByDomain_Call struct {
2973	*mock.Call
2974}
2975
2976// GetRecentWindowByDomain is a helper method to define mock.On call
2977//   - ctx context.Context
2978//   - domain string
2979//   - before time.Time
2980//   - after time.Time
2981func (_e *MockHistoryRepository_Expecter) GetRecentWindowByDomain(ctx interface{}, domain interface{}, before interface{}, after interface{}) *MockHistoryRepository_GetRecentWindowByDomain_Call {
2982	return &MockHistoryRepository_GetRecentWindowByDomain_Call{Call: _e.mock.On("GetRecentWindowByDomain", ctx, domain, before, after)}
2983}
2984
2985func (_c *MockHistoryRepository_GetRecentWindowByDomain_Call) Run(run func(ctx context.Context, domain string, before time.Time, after time.Time)) *MockHistoryRepository_GetRecentWindowByDomain_Call {
2986	_c.Call.Run(func(args mock.Arguments) {
2987		var arg0 context.Context
2988		if args[0] != nil {
2989			arg0 = args[0].(context.Context)
2990		}
2991		var arg1 string
2992		if args[1] != nil {
2993			arg1 = args[1].(string)
2994		}
2995		var arg2 time.Time
2996		if args[2] != nil {
2997			arg2 = args[2].(time.Time)
2998		}
2999		var arg3 time.Time
3000		if args[3] != nil {
3001			arg3 = args[3].(time.Time)
3002		}
3003		run(
3004			arg0,
3005			arg1,
3006			arg2,
3007			arg3,
3008		)
3009	})
3010	return _c
3011}
3012
3013func (_c *MockHistoryRepository_GetRecentWindowByDomain_Call) Return(historyEntrys []*entity.HistoryEntry, err error) *MockHistoryRepository_GetRecentWindowByDomain_Call {
3014	_c.Call.Return(historyEntrys, err)
3015	return _c
3016}
3017
3018func (_c *MockHistoryRepository_GetRecentWindowByDomain_Call) RunAndReturn(run func(ctx context.Context, domain string, before time.Time, after time.Time) ([]*entity.HistoryEntry, error)) *MockHistoryRepository_GetRecentWindowByDomain_Call {
3019	_c.Call.Return(run)
3020	return _c
3021}
3022
3023// GetStats provides a mock function for the type MockHistoryRepository
3024func (_mock *MockHistoryRepository) GetStats(ctx context.Context) (*entity.HistoryStats, error) {
3025	ret := _mock.Called(ctx)
3026
3027	if len(ret) == 0 {
3028		panic("no return value specified for GetStats")
3029	}
3030
3031	var r0 *entity.HistoryStats
3032	var r1 error
3033	if returnFunc, ok := ret.Get(0).(func(context.Context) (*entity.HistoryStats, error)); ok {
3034		return returnFunc(ctx)
3035	}
3036	if returnFunc, ok := ret.Get(0).(func(context.Context) *entity.HistoryStats); ok {
3037		r0 = returnFunc(ctx)
3038	} else {
3039		if ret.Get(0) != nil {
3040			r0 = ret.Get(0).(*entity.HistoryStats)
3041		}
3042	}
3043	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
3044		r1 = returnFunc(ctx)
3045	} else {
3046		r1 = ret.Error(1)
3047	}
3048	return r0, r1
3049}
3050
3051// MockHistoryRepository_GetStats_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStats'
3052type MockHistoryRepository_GetStats_Call struct {
3053	*mock.Call
3054}
3055
3056// GetStats is a helper method to define mock.On call
3057//   - ctx context.Context
3058func (_e *MockHistoryRepository_Expecter) GetStats(ctx interface{}) *MockHistoryRepository_GetStats_Call {
3059	return &MockHistoryRepository_GetStats_Call{Call: _e.mock.On("GetStats", ctx)}
3060}
3061
3062func (_c *MockHistoryRepository_GetStats_Call) Run(run func(ctx context.Context)) *MockHistoryRepository_GetStats_Call {
3063	_c.Call.Run(func(args mock.Arguments) {
3064		var arg0 context.Context
3065		if args[0] != nil {
3066			arg0 = args[0].(context.Context)
3067		}
3068		run(
3069			arg0,
3070		)
3071	})
3072	return _c
3073}
3074
3075func (_c *MockHistoryRepository_GetStats_Call) Return(historyStats *entity.HistoryStats, err error) *MockHistoryRepository_GetStats_Call {
3076	_c.Call.Return(historyStats, err)
3077	return _c
3078}
3079
3080func (_c *MockHistoryRepository_GetStats_Call) RunAndReturn(run func(ctx context.Context) (*entity.HistoryStats, error)) *MockHistoryRepository_GetStats_Call {
3081	_c.Call.Return(run)
3082	return _c
3083}
3084
3085// HasEntriesBefore provides a mock function for the type MockHistoryRepository
3086func (_mock *MockHistoryRepository) HasEntriesBefore(ctx context.Context, before time.Time) (bool, error) {
3087	ret := _mock.Called(ctx, before)
3088
3089	if len(ret) == 0 {
3090		panic("no return value specified for HasEntriesBefore")
3091	}
3092
3093	var r0 bool
3094	var r1 error
3095	if returnFunc, ok := ret.Get(0).(func(context.Context, time.Time) (bool, error)); ok {
3096		return returnFunc(ctx, before)
3097	}
3098	if returnFunc, ok := ret.Get(0).(func(context.Context, time.Time) bool); ok {
3099		r0 = returnFunc(ctx, before)
3100	} else {
3101		r0 = ret.Get(0).(bool)
3102	}
3103	if returnFunc, ok := ret.Get(1).(func(context.Context, time.Time) error); ok {
3104		r1 = returnFunc(ctx, before)
3105	} else {
3106		r1 = ret.Error(1)
3107	}
3108	return r0, r1
3109}
3110
3111// MockHistoryRepository_HasEntriesBefore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasEntriesBefore'
3112type MockHistoryRepository_HasEntriesBefore_Call struct {
3113	*mock.Call
3114}
3115
3116// HasEntriesBefore is a helper method to define mock.On call
3117//   - ctx context.Context
3118//   - before time.Time
3119func (_e *MockHistoryRepository_Expecter) HasEntriesBefore(ctx interface{}, before interface{}) *MockHistoryRepository_HasEntriesBefore_Call {
3120	return &MockHistoryRepository_HasEntriesBefore_Call{Call: _e.mock.On("HasEntriesBefore", ctx, before)}
3121}
3122
3123func (_c *MockHistoryRepository_HasEntriesBefore_Call) Run(run func(ctx context.Context, before time.Time)) *MockHistoryRepository_HasEntriesBefore_Call {
3124	_c.Call.Run(func(args mock.Arguments) {
3125		var arg0 context.Context
3126		if args[0] != nil {
3127			arg0 = args[0].(context.Context)
3128		}
3129		var arg1 time.Time
3130		if args[1] != nil {
3131			arg1 = args[1].(time.Time)
3132		}
3133		run(
3134			arg0,
3135			arg1,
3136		)
3137	})
3138	return _c
3139}
3140
3141func (_c *MockHistoryRepository_HasEntriesBefore_Call) Return(b bool, err error) *MockHistoryRepository_HasEntriesBefore_Call {
3142	_c.Call.Return(b, err)
3143	return _c
3144}
3145
3146func (_c *MockHistoryRepository_HasEntriesBefore_Call) RunAndReturn(run func(ctx context.Context, before time.Time) (bool, error)) *MockHistoryRepository_HasEntriesBefore_Call {
3147	_c.Call.Return(run)
3148	return _c
3149}
3150
3151// HasEntriesByDomainBefore provides a mock function for the type MockHistoryRepository
3152func (_mock *MockHistoryRepository) HasEntriesByDomainBefore(ctx context.Context, domain string, before time.Time) (bool, error) {
3153	ret := _mock.Called(ctx, domain, before)
3154
3155	if len(ret) == 0 {
3156		panic("no return value specified for HasEntriesByDomainBefore")
3157	}
3158
3159	var r0 bool
3160	var r1 error
3161	if returnFunc, ok := ret.Get(0).(func(context.Context, string, time.Time) (bool, error)); ok {
3162		return returnFunc(ctx, domain, before)
3163	}
3164	if returnFunc, ok := ret.Get(0).(func(context.Context, string, time.Time) bool); ok {
3165		r0 = returnFunc(ctx, domain, before)
3166	} else {
3167		r0 = ret.Get(0).(bool)
3168	}
3169	if returnFunc, ok := ret.Get(1).(func(context.Context, string, time.Time) error); ok {
3170		r1 = returnFunc(ctx, domain, before)
3171	} else {
3172		r1 = ret.Error(1)
3173	}
3174	return r0, r1
3175}
3176
3177// MockHistoryRepository_HasEntriesByDomainBefore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasEntriesByDomainBefore'
3178type MockHistoryRepository_HasEntriesByDomainBefore_Call struct {
3179	*mock.Call
3180}
3181
3182// HasEntriesByDomainBefore is a helper method to define mock.On call
3183//   - ctx context.Context
3184//   - domain string
3185//   - before time.Time
3186func (_e *MockHistoryRepository_Expecter) HasEntriesByDomainBefore(ctx interface{}, domain interface{}, before interface{}) *MockHistoryRepository_HasEntriesByDomainBefore_Call {
3187	return &MockHistoryRepository_HasEntriesByDomainBefore_Call{Call: _e.mock.On("HasEntriesByDomainBefore", ctx, domain, before)}
3188}
3189
3190func (_c *MockHistoryRepository_HasEntriesByDomainBefore_Call) Run(run func(ctx context.Context, domain string, before time.Time)) *MockHistoryRepository_HasEntriesByDomainBefore_Call {
3191	_c.Call.Run(func(args mock.Arguments) {
3192		var arg0 context.Context
3193		if args[0] != nil {
3194			arg0 = args[0].(context.Context)
3195		}
3196		var arg1 string
3197		if args[1] != nil {
3198			arg1 = args[1].(string)
3199		}
3200		var arg2 time.Time
3201		if args[2] != nil {
3202			arg2 = args[2].(time.Time)
3203		}
3204		run(
3205			arg0,
3206			arg1,
3207			arg2,
3208		)
3209	})
3210	return _c
3211}
3212
3213func (_c *MockHistoryRepository_HasEntriesByDomainBefore_Call) Return(b bool, err error) *MockHistoryRepository_HasEntriesByDomainBefore_Call {
3214	_c.Call.Return(b, err)
3215	return _c
3216}
3217
3218func (_c *MockHistoryRepository_HasEntriesByDomainBefore_Call) RunAndReturn(run func(ctx context.Context, domain string, before time.Time) (bool, error)) *MockHistoryRepository_HasEntriesByDomainBefore_Call {
3219	_c.Call.Return(run)
3220	return _c
3221}
3222
3223// IncrementVisitCount provides a mock function for the type MockHistoryRepository
3224func (_mock *MockHistoryRepository) IncrementVisitCount(ctx context.Context, url string) error {
3225	ret := _mock.Called(ctx, url)
3226
3227	if len(ret) == 0 {
3228		panic("no return value specified for IncrementVisitCount")
3229	}
3230
3231	var r0 error
3232	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
3233		r0 = returnFunc(ctx, url)
3234	} else {
3235		r0 = ret.Error(0)
3236	}
3237	return r0
3238}
3239
3240// MockHistoryRepository_IncrementVisitCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IncrementVisitCount'
3241type MockHistoryRepository_IncrementVisitCount_Call struct {
3242	*mock.Call
3243}
3244
3245// IncrementVisitCount is a helper method to define mock.On call
3246//   - ctx context.Context
3247//   - url string
3248func (_e *MockHistoryRepository_Expecter) IncrementVisitCount(ctx interface{}, url interface{}) *MockHistoryRepository_IncrementVisitCount_Call {
3249	return &MockHistoryRepository_IncrementVisitCount_Call{Call: _e.mock.On("IncrementVisitCount", ctx, url)}
3250}
3251
3252func (_c *MockHistoryRepository_IncrementVisitCount_Call) Run(run func(ctx context.Context, url string)) *MockHistoryRepository_IncrementVisitCount_Call {
3253	_c.Call.Run(func(args mock.Arguments) {
3254		var arg0 context.Context
3255		if args[0] != nil {
3256			arg0 = args[0].(context.Context)
3257		}
3258		var arg1 string
3259		if args[1] != nil {
3260			arg1 = args[1].(string)
3261		}
3262		run(
3263			arg0,
3264			arg1,
3265		)
3266	})
3267	return _c
3268}
3269
3270func (_c *MockHistoryRepository_IncrementVisitCount_Call) Return(err error) *MockHistoryRepository_IncrementVisitCount_Call {
3271	_c.Call.Return(err)
3272	return _c
3273}
3274
3275func (_c *MockHistoryRepository_IncrementVisitCount_Call) RunAndReturn(run func(ctx context.Context, url string) error) *MockHistoryRepository_IncrementVisitCount_Call {
3276	_c.Call.Return(run)
3277	return _c
3278}
3279
3280// Save provides a mock function for the type MockHistoryRepository
3281func (_mock *MockHistoryRepository) Save(ctx context.Context, entry *entity.HistoryEntry) error {
3282	ret := _mock.Called(ctx, entry)
3283
3284	if len(ret) == 0 {
3285		panic("no return value specified for Save")
3286	}
3287
3288	var r0 error
3289	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.HistoryEntry) error); ok {
3290		r0 = returnFunc(ctx, entry)
3291	} else {
3292		r0 = ret.Error(0)
3293	}
3294	return r0
3295}
3296
3297// MockHistoryRepository_Save_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Save'
3298type MockHistoryRepository_Save_Call struct {
3299	*mock.Call
3300}
3301
3302// Save is a helper method to define mock.On call
3303//   - ctx context.Context
3304//   - entry *entity.HistoryEntry
3305func (_e *MockHistoryRepository_Expecter) Save(ctx interface{}, entry interface{}) *MockHistoryRepository_Save_Call {
3306	return &MockHistoryRepository_Save_Call{Call: _e.mock.On("Save", ctx, entry)}
3307}
3308
3309func (_c *MockHistoryRepository_Save_Call) Run(run func(ctx context.Context, entry *entity.HistoryEntry)) *MockHistoryRepository_Save_Call {
3310	_c.Call.Run(func(args mock.Arguments) {
3311		var arg0 context.Context
3312		if args[0] != nil {
3313			arg0 = args[0].(context.Context)
3314		}
3315		var arg1 *entity.HistoryEntry
3316		if args[1] != nil {
3317			arg1 = args[1].(*entity.HistoryEntry)
3318		}
3319		run(
3320			arg0,
3321			arg1,
3322		)
3323	})
3324	return _c
3325}
3326
3327func (_c *MockHistoryRepository_Save_Call) Return(err error) *MockHistoryRepository_Save_Call {
3328	_c.Call.Return(err)
3329	return _c
3330}
3331
3332func (_c *MockHistoryRepository_Save_Call) RunAndReturn(run func(ctx context.Context, entry *entity.HistoryEntry) error) *MockHistoryRepository_Save_Call {
3333	_c.Call.Return(run)
3334	return _c
3335}
3336
3337// Search provides a mock function for the type MockHistoryRepository
3338func (_mock *MockHistoryRepository) Search(ctx context.Context, query string, limit int) ([]entity.HistoryMatch, error) {
3339	ret := _mock.Called(ctx, query, limit)
3340
3341	if len(ret) == 0 {
3342		panic("no return value specified for Search")
3343	}
3344
3345	var r0 []entity.HistoryMatch
3346	var r1 error
3347	if returnFunc, ok := ret.Get(0).(func(context.Context, string, int) ([]entity.HistoryMatch, error)); ok {
3348		return returnFunc(ctx, query, limit)
3349	}
3350	if returnFunc, ok := ret.Get(0).(func(context.Context, string, int) []entity.HistoryMatch); ok {
3351		r0 = returnFunc(ctx, query, limit)
3352	} else {
3353		if ret.Get(0) != nil {
3354			r0 = ret.Get(0).([]entity.HistoryMatch)
3355		}
3356	}
3357	if returnFunc, ok := ret.Get(1).(func(context.Context, string, int) error); ok {
3358		r1 = returnFunc(ctx, query, limit)
3359	} else {
3360		r1 = ret.Error(1)
3361	}
3362	return r0, r1
3363}
3364
3365// MockHistoryRepository_Search_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Search'
3366type MockHistoryRepository_Search_Call struct {
3367	*mock.Call
3368}
3369
3370// Search is a helper method to define mock.On call
3371//   - ctx context.Context
3372//   - query string
3373//   - limit int
3374func (_e *MockHistoryRepository_Expecter) Search(ctx interface{}, query interface{}, limit interface{}) *MockHistoryRepository_Search_Call {
3375	return &MockHistoryRepository_Search_Call{Call: _e.mock.On("Search", ctx, query, limit)}
3376}
3377
3378func (_c *MockHistoryRepository_Search_Call) Run(run func(ctx context.Context, query string, limit int)) *MockHistoryRepository_Search_Call {
3379	_c.Call.Run(func(args mock.Arguments) {
3380		var arg0 context.Context
3381		if args[0] != nil {
3382			arg0 = args[0].(context.Context)
3383		}
3384		var arg1 string
3385		if args[1] != nil {
3386			arg1 = args[1].(string)
3387		}
3388		var arg2 int
3389		if args[2] != nil {
3390			arg2 = args[2].(int)
3391		}
3392		run(
3393			arg0,
3394			arg1,
3395			arg2,
3396		)
3397	})
3398	return _c
3399}
3400
3401func (_c *MockHistoryRepository_Search_Call) Return(historyMatchs []entity.HistoryMatch, err error) *MockHistoryRepository_Search_Call {
3402	_c.Call.Return(historyMatchs, err)
3403	return _c
3404}
3405
3406func (_c *MockHistoryRepository_Search_Call) RunAndReturn(run func(ctx context.Context, query string, limit int) ([]entity.HistoryMatch, error)) *MockHistoryRepository_Search_Call {
3407	_c.Call.Return(run)
3408	return _c
3409}
3410
3411// 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.
3412// The first argument is typically a *testing.T value.
3413func NewMockSessionRepository(t interface {
3414	mock.TestingT
3415	Cleanup(func())
3416}) *MockSessionRepository {
3417	mock := &MockSessionRepository{}
3418	mock.Mock.Test(t)
3419
3420	t.Cleanup(func() { mock.AssertExpectations(t) })
3421
3422	return mock
3423}
3424
3425// MockSessionRepository is an autogenerated mock type for the SessionRepository type
3426type MockSessionRepository struct {
3427	mock.Mock
3428}
3429
3430type MockSessionRepository_Expecter struct {
3431	mock *mock.Mock
3432}
3433
3434func (_m *MockSessionRepository) EXPECT() *MockSessionRepository_Expecter {
3435	return &MockSessionRepository_Expecter{mock: &_m.Mock}
3436}
3437
3438// Delete provides a mock function for the type MockSessionRepository
3439func (_mock *MockSessionRepository) Delete(ctx context.Context, id entity.SessionID) error {
3440	ret := _mock.Called(ctx, id)
3441
3442	if len(ret) == 0 {
3443		panic("no return value specified for Delete")
3444	}
3445
3446	var r0 error
3447	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID) error); ok {
3448		r0 = returnFunc(ctx, id)
3449	} else {
3450		r0 = ret.Error(0)
3451	}
3452	return r0
3453}
3454
3455// MockSessionRepository_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
3456type MockSessionRepository_Delete_Call struct {
3457	*mock.Call
3458}
3459
3460// Delete is a helper method to define mock.On call
3461//   - ctx context.Context
3462//   - id entity.SessionID
3463func (_e *MockSessionRepository_Expecter) Delete(ctx interface{}, id interface{}) *MockSessionRepository_Delete_Call {
3464	return &MockSessionRepository_Delete_Call{Call: _e.mock.On("Delete", ctx, id)}
3465}
3466
3467func (_c *MockSessionRepository_Delete_Call) Run(run func(ctx context.Context, id entity.SessionID)) *MockSessionRepository_Delete_Call {
3468	_c.Call.Run(func(args mock.Arguments) {
3469		var arg0 context.Context
3470		if args[0] != nil {
3471			arg0 = args[0].(context.Context)
3472		}
3473		var arg1 entity.SessionID
3474		if args[1] != nil {
3475			arg1 = args[1].(entity.SessionID)
3476		}
3477		run(
3478			arg0,
3479			arg1,
3480		)
3481	})
3482	return _c
3483}
3484
3485func (_c *MockSessionRepository_Delete_Call) Return(err error) *MockSessionRepository_Delete_Call {
3486	_c.Call.Return(err)
3487	return _c
3488}
3489
3490func (_c *MockSessionRepository_Delete_Call) RunAndReturn(run func(ctx context.Context, id entity.SessionID) error) *MockSessionRepository_Delete_Call {
3491	_c.Call.Return(run)
3492	return _c
3493}
3494
3495// DeleteExitedBefore provides a mock function for the type MockSessionRepository
3496func (_mock *MockSessionRepository) DeleteExitedBefore(ctx context.Context, cutoff time.Time) (int64, error) {
3497	ret := _mock.Called(ctx, cutoff)
3498
3499	if len(ret) == 0 {
3500		panic("no return value specified for DeleteExitedBefore")
3501	}
3502
3503	var r0 int64
3504	var r1 error
3505	if returnFunc, ok := ret.Get(0).(func(context.Context, time.Time) (int64, error)); ok {
3506		return returnFunc(ctx, cutoff)
3507	}
3508	if returnFunc, ok := ret.Get(0).(func(context.Context, time.Time) int64); ok {
3509		r0 = returnFunc(ctx, cutoff)
3510	} else {
3511		r0 = ret.Get(0).(int64)
3512	}
3513	if returnFunc, ok := ret.Get(1).(func(context.Context, time.Time) error); ok {
3514		r1 = returnFunc(ctx, cutoff)
3515	} else {
3516		r1 = ret.Error(1)
3517	}
3518	return r0, r1
3519}
3520
3521// MockSessionRepository_DeleteExitedBefore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteExitedBefore'
3522type MockSessionRepository_DeleteExitedBefore_Call struct {
3523	*mock.Call
3524}
3525
3526// DeleteExitedBefore is a helper method to define mock.On call
3527//   - ctx context.Context
3528//   - cutoff time.Time
3529func (_e *MockSessionRepository_Expecter) DeleteExitedBefore(ctx interface{}, cutoff interface{}) *MockSessionRepository_DeleteExitedBefore_Call {
3530	return &MockSessionRepository_DeleteExitedBefore_Call{Call: _e.mock.On("DeleteExitedBefore", ctx, cutoff)}
3531}
3532
3533func (_c *MockSessionRepository_DeleteExitedBefore_Call) Run(run func(ctx context.Context, cutoff time.Time)) *MockSessionRepository_DeleteExitedBefore_Call {
3534	_c.Call.Run(func(args mock.Arguments) {
3535		var arg0 context.Context
3536		if args[0] != nil {
3537			arg0 = args[0].(context.Context)
3538		}
3539		var arg1 time.Time
3540		if args[1] != nil {
3541			arg1 = args[1].(time.Time)
3542		}
3543		run(
3544			arg0,
3545			arg1,
3546		)
3547	})
3548	return _c
3549}
3550
3551func (_c *MockSessionRepository_DeleteExitedBefore_Call) Return(n int64, err error) *MockSessionRepository_DeleteExitedBefore_Call {
3552	_c.Call.Return(n, err)
3553	return _c
3554}
3555
3556func (_c *MockSessionRepository_DeleteExitedBefore_Call) RunAndReturn(run func(ctx context.Context, cutoff time.Time) (int64, error)) *MockSessionRepository_DeleteExitedBefore_Call {
3557	_c.Call.Return(run)
3558	return _c
3559}
3560
3561// DeleteOldestExited provides a mock function for the type MockSessionRepository
3562func (_mock *MockSessionRepository) DeleteOldestExited(ctx context.Context, keepCount int) (int64, error) {
3563	ret := _mock.Called(ctx, keepCount)
3564
3565	if len(ret) == 0 {
3566		panic("no return value specified for DeleteOldestExited")
3567	}
3568
3569	var r0 int64
3570	var r1 error
3571	if returnFunc, ok := ret.Get(0).(func(context.Context, int) (int64, error)); ok {
3572		return returnFunc(ctx, keepCount)
3573	}
3574	if returnFunc, ok := ret.Get(0).(func(context.Context, int) int64); ok {
3575		r0 = returnFunc(ctx, keepCount)
3576	} else {
3577		r0 = ret.Get(0).(int64)
3578	}
3579	if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
3580		r1 = returnFunc(ctx, keepCount)
3581	} else {
3582		r1 = ret.Error(1)
3583	}
3584	return r0, r1
3585}
3586
3587// MockSessionRepository_DeleteOldestExited_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteOldestExited'
3588type MockSessionRepository_DeleteOldestExited_Call struct {
3589	*mock.Call
3590}
3591
3592// DeleteOldestExited is a helper method to define mock.On call
3593//   - ctx context.Context
3594//   - keepCount int
3595func (_e *MockSessionRepository_Expecter) DeleteOldestExited(ctx interface{}, keepCount interface{}) *MockSessionRepository_DeleteOldestExited_Call {
3596	return &MockSessionRepository_DeleteOldestExited_Call{Call: _e.mock.On("DeleteOldestExited", ctx, keepCount)}
3597}
3598
3599func (_c *MockSessionRepository_DeleteOldestExited_Call) Run(run func(ctx context.Context, keepCount int)) *MockSessionRepository_DeleteOldestExited_Call {
3600	_c.Call.Run(func(args mock.Arguments) {
3601		var arg0 context.Context
3602		if args[0] != nil {
3603			arg0 = args[0].(context.Context)
3604		}
3605		var arg1 int
3606		if args[1] != nil {
3607			arg1 = args[1].(int)
3608		}
3609		run(
3610			arg0,
3611			arg1,
3612		)
3613	})
3614	return _c
3615}
3616
3617func (_c *MockSessionRepository_DeleteOldestExited_Call) Return(n int64, err error) *MockSessionRepository_DeleteOldestExited_Call {
3618	_c.Call.Return(n, err)
3619	return _c
3620}
3621
3622func (_c *MockSessionRepository_DeleteOldestExited_Call) RunAndReturn(run func(ctx context.Context, keepCount int) (int64, error)) *MockSessionRepository_DeleteOldestExited_Call {
3623	_c.Call.Return(run)
3624	return _c
3625}
3626
3627// FindByID provides a mock function for the type MockSessionRepository
3628func (_mock *MockSessionRepository) FindByID(ctx context.Context, id entity.SessionID) (*entity.Session, error) {
3629	ret := _mock.Called(ctx, id)
3630
3631	if len(ret) == 0 {
3632		panic("no return value specified for FindByID")
3633	}
3634
3635	var r0 *entity.Session
3636	var r1 error
3637	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID) (*entity.Session, error)); ok {
3638		return returnFunc(ctx, id)
3639	}
3640	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID) *entity.Session); ok {
3641		r0 = returnFunc(ctx, id)
3642	} else {
3643		if ret.Get(0) != nil {
3644			r0 = ret.Get(0).(*entity.Session)
3645		}
3646	}
3647	if returnFunc, ok := ret.Get(1).(func(context.Context, entity.SessionID) error); ok {
3648		r1 = returnFunc(ctx, id)
3649	} else {
3650		r1 = ret.Error(1)
3651	}
3652	return r0, r1
3653}
3654
3655// MockSessionRepository_FindByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByID'
3656type MockSessionRepository_FindByID_Call struct {
3657	*mock.Call
3658}
3659
3660// FindByID is a helper method to define mock.On call
3661//   - ctx context.Context
3662//   - id entity.SessionID
3663func (_e *MockSessionRepository_Expecter) FindByID(ctx interface{}, id interface{}) *MockSessionRepository_FindByID_Call {
3664	return &MockSessionRepository_FindByID_Call{Call: _e.mock.On("FindByID", ctx, id)}
3665}
3666
3667func (_c *MockSessionRepository_FindByID_Call) Run(run func(ctx context.Context, id entity.SessionID)) *MockSessionRepository_FindByID_Call {
3668	_c.Call.Run(func(args mock.Arguments) {
3669		var arg0 context.Context
3670		if args[0] != nil {
3671			arg0 = args[0].(context.Context)
3672		}
3673		var arg1 entity.SessionID
3674		if args[1] != nil {
3675			arg1 = args[1].(entity.SessionID)
3676		}
3677		run(
3678			arg0,
3679			arg1,
3680		)
3681	})
3682	return _c
3683}
3684
3685func (_c *MockSessionRepository_FindByID_Call) Return(session *entity.Session, err error) *MockSessionRepository_FindByID_Call {
3686	_c.Call.Return(session, err)
3687	return _c
3688}
3689
3690func (_c *MockSessionRepository_FindByID_Call) RunAndReturn(run func(ctx context.Context, id entity.SessionID) (*entity.Session, error)) *MockSessionRepository_FindByID_Call {
3691	_c.Call.Return(run)
3692	return _c
3693}
3694
3695// GetActive provides a mock function for the type MockSessionRepository
3696func (_mock *MockSessionRepository) GetActive(ctx context.Context) (*entity.Session, error) {
3697	ret := _mock.Called(ctx)
3698
3699	if len(ret) == 0 {
3700		panic("no return value specified for GetActive")
3701	}
3702
3703	var r0 *entity.Session
3704	var r1 error
3705	if returnFunc, ok := ret.Get(0).(func(context.Context) (*entity.Session, error)); ok {
3706		return returnFunc(ctx)
3707	}
3708	if returnFunc, ok := ret.Get(0).(func(context.Context) *entity.Session); ok {
3709		r0 = returnFunc(ctx)
3710	} else {
3711		if ret.Get(0) != nil {
3712			r0 = ret.Get(0).(*entity.Session)
3713		}
3714	}
3715	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
3716		r1 = returnFunc(ctx)
3717	} else {
3718		r1 = ret.Error(1)
3719	}
3720	return r0, r1
3721}
3722
3723// MockSessionRepository_GetActive_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetActive'
3724type MockSessionRepository_GetActive_Call struct {
3725	*mock.Call
3726}
3727
3728// GetActive is a helper method to define mock.On call
3729//   - ctx context.Context
3730func (_e *MockSessionRepository_Expecter) GetActive(ctx interface{}) *MockSessionRepository_GetActive_Call {
3731	return &MockSessionRepository_GetActive_Call{Call: _e.mock.On("GetActive", ctx)}
3732}
3733
3734func (_c *MockSessionRepository_GetActive_Call) Run(run func(ctx context.Context)) *MockSessionRepository_GetActive_Call {
3735	_c.Call.Run(func(args mock.Arguments) {
3736		var arg0 context.Context
3737		if args[0] != nil {
3738			arg0 = args[0].(context.Context)
3739		}
3740		run(
3741			arg0,
3742		)
3743	})
3744	return _c
3745}
3746
3747func (_c *MockSessionRepository_GetActive_Call) Return(session *entity.Session, err error) *MockSessionRepository_GetActive_Call {
3748	_c.Call.Return(session, err)
3749	return _c
3750}
3751
3752func (_c *MockSessionRepository_GetActive_Call) RunAndReturn(run func(ctx context.Context) (*entity.Session, error)) *MockSessionRepository_GetActive_Call {
3753	_c.Call.Return(run)
3754	return _c
3755}
3756
3757// GetRecent provides a mock function for the type MockSessionRepository
3758func (_mock *MockSessionRepository) GetRecent(ctx context.Context, limit int) ([]*entity.Session, error) {
3759	ret := _mock.Called(ctx, limit)
3760
3761	if len(ret) == 0 {
3762		panic("no return value specified for GetRecent")
3763	}
3764
3765	var r0 []*entity.Session
3766	var r1 error
3767	if returnFunc, ok := ret.Get(0).(func(context.Context, int) ([]*entity.Session, error)); ok {
3768		return returnFunc(ctx, limit)
3769	}
3770	if returnFunc, ok := ret.Get(0).(func(context.Context, int) []*entity.Session); ok {
3771		r0 = returnFunc(ctx, limit)
3772	} else {
3773		if ret.Get(0) != nil {
3774			r0 = ret.Get(0).([]*entity.Session)
3775		}
3776	}
3777	if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
3778		r1 = returnFunc(ctx, limit)
3779	} else {
3780		r1 = ret.Error(1)
3781	}
3782	return r0, r1
3783}
3784
3785// MockSessionRepository_GetRecent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRecent'
3786type MockSessionRepository_GetRecent_Call struct {
3787	*mock.Call
3788}
3789
3790// GetRecent is a helper method to define mock.On call
3791//   - ctx context.Context
3792//   - limit int
3793func (_e *MockSessionRepository_Expecter) GetRecent(ctx interface{}, limit interface{}) *MockSessionRepository_GetRecent_Call {
3794	return &MockSessionRepository_GetRecent_Call{Call: _e.mock.On("GetRecent", ctx, limit)}
3795}
3796
3797func (_c *MockSessionRepository_GetRecent_Call) Run(run func(ctx context.Context, limit int)) *MockSessionRepository_GetRecent_Call {
3798	_c.Call.Run(func(args mock.Arguments) {
3799		var arg0 context.Context
3800		if args[0] != nil {
3801			arg0 = args[0].(context.Context)
3802		}
3803		var arg1 int
3804		if args[1] != nil {
3805			arg1 = args[1].(int)
3806		}
3807		run(
3808			arg0,
3809			arg1,
3810		)
3811	})
3812	return _c
3813}
3814
3815func (_c *MockSessionRepository_GetRecent_Call) Return(sessions []*entity.Session, err error) *MockSessionRepository_GetRecent_Call {
3816	_c.Call.Return(sessions, err)
3817	return _c
3818}
3819
3820func (_c *MockSessionRepository_GetRecent_Call) RunAndReturn(run func(ctx context.Context, limit int) ([]*entity.Session, error)) *MockSessionRepository_GetRecent_Call {
3821	_c.Call.Return(run)
3822	return _c
3823}
3824
3825// MarkEnded provides a mock function for the type MockSessionRepository
3826func (_mock *MockSessionRepository) MarkEnded(ctx context.Context, id entity.SessionID, endedAt time.Time) error {
3827	ret := _mock.Called(ctx, id, endedAt)
3828
3829	if len(ret) == 0 {
3830		panic("no return value specified for MarkEnded")
3831	}
3832
3833	var r0 error
3834	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID, time.Time) error); ok {
3835		r0 = returnFunc(ctx, id, endedAt)
3836	} else {
3837		r0 = ret.Error(0)
3838	}
3839	return r0
3840}
3841
3842// MockSessionRepository_MarkEnded_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MarkEnded'
3843type MockSessionRepository_MarkEnded_Call struct {
3844	*mock.Call
3845}
3846
3847// MarkEnded is a helper method to define mock.On call
3848//   - ctx context.Context
3849//   - id entity.SessionID
3850//   - endedAt time.Time
3851func (_e *MockSessionRepository_Expecter) MarkEnded(ctx interface{}, id interface{}, endedAt interface{}) *MockSessionRepository_MarkEnded_Call {
3852	return &MockSessionRepository_MarkEnded_Call{Call: _e.mock.On("MarkEnded", ctx, id, endedAt)}
3853}
3854
3855func (_c *MockSessionRepository_MarkEnded_Call) Run(run func(ctx context.Context, id entity.SessionID, endedAt time.Time)) *MockSessionRepository_MarkEnded_Call {
3856	_c.Call.Run(func(args mock.Arguments) {
3857		var arg0 context.Context
3858		if args[0] != nil {
3859			arg0 = args[0].(context.Context)
3860		}
3861		var arg1 entity.SessionID
3862		if args[1] != nil {
3863			arg1 = args[1].(entity.SessionID)
3864		}
3865		var arg2 time.Time
3866		if args[2] != nil {
3867			arg2 = args[2].(time.Time)
3868		}
3869		run(
3870			arg0,
3871			arg1,
3872			arg2,
3873		)
3874	})
3875	return _c
3876}
3877
3878func (_c *MockSessionRepository_MarkEnded_Call) Return(err error) *MockSessionRepository_MarkEnded_Call {
3879	_c.Call.Return(err)
3880	return _c
3881}
3882
3883func (_c *MockSessionRepository_MarkEnded_Call) RunAndReturn(run func(ctx context.Context, id entity.SessionID, endedAt time.Time) error) *MockSessionRepository_MarkEnded_Call {
3884	_c.Call.Return(run)
3885	return _c
3886}
3887
3888// Save provides a mock function for the type MockSessionRepository
3889func (_mock *MockSessionRepository) Save(ctx context.Context, session *entity.Session) error {
3890	ret := _mock.Called(ctx, session)
3891
3892	if len(ret) == 0 {
3893		panic("no return value specified for Save")
3894	}
3895
3896	var r0 error
3897	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.Session) error); ok {
3898		r0 = returnFunc(ctx, session)
3899	} else {
3900		r0 = ret.Error(0)
3901	}
3902	return r0
3903}
3904
3905// MockSessionRepository_Save_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Save'
3906type MockSessionRepository_Save_Call struct {
3907	*mock.Call
3908}
3909
3910// Save is a helper method to define mock.On call
3911//   - ctx context.Context
3912//   - session *entity.Session
3913func (_e *MockSessionRepository_Expecter) Save(ctx interface{}, session interface{}) *MockSessionRepository_Save_Call {
3914	return &MockSessionRepository_Save_Call{Call: _e.mock.On("Save", ctx, session)}
3915}
3916
3917func (_c *MockSessionRepository_Save_Call) Run(run func(ctx context.Context, session *entity.Session)) *MockSessionRepository_Save_Call {
3918	_c.Call.Run(func(args mock.Arguments) {
3919		var arg0 context.Context
3920		if args[0] != nil {
3921			arg0 = args[0].(context.Context)
3922		}
3923		var arg1 *entity.Session
3924		if args[1] != nil {
3925			arg1 = args[1].(*entity.Session)
3926		}
3927		run(
3928			arg0,
3929			arg1,
3930		)
3931	})
3932	return _c
3933}
3934
3935func (_c *MockSessionRepository_Save_Call) Return(err error) *MockSessionRepository_Save_Call {
3936	_c.Call.Return(err)
3937	return _c
3938}
3939
3940func (_c *MockSessionRepository_Save_Call) RunAndReturn(run func(ctx context.Context, session *entity.Session) error) *MockSessionRepository_Save_Call {
3941	_c.Call.Return(run)
3942	return _c
3943}
3944
3945// 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.
3946// The first argument is typically a *testing.T value.
3947func NewMockSessionStateRepository(t interface {
3948	mock.TestingT
3949	Cleanup(func())
3950}) *MockSessionStateRepository {
3951	mock := &MockSessionStateRepository{}
3952	mock.Mock.Test(t)
3953
3954	t.Cleanup(func() { mock.AssertExpectations(t) })
3955
3956	return mock
3957}
3958
3959// MockSessionStateRepository is an autogenerated mock type for the SessionStateRepository type
3960type MockSessionStateRepository struct {
3961	mock.Mock
3962}
3963
3964type MockSessionStateRepository_Expecter struct {
3965	mock *mock.Mock
3966}
3967
3968func (_m *MockSessionStateRepository) EXPECT() *MockSessionStateRepository_Expecter {
3969	return &MockSessionStateRepository_Expecter{mock: &_m.Mock}
3970}
3971
3972// DeleteSnapshot provides a mock function for the type MockSessionStateRepository
3973func (_mock *MockSessionStateRepository) DeleteSnapshot(ctx context.Context, sessionID entity.SessionID) error {
3974	ret := _mock.Called(ctx, sessionID)
3975
3976	if len(ret) == 0 {
3977		panic("no return value specified for DeleteSnapshot")
3978	}
3979
3980	var r0 error
3981	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID) error); ok {
3982		r0 = returnFunc(ctx, sessionID)
3983	} else {
3984		r0 = ret.Error(0)
3985	}
3986	return r0
3987}
3988
3989// MockSessionStateRepository_DeleteSnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteSnapshot'
3990type MockSessionStateRepository_DeleteSnapshot_Call struct {
3991	*mock.Call
3992}
3993
3994// DeleteSnapshot is a helper method to define mock.On call
3995//   - ctx context.Context
3996//   - sessionID entity.SessionID
3997func (_e *MockSessionStateRepository_Expecter) DeleteSnapshot(ctx interface{}, sessionID interface{}) *MockSessionStateRepository_DeleteSnapshot_Call {
3998	return &MockSessionStateRepository_DeleteSnapshot_Call{Call: _e.mock.On("DeleteSnapshot", ctx, sessionID)}
3999}
4000
4001func (_c *MockSessionStateRepository_DeleteSnapshot_Call) Run(run func(ctx context.Context, sessionID entity.SessionID)) *MockSessionStateRepository_DeleteSnapshot_Call {
4002	_c.Call.Run(func(args mock.Arguments) {
4003		var arg0 context.Context
4004		if args[0] != nil {
4005			arg0 = args[0].(context.Context)
4006		}
4007		var arg1 entity.SessionID
4008		if args[1] != nil {
4009			arg1 = args[1].(entity.SessionID)
4010		}
4011		run(
4012			arg0,
4013			arg1,
4014		)
4015	})
4016	return _c
4017}
4018
4019func (_c *MockSessionStateRepository_DeleteSnapshot_Call) Return(err error) *MockSessionStateRepository_DeleteSnapshot_Call {
4020	_c.Call.Return(err)
4021	return _c
4022}
4023
4024func (_c *MockSessionStateRepository_DeleteSnapshot_Call) RunAndReturn(run func(ctx context.Context, sessionID entity.SessionID) error) *MockSessionStateRepository_DeleteSnapshot_Call {
4025	_c.Call.Return(run)
4026	return _c
4027}
4028
4029// GetAllSnapshots provides a mock function for the type MockSessionStateRepository
4030func (_mock *MockSessionStateRepository) GetAllSnapshots(ctx context.Context) ([]*entity.SessionState, error) {
4031	ret := _mock.Called(ctx)
4032
4033	if len(ret) == 0 {
4034		panic("no return value specified for GetAllSnapshots")
4035	}
4036
4037	var r0 []*entity.SessionState
4038	var r1 error
4039	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*entity.SessionState, error)); ok {
4040		return returnFunc(ctx)
4041	}
4042	if returnFunc, ok := ret.Get(0).(func(context.Context) []*entity.SessionState); ok {
4043		r0 = returnFunc(ctx)
4044	} else {
4045		if ret.Get(0) != nil {
4046			r0 = ret.Get(0).([]*entity.SessionState)
4047		}
4048	}
4049	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
4050		r1 = returnFunc(ctx)
4051	} else {
4052		r1 = ret.Error(1)
4053	}
4054	return r0, r1
4055}
4056
4057// MockSessionStateRepository_GetAllSnapshots_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllSnapshots'
4058type MockSessionStateRepository_GetAllSnapshots_Call struct {
4059	*mock.Call
4060}
4061
4062// GetAllSnapshots is a helper method to define mock.On call
4063//   - ctx context.Context
4064func (_e *MockSessionStateRepository_Expecter) GetAllSnapshots(ctx interface{}) *MockSessionStateRepository_GetAllSnapshots_Call {
4065	return &MockSessionStateRepository_GetAllSnapshots_Call{Call: _e.mock.On("GetAllSnapshots", ctx)}
4066}
4067
4068func (_c *MockSessionStateRepository_GetAllSnapshots_Call) Run(run func(ctx context.Context)) *MockSessionStateRepository_GetAllSnapshots_Call {
4069	_c.Call.Run(func(args mock.Arguments) {
4070		var arg0 context.Context
4071		if args[0] != nil {
4072			arg0 = args[0].(context.Context)
4073		}
4074		run(
4075			arg0,
4076		)
4077	})
4078	return _c
4079}
4080
4081func (_c *MockSessionStateRepository_GetAllSnapshots_Call) Return(sessionStates []*entity.SessionState, err error) *MockSessionStateRepository_GetAllSnapshots_Call {
4082	_c.Call.Return(sessionStates, err)
4083	return _c
4084}
4085
4086func (_c *MockSessionStateRepository_GetAllSnapshots_Call) RunAndReturn(run func(ctx context.Context) ([]*entity.SessionState, error)) *MockSessionStateRepository_GetAllSnapshots_Call {
4087	_c.Call.Return(run)
4088	return _c
4089}
4090
4091// GetSnapshot provides a mock function for the type MockSessionStateRepository
4092func (_mock *MockSessionStateRepository) GetSnapshot(ctx context.Context, sessionID entity.SessionID) (*entity.SessionState, error) {
4093	ret := _mock.Called(ctx, sessionID)
4094
4095	if len(ret) == 0 {
4096		panic("no return value specified for GetSnapshot")
4097	}
4098
4099	var r0 *entity.SessionState
4100	var r1 error
4101	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID) (*entity.SessionState, error)); ok {
4102		return returnFunc(ctx, sessionID)
4103	}
4104	if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID) *entity.SessionState); ok {
4105		r0 = returnFunc(ctx, sessionID)
4106	} else {
4107		if ret.Get(0) != nil {
4108			r0 = ret.Get(0).(*entity.SessionState)
4109		}
4110	}
4111	if returnFunc, ok := ret.Get(1).(func(context.Context, entity.SessionID) error); ok {
4112		r1 = returnFunc(ctx, sessionID)
4113	} else {
4114		r1 = ret.Error(1)
4115	}
4116	return r0, r1
4117}
4118
4119// MockSessionStateRepository_GetSnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSnapshot'
4120type MockSessionStateRepository_GetSnapshot_Call struct {
4121	*mock.Call
4122}
4123
4124// GetSnapshot is a helper method to define mock.On call
4125//   - ctx context.Context
4126//   - sessionID entity.SessionID
4127func (_e *MockSessionStateRepository_Expecter) GetSnapshot(ctx interface{}, sessionID interface{}) *MockSessionStateRepository_GetSnapshot_Call {
4128	return &MockSessionStateRepository_GetSnapshot_Call{Call: _e.mock.On("GetSnapshot", ctx, sessionID)}
4129}
4130
4131func (_c *MockSessionStateRepository_GetSnapshot_Call) Run(run func(ctx context.Context, sessionID entity.SessionID)) *MockSessionStateRepository_GetSnapshot_Call {
4132	_c.Call.Run(func(args mock.Arguments) {
4133		var arg0 context.Context
4134		if args[0] != nil {
4135			arg0 = args[0].(context.Context)
4136		}
4137		var arg1 entity.SessionID
4138		if args[1] != nil {
4139			arg1 = args[1].(entity.SessionID)
4140		}
4141		run(
4142			arg0,
4143			arg1,
4144		)
4145	})
4146	return _c
4147}
4148
4149func (_c *MockSessionStateRepository_GetSnapshot_Call) Return(sessionState *entity.SessionState, err error) *MockSessionStateRepository_GetSnapshot_Call {
4150	_c.Call.Return(sessionState, err)
4151	return _c
4152}
4153
4154func (_c *MockSessionStateRepository_GetSnapshot_Call) RunAndReturn(run func(ctx context.Context, sessionID entity.SessionID) (*entity.SessionState, error)) *MockSessionStateRepository_GetSnapshot_Call {
4155	_c.Call.Return(run)
4156	return _c
4157}
4158
4159// GetTotalSnapshotsSize provides a mock function for the type MockSessionStateRepository
4160func (_mock *MockSessionStateRepository) GetTotalSnapshotsSize(ctx context.Context) (int64, error) {
4161	ret := _mock.Called(ctx)
4162
4163	if len(ret) == 0 {
4164		panic("no return value specified for GetTotalSnapshotsSize")
4165	}
4166
4167	var r0 int64
4168	var r1 error
4169	if returnFunc, ok := ret.Get(0).(func(context.Context) (int64, error)); ok {
4170		return returnFunc(ctx)
4171	}
4172	if returnFunc, ok := ret.Get(0).(func(context.Context) int64); ok {
4173		r0 = returnFunc(ctx)
4174	} else {
4175		r0 = ret.Get(0).(int64)
4176	}
4177	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
4178		r1 = returnFunc(ctx)
4179	} else {
4180		r1 = ret.Error(1)
4181	}
4182	return r0, r1
4183}
4184
4185// MockSessionStateRepository_GetTotalSnapshotsSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTotalSnapshotsSize'
4186type MockSessionStateRepository_GetTotalSnapshotsSize_Call struct {
4187	*mock.Call
4188}
4189
4190// GetTotalSnapshotsSize is a helper method to define mock.On call
4191//   - ctx context.Context
4192func (_e *MockSessionStateRepository_Expecter) GetTotalSnapshotsSize(ctx interface{}) *MockSessionStateRepository_GetTotalSnapshotsSize_Call {
4193	return &MockSessionStateRepository_GetTotalSnapshotsSize_Call{Call: _e.mock.On("GetTotalSnapshotsSize", ctx)}
4194}
4195
4196func (_c *MockSessionStateRepository_GetTotalSnapshotsSize_Call) Run(run func(ctx context.Context)) *MockSessionStateRepository_GetTotalSnapshotsSize_Call {
4197	_c.Call.Run(func(args mock.Arguments) {
4198		var arg0 context.Context
4199		if args[0] != nil {
4200			arg0 = args[0].(context.Context)
4201		}
4202		run(
4203			arg0,
4204		)
4205	})
4206	return _c
4207}
4208
4209func (_c *MockSessionStateRepository_GetTotalSnapshotsSize_Call) Return(n int64, err error) *MockSessionStateRepository_GetTotalSnapshotsSize_Call {
4210	_c.Call.Return(n, err)
4211	return _c
4212}
4213
4214func (_c *MockSessionStateRepository_GetTotalSnapshotsSize_Call) RunAndReturn(run func(ctx context.Context) (int64, error)) *MockSessionStateRepository_GetTotalSnapshotsSize_Call {
4215	_c.Call.Return(run)
4216	return _c
4217}
4218
4219// SaveSnapshot provides a mock function for the type MockSessionStateRepository
4220func (_mock *MockSessionStateRepository) SaveSnapshot(ctx context.Context, state *entity.SessionState) error {
4221	ret := _mock.Called(ctx, state)
4222
4223	if len(ret) == 0 {
4224		panic("no return value specified for SaveSnapshot")
4225	}
4226
4227	var r0 error
4228	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.SessionState) error); ok {
4229		r0 = returnFunc(ctx, state)
4230	} else {
4231		r0 = ret.Error(0)
4232	}
4233	return r0
4234}
4235
4236// MockSessionStateRepository_SaveSnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveSnapshot'
4237type MockSessionStateRepository_SaveSnapshot_Call struct {
4238	*mock.Call
4239}
4240
4241// SaveSnapshot is a helper method to define mock.On call
4242//   - ctx context.Context
4243//   - state *entity.SessionState
4244func (_e *MockSessionStateRepository_Expecter) SaveSnapshot(ctx interface{}, state interface{}) *MockSessionStateRepository_SaveSnapshot_Call {
4245	return &MockSessionStateRepository_SaveSnapshot_Call{Call: _e.mock.On("SaveSnapshot", ctx, state)}
4246}
4247
4248func (_c *MockSessionStateRepository_SaveSnapshot_Call) Run(run func(ctx context.Context, state *entity.SessionState)) *MockSessionStateRepository_SaveSnapshot_Call {
4249	_c.Call.Run(func(args mock.Arguments) {
4250		var arg0 context.Context
4251		if args[0] != nil {
4252			arg0 = args[0].(context.Context)
4253		}
4254		var arg1 *entity.SessionState
4255		if args[1] != nil {
4256			arg1 = args[1].(*entity.SessionState)
4257		}
4258		run(
4259			arg0,
4260			arg1,
4261		)
4262	})
4263	return _c
4264}
4265
4266func (_c *MockSessionStateRepository_SaveSnapshot_Call) Return(err error) *MockSessionStateRepository_SaveSnapshot_Call {
4267	_c.Call.Return(err)
4268	return _c
4269}
4270
4271func (_c *MockSessionStateRepository_SaveSnapshot_Call) RunAndReturn(run func(ctx context.Context, state *entity.SessionState) error) *MockSessionStateRepository_SaveSnapshot_Call {
4272	_c.Call.Return(run)
4273	return _c
4274}
4275
4276// 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.
4277// The first argument is typically a *testing.T value.
4278func NewMockZoomRepository(t interface {
4279	mock.TestingT
4280	Cleanup(func())
4281}) *MockZoomRepository {
4282	mock := &MockZoomRepository{}
4283	mock.Mock.Test(t)
4284
4285	t.Cleanup(func() { mock.AssertExpectations(t) })
4286
4287	return mock
4288}
4289
4290// MockZoomRepository is an autogenerated mock type for the ZoomRepository type
4291type MockZoomRepository struct {
4292	mock.Mock
4293}
4294
4295type MockZoomRepository_Expecter struct {
4296	mock *mock.Mock
4297}
4298
4299func (_m *MockZoomRepository) EXPECT() *MockZoomRepository_Expecter {
4300	return &MockZoomRepository_Expecter{mock: &_m.Mock}
4301}
4302
4303// Delete provides a mock function for the type MockZoomRepository
4304func (_mock *MockZoomRepository) Delete(ctx context.Context, domain string) error {
4305	ret := _mock.Called(ctx, domain)
4306
4307	if len(ret) == 0 {
4308		panic("no return value specified for Delete")
4309	}
4310
4311	var r0 error
4312	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
4313		r0 = returnFunc(ctx, domain)
4314	} else {
4315		r0 = ret.Error(0)
4316	}
4317	return r0
4318}
4319
4320// MockZoomRepository_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
4321type MockZoomRepository_Delete_Call struct {
4322	*mock.Call
4323}
4324
4325// Delete is a helper method to define mock.On call
4326//   - ctx context.Context
4327//   - domain string
4328func (_e *MockZoomRepository_Expecter) Delete(ctx interface{}, domain interface{}) *MockZoomRepository_Delete_Call {
4329	return &MockZoomRepository_Delete_Call{Call: _e.mock.On("Delete", ctx, domain)}
4330}
4331
4332func (_c *MockZoomRepository_Delete_Call) Run(run func(ctx context.Context, domain string)) *MockZoomRepository_Delete_Call {
4333	_c.Call.Run(func(args mock.Arguments) {
4334		var arg0 context.Context
4335		if args[0] != nil {
4336			arg0 = args[0].(context.Context)
4337		}
4338		var arg1 string
4339		if args[1] != nil {
4340			arg1 = args[1].(string)
4341		}
4342		run(
4343			arg0,
4344			arg1,
4345		)
4346	})
4347	return _c
4348}
4349
4350func (_c *MockZoomRepository_Delete_Call) Return(err error) *MockZoomRepository_Delete_Call {
4351	_c.Call.Return(err)
4352	return _c
4353}
4354
4355func (_c *MockZoomRepository_Delete_Call) RunAndReturn(run func(ctx context.Context, domain string) error) *MockZoomRepository_Delete_Call {
4356	_c.Call.Return(run)
4357	return _c
4358}
4359
4360// Get provides a mock function for the type MockZoomRepository
4361func (_mock *MockZoomRepository) Get(ctx context.Context, domain string) (*entity.ZoomLevel, error) {
4362	ret := _mock.Called(ctx, domain)
4363
4364	if len(ret) == 0 {
4365		panic("no return value specified for Get")
4366	}
4367
4368	var r0 *entity.ZoomLevel
4369	var r1 error
4370	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*entity.ZoomLevel, error)); ok {
4371		return returnFunc(ctx, domain)
4372	}
4373	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *entity.ZoomLevel); ok {
4374		r0 = returnFunc(ctx, domain)
4375	} else {
4376		if ret.Get(0) != nil {
4377			r0 = ret.Get(0).(*entity.ZoomLevel)
4378		}
4379	}
4380	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
4381		r1 = returnFunc(ctx, domain)
4382	} else {
4383		r1 = ret.Error(1)
4384	}
4385	return r0, r1
4386}
4387
4388// MockZoomRepository_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'
4389type MockZoomRepository_Get_Call struct {
4390	*mock.Call
4391}
4392
4393// Get is a helper method to define mock.On call
4394//   - ctx context.Context
4395//   - domain string
4396func (_e *MockZoomRepository_Expecter) Get(ctx interface{}, domain interface{}) *MockZoomRepository_Get_Call {
4397	return &MockZoomRepository_Get_Call{Call: _e.mock.On("Get", ctx, domain)}
4398}
4399
4400func (_c *MockZoomRepository_Get_Call) Run(run func(ctx context.Context, domain string)) *MockZoomRepository_Get_Call {
4401	_c.Call.Run(func(args mock.Arguments) {
4402		var arg0 context.Context
4403		if args[0] != nil {
4404			arg0 = args[0].(context.Context)
4405		}
4406		var arg1 string
4407		if args[1] != nil {
4408			arg1 = args[1].(string)
4409		}
4410		run(
4411			arg0,
4412			arg1,
4413		)
4414	})
4415	return _c
4416}
4417
4418func (_c *MockZoomRepository_Get_Call) Return(zoomLevel *entity.ZoomLevel, err error) *MockZoomRepository_Get_Call {
4419	_c.Call.Return(zoomLevel, err)
4420	return _c
4421}
4422
4423func (_c *MockZoomRepository_Get_Call) RunAndReturn(run func(ctx context.Context, domain string) (*entity.ZoomLevel, error)) *MockZoomRepository_Get_Call {
4424	_c.Call.Return(run)
4425	return _c
4426}
4427
4428// GetAll provides a mock function for the type MockZoomRepository
4429func (_mock *MockZoomRepository) GetAll(ctx context.Context) ([]*entity.ZoomLevel, error) {
4430	ret := _mock.Called(ctx)
4431
4432	if len(ret) == 0 {
4433		panic("no return value specified for GetAll")
4434	}
4435
4436	var r0 []*entity.ZoomLevel
4437	var r1 error
4438	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*entity.ZoomLevel, error)); ok {
4439		return returnFunc(ctx)
4440	}
4441	if returnFunc, ok := ret.Get(0).(func(context.Context) []*entity.ZoomLevel); ok {
4442		r0 = returnFunc(ctx)
4443	} else {
4444		if ret.Get(0) != nil {
4445			r0 = ret.Get(0).([]*entity.ZoomLevel)
4446		}
4447	}
4448	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
4449		r1 = returnFunc(ctx)
4450	} else {
4451		r1 = ret.Error(1)
4452	}
4453	return r0, r1
4454}
4455
4456// MockZoomRepository_GetAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAll'
4457type MockZoomRepository_GetAll_Call struct {
4458	*mock.Call
4459}
4460
4461// GetAll is a helper method to define mock.On call
4462//   - ctx context.Context
4463func (_e *MockZoomRepository_Expecter) GetAll(ctx interface{}) *MockZoomRepository_GetAll_Call {
4464	return &MockZoomRepository_GetAll_Call{Call: _e.mock.On("GetAll", ctx)}
4465}
4466
4467func (_c *MockZoomRepository_GetAll_Call) Run(run func(ctx context.Context)) *MockZoomRepository_GetAll_Call {
4468	_c.Call.Run(func(args mock.Arguments) {
4469		var arg0 context.Context
4470		if args[0] != nil {
4471			arg0 = args[0].(context.Context)
4472		}
4473		run(
4474			arg0,
4475		)
4476	})
4477	return _c
4478}
4479
4480func (_c *MockZoomRepository_GetAll_Call) Return(zoomLevels []*entity.ZoomLevel, err error) *MockZoomRepository_GetAll_Call {
4481	_c.Call.Return(zoomLevels, err)
4482	return _c
4483}
4484
4485func (_c *MockZoomRepository_GetAll_Call) RunAndReturn(run func(ctx context.Context) ([]*entity.ZoomLevel, error)) *MockZoomRepository_GetAll_Call {
4486	_c.Call.Return(run)
4487	return _c
4488}
4489
4490// Set provides a mock function for the type MockZoomRepository
4491func (_mock *MockZoomRepository) Set(ctx context.Context, level *entity.ZoomLevel) error {
4492	ret := _mock.Called(ctx, level)
4493
4494	if len(ret) == 0 {
4495		panic("no return value specified for Set")
4496	}
4497
4498	var r0 error
4499	if returnFunc, ok := ret.Get(0).(func(context.Context, *entity.ZoomLevel) error); ok {
4500		r0 = returnFunc(ctx, level)
4501	} else {
4502		r0 = ret.Error(0)
4503	}
4504	return r0
4505}
4506
4507// MockZoomRepository_Set_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Set'
4508type MockZoomRepository_Set_Call struct {
4509	*mock.Call
4510}
4511
4512// Set is a helper method to define mock.On call
4513//   - ctx context.Context
4514//   - level *entity.ZoomLevel
4515func (_e *MockZoomRepository_Expecter) Set(ctx interface{}, level interface{}) *MockZoomRepository_Set_Call {
4516	return &MockZoomRepository_Set_Call{Call: _e.mock.On("Set", ctx, level)}
4517}
4518
4519func (_c *MockZoomRepository_Set_Call) Run(run func(ctx context.Context, level *entity.ZoomLevel)) *MockZoomRepository_Set_Call {
4520	_c.Call.Run(func(args mock.Arguments) {
4521		var arg0 context.Context
4522		if args[0] != nil {
4523			arg0 = args[0].(context.Context)
4524		}
4525		var arg1 *entity.ZoomLevel
4526		if args[1] != nil {
4527			arg1 = args[1].(*entity.ZoomLevel)
4528		}
4529		run(
4530			arg0,
4531			arg1,
4532		)
4533	})
4534	return _c
4535}
4536
4537func (_c *MockZoomRepository_Set_Call) Return(err error) *MockZoomRepository_Set_Call {
4538	_c.Call.Return(err)
4539	return _c
4540}
4541
4542func (_c *MockZoomRepository_Set_Call) RunAndReturn(run func(ctx context.Context, level *entity.ZoomLevel) error) *MockZoomRepository_Set_Call {
4543	_c.Call.Return(run)
4544	return _c
4545}