1// Code generated by mockery; DO NOT EDIT.
2// github.com/vektra/mockery
3// template: testify
4
5package mocks
6
7import (
8 "context"
9 "database/sql"
10
11 "github.com/bnema/dumber/internal/application/port"
12 "github.com/bnema/dumber/internal/domain/entity"
13 "github.com/rs/zerolog"
14 mock "github.com/stretchr/testify/mock"
15)
16
17// NewMockConfigMigrator creates a new instance of MockConfigMigrator. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
18// The first argument is typically a *testing.T value.
19func NewMockConfigMigrator(t interface {
20 mock.TestingT
21 Cleanup(func())
22}) *MockConfigMigrator {
23 mock := &MockConfigMigrator{}
24 mock.Mock.Test(t)
25
26 t.Cleanup(func() { mock.AssertExpectations(t) })
27
28 return mock
29}
30
31// MockConfigMigrator is an autogenerated mock type for the ConfigMigrator type
32type MockConfigMigrator struct {
33 mock.Mock
34}
35
36type MockConfigMigrator_Expecter struct {
37 mock *mock.Mock
38}
39
40func (_m *MockConfigMigrator) EXPECT() *MockConfigMigrator_Expecter {
41 return &MockConfigMigrator_Expecter{mock: &_m.Mock}
42}
43
44// CheckMigration provides a mock function for the type MockConfigMigrator
45func (_mock *MockConfigMigrator) CheckMigration() (*port.MigrationResult, error) {
46 ret := _mock.Called()
47
48 if len(ret) == 0 {
49 panic("no return value specified for CheckMigration")
50 }
51
52 var r0 *port.MigrationResult
53 var r1 error
54 if returnFunc, ok := ret.Get(0).(func() (*port.MigrationResult, error)); ok {
55 return returnFunc()
56 }
57 if returnFunc, ok := ret.Get(0).(func() *port.MigrationResult); ok {
58 r0 = returnFunc()
59 } else {
60 if ret.Get(0) != nil {
61 r0 = ret.Get(0).(*port.MigrationResult)
62 }
63 }
64 if returnFunc, ok := ret.Get(1).(func() error); ok {
65 r1 = returnFunc()
66 } else {
67 r1 = ret.Error(1)
68 }
69 return r0, r1
70}
71
72// MockConfigMigrator_CheckMigration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckMigration'
73type MockConfigMigrator_CheckMigration_Call struct {
74 *mock.Call
75}
76
77// CheckMigration is a helper method to define mock.On call
78func (_e *MockConfigMigrator_Expecter) CheckMigration() *MockConfigMigrator_CheckMigration_Call {
79 return &MockConfigMigrator_CheckMigration_Call{Call: _e.mock.On("CheckMigration")}
80}
81
82func (_c *MockConfigMigrator_CheckMigration_Call) Run(run func()) *MockConfigMigrator_CheckMigration_Call {
83 _c.Call.Run(func(args mock.Arguments) {
84 run()
85 })
86 return _c
87}
88
89func (_c *MockConfigMigrator_CheckMigration_Call) Return(migrationResult *port.MigrationResult, err error) *MockConfigMigrator_CheckMigration_Call {
90 _c.Call.Return(migrationResult, err)
91 return _c
92}
93
94func (_c *MockConfigMigrator_CheckMigration_Call) RunAndReturn(run func() (*port.MigrationResult, error)) *MockConfigMigrator_CheckMigration_Call {
95 _c.Call.Return(run)
96 return _c
97}
98
99// DetectChanges provides a mock function for the type MockConfigMigrator
100func (_mock *MockConfigMigrator) DetectChanges() ([]port.KeyChange, error) {
101 ret := _mock.Called()
102
103 if len(ret) == 0 {
104 panic("no return value specified for DetectChanges")
105 }
106
107 var r0 []port.KeyChange
108 var r1 error
109 if returnFunc, ok := ret.Get(0).(func() ([]port.KeyChange, error)); ok {
110 return returnFunc()
111 }
112 if returnFunc, ok := ret.Get(0).(func() []port.KeyChange); ok {
113 r0 = returnFunc()
114 } else {
115 if ret.Get(0) != nil {
116 r0 = ret.Get(0).([]port.KeyChange)
117 }
118 }
119 if returnFunc, ok := ret.Get(1).(func() error); ok {
120 r1 = returnFunc()
121 } else {
122 r1 = ret.Error(1)
123 }
124 return r0, r1
125}
126
127// MockConfigMigrator_DetectChanges_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DetectChanges'
128type MockConfigMigrator_DetectChanges_Call struct {
129 *mock.Call
130}
131
132// DetectChanges is a helper method to define mock.On call
133func (_e *MockConfigMigrator_Expecter) DetectChanges() *MockConfigMigrator_DetectChanges_Call {
134 return &MockConfigMigrator_DetectChanges_Call{Call: _e.mock.On("DetectChanges")}
135}
136
137func (_c *MockConfigMigrator_DetectChanges_Call) Run(run func()) *MockConfigMigrator_DetectChanges_Call {
138 _c.Call.Run(func(args mock.Arguments) {
139 run()
140 })
141 return _c
142}
143
144func (_c *MockConfigMigrator_DetectChanges_Call) Return(keyChanges []port.KeyChange, err error) *MockConfigMigrator_DetectChanges_Call {
145 _c.Call.Return(keyChanges, err)
146 return _c
147}
148
149func (_c *MockConfigMigrator_DetectChanges_Call) RunAndReturn(run func() ([]port.KeyChange, error)) *MockConfigMigrator_DetectChanges_Call {
150 _c.Call.Return(run)
151 return _c
152}
153
154// GetConfigFile provides a mock function for the type MockConfigMigrator
155func (_mock *MockConfigMigrator) GetConfigFile() (string, error) {
156 ret := _mock.Called()
157
158 if len(ret) == 0 {
159 panic("no return value specified for GetConfigFile")
160 }
161
162 var r0 string
163 var r1 error
164 if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
165 return returnFunc()
166 }
167 if returnFunc, ok := ret.Get(0).(func() string); ok {
168 r0 = returnFunc()
169 } else {
170 r0 = ret.Get(0).(string)
171 }
172 if returnFunc, ok := ret.Get(1).(func() error); ok {
173 r1 = returnFunc()
174 } else {
175 r1 = ret.Error(1)
176 }
177 return r0, r1
178}
179
180// MockConfigMigrator_GetConfigFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetConfigFile'
181type MockConfigMigrator_GetConfigFile_Call struct {
182 *mock.Call
183}
184
185// GetConfigFile is a helper method to define mock.On call
186func (_e *MockConfigMigrator_Expecter) GetConfigFile() *MockConfigMigrator_GetConfigFile_Call {
187 return &MockConfigMigrator_GetConfigFile_Call{Call: _e.mock.On("GetConfigFile")}
188}
189
190func (_c *MockConfigMigrator_GetConfigFile_Call) Run(run func()) *MockConfigMigrator_GetConfigFile_Call {
191 _c.Call.Run(func(args mock.Arguments) {
192 run()
193 })
194 return _c
195}
196
197func (_c *MockConfigMigrator_GetConfigFile_Call) Return(s string, err error) *MockConfigMigrator_GetConfigFile_Call {
198 _c.Call.Return(s, err)
199 return _c
200}
201
202func (_c *MockConfigMigrator_GetConfigFile_Call) RunAndReturn(run func() (string, error)) *MockConfigMigrator_GetConfigFile_Call {
203 _c.Call.Return(run)
204 return _c
205}
206
207// GetKeyInfo provides a mock function for the type MockConfigMigrator
208func (_mock *MockConfigMigrator) GetKeyInfo(key string) port.KeyInfo {
209 ret := _mock.Called(key)
210
211 if len(ret) == 0 {
212 panic("no return value specified for GetKeyInfo")
213 }
214
215 var r0 port.KeyInfo
216 if returnFunc, ok := ret.Get(0).(func(string) port.KeyInfo); ok {
217 r0 = returnFunc(key)
218 } else {
219 r0 = ret.Get(0).(port.KeyInfo)
220 }
221 return r0
222}
223
224// MockConfigMigrator_GetKeyInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetKeyInfo'
225type MockConfigMigrator_GetKeyInfo_Call struct {
226 *mock.Call
227}
228
229// GetKeyInfo is a helper method to define mock.On call
230// - key string
231func (_e *MockConfigMigrator_Expecter) GetKeyInfo(key interface{}) *MockConfigMigrator_GetKeyInfo_Call {
232 return &MockConfigMigrator_GetKeyInfo_Call{Call: _e.mock.On("GetKeyInfo", key)}
233}
234
235func (_c *MockConfigMigrator_GetKeyInfo_Call) Run(run func(key string)) *MockConfigMigrator_GetKeyInfo_Call {
236 _c.Call.Run(func(args mock.Arguments) {
237 var arg0 string
238 if args[0] != nil {
239 arg0 = args[0].(string)
240 }
241 run(
242 arg0,
243 )
244 })
245 return _c
246}
247
248func (_c *MockConfigMigrator_GetKeyInfo_Call) Return(keyInfo port.KeyInfo) *MockConfigMigrator_GetKeyInfo_Call {
249 _c.Call.Return(keyInfo)
250 return _c
251}
252
253func (_c *MockConfigMigrator_GetKeyInfo_Call) RunAndReturn(run func(key string) port.KeyInfo) *MockConfigMigrator_GetKeyInfo_Call {
254 _c.Call.Return(run)
255 return _c
256}
257
258// Migrate provides a mock function for the type MockConfigMigrator
259func (_mock *MockConfigMigrator) Migrate() ([]string, error) {
260 ret := _mock.Called()
261
262 if len(ret) == 0 {
263 panic("no return value specified for Migrate")
264 }
265
266 var r0 []string
267 var r1 error
268 if returnFunc, ok := ret.Get(0).(func() ([]string, error)); ok {
269 return returnFunc()
270 }
271 if returnFunc, ok := ret.Get(0).(func() []string); ok {
272 r0 = returnFunc()
273 } else {
274 if ret.Get(0) != nil {
275 r0 = ret.Get(0).([]string)
276 }
277 }
278 if returnFunc, ok := ret.Get(1).(func() error); ok {
279 r1 = returnFunc()
280 } else {
281 r1 = ret.Error(1)
282 }
283 return r0, r1
284}
285
286// MockConfigMigrator_Migrate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Migrate'
287type MockConfigMigrator_Migrate_Call struct {
288 *mock.Call
289}
290
291// Migrate is a helper method to define mock.On call
292func (_e *MockConfigMigrator_Expecter) Migrate() *MockConfigMigrator_Migrate_Call {
293 return &MockConfigMigrator_Migrate_Call{Call: _e.mock.On("Migrate")}
294}
295
296func (_c *MockConfigMigrator_Migrate_Call) Run(run func()) *MockConfigMigrator_Migrate_Call {
297 _c.Call.Run(func(args mock.Arguments) {
298 run()
299 })
300 return _c
301}
302
303func (_c *MockConfigMigrator_Migrate_Call) Return(strings []string, err error) *MockConfigMigrator_Migrate_Call {
304 _c.Call.Return(strings, err)
305 return _c
306}
307
308func (_c *MockConfigMigrator_Migrate_Call) RunAndReturn(run func() ([]string, error)) *MockConfigMigrator_Migrate_Call {
309 _c.Call.Return(run)
310 return _c
311}
312
313// NewMockDiffFormatter creates a new instance of MockDiffFormatter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
314// The first argument is typically a *testing.T value.
315func NewMockDiffFormatter(t interface {
316 mock.TestingT
317 Cleanup(func())
318}) *MockDiffFormatter {
319 mock := &MockDiffFormatter{}
320 mock.Mock.Test(t)
321
322 t.Cleanup(func() { mock.AssertExpectations(t) })
323
324 return mock
325}
326
327// MockDiffFormatter is an autogenerated mock type for the DiffFormatter type
328type MockDiffFormatter struct {
329 mock.Mock
330}
331
332type MockDiffFormatter_Expecter struct {
333 mock *mock.Mock
334}
335
336func (_m *MockDiffFormatter) EXPECT() *MockDiffFormatter_Expecter {
337 return &MockDiffFormatter_Expecter{mock: &_m.Mock}
338}
339
340// FormatChangesAsDiff provides a mock function for the type MockDiffFormatter
341func (_mock *MockDiffFormatter) FormatChangesAsDiff(changes []port.KeyChange) string {
342 ret := _mock.Called(changes)
343
344 if len(ret) == 0 {
345 panic("no return value specified for FormatChangesAsDiff")
346 }
347
348 var r0 string
349 if returnFunc, ok := ret.Get(0).(func([]port.KeyChange) string); ok {
350 r0 = returnFunc(changes)
351 } else {
352 r0 = ret.Get(0).(string)
353 }
354 return r0
355}
356
357// MockDiffFormatter_FormatChangesAsDiff_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FormatChangesAsDiff'
358type MockDiffFormatter_FormatChangesAsDiff_Call struct {
359 *mock.Call
360}
361
362// FormatChangesAsDiff is a helper method to define mock.On call
363// - changes []port.KeyChange
364func (_e *MockDiffFormatter_Expecter) FormatChangesAsDiff(changes interface{}) *MockDiffFormatter_FormatChangesAsDiff_Call {
365 return &MockDiffFormatter_FormatChangesAsDiff_Call{Call: _e.mock.On("FormatChangesAsDiff", changes)}
366}
367
368func (_c *MockDiffFormatter_FormatChangesAsDiff_Call) Run(run func(changes []port.KeyChange)) *MockDiffFormatter_FormatChangesAsDiff_Call {
369 _c.Call.Run(func(args mock.Arguments) {
370 var arg0 []port.KeyChange
371 if args[0] != nil {
372 arg0 = args[0].([]port.KeyChange)
373 }
374 run(
375 arg0,
376 )
377 })
378 return _c
379}
380
381func (_c *MockDiffFormatter_FormatChangesAsDiff_Call) Return(s string) *MockDiffFormatter_FormatChangesAsDiff_Call {
382 _c.Call.Return(s)
383 return _c
384}
385
386func (_c *MockDiffFormatter_FormatChangesAsDiff_Call) RunAndReturn(run func(changes []port.KeyChange) string) *MockDiffFormatter_FormatChangesAsDiff_Call {
387 _c.Call.Return(run)
388 return _c
389}
390
391// NewMockConfigSchemaProvider creates a new instance of MockConfigSchemaProvider. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
392// The first argument is typically a *testing.T value.
393func NewMockConfigSchemaProvider(t interface {
394 mock.TestingT
395 Cleanup(func())
396}) *MockConfigSchemaProvider {
397 mock := &MockConfigSchemaProvider{}
398 mock.Mock.Test(t)
399
400 t.Cleanup(func() { mock.AssertExpectations(t) })
401
402 return mock
403}
404
405// MockConfigSchemaProvider is an autogenerated mock type for the ConfigSchemaProvider type
406type MockConfigSchemaProvider struct {
407 mock.Mock
408}
409
410type MockConfigSchemaProvider_Expecter struct {
411 mock *mock.Mock
412}
413
414func (_m *MockConfigSchemaProvider) EXPECT() *MockConfigSchemaProvider_Expecter {
415 return &MockConfigSchemaProvider_Expecter{mock: &_m.Mock}
416}
417
418// GetSchema provides a mock function for the type MockConfigSchemaProvider
419func (_mock *MockConfigSchemaProvider) GetSchema() []entity.ConfigKeyInfo {
420 ret := _mock.Called()
421
422 if len(ret) == 0 {
423 panic("no return value specified for GetSchema")
424 }
425
426 var r0 []entity.ConfigKeyInfo
427 if returnFunc, ok := ret.Get(0).(func() []entity.ConfigKeyInfo); ok {
428 r0 = returnFunc()
429 } else {
430 if ret.Get(0) != nil {
431 r0 = ret.Get(0).([]entity.ConfigKeyInfo)
432 }
433 }
434 return r0
435}
436
437// MockConfigSchemaProvider_GetSchema_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSchema'
438type MockConfigSchemaProvider_GetSchema_Call struct {
439 *mock.Call
440}
441
442// GetSchema is a helper method to define mock.On call
443func (_e *MockConfigSchemaProvider_Expecter) GetSchema() *MockConfigSchemaProvider_GetSchema_Call {
444 return &MockConfigSchemaProvider_GetSchema_Call{Call: _e.mock.On("GetSchema")}
445}
446
447func (_c *MockConfigSchemaProvider_GetSchema_Call) Run(run func()) *MockConfigSchemaProvider_GetSchema_Call {
448 _c.Call.Run(func(args mock.Arguments) {
449 run()
450 })
451 return _c
452}
453
454func (_c *MockConfigSchemaProvider_GetSchema_Call) Return(configKeyInfos []entity.ConfigKeyInfo) *MockConfigSchemaProvider_GetSchema_Call {
455 _c.Call.Return(configKeyInfos)
456 return _c
457}
458
459func (_c *MockConfigSchemaProvider_GetSchema_Call) RunAndReturn(run func() []entity.ConfigKeyInfo) *MockConfigSchemaProvider_GetSchema_Call {
460 _c.Call.Return(run)
461 return _c
462}
463
464// NewMockDatabaseProvider creates a new instance of MockDatabaseProvider. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
465// The first argument is typically a *testing.T value.
466func NewMockDatabaseProvider(t interface {
467 mock.TestingT
468 Cleanup(func())
469}) *MockDatabaseProvider {
470 mock := &MockDatabaseProvider{}
471 mock.Mock.Test(t)
472
473 t.Cleanup(func() { mock.AssertExpectations(t) })
474
475 return mock
476}
477
478// MockDatabaseProvider is an autogenerated mock type for the DatabaseProvider type
479type MockDatabaseProvider struct {
480 mock.Mock
481}
482
483type MockDatabaseProvider_Expecter struct {
484 mock *mock.Mock
485}
486
487func (_m *MockDatabaseProvider) EXPECT() *MockDatabaseProvider_Expecter {
488 return &MockDatabaseProvider_Expecter{mock: &_m.Mock}
489}
490
491// Close provides a mock function for the type MockDatabaseProvider
492func (_mock *MockDatabaseProvider) Close() error {
493 ret := _mock.Called()
494
495 if len(ret) == 0 {
496 panic("no return value specified for Close")
497 }
498
499 var r0 error
500 if returnFunc, ok := ret.Get(0).(func() error); ok {
501 r0 = returnFunc()
502 } else {
503 r0 = ret.Error(0)
504 }
505 return r0
506}
507
508// MockDatabaseProvider_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
509type MockDatabaseProvider_Close_Call struct {
510 *mock.Call
511}
512
513// Close is a helper method to define mock.On call
514func (_e *MockDatabaseProvider_Expecter) Close() *MockDatabaseProvider_Close_Call {
515 return &MockDatabaseProvider_Close_Call{Call: _e.mock.On("Close")}
516}
517
518func (_c *MockDatabaseProvider_Close_Call) Run(run func()) *MockDatabaseProvider_Close_Call {
519 _c.Call.Run(func(args mock.Arguments) {
520 run()
521 })
522 return _c
523}
524
525func (_c *MockDatabaseProvider_Close_Call) Return(err error) *MockDatabaseProvider_Close_Call {
526 _c.Call.Return(err)
527 return _c
528}
529
530func (_c *MockDatabaseProvider_Close_Call) RunAndReturn(run func() error) *MockDatabaseProvider_Close_Call {
531 _c.Call.Return(run)
532 return _c
533}
534
535// DB provides a mock function for the type MockDatabaseProvider
536func (_mock *MockDatabaseProvider) DB(ctx context.Context) (*sql.DB, error) {
537 ret := _mock.Called(ctx)
538
539 if len(ret) == 0 {
540 panic("no return value specified for DB")
541 }
542
543 var r0 *sql.DB
544 var r1 error
545 if returnFunc, ok := ret.Get(0).(func(context.Context) (*sql.DB, error)); ok {
546 return returnFunc(ctx)
547 }
548 if returnFunc, ok := ret.Get(0).(func(context.Context) *sql.DB); ok {
549 r0 = returnFunc(ctx)
550 } else {
551 if ret.Get(0) != nil {
552 r0 = ret.Get(0).(*sql.DB)
553 }
554 }
555 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
556 r1 = returnFunc(ctx)
557 } else {
558 r1 = ret.Error(1)
559 }
560 return r0, r1
561}
562
563// MockDatabaseProvider_DB_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DB'
564type MockDatabaseProvider_DB_Call struct {
565 *mock.Call
566}
567
568// DB is a helper method to define mock.On call
569// - ctx context.Context
570func (_e *MockDatabaseProvider_Expecter) DB(ctx interface{}) *MockDatabaseProvider_DB_Call {
571 return &MockDatabaseProvider_DB_Call{Call: _e.mock.On("DB", ctx)}
572}
573
574func (_c *MockDatabaseProvider_DB_Call) Run(run func(ctx context.Context)) *MockDatabaseProvider_DB_Call {
575 _c.Call.Run(func(args mock.Arguments) {
576 var arg0 context.Context
577 if args[0] != nil {
578 arg0 = args[0].(context.Context)
579 }
580 run(
581 arg0,
582 )
583 })
584 return _c
585}
586
587func (_c *MockDatabaseProvider_DB_Call) Return(dB *sql.DB, err error) *MockDatabaseProvider_DB_Call {
588 _c.Call.Return(dB, err)
589 return _c
590}
591
592func (_c *MockDatabaseProvider_DB_Call) RunAndReturn(run func(ctx context.Context) (*sql.DB, error)) *MockDatabaseProvider_DB_Call {
593 _c.Call.Return(run)
594 return _c
595}
596
597// IsInitialized provides a mock function for the type MockDatabaseProvider
598func (_mock *MockDatabaseProvider) IsInitialized() bool {
599 ret := _mock.Called()
600
601 if len(ret) == 0 {
602 panic("no return value specified for IsInitialized")
603 }
604
605 var r0 bool
606 if returnFunc, ok := ret.Get(0).(func() bool); ok {
607 r0 = returnFunc()
608 } else {
609 r0 = ret.Get(0).(bool)
610 }
611 return r0
612}
613
614// MockDatabaseProvider_IsInitialized_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsInitialized'
615type MockDatabaseProvider_IsInitialized_Call struct {
616 *mock.Call
617}
618
619// IsInitialized is a helper method to define mock.On call
620func (_e *MockDatabaseProvider_Expecter) IsInitialized() *MockDatabaseProvider_IsInitialized_Call {
621 return &MockDatabaseProvider_IsInitialized_Call{Call: _e.mock.On("IsInitialized")}
622}
623
624func (_c *MockDatabaseProvider_IsInitialized_Call) Run(run func()) *MockDatabaseProvider_IsInitialized_Call {
625 _c.Call.Run(func(args mock.Arguments) {
626 run()
627 })
628 return _c
629}
630
631func (_c *MockDatabaseProvider_IsInitialized_Call) Return(b bool) *MockDatabaseProvider_IsInitialized_Call {
632 _c.Call.Return(b)
633 return _c
634}
635
636func (_c *MockDatabaseProvider_IsInitialized_Call) RunAndReturn(run func() bool) *MockDatabaseProvider_IsInitialized_Call {
637 _c.Call.Return(run)
638 return _c
639}
640
641// 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.
642// The first argument is typically a *testing.T value.
643func NewMockSessionLogger(t interface {
644 mock.TestingT
645 Cleanup(func())
646}) *MockSessionLogger {
647 mock := &MockSessionLogger{}
648 mock.Mock.Test(t)
649
650 t.Cleanup(func() { mock.AssertExpectations(t) })
651
652 return mock
653}
654
655// MockSessionLogger is an autogenerated mock type for the SessionLogger type
656type MockSessionLogger struct {
657 mock.Mock
658}
659
660type MockSessionLogger_Expecter struct {
661 mock *mock.Mock
662}
663
664func (_m *MockSessionLogger) EXPECT() *MockSessionLogger_Expecter {
665 return &MockSessionLogger_Expecter{mock: &_m.Mock}
666}
667
668// CreateLogger provides a mock function for the type MockSessionLogger
669func (_mock *MockSessionLogger) CreateLogger(ctx context.Context, sessionID entity.SessionID, cfg port.SessionLogConfig) (zerolog.Logger, func(), error) {
670 ret := _mock.Called(ctx, sessionID, cfg)
671
672 if len(ret) == 0 {
673 panic("no return value specified for CreateLogger")
674 }
675
676 var r0 zerolog.Logger
677 var r1 func()
678 var r2 error
679 if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID, port.SessionLogConfig) (zerolog.Logger, func(), error)); ok {
680 return returnFunc(ctx, sessionID, cfg)
681 }
682 if returnFunc, ok := ret.Get(0).(func(context.Context, entity.SessionID, port.SessionLogConfig) zerolog.Logger); ok {
683 r0 = returnFunc(ctx, sessionID, cfg)
684 } else {
685 r0 = ret.Get(0).(zerolog.Logger)
686 }
687 if returnFunc, ok := ret.Get(1).(func(context.Context, entity.SessionID, port.SessionLogConfig) func()); ok {
688 r1 = returnFunc(ctx, sessionID, cfg)
689 } else {
690 if ret.Get(1) != nil {
691 r1 = ret.Get(1).(func())
692 }
693 }
694 if returnFunc, ok := ret.Get(2).(func(context.Context, entity.SessionID, port.SessionLogConfig) error); ok {
695 r2 = returnFunc(ctx, sessionID, cfg)
696 } else {
697 r2 = ret.Error(2)
698 }
699 return r0, r1, r2
700}
701
702// MockSessionLogger_CreateLogger_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateLogger'
703type MockSessionLogger_CreateLogger_Call struct {
704 *mock.Call
705}
706
707// CreateLogger is a helper method to define mock.On call
708// - ctx context.Context
709// - sessionID entity.SessionID
710// - cfg port.SessionLogConfig
711func (_e *MockSessionLogger_Expecter) CreateLogger(ctx interface{}, sessionID interface{}, cfg interface{}) *MockSessionLogger_CreateLogger_Call {
712 return &MockSessionLogger_CreateLogger_Call{Call: _e.mock.On("CreateLogger", ctx, sessionID, cfg)}
713}
714
715func (_c *MockSessionLogger_CreateLogger_Call) Run(run func(ctx context.Context, sessionID entity.SessionID, cfg port.SessionLogConfig)) *MockSessionLogger_CreateLogger_Call {
716 _c.Call.Run(func(args mock.Arguments) {
717 var arg0 context.Context
718 if args[0] != nil {
719 arg0 = args[0].(context.Context)
720 }
721 var arg1 entity.SessionID
722 if args[1] != nil {
723 arg1 = args[1].(entity.SessionID)
724 }
725 var arg2 port.SessionLogConfig
726 if args[2] != nil {
727 arg2 = args[2].(port.SessionLogConfig)
728 }
729 run(
730 arg0,
731 arg1,
732 arg2,
733 )
734 })
735 return _c
736}
737
738func (_c *MockSessionLogger_CreateLogger_Call) Return(logger zerolog.Logger, fn func(), err error) *MockSessionLogger_CreateLogger_Call {
739 _c.Call.Return(logger, fn, err)
740 return _c
741}
742
743func (_c *MockSessionLogger_CreateLogger_Call) RunAndReturn(run func(ctx context.Context, sessionID entity.SessionID, cfg port.SessionLogConfig) (zerolog.Logger, func(), error)) *MockSessionLogger_CreateLogger_Call {
744 _c.Call.Return(run)
745 return _c
746}
747
748// NewMockTabListProvider creates a new instance of MockTabListProvider. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
749// The first argument is typically a *testing.T value.
750func NewMockTabListProvider(t interface {
751 mock.TestingT
752 Cleanup(func())
753}) *MockTabListProvider {
754 mock := &MockTabListProvider{}
755 mock.Mock.Test(t)
756
757 t.Cleanup(func() { mock.AssertExpectations(t) })
758
759 return mock
760}
761
762// MockTabListProvider is an autogenerated mock type for the TabListProvider type
763type MockTabListProvider struct {
764 mock.Mock
765}
766
767type MockTabListProvider_Expecter struct {
768 mock *mock.Mock
769}
770
771func (_m *MockTabListProvider) EXPECT() *MockTabListProvider_Expecter {
772 return &MockTabListProvider_Expecter{mock: &_m.Mock}
773}
774
775// GetSessionID provides a mock function for the type MockTabListProvider
776func (_mock *MockTabListProvider) GetSessionID() entity.SessionID {
777 ret := _mock.Called()
778
779 if len(ret) == 0 {
780 panic("no return value specified for GetSessionID")
781 }
782
783 var r0 entity.SessionID
784 if returnFunc, ok := ret.Get(0).(func() entity.SessionID); ok {
785 r0 = returnFunc()
786 } else {
787 r0 = ret.Get(0).(entity.SessionID)
788 }
789 return r0
790}
791
792// MockTabListProvider_GetSessionID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSessionID'
793type MockTabListProvider_GetSessionID_Call struct {
794 *mock.Call
795}
796
797// GetSessionID is a helper method to define mock.On call
798func (_e *MockTabListProvider_Expecter) GetSessionID() *MockTabListProvider_GetSessionID_Call {
799 return &MockTabListProvider_GetSessionID_Call{Call: _e.mock.On("GetSessionID")}
800}
801
802func (_c *MockTabListProvider_GetSessionID_Call) Run(run func()) *MockTabListProvider_GetSessionID_Call {
803 _c.Call.Run(func(args mock.Arguments) {
804 run()
805 })
806 return _c
807}
808
809func (_c *MockTabListProvider_GetSessionID_Call) Return(sessionID entity.SessionID) *MockTabListProvider_GetSessionID_Call {
810 _c.Call.Return(sessionID)
811 return _c
812}
813
814func (_c *MockTabListProvider_GetSessionID_Call) RunAndReturn(run func() entity.SessionID) *MockTabListProvider_GetSessionID_Call {
815 _c.Call.Return(run)
816 return _c
817}
818
819// GetTabList provides a mock function for the type MockTabListProvider
820func (_mock *MockTabListProvider) GetTabList() *entity.TabList {
821 ret := _mock.Called()
822
823 if len(ret) == 0 {
824 panic("no return value specified for GetTabList")
825 }
826
827 var r0 *entity.TabList
828 if returnFunc, ok := ret.Get(0).(func() *entity.TabList); ok {
829 r0 = returnFunc()
830 } else {
831 if ret.Get(0) != nil {
832 r0 = ret.Get(0).(*entity.TabList)
833 }
834 }
835 return r0
836}
837
838// MockTabListProvider_GetTabList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTabList'
839type MockTabListProvider_GetTabList_Call struct {
840 *mock.Call
841}
842
843// GetTabList is a helper method to define mock.On call
844func (_e *MockTabListProvider_Expecter) GetTabList() *MockTabListProvider_GetTabList_Call {
845 return &MockTabListProvider_GetTabList_Call{Call: _e.mock.On("GetTabList")}
846}
847
848func (_c *MockTabListProvider_GetTabList_Call) Run(run func()) *MockTabListProvider_GetTabList_Call {
849 _c.Call.Run(func(args mock.Arguments) {
850 run()
851 })
852 return _c
853}
854
855func (_c *MockTabListProvider_GetTabList_Call) Return(tabList *entity.TabList) *MockTabListProvider_GetTabList_Call {
856 _c.Call.Return(tabList)
857 return _c
858}
859
860func (_c *MockTabListProvider_GetTabList_Call) RunAndReturn(run func() *entity.TabList) *MockTabListProvider_GetTabList_Call {
861 _c.Call.Return(run)
862 return _c
863}
864
865// NewMockSessionSpawner creates a new instance of MockSessionSpawner. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
866// The first argument is typically a *testing.T value.
867func NewMockSessionSpawner(t interface {
868 mock.TestingT
869 Cleanup(func())
870}) *MockSessionSpawner {
871 mock := &MockSessionSpawner{}
872 mock.Mock.Test(t)
873
874 t.Cleanup(func() { mock.AssertExpectations(t) })
875
876 return mock
877}
878
879// MockSessionSpawner is an autogenerated mock type for the SessionSpawner type
880type MockSessionSpawner struct {
881 mock.Mock
882}
883
884type MockSessionSpawner_Expecter struct {
885 mock *mock.Mock
886}
887
888func (_m *MockSessionSpawner) EXPECT() *MockSessionSpawner_Expecter {
889 return &MockSessionSpawner_Expecter{mock: &_m.Mock}
890}
891
892// SpawnWithSession provides a mock function for the type MockSessionSpawner
893func (_mock *MockSessionSpawner) SpawnWithSession(sessionID entity.SessionID) error {
894 ret := _mock.Called(sessionID)
895
896 if len(ret) == 0 {
897 panic("no return value specified for SpawnWithSession")
898 }
899
900 var r0 error
901 if returnFunc, ok := ret.Get(0).(func(entity.SessionID) error); ok {
902 r0 = returnFunc(sessionID)
903 } else {
904 r0 = ret.Error(0)
905 }
906 return r0
907}
908
909// MockSessionSpawner_SpawnWithSession_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SpawnWithSession'
910type MockSessionSpawner_SpawnWithSession_Call struct {
911 *mock.Call
912}
913
914// SpawnWithSession is a helper method to define mock.On call
915// - sessionID entity.SessionID
916func (_e *MockSessionSpawner_Expecter) SpawnWithSession(sessionID interface{}) *MockSessionSpawner_SpawnWithSession_Call {
917 return &MockSessionSpawner_SpawnWithSession_Call{Call: _e.mock.On("SpawnWithSession", sessionID)}
918}
919
920func (_c *MockSessionSpawner_SpawnWithSession_Call) Run(run func(sessionID entity.SessionID)) *MockSessionSpawner_SpawnWithSession_Call {
921 _c.Call.Run(func(args mock.Arguments) {
922 var arg0 entity.SessionID
923 if args[0] != nil {
924 arg0 = args[0].(entity.SessionID)
925 }
926 run(
927 arg0,
928 )
929 })
930 return _c
931}
932
933func (_c *MockSessionSpawner_SpawnWithSession_Call) Return(err error) *MockSessionSpawner_SpawnWithSession_Call {
934 _c.Call.Return(err)
935 return _c
936}
937
938func (_c *MockSessionSpawner_SpawnWithSession_Call) RunAndReturn(run func(sessionID entity.SessionID) error) *MockSessionSpawner_SpawnWithSession_Call {
939 _c.Call.Return(run)
940 return _c
941}
942
943// 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.
944// The first argument is typically a *testing.T value.
945func NewMockWebView(t interface {
946 mock.TestingT
947 Cleanup(func())
948}) *MockWebView {
949 mock := &MockWebView{}
950 mock.Mock.Test(t)
951
952 t.Cleanup(func() { mock.AssertExpectations(t) })
953
954 return mock
955}
956
957// MockWebView is an autogenerated mock type for the WebView type
958type MockWebView struct {
959 mock.Mock
960}
961
962type MockWebView_Expecter struct {
963 mock *mock.Mock
964}
965
966func (_m *MockWebView) EXPECT() *MockWebView_Expecter {
967 return &MockWebView_Expecter{mock: &_m.Mock}
968}
969
970// CanGoBack provides a mock function for the type MockWebView
971func (_mock *MockWebView) CanGoBack() bool {
972 ret := _mock.Called()
973
974 if len(ret) == 0 {
975 panic("no return value specified for CanGoBack")
976 }
977
978 var r0 bool
979 if returnFunc, ok := ret.Get(0).(func() bool); ok {
980 r0 = returnFunc()
981 } else {
982 r0 = ret.Get(0).(bool)
983 }
984 return r0
985}
986
987// MockWebView_CanGoBack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CanGoBack'
988type MockWebView_CanGoBack_Call struct {
989 *mock.Call
990}
991
992// CanGoBack is a helper method to define mock.On call
993func (_e *MockWebView_Expecter) CanGoBack() *MockWebView_CanGoBack_Call {
994 return &MockWebView_CanGoBack_Call{Call: _e.mock.On("CanGoBack")}
995}
996
997func (_c *MockWebView_CanGoBack_Call) Run(run func()) *MockWebView_CanGoBack_Call {
998 _c.Call.Run(func(args mock.Arguments) {
999 run()
1000 })
1001 return _c
1002}
1003
1004func (_c *MockWebView_CanGoBack_Call) Return(b bool) *MockWebView_CanGoBack_Call {
1005 _c.Call.Return(b)
1006 return _c
1007}
1008
1009func (_c *MockWebView_CanGoBack_Call) RunAndReturn(run func() bool) *MockWebView_CanGoBack_Call {
1010 _c.Call.Return(run)
1011 return _c
1012}
1013
1014// CanGoForward provides a mock function for the type MockWebView
1015func (_mock *MockWebView) CanGoForward() bool {
1016 ret := _mock.Called()
1017
1018 if len(ret) == 0 {
1019 panic("no return value specified for CanGoForward")
1020 }
1021
1022 var r0 bool
1023 if returnFunc, ok := ret.Get(0).(func() bool); ok {
1024 r0 = returnFunc()
1025 } else {
1026 r0 = ret.Get(0).(bool)
1027 }
1028 return r0
1029}
1030
1031// MockWebView_CanGoForward_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CanGoForward'
1032type MockWebView_CanGoForward_Call struct {
1033 *mock.Call
1034}
1035
1036// CanGoForward is a helper method to define mock.On call
1037func (_e *MockWebView_Expecter) CanGoForward() *MockWebView_CanGoForward_Call {
1038 return &MockWebView_CanGoForward_Call{Call: _e.mock.On("CanGoForward")}
1039}
1040
1041func (_c *MockWebView_CanGoForward_Call) Run(run func()) *MockWebView_CanGoForward_Call {
1042 _c.Call.Run(func(args mock.Arguments) {
1043 run()
1044 })
1045 return _c
1046}
1047
1048func (_c *MockWebView_CanGoForward_Call) Return(b bool) *MockWebView_CanGoForward_Call {
1049 _c.Call.Return(b)
1050 return _c
1051}
1052
1053func (_c *MockWebView_CanGoForward_Call) RunAndReturn(run func() bool) *MockWebView_CanGoForward_Call {
1054 _c.Call.Return(run)
1055 return _c
1056}
1057
1058// Destroy provides a mock function for the type MockWebView
1059func (_mock *MockWebView) Destroy() {
1060 _mock.Called()
1061 return
1062}
1063
1064// MockWebView_Destroy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Destroy'
1065type MockWebView_Destroy_Call struct {
1066 *mock.Call
1067}
1068
1069// Destroy is a helper method to define mock.On call
1070func (_e *MockWebView_Expecter) Destroy() *MockWebView_Destroy_Call {
1071 return &MockWebView_Destroy_Call{Call: _e.mock.On("Destroy")}
1072}
1073
1074func (_c *MockWebView_Destroy_Call) Run(run func()) *MockWebView_Destroy_Call {
1075 _c.Call.Run(func(args mock.Arguments) {
1076 run()
1077 })
1078 return _c
1079}
1080
1081func (_c *MockWebView_Destroy_Call) Return() *MockWebView_Destroy_Call {
1082 _c.Call.Return()
1083 return _c
1084}
1085
1086func (_c *MockWebView_Destroy_Call) RunAndReturn(run func()) *MockWebView_Destroy_Call {
1087 _c.Run(run)
1088 return _c
1089}
1090
1091// EstimatedProgress provides a mock function for the type MockWebView
1092func (_mock *MockWebView) EstimatedProgress() float64 {
1093 ret := _mock.Called()
1094
1095 if len(ret) == 0 {
1096 panic("no return value specified for EstimatedProgress")
1097 }
1098
1099 var r0 float64
1100 if returnFunc, ok := ret.Get(0).(func() float64); ok {
1101 r0 = returnFunc()
1102 } else {
1103 r0 = ret.Get(0).(float64)
1104 }
1105 return r0
1106}
1107
1108// MockWebView_EstimatedProgress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EstimatedProgress'
1109type MockWebView_EstimatedProgress_Call struct {
1110 *mock.Call
1111}
1112
1113// EstimatedProgress is a helper method to define mock.On call
1114func (_e *MockWebView_Expecter) EstimatedProgress() *MockWebView_EstimatedProgress_Call {
1115 return &MockWebView_EstimatedProgress_Call{Call: _e.mock.On("EstimatedProgress")}
1116}
1117
1118func (_c *MockWebView_EstimatedProgress_Call) Run(run func()) *MockWebView_EstimatedProgress_Call {
1119 _c.Call.Run(func(args mock.Arguments) {
1120 run()
1121 })
1122 return _c
1123}
1124
1125func (_c *MockWebView_EstimatedProgress_Call) Return(f float64) *MockWebView_EstimatedProgress_Call {
1126 _c.Call.Return(f)
1127 return _c
1128}
1129
1130func (_c *MockWebView_EstimatedProgress_Call) RunAndReturn(run func() float64) *MockWebView_EstimatedProgress_Call {
1131 _c.Call.Return(run)
1132 return _c
1133}
1134
1135// GetFindController provides a mock function for the type MockWebView
1136func (_mock *MockWebView) GetFindController() port.FindController {
1137 ret := _mock.Called()
1138
1139 if len(ret) == 0 {
1140 panic("no return value specified for GetFindController")
1141 }
1142
1143 var r0 port.FindController
1144 if returnFunc, ok := ret.Get(0).(func() port.FindController); ok {
1145 r0 = returnFunc()
1146 } else {
1147 if ret.Get(0) != nil {
1148 r0 = ret.Get(0).(port.FindController)
1149 }
1150 }
1151 return r0
1152}
1153
1154// MockWebView_GetFindController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFindController'
1155type MockWebView_GetFindController_Call struct {
1156 *mock.Call
1157}
1158
1159// GetFindController is a helper method to define mock.On call
1160func (_e *MockWebView_Expecter) GetFindController() *MockWebView_GetFindController_Call {
1161 return &MockWebView_GetFindController_Call{Call: _e.mock.On("GetFindController")}
1162}
1163
1164func (_c *MockWebView_GetFindController_Call) Run(run func()) *MockWebView_GetFindController_Call {
1165 _c.Call.Run(func(args mock.Arguments) {
1166 run()
1167 })
1168 return _c
1169}
1170
1171func (_c *MockWebView_GetFindController_Call) Return(findController port.FindController) *MockWebView_GetFindController_Call {
1172 _c.Call.Return(findController)
1173 return _c
1174}
1175
1176func (_c *MockWebView_GetFindController_Call) RunAndReturn(run func() port.FindController) *MockWebView_GetFindController_Call {
1177 _c.Call.Return(run)
1178 return _c
1179}
1180
1181// GetZoomLevel provides a mock function for the type MockWebView
1182func (_mock *MockWebView) GetZoomLevel() float64 {
1183 ret := _mock.Called()
1184
1185 if len(ret) == 0 {
1186 panic("no return value specified for GetZoomLevel")
1187 }
1188
1189 var r0 float64
1190 if returnFunc, ok := ret.Get(0).(func() float64); ok {
1191 r0 = returnFunc()
1192 } else {
1193 r0 = ret.Get(0).(float64)
1194 }
1195 return r0
1196}
1197
1198// MockWebView_GetZoomLevel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetZoomLevel'
1199type MockWebView_GetZoomLevel_Call struct {
1200 *mock.Call
1201}
1202
1203// GetZoomLevel is a helper method to define mock.On call
1204func (_e *MockWebView_Expecter) GetZoomLevel() *MockWebView_GetZoomLevel_Call {
1205 return &MockWebView_GetZoomLevel_Call{Call: _e.mock.On("GetZoomLevel")}
1206}
1207
1208func (_c *MockWebView_GetZoomLevel_Call) Run(run func()) *MockWebView_GetZoomLevel_Call {
1209 _c.Call.Run(func(args mock.Arguments) {
1210 run()
1211 })
1212 return _c
1213}
1214
1215func (_c *MockWebView_GetZoomLevel_Call) Return(f float64) *MockWebView_GetZoomLevel_Call {
1216 _c.Call.Return(f)
1217 return _c
1218}
1219
1220func (_c *MockWebView_GetZoomLevel_Call) RunAndReturn(run func() float64) *MockWebView_GetZoomLevel_Call {
1221 _c.Call.Return(run)
1222 return _c
1223}
1224
1225// GoBack provides a mock function for the type MockWebView
1226func (_mock *MockWebView) GoBack(ctx context.Context) error {
1227 ret := _mock.Called(ctx)
1228
1229 if len(ret) == 0 {
1230 panic("no return value specified for GoBack")
1231 }
1232
1233 var r0 error
1234 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
1235 r0 = returnFunc(ctx)
1236 } else {
1237 r0 = ret.Error(0)
1238 }
1239 return r0
1240}
1241
1242// MockWebView_GoBack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GoBack'
1243type MockWebView_GoBack_Call struct {
1244 *mock.Call
1245}
1246
1247// GoBack is a helper method to define mock.On call
1248// - ctx context.Context
1249func (_e *MockWebView_Expecter) GoBack(ctx interface{}) *MockWebView_GoBack_Call {
1250 return &MockWebView_GoBack_Call{Call: _e.mock.On("GoBack", ctx)}
1251}
1252
1253func (_c *MockWebView_GoBack_Call) Run(run func(ctx context.Context)) *MockWebView_GoBack_Call {
1254 _c.Call.Run(func(args mock.Arguments) {
1255 var arg0 context.Context
1256 if args[0] != nil {
1257 arg0 = args[0].(context.Context)
1258 }
1259 run(
1260 arg0,
1261 )
1262 })
1263 return _c
1264}
1265
1266func (_c *MockWebView_GoBack_Call) Return(err error) *MockWebView_GoBack_Call {
1267 _c.Call.Return(err)
1268 return _c
1269}
1270
1271func (_c *MockWebView_GoBack_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_GoBack_Call {
1272 _c.Call.Return(run)
1273 return _c
1274}
1275
1276// GoForward provides a mock function for the type MockWebView
1277func (_mock *MockWebView) GoForward(ctx context.Context) error {
1278 ret := _mock.Called(ctx)
1279
1280 if len(ret) == 0 {
1281 panic("no return value specified for GoForward")
1282 }
1283
1284 var r0 error
1285 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
1286 r0 = returnFunc(ctx)
1287 } else {
1288 r0 = ret.Error(0)
1289 }
1290 return r0
1291}
1292
1293// MockWebView_GoForward_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GoForward'
1294type MockWebView_GoForward_Call struct {
1295 *mock.Call
1296}
1297
1298// GoForward is a helper method to define mock.On call
1299// - ctx context.Context
1300func (_e *MockWebView_Expecter) GoForward(ctx interface{}) *MockWebView_GoForward_Call {
1301 return &MockWebView_GoForward_Call{Call: _e.mock.On("GoForward", ctx)}
1302}
1303
1304func (_c *MockWebView_GoForward_Call) Run(run func(ctx context.Context)) *MockWebView_GoForward_Call {
1305 _c.Call.Run(func(args mock.Arguments) {
1306 var arg0 context.Context
1307 if args[0] != nil {
1308 arg0 = args[0].(context.Context)
1309 }
1310 run(
1311 arg0,
1312 )
1313 })
1314 return _c
1315}
1316
1317func (_c *MockWebView_GoForward_Call) Return(err error) *MockWebView_GoForward_Call {
1318 _c.Call.Return(err)
1319 return _c
1320}
1321
1322func (_c *MockWebView_GoForward_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_GoForward_Call {
1323 _c.Call.Return(run)
1324 return _c
1325}
1326
1327// ID provides a mock function for the type MockWebView
1328func (_mock *MockWebView) ID() port.WebViewID {
1329 ret := _mock.Called()
1330
1331 if len(ret) == 0 {
1332 panic("no return value specified for ID")
1333 }
1334
1335 var r0 port.WebViewID
1336 if returnFunc, ok := ret.Get(0).(func() port.WebViewID); ok {
1337 r0 = returnFunc()
1338 } else {
1339 r0 = ret.Get(0).(port.WebViewID)
1340 }
1341 return r0
1342}
1343
1344// MockWebView_ID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ID'
1345type MockWebView_ID_Call struct {
1346 *mock.Call
1347}
1348
1349// ID is a helper method to define mock.On call
1350func (_e *MockWebView_Expecter) ID() *MockWebView_ID_Call {
1351 return &MockWebView_ID_Call{Call: _e.mock.On("ID")}
1352}
1353
1354func (_c *MockWebView_ID_Call) Run(run func()) *MockWebView_ID_Call {
1355 _c.Call.Run(func(args mock.Arguments) {
1356 run()
1357 })
1358 return _c
1359}
1360
1361func (_c *MockWebView_ID_Call) Return(webViewID port.WebViewID) *MockWebView_ID_Call {
1362 _c.Call.Return(webViewID)
1363 return _c
1364}
1365
1366func (_c *MockWebView_ID_Call) RunAndReturn(run func() port.WebViewID) *MockWebView_ID_Call {
1367 _c.Call.Return(run)
1368 return _c
1369}
1370
1371// IsDestroyed provides a mock function for the type MockWebView
1372func (_mock *MockWebView) IsDestroyed() bool {
1373 ret := _mock.Called()
1374
1375 if len(ret) == 0 {
1376 panic("no return value specified for IsDestroyed")
1377 }
1378
1379 var r0 bool
1380 if returnFunc, ok := ret.Get(0).(func() bool); ok {
1381 r0 = returnFunc()
1382 } else {
1383 r0 = ret.Get(0).(bool)
1384 }
1385 return r0
1386}
1387
1388// MockWebView_IsDestroyed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsDestroyed'
1389type MockWebView_IsDestroyed_Call struct {
1390 *mock.Call
1391}
1392
1393// IsDestroyed is a helper method to define mock.On call
1394func (_e *MockWebView_Expecter) IsDestroyed() *MockWebView_IsDestroyed_Call {
1395 return &MockWebView_IsDestroyed_Call{Call: _e.mock.On("IsDestroyed")}
1396}
1397
1398func (_c *MockWebView_IsDestroyed_Call) Run(run func()) *MockWebView_IsDestroyed_Call {
1399 _c.Call.Run(func(args mock.Arguments) {
1400 run()
1401 })
1402 return _c
1403}
1404
1405func (_c *MockWebView_IsDestroyed_Call) Return(b bool) *MockWebView_IsDestroyed_Call {
1406 _c.Call.Return(b)
1407 return _c
1408}
1409
1410func (_c *MockWebView_IsDestroyed_Call) RunAndReturn(run func() bool) *MockWebView_IsDestroyed_Call {
1411 _c.Call.Return(run)
1412 return _c
1413}
1414
1415// IsFullscreen provides a mock function for the type MockWebView
1416func (_mock *MockWebView) IsFullscreen() bool {
1417 ret := _mock.Called()
1418
1419 if len(ret) == 0 {
1420 panic("no return value specified for IsFullscreen")
1421 }
1422
1423 var r0 bool
1424 if returnFunc, ok := ret.Get(0).(func() bool); ok {
1425 r0 = returnFunc()
1426 } else {
1427 r0 = ret.Get(0).(bool)
1428 }
1429 return r0
1430}
1431
1432// MockWebView_IsFullscreen_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsFullscreen'
1433type MockWebView_IsFullscreen_Call struct {
1434 *mock.Call
1435}
1436
1437// IsFullscreen is a helper method to define mock.On call
1438func (_e *MockWebView_Expecter) IsFullscreen() *MockWebView_IsFullscreen_Call {
1439 return &MockWebView_IsFullscreen_Call{Call: _e.mock.On("IsFullscreen")}
1440}
1441
1442func (_c *MockWebView_IsFullscreen_Call) Run(run func()) *MockWebView_IsFullscreen_Call {
1443 _c.Call.Run(func(args mock.Arguments) {
1444 run()
1445 })
1446 return _c
1447}
1448
1449func (_c *MockWebView_IsFullscreen_Call) Return(b bool) *MockWebView_IsFullscreen_Call {
1450 _c.Call.Return(b)
1451 return _c
1452}
1453
1454func (_c *MockWebView_IsFullscreen_Call) RunAndReturn(run func() bool) *MockWebView_IsFullscreen_Call {
1455 _c.Call.Return(run)
1456 return _c
1457}
1458
1459// IsLoading provides a mock function for the type MockWebView
1460func (_mock *MockWebView) IsLoading() bool {
1461 ret := _mock.Called()
1462
1463 if len(ret) == 0 {
1464 panic("no return value specified for IsLoading")
1465 }
1466
1467 var r0 bool
1468 if returnFunc, ok := ret.Get(0).(func() bool); ok {
1469 r0 = returnFunc()
1470 } else {
1471 r0 = ret.Get(0).(bool)
1472 }
1473 return r0
1474}
1475
1476// MockWebView_IsLoading_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsLoading'
1477type MockWebView_IsLoading_Call struct {
1478 *mock.Call
1479}
1480
1481// IsLoading is a helper method to define mock.On call
1482func (_e *MockWebView_Expecter) IsLoading() *MockWebView_IsLoading_Call {
1483 return &MockWebView_IsLoading_Call{Call: _e.mock.On("IsLoading")}
1484}
1485
1486func (_c *MockWebView_IsLoading_Call) Run(run func()) *MockWebView_IsLoading_Call {
1487 _c.Call.Run(func(args mock.Arguments) {
1488 run()
1489 })
1490 return _c
1491}
1492
1493func (_c *MockWebView_IsLoading_Call) Return(b bool) *MockWebView_IsLoading_Call {
1494 _c.Call.Return(b)
1495 return _c
1496}
1497
1498func (_c *MockWebView_IsLoading_Call) RunAndReturn(run func() bool) *MockWebView_IsLoading_Call {
1499 _c.Call.Return(run)
1500 return _c
1501}
1502
1503// IsPlayingAudio provides a mock function for the type MockWebView
1504func (_mock *MockWebView) IsPlayingAudio() bool {
1505 ret := _mock.Called()
1506
1507 if len(ret) == 0 {
1508 panic("no return value specified for IsPlayingAudio")
1509 }
1510
1511 var r0 bool
1512 if returnFunc, ok := ret.Get(0).(func() bool); ok {
1513 r0 = returnFunc()
1514 } else {
1515 r0 = ret.Get(0).(bool)
1516 }
1517 return r0
1518}
1519
1520// MockWebView_IsPlayingAudio_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsPlayingAudio'
1521type MockWebView_IsPlayingAudio_Call struct {
1522 *mock.Call
1523}
1524
1525// IsPlayingAudio is a helper method to define mock.On call
1526func (_e *MockWebView_Expecter) IsPlayingAudio() *MockWebView_IsPlayingAudio_Call {
1527 return &MockWebView_IsPlayingAudio_Call{Call: _e.mock.On("IsPlayingAudio")}
1528}
1529
1530func (_c *MockWebView_IsPlayingAudio_Call) Run(run func()) *MockWebView_IsPlayingAudio_Call {
1531 _c.Call.Run(func(args mock.Arguments) {
1532 run()
1533 })
1534 return _c
1535}
1536
1537func (_c *MockWebView_IsPlayingAudio_Call) Return(b bool) *MockWebView_IsPlayingAudio_Call {
1538 _c.Call.Return(b)
1539 return _c
1540}
1541
1542func (_c *MockWebView_IsPlayingAudio_Call) RunAndReturn(run func() bool) *MockWebView_IsPlayingAudio_Call {
1543 _c.Call.Return(run)
1544 return _c
1545}
1546
1547// LoadHTML provides a mock function for the type MockWebView
1548func (_mock *MockWebView) LoadHTML(ctx context.Context, content string, baseURI string) error {
1549 ret := _mock.Called(ctx, content, baseURI)
1550
1551 if len(ret) == 0 {
1552 panic("no return value specified for LoadHTML")
1553 }
1554
1555 var r0 error
1556 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
1557 r0 = returnFunc(ctx, content, baseURI)
1558 } else {
1559 r0 = ret.Error(0)
1560 }
1561 return r0
1562}
1563
1564// MockWebView_LoadHTML_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadHTML'
1565type MockWebView_LoadHTML_Call struct {
1566 *mock.Call
1567}
1568
1569// LoadHTML is a helper method to define mock.On call
1570// - ctx context.Context
1571// - content string
1572// - baseURI string
1573func (_e *MockWebView_Expecter) LoadHTML(ctx interface{}, content interface{}, baseURI interface{}) *MockWebView_LoadHTML_Call {
1574 return &MockWebView_LoadHTML_Call{Call: _e.mock.On("LoadHTML", ctx, content, baseURI)}
1575}
1576
1577func (_c *MockWebView_LoadHTML_Call) Run(run func(ctx context.Context, content string, baseURI string)) *MockWebView_LoadHTML_Call {
1578 _c.Call.Run(func(args mock.Arguments) {
1579 var arg0 context.Context
1580 if args[0] != nil {
1581 arg0 = args[0].(context.Context)
1582 }
1583 var arg1 string
1584 if args[1] != nil {
1585 arg1 = args[1].(string)
1586 }
1587 var arg2 string
1588 if args[2] != nil {
1589 arg2 = args[2].(string)
1590 }
1591 run(
1592 arg0,
1593 arg1,
1594 arg2,
1595 )
1596 })
1597 return _c
1598}
1599
1600func (_c *MockWebView_LoadHTML_Call) Return(err error) *MockWebView_LoadHTML_Call {
1601 _c.Call.Return(err)
1602 return _c
1603}
1604
1605func (_c *MockWebView_LoadHTML_Call) RunAndReturn(run func(ctx context.Context, content string, baseURI string) error) *MockWebView_LoadHTML_Call {
1606 _c.Call.Return(run)
1607 return _c
1608}
1609
1610// LoadURI provides a mock function for the type MockWebView
1611func (_mock *MockWebView) LoadURI(ctx context.Context, uri string) error {
1612 ret := _mock.Called(ctx, uri)
1613
1614 if len(ret) == 0 {
1615 panic("no return value specified for LoadURI")
1616 }
1617
1618 var r0 error
1619 if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
1620 r0 = returnFunc(ctx, uri)
1621 } else {
1622 r0 = ret.Error(0)
1623 }
1624 return r0
1625}
1626
1627// MockWebView_LoadURI_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadURI'
1628type MockWebView_LoadURI_Call struct {
1629 *mock.Call
1630}
1631
1632// LoadURI is a helper method to define mock.On call
1633// - ctx context.Context
1634// - uri string
1635func (_e *MockWebView_Expecter) LoadURI(ctx interface{}, uri interface{}) *MockWebView_LoadURI_Call {
1636 return &MockWebView_LoadURI_Call{Call: _e.mock.On("LoadURI", ctx, uri)}
1637}
1638
1639func (_c *MockWebView_LoadURI_Call) Run(run func(ctx context.Context, uri string)) *MockWebView_LoadURI_Call {
1640 _c.Call.Run(func(args mock.Arguments) {
1641 var arg0 context.Context
1642 if args[0] != nil {
1643 arg0 = args[0].(context.Context)
1644 }
1645 var arg1 string
1646 if args[1] != nil {
1647 arg1 = args[1].(string)
1648 }
1649 run(
1650 arg0,
1651 arg1,
1652 )
1653 })
1654 return _c
1655}
1656
1657func (_c *MockWebView_LoadURI_Call) Return(err error) *MockWebView_LoadURI_Call {
1658 _c.Call.Return(err)
1659 return _c
1660}
1661
1662func (_c *MockWebView_LoadURI_Call) RunAndReturn(run func(ctx context.Context, uri string) error) *MockWebView_LoadURI_Call {
1663 _c.Call.Return(run)
1664 return _c
1665}
1666
1667// Reload provides a mock function for the type MockWebView
1668func (_mock *MockWebView) Reload(ctx context.Context) error {
1669 ret := _mock.Called(ctx)
1670
1671 if len(ret) == 0 {
1672 panic("no return value specified for Reload")
1673 }
1674
1675 var r0 error
1676 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
1677 r0 = returnFunc(ctx)
1678 } else {
1679 r0 = ret.Error(0)
1680 }
1681 return r0
1682}
1683
1684// MockWebView_Reload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reload'
1685type MockWebView_Reload_Call struct {
1686 *mock.Call
1687}
1688
1689// Reload is a helper method to define mock.On call
1690// - ctx context.Context
1691func (_e *MockWebView_Expecter) Reload(ctx interface{}) *MockWebView_Reload_Call {
1692 return &MockWebView_Reload_Call{Call: _e.mock.On("Reload", ctx)}
1693}
1694
1695func (_c *MockWebView_Reload_Call) Run(run func(ctx context.Context)) *MockWebView_Reload_Call {
1696 _c.Call.Run(func(args mock.Arguments) {
1697 var arg0 context.Context
1698 if args[0] != nil {
1699 arg0 = args[0].(context.Context)
1700 }
1701 run(
1702 arg0,
1703 )
1704 })
1705 return _c
1706}
1707
1708func (_c *MockWebView_Reload_Call) Return(err error) *MockWebView_Reload_Call {
1709 _c.Call.Return(err)
1710 return _c
1711}
1712
1713func (_c *MockWebView_Reload_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_Reload_Call {
1714 _c.Call.Return(run)
1715 return _c
1716}
1717
1718// ReloadBypassCache provides a mock function for the type MockWebView
1719func (_mock *MockWebView) ReloadBypassCache(ctx context.Context) error {
1720 ret := _mock.Called(ctx)
1721
1722 if len(ret) == 0 {
1723 panic("no return value specified for ReloadBypassCache")
1724 }
1725
1726 var r0 error
1727 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
1728 r0 = returnFunc(ctx)
1729 } else {
1730 r0 = ret.Error(0)
1731 }
1732 return r0
1733}
1734
1735// MockWebView_ReloadBypassCache_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReloadBypassCache'
1736type MockWebView_ReloadBypassCache_Call struct {
1737 *mock.Call
1738}
1739
1740// ReloadBypassCache is a helper method to define mock.On call
1741// - ctx context.Context
1742func (_e *MockWebView_Expecter) ReloadBypassCache(ctx interface{}) *MockWebView_ReloadBypassCache_Call {
1743 return &MockWebView_ReloadBypassCache_Call{Call: _e.mock.On("ReloadBypassCache", ctx)}
1744}
1745
1746func (_c *MockWebView_ReloadBypassCache_Call) Run(run func(ctx context.Context)) *MockWebView_ReloadBypassCache_Call {
1747 _c.Call.Run(func(args mock.Arguments) {
1748 var arg0 context.Context
1749 if args[0] != nil {
1750 arg0 = args[0].(context.Context)
1751 }
1752 run(
1753 arg0,
1754 )
1755 })
1756 return _c
1757}
1758
1759func (_c *MockWebView_ReloadBypassCache_Call) Return(err error) *MockWebView_ReloadBypassCache_Call {
1760 _c.Call.Return(err)
1761 return _c
1762}
1763
1764func (_c *MockWebView_ReloadBypassCache_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_ReloadBypassCache_Call {
1765 _c.Call.Return(run)
1766 return _c
1767}
1768
1769// SetCallbacks provides a mock function for the type MockWebView
1770func (_mock *MockWebView) SetCallbacks(callbacks *port.WebViewCallbacks) {
1771 _mock.Called(callbacks)
1772 return
1773}
1774
1775// MockWebView_SetCallbacks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCallbacks'
1776type MockWebView_SetCallbacks_Call struct {
1777 *mock.Call
1778}
1779
1780// SetCallbacks is a helper method to define mock.On call
1781// - callbacks *port.WebViewCallbacks
1782func (_e *MockWebView_Expecter) SetCallbacks(callbacks interface{}) *MockWebView_SetCallbacks_Call {
1783 return &MockWebView_SetCallbacks_Call{Call: _e.mock.On("SetCallbacks", callbacks)}
1784}
1785
1786func (_c *MockWebView_SetCallbacks_Call) Run(run func(callbacks *port.WebViewCallbacks)) *MockWebView_SetCallbacks_Call {
1787 _c.Call.Run(func(args mock.Arguments) {
1788 var arg0 *port.WebViewCallbacks
1789 if args[0] != nil {
1790 arg0 = args[0].(*port.WebViewCallbacks)
1791 }
1792 run(
1793 arg0,
1794 )
1795 })
1796 return _c
1797}
1798
1799func (_c *MockWebView_SetCallbacks_Call) Return() *MockWebView_SetCallbacks_Call {
1800 _c.Call.Return()
1801 return _c
1802}
1803
1804func (_c *MockWebView_SetCallbacks_Call) RunAndReturn(run func(callbacks *port.WebViewCallbacks)) *MockWebView_SetCallbacks_Call {
1805 _c.Run(run)
1806 return _c
1807}
1808
1809// SetZoomLevel provides a mock function for the type MockWebView
1810func (_mock *MockWebView) SetZoomLevel(ctx context.Context, level float64) error {
1811 ret := _mock.Called(ctx, level)
1812
1813 if len(ret) == 0 {
1814 panic("no return value specified for SetZoomLevel")
1815 }
1816
1817 var r0 error
1818 if returnFunc, ok := ret.Get(0).(func(context.Context, float64) error); ok {
1819 r0 = returnFunc(ctx, level)
1820 } else {
1821 r0 = ret.Error(0)
1822 }
1823 return r0
1824}
1825
1826// MockWebView_SetZoomLevel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetZoomLevel'
1827type MockWebView_SetZoomLevel_Call struct {
1828 *mock.Call
1829}
1830
1831// SetZoomLevel is a helper method to define mock.On call
1832// - ctx context.Context
1833// - level float64
1834func (_e *MockWebView_Expecter) SetZoomLevel(ctx interface{}, level interface{}) *MockWebView_SetZoomLevel_Call {
1835 return &MockWebView_SetZoomLevel_Call{Call: _e.mock.On("SetZoomLevel", ctx, level)}
1836}
1837
1838func (_c *MockWebView_SetZoomLevel_Call) Run(run func(ctx context.Context, level float64)) *MockWebView_SetZoomLevel_Call {
1839 _c.Call.Run(func(args mock.Arguments) {
1840 var arg0 context.Context
1841 if args[0] != nil {
1842 arg0 = args[0].(context.Context)
1843 }
1844 var arg1 float64
1845 if args[1] != nil {
1846 arg1 = args[1].(float64)
1847 }
1848 run(
1849 arg0,
1850 arg1,
1851 )
1852 })
1853 return _c
1854}
1855
1856func (_c *MockWebView_SetZoomLevel_Call) Return(err error) *MockWebView_SetZoomLevel_Call {
1857 _c.Call.Return(err)
1858 return _c
1859}
1860
1861func (_c *MockWebView_SetZoomLevel_Call) RunAndReturn(run func(ctx context.Context, level float64) error) *MockWebView_SetZoomLevel_Call {
1862 _c.Call.Return(run)
1863 return _c
1864}
1865
1866// State provides a mock function for the type MockWebView
1867func (_mock *MockWebView) State() port.WebViewState {
1868 ret := _mock.Called()
1869
1870 if len(ret) == 0 {
1871 panic("no return value specified for State")
1872 }
1873
1874 var r0 port.WebViewState
1875 if returnFunc, ok := ret.Get(0).(func() port.WebViewState); ok {
1876 r0 = returnFunc()
1877 } else {
1878 r0 = ret.Get(0).(port.WebViewState)
1879 }
1880 return r0
1881}
1882
1883// MockWebView_State_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'State'
1884type MockWebView_State_Call struct {
1885 *mock.Call
1886}
1887
1888// State is a helper method to define mock.On call
1889func (_e *MockWebView_Expecter) State() *MockWebView_State_Call {
1890 return &MockWebView_State_Call{Call: _e.mock.On("State")}
1891}
1892
1893func (_c *MockWebView_State_Call) Run(run func()) *MockWebView_State_Call {
1894 _c.Call.Run(func(args mock.Arguments) {
1895 run()
1896 })
1897 return _c
1898}
1899
1900func (_c *MockWebView_State_Call) Return(webViewState port.WebViewState) *MockWebView_State_Call {
1901 _c.Call.Return(webViewState)
1902 return _c
1903}
1904
1905func (_c *MockWebView_State_Call) RunAndReturn(run func() port.WebViewState) *MockWebView_State_Call {
1906 _c.Call.Return(run)
1907 return _c
1908}
1909
1910// Stop provides a mock function for the type MockWebView
1911func (_mock *MockWebView) Stop(ctx context.Context) error {
1912 ret := _mock.Called(ctx)
1913
1914 if len(ret) == 0 {
1915 panic("no return value specified for Stop")
1916 }
1917
1918 var r0 error
1919 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
1920 r0 = returnFunc(ctx)
1921 } else {
1922 r0 = ret.Error(0)
1923 }
1924 return r0
1925}
1926
1927// MockWebView_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
1928type MockWebView_Stop_Call struct {
1929 *mock.Call
1930}
1931
1932// Stop is a helper method to define mock.On call
1933// - ctx context.Context
1934func (_e *MockWebView_Expecter) Stop(ctx interface{}) *MockWebView_Stop_Call {
1935 return &MockWebView_Stop_Call{Call: _e.mock.On("Stop", ctx)}
1936}
1937
1938func (_c *MockWebView_Stop_Call) Run(run func(ctx context.Context)) *MockWebView_Stop_Call {
1939 _c.Call.Run(func(args mock.Arguments) {
1940 var arg0 context.Context
1941 if args[0] != nil {
1942 arg0 = args[0].(context.Context)
1943 }
1944 run(
1945 arg0,
1946 )
1947 })
1948 return _c
1949}
1950
1951func (_c *MockWebView_Stop_Call) Return(err error) *MockWebView_Stop_Call {
1952 _c.Call.Return(err)
1953 return _c
1954}
1955
1956func (_c *MockWebView_Stop_Call) RunAndReturn(run func(ctx context.Context) error) *MockWebView_Stop_Call {
1957 _c.Call.Return(run)
1958 return _c
1959}
1960
1961// Title provides a mock function for the type MockWebView
1962func (_mock *MockWebView) Title() string {
1963 ret := _mock.Called()
1964
1965 if len(ret) == 0 {
1966 panic("no return value specified for Title")
1967 }
1968
1969 var r0 string
1970 if returnFunc, ok := ret.Get(0).(func() string); ok {
1971 r0 = returnFunc()
1972 } else {
1973 r0 = ret.Get(0).(string)
1974 }
1975 return r0
1976}
1977
1978// MockWebView_Title_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Title'
1979type MockWebView_Title_Call struct {
1980 *mock.Call
1981}
1982
1983// Title is a helper method to define mock.On call
1984func (_e *MockWebView_Expecter) Title() *MockWebView_Title_Call {
1985 return &MockWebView_Title_Call{Call: _e.mock.On("Title")}
1986}
1987
1988func (_c *MockWebView_Title_Call) Run(run func()) *MockWebView_Title_Call {
1989 _c.Call.Run(func(args mock.Arguments) {
1990 run()
1991 })
1992 return _c
1993}
1994
1995func (_c *MockWebView_Title_Call) Return(s string) *MockWebView_Title_Call {
1996 _c.Call.Return(s)
1997 return _c
1998}
1999
2000func (_c *MockWebView_Title_Call) RunAndReturn(run func() string) *MockWebView_Title_Call {
2001 _c.Call.Return(run)
2002 return _c
2003}
2004
2005// URI provides a mock function for the type MockWebView
2006func (_mock *MockWebView) URI() string {
2007 ret := _mock.Called()
2008
2009 if len(ret) == 0 {
2010 panic("no return value specified for URI")
2011 }
2012
2013 var r0 string
2014 if returnFunc, ok := ret.Get(0).(func() string); ok {
2015 r0 = returnFunc()
2016 } else {
2017 r0 = ret.Get(0).(string)
2018 }
2019 return r0
2020}
2021
2022// MockWebView_URI_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'URI'
2023type MockWebView_URI_Call struct {
2024 *mock.Call
2025}
2026
2027// URI is a helper method to define mock.On call
2028func (_e *MockWebView_Expecter) URI() *MockWebView_URI_Call {
2029 return &MockWebView_URI_Call{Call: _e.mock.On("URI")}
2030}
2031
2032func (_c *MockWebView_URI_Call) Run(run func()) *MockWebView_URI_Call {
2033 _c.Call.Run(func(args mock.Arguments) {
2034 run()
2035 })
2036 return _c
2037}
2038
2039func (_c *MockWebView_URI_Call) Return(s string) *MockWebView_URI_Call {
2040 _c.Call.Return(s)
2041 return _c
2042}
2043
2044func (_c *MockWebView_URI_Call) RunAndReturn(run func() string) *MockWebView_URI_Call {
2045 _c.Call.Return(run)
2046 return _c
2047}
2048
2049// 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.
2050// The first argument is typically a *testing.T value.
2051func NewMockWebViewPool(t interface {
2052 mock.TestingT
2053 Cleanup(func())
2054}) *MockWebViewPool {
2055 mock := &MockWebViewPool{}
2056 mock.Mock.Test(t)
2057
2058 t.Cleanup(func() { mock.AssertExpectations(t) })
2059
2060 return mock
2061}
2062
2063// MockWebViewPool is an autogenerated mock type for the WebViewPool type
2064type MockWebViewPool struct {
2065 mock.Mock
2066}
2067
2068type MockWebViewPool_Expecter struct {
2069 mock *mock.Mock
2070}
2071
2072func (_m *MockWebViewPool) EXPECT() *MockWebViewPool_Expecter {
2073 return &MockWebViewPool_Expecter{mock: &_m.Mock}
2074}
2075
2076// Acquire provides a mock function for the type MockWebViewPool
2077func (_mock *MockWebViewPool) Acquire(ctx context.Context) (port.WebView, error) {
2078 ret := _mock.Called(ctx)
2079
2080 if len(ret) == 0 {
2081 panic("no return value specified for Acquire")
2082 }
2083
2084 var r0 port.WebView
2085 var r1 error
2086 if returnFunc, ok := ret.Get(0).(func(context.Context) (port.WebView, error)); ok {
2087 return returnFunc(ctx)
2088 }
2089 if returnFunc, ok := ret.Get(0).(func(context.Context) port.WebView); ok {
2090 r0 = returnFunc(ctx)
2091 } else {
2092 if ret.Get(0) != nil {
2093 r0 = ret.Get(0).(port.WebView)
2094 }
2095 }
2096 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
2097 r1 = returnFunc(ctx)
2098 } else {
2099 r1 = ret.Error(1)
2100 }
2101 return r0, r1
2102}
2103
2104// MockWebViewPool_Acquire_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Acquire'
2105type MockWebViewPool_Acquire_Call struct {
2106 *mock.Call
2107}
2108
2109// Acquire is a helper method to define mock.On call
2110// - ctx context.Context
2111func (_e *MockWebViewPool_Expecter) Acquire(ctx interface{}) *MockWebViewPool_Acquire_Call {
2112 return &MockWebViewPool_Acquire_Call{Call: _e.mock.On("Acquire", ctx)}
2113}
2114
2115func (_c *MockWebViewPool_Acquire_Call) Run(run func(ctx context.Context)) *MockWebViewPool_Acquire_Call {
2116 _c.Call.Run(func(args mock.Arguments) {
2117 var arg0 context.Context
2118 if args[0] != nil {
2119 arg0 = args[0].(context.Context)
2120 }
2121 run(
2122 arg0,
2123 )
2124 })
2125 return _c
2126}
2127
2128func (_c *MockWebViewPool_Acquire_Call) Return(webView port.WebView, err error) *MockWebViewPool_Acquire_Call {
2129 _c.Call.Return(webView, err)
2130 return _c
2131}
2132
2133func (_c *MockWebViewPool_Acquire_Call) RunAndReturn(run func(ctx context.Context) (port.WebView, error)) *MockWebViewPool_Acquire_Call {
2134 _c.Call.Return(run)
2135 return _c
2136}
2137
2138// Close provides a mock function for the type MockWebViewPool
2139func (_mock *MockWebViewPool) Close() {
2140 _mock.Called()
2141 return
2142}
2143
2144// MockWebViewPool_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
2145type MockWebViewPool_Close_Call struct {
2146 *mock.Call
2147}
2148
2149// Close is a helper method to define mock.On call
2150func (_e *MockWebViewPool_Expecter) Close() *MockWebViewPool_Close_Call {
2151 return &MockWebViewPool_Close_Call{Call: _e.mock.On("Close")}
2152}
2153
2154func (_c *MockWebViewPool_Close_Call) Run(run func()) *MockWebViewPool_Close_Call {
2155 _c.Call.Run(func(args mock.Arguments) {
2156 run()
2157 })
2158 return _c
2159}
2160
2161func (_c *MockWebViewPool_Close_Call) Return() *MockWebViewPool_Close_Call {
2162 _c.Call.Return()
2163 return _c
2164}
2165
2166func (_c *MockWebViewPool_Close_Call) RunAndReturn(run func()) *MockWebViewPool_Close_Call {
2167 _c.Run(run)
2168 return _c
2169}
2170
2171// Prewarm provides a mock function for the type MockWebViewPool
2172func (_mock *MockWebViewPool) Prewarm(count int) {
2173 _mock.Called(count)
2174 return
2175}
2176
2177// MockWebViewPool_Prewarm_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Prewarm'
2178type MockWebViewPool_Prewarm_Call struct {
2179 *mock.Call
2180}
2181
2182// Prewarm is a helper method to define mock.On call
2183// - count int
2184func (_e *MockWebViewPool_Expecter) Prewarm(count interface{}) *MockWebViewPool_Prewarm_Call {
2185 return &MockWebViewPool_Prewarm_Call{Call: _e.mock.On("Prewarm", count)}
2186}
2187
2188func (_c *MockWebViewPool_Prewarm_Call) Run(run func(count int)) *MockWebViewPool_Prewarm_Call {
2189 _c.Call.Run(func(args mock.Arguments) {
2190 var arg0 int
2191 if args[0] != nil {
2192 arg0 = args[0].(int)
2193 }
2194 run(
2195 arg0,
2196 )
2197 })
2198 return _c
2199}
2200
2201func (_c *MockWebViewPool_Prewarm_Call) Return() *MockWebViewPool_Prewarm_Call {
2202 _c.Call.Return()
2203 return _c
2204}
2205
2206func (_c *MockWebViewPool_Prewarm_Call) RunAndReturn(run func(count int)) *MockWebViewPool_Prewarm_Call {
2207 _c.Run(run)
2208 return _c
2209}
2210
2211// Release provides a mock function for the type MockWebViewPool
2212func (_mock *MockWebViewPool) Release(wv port.WebView) {
2213 _mock.Called(wv)
2214 return
2215}
2216
2217// MockWebViewPool_Release_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Release'
2218type MockWebViewPool_Release_Call struct {
2219 *mock.Call
2220}
2221
2222// Release is a helper method to define mock.On call
2223// - wv port.WebView
2224func (_e *MockWebViewPool_Expecter) Release(wv interface{}) *MockWebViewPool_Release_Call {
2225 return &MockWebViewPool_Release_Call{Call: _e.mock.On("Release", wv)}
2226}
2227
2228func (_c *MockWebViewPool_Release_Call) Run(run func(wv port.WebView)) *MockWebViewPool_Release_Call {
2229 _c.Call.Run(func(args mock.Arguments) {
2230 var arg0 port.WebView
2231 if args[0] != nil {
2232 arg0 = args[0].(port.WebView)
2233 }
2234 run(
2235 arg0,
2236 )
2237 })
2238 return _c
2239}
2240
2241func (_c *MockWebViewPool_Release_Call) Return() *MockWebViewPool_Release_Call {
2242 _c.Call.Return()
2243 return _c
2244}
2245
2246func (_c *MockWebViewPool_Release_Call) RunAndReturn(run func(wv port.WebView)) *MockWebViewPool_Release_Call {
2247 _c.Run(run)
2248 return _c
2249}
2250
2251// Size provides a mock function for the type MockWebViewPool
2252func (_mock *MockWebViewPool) Size() int {
2253 ret := _mock.Called()
2254
2255 if len(ret) == 0 {
2256 panic("no return value specified for Size")
2257 }
2258
2259 var r0 int
2260 if returnFunc, ok := ret.Get(0).(func() int); ok {
2261 r0 = returnFunc()
2262 } else {
2263 r0 = ret.Get(0).(int)
2264 }
2265 return r0
2266}
2267
2268// MockWebViewPool_Size_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Size'
2269type MockWebViewPool_Size_Call struct {
2270 *mock.Call
2271}
2272
2273// Size is a helper method to define mock.On call
2274func (_e *MockWebViewPool_Expecter) Size() *MockWebViewPool_Size_Call {
2275 return &MockWebViewPool_Size_Call{Call: _e.mock.On("Size")}
2276}
2277
2278func (_c *MockWebViewPool_Size_Call) Run(run func()) *MockWebViewPool_Size_Call {
2279 _c.Call.Run(func(args mock.Arguments) {
2280 run()
2281 })
2282 return _c
2283}
2284
2285func (_c *MockWebViewPool_Size_Call) Return(n int) *MockWebViewPool_Size_Call {
2286 _c.Call.Return(n)
2287 return _c
2288}
2289
2290func (_c *MockWebViewPool_Size_Call) RunAndReturn(run func() int) *MockWebViewPool_Size_Call {
2291 _c.Call.Return(run)
2292 return _c
2293}
2294
2295// 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.
2296// The first argument is typically a *testing.T value.
2297func NewMockWebViewFactory(t interface {
2298 mock.TestingT
2299 Cleanup(func())
2300}) *MockWebViewFactory {
2301 mock := &MockWebViewFactory{}
2302 mock.Mock.Test(t)
2303
2304 t.Cleanup(func() { mock.AssertExpectations(t) })
2305
2306 return mock
2307}
2308
2309// MockWebViewFactory is an autogenerated mock type for the WebViewFactory type
2310type MockWebViewFactory struct {
2311 mock.Mock
2312}
2313
2314type MockWebViewFactory_Expecter struct {
2315 mock *mock.Mock
2316}
2317
2318func (_m *MockWebViewFactory) EXPECT() *MockWebViewFactory_Expecter {
2319 return &MockWebViewFactory_Expecter{mock: &_m.Mock}
2320}
2321
2322// Create provides a mock function for the type MockWebViewFactory
2323func (_mock *MockWebViewFactory) Create(ctx context.Context) (port.WebView, error) {
2324 ret := _mock.Called(ctx)
2325
2326 if len(ret) == 0 {
2327 panic("no return value specified for Create")
2328 }
2329
2330 var r0 port.WebView
2331 var r1 error
2332 if returnFunc, ok := ret.Get(0).(func(context.Context) (port.WebView, error)); ok {
2333 return returnFunc(ctx)
2334 }
2335 if returnFunc, ok := ret.Get(0).(func(context.Context) port.WebView); ok {
2336 r0 = returnFunc(ctx)
2337 } else {
2338 if ret.Get(0) != nil {
2339 r0 = ret.Get(0).(port.WebView)
2340 }
2341 }
2342 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
2343 r1 = returnFunc(ctx)
2344 } else {
2345 r1 = ret.Error(1)
2346 }
2347 return r0, r1
2348}
2349
2350// MockWebViewFactory_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'
2351type MockWebViewFactory_Create_Call struct {
2352 *mock.Call
2353}
2354
2355// Create is a helper method to define mock.On call
2356// - ctx context.Context
2357func (_e *MockWebViewFactory_Expecter) Create(ctx interface{}) *MockWebViewFactory_Create_Call {
2358 return &MockWebViewFactory_Create_Call{Call: _e.mock.On("Create", ctx)}
2359}
2360
2361func (_c *MockWebViewFactory_Create_Call) Run(run func(ctx context.Context)) *MockWebViewFactory_Create_Call {
2362 _c.Call.Run(func(args mock.Arguments) {
2363 var arg0 context.Context
2364 if args[0] != nil {
2365 arg0 = args[0].(context.Context)
2366 }
2367 run(
2368 arg0,
2369 )
2370 })
2371 return _c
2372}
2373
2374func (_c *MockWebViewFactory_Create_Call) Return(webView port.WebView, err error) *MockWebViewFactory_Create_Call {
2375 _c.Call.Return(webView, err)
2376 return _c
2377}
2378
2379func (_c *MockWebViewFactory_Create_Call) RunAndReturn(run func(ctx context.Context) (port.WebView, error)) *MockWebViewFactory_Create_Call {
2380 _c.Call.Return(run)
2381 return _c
2382}
2383
2384// CreateRelated provides a mock function for the type MockWebViewFactory
2385func (_mock *MockWebViewFactory) CreateRelated(ctx context.Context, parentID port.WebViewID) (port.WebView, error) {
2386 ret := _mock.Called(ctx, parentID)
2387
2388 if len(ret) == 0 {
2389 panic("no return value specified for CreateRelated")
2390 }
2391
2392 var r0 port.WebView
2393 var r1 error
2394 if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebViewID) (port.WebView, error)); ok {
2395 return returnFunc(ctx, parentID)
2396 }
2397 if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebViewID) port.WebView); ok {
2398 r0 = returnFunc(ctx, parentID)
2399 } else {
2400 if ret.Get(0) != nil {
2401 r0 = ret.Get(0).(port.WebView)
2402 }
2403 }
2404 if returnFunc, ok := ret.Get(1).(func(context.Context, port.WebViewID) error); ok {
2405 r1 = returnFunc(ctx, parentID)
2406 } else {
2407 r1 = ret.Error(1)
2408 }
2409 return r0, r1
2410}
2411
2412// MockWebViewFactory_CreateRelated_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRelated'
2413type MockWebViewFactory_CreateRelated_Call struct {
2414 *mock.Call
2415}
2416
2417// CreateRelated is a helper method to define mock.On call
2418// - ctx context.Context
2419// - parentID port.WebViewID
2420func (_e *MockWebViewFactory_Expecter) CreateRelated(ctx interface{}, parentID interface{}) *MockWebViewFactory_CreateRelated_Call {
2421 return &MockWebViewFactory_CreateRelated_Call{Call: _e.mock.On("CreateRelated", ctx, parentID)}
2422}
2423
2424func (_c *MockWebViewFactory_CreateRelated_Call) Run(run func(ctx context.Context, parentID port.WebViewID)) *MockWebViewFactory_CreateRelated_Call {
2425 _c.Call.Run(func(args mock.Arguments) {
2426 var arg0 context.Context
2427 if args[0] != nil {
2428 arg0 = args[0].(context.Context)
2429 }
2430 var arg1 port.WebViewID
2431 if args[1] != nil {
2432 arg1 = args[1].(port.WebViewID)
2433 }
2434 run(
2435 arg0,
2436 arg1,
2437 )
2438 })
2439 return _c
2440}
2441
2442func (_c *MockWebViewFactory_CreateRelated_Call) Return(webView port.WebView, err error) *MockWebViewFactory_CreateRelated_Call {
2443 _c.Call.Return(webView, err)
2444 return _c
2445}
2446
2447func (_c *MockWebViewFactory_CreateRelated_Call) RunAndReturn(run func(ctx context.Context, parentID port.WebViewID) (port.WebView, error)) *MockWebViewFactory_CreateRelated_Call {
2448 _c.Call.Return(run)
2449 return _c
2450}