1// Code generated by mockery; DO NOT EDIT.
2// github.com/vektra/mockery
3// template: testify
4
5package portsmocks
6
7import (
8 "context"
9 "log/slog"
10
11 "github.com/bnema/vev/internal/domain"
12 "github.com/bnema/vev/internal/ports"
13 mock "github.com/stretchr/testify/mock"
14)
15
16// NewMockRemoteDialerFactory creates a new instance of MockRemoteDialerFactory. 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 NewMockRemoteDialerFactory(t interface {
19 mock.TestingT
20 Cleanup(func())
21}) *MockRemoteDialerFactory {
22 mock := &MockRemoteDialerFactory{}
23 mock.Mock.Test(t)
24
25 t.Cleanup(func() { mock.AssertExpectations(t) })
26
27 return mock
28}
29
30// MockRemoteDialerFactory is an autogenerated mock type for the RemoteDialerFactory type
31type MockRemoteDialerFactory struct {
32 mock.Mock
33}
34
35type MockRemoteDialerFactory_Expecter struct {
36 mock *mock.Mock
37}
38
39func (_m *MockRemoteDialerFactory) EXPECT() *MockRemoteDialerFactory_Expecter {
40 return &MockRemoteDialerFactory_Expecter{mock: &_m.Mock}
41}
42
43// DialerForRemote provides a mock function for the type MockRemoteDialerFactory
44func (_mock *MockRemoteDialerFactory) DialerForRemote(target string, session string, mode ports.RemoteTransportMode, log *slog.Logger) (ports.Dialer, error) {
45 ret := _mock.Called(target, session, mode, log)
46
47 if len(ret) == 0 {
48 panic("no return value specified for DialerForRemote")
49 }
50
51 var r0 ports.Dialer
52 var r1 error
53 if returnFunc, ok := ret.Get(0).(func(string, string, ports.RemoteTransportMode, *slog.Logger) (ports.Dialer, error)); ok {
54 return returnFunc(target, session, mode, log)
55 }
56 if returnFunc, ok := ret.Get(0).(func(string, string, ports.RemoteTransportMode, *slog.Logger) ports.Dialer); ok {
57 r0 = returnFunc(target, session, mode, log)
58 } else {
59 if ret.Get(0) != nil {
60 r0 = ret.Get(0).(ports.Dialer)
61 }
62 }
63 if returnFunc, ok := ret.Get(1).(func(string, string, ports.RemoteTransportMode, *slog.Logger) error); ok {
64 r1 = returnFunc(target, session, mode, log)
65 } else {
66 r1 = ret.Error(1)
67 }
68 return r0, r1
69}
70
71// MockRemoteDialerFactory_DialerForRemote_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DialerForRemote'
72type MockRemoteDialerFactory_DialerForRemote_Call struct {
73 *mock.Call
74}
75
76// DialerForRemote is a helper method to define mock.On call
77// - target string
78// - session string
79// - mode ports.RemoteTransportMode
80// - log *slog.Logger
81func (_e *MockRemoteDialerFactory_Expecter) DialerForRemote(target any, session any, mode any, log any) *MockRemoteDialerFactory_DialerForRemote_Call {
82 return &MockRemoteDialerFactory_DialerForRemote_Call{Call: _e.mock.On("DialerForRemote", target, session, mode, log)}
83}
84
85func (_c *MockRemoteDialerFactory_DialerForRemote_Call) Run(run func(target string, session string, mode ports.RemoteTransportMode, log *slog.Logger)) *MockRemoteDialerFactory_DialerForRemote_Call {
86 _c.Call.Run(func(args mock.Arguments) {
87 var arg0 string
88 if args[0] != nil {
89 arg0 = args[0].(string)
90 }
91 var arg1 string
92 if args[1] != nil {
93 arg1 = args[1].(string)
94 }
95 var arg2 ports.RemoteTransportMode
96 if args[2] != nil {
97 arg2 = args[2].(ports.RemoteTransportMode)
98 }
99 var arg3 *slog.Logger
100 if args[3] != nil {
101 arg3 = args[3].(*slog.Logger)
102 }
103 run(
104 arg0,
105 arg1,
106 arg2,
107 arg3,
108 )
109 })
110 return _c
111}
112
113func (_c *MockRemoteDialerFactory_DialerForRemote_Call) Return(dialer ports.Dialer, err error) *MockRemoteDialerFactory_DialerForRemote_Call {
114 _c.Call.Return(dialer, err)
115 return _c
116}
117
118func (_c *MockRemoteDialerFactory_DialerForRemote_Call) RunAndReturn(run func(target string, session string, mode ports.RemoteTransportMode, log *slog.Logger) (ports.Dialer, error)) *MockRemoteDialerFactory_DialerForRemote_Call {
119 _c.Call.Return(run)
120 return _c
121}
122
123// NewMockRemoteHostStore creates a new instance of MockRemoteHostStore. 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 NewMockRemoteHostStore(t interface {
126 mock.TestingT
127 Cleanup(func())
128}) *MockRemoteHostStore {
129 mock := &MockRemoteHostStore{}
130 mock.Mock.Test(t)
131
132 t.Cleanup(func() { mock.AssertExpectations(t) })
133
134 return mock
135}
136
137// MockRemoteHostStore is an autogenerated mock type for the RemoteHostStore type
138type MockRemoteHostStore struct {
139 mock.Mock
140}
141
142type MockRemoteHostStore_Expecter struct {
143 mock *mock.Mock
144}
145
146func (_m *MockRemoteHostStore) EXPECT() *MockRemoteHostStore_Expecter {
147 return &MockRemoteHostStore_Expecter{mock: &_m.Mock}
148}
149
150// AddPinned provides a mock function for the type MockRemoteHostStore
151func (_mock *MockRemoteHostStore) AddPinned(target string) error {
152 ret := _mock.Called(target)
153
154 if len(ret) == 0 {
155 panic("no return value specified for AddPinned")
156 }
157
158 var r0 error
159 if returnFunc, ok := ret.Get(0).(func(string) error); ok {
160 r0 = returnFunc(target)
161 } else {
162 r0 = ret.Error(0)
163 }
164 return r0
165}
166
167// MockRemoteHostStore_AddPinned_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddPinned'
168type MockRemoteHostStore_AddPinned_Call struct {
169 *mock.Call
170}
171
172// AddPinned is a helper method to define mock.On call
173// - target string
174func (_e *MockRemoteHostStore_Expecter) AddPinned(target any) *MockRemoteHostStore_AddPinned_Call {
175 return &MockRemoteHostStore_AddPinned_Call{Call: _e.mock.On("AddPinned", target)}
176}
177
178func (_c *MockRemoteHostStore_AddPinned_Call) Run(run func(target string)) *MockRemoteHostStore_AddPinned_Call {
179 _c.Call.Run(func(args mock.Arguments) {
180 var arg0 string
181 if args[0] != nil {
182 arg0 = args[0].(string)
183 }
184 run(
185 arg0,
186 )
187 })
188 return _c
189}
190
191func (_c *MockRemoteHostStore_AddPinned_Call) Return(err error) *MockRemoteHostStore_AddPinned_Call {
192 _c.Call.Return(err)
193 return _c
194}
195
196func (_c *MockRemoteHostStore_AddPinned_Call) RunAndReturn(run func(target string) error) *MockRemoteHostStore_AddPinned_Call {
197 _c.Call.Return(run)
198 return _c
199}
200
201// Forget provides a mock function for the type MockRemoteHostStore
202func (_mock *MockRemoteHostStore) Forget(target string) error {
203 ret := _mock.Called(target)
204
205 if len(ret) == 0 {
206 panic("no return value specified for Forget")
207 }
208
209 var r0 error
210 if returnFunc, ok := ret.Get(0).(func(string) error); ok {
211 r0 = returnFunc(target)
212 } else {
213 r0 = ret.Error(0)
214 }
215 return r0
216}
217
218// MockRemoteHostStore_Forget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Forget'
219type MockRemoteHostStore_Forget_Call struct {
220 *mock.Call
221}
222
223// Forget is a helper method to define mock.On call
224// - target string
225func (_e *MockRemoteHostStore_Expecter) Forget(target any) *MockRemoteHostStore_Forget_Call {
226 return &MockRemoteHostStore_Forget_Call{Call: _e.mock.On("Forget", target)}
227}
228
229func (_c *MockRemoteHostStore_Forget_Call) Run(run func(target string)) *MockRemoteHostStore_Forget_Call {
230 _c.Call.Run(func(args mock.Arguments) {
231 var arg0 string
232 if args[0] != nil {
233 arg0 = args[0].(string)
234 }
235 run(
236 arg0,
237 )
238 })
239 return _c
240}
241
242func (_c *MockRemoteHostStore_Forget_Call) Return(err error) *MockRemoteHostStore_Forget_Call {
243 _c.Call.Return(err)
244 return _c
245}
246
247func (_c *MockRemoteHostStore_Forget_Call) RunAndReturn(run func(target string) error) *MockRemoteHostStore_Forget_Call {
248 _c.Call.Return(run)
249 return _c
250}
251
252// Hosts provides a mock function for the type MockRemoteHostStore
253func (_mock *MockRemoteHostStore) Hosts() ([]string, []string, error) {
254 ret := _mock.Called()
255
256 if len(ret) == 0 {
257 panic("no return value specified for Hosts")
258 }
259
260 var r0 []string
261 var r1 []string
262 var r2 error
263 if returnFunc, ok := ret.Get(0).(func() ([]string, []string, error)); ok {
264 return returnFunc()
265 }
266 if returnFunc, ok := ret.Get(0).(func() []string); ok {
267 r0 = returnFunc()
268 } else {
269 if ret.Get(0) != nil {
270 r0 = ret.Get(0).([]string)
271 }
272 }
273 if returnFunc, ok := ret.Get(1).(func() []string); ok {
274 r1 = returnFunc()
275 } else {
276 if ret.Get(1) != nil {
277 r1 = ret.Get(1).([]string)
278 }
279 }
280 if returnFunc, ok := ret.Get(2).(func() error); ok {
281 r2 = returnFunc()
282 } else {
283 r2 = ret.Error(2)
284 }
285 return r0, r1, r2
286}
287
288// MockRemoteHostStore_Hosts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hosts'
289type MockRemoteHostStore_Hosts_Call struct {
290 *mock.Call
291}
292
293// Hosts is a helper method to define mock.On call
294func (_e *MockRemoteHostStore_Expecter) Hosts() *MockRemoteHostStore_Hosts_Call {
295 return &MockRemoteHostStore_Hosts_Call{Call: _e.mock.On("Hosts")}
296}
297
298func (_c *MockRemoteHostStore_Hosts_Call) Run(run func()) *MockRemoteHostStore_Hosts_Call {
299 _c.Call.Run(func(args mock.Arguments) {
300 run()
301 })
302 return _c
303}
304
305func (_c *MockRemoteHostStore_Hosts_Call) Return(pinned []string, learned []string, err error) *MockRemoteHostStore_Hosts_Call {
306 _c.Call.Return(pinned, learned, err)
307 return _c
308}
309
310func (_c *MockRemoteHostStore_Hosts_Call) RunAndReturn(run func() ([]string, []string, error)) *MockRemoteHostStore_Hosts_Call {
311 _c.Call.Return(run)
312 return _c
313}
314
315// Remember provides a mock function for the type MockRemoteHostStore
316func (_mock *MockRemoteHostStore) Remember(target string) error {
317 ret := _mock.Called(target)
318
319 if len(ret) == 0 {
320 panic("no return value specified for Remember")
321 }
322
323 var r0 error
324 if returnFunc, ok := ret.Get(0).(func(string) error); ok {
325 r0 = returnFunc(target)
326 } else {
327 r0 = ret.Error(0)
328 }
329 return r0
330}
331
332// MockRemoteHostStore_Remember_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Remember'
333type MockRemoteHostStore_Remember_Call struct {
334 *mock.Call
335}
336
337// Remember is a helper method to define mock.On call
338// - target string
339func (_e *MockRemoteHostStore_Expecter) Remember(target any) *MockRemoteHostStore_Remember_Call {
340 return &MockRemoteHostStore_Remember_Call{Call: _e.mock.On("Remember", target)}
341}
342
343func (_c *MockRemoteHostStore_Remember_Call) Run(run func(target string)) *MockRemoteHostStore_Remember_Call {
344 _c.Call.Run(func(args mock.Arguments) {
345 var arg0 string
346 if args[0] != nil {
347 arg0 = args[0].(string)
348 }
349 run(
350 arg0,
351 )
352 })
353 return _c
354}
355
356func (_c *MockRemoteHostStore_Remember_Call) Return(err error) *MockRemoteHostStore_Remember_Call {
357 _c.Call.Return(err)
358 return _c
359}
360
361func (_c *MockRemoteHostStore_Remember_Call) RunAndReturn(run func(target string) error) *MockRemoteHostStore_Remember_Call {
362 _c.Call.Return(run)
363 return _c
364}
365
366// Remove provides a mock function for the type MockRemoteHostStore
367func (_mock *MockRemoteHostStore) Remove(target string) (bool, error) {
368 ret := _mock.Called(target)
369
370 if len(ret) == 0 {
371 panic("no return value specified for Remove")
372 }
373
374 var r0 bool
375 var r1 error
376 if returnFunc, ok := ret.Get(0).(func(string) (bool, error)); ok {
377 return returnFunc(target)
378 }
379 if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
380 r0 = returnFunc(target)
381 } else {
382 r0 = ret.Get(0).(bool)
383 }
384 if returnFunc, ok := ret.Get(1).(func(string) error); ok {
385 r1 = returnFunc(target)
386 } else {
387 r1 = ret.Error(1)
388 }
389 return r0, r1
390}
391
392// MockRemoteHostStore_Remove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Remove'
393type MockRemoteHostStore_Remove_Call struct {
394 *mock.Call
395}
396
397// Remove is a helper method to define mock.On call
398// - target string
399func (_e *MockRemoteHostStore_Expecter) Remove(target any) *MockRemoteHostStore_Remove_Call {
400 return &MockRemoteHostStore_Remove_Call{Call: _e.mock.On("Remove", target)}
401}
402
403func (_c *MockRemoteHostStore_Remove_Call) Run(run func(target string)) *MockRemoteHostStore_Remove_Call {
404 _c.Call.Run(func(args mock.Arguments) {
405 var arg0 string
406 if args[0] != nil {
407 arg0 = args[0].(string)
408 }
409 run(
410 arg0,
411 )
412 })
413 return _c
414}
415
416func (_c *MockRemoteHostStore_Remove_Call) Return(deleted bool, err error) *MockRemoteHostStore_Remove_Call {
417 _c.Call.Return(deleted, err)
418 return _c
419}
420
421func (_c *MockRemoteHostStore_Remove_Call) RunAndReturn(run func(target string) (bool, error)) *MockRemoteHostStore_Remove_Call {
422 _c.Call.Return(run)
423 return _c
424}
425
426// RemovePinned provides a mock function for the type MockRemoteHostStore
427func (_mock *MockRemoteHostStore) RemovePinned(target string) error {
428 ret := _mock.Called(target)
429
430 if len(ret) == 0 {
431 panic("no return value specified for RemovePinned")
432 }
433
434 var r0 error
435 if returnFunc, ok := ret.Get(0).(func(string) error); ok {
436 r0 = returnFunc(target)
437 } else {
438 r0 = ret.Error(0)
439 }
440 return r0
441}
442
443// MockRemoteHostStore_RemovePinned_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemovePinned'
444type MockRemoteHostStore_RemovePinned_Call struct {
445 *mock.Call
446}
447
448// RemovePinned is a helper method to define mock.On call
449// - target string
450func (_e *MockRemoteHostStore_Expecter) RemovePinned(target any) *MockRemoteHostStore_RemovePinned_Call {
451 return &MockRemoteHostStore_RemovePinned_Call{Call: _e.mock.On("RemovePinned", target)}
452}
453
454func (_c *MockRemoteHostStore_RemovePinned_Call) Run(run func(target string)) *MockRemoteHostStore_RemovePinned_Call {
455 _c.Call.Run(func(args mock.Arguments) {
456 var arg0 string
457 if args[0] != nil {
458 arg0 = args[0].(string)
459 }
460 run(
461 arg0,
462 )
463 })
464 return _c
465}
466
467func (_c *MockRemoteHostStore_RemovePinned_Call) Return(err error) *MockRemoteHostStore_RemovePinned_Call {
468 _c.Call.Return(err)
469 return _c
470}
471
472func (_c *MockRemoteHostStore_RemovePinned_Call) RunAndReturn(run func(target string) error) *MockRemoteHostStore_RemovePinned_Call {
473 _c.Call.Return(run)
474 return _c
475}
476
477// NewMockRemoteHostLearner creates a new instance of MockRemoteHostLearner. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
478// The first argument is typically a *testing.T value.
479func NewMockRemoteHostLearner(t interface {
480 mock.TestingT
481 Cleanup(func())
482}) *MockRemoteHostLearner {
483 mock := &MockRemoteHostLearner{}
484 mock.Mock.Test(t)
485
486 t.Cleanup(func() { mock.AssertExpectations(t) })
487
488 return mock
489}
490
491// MockRemoteHostLearner is an autogenerated mock type for the RemoteHostLearner type
492type MockRemoteHostLearner struct {
493 mock.Mock
494}
495
496type MockRemoteHostLearner_Expecter struct {
497 mock *mock.Mock
498}
499
500func (_m *MockRemoteHostLearner) EXPECT() *MockRemoteHostLearner_Expecter {
501 return &MockRemoteHostLearner_Expecter{mock: &_m.Mock}
502}
503
504// RememberRemoteHost provides a mock function for the type MockRemoteHostLearner
505func (_mock *MockRemoteHostLearner) RememberRemoteHost() error {
506 ret := _mock.Called()
507
508 if len(ret) == 0 {
509 panic("no return value specified for RememberRemoteHost")
510 }
511
512 var r0 error
513 if returnFunc, ok := ret.Get(0).(func() error); ok {
514 r0 = returnFunc()
515 } else {
516 r0 = ret.Error(0)
517 }
518 return r0
519}
520
521// MockRemoteHostLearner_RememberRemoteHost_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RememberRemoteHost'
522type MockRemoteHostLearner_RememberRemoteHost_Call struct {
523 *mock.Call
524}
525
526// RememberRemoteHost is a helper method to define mock.On call
527func (_e *MockRemoteHostLearner_Expecter) RememberRemoteHost() *MockRemoteHostLearner_RememberRemoteHost_Call {
528 return &MockRemoteHostLearner_RememberRemoteHost_Call{Call: _e.mock.On("RememberRemoteHost")}
529}
530
531func (_c *MockRemoteHostLearner_RememberRemoteHost_Call) Run(run func()) *MockRemoteHostLearner_RememberRemoteHost_Call {
532 _c.Call.Run(func(args mock.Arguments) {
533 run()
534 })
535 return _c
536}
537
538func (_c *MockRemoteHostLearner_RememberRemoteHost_Call) Return(err error) *MockRemoteHostLearner_RememberRemoteHost_Call {
539 _c.Call.Return(err)
540 return _c
541}
542
543func (_c *MockRemoteHostLearner_RememberRemoteHost_Call) RunAndReturn(run func() error) *MockRemoteHostLearner_RememberRemoteHost_Call {
544 _c.Call.Return(run)
545 return _c
546}
547
548// NewMockRemoteCatalogClient creates a new instance of MockRemoteCatalogClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
549// The first argument is typically a *testing.T value.
550func NewMockRemoteCatalogClient(t interface {
551 mock.TestingT
552 Cleanup(func())
553}) *MockRemoteCatalogClient {
554 mock := &MockRemoteCatalogClient{}
555 mock.Mock.Test(t)
556
557 t.Cleanup(func() { mock.AssertExpectations(t) })
558
559 return mock
560}
561
562// MockRemoteCatalogClient is an autogenerated mock type for the RemoteCatalogClient type
563type MockRemoteCatalogClient struct {
564 mock.Mock
565}
566
567type MockRemoteCatalogClient_Expecter struct {
568 mock *mock.Mock
569}
570
571func (_m *MockRemoteCatalogClient) EXPECT() *MockRemoteCatalogClient_Expecter {
572 return &MockRemoteCatalogClient_Expecter{mock: &_m.Mock}
573}
574
575// List provides a mock function for the type MockRemoteCatalogClient
576func (_mock *MockRemoteCatalogClient) List(ctx context.Context, target string) (ports.RemoteCatalog, error) {
577 ret := _mock.Called(ctx, target)
578
579 if len(ret) == 0 {
580 panic("no return value specified for List")
581 }
582
583 var r0 ports.RemoteCatalog
584 var r1 error
585 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (ports.RemoteCatalog, error)); ok {
586 return returnFunc(ctx, target)
587 }
588 if returnFunc, ok := ret.Get(0).(func(context.Context, string) ports.RemoteCatalog); ok {
589 r0 = returnFunc(ctx, target)
590 } else {
591 r0 = ret.Get(0).(ports.RemoteCatalog)
592 }
593 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
594 r1 = returnFunc(ctx, target)
595 } else {
596 r1 = ret.Error(1)
597 }
598 return r0, r1
599}
600
601// MockRemoteCatalogClient_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List'
602type MockRemoteCatalogClient_List_Call struct {
603 *mock.Call
604}
605
606// List is a helper method to define mock.On call
607// - ctx context.Context
608// - target string
609func (_e *MockRemoteCatalogClient_Expecter) List(ctx any, target any) *MockRemoteCatalogClient_List_Call {
610 return &MockRemoteCatalogClient_List_Call{Call: _e.mock.On("List", ctx, target)}
611}
612
613func (_c *MockRemoteCatalogClient_List_Call) Run(run func(ctx context.Context, target string)) *MockRemoteCatalogClient_List_Call {
614 _c.Call.Run(func(args mock.Arguments) {
615 var arg0 context.Context
616 if args[0] != nil {
617 arg0 = args[0].(context.Context)
618 }
619 var arg1 string
620 if args[1] != nil {
621 arg1 = args[1].(string)
622 }
623 run(
624 arg0,
625 arg1,
626 )
627 })
628 return _c
629}
630
631func (_c *MockRemoteCatalogClient_List_Call) Return(remoteCatalog ports.RemoteCatalog, err error) *MockRemoteCatalogClient_List_Call {
632 _c.Call.Return(remoteCatalog, err)
633 return _c
634}
635
636func (_c *MockRemoteCatalogClient_List_Call) RunAndReturn(run func(ctx context.Context, target string) (ports.RemoteCatalog, error)) *MockRemoteCatalogClient_List_Call {
637 _c.Call.Return(run)
638 return _c
639}
640
641// NewMockRemotePreviewClient creates a new instance of MockRemotePreviewClient. 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 NewMockRemotePreviewClient(t interface {
644 mock.TestingT
645 Cleanup(func())
646}) *MockRemotePreviewClient {
647 mock := &MockRemotePreviewClient{}
648 mock.Mock.Test(t)
649
650 t.Cleanup(func() { mock.AssertExpectations(t) })
651
652 return mock
653}
654
655// MockRemotePreviewClient is an autogenerated mock type for the RemotePreviewClient type
656type MockRemotePreviewClient struct {
657 mock.Mock
658}
659
660type MockRemotePreviewClient_Expecter struct {
661 mock *mock.Mock
662}
663
664func (_m *MockRemotePreviewClient) EXPECT() *MockRemotePreviewClient_Expecter {
665 return &MockRemotePreviewClient_Expecter{mock: &_m.Mock}
666}
667
668// Preview provides a mock function for the type MockRemotePreviewClient
669func (_mock *MockRemotePreviewClient) Preview(ctx context.Context, target domain.RemoteSessionTarget, width uint16, height uint16) (ports.RemotePreview, error) {
670 ret := _mock.Called(ctx, target, width, height)
671
672 if len(ret) == 0 {
673 panic("no return value specified for Preview")
674 }
675
676 var r0 ports.RemotePreview
677 var r1 error
678 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteSessionTarget, uint16, uint16) (ports.RemotePreview, error)); ok {
679 return returnFunc(ctx, target, width, height)
680 }
681 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteSessionTarget, uint16, uint16) ports.RemotePreview); ok {
682 r0 = returnFunc(ctx, target, width, height)
683 } else {
684 r0 = ret.Get(0).(ports.RemotePreview)
685 }
686 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RemoteSessionTarget, uint16, uint16) error); ok {
687 r1 = returnFunc(ctx, target, width, height)
688 } else {
689 r1 = ret.Error(1)
690 }
691 return r0, r1
692}
693
694// MockRemotePreviewClient_Preview_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Preview'
695type MockRemotePreviewClient_Preview_Call struct {
696 *mock.Call
697}
698
699// Preview is a helper method to define mock.On call
700// - ctx context.Context
701// - target domain.RemoteSessionTarget
702// - width uint16
703// - height uint16
704func (_e *MockRemotePreviewClient_Expecter) Preview(ctx any, target any, width any, height any) *MockRemotePreviewClient_Preview_Call {
705 return &MockRemotePreviewClient_Preview_Call{Call: _e.mock.On("Preview", ctx, target, width, height)}
706}
707
708func (_c *MockRemotePreviewClient_Preview_Call) Run(run func(ctx context.Context, target domain.RemoteSessionTarget, width uint16, height uint16)) *MockRemotePreviewClient_Preview_Call {
709 _c.Call.Run(func(args mock.Arguments) {
710 var arg0 context.Context
711 if args[0] != nil {
712 arg0 = args[0].(context.Context)
713 }
714 var arg1 domain.RemoteSessionTarget
715 if args[1] != nil {
716 arg1 = args[1].(domain.RemoteSessionTarget)
717 }
718 var arg2 uint16
719 if args[2] != nil {
720 arg2 = args[2].(uint16)
721 }
722 var arg3 uint16
723 if args[3] != nil {
724 arg3 = args[3].(uint16)
725 }
726 run(
727 arg0,
728 arg1,
729 arg2,
730 arg3,
731 )
732 })
733 return _c
734}
735
736func (_c *MockRemotePreviewClient_Preview_Call) Return(remotePreview ports.RemotePreview, err error) *MockRemotePreviewClient_Preview_Call {
737 _c.Call.Return(remotePreview, err)
738 return _c
739}
740
741func (_c *MockRemotePreviewClient_Preview_Call) RunAndReturn(run func(ctx context.Context, target domain.RemoteSessionTarget, width uint16, height uint16) (ports.RemotePreview, error)) *MockRemotePreviewClient_Preview_Call {
742 _c.Call.Return(run)
743 return _c
744}
745
746// NewMockRemoteCatalogCache creates a new instance of MockRemoteCatalogCache. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
747// The first argument is typically a *testing.T value.
748func NewMockRemoteCatalogCache(t interface {
749 mock.TestingT
750 Cleanup(func())
751}) *MockRemoteCatalogCache {
752 mock := &MockRemoteCatalogCache{}
753 mock.Mock.Test(t)
754
755 t.Cleanup(func() { mock.AssertExpectations(t) })
756
757 return mock
758}
759
760// MockRemoteCatalogCache is an autogenerated mock type for the RemoteCatalogCache type
761type MockRemoteCatalogCache struct {
762 mock.Mock
763}
764
765type MockRemoteCatalogCache_Expecter struct {
766 mock *mock.Mock
767}
768
769func (_m *MockRemoteCatalogCache) EXPECT() *MockRemoteCatalogCache_Expecter {
770 return &MockRemoteCatalogCache_Expecter{mock: &_m.Mock}
771}
772
773// Load provides a mock function for the type MockRemoteCatalogCache
774func (_mock *MockRemoteCatalogCache) Load() ([]ports.RemoteCatalogCacheEntry, error) {
775 ret := _mock.Called()
776
777 if len(ret) == 0 {
778 panic("no return value specified for Load")
779 }
780
781 var r0 []ports.RemoteCatalogCacheEntry
782 var r1 error
783 if returnFunc, ok := ret.Get(0).(func() ([]ports.RemoteCatalogCacheEntry, error)); ok {
784 return returnFunc()
785 }
786 if returnFunc, ok := ret.Get(0).(func() []ports.RemoteCatalogCacheEntry); ok {
787 r0 = returnFunc()
788 } else {
789 if ret.Get(0) != nil {
790 r0 = ret.Get(0).([]ports.RemoteCatalogCacheEntry)
791 }
792 }
793 if returnFunc, ok := ret.Get(1).(func() error); ok {
794 r1 = returnFunc()
795 } else {
796 r1 = ret.Error(1)
797 }
798 return r0, r1
799}
800
801// MockRemoteCatalogCache_Load_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Load'
802type MockRemoteCatalogCache_Load_Call struct {
803 *mock.Call
804}
805
806// Load is a helper method to define mock.On call
807func (_e *MockRemoteCatalogCache_Expecter) Load() *MockRemoteCatalogCache_Load_Call {
808 return &MockRemoteCatalogCache_Load_Call{Call: _e.mock.On("Load")}
809}
810
811func (_c *MockRemoteCatalogCache_Load_Call) Run(run func()) *MockRemoteCatalogCache_Load_Call {
812 _c.Call.Run(func(args mock.Arguments) {
813 run()
814 })
815 return _c
816}
817
818func (_c *MockRemoteCatalogCache_Load_Call) Return(remoteCatalogCacheEntrys []ports.RemoteCatalogCacheEntry, err error) *MockRemoteCatalogCache_Load_Call {
819 _c.Call.Return(remoteCatalogCacheEntrys, err)
820 return _c
821}
822
823func (_c *MockRemoteCatalogCache_Load_Call) RunAndReturn(run func() ([]ports.RemoteCatalogCacheEntry, error)) *MockRemoteCatalogCache_Load_Call {
824 _c.Call.Return(run)
825 return _c
826}
827
828// Store provides a mock function for the type MockRemoteCatalogCache
829func (_mock *MockRemoteCatalogCache) Store(remoteCatalogCacheEntrys []ports.RemoteCatalogCacheEntry) error {
830 ret := _mock.Called(remoteCatalogCacheEntrys)
831
832 if len(ret) == 0 {
833 panic("no return value specified for Store")
834 }
835
836 var r0 error
837 if returnFunc, ok := ret.Get(0).(func([]ports.RemoteCatalogCacheEntry) error); ok {
838 r0 = returnFunc(remoteCatalogCacheEntrys)
839 } else {
840 r0 = ret.Error(0)
841 }
842 return r0
843}
844
845// MockRemoteCatalogCache_Store_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Store'
846type MockRemoteCatalogCache_Store_Call struct {
847 *mock.Call
848}
849
850// Store is a helper method to define mock.On call
851// - remoteCatalogCacheEntrys []ports.RemoteCatalogCacheEntry
852func (_e *MockRemoteCatalogCache_Expecter) Store(remoteCatalogCacheEntrys any) *MockRemoteCatalogCache_Store_Call {
853 return &MockRemoteCatalogCache_Store_Call{Call: _e.mock.On("Store", remoteCatalogCacheEntrys)}
854}
855
856func (_c *MockRemoteCatalogCache_Store_Call) Run(run func(remoteCatalogCacheEntrys []ports.RemoteCatalogCacheEntry)) *MockRemoteCatalogCache_Store_Call {
857 _c.Call.Run(func(args mock.Arguments) {
858 var arg0 []ports.RemoteCatalogCacheEntry
859 if args[0] != nil {
860 arg0 = args[0].([]ports.RemoteCatalogCacheEntry)
861 }
862 run(
863 arg0,
864 )
865 })
866 return _c
867}
868
869func (_c *MockRemoteCatalogCache_Store_Call) Return(err error) *MockRemoteCatalogCache_Store_Call {
870 _c.Call.Return(err)
871 return _c
872}
873
874func (_c *MockRemoteCatalogCache_Store_Call) RunAndReturn(run func(remoteCatalogCacheEntrys []ports.RemoteCatalogCacheEntry) error) *MockRemoteCatalogCache_Store_Call {
875 _c.Call.Return(run)
876 return _c
877}