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/application/dto"
12 "github.com/bnema/dumber/internal/domain/entity"
13 mock "github.com/stretchr/testify/mock"
14)
15
16// NewMockHomepageHistory creates a new instance of MockHomepageHistory. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
17// The first argument is typically a *testing.T value.
18func NewMockHomepageHistory(t interface {
19 mock.TestingT
20 Cleanup(func())
21}) *MockHomepageHistory {
22 mock := &MockHomepageHistory{}
23 mock.Mock.Test(t)
24
25 t.Cleanup(func() { mock.AssertExpectations(t) })
26
27 return mock
28}
29
30// MockHomepageHistory is an autogenerated mock type for the HomepageHistory type
31type MockHomepageHistory struct {
32 mock.Mock
33}
34
35type MockHomepageHistory_Expecter struct {
36 mock *mock.Mock
37}
38
39func (_m *MockHomepageHistory) EXPECT() *MockHomepageHistory_Expecter {
40 return &MockHomepageHistory_Expecter{mock: &_m.Mock}
41}
42
43// ClearAll provides a mock function for the type MockHomepageHistory
44func (_mock *MockHomepageHistory) ClearAll(ctx context.Context) error {
45 ret := _mock.Called(ctx)
46
47 if len(ret) == 0 {
48 panic("no return value specified for ClearAll")
49 }
50
51 var r0 error
52 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
53 r0 = returnFunc(ctx)
54 } else {
55 r0 = ret.Error(0)
56 }
57 return r0
58}
59
60// MockHomepageHistory_ClearAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClearAll'
61type MockHomepageHistory_ClearAll_Call struct {
62 *mock.Call
63}
64
65// ClearAll is a helper method to define mock.On call
66// - ctx context.Context
67func (_e *MockHomepageHistory_Expecter) ClearAll(ctx any) *MockHomepageHistory_ClearAll_Call {
68 return &MockHomepageHistory_ClearAll_Call{Call: _e.mock.On("ClearAll", ctx)}
69}
70
71func (_c *MockHomepageHistory_ClearAll_Call) Run(run func(ctx context.Context)) *MockHomepageHistory_ClearAll_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 run(
78 arg0,
79 )
80 })
81 return _c
82}
83
84func (_c *MockHomepageHistory_ClearAll_Call) Return(err error) *MockHomepageHistory_ClearAll_Call {
85 _c.Call.Return(err)
86 return _c
87}
88
89func (_c *MockHomepageHistory_ClearAll_Call) RunAndReturn(run func(ctx context.Context) error) *MockHomepageHistory_ClearAll_Call {
90 _c.Call.Return(run)
91 return _c
92}
93
94// ClearOlderThan provides a mock function for the type MockHomepageHistory
95func (_mock *MockHomepageHistory) ClearOlderThan(ctx context.Context, before time.Time) error {
96 ret := _mock.Called(ctx, before)
97
98 if len(ret) == 0 {
99 panic("no return value specified for ClearOlderThan")
100 }
101
102 var r0 error
103 if returnFunc, ok := ret.Get(0).(func(context.Context, time.Time) error); ok {
104 r0 = returnFunc(ctx, before)
105 } else {
106 r0 = ret.Error(0)
107 }
108 return r0
109}
110
111// MockHomepageHistory_ClearOlderThan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClearOlderThan'
112type MockHomepageHistory_ClearOlderThan_Call struct {
113 *mock.Call
114}
115
116// ClearOlderThan is a helper method to define mock.On call
117// - ctx context.Context
118// - before time.Time
119func (_e *MockHomepageHistory_Expecter) ClearOlderThan(ctx any, before any) *MockHomepageHistory_ClearOlderThan_Call {
120 return &MockHomepageHistory_ClearOlderThan_Call{Call: _e.mock.On("ClearOlderThan", ctx, before)}
121}
122
123func (_c *MockHomepageHistory_ClearOlderThan_Call) Run(run func(ctx context.Context, before time.Time)) *MockHomepageHistory_ClearOlderThan_Call {
124 _c.Call.Run(func(args mock.Arguments) {
125 var arg0 context.Context
126 if args[0] != nil {
127 arg0 = args[0].(context.Context)
128 }
129 var arg1 time.Time
130 if args[1] != nil {
131 arg1 = args[1].(time.Time)
132 }
133 run(
134 arg0,
135 arg1,
136 )
137 })
138 return _c
139}
140
141func (_c *MockHomepageHistory_ClearOlderThan_Call) Return(err error) *MockHomepageHistory_ClearOlderThan_Call {
142 _c.Call.Return(err)
143 return _c
144}
145
146func (_c *MockHomepageHistory_ClearOlderThan_Call) RunAndReturn(run func(ctx context.Context, before time.Time) error) *MockHomepageHistory_ClearOlderThan_Call {
147 _c.Call.Return(run)
148 return _c
149}
150
151// ClearRange provides a mock function for the type MockHomepageHistory
152func (_mock *MockHomepageHistory) ClearRange(ctx context.Context, rangeID string) error {
153 ret := _mock.Called(ctx, rangeID)
154
155 if len(ret) == 0 {
156 panic("no return value specified for ClearRange")
157 }
158
159 var r0 error
160 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
161 r0 = returnFunc(ctx, rangeID)
162 } else {
163 r0 = ret.Error(0)
164 }
165 return r0
166}
167
168// MockHomepageHistory_ClearRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClearRange'
169type MockHomepageHistory_ClearRange_Call struct {
170 *mock.Call
171}
172
173// ClearRange is a helper method to define mock.On call
174// - ctx context.Context
175// - rangeID string
176func (_e *MockHomepageHistory_Expecter) ClearRange(ctx any, rangeID any) *MockHomepageHistory_ClearRange_Call {
177 return &MockHomepageHistory_ClearRange_Call{Call: _e.mock.On("ClearRange", ctx, rangeID)}
178}
179
180func (_c *MockHomepageHistory_ClearRange_Call) Run(run func(ctx context.Context, rangeID string)) *MockHomepageHistory_ClearRange_Call {
181 _c.Call.Run(func(args mock.Arguments) {
182 var arg0 context.Context
183 if args[0] != nil {
184 arg0 = args[0].(context.Context)
185 }
186 var arg1 string
187 if args[1] != nil {
188 arg1 = args[1].(string)
189 }
190 run(
191 arg0,
192 arg1,
193 )
194 })
195 return _c
196}
197
198func (_c *MockHomepageHistory_ClearRange_Call) Return(err error) *MockHomepageHistory_ClearRange_Call {
199 _c.Call.Return(err)
200 return _c
201}
202
203func (_c *MockHomepageHistory_ClearRange_Call) RunAndReturn(run func(ctx context.Context, rangeID string) error) *MockHomepageHistory_ClearRange_Call {
204 _c.Call.Return(run)
205 return _c
206}
207
208// Delete provides a mock function for the type MockHomepageHistory
209func (_mock *MockHomepageHistory) Delete(ctx context.Context, id int64) error {
210 ret := _mock.Called(ctx, id)
211
212 if len(ret) == 0 {
213 panic("no return value specified for Delete")
214 }
215
216 var r0 error
217 if returnFunc, ok := ret.Get(0).(func(context.Context, int64) error); ok {
218 r0 = returnFunc(ctx, id)
219 } else {
220 r0 = ret.Error(0)
221 }
222 return r0
223}
224
225// MockHomepageHistory_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
226type MockHomepageHistory_Delete_Call struct {
227 *mock.Call
228}
229
230// Delete is a helper method to define mock.On call
231// - ctx context.Context
232// - id int64
233func (_e *MockHomepageHistory_Expecter) Delete(ctx any, id any) *MockHomepageHistory_Delete_Call {
234 return &MockHomepageHistory_Delete_Call{Call: _e.mock.On("Delete", ctx, id)}
235}
236
237func (_c *MockHomepageHistory_Delete_Call) Run(run func(ctx context.Context, id int64)) *MockHomepageHistory_Delete_Call {
238 _c.Call.Run(func(args mock.Arguments) {
239 var arg0 context.Context
240 if args[0] != nil {
241 arg0 = args[0].(context.Context)
242 }
243 var arg1 int64
244 if args[1] != nil {
245 arg1 = args[1].(int64)
246 }
247 run(
248 arg0,
249 arg1,
250 )
251 })
252 return _c
253}
254
255func (_c *MockHomepageHistory_Delete_Call) Return(err error) *MockHomepageHistory_Delete_Call {
256 _c.Call.Return(err)
257 return _c
258}
259
260func (_c *MockHomepageHistory_Delete_Call) RunAndReturn(run func(ctx context.Context, id int64) error) *MockHomepageHistory_Delete_Call {
261 _c.Call.Return(run)
262 return _c
263}
264
265// DeleteByDomain provides a mock function for the type MockHomepageHistory
266func (_mock *MockHomepageHistory) DeleteByDomain(ctx context.Context, domain string) error {
267 ret := _mock.Called(ctx, domain)
268
269 if len(ret) == 0 {
270 panic("no return value specified for DeleteByDomain")
271 }
272
273 var r0 error
274 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
275 r0 = returnFunc(ctx, domain)
276 } else {
277 r0 = ret.Error(0)
278 }
279 return r0
280}
281
282// MockHomepageHistory_DeleteByDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteByDomain'
283type MockHomepageHistory_DeleteByDomain_Call struct {
284 *mock.Call
285}
286
287// DeleteByDomain is a helper method to define mock.On call
288// - ctx context.Context
289// - domain string
290func (_e *MockHomepageHistory_Expecter) DeleteByDomain(ctx any, domain any) *MockHomepageHistory_DeleteByDomain_Call {
291 return &MockHomepageHistory_DeleteByDomain_Call{Call: _e.mock.On("DeleteByDomain", ctx, domain)}
292}
293
294func (_c *MockHomepageHistory_DeleteByDomain_Call) Run(run func(ctx context.Context, domain string)) *MockHomepageHistory_DeleteByDomain_Call {
295 _c.Call.Run(func(args mock.Arguments) {
296 var arg0 context.Context
297 if args[0] != nil {
298 arg0 = args[0].(context.Context)
299 }
300 var arg1 string
301 if args[1] != nil {
302 arg1 = args[1].(string)
303 }
304 run(
305 arg0,
306 arg1,
307 )
308 })
309 return _c
310}
311
312func (_c *MockHomepageHistory_DeleteByDomain_Call) Return(err error) *MockHomepageHistory_DeleteByDomain_Call {
313 _c.Call.Return(err)
314 return _c
315}
316
317func (_c *MockHomepageHistory_DeleteByDomain_Call) RunAndReturn(run func(ctx context.Context, domain string) error) *MockHomepageHistory_DeleteByDomain_Call {
318 _c.Call.Return(run)
319 return _c
320}
321
322// GetAnalytics provides a mock function for the type MockHomepageHistory
323func (_mock *MockHomepageHistory) GetAnalytics(ctx context.Context) (*entity.HistoryAnalytics, error) {
324 ret := _mock.Called(ctx)
325
326 if len(ret) == 0 {
327 panic("no return value specified for GetAnalytics")
328 }
329
330 var r0 *entity.HistoryAnalytics
331 var r1 error
332 if returnFunc, ok := ret.Get(0).(func(context.Context) (*entity.HistoryAnalytics, error)); ok {
333 return returnFunc(ctx)
334 }
335 if returnFunc, ok := ret.Get(0).(func(context.Context) *entity.HistoryAnalytics); ok {
336 r0 = returnFunc(ctx)
337 } else {
338 if ret.Get(0) != nil {
339 r0 = ret.Get(0).(*entity.HistoryAnalytics)
340 }
341 }
342 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
343 r1 = returnFunc(ctx)
344 } else {
345 r1 = ret.Error(1)
346 }
347 return r0, r1
348}
349
350// MockHomepageHistory_GetAnalytics_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAnalytics'
351type MockHomepageHistory_GetAnalytics_Call struct {
352 *mock.Call
353}
354
355// GetAnalytics is a helper method to define mock.On call
356// - ctx context.Context
357func (_e *MockHomepageHistory_Expecter) GetAnalytics(ctx any) *MockHomepageHistory_GetAnalytics_Call {
358 return &MockHomepageHistory_GetAnalytics_Call{Call: _e.mock.On("GetAnalytics", ctx)}
359}
360
361func (_c *MockHomepageHistory_GetAnalytics_Call) Run(run func(ctx context.Context)) *MockHomepageHistory_GetAnalytics_Call {
362 _c.Call.Run(func(args mock.Arguments) {
363 var arg0 context.Context
364 if args[0] != nil {
365 arg0 = args[0].(context.Context)
366 }
367 run(
368 arg0,
369 )
370 })
371 return _c
372}
373
374func (_c *MockHomepageHistory_GetAnalytics_Call) Return(historyAnalytics *entity.HistoryAnalytics, err error) *MockHomepageHistory_GetAnalytics_Call {
375 _c.Call.Return(historyAnalytics, err)
376 return _c
377}
378
379func (_c *MockHomepageHistory_GetAnalytics_Call) RunAndReturn(run func(ctx context.Context) (*entity.HistoryAnalytics, error)) *MockHomepageHistory_GetAnalytics_Call {
380 _c.Call.Return(run)
381 return _c
382}
383
384// GetDomainStats provides a mock function for the type MockHomepageHistory
385func (_mock *MockHomepageHistory) GetDomainStats(ctx context.Context, limit int) ([]*entity.DomainStat, error) {
386 ret := _mock.Called(ctx, limit)
387
388 if len(ret) == 0 {
389 panic("no return value specified for GetDomainStats")
390 }
391
392 var r0 []*entity.DomainStat
393 var r1 error
394 if returnFunc, ok := ret.Get(0).(func(context.Context, int) ([]*entity.DomainStat, error)); ok {
395 return returnFunc(ctx, limit)
396 }
397 if returnFunc, ok := ret.Get(0).(func(context.Context, int) []*entity.DomainStat); ok {
398 r0 = returnFunc(ctx, limit)
399 } else {
400 if ret.Get(0) != nil {
401 r0 = ret.Get(0).([]*entity.DomainStat)
402 }
403 }
404 if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
405 r1 = returnFunc(ctx, limit)
406 } else {
407 r1 = ret.Error(1)
408 }
409 return r0, r1
410}
411
412// MockHomepageHistory_GetDomainStats_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDomainStats'
413type MockHomepageHistory_GetDomainStats_Call struct {
414 *mock.Call
415}
416
417// GetDomainStats is a helper method to define mock.On call
418// - ctx context.Context
419// - limit int
420func (_e *MockHomepageHistory_Expecter) GetDomainStats(ctx any, limit any) *MockHomepageHistory_GetDomainStats_Call {
421 return &MockHomepageHistory_GetDomainStats_Call{Call: _e.mock.On("GetDomainStats", ctx, limit)}
422}
423
424func (_c *MockHomepageHistory_GetDomainStats_Call) Run(run func(ctx context.Context, limit int)) *MockHomepageHistory_GetDomainStats_Call {
425 _c.Call.Run(func(args mock.Arguments) {
426 var arg0 context.Context
427 if args[0] != nil {
428 arg0 = args[0].(context.Context)
429 }
430 var arg1 int
431 if args[1] != nil {
432 arg1 = args[1].(int)
433 }
434 run(
435 arg0,
436 arg1,
437 )
438 })
439 return _c
440}
441
442func (_c *MockHomepageHistory_GetDomainStats_Call) Return(domainStats []*entity.DomainStat, err error) *MockHomepageHistory_GetDomainStats_Call {
443 _c.Call.Return(domainStats, err)
444 return _c
445}
446
447func (_c *MockHomepageHistory_GetDomainStats_Call) RunAndReturn(run func(ctx context.Context, limit int) ([]*entity.DomainStat, error)) *MockHomepageHistory_GetDomainStats_Call {
448 _c.Call.Return(run)
449 return _c
450}
451
452// GetRecent provides a mock function for the type MockHomepageHistory
453func (_mock *MockHomepageHistory) GetRecent(ctx context.Context, limit int, offset int) ([]*entity.HistoryEntry, error) {
454 ret := _mock.Called(ctx, limit, offset)
455
456 if len(ret) == 0 {
457 panic("no return value specified for GetRecent")
458 }
459
460 var r0 []*entity.HistoryEntry
461 var r1 error
462 if returnFunc, ok := ret.Get(0).(func(context.Context, int, int) ([]*entity.HistoryEntry, error)); ok {
463 return returnFunc(ctx, limit, offset)
464 }
465 if returnFunc, ok := ret.Get(0).(func(context.Context, int, int) []*entity.HistoryEntry); ok {
466 r0 = returnFunc(ctx, limit, offset)
467 } else {
468 if ret.Get(0) != nil {
469 r0 = ret.Get(0).([]*entity.HistoryEntry)
470 }
471 }
472 if returnFunc, ok := ret.Get(1).(func(context.Context, int, int) error); ok {
473 r1 = returnFunc(ctx, limit, offset)
474 } else {
475 r1 = ret.Error(1)
476 }
477 return r0, r1
478}
479
480// MockHomepageHistory_GetRecent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRecent'
481type MockHomepageHistory_GetRecent_Call struct {
482 *mock.Call
483}
484
485// GetRecent is a helper method to define mock.On call
486// - ctx context.Context
487// - limit int
488// - offset int
489func (_e *MockHomepageHistory_Expecter) GetRecent(ctx any, limit any, offset any) *MockHomepageHistory_GetRecent_Call {
490 return &MockHomepageHistory_GetRecent_Call{Call: _e.mock.On("GetRecent", ctx, limit, offset)}
491}
492
493func (_c *MockHomepageHistory_GetRecent_Call) Run(run func(ctx context.Context, limit int, offset int)) *MockHomepageHistory_GetRecent_Call {
494 _c.Call.Run(func(args mock.Arguments) {
495 var arg0 context.Context
496 if args[0] != nil {
497 arg0 = args[0].(context.Context)
498 }
499 var arg1 int
500 if args[1] != nil {
501 arg1 = args[1].(int)
502 }
503 var arg2 int
504 if args[2] != nil {
505 arg2 = args[2].(int)
506 }
507 run(
508 arg0,
509 arg1,
510 arg2,
511 )
512 })
513 return _c
514}
515
516func (_c *MockHomepageHistory_GetRecent_Call) Return(historyEntrys []*entity.HistoryEntry, err error) *MockHomepageHistory_GetRecent_Call {
517 _c.Call.Return(historyEntrys, err)
518 return _c
519}
520
521func (_c *MockHomepageHistory_GetRecent_Call) RunAndReturn(run func(ctx context.Context, limit int, offset int) ([]*entity.HistoryEntry, error)) *MockHomepageHistory_GetRecent_Call {
522 _c.Call.Return(run)
523 return _c
524}
525
526// GetRecentByDomain provides a mock function for the type MockHomepageHistory
527func (_mock *MockHomepageHistory) GetRecentByDomain(ctx context.Context, domain string, limit int, offset int) ([]*entity.HistoryEntry, error) {
528 ret := _mock.Called(ctx, domain, limit, offset)
529
530 if len(ret) == 0 {
531 panic("no return value specified for GetRecentByDomain")
532 }
533
534 var r0 []*entity.HistoryEntry
535 var r1 error
536 if returnFunc, ok := ret.Get(0).(func(context.Context, string, int, int) ([]*entity.HistoryEntry, error)); ok {
537 return returnFunc(ctx, domain, limit, offset)
538 }
539 if returnFunc, ok := ret.Get(0).(func(context.Context, string, int, int) []*entity.HistoryEntry); ok {
540 r0 = returnFunc(ctx, domain, limit, offset)
541 } else {
542 if ret.Get(0) != nil {
543 r0 = ret.Get(0).([]*entity.HistoryEntry)
544 }
545 }
546 if returnFunc, ok := ret.Get(1).(func(context.Context, string, int, int) error); ok {
547 r1 = returnFunc(ctx, domain, limit, offset)
548 } else {
549 r1 = ret.Error(1)
550 }
551 return r0, r1
552}
553
554// MockHomepageHistory_GetRecentByDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRecentByDomain'
555type MockHomepageHistory_GetRecentByDomain_Call struct {
556 *mock.Call
557}
558
559// GetRecentByDomain is a helper method to define mock.On call
560// - ctx context.Context
561// - domain string
562// - limit int
563// - offset int
564func (_e *MockHomepageHistory_Expecter) GetRecentByDomain(ctx any, domain any, limit any, offset any) *MockHomepageHistory_GetRecentByDomain_Call {
565 return &MockHomepageHistory_GetRecentByDomain_Call{Call: _e.mock.On("GetRecentByDomain", ctx, domain, limit, offset)}
566}
567
568func (_c *MockHomepageHistory_GetRecentByDomain_Call) Run(run func(ctx context.Context, domain string, limit int, offset int)) *MockHomepageHistory_GetRecentByDomain_Call {
569 _c.Call.Run(func(args mock.Arguments) {
570 var arg0 context.Context
571 if args[0] != nil {
572 arg0 = args[0].(context.Context)
573 }
574 var arg1 string
575 if args[1] != nil {
576 arg1 = args[1].(string)
577 }
578 var arg2 int
579 if args[2] != nil {
580 arg2 = args[2].(int)
581 }
582 var arg3 int
583 if args[3] != nil {
584 arg3 = args[3].(int)
585 }
586 run(
587 arg0,
588 arg1,
589 arg2,
590 arg3,
591 )
592 })
593 return _c
594}
595
596func (_c *MockHomepageHistory_GetRecentByDomain_Call) Return(historyEntrys []*entity.HistoryEntry, err error) *MockHomepageHistory_GetRecentByDomain_Call {
597 _c.Call.Return(historyEntrys, err)
598 return _c
599}
600
601func (_c *MockHomepageHistory_GetRecentByDomain_Call) RunAndReturn(run func(ctx context.Context, domain string, limit int, offset int) ([]*entity.HistoryEntry, error)) *MockHomepageHistory_GetRecentByDomain_Call {
602 _c.Call.Return(run)
603 return _c
604}
605
606// GetRecentWindow provides a mock function for the type MockHomepageHistory
607func (_mock *MockHomepageHistory) GetRecentWindow(ctx context.Context, before time.Time, beforeID int64, domain string) (*entity.HistoryWindow, error) {
608 ret := _mock.Called(ctx, before, beforeID, domain)
609
610 if len(ret) == 0 {
611 panic("no return value specified for GetRecentWindow")
612 }
613
614 var r0 *entity.HistoryWindow
615 var r1 error
616 if returnFunc, ok := ret.Get(0).(func(context.Context, time.Time, int64, string) (*entity.HistoryWindow, error)); ok {
617 return returnFunc(ctx, before, beforeID, domain)
618 }
619 if returnFunc, ok := ret.Get(0).(func(context.Context, time.Time, int64, string) *entity.HistoryWindow); ok {
620 r0 = returnFunc(ctx, before, beforeID, domain)
621 } else {
622 if ret.Get(0) != nil {
623 r0 = ret.Get(0).(*entity.HistoryWindow)
624 }
625 }
626 if returnFunc, ok := ret.Get(1).(func(context.Context, time.Time, int64, string) error); ok {
627 r1 = returnFunc(ctx, before, beforeID, domain)
628 } else {
629 r1 = ret.Error(1)
630 }
631 return r0, r1
632}
633
634// MockHomepageHistory_GetRecentWindow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRecentWindow'
635type MockHomepageHistory_GetRecentWindow_Call struct {
636 *mock.Call
637}
638
639// GetRecentWindow is a helper method to define mock.On call
640// - ctx context.Context
641// - before time.Time
642// - beforeID int64
643// - domain string
644func (_e *MockHomepageHistory_Expecter) GetRecentWindow(ctx any, before any, beforeID any, domain any) *MockHomepageHistory_GetRecentWindow_Call {
645 return &MockHomepageHistory_GetRecentWindow_Call{Call: _e.mock.On("GetRecentWindow", ctx, before, beforeID, domain)}
646}
647
648func (_c *MockHomepageHistory_GetRecentWindow_Call) Run(run func(ctx context.Context, before time.Time, beforeID int64, domain string)) *MockHomepageHistory_GetRecentWindow_Call {
649 _c.Call.Run(func(args mock.Arguments) {
650 var arg0 context.Context
651 if args[0] != nil {
652 arg0 = args[0].(context.Context)
653 }
654 var arg1 time.Time
655 if args[1] != nil {
656 arg1 = args[1].(time.Time)
657 }
658 var arg2 int64
659 if args[2] != nil {
660 arg2 = args[2].(int64)
661 }
662 var arg3 string
663 if args[3] != nil {
664 arg3 = args[3].(string)
665 }
666 run(
667 arg0,
668 arg1,
669 arg2,
670 arg3,
671 )
672 })
673 return _c
674}
675
676func (_c *MockHomepageHistory_GetRecentWindow_Call) Return(historyWindow *entity.HistoryWindow, err error) *MockHomepageHistory_GetRecentWindow_Call {
677 _c.Call.Return(historyWindow, err)
678 return _c
679}
680
681func (_c *MockHomepageHistory_GetRecentWindow_Call) RunAndReturn(run func(ctx context.Context, before time.Time, beforeID int64, domain string) (*entity.HistoryWindow, error)) *MockHomepageHistory_GetRecentWindow_Call {
682 _c.Call.Return(run)
683 return _c
684}
685
686// GetStats provides a mock function for the type MockHomepageHistory
687func (_mock *MockHomepageHistory) GetStats(ctx context.Context) (*entity.HistoryStats, error) {
688 ret := _mock.Called(ctx)
689
690 if len(ret) == 0 {
691 panic("no return value specified for GetStats")
692 }
693
694 var r0 *entity.HistoryStats
695 var r1 error
696 if returnFunc, ok := ret.Get(0).(func(context.Context) (*entity.HistoryStats, error)); ok {
697 return returnFunc(ctx)
698 }
699 if returnFunc, ok := ret.Get(0).(func(context.Context) *entity.HistoryStats); ok {
700 r0 = returnFunc(ctx)
701 } else {
702 if ret.Get(0) != nil {
703 r0 = ret.Get(0).(*entity.HistoryStats)
704 }
705 }
706 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
707 r1 = returnFunc(ctx)
708 } else {
709 r1 = ret.Error(1)
710 }
711 return r0, r1
712}
713
714// MockHomepageHistory_GetStats_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStats'
715type MockHomepageHistory_GetStats_Call struct {
716 *mock.Call
717}
718
719// GetStats is a helper method to define mock.On call
720// - ctx context.Context
721func (_e *MockHomepageHistory_Expecter) GetStats(ctx any) *MockHomepageHistory_GetStats_Call {
722 return &MockHomepageHistory_GetStats_Call{Call: _e.mock.On("GetStats", ctx)}
723}
724
725func (_c *MockHomepageHistory_GetStats_Call) Run(run func(ctx context.Context)) *MockHomepageHistory_GetStats_Call {
726 _c.Call.Run(func(args mock.Arguments) {
727 var arg0 context.Context
728 if args[0] != nil {
729 arg0 = args[0].(context.Context)
730 }
731 run(
732 arg0,
733 )
734 })
735 return _c
736}
737
738func (_c *MockHomepageHistory_GetStats_Call) Return(historyStats *entity.HistoryStats, err error) *MockHomepageHistory_GetStats_Call {
739 _c.Call.Return(historyStats, err)
740 return _c
741}
742
743func (_c *MockHomepageHistory_GetStats_Call) RunAndReturn(run func(ctx context.Context) (*entity.HistoryStats, error)) *MockHomepageHistory_GetStats_Call {
744 _c.Call.Return(run)
745 return _c
746}
747
748// Search provides a mock function for the type MockHomepageHistory
749func (_mock *MockHomepageHistory) Search(ctx context.Context, input dto.HistorySearchInput) (*dto.HistorySearchOutput, error) {
750 ret := _mock.Called(ctx, input)
751
752 if len(ret) == 0 {
753 panic("no return value specified for Search")
754 }
755
756 var r0 *dto.HistorySearchOutput
757 var r1 error
758 if returnFunc, ok := ret.Get(0).(func(context.Context, dto.HistorySearchInput) (*dto.HistorySearchOutput, error)); ok {
759 return returnFunc(ctx, input)
760 }
761 if returnFunc, ok := ret.Get(0).(func(context.Context, dto.HistorySearchInput) *dto.HistorySearchOutput); ok {
762 r0 = returnFunc(ctx, input)
763 } else {
764 if ret.Get(0) != nil {
765 r0 = ret.Get(0).(*dto.HistorySearchOutput)
766 }
767 }
768 if returnFunc, ok := ret.Get(1).(func(context.Context, dto.HistorySearchInput) error); ok {
769 r1 = returnFunc(ctx, input)
770 } else {
771 r1 = ret.Error(1)
772 }
773 return r0, r1
774}
775
776// MockHomepageHistory_Search_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Search'
777type MockHomepageHistory_Search_Call struct {
778 *mock.Call
779}
780
781// Search is a helper method to define mock.On call
782// - ctx context.Context
783// - input dto.HistorySearchInput
784func (_e *MockHomepageHistory_Expecter) Search(ctx any, input any) *MockHomepageHistory_Search_Call {
785 return &MockHomepageHistory_Search_Call{Call: _e.mock.On("Search", ctx, input)}
786}
787
788func (_c *MockHomepageHistory_Search_Call) Run(run func(ctx context.Context, input dto.HistorySearchInput)) *MockHomepageHistory_Search_Call {
789 _c.Call.Run(func(args mock.Arguments) {
790 var arg0 context.Context
791 if args[0] != nil {
792 arg0 = args[0].(context.Context)
793 }
794 var arg1 dto.HistorySearchInput
795 if args[1] != nil {
796 arg1 = args[1].(dto.HistorySearchInput)
797 }
798 run(
799 arg0,
800 arg1,
801 )
802 })
803 return _c
804}
805
806func (_c *MockHomepageHistory_Search_Call) Return(historySearchOutput *dto.HistorySearchOutput, err error) *MockHomepageHistory_Search_Call {
807 _c.Call.Return(historySearchOutput, err)
808 return _c
809}
810
811func (_c *MockHomepageHistory_Search_Call) RunAndReturn(run func(ctx context.Context, input dto.HistorySearchInput) (*dto.HistorySearchOutput, error)) *MockHomepageHistory_Search_Call {
812 _c.Call.Return(run)
813 return _c
814}
815
816// NewMockHomepageFavorites creates a new instance of MockHomepageFavorites. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
817// The first argument is typically a *testing.T value.
818func NewMockHomepageFavorites(t interface {
819 mock.TestingT
820 Cleanup(func())
821}) *MockHomepageFavorites {
822 mock := &MockHomepageFavorites{}
823 mock.Mock.Test(t)
824
825 t.Cleanup(func() { mock.AssertExpectations(t) })
826
827 return mock
828}
829
830// MockHomepageFavorites is an autogenerated mock type for the HomepageFavorites type
831type MockHomepageFavorites struct {
832 mock.Mock
833}
834
835type MockHomepageFavorites_Expecter struct {
836 mock *mock.Mock
837}
838
839func (_m *MockHomepageFavorites) EXPECT() *MockHomepageFavorites_Expecter {
840 return &MockHomepageFavorites_Expecter{mock: &_m.Mock}
841}
842
843// AddFavorite provides a mock function for the type MockHomepageFavorites
844func (_mock *MockHomepageFavorites) AddFavorite(ctx context.Context, input dto.FavoriteCreateInput) (*entity.Favorite, error) {
845 ret := _mock.Called(ctx, input)
846
847 if len(ret) == 0 {
848 panic("no return value specified for AddFavorite")
849 }
850
851 var r0 *entity.Favorite
852 var r1 error
853 if returnFunc, ok := ret.Get(0).(func(context.Context, dto.FavoriteCreateInput) (*entity.Favorite, error)); ok {
854 return returnFunc(ctx, input)
855 }
856 if returnFunc, ok := ret.Get(0).(func(context.Context, dto.FavoriteCreateInput) *entity.Favorite); ok {
857 r0 = returnFunc(ctx, input)
858 } else {
859 if ret.Get(0) != nil {
860 r0 = ret.Get(0).(*entity.Favorite)
861 }
862 }
863 if returnFunc, ok := ret.Get(1).(func(context.Context, dto.FavoriteCreateInput) error); ok {
864 r1 = returnFunc(ctx, input)
865 } else {
866 r1 = ret.Error(1)
867 }
868 return r0, r1
869}
870
871// MockHomepageFavorites_AddFavorite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFavorite'
872type MockHomepageFavorites_AddFavorite_Call struct {
873 *mock.Call
874}
875
876// AddFavorite is a helper method to define mock.On call
877// - ctx context.Context
878// - input dto.FavoriteCreateInput
879func (_e *MockHomepageFavorites_Expecter) AddFavorite(ctx any, input any) *MockHomepageFavorites_AddFavorite_Call {
880 return &MockHomepageFavorites_AddFavorite_Call{Call: _e.mock.On("AddFavorite", ctx, input)}
881}
882
883func (_c *MockHomepageFavorites_AddFavorite_Call) Run(run func(ctx context.Context, input dto.FavoriteCreateInput)) *MockHomepageFavorites_AddFavorite_Call {
884 _c.Call.Run(func(args mock.Arguments) {
885 var arg0 context.Context
886 if args[0] != nil {
887 arg0 = args[0].(context.Context)
888 }
889 var arg1 dto.FavoriteCreateInput
890 if args[1] != nil {
891 arg1 = args[1].(dto.FavoriteCreateInput)
892 }
893 run(
894 arg0,
895 arg1,
896 )
897 })
898 return _c
899}
900
901func (_c *MockHomepageFavorites_AddFavorite_Call) Return(favorite *entity.Favorite, err error) *MockHomepageFavorites_AddFavorite_Call {
902 _c.Call.Return(favorite, err)
903 return _c
904}
905
906func (_c *MockHomepageFavorites_AddFavorite_Call) RunAndReturn(run func(ctx context.Context, input dto.FavoriteCreateInput) (*entity.Favorite, error)) *MockHomepageFavorites_AddFavorite_Call {
907 _c.Call.Return(run)
908 return _c
909}
910
911// AddTag provides a mock function for the type MockHomepageFavorites
912func (_mock *MockHomepageFavorites) AddTag(ctx context.Context, name string, color string) (*entity.Tag, error) {
913 ret := _mock.Called(ctx, name, color)
914
915 if len(ret) == 0 {
916 panic("no return value specified for AddTag")
917 }
918
919 var r0 *entity.Tag
920 var r1 error
921 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*entity.Tag, error)); ok {
922 return returnFunc(ctx, name, color)
923 }
924 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *entity.Tag); ok {
925 r0 = returnFunc(ctx, name, color)
926 } else {
927 if ret.Get(0) != nil {
928 r0 = ret.Get(0).(*entity.Tag)
929 }
930 }
931 if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
932 r1 = returnFunc(ctx, name, color)
933 } else {
934 r1 = ret.Error(1)
935 }
936 return r0, r1
937}
938
939// MockHomepageFavorites_AddTag_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddTag'
940type MockHomepageFavorites_AddTag_Call struct {
941 *mock.Call
942}
943
944// AddTag is a helper method to define mock.On call
945// - ctx context.Context
946// - name string
947// - color string
948func (_e *MockHomepageFavorites_Expecter) AddTag(ctx any, name any, color any) *MockHomepageFavorites_AddTag_Call {
949 return &MockHomepageFavorites_AddTag_Call{Call: _e.mock.On("AddTag", ctx, name, color)}
950}
951
952func (_c *MockHomepageFavorites_AddTag_Call) Run(run func(ctx context.Context, name string, color string)) *MockHomepageFavorites_AddTag_Call {
953 _c.Call.Run(func(args mock.Arguments) {
954 var arg0 context.Context
955 if args[0] != nil {
956 arg0 = args[0].(context.Context)
957 }
958 var arg1 string
959 if args[1] != nil {
960 arg1 = args[1].(string)
961 }
962 var arg2 string
963 if args[2] != nil {
964 arg2 = args[2].(string)
965 }
966 run(
967 arg0,
968 arg1,
969 arg2,
970 )
971 })
972 return _c
973}
974
975func (_c *MockHomepageFavorites_AddTag_Call) Return(tag *entity.Tag, err error) *MockHomepageFavorites_AddTag_Call {
976 _c.Call.Return(tag, err)
977 return _c
978}
979
980func (_c *MockHomepageFavorites_AddTag_Call) RunAndReturn(run func(ctx context.Context, name string, color string) (*entity.Tag, error)) *MockHomepageFavorites_AddTag_Call {
981 _c.Call.Return(run)
982 return _c
983}
984
985// CreateFolder provides a mock function for the type MockHomepageFavorites
986func (_mock *MockHomepageFavorites) CreateFolder(ctx context.Context, name string, icon string, parentID *entity.FolderID) (*entity.Folder, error) {
987 ret := _mock.Called(ctx, name, icon, parentID)
988
989 if len(ret) == 0 {
990 panic("no return value specified for CreateFolder")
991 }
992
993 var r0 *entity.Folder
994 var r1 error
995 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *entity.FolderID) (*entity.Folder, error)); ok {
996 return returnFunc(ctx, name, icon, parentID)
997 }
998 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *entity.FolderID) *entity.Folder); ok {
999 r0 = returnFunc(ctx, name, icon, parentID)
1000 } else {
1001 if ret.Get(0) != nil {
1002 r0 = ret.Get(0).(*entity.Folder)
1003 }
1004 }
1005 if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *entity.FolderID) error); ok {
1006 r1 = returnFunc(ctx, name, icon, parentID)
1007 } else {
1008 r1 = ret.Error(1)
1009 }
1010 return r0, r1
1011}
1012
1013// MockHomepageFavorites_CreateFolder_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateFolder'
1014type MockHomepageFavorites_CreateFolder_Call struct {
1015 *mock.Call
1016}
1017
1018// CreateFolder is a helper method to define mock.On call
1019// - ctx context.Context
1020// - name string
1021// - icon string
1022// - parentID *entity.FolderID
1023func (_e *MockHomepageFavorites_Expecter) CreateFolder(ctx any, name any, icon any, parentID any) *MockHomepageFavorites_CreateFolder_Call {
1024 return &MockHomepageFavorites_CreateFolder_Call{Call: _e.mock.On("CreateFolder", ctx, name, icon, parentID)}
1025}
1026
1027func (_c *MockHomepageFavorites_CreateFolder_Call) Run(run func(ctx context.Context, name string, icon string, parentID *entity.FolderID)) *MockHomepageFavorites_CreateFolder_Call {
1028 _c.Call.Run(func(args mock.Arguments) {
1029 var arg0 context.Context
1030 if args[0] != nil {
1031 arg0 = args[0].(context.Context)
1032 }
1033 var arg1 string
1034 if args[1] != nil {
1035 arg1 = args[1].(string)
1036 }
1037 var arg2 string
1038 if args[2] != nil {
1039 arg2 = args[2].(string)
1040 }
1041 var arg3 *entity.FolderID
1042 if args[3] != nil {
1043 arg3 = args[3].(*entity.FolderID)
1044 }
1045 run(
1046 arg0,
1047 arg1,
1048 arg2,
1049 arg3,
1050 )
1051 })
1052 return _c
1053}
1054
1055func (_c *MockHomepageFavorites_CreateFolder_Call) Return(folder *entity.Folder, err error) *MockHomepageFavorites_CreateFolder_Call {
1056 _c.Call.Return(folder, err)
1057 return _c
1058}
1059
1060func (_c *MockHomepageFavorites_CreateFolder_Call) RunAndReturn(run func(ctx context.Context, name string, icon string, parentID *entity.FolderID) (*entity.Folder, error)) *MockHomepageFavorites_CreateFolder_Call {
1061 _c.Call.Return(run)
1062 return _c
1063}
1064
1065// DeleteFavorite provides a mock function for the type MockHomepageFavorites
1066func (_mock *MockHomepageFavorites) DeleteFavorite(ctx context.Context, id entity.FavoriteID) error {
1067 ret := _mock.Called(ctx, id)
1068
1069 if len(ret) == 0 {
1070 panic("no return value specified for DeleteFavorite")
1071 }
1072
1073 var r0 error
1074 if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FavoriteID) error); ok {
1075 r0 = returnFunc(ctx, id)
1076 } else {
1077 r0 = ret.Error(0)
1078 }
1079 return r0
1080}
1081
1082// MockHomepageFavorites_DeleteFavorite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFavorite'
1083type MockHomepageFavorites_DeleteFavorite_Call struct {
1084 *mock.Call
1085}
1086
1087// DeleteFavorite is a helper method to define mock.On call
1088// - ctx context.Context
1089// - id entity.FavoriteID
1090func (_e *MockHomepageFavorites_Expecter) DeleteFavorite(ctx any, id any) *MockHomepageFavorites_DeleteFavorite_Call {
1091 return &MockHomepageFavorites_DeleteFavorite_Call{Call: _e.mock.On("DeleteFavorite", ctx, id)}
1092}
1093
1094func (_c *MockHomepageFavorites_DeleteFavorite_Call) Run(run func(ctx context.Context, id entity.FavoriteID)) *MockHomepageFavorites_DeleteFavorite_Call {
1095 _c.Call.Run(func(args mock.Arguments) {
1096 var arg0 context.Context
1097 if args[0] != nil {
1098 arg0 = args[0].(context.Context)
1099 }
1100 var arg1 entity.FavoriteID
1101 if args[1] != nil {
1102 arg1 = args[1].(entity.FavoriteID)
1103 }
1104 run(
1105 arg0,
1106 arg1,
1107 )
1108 })
1109 return _c
1110}
1111
1112func (_c *MockHomepageFavorites_DeleteFavorite_Call) Return(err error) *MockHomepageFavorites_DeleteFavorite_Call {
1113 _c.Call.Return(err)
1114 return _c
1115}
1116
1117func (_c *MockHomepageFavorites_DeleteFavorite_Call) RunAndReturn(run func(ctx context.Context, id entity.FavoriteID) error) *MockHomepageFavorites_DeleteFavorite_Call {
1118 _c.Call.Return(run)
1119 return _c
1120}
1121
1122// DeleteFolder provides a mock function for the type MockHomepageFavorites
1123func (_mock *MockHomepageFavorites) DeleteFolder(ctx context.Context, id entity.FolderID) error {
1124 ret := _mock.Called(ctx, id)
1125
1126 if len(ret) == 0 {
1127 panic("no return value specified for DeleteFolder")
1128 }
1129
1130 var r0 error
1131 if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FolderID) error); ok {
1132 r0 = returnFunc(ctx, id)
1133 } else {
1134 r0 = ret.Error(0)
1135 }
1136 return r0
1137}
1138
1139// MockHomepageFavorites_DeleteFolder_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteFolder'
1140type MockHomepageFavorites_DeleteFolder_Call struct {
1141 *mock.Call
1142}
1143
1144// DeleteFolder is a helper method to define mock.On call
1145// - ctx context.Context
1146// - id entity.FolderID
1147func (_e *MockHomepageFavorites_Expecter) DeleteFolder(ctx any, id any) *MockHomepageFavorites_DeleteFolder_Call {
1148 return &MockHomepageFavorites_DeleteFolder_Call{Call: _e.mock.On("DeleteFolder", ctx, id)}
1149}
1150
1151func (_c *MockHomepageFavorites_DeleteFolder_Call) Run(run func(ctx context.Context, id entity.FolderID)) *MockHomepageFavorites_DeleteFolder_Call {
1152 _c.Call.Run(func(args mock.Arguments) {
1153 var arg0 context.Context
1154 if args[0] != nil {
1155 arg0 = args[0].(context.Context)
1156 }
1157 var arg1 entity.FolderID
1158 if args[1] != nil {
1159 arg1 = args[1].(entity.FolderID)
1160 }
1161 run(
1162 arg0,
1163 arg1,
1164 )
1165 })
1166 return _c
1167}
1168
1169func (_c *MockHomepageFavorites_DeleteFolder_Call) Return(err error) *MockHomepageFavorites_DeleteFolder_Call {
1170 _c.Call.Return(err)
1171 return _c
1172}
1173
1174func (_c *MockHomepageFavorites_DeleteFolder_Call) RunAndReturn(run func(ctx context.Context, id entity.FolderID) error) *MockHomepageFavorites_DeleteFolder_Call {
1175 _c.Call.Return(run)
1176 return _c
1177}
1178
1179// DeleteTag provides a mock function for the type MockHomepageFavorites
1180func (_mock *MockHomepageFavorites) DeleteTag(ctx context.Context, id entity.TagID) error {
1181 ret := _mock.Called(ctx, id)
1182
1183 if len(ret) == 0 {
1184 panic("no return value specified for DeleteTag")
1185 }
1186
1187 var r0 error
1188 if returnFunc, ok := ret.Get(0).(func(context.Context, entity.TagID) error); ok {
1189 r0 = returnFunc(ctx, id)
1190 } else {
1191 r0 = ret.Error(0)
1192 }
1193 return r0
1194}
1195
1196// MockHomepageFavorites_DeleteTag_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTag'
1197type MockHomepageFavorites_DeleteTag_Call struct {
1198 *mock.Call
1199}
1200
1201// DeleteTag is a helper method to define mock.On call
1202// - ctx context.Context
1203// - id entity.TagID
1204func (_e *MockHomepageFavorites_Expecter) DeleteTag(ctx any, id any) *MockHomepageFavorites_DeleteTag_Call {
1205 return &MockHomepageFavorites_DeleteTag_Call{Call: _e.mock.On("DeleteTag", ctx, id)}
1206}
1207
1208func (_c *MockHomepageFavorites_DeleteTag_Call) Run(run func(ctx context.Context, id entity.TagID)) *MockHomepageFavorites_DeleteTag_Call {
1209 _c.Call.Run(func(args mock.Arguments) {
1210 var arg0 context.Context
1211 if args[0] != nil {
1212 arg0 = args[0].(context.Context)
1213 }
1214 var arg1 entity.TagID
1215 if args[1] != nil {
1216 arg1 = args[1].(entity.TagID)
1217 }
1218 run(
1219 arg0,
1220 arg1,
1221 )
1222 })
1223 return _c
1224}
1225
1226func (_c *MockHomepageFavorites_DeleteTag_Call) Return(err error) *MockHomepageFavorites_DeleteTag_Call {
1227 _c.Call.Return(err)
1228 return _c
1229}
1230
1231func (_c *MockHomepageFavorites_DeleteTag_Call) RunAndReturn(run func(ctx context.Context, id entity.TagID) error) *MockHomepageFavorites_DeleteTag_Call {
1232 _c.Call.Return(run)
1233 return _c
1234}
1235
1236// GetAll provides a mock function for the type MockHomepageFavorites
1237func (_mock *MockHomepageFavorites) GetAll(ctx context.Context) ([]*entity.Favorite, error) {
1238 ret := _mock.Called(ctx)
1239
1240 if len(ret) == 0 {
1241 panic("no return value specified for GetAll")
1242 }
1243
1244 var r0 []*entity.Favorite
1245 var r1 error
1246 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*entity.Favorite, error)); ok {
1247 return returnFunc(ctx)
1248 }
1249 if returnFunc, ok := ret.Get(0).(func(context.Context) []*entity.Favorite); ok {
1250 r0 = returnFunc(ctx)
1251 } else {
1252 if ret.Get(0) != nil {
1253 r0 = ret.Get(0).([]*entity.Favorite)
1254 }
1255 }
1256 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1257 r1 = returnFunc(ctx)
1258 } else {
1259 r1 = ret.Error(1)
1260 }
1261 return r0, r1
1262}
1263
1264// MockHomepageFavorites_GetAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAll'
1265type MockHomepageFavorites_GetAll_Call struct {
1266 *mock.Call
1267}
1268
1269// GetAll is a helper method to define mock.On call
1270// - ctx context.Context
1271func (_e *MockHomepageFavorites_Expecter) GetAll(ctx any) *MockHomepageFavorites_GetAll_Call {
1272 return &MockHomepageFavorites_GetAll_Call{Call: _e.mock.On("GetAll", ctx)}
1273}
1274
1275func (_c *MockHomepageFavorites_GetAll_Call) Run(run func(ctx context.Context)) *MockHomepageFavorites_GetAll_Call {
1276 _c.Call.Run(func(args mock.Arguments) {
1277 var arg0 context.Context
1278 if args[0] != nil {
1279 arg0 = args[0].(context.Context)
1280 }
1281 run(
1282 arg0,
1283 )
1284 })
1285 return _c
1286}
1287
1288func (_c *MockHomepageFavorites_GetAll_Call) Return(favorites []*entity.Favorite, err error) *MockHomepageFavorites_GetAll_Call {
1289 _c.Call.Return(favorites, err)
1290 return _c
1291}
1292
1293func (_c *MockHomepageFavorites_GetAll_Call) RunAndReturn(run func(ctx context.Context) ([]*entity.Favorite, error)) *MockHomepageFavorites_GetAll_Call {
1294 _c.Call.Return(run)
1295 return _c
1296}
1297
1298// GetAllFolders provides a mock function for the type MockHomepageFavorites
1299func (_mock *MockHomepageFavorites) GetAllFolders(ctx context.Context) ([]*entity.Folder, error) {
1300 ret := _mock.Called(ctx)
1301
1302 if len(ret) == 0 {
1303 panic("no return value specified for GetAllFolders")
1304 }
1305
1306 var r0 []*entity.Folder
1307 var r1 error
1308 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*entity.Folder, error)); ok {
1309 return returnFunc(ctx)
1310 }
1311 if returnFunc, ok := ret.Get(0).(func(context.Context) []*entity.Folder); ok {
1312 r0 = returnFunc(ctx)
1313 } else {
1314 if ret.Get(0) != nil {
1315 r0 = ret.Get(0).([]*entity.Folder)
1316 }
1317 }
1318 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1319 r1 = returnFunc(ctx)
1320 } else {
1321 r1 = ret.Error(1)
1322 }
1323 return r0, r1
1324}
1325
1326// MockHomepageFavorites_GetAllFolders_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllFolders'
1327type MockHomepageFavorites_GetAllFolders_Call struct {
1328 *mock.Call
1329}
1330
1331// GetAllFolders is a helper method to define mock.On call
1332// - ctx context.Context
1333func (_e *MockHomepageFavorites_Expecter) GetAllFolders(ctx any) *MockHomepageFavorites_GetAllFolders_Call {
1334 return &MockHomepageFavorites_GetAllFolders_Call{Call: _e.mock.On("GetAllFolders", ctx)}
1335}
1336
1337func (_c *MockHomepageFavorites_GetAllFolders_Call) Run(run func(ctx context.Context)) *MockHomepageFavorites_GetAllFolders_Call {
1338 _c.Call.Run(func(args mock.Arguments) {
1339 var arg0 context.Context
1340 if args[0] != nil {
1341 arg0 = args[0].(context.Context)
1342 }
1343 run(
1344 arg0,
1345 )
1346 })
1347 return _c
1348}
1349
1350func (_c *MockHomepageFavorites_GetAllFolders_Call) Return(folders []*entity.Folder, err error) *MockHomepageFavorites_GetAllFolders_Call {
1351 _c.Call.Return(folders, err)
1352 return _c
1353}
1354
1355func (_c *MockHomepageFavorites_GetAllFolders_Call) RunAndReturn(run func(ctx context.Context) ([]*entity.Folder, error)) *MockHomepageFavorites_GetAllFolders_Call {
1356 _c.Call.Return(run)
1357 return _c
1358}
1359
1360// GetAllTags provides a mock function for the type MockHomepageFavorites
1361func (_mock *MockHomepageFavorites) GetAllTags(ctx context.Context) ([]*entity.Tag, error) {
1362 ret := _mock.Called(ctx)
1363
1364 if len(ret) == 0 {
1365 panic("no return value specified for GetAllTags")
1366 }
1367
1368 var r0 []*entity.Tag
1369 var r1 error
1370 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*entity.Tag, error)); ok {
1371 return returnFunc(ctx)
1372 }
1373 if returnFunc, ok := ret.Get(0).(func(context.Context) []*entity.Tag); ok {
1374 r0 = returnFunc(ctx)
1375 } else {
1376 if ret.Get(0) != nil {
1377 r0 = ret.Get(0).([]*entity.Tag)
1378 }
1379 }
1380 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1381 r1 = returnFunc(ctx)
1382 } else {
1383 r1 = ret.Error(1)
1384 }
1385 return r0, r1
1386}
1387
1388// MockHomepageFavorites_GetAllTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllTags'
1389type MockHomepageFavorites_GetAllTags_Call struct {
1390 *mock.Call
1391}
1392
1393// GetAllTags is a helper method to define mock.On call
1394// - ctx context.Context
1395func (_e *MockHomepageFavorites_Expecter) GetAllTags(ctx any) *MockHomepageFavorites_GetAllTags_Call {
1396 return &MockHomepageFavorites_GetAllTags_Call{Call: _e.mock.On("GetAllTags", ctx)}
1397}
1398
1399func (_c *MockHomepageFavorites_GetAllTags_Call) Run(run func(ctx context.Context)) *MockHomepageFavorites_GetAllTags_Call {
1400 _c.Call.Run(func(args mock.Arguments) {
1401 var arg0 context.Context
1402 if args[0] != nil {
1403 arg0 = args[0].(context.Context)
1404 }
1405 run(
1406 arg0,
1407 )
1408 })
1409 return _c
1410}
1411
1412func (_c *MockHomepageFavorites_GetAllTags_Call) Return(tags []*entity.Tag, err error) *MockHomepageFavorites_GetAllTags_Call {
1413 _c.Call.Return(tags, err)
1414 return _c
1415}
1416
1417func (_c *MockHomepageFavorites_GetAllTags_Call) RunAndReturn(run func(ctx context.Context) ([]*entity.Tag, error)) *MockHomepageFavorites_GetAllTags_Call {
1418 _c.Call.Return(run)
1419 return _c
1420}
1421
1422// GetByShortcut provides a mock function for the type MockHomepageFavorites
1423func (_mock *MockHomepageFavorites) GetByShortcut(ctx context.Context, key int) (*entity.Favorite, error) {
1424 ret := _mock.Called(ctx, key)
1425
1426 if len(ret) == 0 {
1427 panic("no return value specified for GetByShortcut")
1428 }
1429
1430 var r0 *entity.Favorite
1431 var r1 error
1432 if returnFunc, ok := ret.Get(0).(func(context.Context, int) (*entity.Favorite, error)); ok {
1433 return returnFunc(ctx, key)
1434 }
1435 if returnFunc, ok := ret.Get(0).(func(context.Context, int) *entity.Favorite); ok {
1436 r0 = returnFunc(ctx, key)
1437 } else {
1438 if ret.Get(0) != nil {
1439 r0 = ret.Get(0).(*entity.Favorite)
1440 }
1441 }
1442 if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
1443 r1 = returnFunc(ctx, key)
1444 } else {
1445 r1 = ret.Error(1)
1446 }
1447 return r0, r1
1448}
1449
1450// MockHomepageFavorites_GetByShortcut_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetByShortcut'
1451type MockHomepageFavorites_GetByShortcut_Call struct {
1452 *mock.Call
1453}
1454
1455// GetByShortcut is a helper method to define mock.On call
1456// - ctx context.Context
1457// - key int
1458func (_e *MockHomepageFavorites_Expecter) GetByShortcut(ctx any, key any) *MockHomepageFavorites_GetByShortcut_Call {
1459 return &MockHomepageFavorites_GetByShortcut_Call{Call: _e.mock.On("GetByShortcut", ctx, key)}
1460}
1461
1462func (_c *MockHomepageFavorites_GetByShortcut_Call) Run(run func(ctx context.Context, key int)) *MockHomepageFavorites_GetByShortcut_Call {
1463 _c.Call.Run(func(args mock.Arguments) {
1464 var arg0 context.Context
1465 if args[0] != nil {
1466 arg0 = args[0].(context.Context)
1467 }
1468 var arg1 int
1469 if args[1] != nil {
1470 arg1 = args[1].(int)
1471 }
1472 run(
1473 arg0,
1474 arg1,
1475 )
1476 })
1477 return _c
1478}
1479
1480func (_c *MockHomepageFavorites_GetByShortcut_Call) Return(favorite *entity.Favorite, err error) *MockHomepageFavorites_GetByShortcut_Call {
1481 _c.Call.Return(favorite, err)
1482 return _c
1483}
1484
1485func (_c *MockHomepageFavorites_GetByShortcut_Call) RunAndReturn(run func(ctx context.Context, key int) (*entity.Favorite, error)) *MockHomepageFavorites_GetByShortcut_Call {
1486 _c.Call.Return(run)
1487 return _c
1488}
1489
1490// Move provides a mock function for the type MockHomepageFavorites
1491func (_mock *MockHomepageFavorites) Move(ctx context.Context, id entity.FavoriteID, folderID *entity.FolderID) error {
1492 ret := _mock.Called(ctx, id, folderID)
1493
1494 if len(ret) == 0 {
1495 panic("no return value specified for Move")
1496 }
1497
1498 var r0 error
1499 if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FavoriteID, *entity.FolderID) error); ok {
1500 r0 = returnFunc(ctx, id, folderID)
1501 } else {
1502 r0 = ret.Error(0)
1503 }
1504 return r0
1505}
1506
1507// MockHomepageFavorites_Move_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Move'
1508type MockHomepageFavorites_Move_Call struct {
1509 *mock.Call
1510}
1511
1512// Move is a helper method to define mock.On call
1513// - ctx context.Context
1514// - id entity.FavoriteID
1515// - folderID *entity.FolderID
1516func (_e *MockHomepageFavorites_Expecter) Move(ctx any, id any, folderID any) *MockHomepageFavorites_Move_Call {
1517 return &MockHomepageFavorites_Move_Call{Call: _e.mock.On("Move", ctx, id, folderID)}
1518}
1519
1520func (_c *MockHomepageFavorites_Move_Call) Run(run func(ctx context.Context, id entity.FavoriteID, folderID *entity.FolderID)) *MockHomepageFavorites_Move_Call {
1521 _c.Call.Run(func(args mock.Arguments) {
1522 var arg0 context.Context
1523 if args[0] != nil {
1524 arg0 = args[0].(context.Context)
1525 }
1526 var arg1 entity.FavoriteID
1527 if args[1] != nil {
1528 arg1 = args[1].(entity.FavoriteID)
1529 }
1530 var arg2 *entity.FolderID
1531 if args[2] != nil {
1532 arg2 = args[2].(*entity.FolderID)
1533 }
1534 run(
1535 arg0,
1536 arg1,
1537 arg2,
1538 )
1539 })
1540 return _c
1541}
1542
1543func (_c *MockHomepageFavorites_Move_Call) Return(err error) *MockHomepageFavorites_Move_Call {
1544 _c.Call.Return(err)
1545 return _c
1546}
1547
1548func (_c *MockHomepageFavorites_Move_Call) RunAndReturn(run func(ctx context.Context, id entity.FavoriteID, folderID *entity.FolderID) error) *MockHomepageFavorites_Move_Call {
1549 _c.Call.Return(run)
1550 return _c
1551}
1552
1553// SetShortcut provides a mock function for the type MockHomepageFavorites
1554func (_mock *MockHomepageFavorites) SetShortcut(ctx context.Context, id entity.FavoriteID, key *int) error {
1555 ret := _mock.Called(ctx, id, key)
1556
1557 if len(ret) == 0 {
1558 panic("no return value specified for SetShortcut")
1559 }
1560
1561 var r0 error
1562 if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FavoriteID, *int) error); ok {
1563 r0 = returnFunc(ctx, id, key)
1564 } else {
1565 r0 = ret.Error(0)
1566 }
1567 return r0
1568}
1569
1570// MockHomepageFavorites_SetShortcut_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetShortcut'
1571type MockHomepageFavorites_SetShortcut_Call struct {
1572 *mock.Call
1573}
1574
1575// SetShortcut is a helper method to define mock.On call
1576// - ctx context.Context
1577// - id entity.FavoriteID
1578// - key *int
1579func (_e *MockHomepageFavorites_Expecter) SetShortcut(ctx any, id any, key any) *MockHomepageFavorites_SetShortcut_Call {
1580 return &MockHomepageFavorites_SetShortcut_Call{Call: _e.mock.On("SetShortcut", ctx, id, key)}
1581}
1582
1583func (_c *MockHomepageFavorites_SetShortcut_Call) Run(run func(ctx context.Context, id entity.FavoriteID, key *int)) *MockHomepageFavorites_SetShortcut_Call {
1584 _c.Call.Run(func(args mock.Arguments) {
1585 var arg0 context.Context
1586 if args[0] != nil {
1587 arg0 = args[0].(context.Context)
1588 }
1589 var arg1 entity.FavoriteID
1590 if args[1] != nil {
1591 arg1 = args[1].(entity.FavoriteID)
1592 }
1593 var arg2 *int
1594 if args[2] != nil {
1595 arg2 = args[2].(*int)
1596 }
1597 run(
1598 arg0,
1599 arg1,
1600 arg2,
1601 )
1602 })
1603 return _c
1604}
1605
1606func (_c *MockHomepageFavorites_SetShortcut_Call) Return(err error) *MockHomepageFavorites_SetShortcut_Call {
1607 _c.Call.Return(err)
1608 return _c
1609}
1610
1611func (_c *MockHomepageFavorites_SetShortcut_Call) RunAndReturn(run func(ctx context.Context, id entity.FavoriteID, key *int) error) *MockHomepageFavorites_SetShortcut_Call {
1612 _c.Call.Return(run)
1613 return _c
1614}
1615
1616// TagFavorite provides a mock function for the type MockHomepageFavorites
1617func (_mock *MockHomepageFavorites) TagFavorite(ctx context.Context, favID entity.FavoriteID, tagID entity.TagID) error {
1618 ret := _mock.Called(ctx, favID, tagID)
1619
1620 if len(ret) == 0 {
1621 panic("no return value specified for TagFavorite")
1622 }
1623
1624 var r0 error
1625 if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FavoriteID, entity.TagID) error); ok {
1626 r0 = returnFunc(ctx, favID, tagID)
1627 } else {
1628 r0 = ret.Error(0)
1629 }
1630 return r0
1631}
1632
1633// MockHomepageFavorites_TagFavorite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TagFavorite'
1634type MockHomepageFavorites_TagFavorite_Call struct {
1635 *mock.Call
1636}
1637
1638// TagFavorite is a helper method to define mock.On call
1639// - ctx context.Context
1640// - favID entity.FavoriteID
1641// - tagID entity.TagID
1642func (_e *MockHomepageFavorites_Expecter) TagFavorite(ctx any, favID any, tagID any) *MockHomepageFavorites_TagFavorite_Call {
1643 return &MockHomepageFavorites_TagFavorite_Call{Call: _e.mock.On("TagFavorite", ctx, favID, tagID)}
1644}
1645
1646func (_c *MockHomepageFavorites_TagFavorite_Call) Run(run func(ctx context.Context, favID entity.FavoriteID, tagID entity.TagID)) *MockHomepageFavorites_TagFavorite_Call {
1647 _c.Call.Run(func(args mock.Arguments) {
1648 var arg0 context.Context
1649 if args[0] != nil {
1650 arg0 = args[0].(context.Context)
1651 }
1652 var arg1 entity.FavoriteID
1653 if args[1] != nil {
1654 arg1 = args[1].(entity.FavoriteID)
1655 }
1656 var arg2 entity.TagID
1657 if args[2] != nil {
1658 arg2 = args[2].(entity.TagID)
1659 }
1660 run(
1661 arg0,
1662 arg1,
1663 arg2,
1664 )
1665 })
1666 return _c
1667}
1668
1669func (_c *MockHomepageFavorites_TagFavorite_Call) Return(err error) *MockHomepageFavorites_TagFavorite_Call {
1670 _c.Call.Return(err)
1671 return _c
1672}
1673
1674func (_c *MockHomepageFavorites_TagFavorite_Call) RunAndReturn(run func(ctx context.Context, favID entity.FavoriteID, tagID entity.TagID) error) *MockHomepageFavorites_TagFavorite_Call {
1675 _c.Call.Return(run)
1676 return _c
1677}
1678
1679// UntagFavorite provides a mock function for the type MockHomepageFavorites
1680func (_mock *MockHomepageFavorites) UntagFavorite(ctx context.Context, favID entity.FavoriteID, tagID entity.TagID) error {
1681 ret := _mock.Called(ctx, favID, tagID)
1682
1683 if len(ret) == 0 {
1684 panic("no return value specified for UntagFavorite")
1685 }
1686
1687 var r0 error
1688 if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FavoriteID, entity.TagID) error); ok {
1689 r0 = returnFunc(ctx, favID, tagID)
1690 } else {
1691 r0 = ret.Error(0)
1692 }
1693 return r0
1694}
1695
1696// MockHomepageFavorites_UntagFavorite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UntagFavorite'
1697type MockHomepageFavorites_UntagFavorite_Call struct {
1698 *mock.Call
1699}
1700
1701// UntagFavorite is a helper method to define mock.On call
1702// - ctx context.Context
1703// - favID entity.FavoriteID
1704// - tagID entity.TagID
1705func (_e *MockHomepageFavorites_Expecter) UntagFavorite(ctx any, favID any, tagID any) *MockHomepageFavorites_UntagFavorite_Call {
1706 return &MockHomepageFavorites_UntagFavorite_Call{Call: _e.mock.On("UntagFavorite", ctx, favID, tagID)}
1707}
1708
1709func (_c *MockHomepageFavorites_UntagFavorite_Call) Run(run func(ctx context.Context, favID entity.FavoriteID, tagID entity.TagID)) *MockHomepageFavorites_UntagFavorite_Call {
1710 _c.Call.Run(func(args mock.Arguments) {
1711 var arg0 context.Context
1712 if args[0] != nil {
1713 arg0 = args[0].(context.Context)
1714 }
1715 var arg1 entity.FavoriteID
1716 if args[1] != nil {
1717 arg1 = args[1].(entity.FavoriteID)
1718 }
1719 var arg2 entity.TagID
1720 if args[2] != nil {
1721 arg2 = args[2].(entity.TagID)
1722 }
1723 run(
1724 arg0,
1725 arg1,
1726 arg2,
1727 )
1728 })
1729 return _c
1730}
1731
1732func (_c *MockHomepageFavorites_UntagFavorite_Call) Return(err error) *MockHomepageFavorites_UntagFavorite_Call {
1733 _c.Call.Return(err)
1734 return _c
1735}
1736
1737func (_c *MockHomepageFavorites_UntagFavorite_Call) RunAndReturn(run func(ctx context.Context, favID entity.FavoriteID, tagID entity.TagID) error) *MockHomepageFavorites_UntagFavorite_Call {
1738 _c.Call.Return(run)
1739 return _c
1740}
1741
1742// UpdateFavorite provides a mock function for the type MockHomepageFavorites
1743func (_mock *MockHomepageFavorites) UpdateFavorite(ctx context.Context, input dto.FavoriteUpdateInput) (*entity.Favorite, error) {
1744 ret := _mock.Called(ctx, input)
1745
1746 if len(ret) == 0 {
1747 panic("no return value specified for UpdateFavorite")
1748 }
1749
1750 var r0 *entity.Favorite
1751 var r1 error
1752 if returnFunc, ok := ret.Get(0).(func(context.Context, dto.FavoriteUpdateInput) (*entity.Favorite, error)); ok {
1753 return returnFunc(ctx, input)
1754 }
1755 if returnFunc, ok := ret.Get(0).(func(context.Context, dto.FavoriteUpdateInput) *entity.Favorite); ok {
1756 r0 = returnFunc(ctx, input)
1757 } else {
1758 if ret.Get(0) != nil {
1759 r0 = ret.Get(0).(*entity.Favorite)
1760 }
1761 }
1762 if returnFunc, ok := ret.Get(1).(func(context.Context, dto.FavoriteUpdateInput) error); ok {
1763 r1 = returnFunc(ctx, input)
1764 } else {
1765 r1 = ret.Error(1)
1766 }
1767 return r0, r1
1768}
1769
1770// MockHomepageFavorites_UpdateFavorite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateFavorite'
1771type MockHomepageFavorites_UpdateFavorite_Call struct {
1772 *mock.Call
1773}
1774
1775// UpdateFavorite is a helper method to define mock.On call
1776// - ctx context.Context
1777// - input dto.FavoriteUpdateInput
1778func (_e *MockHomepageFavorites_Expecter) UpdateFavorite(ctx any, input any) *MockHomepageFavorites_UpdateFavorite_Call {
1779 return &MockHomepageFavorites_UpdateFavorite_Call{Call: _e.mock.On("UpdateFavorite", ctx, input)}
1780}
1781
1782func (_c *MockHomepageFavorites_UpdateFavorite_Call) Run(run func(ctx context.Context, input dto.FavoriteUpdateInput)) *MockHomepageFavorites_UpdateFavorite_Call {
1783 _c.Call.Run(func(args mock.Arguments) {
1784 var arg0 context.Context
1785 if args[0] != nil {
1786 arg0 = args[0].(context.Context)
1787 }
1788 var arg1 dto.FavoriteUpdateInput
1789 if args[1] != nil {
1790 arg1 = args[1].(dto.FavoriteUpdateInput)
1791 }
1792 run(
1793 arg0,
1794 arg1,
1795 )
1796 })
1797 return _c
1798}
1799
1800func (_c *MockHomepageFavorites_UpdateFavorite_Call) Return(favorite *entity.Favorite, err error) *MockHomepageFavorites_UpdateFavorite_Call {
1801 _c.Call.Return(favorite, err)
1802 return _c
1803}
1804
1805func (_c *MockHomepageFavorites_UpdateFavorite_Call) RunAndReturn(run func(ctx context.Context, input dto.FavoriteUpdateInput) (*entity.Favorite, error)) *MockHomepageFavorites_UpdateFavorite_Call {
1806 _c.Call.Return(run)
1807 return _c
1808}
1809
1810// UpdateFolder provides a mock function for the type MockHomepageFavorites
1811func (_mock *MockHomepageFavorites) UpdateFolder(ctx context.Context, id entity.FolderID, name string, icon string) error {
1812 ret := _mock.Called(ctx, id, name, icon)
1813
1814 if len(ret) == 0 {
1815 panic("no return value specified for UpdateFolder")
1816 }
1817
1818 var r0 error
1819 if returnFunc, ok := ret.Get(0).(func(context.Context, entity.FolderID, string, string) error); ok {
1820 r0 = returnFunc(ctx, id, name, icon)
1821 } else {
1822 r0 = ret.Error(0)
1823 }
1824 return r0
1825}
1826
1827// MockHomepageFavorites_UpdateFolder_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateFolder'
1828type MockHomepageFavorites_UpdateFolder_Call struct {
1829 *mock.Call
1830}
1831
1832// UpdateFolder is a helper method to define mock.On call
1833// - ctx context.Context
1834// - id entity.FolderID
1835// - name string
1836// - icon string
1837func (_e *MockHomepageFavorites_Expecter) UpdateFolder(ctx any, id any, name any, icon any) *MockHomepageFavorites_UpdateFolder_Call {
1838 return &MockHomepageFavorites_UpdateFolder_Call{Call: _e.mock.On("UpdateFolder", ctx, id, name, icon)}
1839}
1840
1841func (_c *MockHomepageFavorites_UpdateFolder_Call) Run(run func(ctx context.Context, id entity.FolderID, name string, icon string)) *MockHomepageFavorites_UpdateFolder_Call {
1842 _c.Call.Run(func(args mock.Arguments) {
1843 var arg0 context.Context
1844 if args[0] != nil {
1845 arg0 = args[0].(context.Context)
1846 }
1847 var arg1 entity.FolderID
1848 if args[1] != nil {
1849 arg1 = args[1].(entity.FolderID)
1850 }
1851 var arg2 string
1852 if args[2] != nil {
1853 arg2 = args[2].(string)
1854 }
1855 var arg3 string
1856 if args[3] != nil {
1857 arg3 = args[3].(string)
1858 }
1859 run(
1860 arg0,
1861 arg1,
1862 arg2,
1863 arg3,
1864 )
1865 })
1866 return _c
1867}
1868
1869func (_c *MockHomepageFavorites_UpdateFolder_Call) Return(err error) *MockHomepageFavorites_UpdateFolder_Call {
1870 _c.Call.Return(err)
1871 return _c
1872}
1873
1874func (_c *MockHomepageFavorites_UpdateFolder_Call) RunAndReturn(run func(ctx context.Context, id entity.FolderID, name string, icon string) error) *MockHomepageFavorites_UpdateFolder_Call {
1875 _c.Call.Return(run)
1876 return _c
1877}
1878
1879// UpdateTag provides a mock function for the type MockHomepageFavorites
1880func (_mock *MockHomepageFavorites) UpdateTag(ctx context.Context, id entity.TagID, name string, color string) error {
1881 ret := _mock.Called(ctx, id, name, color)
1882
1883 if len(ret) == 0 {
1884 panic("no return value specified for UpdateTag")
1885 }
1886
1887 var r0 error
1888 if returnFunc, ok := ret.Get(0).(func(context.Context, entity.TagID, string, string) error); ok {
1889 r0 = returnFunc(ctx, id, name, color)
1890 } else {
1891 r0 = ret.Error(0)
1892 }
1893 return r0
1894}
1895
1896// MockHomepageFavorites_UpdateTag_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTag'
1897type MockHomepageFavorites_UpdateTag_Call struct {
1898 *mock.Call
1899}
1900
1901// UpdateTag is a helper method to define mock.On call
1902// - ctx context.Context
1903// - id entity.TagID
1904// - name string
1905// - color string
1906func (_e *MockHomepageFavorites_Expecter) UpdateTag(ctx any, id any, name any, color any) *MockHomepageFavorites_UpdateTag_Call {
1907 return &MockHomepageFavorites_UpdateTag_Call{Call: _e.mock.On("UpdateTag", ctx, id, name, color)}
1908}
1909
1910func (_c *MockHomepageFavorites_UpdateTag_Call) Run(run func(ctx context.Context, id entity.TagID, name string, color string)) *MockHomepageFavorites_UpdateTag_Call {
1911 _c.Call.Run(func(args mock.Arguments) {
1912 var arg0 context.Context
1913 if args[0] != nil {
1914 arg0 = args[0].(context.Context)
1915 }
1916 var arg1 entity.TagID
1917 if args[1] != nil {
1918 arg1 = args[1].(entity.TagID)
1919 }
1920 var arg2 string
1921 if args[2] != nil {
1922 arg2 = args[2].(string)
1923 }
1924 var arg3 string
1925 if args[3] != nil {
1926 arg3 = args[3].(string)
1927 }
1928 run(
1929 arg0,
1930 arg1,
1931 arg2,
1932 arg3,
1933 )
1934 })
1935 return _c
1936}
1937
1938func (_c *MockHomepageFavorites_UpdateTag_Call) Return(err error) *MockHomepageFavorites_UpdateTag_Call {
1939 _c.Call.Return(err)
1940 return _c
1941}
1942
1943func (_c *MockHomepageFavorites_UpdateTag_Call) RunAndReturn(run func(ctx context.Context, id entity.TagID, name string, color string) error) *MockHomepageFavorites_UpdateTag_Call {
1944 _c.Call.Return(run)
1945 return _c
1946}