1// Code generated by mockery; DO NOT EDIT.
2// github.com/vektra/mockery
3// template: testify
4
5package mocks
6
7import (
8 "context"
9
10 "github.com/bnema/dumber/internal/application/port"
11 "github.com/bnema/dumber/internal/domain/entity"
12 "github.com/rs/zerolog"
13 mock "github.com/stretchr/testify/mock"
14)
15
16// NewMockSessionLogger creates a new instance of MockSessionLogger. 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 NewMockSessionLogger(t interface {
19 mock.TestingT
20 Cleanup(func())
21}) *MockSessionLogger {
22 mock := &MockSessionLogger{}
23 mock.Mock.Test(t)
24
25 t.Cleanup(func() { mock.AssertExpectations(t) })
26
27 return mock
28}
29
30// MockSessionLogger is an autogenerated mock type for the SessionLogger type
31type MockSessionLogger struct {
32 mock.Mock
33}
34
35type MockSessionLogger_Expecter struct {
36 mock *mock.Mock
37}
38
39func (_m *MockSessionLogger) EXPECT() *MockSessionLogger_Expecter {
40 return &MockSessionLogger_Expecter{mock: &_m.Mock}
41}
42
43// CreateLogger provides a mock function for the type MockSessionLogger
44func (_mock *MockSessionLogger) CreateLogger(ctx context.Context, sessionID entity.SessionID, cfg port.SessionLogConfig) (zerolog.Logger, func(), error) {
45 ret := _mock.Called(ctx, sessionID, cfg)
46
47 if len(ret) == 0 {
48 panic("no return value specified for CreateLogger")
49 }
50
51 var r0 zerolog.Logger
52 var r1 func()
53 var r2 error
54 if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID, port.SessionLogConfig) (zerolog.Logger, func(), error)); ok {
55 return returnFunc(ctx, sessionID, cfg)
56 }
57 if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID, port.SessionLogConfig) zerolog.Logger); ok {
58 r0 = returnFunc(ctx, sessionID, cfg)
59 } else {
60 r0 = ret.Get(0).(zerolog.Logger)
61 }
62 if returnFunc, ok := ret.Get(1).(func(context.Context, entity.SessionID, port.SessionLogConfig) func()); ok {
63 r1 = returnFunc(ctx, sessionID, cfg)
64 } else {
65 if ret.Get(1) != nil {
66 r1 = ret.Get(1).(func())
67 }
68 }
69 if returnFunc, ok := ret.Get(2).(func(context.Context, entity.SessionID, port.SessionLogConfig) error); ok {
70 r2 = returnFunc(ctx, sessionID, cfg)
71 } else {
72 r2 = ret.Error(2)
73 }
74 return r0, r1, r2
75}
76
77// MockSessionLogger_CreateLogger_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateLogger'
78type MockSessionLogger_CreateLogger_Call struct {
79 *mock.Call
80}
81
82// CreateLogger is a helper method to define mock.On call
83// - ctx context.Context
84// - sessionID entity.SessionID
85// - cfg port.SessionLogConfig
86func (_e *MockSessionLogger_Expecter) CreateLogger(ctx interface{}, sessionID interface{}, cfg interface{}) *MockSessionLogger_CreateLogger_Call {
87 return &MockSessionLogger_CreateLogger_Call{Call: _e.mock.On("CreateLogger", ctx, sessionID, cfg)}
88}
89
90func (_c *MockSessionLogger_CreateLogger_Call) Run(run func(ctx context.Context, sessionID entity.SessionID, cfg port.SessionLogConfig)) *MockSessionLogger_CreateLogger_Call {
91 _c.Call.Run(func(args mock.Arguments) {
92 var arg0 context.Context
93 if args[0] != nil {
94 arg0 = args[0].(context.Context)
95 }
96 var arg1 entity.SessionID
97 if args[1] != nil {
98 arg1 = args[1].(entity.SessionID)
99 }
100 var arg2 port.SessionLogConfig
101 if args[2] != nil {
102 arg2 = args[2].(port.SessionLogConfig)
103 }
104 run(
105 arg0,
106 arg1,
107 arg2,
108 )
109 })
110 return _c
111}
112
113func (_c *MockSessionLogger_CreateLogger_Call) Return(logger zerolog.Logger, fn func(), err error) *MockSessionLogger_CreateLogger_Call {
114 _c.Call.Return(logger, fn, err)
115 return _c
116}
117
118func (_c *MockSessionLogger_CreateLogger_Call) RunAndReturn(run func(ctx context.Context, sessionID entity.SessionID, cfg port.SessionLogConfig) (zerolog.Logger, func(), error)) *MockSessionLogger_CreateLogger_Call {
119 _c.Call.Return(run)
120 return _c
121}
122
123// NewMockWebView creates a new instance of MockWebView. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
124// The first argument is typically a *testing.T value.
125func NewMockWebView(t interface {
126 mock.TestingT
127 Cleanup(func())
128}) *MockWebView {
129 mock := &MockWebView{}
130 mock.Mock.Test(t)
131
132 t.Cleanup(func() { mock.AssertExpectations(t) })
133
134 return mock
135}
136
137// MockWebView is an autogenerated mock type for the WebView type
138type MockWebView struct {
139 mock.Mock
140}
141
142type MockWebView_Expecter struct {
143 mock *mock.Mock
144}
145
146func (_m *MockWebView) EXPECT() *MockWebView_Expecter {
147 return &MockWebView_Expecter{mock: &_m.Mock}
148}
149
150// CanGoBack provides a mock function for the type MockWebView
151func (_mock *MockWebView) CanGoBack() bool {
152 ret := _mock.Called()
153
154 if len(ret) == 0 {
155 panic("no return value specified for CanGoBack")
156 }
157
158 var r0 bool
159 if returnFunc, ok := ret.Get(0).(func() bool); ok {
160 r0 = returnFunc()
161 } else {
162 r0 = ret.Get(0).(bool)
163 }
164 return r0
165}
166
167// MockWebView_CanGoBack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CanGoBack'
168type MockWebView_CanGoBack_Call struct {
169 *mock.Call
170}
171
172// CanGoBack is a helper method to define mock.On call
173func (_e *MockWebView_Expecter) CanGoBack() *MockWebView_CanGoBack_Call {
174 return &MockWebView_CanGoBack_Call{Call: _e.mock.On("CanGoBack")}
175}
176
177func (_c *MockWebView_CanGoBack_Call) Run(run func()) *MockWebView_CanGoBack_Call {
178 _c.Call.Run(func(args mock.Arguments) {
179 run()
180 })
181 return _c
182}
183
184func (_c *MockWebView_CanGoBack_Call) Return(b bool) *MockWebView_CanGoBack_Call {
185 _c.Call.Return(b)
186 return _c
187}
188
189func (_c *MockWebView_CanGoBack_Call) RunAndReturn(run func() bool) *MockWebView_CanGoBack_Call {
190 _c.Call.Return(run)
191 return _c
192}
193
194// CanGoForward provides a mock function for the type MockWebView
195func (_mock *MockWebView) CanGoForward() bool {
196 ret := _mock.Called()
197
198 if len(ret) == 0 {
199 panic("no return value specified for CanGoForward")
200 }
201
202 var r0 bool
203 if returnFunc, ok := ret.Get(0).(func() bool); ok {
204 r0 = returnFunc()
205 } else {
206 r0 = ret.Get(0).(bool)
207 }
208 return r0
209}
210
211// MockWebView_CanGoForward_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CanGoForward'
212type MockWebView_CanGoForward_Call struct {
213 *mock.Call
214}
215
216// CanGoForward is a helper method to define mock.On call
217func (_e *MockWebView_Expecter) CanGoForward() *MockWebView_CanGoForward_Call {
218 return &MockWebView_CanGoForward_Call{Call: _e.mock.On("CanGoForward")}
219}
220
221func (_c *MockWebView_CanGoForward_Call) Run(run func()) *MockWebView_CanGoForward_Call {
222 _c.Call.Run(func(args mock.Arguments) {
223 run()
224 })
225 return _c
226}
227
228func (_c *MockWebView_CanGoForward_Call) Return(b bool) *MockWebView_CanGoForward_Call {
229 _c.Call.Return(b)
230 return _c
231}
232
233func (_c *MockWebView_CanGoForward_Call) RunAndReturn(run func() bool) *MockWebView_CanGoForward_Call {
234 _c.Call.Return(run)
235 return _c
236}
237
238// Destroy provides a mock function for the type MockWebView
239func (_mock *MockWebView) Destroy() {
240 _mock.Called()
241 return
242}
243
244// MockWebView_Destroy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Destroy'
245type MockWebView_Destroy_Call struct {
246 *mock.Call
247}
248
249// Destroy is a helper method to define mock.On call
250func (_e *MockWebView_Expecter) Destroy() *MockWebView_Destroy_Call {
251 return &MockWebView_Destroy_Call{Call: _e.mock.On("Destroy")}
252}
253
254func (_c *MockWebView_Destroy_Call) Run(run func()) *MockWebView_Destroy_Call {
255 _c.Call.Run(func(args mock.Arguments) {
256 run()
257 })
258 return _c
259}
260
261func (_c *MockWebView_Destroy_Call) Return() *MockWebView_Destroy_Call {
262 _c.Call.Return()
263 return _c
264}
265
266func (_c *MockWebView_Destroy_Call) RunAndReturn(run func()) *MockWebView_Destroy_Call {
267 _c.Run(run)
268 return _c
269}
270
271// EstimatedProgress provides a mock function for the type MockWebView
272func (_mock *MockWebView) EstimatedProgress() float64 {
273 ret := _mock.Called()
274
275 if len(ret) == 0 {
276 panic("no return value specified for EstimatedProgress")
277 }
278
279 var r0 float64
280 if returnFunc, ok := ret.Get(0).(func() float64); ok {
281 r0 = returnFunc()
282 } else {
283 r0 = ret.Get(0).(float64)
284 }
285 return r0
286}
287
288// MockWebView_EstimatedProgress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EstimatedProgress'
289type MockWebView_EstimatedProgress_Call struct {
290 *mock.Call
291}
292
293// EstimatedProgress is a helper method to define mock.On call
294func (_e *MockWebView_Expecter) EstimatedProgress() *MockWebView_EstimatedProgress_Call {
295 return &MockWebView_EstimatedProgress_Call{Call: _e.mock.On("EstimatedProgress")}
296}
297
298func (_c *MockWebView_EstimatedProgress_Call) Run(run func()) *MockWebView_EstimatedProgress_Call {
299 _c.Call.Run(func(args mock.Arguments) {
300 run()
301 })
302 return _c
303}
304
305func (_c *MockWebView_EstimatedProgress_Call) Return(f float64) *MockWebView_EstimatedProgress_Call {
306 _c.Call.Return(f)
307 return _c
308}
309
310func (_c *MockWebView_EstimatedProgress_Call) RunAndReturn(run func() float64) *MockWebView_EstimatedProgress_Call {
311 _c.Call.Return(run)
312 return _c
313}
314
315// GetFindController provides a mock function for the type MockWebView
316func (_mock *MockWebView) GetFindController() port.FindController {
317 ret := _mock.Called()
318
319 if len(ret) == 0 {
320 panic("no return value specified for GetFindController")
321 }
322
323 var r0 port.FindController
324 if returnFunc, ok := ret.Get(0).(func() port.FindController); ok {
325 r0 = returnFunc()
326 } else {
327 if ret.Get(0) != nil {
328 r0 = ret.Get(0).(port.FindController)
329 }
330 }
331 return r0
332}
333
334// MockWebView_GetFindController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFindController'
335type MockWebView_GetFindController_Call struct {
336 *mock.Call
337}
338
339// GetFindController is a helper method to define mock.On call
340func (_e *MockWebView_Expecter) GetFindController() *MockWebView_GetFindController_Call {
341 return &MockWebView_GetFindController_Call{Call: _e.mock.On("GetFindController")}
342}
343
344func (_c *MockWebView_GetFindController_Call) Run(run func()) *MockWebView_GetFindController_Call {
345 _c.Call.Run(func(args mock.Arguments) {
346 run()
347 })
348 return _c
349}
350
351func (_c *MockWebView_GetFindController_Call) Return(findController port.FindController) *MockWebView_GetFindController_Call {
352 _c.Call.Return(findController)
353 return _c
354}
355
356func (_c *MockWebView_GetFindController_Call) RunAndReturn(run func() port.FindController) *MockWebView_GetFindController_Call {
357 _c.Call.Return(run)
358 return _c
359}
360
361// GetZoomLevel provides a mock function for the type MockWebView
362func (_mock *MockWebView) GetZoomLevel() float64 {
363 ret := _mock.Called()
364
365 if len(ret) == 0 {
366 panic("no return value specified for GetZoomLevel")
367 }
368
369 var r0 float64
370 if returnFunc, ok := ret.Get(0).(func() float64); ok {
371 r0 = returnFunc()
372 } else {
373 r0 = ret.Get(0).(float64)
374 }
375 return r0
376}
377
378// MockWebView_GetZoomLevel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetZoomLevel'
379type MockWebView_GetZoomLevel_Call struct {
380 *mock.Call
381}
382
383// GetZoomLevel is a helper method to define mock.On call
384func (_e *MockWebView_Expecter) GetZoomLevel() *MockWebView_GetZoomLevel_Call {
385 return &MockWebView_GetZoomLevel_Call{Call: _e.mock.On("GetZoomLevel")}
386}
387
388func (_c *MockWebView_GetZoomLevel_Call) Run(run func()) *MockWebView_GetZoomLevel_Call {
389 _c.Call.Run(func(args mock.Arguments) {
390 run()
391 })
392 return _c
393}
394
395func (_c *MockWebView_GetZoomLevel_Call) Return(f float64) *MockWebView_GetZoomLevel_Call {
396 _c.Call.Return(f)
397 return _c
398}
399
400func (_c *MockWebView_GetZoomLevel_Call) RunAndReturn(run func() float64) *MockWebView_GetZoomLevel_Call {
401 _c.Call.Return(run)
402 return _c
403}
404
405// GoBack provides a mock function for the type MockWebView
406func (_mock *MockWebView) GoBack(ctx context.Context) error {
407 ret := _mock.Called(ctx)
408
409 if len(ret) == 0 {
410 panic("no return value specified for GoBack")
411 }
412
413 var r0 error
414 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
415 r0 = returnFunc(ctx)
416 } else {
417 r0 = ret.Error(0)
418 }
419 return r0
420}
421
422// MockWebView_GoBack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GoBack'
423type MockWebView_GoBack_Call struct {
424 *mock.Call
425}
426
427// GoBack is a helper method to define mock.On call
428// - ctx context.Context
429func (_e *MockWebView_Expecter) GoBack(ctx interface{}) *MockWebView_GoBack_Call {
430 return &MockWebView_GoBack_Call{Call: _e.mock.On("GoBack", ctx)}
431}
432
433func (_c *MockWebView_GoBack_Call) Run(run func(ctx context.Context)) *MockWebView_GoBack_Call {
434 _c.Call.Run(func(args mock.Arguments) {
435 var arg0 context.Context
436 if args[0] != nil {
437 arg0 = args[0].(context.Context)
438 }
439 run(
440 arg0,
441 )
442 })
443 return _c
444}
445
446func (_c *MockWebView_GoBack_Call) Return(err error) *MockWebView_GoBack_Call {
447 _c.Call.Return(err)
448 return _c
449}
450
451func (_c *MockWebView_GoBack_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_GoBack_Call {
452 _c.Call.Return(run)
453 return _c
454}
455
456// GoForward provides a mock function for the type MockWebView
457func (_mock *MockWebView) GoForward(ctx context.Context) error {
458 ret := _mock.Called(ctx)
459
460 if len(ret) == 0 {
461 panic("no return value specified for GoForward")
462 }
463
464 var r0 error
465 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
466 r0 = returnFunc(ctx)
467 } else {
468 r0 = ret.Error(0)
469 }
470 return r0
471}
472
473// MockWebView_GoForward_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GoForward'
474type MockWebView_GoForward_Call struct {
475 *mock.Call
476}
477
478// GoForward is a helper method to define mock.On call
479// - ctx context.Context
480func (_e *MockWebView_Expecter) GoForward(ctx interface{}) *MockWebView_GoForward_Call {
481 return &MockWebView_GoForward_Call{Call: _e.mock.On("GoForward", ctx)}
482}
483
484func (_c *MockWebView_GoForward_Call) Run(run func(ctx context.Context)) *MockWebView_GoForward_Call {
485 _c.Call.Run(func(args mock.Arguments) {
486 var arg0 context.Context
487 if args[0] != nil {
488 arg0 = args[0].(context.Context)
489 }
490 run(
491 arg0,
492 )
493 })
494 return _c
495}
496
497func (_c *MockWebView_GoForward_Call) Return(err error) *MockWebView_GoForward_Call {
498 _c.Call.Return(err)
499 return _c
500}
501
502func (_c *MockWebView_GoForward_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_GoForward_Call {
503 _c.Call.Return(run)
504 return _c
505}
506
507// ID provides a mock function for the type MockWebView
508func (_mock *MockWebView) ID() port.WebViewID {
509 ret := _mock.Called()
510
511 if len(ret) == 0 {
512 panic("no return value specified for ID")
513 }
514
515 var r0 port.WebViewID
516 if returnFunc, ok := ret.Get(0).(func() port.WebViewID); ok {
517 r0 = returnFunc()
518 } else {
519 r0 = ret.Get(0).(port.WebViewID)
520 }
521 return r0
522}
523
524// MockWebView_ID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ID'
525type MockWebView_ID_Call struct {
526 *mock.Call
527}
528
529// ID is a helper method to define mock.On call
530func (_e *MockWebView_Expecter) ID() *MockWebView_ID_Call {
531 return &MockWebView_ID_Call{Call: _e.mock.On("ID")}
532}
533
534func (_c *MockWebView_ID_Call) Run(run func()) *MockWebView_ID_Call {
535 _c.Call.Run(func(args mock.Arguments) {
536 run()
537 })
538 return _c
539}
540
541func (_c *MockWebView_ID_Call) Return(webViewID port.WebViewID) *MockWebView_ID_Call {
542 _c.Call.Return(webViewID)
543 return _c
544}
545
546func (_c *MockWebView_ID_Call) RunAndReturn(run func() port.WebViewID) *MockWebView_ID_Call {
547 _c.Call.Return(run)
548 return _c
549}
550
551// IsDestroyed provides a mock function for the type MockWebView
552func (_mock *MockWebView) IsDestroyed() bool {
553 ret := _mock.Called()
554
555 if len(ret) == 0 {
556 panic("no return value specified for IsDestroyed")
557 }
558
559 var r0 bool
560 if returnFunc, ok := ret.Get(0).(func() bool); ok {
561 r0 = returnFunc()
562 } else {
563 r0 = ret.Get(0).(bool)
564 }
565 return r0
566}
567
568// MockWebView_IsDestroyed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsDestroyed'
569type MockWebView_IsDestroyed_Call struct {
570 *mock.Call
571}
572
573// IsDestroyed is a helper method to define mock.On call
574func (_e *MockWebView_Expecter) IsDestroyed() *MockWebView_IsDestroyed_Call {
575 return &MockWebView_IsDestroyed_Call{Call: _e.mock.On("IsDestroyed")}
576}
577
578func (_c *MockWebView_IsDestroyed_Call) Run(run func()) *MockWebView_IsDestroyed_Call {
579 _c.Call.Run(func(args mock.Arguments) {
580 run()
581 })
582 return _c
583}
584
585func (_c *MockWebView_IsDestroyed_Call) Return(b bool) *MockWebView_IsDestroyed_Call {
586 _c.Call.Return(b)
587 return _c
588}
589
590func (_c *MockWebView_IsDestroyed_Call) RunAndReturn(run func() bool) *MockWebView_IsDestroyed_Call {
591 _c.Call.Return(run)
592 return _c
593}
594
595// IsLoading provides a mock function for the type MockWebView
596func (_mock *MockWebView) IsLoading() bool {
597 ret := _mock.Called()
598
599 if len(ret) == 0 {
600 panic("no return value specified for IsLoading")
601 }
602
603 var r0 bool
604 if returnFunc, ok := ret.Get(0).(func() bool); ok {
605 r0 = returnFunc()
606 } else {
607 r0 = ret.Get(0).(bool)
608 }
609 return r0
610}
611
612// MockWebView_IsLoading_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsLoading'
613type MockWebView_IsLoading_Call struct {
614 *mock.Call
615}
616
617// IsLoading is a helper method to define mock.On call
618func (_e *MockWebView_Expecter) IsLoading() *MockWebView_IsLoading_Call {
619 return &MockWebView_IsLoading_Call{Call: _e.mock.On("IsLoading")}
620}
621
622func (_c *MockWebView_IsLoading_Call) Run(run func()) *MockWebView_IsLoading_Call {
623 _c.Call.Run(func(args mock.Arguments) {
624 run()
625 })
626 return _c
627}
628
629func (_c *MockWebView_IsLoading_Call) Return(b bool) *MockWebView_IsLoading_Call {
630 _c.Call.Return(b)
631 return _c
632}
633
634func (_c *MockWebView_IsLoading_Call) RunAndReturn(run func() bool) *MockWebView_IsLoading_Call {
635 _c.Call.Return(run)
636 return _c
637}
638
639// LoadHTML provides a mock function for the type MockWebView
640func (_mock *MockWebView) LoadHTML(ctx context.Context, content string, baseURI string) error {
641 ret := _mock.Called(ctx, content, baseURI)
642
643 if len(ret) == 0 {
644 panic("no return value specified for LoadHTML")
645 }
646
647 var r0 error
648 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
649 r0 = returnFunc(ctx, content, baseURI)
650 } else {
651 r0 = ret.Error(0)
652 }
653 return r0
654}
655
656// MockWebView_LoadHTML_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadHTML'
657type MockWebView_LoadHTML_Call struct {
658 *mock.Call
659}
660
661// LoadHTML is a helper method to define mock.On call
662// - ctx context.Context
663// - content string
664// - baseURI string
665func (_e *MockWebView_Expecter) LoadHTML(ctx interface{}, content interface{}, baseURI interface{}) *MockWebView_LoadHTML_Call {
666 return &MockWebView_LoadHTML_Call{Call: _e.mock.On("LoadHTML", ctx, content, baseURI)}
667}
668
669func (_c *MockWebView_LoadHTML_Call) Run(run func(ctx context.Context, content string, baseURI string)) *MockWebView_LoadHTML_Call {
670 _c.Call.Run(func(args mock.Arguments) {
671 var arg0 context.Context
672 if args[0] != nil {
673 arg0 = args[0].(context.Context)
674 }
675 var arg1 string
676 if args[1] != nil {
677 arg1 = args[1].(string)
678 }
679 var arg2 string
680 if args[2] != nil {
681 arg2 = args[2].(string)
682 }
683 run(
684 arg0,
685 arg1,
686 arg2,
687 )
688 })
689 return _c
690}
691
692func (_c *MockWebView_LoadHTML_Call) Return(err error) *MockWebView_LoadHTML_Call {
693 _c.Call.Return(err)
694 return _c
695}
696
697func (_c *MockWebView_LoadHTML_Call) RunAndReturn(run func(ctx context.Context, content string, baseURI string) error) *MockWebView_LoadHTML_Call {
698 _c.Call.Return(run)
699 return _c
700}
701
702// LoadURI provides a mock function for the type MockWebView
703func (_mock *MockWebView) LoadURI(ctx context.Context, uri string) error {
704 ret := _mock.Called(ctx, uri)
705
706 if len(ret) == 0 {
707 panic("no return value specified for LoadURI")
708 }
709
710 var r0 error
711 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
712 r0 = returnFunc(ctx, uri)
713 } else {
714 r0 = ret.Error(0)
715 }
716 return r0
717}
718
719// MockWebView_LoadURI_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadURI'
720type MockWebView_LoadURI_Call struct {
721 *mock.Call
722}
723
724// LoadURI is a helper method to define mock.On call
725// - ctx context.Context
726// - uri string
727func (_e *MockWebView_Expecter) LoadURI(ctx interface{}, uri interface{}) *MockWebView_LoadURI_Call {
728 return &MockWebView_LoadURI_Call{Call: _e.mock.On("LoadURI", ctx, uri)}
729}
730
731func (_c *MockWebView_LoadURI_Call) Run(run func(ctx context.Context, uri string)) *MockWebView_LoadURI_Call {
732 _c.Call.Run(func(args mock.Arguments) {
733 var arg0 context.Context
734 if args[0] != nil {
735 arg0 = args[0].(context.Context)
736 }
737 var arg1 string
738 if args[1] != nil {
739 arg1 = args[1].(string)
740 }
741 run(
742 arg0,
743 arg1,
744 )
745 })
746 return _c
747}
748
749func (_c *MockWebView_LoadURI_Call) Return(err error) *MockWebView_LoadURI_Call {
750 _c.Call.Return(err)
751 return _c
752}
753
754func (_c *MockWebView_LoadURI_Call) RunAndReturn(run func(ctx context.Context, uri string) error) *MockWebView_LoadURI_Call {
755 _c.Call.Return(run)
756 return _c
757}
758
759// Reload provides a mock function for the type MockWebView
760func (_mock *MockWebView) Reload(ctx context.Context) error {
761 ret := _mock.Called(ctx)
762
763 if len(ret) == 0 {
764 panic("no return value specified for Reload")
765 }
766
767 var r0 error
768 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
769 r0 = returnFunc(ctx)
770 } else {
771 r0 = ret.Error(0)
772 }
773 return r0
774}
775
776// MockWebView_Reload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reload'
777type MockWebView_Reload_Call struct {
778 *mock.Call
779}
780
781// Reload is a helper method to define mock.On call
782// - ctx context.Context
783func (_e *MockWebView_Expecter) Reload(ctx interface{}) *MockWebView_Reload_Call {
784 return &MockWebView_Reload_Call{Call: _e.mock.On("Reload", ctx)}
785}
786
787func (_c *MockWebView_Reload_Call) Run(run func(ctx context.Context)) *MockWebView_Reload_Call {
788 _c.Call.Run(func(args mock.Arguments) {
789 var arg0 context.Context
790 if args[0] != nil {
791 arg0 = args[0].(context.Context)
792 }
793 run(
794 arg0,
795 )
796 })
797 return _c
798}
799
800func (_c *MockWebView_Reload_Call) Return(err error) *MockWebView_Reload_Call {
801 _c.Call.Return(err)
802 return _c
803}
804
805func (_c *MockWebView_Reload_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_Reload_Call {
806 _c.Call.Return(run)
807 return _c
808}
809
810// ReloadBypassCache provides a mock function for the type MockWebView
811func (_mock *MockWebView) ReloadBypassCache(ctx context.Context) error {
812 ret := _mock.Called(ctx)
813
814 if len(ret) == 0 {
815 panic("no return value specified for ReloadBypassCache")
816 }
817
818 var r0 error
819 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
820 r0 = returnFunc(ctx)
821 } else {
822 r0 = ret.Error(0)
823 }
824 return r0
825}
826
827// MockWebView_ReloadBypassCache_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReloadBypassCache'
828type MockWebView_ReloadBypassCache_Call struct {
829 *mock.Call
830}
831
832// ReloadBypassCache is a helper method to define mock.On call
833// - ctx context.Context
834func (_e *MockWebView_Expecter) ReloadBypassCache(ctx interface{}) *MockWebView_ReloadBypassCache_Call {
835 return &MockWebView_ReloadBypassCache_Call{Call: _e.mock.On("ReloadBypassCache", ctx)}
836}
837
838func (_c *MockWebView_ReloadBypassCache_Call) Run(run func(ctx context.Context)) *MockWebView_ReloadBypassCache_Call {
839 _c.Call.Run(func(args mock.Arguments) {
840 var arg0 context.Context
841 if args[0] != nil {
842 arg0 = args[0].(context.Context)
843 }
844 run(
845 arg0,
846 )
847 })
848 return _c
849}
850
851func (_c *MockWebView_ReloadBypassCache_Call) Return(err error) *MockWebView_ReloadBypassCache_Call {
852 _c.Call.Return(err)
853 return _c
854}
855
856func (_c *MockWebView_ReloadBypassCache_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_ReloadBypassCache_Call {
857 _c.Call.Return(run)
858 return _c
859}
860
861// SetCallbacks provides a mock function for the type MockWebView
862func (_mock *MockWebView) SetCallbacks(callbacks *port.WebViewCallbacks) {
863 _mock.Called(callbacks)
864 return
865}
866
867// MockWebView_SetCallbacks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCallbacks'
868type MockWebView_SetCallbacks_Call struct {
869 *mock.Call
870}
871
872// SetCallbacks is a helper method to define mock.On call
873// - callbacks *port.WebViewCallbacks
874func (_e *MockWebView_Expecter) SetCallbacks(callbacks interface{}) *MockWebView_SetCallbacks_Call {
875 return &MockWebView_SetCallbacks_Call{Call: _e.mock.On("SetCallbacks", callbacks)}
876}
877
878func (_c *MockWebView_SetCallbacks_Call) Run(run func(callbacks *port.WebViewCallbacks)) *MockWebView_SetCallbacks_Call {
879 _c.Call.Run(func(args mock.Arguments) {
880 var arg0 *port.WebViewCallbacks
881 if args[0] != nil {
882 arg0 = args[0].(*port.WebViewCallbacks)
883 }
884 run(
885 arg0,
886 )
887 })
888 return _c
889}
890
891func (_c *MockWebView_SetCallbacks_Call) Return() *MockWebView_SetCallbacks_Call {
892 _c.Call.Return()
893 return _c
894}
895
896func (_c *MockWebView_SetCallbacks_Call) RunAndReturn(run func(callbacks *port.WebViewCallbacks)) *MockWebView_SetCallbacks_Call {
897 _c.Run(run)
898 return _c
899}
900
901// SetZoomLevel provides a mock function for the type MockWebView
902func (_mock *MockWebView) SetZoomLevel(ctx context.Context, level float64) error {
903 ret := _mock.Called(ctx, level)
904
905 if len(ret) == 0 {
906 panic("no return value specified for SetZoomLevel")
907 }
908
909 var r0 error
910 if returnFunc, ok := ret.Get(0).(func(context.Context, float64) error); ok {
911 r0 = returnFunc(ctx, level)
912 } else {
913 r0 = ret.Error(0)
914 }
915 return r0
916}
917
918// MockWebView_SetZoomLevel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetZoomLevel'
919type MockWebView_SetZoomLevel_Call struct {
920 *mock.Call
921}
922
923// SetZoomLevel is a helper method to define mock.On call
924// - ctx context.Context
925// - level float64
926func (_e *MockWebView_Expecter) SetZoomLevel(ctx interface{}, level interface{}) *MockWebView_SetZoomLevel_Call {
927 return &MockWebView_SetZoomLevel_Call{Call: _e.mock.On("SetZoomLevel", ctx, level)}
928}
929
930func (_c *MockWebView_SetZoomLevel_Call) Run(run func(ctx context.Context, level float64)) *MockWebView_SetZoomLevel_Call {
931 _c.Call.Run(func(args mock.Arguments) {
932 var arg0 context.Context
933 if args[0] != nil {
934 arg0 = args[0].(context.Context)
935 }
936 var arg1 float64
937 if args[1] != nil {
938 arg1 = args[1].(float64)
939 }
940 run(
941 arg0,
942 arg1,
943 )
944 })
945 return _c
946}
947
948func (_c *MockWebView_SetZoomLevel_Call) Return(err error) *MockWebView_SetZoomLevel_Call {
949 _c.Call.Return(err)
950 return _c
951}
952
953func (_c *MockWebView_SetZoomLevel_Call) RunAndReturn(run func(ctx context.Context, level float64) error) *MockWebView_SetZoomLevel_Call {
954 _c.Call.Return(run)
955 return _c
956}
957
958// State provides a mock function for the type MockWebView
959func (_mock *MockWebView) State() port.WebViewState {
960 ret := _mock.Called()
961
962 if len(ret) == 0 {
963 panic("no return value specified for State")
964 }
965
966 var r0 port.WebViewState
967 if returnFunc, ok := ret.Get(0).(func() port.WebViewState); ok {
968 r0 = returnFunc()
969 } else {
970 r0 = ret.Get(0).(port.WebViewState)
971 }
972 return r0
973}
974
975// MockWebView_State_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'State'
976type MockWebView_State_Call struct {
977 *mock.Call
978}
979
980// State is a helper method to define mock.On call
981func (_e *MockWebView_Expecter) State() *MockWebView_State_Call {
982 return &MockWebView_State_Call{Call: _e.mock.On("State")}
983}
984
985func (_c *MockWebView_State_Call) Run(run func()) *MockWebView_State_Call {
986 _c.Call.Run(func(args mock.Arguments) {
987 run()
988 })
989 return _c
990}
991
992func (_c *MockWebView_State_Call) Return(webViewState port.WebViewState) *MockWebView_State_Call {
993 _c.Call.Return(webViewState)
994 return _c
995}
996
997func (_c *MockWebView_State_Call) RunAndReturn(run func() port.WebViewState) *MockWebView_State_Call {
998 _c.Call.Return(run)
999 return _c
1000}
1001
1002// Stop provides a mock function for the type MockWebView
1003func (_mock *MockWebView) Stop(ctx context.Context) error {
1004 ret := _mock.Called(ctx)
1005
1006 if len(ret) == 0 {
1007 panic("no return value specified for Stop")
1008 }
1009
1010 var r0 error
1011 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
1012 r0 = returnFunc(ctx)
1013 } else {
1014 r0 = ret.Error(0)
1015 }
1016 return r0
1017}
1018
1019// MockWebView_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
1020type MockWebView_Stop_Call struct {
1021 *mock.Call
1022}
1023
1024// Stop is a helper method to define mock.On call
1025// - ctx context.Context
1026func (_e *MockWebView_Expecter) Stop(ctx interface{}) *MockWebView_Stop_Call {
1027 return &MockWebView_Stop_Call{Call: _e.mock.On("Stop", ctx)}
1028}
1029
1030func (_c *MockWebView_Stop_Call) Run(run func(ctx context.Context)) *MockWebView_Stop_Call {
1031 _c.Call.Run(func(args mock.Arguments) {
1032 var arg0 context.Context
1033 if args[0] != nil {
1034 arg0 = args[0].(context.Context)
1035 }
1036 run(
1037 arg0,
1038 )
1039 })
1040 return _c
1041}
1042
1043func (_c *MockWebView_Stop_Call) Return(err error) *MockWebView_Stop_Call {
1044 _c.Call.Return(err)
1045 return _c
1046}
1047
1048func (_c *MockWebView_Stop_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_Stop_Call {
1049 _c.Call.Return(run)
1050 return _c
1051}
1052
1053// Title provides a mock function for the type MockWebView
1054func (_mock *MockWebView) Title() string {
1055 ret := _mock.Called()
1056
1057 if len(ret) == 0 {
1058 panic("no return value specified for Title")
1059 }
1060
1061 var r0 string
1062 if returnFunc, ok := ret.Get(0).(func() string); ok {
1063 r0 = returnFunc()
1064 } else {
1065 r0 = ret.Get(0).(string)
1066 }
1067 return r0
1068}
1069
1070// MockWebView_Title_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Title'
1071type MockWebView_Title_Call struct {
1072 *mock.Call
1073}
1074
1075// Title is a helper method to define mock.On call
1076func (_e *MockWebView_Expecter) Title() *MockWebView_Title_Call {
1077 return &MockWebView_Title_Call{Call: _e.mock.On("Title")}
1078}
1079
1080func (_c *MockWebView_Title_Call) Run(run func()) *MockWebView_Title_Call {
1081 _c.Call.Run(func(args mock.Arguments) {
1082 run()
1083 })
1084 return _c
1085}
1086
1087func (_c *MockWebView_Title_Call) Return(s string) *MockWebView_Title_Call {
1088 _c.Call.Return(s)
1089 return _c
1090}
1091
1092func (_c *MockWebView_Title_Call) RunAndReturn(run func() string) *MockWebView_Title_Call {
1093 _c.Call.Return(run)
1094 return _c
1095}
1096
1097// URI provides a mock function for the type MockWebView
1098func (_mock *MockWebView) URI() string {
1099 ret := _mock.Called()
1100
1101 if len(ret) == 0 {
1102 panic("no return value specified for URI")
1103 }
1104
1105 var r0 string
1106 if returnFunc, ok := ret.Get(0).(func() string); ok {
1107 r0 = returnFunc()
1108 } else {
1109 r0 = ret.Get(0).(string)
1110 }
1111 return r0
1112}
1113
1114// MockWebView_URI_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'URI'
1115type MockWebView_URI_Call struct {
1116 *mock.Call
1117}
1118
1119// URI is a helper method to define mock.On call
1120func (_e *MockWebView_Expecter) URI() *MockWebView_URI_Call {
1121 return &MockWebView_URI_Call{Call: _e.mock.On("URI")}
1122}
1123
1124func (_c *MockWebView_URI_Call) Run(run func()) *MockWebView_URI_Call {
1125 _c.Call.Run(func(args mock.Arguments) {
1126 run()
1127 })
1128 return _c
1129}
1130
1131func (_c *MockWebView_URI_Call) Return(s string) *MockWebView_URI_Call {
1132 _c.Call.Return(s)
1133 return _c
1134}
1135
1136func (_c *MockWebView_URI_Call) RunAndReturn(run func() string) *MockWebView_URI_Call {
1137 _c.Call.Return(run)
1138 return _c
1139}
1140
1141// NewMockWebViewPool creates a new instance of MockWebViewPool. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
1142// The first argument is typically a *testing.T value.
1143func NewMockWebViewPool(t interface {
1144 mock.TestingT
1145 Cleanup(func())
1146}) *MockWebViewPool {
1147 mock := &MockWebViewPool{}
1148 mock.Mock.Test(t)
1149
1150 t.Cleanup(func() { mock.AssertExpectations(t) })
1151
1152 return mock
1153}
1154
1155// MockWebViewPool is an autogenerated mock type for the WebViewPool type
1156type MockWebViewPool struct {
1157 mock.Mock
1158}
1159
1160type MockWebViewPool_Expecter struct {
1161 mock *mock.Mock
1162}
1163
1164func (_m *MockWebViewPool) EXPECT() *MockWebViewPool_Expecter {
1165 return &MockWebViewPool_Expecter{mock: &_m.Mock}
1166}
1167
1168// Acquire provides a mock function for the type MockWebViewPool
1169func (_mock *MockWebViewPool) Acquire(ctx context.Context) (port.WebView, error) {
1170 ret := _mock.Called(ctx)
1171
1172 if len(ret) == 0 {
1173 panic("no return value specified for Acquire")
1174 }
1175
1176 var r0 port.WebView
1177 var r1 error
1178 if returnFunc, ok := ret.Get(0).(func(context.Context) (port.WebView, error)); ok {
1179 return returnFunc(ctx)
1180 }
1181 if returnFunc, ok := ret.Get(0).(func(context.Context) port.WebView); ok {
1182 r0 = returnFunc(ctx)
1183 } else {
1184 if ret.Get(0) != nil {
1185 r0 = ret.Get(0).(port.WebView)
1186 }
1187 }
1188 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1189 r1 = returnFunc(ctx)
1190 } else {
1191 r1 = ret.Error(1)
1192 }
1193 return r0, r1
1194}
1195
1196// MockWebViewPool_Acquire_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Acquire'
1197type MockWebViewPool_Acquire_Call struct {
1198 *mock.Call
1199}
1200
1201// Acquire is a helper method to define mock.On call
1202// - ctx context.Context
1203func (_e *MockWebViewPool_Expecter) Acquire(ctx interface{}) *MockWebViewPool_Acquire_Call {
1204 return &MockWebViewPool_Acquire_Call{Call: _e.mock.On("Acquire", ctx)}
1205}
1206
1207func (_c *MockWebViewPool_Acquire_Call) Run(run func(ctx context.Context)) *MockWebViewPool_Acquire_Call {
1208 _c.Call.Run(func(args mock.Arguments) {
1209 var arg0 context.Context
1210 if args[0] != nil {
1211 arg0 = args[0].(context.Context)
1212 }
1213 run(
1214 arg0,
1215 )
1216 })
1217 return _c
1218}
1219
1220func (_c *MockWebViewPool_Acquire_Call) Return(webView port.WebView, err error) *MockWebViewPool_Acquire_Call {
1221 _c.Call.Return(webView, err)
1222 return _c
1223}
1224
1225func (_c *MockWebViewPool_Acquire_Call) RunAndReturn(run func(ctx context.Context) (port.WebView, error)) *MockWebViewPool_Acquire_Call {
1226 _c.Call.Return(run)
1227 return _c
1228}
1229
1230// Close provides a mock function for the type MockWebViewPool
1231func (_mock *MockWebViewPool) Close() {
1232 _mock.Called()
1233 return
1234}
1235
1236// MockWebViewPool_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
1237type MockWebViewPool_Close_Call struct {
1238 *mock.Call
1239}
1240
1241// Close is a helper method to define mock.On call
1242func (_e *MockWebViewPool_Expecter) Close() *MockWebViewPool_Close_Call {
1243 return &MockWebViewPool_Close_Call{Call: _e.mock.On("Close")}
1244}
1245
1246func (_c *MockWebViewPool_Close_Call) Run(run func()) *MockWebViewPool_Close_Call {
1247 _c.Call.Run(func(args mock.Arguments) {
1248 run()
1249 })
1250 return _c
1251}
1252
1253func (_c *MockWebViewPool_Close_Call) Return() *MockWebViewPool_Close_Call {
1254 _c.Call.Return()
1255 return _c
1256}
1257
1258func (_c *MockWebViewPool_Close_Call) RunAndReturn(run func()) *MockWebViewPool_Close_Call {
1259 _c.Run(run)
1260 return _c
1261}
1262
1263// Prewarm provides a mock function for the type MockWebViewPool
1264func (_mock *MockWebViewPool) Prewarm(count int) {
1265 _mock.Called(count)
1266 return
1267}
1268
1269// MockWebViewPool_Prewarm_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Prewarm'
1270type MockWebViewPool_Prewarm_Call struct {
1271 *mock.Call
1272}
1273
1274// Prewarm is a helper method to define mock.On call
1275// - count int
1276func (_e *MockWebViewPool_Expecter) Prewarm(count interface{}) *MockWebViewPool_Prewarm_Call {
1277 return &MockWebViewPool_Prewarm_Call{Call: _e.mock.On("Prewarm", count)}
1278}
1279
1280func (_c *MockWebViewPool_Prewarm_Call) Run(run func(count int)) *MockWebViewPool_Prewarm_Call {
1281 _c.Call.Run(func(args mock.Arguments) {
1282 var arg0 int
1283 if args[0] != nil {
1284 arg0 = args[0].(int)
1285 }
1286 run(
1287 arg0,
1288 )
1289 })
1290 return _c
1291}
1292
1293func (_c *MockWebViewPool_Prewarm_Call) Return() *MockWebViewPool_Prewarm_Call {
1294 _c.Call.Return()
1295 return _c
1296}
1297
1298func (_c *MockWebViewPool_Prewarm_Call) RunAndReturn(run func(count int)) *MockWebViewPool_Prewarm_Call {
1299 _c.Run(run)
1300 return _c
1301}
1302
1303// Release provides a mock function for the type MockWebViewPool
1304func (_mock *MockWebViewPool) Release(wv port.WebView) {
1305 _mock.Called(wv)
1306 return
1307}
1308
1309// MockWebViewPool_Release_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Release'
1310type MockWebViewPool_Release_Call struct {
1311 *mock.Call
1312}
1313
1314// Release is a helper method to define mock.On call
1315// - wv port.WebView
1316func (_e *MockWebViewPool_Expecter) Release(wv interface{}) *MockWebViewPool_Release_Call {
1317 return &MockWebViewPool_Release_Call{Call: _e.mock.On("Release", wv)}
1318}
1319
1320func (_c *MockWebViewPool_Release_Call) Run(run func(wv port.WebView)) *MockWebViewPool_Release_Call {
1321 _c.Call.Run(func(args mock.Arguments) {
1322 var arg0 port.WebView
1323 if args[0] != nil {
1324 arg0 = args[0].(port.WebView)
1325 }
1326 run(
1327 arg0,
1328 )
1329 })
1330 return _c
1331}
1332
1333func (_c *MockWebViewPool_Release_Call) Return() *MockWebViewPool_Release_Call {
1334 _c.Call.Return()
1335 return _c
1336}
1337
1338func (_c *MockWebViewPool_Release_Call) RunAndReturn(run func(wv port.WebView)) *MockWebViewPool_Release_Call {
1339 _c.Run(run)
1340 return _c
1341}
1342
1343// Size provides a mock function for the type MockWebViewPool
1344func (_mock *MockWebViewPool) Size() int {
1345 ret := _mock.Called()
1346
1347 if len(ret) == 0 {
1348 panic("no return value specified for Size")
1349 }
1350
1351 var r0 int
1352 if returnFunc, ok := ret.Get(0).(func() int); ok {
1353 r0 = returnFunc()
1354 } else {
1355 r0 = ret.Get(0).(int)
1356 }
1357 return r0
1358}
1359
1360// MockWebViewPool_Size_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Size'
1361type MockWebViewPool_Size_Call struct {
1362 *mock.Call
1363}
1364
1365// Size is a helper method to define mock.On call
1366func (_e *MockWebViewPool_Expecter) Size() *MockWebViewPool_Size_Call {
1367 return &MockWebViewPool_Size_Call{Call: _e.mock.On("Size")}
1368}
1369
1370func (_c *MockWebViewPool_Size_Call) Run(run func()) *MockWebViewPool_Size_Call {
1371 _c.Call.Run(func(args mock.Arguments) {
1372 run()
1373 })
1374 return _c
1375}
1376
1377func (_c *MockWebViewPool_Size_Call) Return(n int) *MockWebViewPool_Size_Call {
1378 _c.Call.Return(n)
1379 return _c
1380}
1381
1382func (_c *MockWebViewPool_Size_Call) RunAndReturn(run func() int) *MockWebViewPool_Size_Call {
1383 _c.Call.Return(run)
1384 return _c
1385}
1386
1387// NewMockWebViewFactory creates a new instance of MockWebViewFactory. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
1388// The first argument is typically a *testing.T value.
1389func NewMockWebViewFactory(t interface {
1390 mock.TestingT
1391 Cleanup(func())
1392}) *MockWebViewFactory {
1393 mock := &MockWebViewFactory{}
1394 mock.Mock.Test(t)
1395
1396 t.Cleanup(func() { mock.AssertExpectations(t) })
1397
1398 return mock
1399}
1400
1401// MockWebViewFactory is an autogenerated mock type for the WebViewFactory type
1402type MockWebViewFactory struct {
1403 mock.Mock
1404}
1405
1406type MockWebViewFactory_Expecter struct {
1407 mock *mock.Mock
1408}
1409
1410func (_m *MockWebViewFactory) EXPECT() *MockWebViewFactory_Expecter {
1411 return &MockWebViewFactory_Expecter{mock: &_m.Mock}
1412}
1413
1414// Create provides a mock function for the type MockWebViewFactory
1415func (_mock *MockWebViewFactory) Create(ctx context.Context) (port.WebView, error) {
1416 ret := _mock.Called(ctx)
1417
1418 if len(ret) == 0 {
1419 panic("no return value specified for Create")
1420 }
1421
1422 var r0 port.WebView
1423 var r1 error
1424 if returnFunc, ok := ret.Get(0).(func(context.Context) (port.WebView, error)); ok {
1425 return returnFunc(ctx)
1426 }
1427 if returnFunc, ok := ret.Get(0).(func(context.Context) port.WebView); ok {
1428 r0 = returnFunc(ctx)
1429 } else {
1430 if ret.Get(0) != nil {
1431 r0 = ret.Get(0).(port.WebView)
1432 }
1433 }
1434 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1435 r1 = returnFunc(ctx)
1436 } else {
1437 r1 = ret.Error(1)
1438 }
1439 return r0, r1
1440}
1441
1442// MockWebViewFactory_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'
1443type MockWebViewFactory_Create_Call struct {
1444 *mock.Call
1445}
1446
1447// Create is a helper method to define mock.On call
1448// - ctx context.Context
1449func (_e *MockWebViewFactory_Expecter) Create(ctx interface{}) *MockWebViewFactory_Create_Call {
1450 return &MockWebViewFactory_Create_Call{Call: _e.mock.On("Create", ctx)}
1451}
1452
1453func (_c *MockWebViewFactory_Create_Call) Run(run func(ctx context.Context)) *MockWebViewFactory_Create_Call {
1454 _c.Call.Run(func(args mock.Arguments) {
1455 var arg0 context.Context
1456 if args[0] != nil {
1457 arg0 = args[0].(context.Context)
1458 }
1459 run(
1460 arg0,
1461 )
1462 })
1463 return _c
1464}
1465
1466func (_c *MockWebViewFactory_Create_Call) Return(webView port.WebView, err error) *MockWebViewFactory_Create_Call {
1467 _c.Call.Return(webView, err)
1468 return _c
1469}
1470
1471func (_c *MockWebViewFactory_Create_Call) RunAndReturn(run func(ctx context.Context) (port.WebView, error)) *MockWebViewFactory_Create_Call {
1472 _c.Call.Return(run)
1473 return _c
1474}
1475
1476// CreateRelated provides a mock function for the type MockWebViewFactory
1477func (_mock *MockWebViewFactory) CreateRelated(ctx context.Context, parentID port.WebViewID) (port.WebView, error) {
1478 ret := _mock.Called(ctx, parentID)
1479
1480 if len(ret) == 0 {
1481 panic("no return value specified for CreateRelated")
1482 }
1483
1484 var r0 port.WebView
1485 var r1 error
1486 if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebViewID) (port.WebView, error)); ok {
1487 return returnFunc(ctx, parentID)
1488 }
1489 if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebViewID) port.WebView); ok {
1490 r0 = returnFunc(ctx, parentID)
1491 } else {
1492 if ret.Get(0) != nil {
1493 r0 = ret.Get(0).(port.WebView)
1494 }
1495 }
1496 if returnFunc, ok := ret.Get(1).(func(context.Context, port.WebViewID) error); ok {
1497 r1 = returnFunc(ctx, parentID)
1498 } else {
1499 r1 = ret.Error(1)
1500 }
1501 return r0, r1
1502}
1503
1504// MockWebViewFactory_CreateRelated_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRelated'
1505type MockWebViewFactory_CreateRelated_Call struct {
1506 *mock.Call
1507}
1508
1509// CreateRelated is a helper method to define mock.On call
1510// - ctx context.Context
1511// - parentID port.WebViewID
1512func (_e *MockWebViewFactory_Expecter) CreateRelated(ctx interface{}, parentID interface{}) *MockWebViewFactory_CreateRelated_Call {
1513 return &MockWebViewFactory_CreateRelated_Call{Call: _e.mock.On("CreateRelated", ctx, parentID)}
1514}
1515
1516func (_c *MockWebViewFactory_CreateRelated_Call) Run(run func(ctx context.Context, parentID port.WebViewID)) *MockWebViewFactory_CreateRelated_Call {
1517 _c.Call.Run(func(args mock.Arguments) {
1518 var arg0 context.Context
1519 if args[0] != nil {
1520 arg0 = args[0].(context.Context)
1521 }
1522 var arg1 port.WebViewID
1523 if args[1] != nil {
1524 arg1 = args[1].(port.WebViewID)
1525 }
1526 run(
1527 arg0,
1528 arg1,
1529 )
1530 })
1531 return _c
1532}
1533
1534func (_c *MockWebViewFactory_CreateRelated_Call) Return(webView port.WebView, err error) *MockWebViewFactory_CreateRelated_Call {
1535 _c.Call.Return(webView, err)
1536 return _c
1537}
1538
1539func (_c *MockWebViewFactory_CreateRelated_Call) RunAndReturn(run func(ctx context.Context, parentID port.WebViewID) (port.WebView, error)) *MockWebViewFactory_CreateRelated_Call {
1540 _c.Call.Return(run)
1541 return _c
1542}