1// Code generated by mockery; DO NOT EDIT.
2// github.com/vektra/mockery
3// template: testify
4
5package portsmocks
6
7import (
8 "context"
9
10 "github.com/bnema/vev/internal/domain"
11 "github.com/bnema/vev/internal/ports"
12 mock "github.com/stretchr/testify/mock"
13)
14
15// NewMockBrokerSubscription creates a new instance of MockBrokerSubscription. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
16// The first argument is typically a *testing.T value.
17func NewMockBrokerSubscription(t interface {
18 mock.TestingT
19 Cleanup(func())
20}) *MockBrokerSubscription {
21 if helper, ok := t.(interface{ Helper() }); ok {
22 helper.Helper()
23 }
24
25 mock := &MockBrokerSubscription{}
26 mock.Mock.Test(t)
27
28 t.Cleanup(func() {
29 if helper, ok := t.(interface{ Helper() }); ok {
30 helper.Helper()
31 }
32 mock.AssertExpectations(t)
33 })
34
35 return mock
36}
37
38// MockBrokerSubscription is an autogenerated mock type for the BrokerSubscription type
39type MockBrokerSubscription struct {
40 mock.Mock
41}
42
43type MockBrokerSubscription_Expecter struct {
44 mock *mock.Mock
45}
46
47func (_m *MockBrokerSubscription) EXPECT() *MockBrokerSubscription_Expecter {
48 return &MockBrokerSubscription_Expecter{mock: &_m.Mock}
49}
50
51// Changed provides a mock function for the type MockBrokerSubscription
52func (_mock *MockBrokerSubscription) Changed() <-chan struct{} {
53 ret := _mock.Called()
54
55 if len(ret) == 0 {
56 panic("no return value specified for Changed")
57 }
58
59 var r0 <-chan struct{}
60 if returnFunc, ok := ret.Get(0).(func() <-chan struct{}); ok {
61 r0 = returnFunc()
62 } else {
63 if ret.Get(0) != nil {
64 r0 = ret.Get(0).(<-chan struct{})
65 }
66 }
67 return r0
68}
69
70// MockBrokerSubscription_Changed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Changed'
71type MockBrokerSubscription_Changed_Call struct {
72 *mock.Call
73}
74
75// Changed is a helper method to define mock.On call
76func (_e *MockBrokerSubscription_Expecter) Changed() *MockBrokerSubscription_Changed_Call {
77 return &MockBrokerSubscription_Changed_Call{Call: _e.mock.On("Changed")}
78}
79
80func (_c *MockBrokerSubscription_Changed_Call) Run(run func()) *MockBrokerSubscription_Changed_Call {
81 _c.Call.Run(func(args mock.Arguments) {
82 run()
83 })
84 return _c
85}
86
87func (_c *MockBrokerSubscription_Changed_Call) Return(valCh <-chan struct{}) *MockBrokerSubscription_Changed_Call {
88 _c.Call.Return(valCh)
89 return _c
90}
91
92func (_c *MockBrokerSubscription_Changed_Call) RunAndReturn(run func() <-chan struct{}) *MockBrokerSubscription_Changed_Call {
93 _c.Call.Return(run)
94 return _c
95}
96
97// Close provides a mock function for the type MockBrokerSubscription
98func (_mock *MockBrokerSubscription) Close() {
99 _mock.Called()
100 return
101}
102
103// MockBrokerSubscription_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
104type MockBrokerSubscription_Close_Call struct {
105 *mock.Call
106}
107
108// Close is a helper method to define mock.On call
109func (_e *MockBrokerSubscription_Expecter) Close() *MockBrokerSubscription_Close_Call {
110 return &MockBrokerSubscription_Close_Call{Call: _e.mock.On("Close")}
111}
112
113func (_c *MockBrokerSubscription_Close_Call) Run(run func()) *MockBrokerSubscription_Close_Call {
114 _c.Call.Run(func(args mock.Arguments) {
115 run()
116 })
117 return _c
118}
119
120func (_c *MockBrokerSubscription_Close_Call) Return() *MockBrokerSubscription_Close_Call {
121 _c.Call.Return()
122 return _c
123}
124
125func (_c *MockBrokerSubscription_Close_Call) RunAndReturn(run func()) *MockBrokerSubscription_Close_Call {
126 _c.Run(run)
127 return _c
128}
129
130// NewMockBrokerPreviewSubscription creates a new instance of MockBrokerPreviewSubscription. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
131// The first argument is typically a *testing.T value.
132func NewMockBrokerPreviewSubscription(t interface {
133 mock.TestingT
134 Cleanup(func())
135}) *MockBrokerPreviewSubscription {
136 if helper, ok := t.(interface{ Helper() }); ok {
137 helper.Helper()
138 }
139
140 mock := &MockBrokerPreviewSubscription{}
141 mock.Mock.Test(t)
142
143 t.Cleanup(func() {
144 if helper, ok := t.(interface{ Helper() }); ok {
145 helper.Helper()
146 }
147 mock.AssertExpectations(t)
148 })
149
150 return mock
151}
152
153// MockBrokerPreviewSubscription is an autogenerated mock type for the BrokerPreviewSubscription type
154type MockBrokerPreviewSubscription struct {
155 mock.Mock
156}
157
158type MockBrokerPreviewSubscription_Expecter struct {
159 mock *mock.Mock
160}
161
162func (_m *MockBrokerPreviewSubscription) EXPECT() *MockBrokerPreviewSubscription_Expecter {
163 return &MockBrokerPreviewSubscription_Expecter{mock: &_m.Mock}
164}
165
166// Changed provides a mock function for the type MockBrokerPreviewSubscription
167func (_mock *MockBrokerPreviewSubscription) Changed() <-chan struct{} {
168 ret := _mock.Called()
169
170 if len(ret) == 0 {
171 panic("no return value specified for Changed")
172 }
173
174 var r0 <-chan struct{}
175 if returnFunc, ok := ret.Get(0).(func() <-chan struct{}); ok {
176 r0 = returnFunc()
177 } else {
178 if ret.Get(0) != nil {
179 r0 = ret.Get(0).(<-chan struct{})
180 }
181 }
182 return r0
183}
184
185// MockBrokerPreviewSubscription_Changed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Changed'
186type MockBrokerPreviewSubscription_Changed_Call struct {
187 *mock.Call
188}
189
190// Changed is a helper method to define mock.On call
191func (_e *MockBrokerPreviewSubscription_Expecter) Changed() *MockBrokerPreviewSubscription_Changed_Call {
192 return &MockBrokerPreviewSubscription_Changed_Call{Call: _e.mock.On("Changed")}
193}
194
195func (_c *MockBrokerPreviewSubscription_Changed_Call) Run(run func()) *MockBrokerPreviewSubscription_Changed_Call {
196 _c.Call.Run(func(args mock.Arguments) {
197 run()
198 })
199 return _c
200}
201
202func (_c *MockBrokerPreviewSubscription_Changed_Call) Return(valCh <-chan struct{}) *MockBrokerPreviewSubscription_Changed_Call {
203 _c.Call.Return(valCh)
204 return _c
205}
206
207func (_c *MockBrokerPreviewSubscription_Changed_Call) RunAndReturn(run func() <-chan struct{}) *MockBrokerPreviewSubscription_Changed_Call {
208 _c.Call.Return(run)
209 return _c
210}
211
212// Close provides a mock function for the type MockBrokerPreviewSubscription
213func (_mock *MockBrokerPreviewSubscription) Close() {
214 _mock.Called()
215 return
216}
217
218// MockBrokerPreviewSubscription_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
219type MockBrokerPreviewSubscription_Close_Call struct {
220 *mock.Call
221}
222
223// Close is a helper method to define mock.On call
224func (_e *MockBrokerPreviewSubscription_Expecter) Close() *MockBrokerPreviewSubscription_Close_Call {
225 return &MockBrokerPreviewSubscription_Close_Call{Call: _e.mock.On("Close")}
226}
227
228func (_c *MockBrokerPreviewSubscription_Close_Call) Run(run func()) *MockBrokerPreviewSubscription_Close_Call {
229 _c.Call.Run(func(args mock.Arguments) {
230 run()
231 })
232 return _c
233}
234
235func (_c *MockBrokerPreviewSubscription_Close_Call) Return() *MockBrokerPreviewSubscription_Close_Call {
236 _c.Call.Return()
237 return _c
238}
239
240func (_c *MockBrokerPreviewSubscription_Close_Call) RunAndReturn(run func()) *MockBrokerPreviewSubscription_Close_Call {
241 _c.Run(run)
242 return _c
243}
244
245// Latest provides a mock function for the type MockBrokerPreviewSubscription
246func (_mock *MockBrokerPreviewSubscription) Latest() ports.BrokerPreviewPublication {
247 ret := _mock.Called()
248
249 if len(ret) == 0 {
250 panic("no return value specified for Latest")
251 }
252
253 var r0 ports.BrokerPreviewPublication
254 if returnFunc, ok := ret.Get(0).(func() ports.BrokerPreviewPublication); ok {
255 r0 = returnFunc()
256 } else {
257 r0 = ret.Get(0).(ports.BrokerPreviewPublication)
258 }
259 return r0
260}
261
262// MockBrokerPreviewSubscription_Latest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Latest'
263type MockBrokerPreviewSubscription_Latest_Call struct {
264 *mock.Call
265}
266
267// Latest is a helper method to define mock.On call
268func (_e *MockBrokerPreviewSubscription_Expecter) Latest() *MockBrokerPreviewSubscription_Latest_Call {
269 return &MockBrokerPreviewSubscription_Latest_Call{Call: _e.mock.On("Latest")}
270}
271
272func (_c *MockBrokerPreviewSubscription_Latest_Call) Run(run func()) *MockBrokerPreviewSubscription_Latest_Call {
273 _c.Call.Run(func(args mock.Arguments) {
274 run()
275 })
276 return _c
277}
278
279func (_c *MockBrokerPreviewSubscription_Latest_Call) Return(brokerPreviewPublication ports.BrokerPreviewPublication) *MockBrokerPreviewSubscription_Latest_Call {
280 _c.Call.Return(brokerPreviewPublication)
281 return _c
282}
283
284func (_c *MockBrokerPreviewSubscription_Latest_Call) RunAndReturn(run func() ports.BrokerPreviewPublication) *MockBrokerPreviewSubscription_Latest_Call {
285 _c.Call.Return(run)
286 return _c
287}
288
289// NewMockBrokerConnection creates a new instance of MockBrokerConnection. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
290// The first argument is typically a *testing.T value.
291func NewMockBrokerConnection(t interface {
292 mock.TestingT
293 Cleanup(func())
294}) *MockBrokerConnection {
295 if helper, ok := t.(interface{ Helper() }); ok {
296 helper.Helper()
297 }
298
299 mock := &MockBrokerConnection{}
300 mock.Mock.Test(t)
301
302 t.Cleanup(func() {
303 if helper, ok := t.(interface{ Helper() }); ok {
304 helper.Helper()
305 }
306 mock.AssertExpectations(t)
307 })
308
309 return mock
310}
311
312// MockBrokerConnection is an autogenerated mock type for the BrokerConnection type
313type MockBrokerConnection struct {
314 mock.Mock
315}
316
317type MockBrokerConnection_Expecter struct {
318 mock *mock.Mock
319}
320
321func (_m *MockBrokerConnection) EXPECT() *MockBrokerConnection_Expecter {
322 return &MockBrokerConnection_Expecter{mock: &_m.Mock}
323}
324
325// Close provides a mock function for the type MockBrokerConnection
326func (_mock *MockBrokerConnection) Close() error {
327 ret := _mock.Called()
328
329 if len(ret) == 0 {
330 panic("no return value specified for Close")
331 }
332
333 var r0 error
334 if returnFunc, ok := ret.Get(0).(func() error); ok {
335 r0 = returnFunc()
336 } else {
337 r0 = ret.Error(0)
338 }
339 return r0
340}
341
342// MockBrokerConnection_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
343type MockBrokerConnection_Close_Call struct {
344 *mock.Call
345}
346
347// Close is a helper method to define mock.On call
348func (_e *MockBrokerConnection_Expecter) Close() *MockBrokerConnection_Close_Call {
349 return &MockBrokerConnection_Close_Call{Call: _e.mock.On("Close")}
350}
351
352func (_c *MockBrokerConnection_Close_Call) Run(run func()) *MockBrokerConnection_Close_Call {
353 _c.Call.Run(func(args mock.Arguments) {
354 run()
355 })
356 return _c
357}
358
359func (_c *MockBrokerConnection_Close_Call) Return(err error) *MockBrokerConnection_Close_Call {
360 _c.Call.Return(err)
361 return _c
362}
363
364func (_c *MockBrokerConnection_Close_Call) RunAndReturn(run func() error) *MockBrokerConnection_Close_Call {
365 _c.Call.Return(run)
366 return _c
367}
368
369// ConnectionID provides a mock function for the type MockBrokerConnection
370func (_mock *MockBrokerConnection) ConnectionID() ports.BrokerConnectionID {
371 ret := _mock.Called()
372
373 if len(ret) == 0 {
374 panic("no return value specified for ConnectionID")
375 }
376
377 var r0 ports.BrokerConnectionID
378 if returnFunc, ok := ret.Get(0).(func() ports.BrokerConnectionID); ok {
379 r0 = returnFunc()
380 } else {
381 if ret.Get(0) != nil {
382 r0 = ret.Get(0).(ports.BrokerConnectionID)
383 }
384 }
385 return r0
386}
387
388// MockBrokerConnection_ConnectionID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectionID'
389type MockBrokerConnection_ConnectionID_Call struct {
390 *mock.Call
391}
392
393// ConnectionID is a helper method to define mock.On call
394func (_e *MockBrokerConnection_Expecter) ConnectionID() *MockBrokerConnection_ConnectionID_Call {
395 return &MockBrokerConnection_ConnectionID_Call{Call: _e.mock.On("ConnectionID")}
396}
397
398func (_c *MockBrokerConnection_ConnectionID_Call) Run(run func()) *MockBrokerConnection_ConnectionID_Call {
399 _c.Call.Run(func(args mock.Arguments) {
400 run()
401 })
402 return _c
403}
404
405func (_c *MockBrokerConnection_ConnectionID_Call) Return(brokerConnectionID ports.BrokerConnectionID) *MockBrokerConnection_ConnectionID_Call {
406 _c.Call.Return(brokerConnectionID)
407 return _c
408}
409
410func (_c *MockBrokerConnection_ConnectionID_Call) RunAndReturn(run func() ports.BrokerConnectionID) *MockBrokerConnection_ConnectionID_Call {
411 _c.Call.Return(run)
412 return _c
413}
414
415// Done provides a mock function for the type MockBrokerConnection
416func (_mock *MockBrokerConnection) Done() <-chan struct{} {
417 ret := _mock.Called()
418
419 if len(ret) == 0 {
420 panic("no return value specified for Done")
421 }
422
423 var r0 <-chan struct{}
424 if returnFunc, ok := ret.Get(0).(func() <-chan struct{}); ok {
425 r0 = returnFunc()
426 } else {
427 if ret.Get(0) != nil {
428 r0 = ret.Get(0).(<-chan struct{})
429 }
430 }
431 return r0
432}
433
434// MockBrokerConnection_Done_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Done'
435type MockBrokerConnection_Done_Call struct {
436 *mock.Call
437}
438
439// Done is a helper method to define mock.On call
440func (_e *MockBrokerConnection_Expecter) Done() *MockBrokerConnection_Done_Call {
441 return &MockBrokerConnection_Done_Call{Call: _e.mock.On("Done")}
442}
443
444func (_c *MockBrokerConnection_Done_Call) Run(run func()) *MockBrokerConnection_Done_Call {
445 _c.Call.Run(func(args mock.Arguments) {
446 run()
447 })
448 return _c
449}
450
451func (_c *MockBrokerConnection_Done_Call) Return(valCh <-chan struct{}) *MockBrokerConnection_Done_Call {
452 _c.Call.Return(valCh)
453 return _c
454}
455
456func (_c *MockBrokerConnection_Done_Call) RunAndReturn(run func() <-chan struct{}) *MockBrokerConnection_Done_Call {
457 _c.Call.Return(run)
458 return _c
459}
460
461// Err provides a mock function for the type MockBrokerConnection
462func (_mock *MockBrokerConnection) Err() error {
463 ret := _mock.Called()
464
465 if len(ret) == 0 {
466 panic("no return value specified for Err")
467 }
468
469 var r0 error
470 if returnFunc, ok := ret.Get(0).(func() error); ok {
471 r0 = returnFunc()
472 } else {
473 r0 = ret.Error(0)
474 }
475 return r0
476}
477
478// MockBrokerConnection_Err_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Err'
479type MockBrokerConnection_Err_Call struct {
480 *mock.Call
481}
482
483// Err is a helper method to define mock.On call
484func (_e *MockBrokerConnection_Expecter) Err() *MockBrokerConnection_Err_Call {
485 return &MockBrokerConnection_Err_Call{Call: _e.mock.On("Err")}
486}
487
488func (_c *MockBrokerConnection_Err_Call) Run(run func()) *MockBrokerConnection_Err_Call {
489 _c.Call.Run(func(args mock.Arguments) {
490 run()
491 })
492 return _c
493}
494
495func (_c *MockBrokerConnection_Err_Call) Return(err error) *MockBrokerConnection_Err_Call {
496 _c.Call.Return(err)
497 return _c
498}
499
500func (_c *MockBrokerConnection_Err_Call) RunAndReturn(run func() error) *MockBrokerConnection_Err_Call {
501 _c.Call.Return(run)
502 return _c
503}
504
505// NextStreamID provides a mock function for the type MockBrokerConnection
506func (_mock *MockBrokerConnection) NextStreamID() (ports.BrokerStreamID, error) {
507 ret := _mock.Called()
508
509 if len(ret) == 0 {
510 panic("no return value specified for NextStreamID")
511 }
512
513 var r0 ports.BrokerStreamID
514 var r1 error
515 if returnFunc, ok := ret.Get(0).(func() (ports.BrokerStreamID, error)); ok {
516 return returnFunc()
517 }
518 if returnFunc, ok := ret.Get(0).(func() ports.BrokerStreamID); ok {
519 r0 = returnFunc()
520 } else {
521 r0 = ret.Get(0).(ports.BrokerStreamID)
522 }
523 if returnFunc, ok := ret.Get(1).(func() error); ok {
524 r1 = returnFunc()
525 } else {
526 r1 = ret.Error(1)
527 }
528 return r0, r1
529}
530
531// MockBrokerConnection_NextStreamID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NextStreamID'
532type MockBrokerConnection_NextStreamID_Call struct {
533 *mock.Call
534}
535
536// NextStreamID is a helper method to define mock.On call
537func (_e *MockBrokerConnection_Expecter) NextStreamID() *MockBrokerConnection_NextStreamID_Call {
538 return &MockBrokerConnection_NextStreamID_Call{Call: _e.mock.On("NextStreamID")}
539}
540
541func (_c *MockBrokerConnection_NextStreamID_Call) Run(run func()) *MockBrokerConnection_NextStreamID_Call {
542 _c.Call.Run(func(args mock.Arguments) {
543 run()
544 })
545 return _c
546}
547
548func (_c *MockBrokerConnection_NextStreamID_Call) Return(brokerStreamID ports.BrokerStreamID, err error) *MockBrokerConnection_NextStreamID_Call {
549 _c.Call.Return(brokerStreamID, err)
550 return _c
551}
552
553func (_c *MockBrokerConnection_NextStreamID_Call) RunAndReturn(run func() (ports.BrokerStreamID, error)) *MockBrokerConnection_NextStreamID_Call {
554 _c.Call.Return(run)
555 return _c
556}
557
558// NewMockBrokerObservation creates a new instance of MockBrokerObservation. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
559// The first argument is typically a *testing.T value.
560func NewMockBrokerObservation(t interface {
561 mock.TestingT
562 Cleanup(func())
563}) *MockBrokerObservation {
564 if helper, ok := t.(interface{ Helper() }); ok {
565 helper.Helper()
566 }
567
568 mock := &MockBrokerObservation{}
569 mock.Mock.Test(t)
570
571 t.Cleanup(func() {
572 if helper, ok := t.(interface{ Helper() }); ok {
573 helper.Helper()
574 }
575 mock.AssertExpectations(t)
576 })
577
578 return mock
579}
580
581// MockBrokerObservation is an autogenerated mock type for the BrokerObservation type
582type MockBrokerObservation struct {
583 mock.Mock
584}
585
586type MockBrokerObservation_Expecter struct {
587 mock *mock.Mock
588}
589
590func (_m *MockBrokerObservation) EXPECT() *MockBrokerObservation_Expecter {
591 return &MockBrokerObservation_Expecter{mock: &_m.Mock}
592}
593
594// RequestReconcile provides a mock function for the type MockBrokerObservation
595func (_mock *MockBrokerObservation) RequestReconcile(endpoint string) {
596 _mock.Called(endpoint)
597 return
598}
599
600// MockBrokerObservation_RequestReconcile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RequestReconcile'
601type MockBrokerObservation_RequestReconcile_Call struct {
602 *mock.Call
603}
604
605// RequestReconcile is a helper method to define mock.On call
606// - endpoint string
607func (_e *MockBrokerObservation_Expecter) RequestReconcile(endpoint any) *MockBrokerObservation_RequestReconcile_Call {
608 return &MockBrokerObservation_RequestReconcile_Call{Call: _e.mock.On("RequestReconcile", endpoint)}
609}
610
611func (_c *MockBrokerObservation_RequestReconcile_Call) Run(run func(endpoint string)) *MockBrokerObservation_RequestReconcile_Call {
612 _c.Call.Run(func(args mock.Arguments) {
613 var arg0 string
614 if args[0] != nil {
615 arg0 = args[0].(string)
616 }
617 run(
618 arg0,
619 )
620 })
621 return _c
622}
623
624func (_c *MockBrokerObservation_RequestReconcile_Call) Return() *MockBrokerObservation_RequestReconcile_Call {
625 _c.Call.Return()
626 return _c
627}
628
629func (_c *MockBrokerObservation_RequestReconcile_Call) RunAndReturn(run func(endpoint string)) *MockBrokerObservation_RequestReconcile_Call {
630 _c.Run(run)
631 return _c
632}
633
634// Snapshot provides a mock function for the type MockBrokerObservation
635func (_mock *MockBrokerObservation) Snapshot() ports.BrokerSnapshot {
636 ret := _mock.Called()
637
638 if len(ret) == 0 {
639 panic("no return value specified for Snapshot")
640 }
641
642 var r0 ports.BrokerSnapshot
643 if returnFunc, ok := ret.Get(0).(func() ports.BrokerSnapshot); ok {
644 r0 = returnFunc()
645 } else {
646 r0 = ret.Get(0).(ports.BrokerSnapshot)
647 }
648 return r0
649}
650
651// MockBrokerObservation_Snapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Snapshot'
652type MockBrokerObservation_Snapshot_Call struct {
653 *mock.Call
654}
655
656// Snapshot is a helper method to define mock.On call
657func (_e *MockBrokerObservation_Expecter) Snapshot() *MockBrokerObservation_Snapshot_Call {
658 return &MockBrokerObservation_Snapshot_Call{Call: _e.mock.On("Snapshot")}
659}
660
661func (_c *MockBrokerObservation_Snapshot_Call) Run(run func()) *MockBrokerObservation_Snapshot_Call {
662 _c.Call.Run(func(args mock.Arguments) {
663 run()
664 })
665 return _c
666}
667
668func (_c *MockBrokerObservation_Snapshot_Call) Return(brokerSnapshot ports.BrokerSnapshot) *MockBrokerObservation_Snapshot_Call {
669 _c.Call.Return(brokerSnapshot)
670 return _c
671}
672
673func (_c *MockBrokerObservation_Snapshot_Call) RunAndReturn(run func() ports.BrokerSnapshot) *MockBrokerObservation_Snapshot_Call {
674 _c.Call.Return(run)
675 return _c
676}
677
678// Subscribe provides a mock function for the type MockBrokerObservation
679func (_mock *MockBrokerObservation) Subscribe() (ports.BrokerSubscription, error) {
680 ret := _mock.Called()
681
682 if len(ret) == 0 {
683 panic("no return value specified for Subscribe")
684 }
685
686 var r0 ports.BrokerSubscription
687 var r1 error
688 if returnFunc, ok := ret.Get(0).(func() (ports.BrokerSubscription, error)); ok {
689 return returnFunc()
690 }
691 if returnFunc, ok := ret.Get(0).(func() ports.BrokerSubscription); ok {
692 r0 = returnFunc()
693 } else {
694 if ret.Get(0) != nil {
695 r0 = ret.Get(0).(ports.BrokerSubscription)
696 }
697 }
698 if returnFunc, ok := ret.Get(1).(func() error); ok {
699 r1 = returnFunc()
700 } else {
701 r1 = ret.Error(1)
702 }
703 return r0, r1
704}
705
706// MockBrokerObservation_Subscribe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Subscribe'
707type MockBrokerObservation_Subscribe_Call struct {
708 *mock.Call
709}
710
711// Subscribe is a helper method to define mock.On call
712func (_e *MockBrokerObservation_Expecter) Subscribe() *MockBrokerObservation_Subscribe_Call {
713 return &MockBrokerObservation_Subscribe_Call{Call: _e.mock.On("Subscribe")}
714}
715
716func (_c *MockBrokerObservation_Subscribe_Call) Run(run func()) *MockBrokerObservation_Subscribe_Call {
717 _c.Call.Run(func(args mock.Arguments) {
718 run()
719 })
720 return _c
721}
722
723func (_c *MockBrokerObservation_Subscribe_Call) Return(brokerSubscription ports.BrokerSubscription, err error) *MockBrokerObservation_Subscribe_Call {
724 _c.Call.Return(brokerSubscription, err)
725 return _c
726}
727
728func (_c *MockBrokerObservation_Subscribe_Call) RunAndReturn(run func() (ports.BrokerSubscription, error)) *MockBrokerObservation_Subscribe_Call {
729 _c.Call.Return(run)
730 return _c
731}
732
733// SubscribePreview provides a mock function for the type MockBrokerObservation
734func (_mock *MockBrokerObservation) SubscribePreview(request ports.BrokerPreviewRequest) (ports.BrokerPreviewSubscription, error) {
735 ret := _mock.Called(request)
736
737 if len(ret) == 0 {
738 panic("no return value specified for SubscribePreview")
739 }
740
741 var r0 ports.BrokerPreviewSubscription
742 var r1 error
743 if returnFunc, ok := ret.Get(0).(func(ports.BrokerPreviewRequest) (ports.BrokerPreviewSubscription, error)); ok {
744 return returnFunc(request)
745 }
746 if returnFunc, ok := ret.Get(0).(func(ports.BrokerPreviewRequest) ports.BrokerPreviewSubscription); ok {
747 r0 = returnFunc(request)
748 } else {
749 if ret.Get(0) != nil {
750 r0 = ret.Get(0).(ports.BrokerPreviewSubscription)
751 }
752 }
753 if returnFunc, ok := ret.Get(1).(func(ports.BrokerPreviewRequest) error); ok {
754 r1 = returnFunc(request)
755 } else {
756 r1 = ret.Error(1)
757 }
758 return r0, r1
759}
760
761// MockBrokerObservation_SubscribePreview_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubscribePreview'
762type MockBrokerObservation_SubscribePreview_Call struct {
763 *mock.Call
764}
765
766// SubscribePreview is a helper method to define mock.On call
767// - request ports.BrokerPreviewRequest
768func (_e *MockBrokerObservation_Expecter) SubscribePreview(request any) *MockBrokerObservation_SubscribePreview_Call {
769 return &MockBrokerObservation_SubscribePreview_Call{Call: _e.mock.On("SubscribePreview", request)}
770}
771
772func (_c *MockBrokerObservation_SubscribePreview_Call) Run(run func(request ports.BrokerPreviewRequest)) *MockBrokerObservation_SubscribePreview_Call {
773 _c.Call.Run(func(args mock.Arguments) {
774 var arg0 ports.BrokerPreviewRequest
775 if args[0] != nil {
776 arg0 = args[0].(ports.BrokerPreviewRequest)
777 }
778 run(
779 arg0,
780 )
781 })
782 return _c
783}
784
785func (_c *MockBrokerObservation_SubscribePreview_Call) Return(brokerPreviewSubscription ports.BrokerPreviewSubscription, err error) *MockBrokerObservation_SubscribePreview_Call {
786 _c.Call.Return(brokerPreviewSubscription, err)
787 return _c
788}
789
790func (_c *MockBrokerObservation_SubscribePreview_Call) RunAndReturn(run func(request ports.BrokerPreviewRequest) (ports.BrokerPreviewSubscription, error)) *MockBrokerObservation_SubscribePreview_Call {
791 _c.Call.Return(run)
792 return _c
793}
794
795// NewMockBrokerHostMembership creates a new instance of MockBrokerHostMembership. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
796// The first argument is typically a *testing.T value.
797func NewMockBrokerHostMembership(t interface {
798 mock.TestingT
799 Cleanup(func())
800}) *MockBrokerHostMembership {
801 if helper, ok := t.(interface{ Helper() }); ok {
802 helper.Helper()
803 }
804
805 mock := &MockBrokerHostMembership{}
806 mock.Mock.Test(t)
807
808 t.Cleanup(func() {
809 if helper, ok := t.(interface{ Helper() }); ok {
810 helper.Helper()
811 }
812 mock.AssertExpectations(t)
813 })
814
815 return mock
816}
817
818// MockBrokerHostMembership is an autogenerated mock type for the BrokerHostMembership type
819type MockBrokerHostMembership struct {
820 mock.Mock
821}
822
823type MockBrokerHostMembership_Expecter struct {
824 mock *mock.Mock
825}
826
827func (_m *MockBrokerHostMembership) EXPECT() *MockBrokerHostMembership_Expecter {
828 return &MockBrokerHostMembership_Expecter{mock: &_m.Mock}
829}
830
831// AddHost provides a mock function for the type MockBrokerHostMembership
832func (_mock *MockBrokerHostMembership) AddHost(ctx context.Context, endpoint string, policy ports.BrokerPolicy) (domain.RemoteRegistration, error) {
833 ret := _mock.Called(ctx, endpoint, policy)
834
835 if len(ret) == 0 {
836 panic("no return value specified for AddHost")
837 }
838
839 var r0 domain.RemoteRegistration
840 var r1 error
841 if returnFunc, ok := ret.Get(0).(func(context.Context, string, ports.BrokerPolicy) (domain.RemoteRegistration, error)); ok {
842 return returnFunc(ctx, endpoint, policy)
843 }
844 if returnFunc, ok := ret.Get(0).(func(context.Context, string, ports.BrokerPolicy) domain.RemoteRegistration); ok {
845 r0 = returnFunc(ctx, endpoint, policy)
846 } else {
847 r0 = ret.Get(0).(domain.RemoteRegistration)
848 }
849 if returnFunc, ok := ret.Get(1).(func(context.Context, string, ports.BrokerPolicy) error); ok {
850 r1 = returnFunc(ctx, endpoint, policy)
851 } else {
852 r1 = ret.Error(1)
853 }
854 return r0, r1
855}
856
857// MockBrokerHostMembership_AddHost_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddHost'
858type MockBrokerHostMembership_AddHost_Call struct {
859 *mock.Call
860}
861
862// AddHost is a helper method to define mock.On call
863// - ctx context.Context
864// - endpoint string
865// - policy ports.BrokerPolicy
866func (_e *MockBrokerHostMembership_Expecter) AddHost(ctx any, endpoint any, policy any) *MockBrokerHostMembership_AddHost_Call {
867 return &MockBrokerHostMembership_AddHost_Call{Call: _e.mock.On("AddHost", ctx, endpoint, policy)}
868}
869
870func (_c *MockBrokerHostMembership_AddHost_Call) Run(run func(ctx context.Context, endpoint string, policy ports.BrokerPolicy)) *MockBrokerHostMembership_AddHost_Call {
871 _c.Call.Run(func(args mock.Arguments) {
872 var arg0 context.Context
873 if args[0] != nil {
874 arg0 = args[0].(context.Context)
875 }
876 var arg1 string
877 if args[1] != nil {
878 arg1 = args[1].(string)
879 }
880 var arg2 ports.BrokerPolicy
881 if args[2] != nil {
882 arg2 = args[2].(ports.BrokerPolicy)
883 }
884 run(
885 arg0,
886 arg1,
887 arg2,
888 )
889 })
890 return _c
891}
892
893func (_c *MockBrokerHostMembership_AddHost_Call) Return(remoteRegistration domain.RemoteRegistration, err error) *MockBrokerHostMembership_AddHost_Call {
894 _c.Call.Return(remoteRegistration, err)
895 return _c
896}
897
898func (_c *MockBrokerHostMembership_AddHost_Call) RunAndReturn(run func(ctx context.Context, endpoint string, policy ports.BrokerPolicy) (domain.RemoteRegistration, error)) *MockBrokerHostMembership_AddHost_Call {
899 _c.Call.Return(run)
900 return _c
901}
902
903// RemoveHost provides a mock function for the type MockBrokerHostMembership
904func (_mock *MockBrokerHostMembership) RemoveHost(ctx context.Context, expected domain.RemoteRegistration) (bool, error) {
905 ret := _mock.Called(ctx, expected)
906
907 if len(ret) == 0 {
908 panic("no return value specified for RemoveHost")
909 }
910
911 var r0 bool
912 var r1 error
913 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteRegistration) (bool, error)); ok {
914 return returnFunc(ctx, expected)
915 }
916 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteRegistration) bool); ok {
917 r0 = returnFunc(ctx, expected)
918 } else {
919 r0 = ret.Get(0).(bool)
920 }
921 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RemoteRegistration) error); ok {
922 r1 = returnFunc(ctx, expected)
923 } else {
924 r1 = ret.Error(1)
925 }
926 return r0, r1
927}
928
929// MockBrokerHostMembership_RemoveHost_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveHost'
930type MockBrokerHostMembership_RemoveHost_Call struct {
931 *mock.Call
932}
933
934// RemoveHost is a helper method to define mock.On call
935// - ctx context.Context
936// - expected domain.RemoteRegistration
937func (_e *MockBrokerHostMembership_Expecter) RemoveHost(ctx any, expected any) *MockBrokerHostMembership_RemoveHost_Call {
938 return &MockBrokerHostMembership_RemoveHost_Call{Call: _e.mock.On("RemoveHost", ctx, expected)}
939}
940
941func (_c *MockBrokerHostMembership_RemoveHost_Call) Run(run func(ctx context.Context, expected domain.RemoteRegistration)) *MockBrokerHostMembership_RemoveHost_Call {
942 _c.Call.Run(func(args mock.Arguments) {
943 var arg0 context.Context
944 if args[0] != nil {
945 arg0 = args[0].(context.Context)
946 }
947 var arg1 domain.RemoteRegistration
948 if args[1] != nil {
949 arg1 = args[1].(domain.RemoteRegistration)
950 }
951 run(
952 arg0,
953 arg1,
954 )
955 })
956 return _c
957}
958
959func (_c *MockBrokerHostMembership_RemoveHost_Call) Return(b bool, err error) *MockBrokerHostMembership_RemoveHost_Call {
960 _c.Call.Return(b, err)
961 return _c
962}
963
964func (_c *MockBrokerHostMembership_RemoveHost_Call) RunAndReturn(run func(ctx context.Context, expected domain.RemoteRegistration) (bool, error)) *MockBrokerHostMembership_RemoveHost_Call {
965 _c.Call.Return(run)
966 return _c
967}
968
969// UpdateHostPolicy provides a mock function for the type MockBrokerHostMembership
970func (_mock *MockBrokerHostMembership) UpdateHostPolicy(ctx context.Context, expected domain.RemoteRegistration, policy ports.BrokerPolicy) (domain.RemoteRegistration, error) {
971 ret := _mock.Called(ctx, expected, policy)
972
973 if len(ret) == 0 {
974 panic("no return value specified for UpdateHostPolicy")
975 }
976
977 var r0 domain.RemoteRegistration
978 var r1 error
979 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteRegistration, ports.BrokerPolicy) (domain.RemoteRegistration, error)); ok {
980 return returnFunc(ctx, expected, policy)
981 }
982 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteRegistration, ports.BrokerPolicy) domain.RemoteRegistration); ok {
983 r0 = returnFunc(ctx, expected, policy)
984 } else {
985 r0 = ret.Get(0).(domain.RemoteRegistration)
986 }
987 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RemoteRegistration, ports.BrokerPolicy) error); ok {
988 r1 = returnFunc(ctx, expected, policy)
989 } else {
990 r1 = ret.Error(1)
991 }
992 return r0, r1
993}
994
995// MockBrokerHostMembership_UpdateHostPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateHostPolicy'
996type MockBrokerHostMembership_UpdateHostPolicy_Call struct {
997 *mock.Call
998}
999
1000// UpdateHostPolicy is a helper method to define mock.On call
1001// - ctx context.Context
1002// - expected domain.RemoteRegistration
1003// - policy ports.BrokerPolicy
1004func (_e *MockBrokerHostMembership_Expecter) UpdateHostPolicy(ctx any, expected any, policy any) *MockBrokerHostMembership_UpdateHostPolicy_Call {
1005 return &MockBrokerHostMembership_UpdateHostPolicy_Call{Call: _e.mock.On("UpdateHostPolicy", ctx, expected, policy)}
1006}
1007
1008func (_c *MockBrokerHostMembership_UpdateHostPolicy_Call) Run(run func(ctx context.Context, expected domain.RemoteRegistration, policy ports.BrokerPolicy)) *MockBrokerHostMembership_UpdateHostPolicy_Call {
1009 _c.Call.Run(func(args mock.Arguments) {
1010 var arg0 context.Context
1011 if args[0] != nil {
1012 arg0 = args[0].(context.Context)
1013 }
1014 var arg1 domain.RemoteRegistration
1015 if args[1] != nil {
1016 arg1 = args[1].(domain.RemoteRegistration)
1017 }
1018 var arg2 ports.BrokerPolicy
1019 if args[2] != nil {
1020 arg2 = args[2].(ports.BrokerPolicy)
1021 }
1022 run(
1023 arg0,
1024 arg1,
1025 arg2,
1026 )
1027 })
1028 return _c
1029}
1030
1031func (_c *MockBrokerHostMembership_UpdateHostPolicy_Call) Return(remoteRegistration domain.RemoteRegistration, err error) *MockBrokerHostMembership_UpdateHostPolicy_Call {
1032 _c.Call.Return(remoteRegistration, err)
1033 return _c
1034}
1035
1036func (_c *MockBrokerHostMembership_UpdateHostPolicy_Call) RunAndReturn(run func(ctx context.Context, expected domain.RemoteRegistration, policy ports.BrokerPolicy) (domain.RemoteRegistration, error)) *MockBrokerHostMembership_UpdateHostPolicy_Call {
1037 _c.Call.Return(run)
1038 return _c
1039}
1040
1041// NewMockBrokerSession creates a new instance of MockBrokerSession. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
1042// The first argument is typically a *testing.T value.
1043func NewMockBrokerSession(t interface {
1044 mock.TestingT
1045 Cleanup(func())
1046}) *MockBrokerSession {
1047 if helper, ok := t.(interface{ Helper() }); ok {
1048 helper.Helper()
1049 }
1050
1051 mock := &MockBrokerSession{}
1052 mock.Mock.Test(t)
1053
1054 t.Cleanup(func() {
1055 if helper, ok := t.(interface{ Helper() }); ok {
1056 helper.Helper()
1057 }
1058 mock.AssertExpectations(t)
1059 })
1060
1061 return mock
1062}
1063
1064// MockBrokerSession is an autogenerated mock type for the BrokerSession type
1065type MockBrokerSession struct {
1066 mock.Mock
1067}
1068
1069type MockBrokerSession_Expecter struct {
1070 mock *mock.Mock
1071}
1072
1073func (_m *MockBrokerSession) EXPECT() *MockBrokerSession_Expecter {
1074 return &MockBrokerSession_Expecter{mock: &_m.Mock}
1075}
1076
1077// AddHost provides a mock function for the type MockBrokerSession
1078func (_mock *MockBrokerSession) AddHost(ctx context.Context, endpoint string, policy ports.BrokerPolicy) (domain.RemoteRegistration, error) {
1079 ret := _mock.Called(ctx, endpoint, policy)
1080
1081 if len(ret) == 0 {
1082 panic("no return value specified for AddHost")
1083 }
1084
1085 var r0 domain.RemoteRegistration
1086 var r1 error
1087 if returnFunc, ok := ret.Get(0).(func(context.Context, string, ports.BrokerPolicy) (domain.RemoteRegistration, error)); ok {
1088 return returnFunc(ctx, endpoint, policy)
1089 }
1090 if returnFunc, ok := ret.Get(0).(func(context.Context, string, ports.BrokerPolicy) domain.RemoteRegistration); ok {
1091 r0 = returnFunc(ctx, endpoint, policy)
1092 } else {
1093 r0 = ret.Get(0).(domain.RemoteRegistration)
1094 }
1095 if returnFunc, ok := ret.Get(1).(func(context.Context, string, ports.BrokerPolicy) error); ok {
1096 r1 = returnFunc(ctx, endpoint, policy)
1097 } else {
1098 r1 = ret.Error(1)
1099 }
1100 return r0, r1
1101}
1102
1103// MockBrokerSession_AddHost_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddHost'
1104type MockBrokerSession_AddHost_Call struct {
1105 *mock.Call
1106}
1107
1108// AddHost is a helper method to define mock.On call
1109// - ctx context.Context
1110// - endpoint string
1111// - policy ports.BrokerPolicy
1112func (_e *MockBrokerSession_Expecter) AddHost(ctx any, endpoint any, policy any) *MockBrokerSession_AddHost_Call {
1113 return &MockBrokerSession_AddHost_Call{Call: _e.mock.On("AddHost", ctx, endpoint, policy)}
1114}
1115
1116func (_c *MockBrokerSession_AddHost_Call) Run(run func(ctx context.Context, endpoint string, policy ports.BrokerPolicy)) *MockBrokerSession_AddHost_Call {
1117 _c.Call.Run(func(args mock.Arguments) {
1118 var arg0 context.Context
1119 if args[0] != nil {
1120 arg0 = args[0].(context.Context)
1121 }
1122 var arg1 string
1123 if args[1] != nil {
1124 arg1 = args[1].(string)
1125 }
1126 var arg2 ports.BrokerPolicy
1127 if args[2] != nil {
1128 arg2 = args[2].(ports.BrokerPolicy)
1129 }
1130 run(
1131 arg0,
1132 arg1,
1133 arg2,
1134 )
1135 })
1136 return _c
1137}
1138
1139func (_c *MockBrokerSession_AddHost_Call) Return(remoteRegistration domain.RemoteRegistration, err error) *MockBrokerSession_AddHost_Call {
1140 _c.Call.Return(remoteRegistration, err)
1141 return _c
1142}
1143
1144func (_c *MockBrokerSession_AddHost_Call) RunAndReturn(run func(ctx context.Context, endpoint string, policy ports.BrokerPolicy) (domain.RemoteRegistration, error)) *MockBrokerSession_AddHost_Call {
1145 _c.Call.Return(run)
1146 return _c
1147}
1148
1149// Close provides a mock function for the type MockBrokerSession
1150func (_mock *MockBrokerSession) Close() error {
1151 ret := _mock.Called()
1152
1153 if len(ret) == 0 {
1154 panic("no return value specified for Close")
1155 }
1156
1157 var r0 error
1158 if returnFunc, ok := ret.Get(0).(func() error); ok {
1159 r0 = returnFunc()
1160 } else {
1161 r0 = ret.Error(0)
1162 }
1163 return r0
1164}
1165
1166// MockBrokerSession_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
1167type MockBrokerSession_Close_Call struct {
1168 *mock.Call
1169}
1170
1171// Close is a helper method to define mock.On call
1172func (_e *MockBrokerSession_Expecter) Close() *MockBrokerSession_Close_Call {
1173 return &MockBrokerSession_Close_Call{Call: _e.mock.On("Close")}
1174}
1175
1176func (_c *MockBrokerSession_Close_Call) Run(run func()) *MockBrokerSession_Close_Call {
1177 _c.Call.Run(func(args mock.Arguments) {
1178 run()
1179 })
1180 return _c
1181}
1182
1183func (_c *MockBrokerSession_Close_Call) Return(err error) *MockBrokerSession_Close_Call {
1184 _c.Call.Return(err)
1185 return _c
1186}
1187
1188func (_c *MockBrokerSession_Close_Call) RunAndReturn(run func() error) *MockBrokerSession_Close_Call {
1189 _c.Call.Return(run)
1190 return _c
1191}
1192
1193// CloseStream provides a mock function for the type MockBrokerSession
1194func (_mock *MockBrokerSession) CloseStream(connection ports.BrokerConnectionID, stream ports.BrokerStreamID) error {
1195 ret := _mock.Called(connection, stream)
1196
1197 if len(ret) == 0 {
1198 panic("no return value specified for CloseStream")
1199 }
1200
1201 var r0 error
1202 if returnFunc, ok := ret.Get(0).(func(ports.BrokerConnectionID, ports.BrokerStreamID) error); ok {
1203 r0 = returnFunc(connection, stream)
1204 } else {
1205 r0 = ret.Error(0)
1206 }
1207 return r0
1208}
1209
1210// MockBrokerSession_CloseStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseStream'
1211type MockBrokerSession_CloseStream_Call struct {
1212 *mock.Call
1213}
1214
1215// CloseStream is a helper method to define mock.On call
1216// - connection ports.BrokerConnectionID
1217// - stream ports.BrokerStreamID
1218func (_e *MockBrokerSession_Expecter) CloseStream(connection any, stream any) *MockBrokerSession_CloseStream_Call {
1219 return &MockBrokerSession_CloseStream_Call{Call: _e.mock.On("CloseStream", connection, stream)}
1220}
1221
1222func (_c *MockBrokerSession_CloseStream_Call) Run(run func(connection ports.BrokerConnectionID, stream ports.BrokerStreamID)) *MockBrokerSession_CloseStream_Call {
1223 _c.Call.Run(func(args mock.Arguments) {
1224 var arg0 ports.BrokerConnectionID
1225 if args[0] != nil {
1226 arg0 = args[0].(ports.BrokerConnectionID)
1227 }
1228 var arg1 ports.BrokerStreamID
1229 if args[1] != nil {
1230 arg1 = args[1].(ports.BrokerStreamID)
1231 }
1232 run(
1233 arg0,
1234 arg1,
1235 )
1236 })
1237 return _c
1238}
1239
1240func (_c *MockBrokerSession_CloseStream_Call) Return(err error) *MockBrokerSession_CloseStream_Call {
1241 _c.Call.Return(err)
1242 return _c
1243}
1244
1245func (_c *MockBrokerSession_CloseStream_Call) RunAndReturn(run func(connection ports.BrokerConnectionID, stream ports.BrokerStreamID) error) *MockBrokerSession_CloseStream_Call {
1246 _c.Call.Return(run)
1247 return _c
1248}
1249
1250// ConnectionID provides a mock function for the type MockBrokerSession
1251func (_mock *MockBrokerSession) ConnectionID() ports.BrokerConnectionID {
1252 ret := _mock.Called()
1253
1254 if len(ret) == 0 {
1255 panic("no return value specified for ConnectionID")
1256 }
1257
1258 var r0 ports.BrokerConnectionID
1259 if returnFunc, ok := ret.Get(0).(func() ports.BrokerConnectionID); ok {
1260 r0 = returnFunc()
1261 } else {
1262 if ret.Get(0) != nil {
1263 r0 = ret.Get(0).(ports.BrokerConnectionID)
1264 }
1265 }
1266 return r0
1267}
1268
1269// MockBrokerSession_ConnectionID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectionID'
1270type MockBrokerSession_ConnectionID_Call struct {
1271 *mock.Call
1272}
1273
1274// ConnectionID is a helper method to define mock.On call
1275func (_e *MockBrokerSession_Expecter) ConnectionID() *MockBrokerSession_ConnectionID_Call {
1276 return &MockBrokerSession_ConnectionID_Call{Call: _e.mock.On("ConnectionID")}
1277}
1278
1279func (_c *MockBrokerSession_ConnectionID_Call) Run(run func()) *MockBrokerSession_ConnectionID_Call {
1280 _c.Call.Run(func(args mock.Arguments) {
1281 run()
1282 })
1283 return _c
1284}
1285
1286func (_c *MockBrokerSession_ConnectionID_Call) Return(brokerConnectionID ports.BrokerConnectionID) *MockBrokerSession_ConnectionID_Call {
1287 _c.Call.Return(brokerConnectionID)
1288 return _c
1289}
1290
1291func (_c *MockBrokerSession_ConnectionID_Call) RunAndReturn(run func() ports.BrokerConnectionID) *MockBrokerSession_ConnectionID_Call {
1292 _c.Call.Return(run)
1293 return _c
1294}
1295
1296// Done provides a mock function for the type MockBrokerSession
1297func (_mock *MockBrokerSession) Done() <-chan struct{} {
1298 ret := _mock.Called()
1299
1300 if len(ret) == 0 {
1301 panic("no return value specified for Done")
1302 }
1303
1304 var r0 <-chan struct{}
1305 if returnFunc, ok := ret.Get(0).(func() <-chan struct{}); ok {
1306 r0 = returnFunc()
1307 } else {
1308 if ret.Get(0) != nil {
1309 r0 = ret.Get(0).(<-chan struct{})
1310 }
1311 }
1312 return r0
1313}
1314
1315// MockBrokerSession_Done_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Done'
1316type MockBrokerSession_Done_Call struct {
1317 *mock.Call
1318}
1319
1320// Done is a helper method to define mock.On call
1321func (_e *MockBrokerSession_Expecter) Done() *MockBrokerSession_Done_Call {
1322 return &MockBrokerSession_Done_Call{Call: _e.mock.On("Done")}
1323}
1324
1325func (_c *MockBrokerSession_Done_Call) Run(run func()) *MockBrokerSession_Done_Call {
1326 _c.Call.Run(func(args mock.Arguments) {
1327 run()
1328 })
1329 return _c
1330}
1331
1332func (_c *MockBrokerSession_Done_Call) Return(valCh <-chan struct{}) *MockBrokerSession_Done_Call {
1333 _c.Call.Return(valCh)
1334 return _c
1335}
1336
1337func (_c *MockBrokerSession_Done_Call) RunAndReturn(run func() <-chan struct{}) *MockBrokerSession_Done_Call {
1338 _c.Call.Return(run)
1339 return _c
1340}
1341
1342// Err provides a mock function for the type MockBrokerSession
1343func (_mock *MockBrokerSession) Err() error {
1344 ret := _mock.Called()
1345
1346 if len(ret) == 0 {
1347 panic("no return value specified for Err")
1348 }
1349
1350 var r0 error
1351 if returnFunc, ok := ret.Get(0).(func() error); ok {
1352 r0 = returnFunc()
1353 } else {
1354 r0 = ret.Error(0)
1355 }
1356 return r0
1357}
1358
1359// MockBrokerSession_Err_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Err'
1360type MockBrokerSession_Err_Call struct {
1361 *mock.Call
1362}
1363
1364// Err is a helper method to define mock.On call
1365func (_e *MockBrokerSession_Expecter) Err() *MockBrokerSession_Err_Call {
1366 return &MockBrokerSession_Err_Call{Call: _e.mock.On("Err")}
1367}
1368
1369func (_c *MockBrokerSession_Err_Call) Run(run func()) *MockBrokerSession_Err_Call {
1370 _c.Call.Run(func(args mock.Arguments) {
1371 run()
1372 })
1373 return _c
1374}
1375
1376func (_c *MockBrokerSession_Err_Call) Return(err error) *MockBrokerSession_Err_Call {
1377 _c.Call.Return(err)
1378 return _c
1379}
1380
1381func (_c *MockBrokerSession_Err_Call) RunAndReturn(run func() error) *MockBrokerSession_Err_Call {
1382 _c.Call.Return(run)
1383 return _c
1384}
1385
1386// NextStreamID provides a mock function for the type MockBrokerSession
1387func (_mock *MockBrokerSession) NextStreamID() (ports.BrokerStreamID, error) {
1388 ret := _mock.Called()
1389
1390 if len(ret) == 0 {
1391 panic("no return value specified for NextStreamID")
1392 }
1393
1394 var r0 ports.BrokerStreamID
1395 var r1 error
1396 if returnFunc, ok := ret.Get(0).(func() (ports.BrokerStreamID, error)); ok {
1397 return returnFunc()
1398 }
1399 if returnFunc, ok := ret.Get(0).(func() ports.BrokerStreamID); ok {
1400 r0 = returnFunc()
1401 } else {
1402 r0 = ret.Get(0).(ports.BrokerStreamID)
1403 }
1404 if returnFunc, ok := ret.Get(1).(func() error); ok {
1405 r1 = returnFunc()
1406 } else {
1407 r1 = ret.Error(1)
1408 }
1409 return r0, r1
1410}
1411
1412// MockBrokerSession_NextStreamID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NextStreamID'
1413type MockBrokerSession_NextStreamID_Call struct {
1414 *mock.Call
1415}
1416
1417// NextStreamID is a helper method to define mock.On call
1418func (_e *MockBrokerSession_Expecter) NextStreamID() *MockBrokerSession_NextStreamID_Call {
1419 return &MockBrokerSession_NextStreamID_Call{Call: _e.mock.On("NextStreamID")}
1420}
1421
1422func (_c *MockBrokerSession_NextStreamID_Call) Run(run func()) *MockBrokerSession_NextStreamID_Call {
1423 _c.Call.Run(func(args mock.Arguments) {
1424 run()
1425 })
1426 return _c
1427}
1428
1429func (_c *MockBrokerSession_NextStreamID_Call) Return(brokerStreamID ports.BrokerStreamID, err error) *MockBrokerSession_NextStreamID_Call {
1430 _c.Call.Return(brokerStreamID, err)
1431 return _c
1432}
1433
1434func (_c *MockBrokerSession_NextStreamID_Call) RunAndReturn(run func() (ports.BrokerStreamID, error)) *MockBrokerSession_NextStreamID_Call {
1435 _c.Call.Return(run)
1436 return _c
1437}
1438
1439// RemoveHost provides a mock function for the type MockBrokerSession
1440func (_mock *MockBrokerSession) RemoveHost(ctx context.Context, expected domain.RemoteRegistration) (bool, error) {
1441 ret := _mock.Called(ctx, expected)
1442
1443 if len(ret) == 0 {
1444 panic("no return value specified for RemoveHost")
1445 }
1446
1447 var r0 bool
1448 var r1 error
1449 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteRegistration) (bool, error)); ok {
1450 return returnFunc(ctx, expected)
1451 }
1452 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteRegistration) bool); ok {
1453 r0 = returnFunc(ctx, expected)
1454 } else {
1455 r0 = ret.Get(0).(bool)
1456 }
1457 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RemoteRegistration) error); ok {
1458 r1 = returnFunc(ctx, expected)
1459 } else {
1460 r1 = ret.Error(1)
1461 }
1462 return r0, r1
1463}
1464
1465// MockBrokerSession_RemoveHost_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveHost'
1466type MockBrokerSession_RemoveHost_Call struct {
1467 *mock.Call
1468}
1469
1470// RemoveHost is a helper method to define mock.On call
1471// - ctx context.Context
1472// - expected domain.RemoteRegistration
1473func (_e *MockBrokerSession_Expecter) RemoveHost(ctx any, expected any) *MockBrokerSession_RemoveHost_Call {
1474 return &MockBrokerSession_RemoveHost_Call{Call: _e.mock.On("RemoveHost", ctx, expected)}
1475}
1476
1477func (_c *MockBrokerSession_RemoveHost_Call) Run(run func(ctx context.Context, expected domain.RemoteRegistration)) *MockBrokerSession_RemoveHost_Call {
1478 _c.Call.Run(func(args mock.Arguments) {
1479 var arg0 context.Context
1480 if args[0] != nil {
1481 arg0 = args[0].(context.Context)
1482 }
1483 var arg1 domain.RemoteRegistration
1484 if args[1] != nil {
1485 arg1 = args[1].(domain.RemoteRegistration)
1486 }
1487 run(
1488 arg0,
1489 arg1,
1490 )
1491 })
1492 return _c
1493}
1494
1495func (_c *MockBrokerSession_RemoveHost_Call) Return(b bool, err error) *MockBrokerSession_RemoveHost_Call {
1496 _c.Call.Return(b, err)
1497 return _c
1498}
1499
1500func (_c *MockBrokerSession_RemoveHost_Call) RunAndReturn(run func(ctx context.Context, expected domain.RemoteRegistration) (bool, error)) *MockBrokerSession_RemoveHost_Call {
1501 _c.Call.Return(run)
1502 return _c
1503}
1504
1505// RequestReconcile provides a mock function for the type MockBrokerSession
1506func (_mock *MockBrokerSession) RequestReconcile(endpoint string) {
1507 _mock.Called(endpoint)
1508 return
1509}
1510
1511// MockBrokerSession_RequestReconcile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RequestReconcile'
1512type MockBrokerSession_RequestReconcile_Call struct {
1513 *mock.Call
1514}
1515
1516// RequestReconcile is a helper method to define mock.On call
1517// - endpoint string
1518func (_e *MockBrokerSession_Expecter) RequestReconcile(endpoint any) *MockBrokerSession_RequestReconcile_Call {
1519 return &MockBrokerSession_RequestReconcile_Call{Call: _e.mock.On("RequestReconcile", endpoint)}
1520}
1521
1522func (_c *MockBrokerSession_RequestReconcile_Call) Run(run func(endpoint string)) *MockBrokerSession_RequestReconcile_Call {
1523 _c.Call.Run(func(args mock.Arguments) {
1524 var arg0 string
1525 if args[0] != nil {
1526 arg0 = args[0].(string)
1527 }
1528 run(
1529 arg0,
1530 )
1531 })
1532 return _c
1533}
1534
1535func (_c *MockBrokerSession_RequestReconcile_Call) Return() *MockBrokerSession_RequestReconcile_Call {
1536 _c.Call.Return()
1537 return _c
1538}
1539
1540func (_c *MockBrokerSession_RequestReconcile_Call) RunAndReturn(run func(endpoint string)) *MockBrokerSession_RequestReconcile_Call {
1541 _c.Run(run)
1542 return _c
1543}
1544
1545// Snapshot provides a mock function for the type MockBrokerSession
1546func (_mock *MockBrokerSession) Snapshot() ports.BrokerSnapshot {
1547 ret := _mock.Called()
1548
1549 if len(ret) == 0 {
1550 panic("no return value specified for Snapshot")
1551 }
1552
1553 var r0 ports.BrokerSnapshot
1554 if returnFunc, ok := ret.Get(0).(func() ports.BrokerSnapshot); ok {
1555 r0 = returnFunc()
1556 } else {
1557 r0 = ret.Get(0).(ports.BrokerSnapshot)
1558 }
1559 return r0
1560}
1561
1562// MockBrokerSession_Snapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Snapshot'
1563type MockBrokerSession_Snapshot_Call struct {
1564 *mock.Call
1565}
1566
1567// Snapshot is a helper method to define mock.On call
1568func (_e *MockBrokerSession_Expecter) Snapshot() *MockBrokerSession_Snapshot_Call {
1569 return &MockBrokerSession_Snapshot_Call{Call: _e.mock.On("Snapshot")}
1570}
1571
1572func (_c *MockBrokerSession_Snapshot_Call) Run(run func()) *MockBrokerSession_Snapshot_Call {
1573 _c.Call.Run(func(args mock.Arguments) {
1574 run()
1575 })
1576 return _c
1577}
1578
1579func (_c *MockBrokerSession_Snapshot_Call) Return(brokerSnapshot ports.BrokerSnapshot) *MockBrokerSession_Snapshot_Call {
1580 _c.Call.Return(brokerSnapshot)
1581 return _c
1582}
1583
1584func (_c *MockBrokerSession_Snapshot_Call) RunAndReturn(run func() ports.BrokerSnapshot) *MockBrokerSession_Snapshot_Call {
1585 _c.Call.Return(run)
1586 return _c
1587}
1588
1589// Subscribe provides a mock function for the type MockBrokerSession
1590func (_mock *MockBrokerSession) Subscribe() (ports.BrokerSubscription, error) {
1591 ret := _mock.Called()
1592
1593 if len(ret) == 0 {
1594 panic("no return value specified for Subscribe")
1595 }
1596
1597 var r0 ports.BrokerSubscription
1598 var r1 error
1599 if returnFunc, ok := ret.Get(0).(func() (ports.BrokerSubscription, error)); ok {
1600 return returnFunc()
1601 }
1602 if returnFunc, ok := ret.Get(0).(func() ports.BrokerSubscription); ok {
1603 r0 = returnFunc()
1604 } else {
1605 if ret.Get(0) != nil {
1606 r0 = ret.Get(0).(ports.BrokerSubscription)
1607 }
1608 }
1609 if returnFunc, ok := ret.Get(1).(func() error); ok {
1610 r1 = returnFunc()
1611 } else {
1612 r1 = ret.Error(1)
1613 }
1614 return r0, r1
1615}
1616
1617// MockBrokerSession_Subscribe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Subscribe'
1618type MockBrokerSession_Subscribe_Call struct {
1619 *mock.Call
1620}
1621
1622// Subscribe is a helper method to define mock.On call
1623func (_e *MockBrokerSession_Expecter) Subscribe() *MockBrokerSession_Subscribe_Call {
1624 return &MockBrokerSession_Subscribe_Call{Call: _e.mock.On("Subscribe")}
1625}
1626
1627func (_c *MockBrokerSession_Subscribe_Call) Run(run func()) *MockBrokerSession_Subscribe_Call {
1628 _c.Call.Run(func(args mock.Arguments) {
1629 run()
1630 })
1631 return _c
1632}
1633
1634func (_c *MockBrokerSession_Subscribe_Call) Return(brokerSubscription ports.BrokerSubscription, err error) *MockBrokerSession_Subscribe_Call {
1635 _c.Call.Return(brokerSubscription, err)
1636 return _c
1637}
1638
1639func (_c *MockBrokerSession_Subscribe_Call) RunAndReturn(run func() (ports.BrokerSubscription, error)) *MockBrokerSession_Subscribe_Call {
1640 _c.Call.Return(run)
1641 return _c
1642}
1643
1644// SubscribePreview provides a mock function for the type MockBrokerSession
1645func (_mock *MockBrokerSession) SubscribePreview(request ports.BrokerPreviewRequest) (ports.BrokerPreviewSubscription, error) {
1646 ret := _mock.Called(request)
1647
1648 if len(ret) == 0 {
1649 panic("no return value specified for SubscribePreview")
1650 }
1651
1652 var r0 ports.BrokerPreviewSubscription
1653 var r1 error
1654 if returnFunc, ok := ret.Get(0).(func(ports.BrokerPreviewRequest) (ports.BrokerPreviewSubscription, error)); ok {
1655 return returnFunc(request)
1656 }
1657 if returnFunc, ok := ret.Get(0).(func(ports.BrokerPreviewRequest) ports.BrokerPreviewSubscription); ok {
1658 r0 = returnFunc(request)
1659 } else {
1660 if ret.Get(0) != nil {
1661 r0 = ret.Get(0).(ports.BrokerPreviewSubscription)
1662 }
1663 }
1664 if returnFunc, ok := ret.Get(1).(func(ports.BrokerPreviewRequest) error); ok {
1665 r1 = returnFunc(request)
1666 } else {
1667 r1 = ret.Error(1)
1668 }
1669 return r0, r1
1670}
1671
1672// MockBrokerSession_SubscribePreview_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubscribePreview'
1673type MockBrokerSession_SubscribePreview_Call struct {
1674 *mock.Call
1675}
1676
1677// SubscribePreview is a helper method to define mock.On call
1678// - request ports.BrokerPreviewRequest
1679func (_e *MockBrokerSession_Expecter) SubscribePreview(request any) *MockBrokerSession_SubscribePreview_Call {
1680 return &MockBrokerSession_SubscribePreview_Call{Call: _e.mock.On("SubscribePreview", request)}
1681}
1682
1683func (_c *MockBrokerSession_SubscribePreview_Call) Run(run func(request ports.BrokerPreviewRequest)) *MockBrokerSession_SubscribePreview_Call {
1684 _c.Call.Run(func(args mock.Arguments) {
1685 var arg0 ports.BrokerPreviewRequest
1686 if args[0] != nil {
1687 arg0 = args[0].(ports.BrokerPreviewRequest)
1688 }
1689 run(
1690 arg0,
1691 )
1692 })
1693 return _c
1694}
1695
1696func (_c *MockBrokerSession_SubscribePreview_Call) Return(brokerPreviewSubscription ports.BrokerPreviewSubscription, err error) *MockBrokerSession_SubscribePreview_Call {
1697 _c.Call.Return(brokerPreviewSubscription, err)
1698 return _c
1699}
1700
1701func (_c *MockBrokerSession_SubscribePreview_Call) RunAndReturn(run func(request ports.BrokerPreviewRequest) (ports.BrokerPreviewSubscription, error)) *MockBrokerSession_SubscribePreview_Call {
1702 _c.Call.Return(run)
1703 return _c
1704}
1705
1706// UpdateHostPolicy provides a mock function for the type MockBrokerSession
1707func (_mock *MockBrokerSession) UpdateHostPolicy(ctx context.Context, expected domain.RemoteRegistration, policy ports.BrokerPolicy) (domain.RemoteRegistration, error) {
1708 ret := _mock.Called(ctx, expected, policy)
1709
1710 if len(ret) == 0 {
1711 panic("no return value specified for UpdateHostPolicy")
1712 }
1713
1714 var r0 domain.RemoteRegistration
1715 var r1 error
1716 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteRegistration, ports.BrokerPolicy) (domain.RemoteRegistration, error)); ok {
1717 return returnFunc(ctx, expected, policy)
1718 }
1719 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteRegistration, ports.BrokerPolicy) domain.RemoteRegistration); ok {
1720 r0 = returnFunc(ctx, expected, policy)
1721 } else {
1722 r0 = ret.Get(0).(domain.RemoteRegistration)
1723 }
1724 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RemoteRegistration, ports.BrokerPolicy) error); ok {
1725 r1 = returnFunc(ctx, expected, policy)
1726 } else {
1727 r1 = ret.Error(1)
1728 }
1729 return r0, r1
1730}
1731
1732// MockBrokerSession_UpdateHostPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateHostPolicy'
1733type MockBrokerSession_UpdateHostPolicy_Call struct {
1734 *mock.Call
1735}
1736
1737// UpdateHostPolicy is a helper method to define mock.On call
1738// - ctx context.Context
1739// - expected domain.RemoteRegistration
1740// - policy ports.BrokerPolicy
1741func (_e *MockBrokerSession_Expecter) UpdateHostPolicy(ctx any, expected any, policy any) *MockBrokerSession_UpdateHostPolicy_Call {
1742 return &MockBrokerSession_UpdateHostPolicy_Call{Call: _e.mock.On("UpdateHostPolicy", ctx, expected, policy)}
1743}
1744
1745func (_c *MockBrokerSession_UpdateHostPolicy_Call) Run(run func(ctx context.Context, expected domain.RemoteRegistration, policy ports.BrokerPolicy)) *MockBrokerSession_UpdateHostPolicy_Call {
1746 _c.Call.Run(func(args mock.Arguments) {
1747 var arg0 context.Context
1748 if args[0] != nil {
1749 arg0 = args[0].(context.Context)
1750 }
1751 var arg1 domain.RemoteRegistration
1752 if args[1] != nil {
1753 arg1 = args[1].(domain.RemoteRegistration)
1754 }
1755 var arg2 ports.BrokerPolicy
1756 if args[2] != nil {
1757 arg2 = args[2].(ports.BrokerPolicy)
1758 }
1759 run(
1760 arg0,
1761 arg1,
1762 arg2,
1763 )
1764 })
1765 return _c
1766}
1767
1768func (_c *MockBrokerSession_UpdateHostPolicy_Call) Return(remoteRegistration domain.RemoteRegistration, err error) *MockBrokerSession_UpdateHostPolicy_Call {
1769 _c.Call.Return(remoteRegistration, err)
1770 return _c
1771}
1772
1773func (_c *MockBrokerSession_UpdateHostPolicy_Call) RunAndReturn(run func(ctx context.Context, expected domain.RemoteRegistration, policy ports.BrokerPolicy) (domain.RemoteRegistration, error)) *MockBrokerSession_UpdateHostPolicy_Call {
1774 _c.Call.Return(run)
1775 return _c
1776}
1777
1778// NewMockBrokerService creates a new instance of MockBrokerService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
1779// The first argument is typically a *testing.T value.
1780func NewMockBrokerService(t interface {
1781 mock.TestingT
1782 Cleanup(func())
1783}) *MockBrokerService {
1784 if helper, ok := t.(interface{ Helper() }); ok {
1785 helper.Helper()
1786 }
1787
1788 mock := &MockBrokerService{}
1789 mock.Mock.Test(t)
1790
1791 t.Cleanup(func() {
1792 if helper, ok := t.(interface{ Helper() }); ok {
1793 helper.Helper()
1794 }
1795 mock.AssertExpectations(t)
1796 })
1797
1798 return mock
1799}
1800
1801// MockBrokerService is an autogenerated mock type for the BrokerService type
1802type MockBrokerService struct {
1803 mock.Mock
1804}
1805
1806type MockBrokerService_Expecter struct {
1807 mock *mock.Mock
1808}
1809
1810func (_m *MockBrokerService) EXPECT() *MockBrokerService_Expecter {
1811 return &MockBrokerService_Expecter{mock: &_m.Mock}
1812}
1813
1814// AddHost provides a mock function for the type MockBrokerService
1815func (_mock *MockBrokerService) AddHost(ctx context.Context, endpoint string, policy ports.BrokerPolicy) (domain.RemoteRegistration, error) {
1816 ret := _mock.Called(ctx, endpoint, policy)
1817
1818 if len(ret) == 0 {
1819 panic("no return value specified for AddHost")
1820 }
1821
1822 var r0 domain.RemoteRegistration
1823 var r1 error
1824 if returnFunc, ok := ret.Get(0).(func(context.Context, string, ports.BrokerPolicy) (domain.RemoteRegistration, error)); ok {
1825 return returnFunc(ctx, endpoint, policy)
1826 }
1827 if returnFunc, ok := ret.Get(0).(func(context.Context, string, ports.BrokerPolicy) domain.RemoteRegistration); ok {
1828 r0 = returnFunc(ctx, endpoint, policy)
1829 } else {
1830 r0 = ret.Get(0).(domain.RemoteRegistration)
1831 }
1832 if returnFunc, ok := ret.Get(1).(func(context.Context, string, ports.BrokerPolicy) error); ok {
1833 r1 = returnFunc(ctx, endpoint, policy)
1834 } else {
1835 r1 = ret.Error(1)
1836 }
1837 return r0, r1
1838}
1839
1840// MockBrokerService_AddHost_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddHost'
1841type MockBrokerService_AddHost_Call struct {
1842 *mock.Call
1843}
1844
1845// AddHost is a helper method to define mock.On call
1846// - ctx context.Context
1847// - endpoint string
1848// - policy ports.BrokerPolicy
1849func (_e *MockBrokerService_Expecter) AddHost(ctx any, endpoint any, policy any) *MockBrokerService_AddHost_Call {
1850 return &MockBrokerService_AddHost_Call{Call: _e.mock.On("AddHost", ctx, endpoint, policy)}
1851}
1852
1853func (_c *MockBrokerService_AddHost_Call) Run(run func(ctx context.Context, endpoint string, policy ports.BrokerPolicy)) *MockBrokerService_AddHost_Call {
1854 _c.Call.Run(func(args mock.Arguments) {
1855 var arg0 context.Context
1856 if args[0] != nil {
1857 arg0 = args[0].(context.Context)
1858 }
1859 var arg1 string
1860 if args[1] != nil {
1861 arg1 = args[1].(string)
1862 }
1863 var arg2 ports.BrokerPolicy
1864 if args[2] != nil {
1865 arg2 = args[2].(ports.BrokerPolicy)
1866 }
1867 run(
1868 arg0,
1869 arg1,
1870 arg2,
1871 )
1872 })
1873 return _c
1874}
1875
1876func (_c *MockBrokerService_AddHost_Call) Return(remoteRegistration domain.RemoteRegistration, err error) *MockBrokerService_AddHost_Call {
1877 _c.Call.Return(remoteRegistration, err)
1878 return _c
1879}
1880
1881func (_c *MockBrokerService_AddHost_Call) RunAndReturn(run func(ctx context.Context, endpoint string, policy ports.BrokerPolicy) (domain.RemoteRegistration, error)) *MockBrokerService_AddHost_Call {
1882 _c.Call.Return(run)
1883 return _c
1884}
1885
1886// Close provides a mock function for the type MockBrokerService
1887func (_mock *MockBrokerService) Close() error {
1888 ret := _mock.Called()
1889
1890 if len(ret) == 0 {
1891 panic("no return value specified for Close")
1892 }
1893
1894 var r0 error
1895 if returnFunc, ok := ret.Get(0).(func() error); ok {
1896 r0 = returnFunc()
1897 } else {
1898 r0 = ret.Error(0)
1899 }
1900 return r0
1901}
1902
1903// MockBrokerService_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
1904type MockBrokerService_Close_Call struct {
1905 *mock.Call
1906}
1907
1908// Close is a helper method to define mock.On call
1909func (_e *MockBrokerService_Expecter) Close() *MockBrokerService_Close_Call {
1910 return &MockBrokerService_Close_Call{Call: _e.mock.On("Close")}
1911}
1912
1913func (_c *MockBrokerService_Close_Call) Run(run func()) *MockBrokerService_Close_Call {
1914 _c.Call.Run(func(args mock.Arguments) {
1915 run()
1916 })
1917 return _c
1918}
1919
1920func (_c *MockBrokerService_Close_Call) Return(err error) *MockBrokerService_Close_Call {
1921 _c.Call.Return(err)
1922 return _c
1923}
1924
1925func (_c *MockBrokerService_Close_Call) RunAndReturn(run func() error) *MockBrokerService_Close_Call {
1926 _c.Call.Return(run)
1927 return _c
1928}
1929
1930// CloseStream provides a mock function for the type MockBrokerService
1931func (_mock *MockBrokerService) CloseStream(connection ports.BrokerConnectionID, stream ports.BrokerStreamID) error {
1932 ret := _mock.Called(connection, stream)
1933
1934 if len(ret) == 0 {
1935 panic("no return value specified for CloseStream")
1936 }
1937
1938 var r0 error
1939 if returnFunc, ok := ret.Get(0).(func(ports.BrokerConnectionID, ports.BrokerStreamID) error); ok {
1940 r0 = returnFunc(connection, stream)
1941 } else {
1942 r0 = ret.Error(0)
1943 }
1944 return r0
1945}
1946
1947// MockBrokerService_CloseStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseStream'
1948type MockBrokerService_CloseStream_Call struct {
1949 *mock.Call
1950}
1951
1952// CloseStream is a helper method to define mock.On call
1953// - connection ports.BrokerConnectionID
1954// - stream ports.BrokerStreamID
1955func (_e *MockBrokerService_Expecter) CloseStream(connection any, stream any) *MockBrokerService_CloseStream_Call {
1956 return &MockBrokerService_CloseStream_Call{Call: _e.mock.On("CloseStream", connection, stream)}
1957}
1958
1959func (_c *MockBrokerService_CloseStream_Call) Run(run func(connection ports.BrokerConnectionID, stream ports.BrokerStreamID)) *MockBrokerService_CloseStream_Call {
1960 _c.Call.Run(func(args mock.Arguments) {
1961 var arg0 ports.BrokerConnectionID
1962 if args[0] != nil {
1963 arg0 = args[0].(ports.BrokerConnectionID)
1964 }
1965 var arg1 ports.BrokerStreamID
1966 if args[1] != nil {
1967 arg1 = args[1].(ports.BrokerStreamID)
1968 }
1969 run(
1970 arg0,
1971 arg1,
1972 )
1973 })
1974 return _c
1975}
1976
1977func (_c *MockBrokerService_CloseStream_Call) Return(err error) *MockBrokerService_CloseStream_Call {
1978 _c.Call.Return(err)
1979 return _c
1980}
1981
1982func (_c *MockBrokerService_CloseStream_Call) RunAndReturn(run func(connection ports.BrokerConnectionID, stream ports.BrokerStreamID) error) *MockBrokerService_CloseStream_Call {
1983 _c.Call.Return(run)
1984 return _c
1985}
1986
1987// ConnectionID provides a mock function for the type MockBrokerService
1988func (_mock *MockBrokerService) ConnectionID() ports.BrokerConnectionID {
1989 ret := _mock.Called()
1990
1991 if len(ret) == 0 {
1992 panic("no return value specified for ConnectionID")
1993 }
1994
1995 var r0 ports.BrokerConnectionID
1996 if returnFunc, ok := ret.Get(0).(func() ports.BrokerConnectionID); ok {
1997 r0 = returnFunc()
1998 } else {
1999 if ret.Get(0) != nil {
2000 r0 = ret.Get(0).(ports.BrokerConnectionID)
2001 }
2002 }
2003 return r0
2004}
2005
2006// MockBrokerService_ConnectionID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectionID'
2007type MockBrokerService_ConnectionID_Call struct {
2008 *mock.Call
2009}
2010
2011// ConnectionID is a helper method to define mock.On call
2012func (_e *MockBrokerService_Expecter) ConnectionID() *MockBrokerService_ConnectionID_Call {
2013 return &MockBrokerService_ConnectionID_Call{Call: _e.mock.On("ConnectionID")}
2014}
2015
2016func (_c *MockBrokerService_ConnectionID_Call) Run(run func()) *MockBrokerService_ConnectionID_Call {
2017 _c.Call.Run(func(args mock.Arguments) {
2018 run()
2019 })
2020 return _c
2021}
2022
2023func (_c *MockBrokerService_ConnectionID_Call) Return(brokerConnectionID ports.BrokerConnectionID) *MockBrokerService_ConnectionID_Call {
2024 _c.Call.Return(brokerConnectionID)
2025 return _c
2026}
2027
2028func (_c *MockBrokerService_ConnectionID_Call) RunAndReturn(run func() ports.BrokerConnectionID) *MockBrokerService_ConnectionID_Call {
2029 _c.Call.Return(run)
2030 return _c
2031}
2032
2033// Done provides a mock function for the type MockBrokerService
2034func (_mock *MockBrokerService) Done() <-chan struct{} {
2035 ret := _mock.Called()
2036
2037 if len(ret) == 0 {
2038 panic("no return value specified for Done")
2039 }
2040
2041 var r0 <-chan struct{}
2042 if returnFunc, ok := ret.Get(0).(func() <-chan struct{}); ok {
2043 r0 = returnFunc()
2044 } else {
2045 if ret.Get(0) != nil {
2046 r0 = ret.Get(0).(<-chan struct{})
2047 }
2048 }
2049 return r0
2050}
2051
2052// MockBrokerService_Done_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Done'
2053type MockBrokerService_Done_Call struct {
2054 *mock.Call
2055}
2056
2057// Done is a helper method to define mock.On call
2058func (_e *MockBrokerService_Expecter) Done() *MockBrokerService_Done_Call {
2059 return &MockBrokerService_Done_Call{Call: _e.mock.On("Done")}
2060}
2061
2062func (_c *MockBrokerService_Done_Call) Run(run func()) *MockBrokerService_Done_Call {
2063 _c.Call.Run(func(args mock.Arguments) {
2064 run()
2065 })
2066 return _c
2067}
2068
2069func (_c *MockBrokerService_Done_Call) Return(valCh <-chan struct{}) *MockBrokerService_Done_Call {
2070 _c.Call.Return(valCh)
2071 return _c
2072}
2073
2074func (_c *MockBrokerService_Done_Call) RunAndReturn(run func() <-chan struct{}) *MockBrokerService_Done_Call {
2075 _c.Call.Return(run)
2076 return _c
2077}
2078
2079// Err provides a mock function for the type MockBrokerService
2080func (_mock *MockBrokerService) Err() error {
2081 ret := _mock.Called()
2082
2083 if len(ret) == 0 {
2084 panic("no return value specified for Err")
2085 }
2086
2087 var r0 error
2088 if returnFunc, ok := ret.Get(0).(func() error); ok {
2089 r0 = returnFunc()
2090 } else {
2091 r0 = ret.Error(0)
2092 }
2093 return r0
2094}
2095
2096// MockBrokerService_Err_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Err'
2097type MockBrokerService_Err_Call struct {
2098 *mock.Call
2099}
2100
2101// Err is a helper method to define mock.On call
2102func (_e *MockBrokerService_Expecter) Err() *MockBrokerService_Err_Call {
2103 return &MockBrokerService_Err_Call{Call: _e.mock.On("Err")}
2104}
2105
2106func (_c *MockBrokerService_Err_Call) Run(run func()) *MockBrokerService_Err_Call {
2107 _c.Call.Run(func(args mock.Arguments) {
2108 run()
2109 })
2110 return _c
2111}
2112
2113func (_c *MockBrokerService_Err_Call) Return(err error) *MockBrokerService_Err_Call {
2114 _c.Call.Return(err)
2115 return _c
2116}
2117
2118func (_c *MockBrokerService_Err_Call) RunAndReturn(run func() error) *MockBrokerService_Err_Call {
2119 _c.Call.Return(run)
2120 return _c
2121}
2122
2123// NextStreamID provides a mock function for the type MockBrokerService
2124func (_mock *MockBrokerService) NextStreamID() (ports.BrokerStreamID, error) {
2125 ret := _mock.Called()
2126
2127 if len(ret) == 0 {
2128 panic("no return value specified for NextStreamID")
2129 }
2130
2131 var r0 ports.BrokerStreamID
2132 var r1 error
2133 if returnFunc, ok := ret.Get(0).(func() (ports.BrokerStreamID, error)); ok {
2134 return returnFunc()
2135 }
2136 if returnFunc, ok := ret.Get(0).(func() ports.BrokerStreamID); ok {
2137 r0 = returnFunc()
2138 } else {
2139 r0 = ret.Get(0).(ports.BrokerStreamID)
2140 }
2141 if returnFunc, ok := ret.Get(1).(func() error); ok {
2142 r1 = returnFunc()
2143 } else {
2144 r1 = ret.Error(1)
2145 }
2146 return r0, r1
2147}
2148
2149// MockBrokerService_NextStreamID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NextStreamID'
2150type MockBrokerService_NextStreamID_Call struct {
2151 *mock.Call
2152}
2153
2154// NextStreamID is a helper method to define mock.On call
2155func (_e *MockBrokerService_Expecter) NextStreamID() *MockBrokerService_NextStreamID_Call {
2156 return &MockBrokerService_NextStreamID_Call{Call: _e.mock.On("NextStreamID")}
2157}
2158
2159func (_c *MockBrokerService_NextStreamID_Call) Run(run func()) *MockBrokerService_NextStreamID_Call {
2160 _c.Call.Run(func(args mock.Arguments) {
2161 run()
2162 })
2163 return _c
2164}
2165
2166func (_c *MockBrokerService_NextStreamID_Call) Return(brokerStreamID ports.BrokerStreamID, err error) *MockBrokerService_NextStreamID_Call {
2167 _c.Call.Return(brokerStreamID, err)
2168 return _c
2169}
2170
2171func (_c *MockBrokerService_NextStreamID_Call) RunAndReturn(run func() (ports.BrokerStreamID, error)) *MockBrokerService_NextStreamID_Call {
2172 _c.Call.Return(run)
2173 return _c
2174}
2175
2176// OpenStream provides a mock function for the type MockBrokerService
2177func (_mock *MockBrokerService) OpenStream(ctx context.Context, request ports.BrokerOpenStreamRequest) (ports.BrokerLogicalConnection, error) {
2178 ret := _mock.Called(ctx, request)
2179
2180 if len(ret) == 0 {
2181 panic("no return value specified for OpenStream")
2182 }
2183
2184 var r0 ports.BrokerLogicalConnection
2185 var r1 error
2186 if returnFunc, ok := ret.Get(0).(func(context.Context, ports.BrokerOpenStreamRequest) (ports.BrokerLogicalConnection, error)); ok {
2187 return returnFunc(ctx, request)
2188 }
2189 if returnFunc, ok := ret.Get(0).(func(context.Context, ports.BrokerOpenStreamRequest) ports.BrokerLogicalConnection); ok {
2190 r0 = returnFunc(ctx, request)
2191 } else {
2192 if ret.Get(0) != nil {
2193 r0 = ret.Get(0).(ports.BrokerLogicalConnection)
2194 }
2195 }
2196 if returnFunc, ok := ret.Get(1).(func(context.Context, ports.BrokerOpenStreamRequest) error); ok {
2197 r1 = returnFunc(ctx, request)
2198 } else {
2199 r1 = ret.Error(1)
2200 }
2201 return r0, r1
2202}
2203
2204// MockBrokerService_OpenStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OpenStream'
2205type MockBrokerService_OpenStream_Call struct {
2206 *mock.Call
2207}
2208
2209// OpenStream is a helper method to define mock.On call
2210// - ctx context.Context
2211// - request ports.BrokerOpenStreamRequest
2212func (_e *MockBrokerService_Expecter) OpenStream(ctx any, request any) *MockBrokerService_OpenStream_Call {
2213 return &MockBrokerService_OpenStream_Call{Call: _e.mock.On("OpenStream", ctx, request)}
2214}
2215
2216func (_c *MockBrokerService_OpenStream_Call) Run(run func(ctx context.Context, request ports.BrokerOpenStreamRequest)) *MockBrokerService_OpenStream_Call {
2217 _c.Call.Run(func(args mock.Arguments) {
2218 var arg0 context.Context
2219 if args[0] != nil {
2220 arg0 = args[0].(context.Context)
2221 }
2222 var arg1 ports.BrokerOpenStreamRequest
2223 if args[1] != nil {
2224 arg1 = args[1].(ports.BrokerOpenStreamRequest)
2225 }
2226 run(
2227 arg0,
2228 arg1,
2229 )
2230 })
2231 return _c
2232}
2233
2234func (_c *MockBrokerService_OpenStream_Call) Return(brokerLogicalConnection ports.BrokerLogicalConnection, err error) *MockBrokerService_OpenStream_Call {
2235 _c.Call.Return(brokerLogicalConnection, err)
2236 return _c
2237}
2238
2239func (_c *MockBrokerService_OpenStream_Call) RunAndReturn(run func(ctx context.Context, request ports.BrokerOpenStreamRequest) (ports.BrokerLogicalConnection, error)) *MockBrokerService_OpenStream_Call {
2240 _c.Call.Return(run)
2241 return _c
2242}
2243
2244// RemoveHost provides a mock function for the type MockBrokerService
2245func (_mock *MockBrokerService) RemoveHost(ctx context.Context, expected domain.RemoteRegistration) (bool, error) {
2246 ret := _mock.Called(ctx, expected)
2247
2248 if len(ret) == 0 {
2249 panic("no return value specified for RemoveHost")
2250 }
2251
2252 var r0 bool
2253 var r1 error
2254 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteRegistration) (bool, error)); ok {
2255 return returnFunc(ctx, expected)
2256 }
2257 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteRegistration) bool); ok {
2258 r0 = returnFunc(ctx, expected)
2259 } else {
2260 r0 = ret.Get(0).(bool)
2261 }
2262 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RemoteRegistration) error); ok {
2263 r1 = returnFunc(ctx, expected)
2264 } else {
2265 r1 = ret.Error(1)
2266 }
2267 return r0, r1
2268}
2269
2270// MockBrokerService_RemoveHost_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveHost'
2271type MockBrokerService_RemoveHost_Call struct {
2272 *mock.Call
2273}
2274
2275// RemoveHost is a helper method to define mock.On call
2276// - ctx context.Context
2277// - expected domain.RemoteRegistration
2278func (_e *MockBrokerService_Expecter) RemoveHost(ctx any, expected any) *MockBrokerService_RemoveHost_Call {
2279 return &MockBrokerService_RemoveHost_Call{Call: _e.mock.On("RemoveHost", ctx, expected)}
2280}
2281
2282func (_c *MockBrokerService_RemoveHost_Call) Run(run func(ctx context.Context, expected domain.RemoteRegistration)) *MockBrokerService_RemoveHost_Call {
2283 _c.Call.Run(func(args mock.Arguments) {
2284 var arg0 context.Context
2285 if args[0] != nil {
2286 arg0 = args[0].(context.Context)
2287 }
2288 var arg1 domain.RemoteRegistration
2289 if args[1] != nil {
2290 arg1 = args[1].(domain.RemoteRegistration)
2291 }
2292 run(
2293 arg0,
2294 arg1,
2295 )
2296 })
2297 return _c
2298}
2299
2300func (_c *MockBrokerService_RemoveHost_Call) Return(b bool, err error) *MockBrokerService_RemoveHost_Call {
2301 _c.Call.Return(b, err)
2302 return _c
2303}
2304
2305func (_c *MockBrokerService_RemoveHost_Call) RunAndReturn(run func(ctx context.Context, expected domain.RemoteRegistration) (bool, error)) *MockBrokerService_RemoveHost_Call {
2306 _c.Call.Return(run)
2307 return _c
2308}
2309
2310// RequestReconcile provides a mock function for the type MockBrokerService
2311func (_mock *MockBrokerService) RequestReconcile(endpoint string) {
2312 _mock.Called(endpoint)
2313 return
2314}
2315
2316// MockBrokerService_RequestReconcile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RequestReconcile'
2317type MockBrokerService_RequestReconcile_Call struct {
2318 *mock.Call
2319}
2320
2321// RequestReconcile is a helper method to define mock.On call
2322// - endpoint string
2323func (_e *MockBrokerService_Expecter) RequestReconcile(endpoint any) *MockBrokerService_RequestReconcile_Call {
2324 return &MockBrokerService_RequestReconcile_Call{Call: _e.mock.On("RequestReconcile", endpoint)}
2325}
2326
2327func (_c *MockBrokerService_RequestReconcile_Call) Run(run func(endpoint string)) *MockBrokerService_RequestReconcile_Call {
2328 _c.Call.Run(func(args mock.Arguments) {
2329 var arg0 string
2330 if args[0] != nil {
2331 arg0 = args[0].(string)
2332 }
2333 run(
2334 arg0,
2335 )
2336 })
2337 return _c
2338}
2339
2340func (_c *MockBrokerService_RequestReconcile_Call) Return() *MockBrokerService_RequestReconcile_Call {
2341 _c.Call.Return()
2342 return _c
2343}
2344
2345func (_c *MockBrokerService_RequestReconcile_Call) RunAndReturn(run func(endpoint string)) *MockBrokerService_RequestReconcile_Call {
2346 _c.Run(run)
2347 return _c
2348}
2349
2350// Snapshot provides a mock function for the type MockBrokerService
2351func (_mock *MockBrokerService) Snapshot() ports.BrokerSnapshot {
2352 ret := _mock.Called()
2353
2354 if len(ret) == 0 {
2355 panic("no return value specified for Snapshot")
2356 }
2357
2358 var r0 ports.BrokerSnapshot
2359 if returnFunc, ok := ret.Get(0).(func() ports.BrokerSnapshot); ok {
2360 r0 = returnFunc()
2361 } else {
2362 r0 = ret.Get(0).(ports.BrokerSnapshot)
2363 }
2364 return r0
2365}
2366
2367// MockBrokerService_Snapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Snapshot'
2368type MockBrokerService_Snapshot_Call struct {
2369 *mock.Call
2370}
2371
2372// Snapshot is a helper method to define mock.On call
2373func (_e *MockBrokerService_Expecter) Snapshot() *MockBrokerService_Snapshot_Call {
2374 return &MockBrokerService_Snapshot_Call{Call: _e.mock.On("Snapshot")}
2375}
2376
2377func (_c *MockBrokerService_Snapshot_Call) Run(run func()) *MockBrokerService_Snapshot_Call {
2378 _c.Call.Run(func(args mock.Arguments) {
2379 run()
2380 })
2381 return _c
2382}
2383
2384func (_c *MockBrokerService_Snapshot_Call) Return(brokerSnapshot ports.BrokerSnapshot) *MockBrokerService_Snapshot_Call {
2385 _c.Call.Return(brokerSnapshot)
2386 return _c
2387}
2388
2389func (_c *MockBrokerService_Snapshot_Call) RunAndReturn(run func() ports.BrokerSnapshot) *MockBrokerService_Snapshot_Call {
2390 _c.Call.Return(run)
2391 return _c
2392}
2393
2394// Subscribe provides a mock function for the type MockBrokerService
2395func (_mock *MockBrokerService) Subscribe() (ports.BrokerSubscription, error) {
2396 ret := _mock.Called()
2397
2398 if len(ret) == 0 {
2399 panic("no return value specified for Subscribe")
2400 }
2401
2402 var r0 ports.BrokerSubscription
2403 var r1 error
2404 if returnFunc, ok := ret.Get(0).(func() (ports.BrokerSubscription, error)); ok {
2405 return returnFunc()
2406 }
2407 if returnFunc, ok := ret.Get(0).(func() ports.BrokerSubscription); ok {
2408 r0 = returnFunc()
2409 } else {
2410 if ret.Get(0) != nil {
2411 r0 = ret.Get(0).(ports.BrokerSubscription)
2412 }
2413 }
2414 if returnFunc, ok := ret.Get(1).(func() error); ok {
2415 r1 = returnFunc()
2416 } else {
2417 r1 = ret.Error(1)
2418 }
2419 return r0, r1
2420}
2421
2422// MockBrokerService_Subscribe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Subscribe'
2423type MockBrokerService_Subscribe_Call struct {
2424 *mock.Call
2425}
2426
2427// Subscribe is a helper method to define mock.On call
2428func (_e *MockBrokerService_Expecter) Subscribe() *MockBrokerService_Subscribe_Call {
2429 return &MockBrokerService_Subscribe_Call{Call: _e.mock.On("Subscribe")}
2430}
2431
2432func (_c *MockBrokerService_Subscribe_Call) Run(run func()) *MockBrokerService_Subscribe_Call {
2433 _c.Call.Run(func(args mock.Arguments) {
2434 run()
2435 })
2436 return _c
2437}
2438
2439func (_c *MockBrokerService_Subscribe_Call) Return(brokerSubscription ports.BrokerSubscription, err error) *MockBrokerService_Subscribe_Call {
2440 _c.Call.Return(brokerSubscription, err)
2441 return _c
2442}
2443
2444func (_c *MockBrokerService_Subscribe_Call) RunAndReturn(run func() (ports.BrokerSubscription, error)) *MockBrokerService_Subscribe_Call {
2445 _c.Call.Return(run)
2446 return _c
2447}
2448
2449// SubscribePreview provides a mock function for the type MockBrokerService
2450func (_mock *MockBrokerService) SubscribePreview(request ports.BrokerPreviewRequest) (ports.BrokerPreviewSubscription, error) {
2451 ret := _mock.Called(request)
2452
2453 if len(ret) == 0 {
2454 panic("no return value specified for SubscribePreview")
2455 }
2456
2457 var r0 ports.BrokerPreviewSubscription
2458 var r1 error
2459 if returnFunc, ok := ret.Get(0).(func(ports.BrokerPreviewRequest) (ports.BrokerPreviewSubscription, error)); ok {
2460 return returnFunc(request)
2461 }
2462 if returnFunc, ok := ret.Get(0).(func(ports.BrokerPreviewRequest) ports.BrokerPreviewSubscription); ok {
2463 r0 = returnFunc(request)
2464 } else {
2465 if ret.Get(0) != nil {
2466 r0 = ret.Get(0).(ports.BrokerPreviewSubscription)
2467 }
2468 }
2469 if returnFunc, ok := ret.Get(1).(func(ports.BrokerPreviewRequest) error); ok {
2470 r1 = returnFunc(request)
2471 } else {
2472 r1 = ret.Error(1)
2473 }
2474 return r0, r1
2475}
2476
2477// MockBrokerService_SubscribePreview_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubscribePreview'
2478type MockBrokerService_SubscribePreview_Call struct {
2479 *mock.Call
2480}
2481
2482// SubscribePreview is a helper method to define mock.On call
2483// - request ports.BrokerPreviewRequest
2484func (_e *MockBrokerService_Expecter) SubscribePreview(request any) *MockBrokerService_SubscribePreview_Call {
2485 return &MockBrokerService_SubscribePreview_Call{Call: _e.mock.On("SubscribePreview", request)}
2486}
2487
2488func (_c *MockBrokerService_SubscribePreview_Call) Run(run func(request ports.BrokerPreviewRequest)) *MockBrokerService_SubscribePreview_Call {
2489 _c.Call.Run(func(args mock.Arguments) {
2490 var arg0 ports.BrokerPreviewRequest
2491 if args[0] != nil {
2492 arg0 = args[0].(ports.BrokerPreviewRequest)
2493 }
2494 run(
2495 arg0,
2496 )
2497 })
2498 return _c
2499}
2500
2501func (_c *MockBrokerService_SubscribePreview_Call) Return(brokerPreviewSubscription ports.BrokerPreviewSubscription, err error) *MockBrokerService_SubscribePreview_Call {
2502 _c.Call.Return(brokerPreviewSubscription, err)
2503 return _c
2504}
2505
2506func (_c *MockBrokerService_SubscribePreview_Call) RunAndReturn(run func(request ports.BrokerPreviewRequest) (ports.BrokerPreviewSubscription, error)) *MockBrokerService_SubscribePreview_Call {
2507 _c.Call.Return(run)
2508 return _c
2509}
2510
2511// UpdateHostPolicy provides a mock function for the type MockBrokerService
2512func (_mock *MockBrokerService) UpdateHostPolicy(ctx context.Context, expected domain.RemoteRegistration, policy ports.BrokerPolicy) (domain.RemoteRegistration, error) {
2513 ret := _mock.Called(ctx, expected, policy)
2514
2515 if len(ret) == 0 {
2516 panic("no return value specified for UpdateHostPolicy")
2517 }
2518
2519 var r0 domain.RemoteRegistration
2520 var r1 error
2521 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteRegistration, ports.BrokerPolicy) (domain.RemoteRegistration, error)); ok {
2522 return returnFunc(ctx, expected, policy)
2523 }
2524 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteRegistration, ports.BrokerPolicy) domain.RemoteRegistration); ok {
2525 r0 = returnFunc(ctx, expected, policy)
2526 } else {
2527 r0 = ret.Get(0).(domain.RemoteRegistration)
2528 }
2529 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RemoteRegistration, ports.BrokerPolicy) error); ok {
2530 r1 = returnFunc(ctx, expected, policy)
2531 } else {
2532 r1 = ret.Error(1)
2533 }
2534 return r0, r1
2535}
2536
2537// MockBrokerService_UpdateHostPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateHostPolicy'
2538type MockBrokerService_UpdateHostPolicy_Call struct {
2539 *mock.Call
2540}
2541
2542// UpdateHostPolicy is a helper method to define mock.On call
2543// - ctx context.Context
2544// - expected domain.RemoteRegistration
2545// - policy ports.BrokerPolicy
2546func (_e *MockBrokerService_Expecter) UpdateHostPolicy(ctx any, expected any, policy any) *MockBrokerService_UpdateHostPolicy_Call {
2547 return &MockBrokerService_UpdateHostPolicy_Call{Call: _e.mock.On("UpdateHostPolicy", ctx, expected, policy)}
2548}
2549
2550func (_c *MockBrokerService_UpdateHostPolicy_Call) Run(run func(ctx context.Context, expected domain.RemoteRegistration, policy ports.BrokerPolicy)) *MockBrokerService_UpdateHostPolicy_Call {
2551 _c.Call.Run(func(args mock.Arguments) {
2552 var arg0 context.Context
2553 if args[0] != nil {
2554 arg0 = args[0].(context.Context)
2555 }
2556 var arg1 domain.RemoteRegistration
2557 if args[1] != nil {
2558 arg1 = args[1].(domain.RemoteRegistration)
2559 }
2560 var arg2 ports.BrokerPolicy
2561 if args[2] != nil {
2562 arg2 = args[2].(ports.BrokerPolicy)
2563 }
2564 run(
2565 arg0,
2566 arg1,
2567 arg2,
2568 )
2569 })
2570 return _c
2571}
2572
2573func (_c *MockBrokerService_UpdateHostPolicy_Call) Return(remoteRegistration domain.RemoteRegistration, err error) *MockBrokerService_UpdateHostPolicy_Call {
2574 _c.Call.Return(remoteRegistration, err)
2575 return _c
2576}
2577
2578func (_c *MockBrokerService_UpdateHostPolicy_Call) RunAndReturn(run func(ctx context.Context, expected domain.RemoteRegistration, policy ports.BrokerPolicy) (domain.RemoteRegistration, error)) *MockBrokerService_UpdateHostPolicy_Call {
2579 _c.Call.Return(run)
2580 return _c
2581}
2582
2583// NewMockBrokerNavigator creates a new instance of MockBrokerNavigator. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
2584// The first argument is typically a *testing.T value.
2585func NewMockBrokerNavigator(t interface {
2586 mock.TestingT
2587 Cleanup(func())
2588}) *MockBrokerNavigator {
2589 if helper, ok := t.(interface{ Helper() }); ok {
2590 helper.Helper()
2591 }
2592
2593 mock := &MockBrokerNavigator{}
2594 mock.Mock.Test(t)
2595
2596 t.Cleanup(func() {
2597 if helper, ok := t.(interface{ Helper() }); ok {
2598 helper.Helper()
2599 }
2600 mock.AssertExpectations(t)
2601 })
2602
2603 return mock
2604}
2605
2606// MockBrokerNavigator is an autogenerated mock type for the BrokerNavigator type
2607type MockBrokerNavigator struct {
2608 mock.Mock
2609}
2610
2611type MockBrokerNavigator_Expecter struct {
2612 mock *mock.Mock
2613}
2614
2615func (_m *MockBrokerNavigator) EXPECT() *MockBrokerNavigator_Expecter {
2616 return &MockBrokerNavigator_Expecter{mock: &_m.Mock}
2617}
2618
2619// Close provides a mock function for the type MockBrokerNavigator
2620func (_mock *MockBrokerNavigator) Close() error {
2621 ret := _mock.Called()
2622
2623 if len(ret) == 0 {
2624 panic("no return value specified for Close")
2625 }
2626
2627 var r0 error
2628 if returnFunc, ok := ret.Get(0).(func() error); ok {
2629 r0 = returnFunc()
2630 } else {
2631 r0 = ret.Error(0)
2632 }
2633 return r0
2634}
2635
2636// MockBrokerNavigator_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
2637type MockBrokerNavigator_Close_Call struct {
2638 *mock.Call
2639}
2640
2641// Close is a helper method to define mock.On call
2642func (_e *MockBrokerNavigator_Expecter) Close() *MockBrokerNavigator_Close_Call {
2643 return &MockBrokerNavigator_Close_Call{Call: _e.mock.On("Close")}
2644}
2645
2646func (_c *MockBrokerNavigator_Close_Call) Run(run func()) *MockBrokerNavigator_Close_Call {
2647 _c.Call.Run(func(args mock.Arguments) {
2648 run()
2649 })
2650 return _c
2651}
2652
2653func (_c *MockBrokerNavigator_Close_Call) Return(err error) *MockBrokerNavigator_Close_Call {
2654 _c.Call.Return(err)
2655 return _c
2656}
2657
2658func (_c *MockBrokerNavigator_Close_Call) RunAndReturn(run func() error) *MockBrokerNavigator_Close_Call {
2659 _c.Call.Return(run)
2660 return _c
2661}
2662
2663// ConnectionID provides a mock function for the type MockBrokerNavigator
2664func (_mock *MockBrokerNavigator) ConnectionID() ports.BrokerConnectionID {
2665 ret := _mock.Called()
2666
2667 if len(ret) == 0 {
2668 panic("no return value specified for ConnectionID")
2669 }
2670
2671 var r0 ports.BrokerConnectionID
2672 if returnFunc, ok := ret.Get(0).(func() ports.BrokerConnectionID); ok {
2673 r0 = returnFunc()
2674 } else {
2675 if ret.Get(0) != nil {
2676 r0 = ret.Get(0).(ports.BrokerConnectionID)
2677 }
2678 }
2679 return r0
2680}
2681
2682// MockBrokerNavigator_ConnectionID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectionID'
2683type MockBrokerNavigator_ConnectionID_Call struct {
2684 *mock.Call
2685}
2686
2687// ConnectionID is a helper method to define mock.On call
2688func (_e *MockBrokerNavigator_Expecter) ConnectionID() *MockBrokerNavigator_ConnectionID_Call {
2689 return &MockBrokerNavigator_ConnectionID_Call{Call: _e.mock.On("ConnectionID")}
2690}
2691
2692func (_c *MockBrokerNavigator_ConnectionID_Call) Run(run func()) *MockBrokerNavigator_ConnectionID_Call {
2693 _c.Call.Run(func(args mock.Arguments) {
2694 run()
2695 })
2696 return _c
2697}
2698
2699func (_c *MockBrokerNavigator_ConnectionID_Call) Return(brokerConnectionID ports.BrokerConnectionID) *MockBrokerNavigator_ConnectionID_Call {
2700 _c.Call.Return(brokerConnectionID)
2701 return _c
2702}
2703
2704func (_c *MockBrokerNavigator_ConnectionID_Call) RunAndReturn(run func() ports.BrokerConnectionID) *MockBrokerNavigator_ConnectionID_Call {
2705 _c.Call.Return(run)
2706 return _c
2707}
2708
2709// Done provides a mock function for the type MockBrokerNavigator
2710func (_mock *MockBrokerNavigator) Done() <-chan struct{} {
2711 ret := _mock.Called()
2712
2713 if len(ret) == 0 {
2714 panic("no return value specified for Done")
2715 }
2716
2717 var r0 <-chan struct{}
2718 if returnFunc, ok := ret.Get(0).(func() <-chan struct{}); ok {
2719 r0 = returnFunc()
2720 } else {
2721 if ret.Get(0) != nil {
2722 r0 = ret.Get(0).(<-chan struct{})
2723 }
2724 }
2725 return r0
2726}
2727
2728// MockBrokerNavigator_Done_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Done'
2729type MockBrokerNavigator_Done_Call struct {
2730 *mock.Call
2731}
2732
2733// Done is a helper method to define mock.On call
2734func (_e *MockBrokerNavigator_Expecter) Done() *MockBrokerNavigator_Done_Call {
2735 return &MockBrokerNavigator_Done_Call{Call: _e.mock.On("Done")}
2736}
2737
2738func (_c *MockBrokerNavigator_Done_Call) Run(run func()) *MockBrokerNavigator_Done_Call {
2739 _c.Call.Run(func(args mock.Arguments) {
2740 run()
2741 })
2742 return _c
2743}
2744
2745func (_c *MockBrokerNavigator_Done_Call) Return(valCh <-chan struct{}) *MockBrokerNavigator_Done_Call {
2746 _c.Call.Return(valCh)
2747 return _c
2748}
2749
2750func (_c *MockBrokerNavigator_Done_Call) RunAndReturn(run func() <-chan struct{}) *MockBrokerNavigator_Done_Call {
2751 _c.Call.Return(run)
2752 return _c
2753}
2754
2755// Err provides a mock function for the type MockBrokerNavigator
2756func (_mock *MockBrokerNavigator) Err() error {
2757 ret := _mock.Called()
2758
2759 if len(ret) == 0 {
2760 panic("no return value specified for Err")
2761 }
2762
2763 var r0 error
2764 if returnFunc, ok := ret.Get(0).(func() error); ok {
2765 r0 = returnFunc()
2766 } else {
2767 r0 = ret.Error(0)
2768 }
2769 return r0
2770}
2771
2772// MockBrokerNavigator_Err_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Err'
2773type MockBrokerNavigator_Err_Call struct {
2774 *mock.Call
2775}
2776
2777// Err is a helper method to define mock.On call
2778func (_e *MockBrokerNavigator_Expecter) Err() *MockBrokerNavigator_Err_Call {
2779 return &MockBrokerNavigator_Err_Call{Call: _e.mock.On("Err")}
2780}
2781
2782func (_c *MockBrokerNavigator_Err_Call) Run(run func()) *MockBrokerNavigator_Err_Call {
2783 _c.Call.Run(func(args mock.Arguments) {
2784 run()
2785 })
2786 return _c
2787}
2788
2789func (_c *MockBrokerNavigator_Err_Call) Return(err error) *MockBrokerNavigator_Err_Call {
2790 _c.Call.Return(err)
2791 return _c
2792}
2793
2794func (_c *MockBrokerNavigator_Err_Call) RunAndReturn(run func() error) *MockBrokerNavigator_Err_Call {
2795 _c.Call.Return(run)
2796 return _c
2797}
2798
2799// NextStreamID provides a mock function for the type MockBrokerNavigator
2800func (_mock *MockBrokerNavigator) NextStreamID() (ports.BrokerStreamID, error) {
2801 ret := _mock.Called()
2802
2803 if len(ret) == 0 {
2804 panic("no return value specified for NextStreamID")
2805 }
2806
2807 var r0 ports.BrokerStreamID
2808 var r1 error
2809 if returnFunc, ok := ret.Get(0).(func() (ports.BrokerStreamID, error)); ok {
2810 return returnFunc()
2811 }
2812 if returnFunc, ok := ret.Get(0).(func() ports.BrokerStreamID); ok {
2813 r0 = returnFunc()
2814 } else {
2815 r0 = ret.Get(0).(ports.BrokerStreamID)
2816 }
2817 if returnFunc, ok := ret.Get(1).(func() error); ok {
2818 r1 = returnFunc()
2819 } else {
2820 r1 = ret.Error(1)
2821 }
2822 return r0, r1
2823}
2824
2825// MockBrokerNavigator_NextStreamID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NextStreamID'
2826type MockBrokerNavigator_NextStreamID_Call struct {
2827 *mock.Call
2828}
2829
2830// NextStreamID is a helper method to define mock.On call
2831func (_e *MockBrokerNavigator_Expecter) NextStreamID() *MockBrokerNavigator_NextStreamID_Call {
2832 return &MockBrokerNavigator_NextStreamID_Call{Call: _e.mock.On("NextStreamID")}
2833}
2834
2835func (_c *MockBrokerNavigator_NextStreamID_Call) Run(run func()) *MockBrokerNavigator_NextStreamID_Call {
2836 _c.Call.Run(func(args mock.Arguments) {
2837 run()
2838 })
2839 return _c
2840}
2841
2842func (_c *MockBrokerNavigator_NextStreamID_Call) Return(brokerStreamID ports.BrokerStreamID, err error) *MockBrokerNavigator_NextStreamID_Call {
2843 _c.Call.Return(brokerStreamID, err)
2844 return _c
2845}
2846
2847func (_c *MockBrokerNavigator_NextStreamID_Call) RunAndReturn(run func() (ports.BrokerStreamID, error)) *MockBrokerNavigator_NextStreamID_Call {
2848 _c.Call.Return(run)
2849 return _c
2850}
2851
2852// OpenStream provides a mock function for the type MockBrokerNavigator
2853func (_mock *MockBrokerNavigator) OpenStream(ctx context.Context, request ports.BrokerOpenStreamRequest) (ports.BrokerLogicalConnection, error) {
2854 ret := _mock.Called(ctx, request)
2855
2856 if len(ret) == 0 {
2857 panic("no return value specified for OpenStream")
2858 }
2859
2860 var r0 ports.BrokerLogicalConnection
2861 var r1 error
2862 if returnFunc, ok := ret.Get(0).(func(context.Context, ports.BrokerOpenStreamRequest) (ports.BrokerLogicalConnection, error)); ok {
2863 return returnFunc(ctx, request)
2864 }
2865 if returnFunc, ok := ret.Get(0).(func(context.Context, ports.BrokerOpenStreamRequest) ports.BrokerLogicalConnection); ok {
2866 r0 = returnFunc(ctx, request)
2867 } else {
2868 if ret.Get(0) != nil {
2869 r0 = ret.Get(0).(ports.BrokerLogicalConnection)
2870 }
2871 }
2872 if returnFunc, ok := ret.Get(1).(func(context.Context, ports.BrokerOpenStreamRequest) error); ok {
2873 r1 = returnFunc(ctx, request)
2874 } else {
2875 r1 = ret.Error(1)
2876 }
2877 return r0, r1
2878}
2879
2880// MockBrokerNavigator_OpenStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OpenStream'
2881type MockBrokerNavigator_OpenStream_Call struct {
2882 *mock.Call
2883}
2884
2885// OpenStream is a helper method to define mock.On call
2886// - ctx context.Context
2887// - request ports.BrokerOpenStreamRequest
2888func (_e *MockBrokerNavigator_Expecter) OpenStream(ctx any, request any) *MockBrokerNavigator_OpenStream_Call {
2889 return &MockBrokerNavigator_OpenStream_Call{Call: _e.mock.On("OpenStream", ctx, request)}
2890}
2891
2892func (_c *MockBrokerNavigator_OpenStream_Call) Run(run func(ctx context.Context, request ports.BrokerOpenStreamRequest)) *MockBrokerNavigator_OpenStream_Call {
2893 _c.Call.Run(func(args mock.Arguments) {
2894 var arg0 context.Context
2895 if args[0] != nil {
2896 arg0 = args[0].(context.Context)
2897 }
2898 var arg1 ports.BrokerOpenStreamRequest
2899 if args[1] != nil {
2900 arg1 = args[1].(ports.BrokerOpenStreamRequest)
2901 }
2902 run(
2903 arg0,
2904 arg1,
2905 )
2906 })
2907 return _c
2908}
2909
2910func (_c *MockBrokerNavigator_OpenStream_Call) Return(brokerLogicalConnection ports.BrokerLogicalConnection, err error) *MockBrokerNavigator_OpenStream_Call {
2911 _c.Call.Return(brokerLogicalConnection, err)
2912 return _c
2913}
2914
2915func (_c *MockBrokerNavigator_OpenStream_Call) RunAndReturn(run func(ctx context.Context, request ports.BrokerOpenStreamRequest) (ports.BrokerLogicalConnection, error)) *MockBrokerNavigator_OpenStream_Call {
2916 _c.Call.Return(run)
2917 return _c
2918}
2919
2920// RequestReconcile provides a mock function for the type MockBrokerNavigator
2921func (_mock *MockBrokerNavigator) RequestReconcile(endpoint string) {
2922 _mock.Called(endpoint)
2923 return
2924}
2925
2926// MockBrokerNavigator_RequestReconcile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RequestReconcile'
2927type MockBrokerNavigator_RequestReconcile_Call struct {
2928 *mock.Call
2929}
2930
2931// RequestReconcile is a helper method to define mock.On call
2932// - endpoint string
2933func (_e *MockBrokerNavigator_Expecter) RequestReconcile(endpoint any) *MockBrokerNavigator_RequestReconcile_Call {
2934 return &MockBrokerNavigator_RequestReconcile_Call{Call: _e.mock.On("RequestReconcile", endpoint)}
2935}
2936
2937func (_c *MockBrokerNavigator_RequestReconcile_Call) Run(run func(endpoint string)) *MockBrokerNavigator_RequestReconcile_Call {
2938 _c.Call.Run(func(args mock.Arguments) {
2939 var arg0 string
2940 if args[0] != nil {
2941 arg0 = args[0].(string)
2942 }
2943 run(
2944 arg0,
2945 )
2946 })
2947 return _c
2948}
2949
2950func (_c *MockBrokerNavigator_RequestReconcile_Call) Return() *MockBrokerNavigator_RequestReconcile_Call {
2951 _c.Call.Return()
2952 return _c
2953}
2954
2955func (_c *MockBrokerNavigator_RequestReconcile_Call) RunAndReturn(run func(endpoint string)) *MockBrokerNavigator_RequestReconcile_Call {
2956 _c.Run(run)
2957 return _c
2958}
2959
2960// Snapshot provides a mock function for the type MockBrokerNavigator
2961func (_mock *MockBrokerNavigator) Snapshot() ports.BrokerSnapshot {
2962 ret := _mock.Called()
2963
2964 if len(ret) == 0 {
2965 panic("no return value specified for Snapshot")
2966 }
2967
2968 var r0 ports.BrokerSnapshot
2969 if returnFunc, ok := ret.Get(0).(func() ports.BrokerSnapshot); ok {
2970 r0 = returnFunc()
2971 } else {
2972 r0 = ret.Get(0).(ports.BrokerSnapshot)
2973 }
2974 return r0
2975}
2976
2977// MockBrokerNavigator_Snapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Snapshot'
2978type MockBrokerNavigator_Snapshot_Call struct {
2979 *mock.Call
2980}
2981
2982// Snapshot is a helper method to define mock.On call
2983func (_e *MockBrokerNavigator_Expecter) Snapshot() *MockBrokerNavigator_Snapshot_Call {
2984 return &MockBrokerNavigator_Snapshot_Call{Call: _e.mock.On("Snapshot")}
2985}
2986
2987func (_c *MockBrokerNavigator_Snapshot_Call) Run(run func()) *MockBrokerNavigator_Snapshot_Call {
2988 _c.Call.Run(func(args mock.Arguments) {
2989 run()
2990 })
2991 return _c
2992}
2993
2994func (_c *MockBrokerNavigator_Snapshot_Call) Return(brokerSnapshot ports.BrokerSnapshot) *MockBrokerNavigator_Snapshot_Call {
2995 _c.Call.Return(brokerSnapshot)
2996 return _c
2997}
2998
2999func (_c *MockBrokerNavigator_Snapshot_Call) RunAndReturn(run func() ports.BrokerSnapshot) *MockBrokerNavigator_Snapshot_Call {
3000 _c.Call.Return(run)
3001 return _c
3002}
3003
3004// Subscribe provides a mock function for the type MockBrokerNavigator
3005func (_mock *MockBrokerNavigator) Subscribe() (ports.BrokerSubscription, error) {
3006 ret := _mock.Called()
3007
3008 if len(ret) == 0 {
3009 panic("no return value specified for Subscribe")
3010 }
3011
3012 var r0 ports.BrokerSubscription
3013 var r1 error
3014 if returnFunc, ok := ret.Get(0).(func() (ports.BrokerSubscription, error)); ok {
3015 return returnFunc()
3016 }
3017 if returnFunc, ok := ret.Get(0).(func() ports.BrokerSubscription); ok {
3018 r0 = returnFunc()
3019 } else {
3020 if ret.Get(0) != nil {
3021 r0 = ret.Get(0).(ports.BrokerSubscription)
3022 }
3023 }
3024 if returnFunc, ok := ret.Get(1).(func() error); ok {
3025 r1 = returnFunc()
3026 } else {
3027 r1 = ret.Error(1)
3028 }
3029 return r0, r1
3030}
3031
3032// MockBrokerNavigator_Subscribe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Subscribe'
3033type MockBrokerNavigator_Subscribe_Call struct {
3034 *mock.Call
3035}
3036
3037// Subscribe is a helper method to define mock.On call
3038func (_e *MockBrokerNavigator_Expecter) Subscribe() *MockBrokerNavigator_Subscribe_Call {
3039 return &MockBrokerNavigator_Subscribe_Call{Call: _e.mock.On("Subscribe")}
3040}
3041
3042func (_c *MockBrokerNavigator_Subscribe_Call) Run(run func()) *MockBrokerNavigator_Subscribe_Call {
3043 _c.Call.Run(func(args mock.Arguments) {
3044 run()
3045 })
3046 return _c
3047}
3048
3049func (_c *MockBrokerNavigator_Subscribe_Call) Return(brokerSubscription ports.BrokerSubscription, err error) *MockBrokerNavigator_Subscribe_Call {
3050 _c.Call.Return(brokerSubscription, err)
3051 return _c
3052}
3053
3054func (_c *MockBrokerNavigator_Subscribe_Call) RunAndReturn(run func() (ports.BrokerSubscription, error)) *MockBrokerNavigator_Subscribe_Call {
3055 _c.Call.Return(run)
3056 return _c
3057}
3058
3059// SubscribePreview provides a mock function for the type MockBrokerNavigator
3060func (_mock *MockBrokerNavigator) SubscribePreview(request ports.BrokerPreviewRequest) (ports.BrokerPreviewSubscription, error) {
3061 ret := _mock.Called(request)
3062
3063 if len(ret) == 0 {
3064 panic("no return value specified for SubscribePreview")
3065 }
3066
3067 var r0 ports.BrokerPreviewSubscription
3068 var r1 error
3069 if returnFunc, ok := ret.Get(0).(func(ports.BrokerPreviewRequest) (ports.BrokerPreviewSubscription, error)); ok {
3070 return returnFunc(request)
3071 }
3072 if returnFunc, ok := ret.Get(0).(func(ports.BrokerPreviewRequest) ports.BrokerPreviewSubscription); ok {
3073 r0 = returnFunc(request)
3074 } else {
3075 if ret.Get(0) != nil {
3076 r0 = ret.Get(0).(ports.BrokerPreviewSubscription)
3077 }
3078 }
3079 if returnFunc, ok := ret.Get(1).(func(ports.BrokerPreviewRequest) error); ok {
3080 r1 = returnFunc(request)
3081 } else {
3082 r1 = ret.Error(1)
3083 }
3084 return r0, r1
3085}
3086
3087// MockBrokerNavigator_SubscribePreview_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubscribePreview'
3088type MockBrokerNavigator_SubscribePreview_Call struct {
3089 *mock.Call
3090}
3091
3092// SubscribePreview is a helper method to define mock.On call
3093// - request ports.BrokerPreviewRequest
3094func (_e *MockBrokerNavigator_Expecter) SubscribePreview(request any) *MockBrokerNavigator_SubscribePreview_Call {
3095 return &MockBrokerNavigator_SubscribePreview_Call{Call: _e.mock.On("SubscribePreview", request)}
3096}
3097
3098func (_c *MockBrokerNavigator_SubscribePreview_Call) Run(run func(request ports.BrokerPreviewRequest)) *MockBrokerNavigator_SubscribePreview_Call {
3099 _c.Call.Run(func(args mock.Arguments) {
3100 var arg0 ports.BrokerPreviewRequest
3101 if args[0] != nil {
3102 arg0 = args[0].(ports.BrokerPreviewRequest)
3103 }
3104 run(
3105 arg0,
3106 )
3107 })
3108 return _c
3109}
3110
3111func (_c *MockBrokerNavigator_SubscribePreview_Call) Return(brokerPreviewSubscription ports.BrokerPreviewSubscription, err error) *MockBrokerNavigator_SubscribePreview_Call {
3112 _c.Call.Return(brokerPreviewSubscription, err)
3113 return _c
3114}
3115
3116func (_c *MockBrokerNavigator_SubscribePreview_Call) RunAndReturn(run func(request ports.BrokerPreviewRequest) (ports.BrokerPreviewSubscription, error)) *MockBrokerNavigator_SubscribePreview_Call {
3117 _c.Call.Return(run)
3118 return _c
3119}
3120
3121// NewMockBrokerEnvelopeStream creates a new instance of MockBrokerEnvelopeStream. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
3122// The first argument is typically a *testing.T value.
3123func NewMockBrokerEnvelopeStream(t interface {
3124 mock.TestingT
3125 Cleanup(func())
3126}) *MockBrokerEnvelopeStream {
3127 if helper, ok := t.(interface{ Helper() }); ok {
3128 helper.Helper()
3129 }
3130
3131 mock := &MockBrokerEnvelopeStream{}
3132 mock.Mock.Test(t)
3133
3134 t.Cleanup(func() {
3135 if helper, ok := t.(interface{ Helper() }); ok {
3136 helper.Helper()
3137 }
3138 mock.AssertExpectations(t)
3139 })
3140
3141 return mock
3142}
3143
3144// MockBrokerEnvelopeStream is an autogenerated mock type for the BrokerEnvelopeStream type
3145type MockBrokerEnvelopeStream struct {
3146 mock.Mock
3147}
3148
3149type MockBrokerEnvelopeStream_Expecter struct {
3150 mock *mock.Mock
3151}
3152
3153func (_m *MockBrokerEnvelopeStream) EXPECT() *MockBrokerEnvelopeStream_Expecter {
3154 return &MockBrokerEnvelopeStream_Expecter{mock: &_m.Mock}
3155}
3156
3157// Close provides a mock function for the type MockBrokerEnvelopeStream
3158func (_mock *MockBrokerEnvelopeStream) Close() error {
3159 ret := _mock.Called()
3160
3161 if len(ret) == 0 {
3162 panic("no return value specified for Close")
3163 }
3164
3165 var r0 error
3166 if returnFunc, ok := ret.Get(0).(func() error); ok {
3167 r0 = returnFunc()
3168 } else {
3169 r0 = ret.Error(0)
3170 }
3171 return r0
3172}
3173
3174// MockBrokerEnvelopeStream_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
3175type MockBrokerEnvelopeStream_Close_Call struct {
3176 *mock.Call
3177}
3178
3179// Close is a helper method to define mock.On call
3180func (_e *MockBrokerEnvelopeStream_Expecter) Close() *MockBrokerEnvelopeStream_Close_Call {
3181 return &MockBrokerEnvelopeStream_Close_Call{Call: _e.mock.On("Close")}
3182}
3183
3184func (_c *MockBrokerEnvelopeStream_Close_Call) Run(run func()) *MockBrokerEnvelopeStream_Close_Call {
3185 _c.Call.Run(func(args mock.Arguments) {
3186 run()
3187 })
3188 return _c
3189}
3190
3191func (_c *MockBrokerEnvelopeStream_Close_Call) Return(err error) *MockBrokerEnvelopeStream_Close_Call {
3192 _c.Call.Return(err)
3193 return _c
3194}
3195
3196func (_c *MockBrokerEnvelopeStream_Close_Call) RunAndReturn(run func() error) *MockBrokerEnvelopeStream_Close_Call {
3197 _c.Call.Return(run)
3198 return _c
3199}
3200
3201// Done provides a mock function for the type MockBrokerEnvelopeStream
3202func (_mock *MockBrokerEnvelopeStream) Done() <-chan struct{} {
3203 ret := _mock.Called()
3204
3205 if len(ret) == 0 {
3206 panic("no return value specified for Done")
3207 }
3208
3209 var r0 <-chan struct{}
3210 if returnFunc, ok := ret.Get(0).(func() <-chan struct{}); ok {
3211 r0 = returnFunc()
3212 } else {
3213 if ret.Get(0) != nil {
3214 r0 = ret.Get(0).(<-chan struct{})
3215 }
3216 }
3217 return r0
3218}
3219
3220// MockBrokerEnvelopeStream_Done_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Done'
3221type MockBrokerEnvelopeStream_Done_Call struct {
3222 *mock.Call
3223}
3224
3225// Done is a helper method to define mock.On call
3226func (_e *MockBrokerEnvelopeStream_Expecter) Done() *MockBrokerEnvelopeStream_Done_Call {
3227 return &MockBrokerEnvelopeStream_Done_Call{Call: _e.mock.On("Done")}
3228}
3229
3230func (_c *MockBrokerEnvelopeStream_Done_Call) Run(run func()) *MockBrokerEnvelopeStream_Done_Call {
3231 _c.Call.Run(func(args mock.Arguments) {
3232 run()
3233 })
3234 return _c
3235}
3236
3237func (_c *MockBrokerEnvelopeStream_Done_Call) Return(valCh <-chan struct{}) *MockBrokerEnvelopeStream_Done_Call {
3238 _c.Call.Return(valCh)
3239 return _c
3240}
3241
3242func (_c *MockBrokerEnvelopeStream_Done_Call) RunAndReturn(run func() <-chan struct{}) *MockBrokerEnvelopeStream_Done_Call {
3243 _c.Call.Return(run)
3244 return _c
3245}
3246
3247// Err provides a mock function for the type MockBrokerEnvelopeStream
3248func (_mock *MockBrokerEnvelopeStream) Err() error {
3249 ret := _mock.Called()
3250
3251 if len(ret) == 0 {
3252 panic("no return value specified for Err")
3253 }
3254
3255 var r0 error
3256 if returnFunc, ok := ret.Get(0).(func() error); ok {
3257 r0 = returnFunc()
3258 } else {
3259 r0 = ret.Error(0)
3260 }
3261 return r0
3262}
3263
3264// MockBrokerEnvelopeStream_Err_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Err'
3265type MockBrokerEnvelopeStream_Err_Call struct {
3266 *mock.Call
3267}
3268
3269// Err is a helper method to define mock.On call
3270func (_e *MockBrokerEnvelopeStream_Expecter) Err() *MockBrokerEnvelopeStream_Err_Call {
3271 return &MockBrokerEnvelopeStream_Err_Call{Call: _e.mock.On("Err")}
3272}
3273
3274func (_c *MockBrokerEnvelopeStream_Err_Call) Run(run func()) *MockBrokerEnvelopeStream_Err_Call {
3275 _c.Call.Run(func(args mock.Arguments) {
3276 run()
3277 })
3278 return _c
3279}
3280
3281func (_c *MockBrokerEnvelopeStream_Err_Call) Return(err error) *MockBrokerEnvelopeStream_Err_Call {
3282 _c.Call.Return(err)
3283 return _c
3284}
3285
3286func (_c *MockBrokerEnvelopeStream_Err_Call) RunAndReturn(run func() error) *MockBrokerEnvelopeStream_Err_Call {
3287 _c.Call.Return(run)
3288 return _c
3289}
3290
3291// RecvEnvelope provides a mock function for the type MockBrokerEnvelopeStream
3292func (_mock *MockBrokerEnvelopeStream) RecvEnvelope() ([]byte, error) {
3293 ret := _mock.Called()
3294
3295 if len(ret) == 0 {
3296 panic("no return value specified for RecvEnvelope")
3297 }
3298
3299 var r0 []byte
3300 var r1 error
3301 if returnFunc, ok := ret.Get(0).(func() ([]byte, error)); ok {
3302 return returnFunc()
3303 }
3304 if returnFunc, ok := ret.Get(0).(func() []byte); ok {
3305 r0 = returnFunc()
3306 } else {
3307 if ret.Get(0) != nil {
3308 r0 = ret.Get(0).([]byte)
3309 }
3310 }
3311 if returnFunc, ok := ret.Get(1).(func() error); ok {
3312 r1 = returnFunc()
3313 } else {
3314 r1 = ret.Error(1)
3315 }
3316 return r0, r1
3317}
3318
3319// MockBrokerEnvelopeStream_RecvEnvelope_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecvEnvelope'
3320type MockBrokerEnvelopeStream_RecvEnvelope_Call struct {
3321 *mock.Call
3322}
3323
3324// RecvEnvelope is a helper method to define mock.On call
3325func (_e *MockBrokerEnvelopeStream_Expecter) RecvEnvelope() *MockBrokerEnvelopeStream_RecvEnvelope_Call {
3326 return &MockBrokerEnvelopeStream_RecvEnvelope_Call{Call: _e.mock.On("RecvEnvelope")}
3327}
3328
3329func (_c *MockBrokerEnvelopeStream_RecvEnvelope_Call) Run(run func()) *MockBrokerEnvelopeStream_RecvEnvelope_Call {
3330 _c.Call.Run(func(args mock.Arguments) {
3331 run()
3332 })
3333 return _c
3334}
3335
3336func (_c *MockBrokerEnvelopeStream_RecvEnvelope_Call) Return(bytes []byte, err error) *MockBrokerEnvelopeStream_RecvEnvelope_Call {
3337 _c.Call.Return(bytes, err)
3338 return _c
3339}
3340
3341func (_c *MockBrokerEnvelopeStream_RecvEnvelope_Call) RunAndReturn(run func() ([]byte, error)) *MockBrokerEnvelopeStream_RecvEnvelope_Call {
3342 _c.Call.Return(run)
3343 return _c
3344}
3345
3346// SendEnvelope provides a mock function for the type MockBrokerEnvelopeStream
3347func (_mock *MockBrokerEnvelopeStream) SendEnvelope(bytes []byte) error {
3348 ret := _mock.Called(bytes)
3349
3350 if len(ret) == 0 {
3351 panic("no return value specified for SendEnvelope")
3352 }
3353
3354 var r0 error
3355 if returnFunc, ok := ret.Get(0).(func([]byte) error); ok {
3356 r0 = returnFunc(bytes)
3357 } else {
3358 r0 = ret.Error(0)
3359 }
3360 return r0
3361}
3362
3363// MockBrokerEnvelopeStream_SendEnvelope_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendEnvelope'
3364type MockBrokerEnvelopeStream_SendEnvelope_Call struct {
3365 *mock.Call
3366}
3367
3368// SendEnvelope is a helper method to define mock.On call
3369// - bytes []byte
3370func (_e *MockBrokerEnvelopeStream_Expecter) SendEnvelope(bytes any) *MockBrokerEnvelopeStream_SendEnvelope_Call {
3371 return &MockBrokerEnvelopeStream_SendEnvelope_Call{Call: _e.mock.On("SendEnvelope", bytes)}
3372}
3373
3374func (_c *MockBrokerEnvelopeStream_SendEnvelope_Call) Run(run func(bytes []byte)) *MockBrokerEnvelopeStream_SendEnvelope_Call {
3375 _c.Call.Run(func(args mock.Arguments) {
3376 var arg0 []byte
3377 if args[0] != nil {
3378 arg0 = args[0].([]byte)
3379 }
3380 run(
3381 arg0,
3382 )
3383 })
3384 return _c
3385}
3386
3387func (_c *MockBrokerEnvelopeStream_SendEnvelope_Call) Return(err error) *MockBrokerEnvelopeStream_SendEnvelope_Call {
3388 _c.Call.Return(err)
3389 return _c
3390}
3391
3392func (_c *MockBrokerEnvelopeStream_SendEnvelope_Call) RunAndReturn(run func(bytes []byte) error) *MockBrokerEnvelopeStream_SendEnvelope_Call {
3393 _c.Call.Return(run)
3394 return _c
3395}
3396
3397// NewMockBrokerCoreService creates a new instance of MockBrokerCoreService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
3398// The first argument is typically a *testing.T value.
3399func NewMockBrokerCoreService(t interface {
3400 mock.TestingT
3401 Cleanup(func())
3402}) *MockBrokerCoreService {
3403 if helper, ok := t.(interface{ Helper() }); ok {
3404 helper.Helper()
3405 }
3406
3407 mock := &MockBrokerCoreService{}
3408 mock.Mock.Test(t)
3409
3410 t.Cleanup(func() {
3411 if helper, ok := t.(interface{ Helper() }); ok {
3412 helper.Helper()
3413 }
3414 mock.AssertExpectations(t)
3415 })
3416
3417 return mock
3418}
3419
3420// MockBrokerCoreService is an autogenerated mock type for the BrokerCoreService type
3421type MockBrokerCoreService struct {
3422 mock.Mock
3423}
3424
3425type MockBrokerCoreService_Expecter struct {
3426 mock *mock.Mock
3427}
3428
3429func (_m *MockBrokerCoreService) EXPECT() *MockBrokerCoreService_Expecter {
3430 return &MockBrokerCoreService_Expecter{mock: &_m.Mock}
3431}
3432
3433// AddHost provides a mock function for the type MockBrokerCoreService
3434func (_mock *MockBrokerCoreService) AddHost(ctx context.Context, endpoint string, policy ports.BrokerPolicy) (domain.RemoteRegistration, error) {
3435 ret := _mock.Called(ctx, endpoint, policy)
3436
3437 if len(ret) == 0 {
3438 panic("no return value specified for AddHost")
3439 }
3440
3441 var r0 domain.RemoteRegistration
3442 var r1 error
3443 if returnFunc, ok := ret.Get(0).(func(context.Context, string, ports.BrokerPolicy) (domain.RemoteRegistration, error)); ok {
3444 return returnFunc(ctx, endpoint, policy)
3445 }
3446 if returnFunc, ok := ret.Get(0).(func(context.Context, string, ports.BrokerPolicy) domain.RemoteRegistration); ok {
3447 r0 = returnFunc(ctx, endpoint, policy)
3448 } else {
3449 r0 = ret.Get(0).(domain.RemoteRegistration)
3450 }
3451 if returnFunc, ok := ret.Get(1).(func(context.Context, string, ports.BrokerPolicy) error); ok {
3452 r1 = returnFunc(ctx, endpoint, policy)
3453 } else {
3454 r1 = ret.Error(1)
3455 }
3456 return r0, r1
3457}
3458
3459// MockBrokerCoreService_AddHost_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddHost'
3460type MockBrokerCoreService_AddHost_Call struct {
3461 *mock.Call
3462}
3463
3464// AddHost is a helper method to define mock.On call
3465// - ctx context.Context
3466// - endpoint string
3467// - policy ports.BrokerPolicy
3468func (_e *MockBrokerCoreService_Expecter) AddHost(ctx any, endpoint any, policy any) *MockBrokerCoreService_AddHost_Call {
3469 return &MockBrokerCoreService_AddHost_Call{Call: _e.mock.On("AddHost", ctx, endpoint, policy)}
3470}
3471
3472func (_c *MockBrokerCoreService_AddHost_Call) Run(run func(ctx context.Context, endpoint string, policy ports.BrokerPolicy)) *MockBrokerCoreService_AddHost_Call {
3473 _c.Call.Run(func(args mock.Arguments) {
3474 var arg0 context.Context
3475 if args[0] != nil {
3476 arg0 = args[0].(context.Context)
3477 }
3478 var arg1 string
3479 if args[1] != nil {
3480 arg1 = args[1].(string)
3481 }
3482 var arg2 ports.BrokerPolicy
3483 if args[2] != nil {
3484 arg2 = args[2].(ports.BrokerPolicy)
3485 }
3486 run(
3487 arg0,
3488 arg1,
3489 arg2,
3490 )
3491 })
3492 return _c
3493}
3494
3495func (_c *MockBrokerCoreService_AddHost_Call) Return(remoteRegistration domain.RemoteRegistration, err error) *MockBrokerCoreService_AddHost_Call {
3496 _c.Call.Return(remoteRegistration, err)
3497 return _c
3498}
3499
3500func (_c *MockBrokerCoreService_AddHost_Call) RunAndReturn(run func(ctx context.Context, endpoint string, policy ports.BrokerPolicy) (domain.RemoteRegistration, error)) *MockBrokerCoreService_AddHost_Call {
3501 _c.Call.Return(run)
3502 return _c
3503}
3504
3505// Close provides a mock function for the type MockBrokerCoreService
3506func (_mock *MockBrokerCoreService) Close() error {
3507 ret := _mock.Called()
3508
3509 if len(ret) == 0 {
3510 panic("no return value specified for Close")
3511 }
3512
3513 var r0 error
3514 if returnFunc, ok := ret.Get(0).(func() error); ok {
3515 r0 = returnFunc()
3516 } else {
3517 r0 = ret.Error(0)
3518 }
3519 return r0
3520}
3521
3522// MockBrokerCoreService_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
3523type MockBrokerCoreService_Close_Call struct {
3524 *mock.Call
3525}
3526
3527// Close is a helper method to define mock.On call
3528func (_e *MockBrokerCoreService_Expecter) Close() *MockBrokerCoreService_Close_Call {
3529 return &MockBrokerCoreService_Close_Call{Call: _e.mock.On("Close")}
3530}
3531
3532func (_c *MockBrokerCoreService_Close_Call) Run(run func()) *MockBrokerCoreService_Close_Call {
3533 _c.Call.Run(func(args mock.Arguments) {
3534 run()
3535 })
3536 return _c
3537}
3538
3539func (_c *MockBrokerCoreService_Close_Call) Return(err error) *MockBrokerCoreService_Close_Call {
3540 _c.Call.Return(err)
3541 return _c
3542}
3543
3544func (_c *MockBrokerCoreService_Close_Call) RunAndReturn(run func() error) *MockBrokerCoreService_Close_Call {
3545 _c.Call.Return(run)
3546 return _c
3547}
3548
3549// CloseStream provides a mock function for the type MockBrokerCoreService
3550func (_mock *MockBrokerCoreService) CloseStream(connection ports.BrokerConnectionID, stream ports.BrokerStreamID) error {
3551 ret := _mock.Called(connection, stream)
3552
3553 if len(ret) == 0 {
3554 panic("no return value specified for CloseStream")
3555 }
3556
3557 var r0 error
3558 if returnFunc, ok := ret.Get(0).(func(ports.BrokerConnectionID, ports.BrokerStreamID) error); ok {
3559 r0 = returnFunc(connection, stream)
3560 } else {
3561 r0 = ret.Error(0)
3562 }
3563 return r0
3564}
3565
3566// MockBrokerCoreService_CloseStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseStream'
3567type MockBrokerCoreService_CloseStream_Call struct {
3568 *mock.Call
3569}
3570
3571// CloseStream is a helper method to define mock.On call
3572// - connection ports.BrokerConnectionID
3573// - stream ports.BrokerStreamID
3574func (_e *MockBrokerCoreService_Expecter) CloseStream(connection any, stream any) *MockBrokerCoreService_CloseStream_Call {
3575 return &MockBrokerCoreService_CloseStream_Call{Call: _e.mock.On("CloseStream", connection, stream)}
3576}
3577
3578func (_c *MockBrokerCoreService_CloseStream_Call) Run(run func(connection ports.BrokerConnectionID, stream ports.BrokerStreamID)) *MockBrokerCoreService_CloseStream_Call {
3579 _c.Call.Run(func(args mock.Arguments) {
3580 var arg0 ports.BrokerConnectionID
3581 if args[0] != nil {
3582 arg0 = args[0].(ports.BrokerConnectionID)
3583 }
3584 var arg1 ports.BrokerStreamID
3585 if args[1] != nil {
3586 arg1 = args[1].(ports.BrokerStreamID)
3587 }
3588 run(
3589 arg0,
3590 arg1,
3591 )
3592 })
3593 return _c
3594}
3595
3596func (_c *MockBrokerCoreService_CloseStream_Call) Return(err error) *MockBrokerCoreService_CloseStream_Call {
3597 _c.Call.Return(err)
3598 return _c
3599}
3600
3601func (_c *MockBrokerCoreService_CloseStream_Call) RunAndReturn(run func(connection ports.BrokerConnectionID, stream ports.BrokerStreamID) error) *MockBrokerCoreService_CloseStream_Call {
3602 _c.Call.Return(run)
3603 return _c
3604}
3605
3606// ConnectionID provides a mock function for the type MockBrokerCoreService
3607func (_mock *MockBrokerCoreService) ConnectionID() ports.BrokerConnectionID {
3608 ret := _mock.Called()
3609
3610 if len(ret) == 0 {
3611 panic("no return value specified for ConnectionID")
3612 }
3613
3614 var r0 ports.BrokerConnectionID
3615 if returnFunc, ok := ret.Get(0).(func() ports.BrokerConnectionID); ok {
3616 r0 = returnFunc()
3617 } else {
3618 if ret.Get(0) != nil {
3619 r0 = ret.Get(0).(ports.BrokerConnectionID)
3620 }
3621 }
3622 return r0
3623}
3624
3625// MockBrokerCoreService_ConnectionID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectionID'
3626type MockBrokerCoreService_ConnectionID_Call struct {
3627 *mock.Call
3628}
3629
3630// ConnectionID is a helper method to define mock.On call
3631func (_e *MockBrokerCoreService_Expecter) ConnectionID() *MockBrokerCoreService_ConnectionID_Call {
3632 return &MockBrokerCoreService_ConnectionID_Call{Call: _e.mock.On("ConnectionID")}
3633}
3634
3635func (_c *MockBrokerCoreService_ConnectionID_Call) Run(run func()) *MockBrokerCoreService_ConnectionID_Call {
3636 _c.Call.Run(func(args mock.Arguments) {
3637 run()
3638 })
3639 return _c
3640}
3641
3642func (_c *MockBrokerCoreService_ConnectionID_Call) Return(brokerConnectionID ports.BrokerConnectionID) *MockBrokerCoreService_ConnectionID_Call {
3643 _c.Call.Return(brokerConnectionID)
3644 return _c
3645}
3646
3647func (_c *MockBrokerCoreService_ConnectionID_Call) RunAndReturn(run func() ports.BrokerConnectionID) *MockBrokerCoreService_ConnectionID_Call {
3648 _c.Call.Return(run)
3649 return _c
3650}
3651
3652// Done provides a mock function for the type MockBrokerCoreService
3653func (_mock *MockBrokerCoreService) Done() <-chan struct{} {
3654 ret := _mock.Called()
3655
3656 if len(ret) == 0 {
3657 panic("no return value specified for Done")
3658 }
3659
3660 var r0 <-chan struct{}
3661 if returnFunc, ok := ret.Get(0).(func() <-chan struct{}); ok {
3662 r0 = returnFunc()
3663 } else {
3664 if ret.Get(0) != nil {
3665 r0 = ret.Get(0).(<-chan struct{})
3666 }
3667 }
3668 return r0
3669}
3670
3671// MockBrokerCoreService_Done_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Done'
3672type MockBrokerCoreService_Done_Call struct {
3673 *mock.Call
3674}
3675
3676// Done is a helper method to define mock.On call
3677func (_e *MockBrokerCoreService_Expecter) Done() *MockBrokerCoreService_Done_Call {
3678 return &MockBrokerCoreService_Done_Call{Call: _e.mock.On("Done")}
3679}
3680
3681func (_c *MockBrokerCoreService_Done_Call) Run(run func()) *MockBrokerCoreService_Done_Call {
3682 _c.Call.Run(func(args mock.Arguments) {
3683 run()
3684 })
3685 return _c
3686}
3687
3688func (_c *MockBrokerCoreService_Done_Call) Return(valCh <-chan struct{}) *MockBrokerCoreService_Done_Call {
3689 _c.Call.Return(valCh)
3690 return _c
3691}
3692
3693func (_c *MockBrokerCoreService_Done_Call) RunAndReturn(run func() <-chan struct{}) *MockBrokerCoreService_Done_Call {
3694 _c.Call.Return(run)
3695 return _c
3696}
3697
3698// Err provides a mock function for the type MockBrokerCoreService
3699func (_mock *MockBrokerCoreService) Err() error {
3700 ret := _mock.Called()
3701
3702 if len(ret) == 0 {
3703 panic("no return value specified for Err")
3704 }
3705
3706 var r0 error
3707 if returnFunc, ok := ret.Get(0).(func() error); ok {
3708 r0 = returnFunc()
3709 } else {
3710 r0 = ret.Error(0)
3711 }
3712 return r0
3713}
3714
3715// MockBrokerCoreService_Err_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Err'
3716type MockBrokerCoreService_Err_Call struct {
3717 *mock.Call
3718}
3719
3720// Err is a helper method to define mock.On call
3721func (_e *MockBrokerCoreService_Expecter) Err() *MockBrokerCoreService_Err_Call {
3722 return &MockBrokerCoreService_Err_Call{Call: _e.mock.On("Err")}
3723}
3724
3725func (_c *MockBrokerCoreService_Err_Call) Run(run func()) *MockBrokerCoreService_Err_Call {
3726 _c.Call.Run(func(args mock.Arguments) {
3727 run()
3728 })
3729 return _c
3730}
3731
3732func (_c *MockBrokerCoreService_Err_Call) Return(err error) *MockBrokerCoreService_Err_Call {
3733 _c.Call.Return(err)
3734 return _c
3735}
3736
3737func (_c *MockBrokerCoreService_Err_Call) RunAndReturn(run func() error) *MockBrokerCoreService_Err_Call {
3738 _c.Call.Return(run)
3739 return _c
3740}
3741
3742// NextStreamID provides a mock function for the type MockBrokerCoreService
3743func (_mock *MockBrokerCoreService) NextStreamID() (ports.BrokerStreamID, error) {
3744 ret := _mock.Called()
3745
3746 if len(ret) == 0 {
3747 panic("no return value specified for NextStreamID")
3748 }
3749
3750 var r0 ports.BrokerStreamID
3751 var r1 error
3752 if returnFunc, ok := ret.Get(0).(func() (ports.BrokerStreamID, error)); ok {
3753 return returnFunc()
3754 }
3755 if returnFunc, ok := ret.Get(0).(func() ports.BrokerStreamID); ok {
3756 r0 = returnFunc()
3757 } else {
3758 r0 = ret.Get(0).(ports.BrokerStreamID)
3759 }
3760 if returnFunc, ok := ret.Get(1).(func() error); ok {
3761 r1 = returnFunc()
3762 } else {
3763 r1 = ret.Error(1)
3764 }
3765 return r0, r1
3766}
3767
3768// MockBrokerCoreService_NextStreamID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NextStreamID'
3769type MockBrokerCoreService_NextStreamID_Call struct {
3770 *mock.Call
3771}
3772
3773// NextStreamID is a helper method to define mock.On call
3774func (_e *MockBrokerCoreService_Expecter) NextStreamID() *MockBrokerCoreService_NextStreamID_Call {
3775 return &MockBrokerCoreService_NextStreamID_Call{Call: _e.mock.On("NextStreamID")}
3776}
3777
3778func (_c *MockBrokerCoreService_NextStreamID_Call) Run(run func()) *MockBrokerCoreService_NextStreamID_Call {
3779 _c.Call.Run(func(args mock.Arguments) {
3780 run()
3781 })
3782 return _c
3783}
3784
3785func (_c *MockBrokerCoreService_NextStreamID_Call) Return(brokerStreamID ports.BrokerStreamID, err error) *MockBrokerCoreService_NextStreamID_Call {
3786 _c.Call.Return(brokerStreamID, err)
3787 return _c
3788}
3789
3790func (_c *MockBrokerCoreService_NextStreamID_Call) RunAndReturn(run func() (ports.BrokerStreamID, error)) *MockBrokerCoreService_NextStreamID_Call {
3791 _c.Call.Return(run)
3792 return _c
3793}
3794
3795// OpenEnvelopeStream provides a mock function for the type MockBrokerCoreService
3796func (_mock *MockBrokerCoreService) OpenEnvelopeStream(ctx context.Context, request ports.BrokerOpenStreamRequest) (ports.BrokerEnvelopeStream, error) {
3797 ret := _mock.Called(ctx, request)
3798
3799 if len(ret) == 0 {
3800 panic("no return value specified for OpenEnvelopeStream")
3801 }
3802
3803 var r0 ports.BrokerEnvelopeStream
3804 var r1 error
3805 if returnFunc, ok := ret.Get(0).(func(context.Context, ports.BrokerOpenStreamRequest) (ports.BrokerEnvelopeStream, error)); ok {
3806 return returnFunc(ctx, request)
3807 }
3808 if returnFunc, ok := ret.Get(0).(func(context.Context, ports.BrokerOpenStreamRequest) ports.BrokerEnvelopeStream); ok {
3809 r0 = returnFunc(ctx, request)
3810 } else {
3811 if ret.Get(0) != nil {
3812 r0 = ret.Get(0).(ports.BrokerEnvelopeStream)
3813 }
3814 }
3815 if returnFunc, ok := ret.Get(1).(func(context.Context, ports.BrokerOpenStreamRequest) error); ok {
3816 r1 = returnFunc(ctx, request)
3817 } else {
3818 r1 = ret.Error(1)
3819 }
3820 return r0, r1
3821}
3822
3823// MockBrokerCoreService_OpenEnvelopeStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OpenEnvelopeStream'
3824type MockBrokerCoreService_OpenEnvelopeStream_Call struct {
3825 *mock.Call
3826}
3827
3828// OpenEnvelopeStream is a helper method to define mock.On call
3829// - ctx context.Context
3830// - request ports.BrokerOpenStreamRequest
3831func (_e *MockBrokerCoreService_Expecter) OpenEnvelopeStream(ctx any, request any) *MockBrokerCoreService_OpenEnvelopeStream_Call {
3832 return &MockBrokerCoreService_OpenEnvelopeStream_Call{Call: _e.mock.On("OpenEnvelopeStream", ctx, request)}
3833}
3834
3835func (_c *MockBrokerCoreService_OpenEnvelopeStream_Call) Run(run func(ctx context.Context, request ports.BrokerOpenStreamRequest)) *MockBrokerCoreService_OpenEnvelopeStream_Call {
3836 _c.Call.Run(func(args mock.Arguments) {
3837 var arg0 context.Context
3838 if args[0] != nil {
3839 arg0 = args[0].(context.Context)
3840 }
3841 var arg1 ports.BrokerOpenStreamRequest
3842 if args[1] != nil {
3843 arg1 = args[1].(ports.BrokerOpenStreamRequest)
3844 }
3845 run(
3846 arg0,
3847 arg1,
3848 )
3849 })
3850 return _c
3851}
3852
3853func (_c *MockBrokerCoreService_OpenEnvelopeStream_Call) Return(brokerEnvelopeStream ports.BrokerEnvelopeStream, err error) *MockBrokerCoreService_OpenEnvelopeStream_Call {
3854 _c.Call.Return(brokerEnvelopeStream, err)
3855 return _c
3856}
3857
3858func (_c *MockBrokerCoreService_OpenEnvelopeStream_Call) RunAndReturn(run func(ctx context.Context, request ports.BrokerOpenStreamRequest) (ports.BrokerEnvelopeStream, error)) *MockBrokerCoreService_OpenEnvelopeStream_Call {
3859 _c.Call.Return(run)
3860 return _c
3861}
3862
3863// RemoveHost provides a mock function for the type MockBrokerCoreService
3864func (_mock *MockBrokerCoreService) RemoveHost(ctx context.Context, expected domain.RemoteRegistration) (bool, error) {
3865 ret := _mock.Called(ctx, expected)
3866
3867 if len(ret) == 0 {
3868 panic("no return value specified for RemoveHost")
3869 }
3870
3871 var r0 bool
3872 var r1 error
3873 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteRegistration) (bool, error)); ok {
3874 return returnFunc(ctx, expected)
3875 }
3876 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteRegistration) bool); ok {
3877 r0 = returnFunc(ctx, expected)
3878 } else {
3879 r0 = ret.Get(0).(bool)
3880 }
3881 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RemoteRegistration) error); ok {
3882 r1 = returnFunc(ctx, expected)
3883 } else {
3884 r1 = ret.Error(1)
3885 }
3886 return r0, r1
3887}
3888
3889// MockBrokerCoreService_RemoveHost_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveHost'
3890type MockBrokerCoreService_RemoveHost_Call struct {
3891 *mock.Call
3892}
3893
3894// RemoveHost is a helper method to define mock.On call
3895// - ctx context.Context
3896// - expected domain.RemoteRegistration
3897func (_e *MockBrokerCoreService_Expecter) RemoveHost(ctx any, expected any) *MockBrokerCoreService_RemoveHost_Call {
3898 return &MockBrokerCoreService_RemoveHost_Call{Call: _e.mock.On("RemoveHost", ctx, expected)}
3899}
3900
3901func (_c *MockBrokerCoreService_RemoveHost_Call) Run(run func(ctx context.Context, expected domain.RemoteRegistration)) *MockBrokerCoreService_RemoveHost_Call {
3902 _c.Call.Run(func(args mock.Arguments) {
3903 var arg0 context.Context
3904 if args[0] != nil {
3905 arg0 = args[0].(context.Context)
3906 }
3907 var arg1 domain.RemoteRegistration
3908 if args[1] != nil {
3909 arg1 = args[1].(domain.RemoteRegistration)
3910 }
3911 run(
3912 arg0,
3913 arg1,
3914 )
3915 })
3916 return _c
3917}
3918
3919func (_c *MockBrokerCoreService_RemoveHost_Call) Return(b bool, err error) *MockBrokerCoreService_RemoveHost_Call {
3920 _c.Call.Return(b, err)
3921 return _c
3922}
3923
3924func (_c *MockBrokerCoreService_RemoveHost_Call) RunAndReturn(run func(ctx context.Context, expected domain.RemoteRegistration) (bool, error)) *MockBrokerCoreService_RemoveHost_Call {
3925 _c.Call.Return(run)
3926 return _c
3927}
3928
3929// RequestReconcile provides a mock function for the type MockBrokerCoreService
3930func (_mock *MockBrokerCoreService) RequestReconcile(endpoint string) {
3931 _mock.Called(endpoint)
3932 return
3933}
3934
3935// MockBrokerCoreService_RequestReconcile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RequestReconcile'
3936type MockBrokerCoreService_RequestReconcile_Call struct {
3937 *mock.Call
3938}
3939
3940// RequestReconcile is a helper method to define mock.On call
3941// - endpoint string
3942func (_e *MockBrokerCoreService_Expecter) RequestReconcile(endpoint any) *MockBrokerCoreService_RequestReconcile_Call {
3943 return &MockBrokerCoreService_RequestReconcile_Call{Call: _e.mock.On("RequestReconcile", endpoint)}
3944}
3945
3946func (_c *MockBrokerCoreService_RequestReconcile_Call) Run(run func(endpoint string)) *MockBrokerCoreService_RequestReconcile_Call {
3947 _c.Call.Run(func(args mock.Arguments) {
3948 var arg0 string
3949 if args[0] != nil {
3950 arg0 = args[0].(string)
3951 }
3952 run(
3953 arg0,
3954 )
3955 })
3956 return _c
3957}
3958
3959func (_c *MockBrokerCoreService_RequestReconcile_Call) Return() *MockBrokerCoreService_RequestReconcile_Call {
3960 _c.Call.Return()
3961 return _c
3962}
3963
3964func (_c *MockBrokerCoreService_RequestReconcile_Call) RunAndReturn(run func(endpoint string)) *MockBrokerCoreService_RequestReconcile_Call {
3965 _c.Run(run)
3966 return _c
3967}
3968
3969// Snapshot provides a mock function for the type MockBrokerCoreService
3970func (_mock *MockBrokerCoreService) Snapshot() ports.BrokerSnapshot {
3971 ret := _mock.Called()
3972
3973 if len(ret) == 0 {
3974 panic("no return value specified for Snapshot")
3975 }
3976
3977 var r0 ports.BrokerSnapshot
3978 if returnFunc, ok := ret.Get(0).(func() ports.BrokerSnapshot); ok {
3979 r0 = returnFunc()
3980 } else {
3981 r0 = ret.Get(0).(ports.BrokerSnapshot)
3982 }
3983 return r0
3984}
3985
3986// MockBrokerCoreService_Snapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Snapshot'
3987type MockBrokerCoreService_Snapshot_Call struct {
3988 *mock.Call
3989}
3990
3991// Snapshot is a helper method to define mock.On call
3992func (_e *MockBrokerCoreService_Expecter) Snapshot() *MockBrokerCoreService_Snapshot_Call {
3993 return &MockBrokerCoreService_Snapshot_Call{Call: _e.mock.On("Snapshot")}
3994}
3995
3996func (_c *MockBrokerCoreService_Snapshot_Call) Run(run func()) *MockBrokerCoreService_Snapshot_Call {
3997 _c.Call.Run(func(args mock.Arguments) {
3998 run()
3999 })
4000 return _c
4001}
4002
4003func (_c *MockBrokerCoreService_Snapshot_Call) Return(brokerSnapshot ports.BrokerSnapshot) *MockBrokerCoreService_Snapshot_Call {
4004 _c.Call.Return(brokerSnapshot)
4005 return _c
4006}
4007
4008func (_c *MockBrokerCoreService_Snapshot_Call) RunAndReturn(run func() ports.BrokerSnapshot) *MockBrokerCoreService_Snapshot_Call {
4009 _c.Call.Return(run)
4010 return _c
4011}
4012
4013// Subscribe provides a mock function for the type MockBrokerCoreService
4014func (_mock *MockBrokerCoreService) Subscribe() (ports.BrokerSubscription, error) {
4015 ret := _mock.Called()
4016
4017 if len(ret) == 0 {
4018 panic("no return value specified for Subscribe")
4019 }
4020
4021 var r0 ports.BrokerSubscription
4022 var r1 error
4023 if returnFunc, ok := ret.Get(0).(func() (ports.BrokerSubscription, error)); ok {
4024 return returnFunc()
4025 }
4026 if returnFunc, ok := ret.Get(0).(func() ports.BrokerSubscription); ok {
4027 r0 = returnFunc()
4028 } else {
4029 if ret.Get(0) != nil {
4030 r0 = ret.Get(0).(ports.BrokerSubscription)
4031 }
4032 }
4033 if returnFunc, ok := ret.Get(1).(func() error); ok {
4034 r1 = returnFunc()
4035 } else {
4036 r1 = ret.Error(1)
4037 }
4038 return r0, r1
4039}
4040
4041// MockBrokerCoreService_Subscribe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Subscribe'
4042type MockBrokerCoreService_Subscribe_Call struct {
4043 *mock.Call
4044}
4045
4046// Subscribe is a helper method to define mock.On call
4047func (_e *MockBrokerCoreService_Expecter) Subscribe() *MockBrokerCoreService_Subscribe_Call {
4048 return &MockBrokerCoreService_Subscribe_Call{Call: _e.mock.On("Subscribe")}
4049}
4050
4051func (_c *MockBrokerCoreService_Subscribe_Call) Run(run func()) *MockBrokerCoreService_Subscribe_Call {
4052 _c.Call.Run(func(args mock.Arguments) {
4053 run()
4054 })
4055 return _c
4056}
4057
4058func (_c *MockBrokerCoreService_Subscribe_Call) Return(brokerSubscription ports.BrokerSubscription, err error) *MockBrokerCoreService_Subscribe_Call {
4059 _c.Call.Return(brokerSubscription, err)
4060 return _c
4061}
4062
4063func (_c *MockBrokerCoreService_Subscribe_Call) RunAndReturn(run func() (ports.BrokerSubscription, error)) *MockBrokerCoreService_Subscribe_Call {
4064 _c.Call.Return(run)
4065 return _c
4066}
4067
4068// SubscribePreview provides a mock function for the type MockBrokerCoreService
4069func (_mock *MockBrokerCoreService) SubscribePreview(request ports.BrokerPreviewRequest) (ports.BrokerPreviewSubscription, error) {
4070 ret := _mock.Called(request)
4071
4072 if len(ret) == 0 {
4073 panic("no return value specified for SubscribePreview")
4074 }
4075
4076 var r0 ports.BrokerPreviewSubscription
4077 var r1 error
4078 if returnFunc, ok := ret.Get(0).(func(ports.BrokerPreviewRequest) (ports.BrokerPreviewSubscription, error)); ok {
4079 return returnFunc(request)
4080 }
4081 if returnFunc, ok := ret.Get(0).(func(ports.BrokerPreviewRequest) ports.BrokerPreviewSubscription); ok {
4082 r0 = returnFunc(request)
4083 } else {
4084 if ret.Get(0) != nil {
4085 r0 = ret.Get(0).(ports.BrokerPreviewSubscription)
4086 }
4087 }
4088 if returnFunc, ok := ret.Get(1).(func(ports.BrokerPreviewRequest) error); ok {
4089 r1 = returnFunc(request)
4090 } else {
4091 r1 = ret.Error(1)
4092 }
4093 return r0, r1
4094}
4095
4096// MockBrokerCoreService_SubscribePreview_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubscribePreview'
4097type MockBrokerCoreService_SubscribePreview_Call struct {
4098 *mock.Call
4099}
4100
4101// SubscribePreview is a helper method to define mock.On call
4102// - request ports.BrokerPreviewRequest
4103func (_e *MockBrokerCoreService_Expecter) SubscribePreview(request any) *MockBrokerCoreService_SubscribePreview_Call {
4104 return &MockBrokerCoreService_SubscribePreview_Call{Call: _e.mock.On("SubscribePreview", request)}
4105}
4106
4107func (_c *MockBrokerCoreService_SubscribePreview_Call) Run(run func(request ports.BrokerPreviewRequest)) *MockBrokerCoreService_SubscribePreview_Call {
4108 _c.Call.Run(func(args mock.Arguments) {
4109 var arg0 ports.BrokerPreviewRequest
4110 if args[0] != nil {
4111 arg0 = args[0].(ports.BrokerPreviewRequest)
4112 }
4113 run(
4114 arg0,
4115 )
4116 })
4117 return _c
4118}
4119
4120func (_c *MockBrokerCoreService_SubscribePreview_Call) Return(brokerPreviewSubscription ports.BrokerPreviewSubscription, err error) *MockBrokerCoreService_SubscribePreview_Call {
4121 _c.Call.Return(brokerPreviewSubscription, err)
4122 return _c
4123}
4124
4125func (_c *MockBrokerCoreService_SubscribePreview_Call) RunAndReturn(run func(request ports.BrokerPreviewRequest) (ports.BrokerPreviewSubscription, error)) *MockBrokerCoreService_SubscribePreview_Call {
4126 _c.Call.Return(run)
4127 return _c
4128}
4129
4130// UpdateHostPolicy provides a mock function for the type MockBrokerCoreService
4131func (_mock *MockBrokerCoreService) UpdateHostPolicy(ctx context.Context, expected domain.RemoteRegistration, policy ports.BrokerPolicy) (domain.RemoteRegistration, error) {
4132 ret := _mock.Called(ctx, expected, policy)
4133
4134 if len(ret) == 0 {
4135 panic("no return value specified for UpdateHostPolicy")
4136 }
4137
4138 var r0 domain.RemoteRegistration
4139 var r1 error
4140 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteRegistration, ports.BrokerPolicy) (domain.RemoteRegistration, error)); ok {
4141 return returnFunc(ctx, expected, policy)
4142 }
4143 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteRegistration, ports.BrokerPolicy) domain.RemoteRegistration); ok {
4144 r0 = returnFunc(ctx, expected, policy)
4145 } else {
4146 r0 = ret.Get(0).(domain.RemoteRegistration)
4147 }
4148 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RemoteRegistration, ports.BrokerPolicy) error); ok {
4149 r1 = returnFunc(ctx, expected, policy)
4150 } else {
4151 r1 = ret.Error(1)
4152 }
4153 return r0, r1
4154}
4155
4156// MockBrokerCoreService_UpdateHostPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateHostPolicy'
4157type MockBrokerCoreService_UpdateHostPolicy_Call struct {
4158 *mock.Call
4159}
4160
4161// UpdateHostPolicy is a helper method to define mock.On call
4162// - ctx context.Context
4163// - expected domain.RemoteRegistration
4164// - policy ports.BrokerPolicy
4165func (_e *MockBrokerCoreService_Expecter) UpdateHostPolicy(ctx any, expected any, policy any) *MockBrokerCoreService_UpdateHostPolicy_Call {
4166 return &MockBrokerCoreService_UpdateHostPolicy_Call{Call: _e.mock.On("UpdateHostPolicy", ctx, expected, policy)}
4167}
4168
4169func (_c *MockBrokerCoreService_UpdateHostPolicy_Call) Run(run func(ctx context.Context, expected domain.RemoteRegistration, policy ports.BrokerPolicy)) *MockBrokerCoreService_UpdateHostPolicy_Call {
4170 _c.Call.Run(func(args mock.Arguments) {
4171 var arg0 context.Context
4172 if args[0] != nil {
4173 arg0 = args[0].(context.Context)
4174 }
4175 var arg1 domain.RemoteRegistration
4176 if args[1] != nil {
4177 arg1 = args[1].(domain.RemoteRegistration)
4178 }
4179 var arg2 ports.BrokerPolicy
4180 if args[2] != nil {
4181 arg2 = args[2].(ports.BrokerPolicy)
4182 }
4183 run(
4184 arg0,
4185 arg1,
4186 arg2,
4187 )
4188 })
4189 return _c
4190}
4191
4192func (_c *MockBrokerCoreService_UpdateHostPolicy_Call) Return(remoteRegistration domain.RemoteRegistration, err error) *MockBrokerCoreService_UpdateHostPolicy_Call {
4193 _c.Call.Return(remoteRegistration, err)
4194 return _c
4195}
4196
4197func (_c *MockBrokerCoreService_UpdateHostPolicy_Call) RunAndReturn(run func(ctx context.Context, expected domain.RemoteRegistration, policy ports.BrokerPolicy) (domain.RemoteRegistration, error)) *MockBrokerCoreService_UpdateHostPolicy_Call {
4198 _c.Call.Return(run)
4199 return _c
4200}
4201
4202// NewMockSessionCodec creates a new instance of MockSessionCodec. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
4203// The first argument is typically a *testing.T value.
4204func NewMockSessionCodec(t interface {
4205 mock.TestingT
4206 Cleanup(func())
4207}) *MockSessionCodec {
4208 if helper, ok := t.(interface{ Helper() }); ok {
4209 helper.Helper()
4210 }
4211
4212 mock := &MockSessionCodec{}
4213 mock.Mock.Test(t)
4214
4215 t.Cleanup(func() {
4216 if helper, ok := t.(interface{ Helper() }); ok {
4217 helper.Helper()
4218 }
4219 mock.AssertExpectations(t)
4220 })
4221
4222 return mock
4223}
4224
4225// MockSessionCodec is an autogenerated mock type for the SessionCodec type
4226type MockSessionCodec struct {
4227 mock.Mock
4228}
4229
4230type MockSessionCodec_Expecter struct {
4231 mock *mock.Mock
4232}
4233
4234func (_m *MockSessionCodec) EXPECT() *MockSessionCodec_Expecter {
4235 return &MockSessionCodec_Expecter{mock: &_m.Mock}
4236}
4237
4238// Client provides a mock function for the type MockSessionCodec
4239func (_mock *MockSessionCodec) Client(brokerEnvelopeStream ports.BrokerEnvelopeStream) ports.ClientConnection {
4240 ret := _mock.Called(brokerEnvelopeStream)
4241
4242 if len(ret) == 0 {
4243 panic("no return value specified for Client")
4244 }
4245
4246 var r0 ports.ClientConnection
4247 if returnFunc, ok := ret.Get(0).(func(ports.BrokerEnvelopeStream) ports.ClientConnection); ok {
4248 r0 = returnFunc(brokerEnvelopeStream)
4249 } else {
4250 if ret.Get(0) != nil {
4251 r0 = ret.Get(0).(ports.ClientConnection)
4252 }
4253 }
4254 return r0
4255}
4256
4257// MockSessionCodec_Client_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Client'
4258type MockSessionCodec_Client_Call struct {
4259 *mock.Call
4260}
4261
4262// Client is a helper method to define mock.On call
4263// - brokerEnvelopeStream ports.BrokerEnvelopeStream
4264func (_e *MockSessionCodec_Expecter) Client(brokerEnvelopeStream any) *MockSessionCodec_Client_Call {
4265 return &MockSessionCodec_Client_Call{Call: _e.mock.On("Client", brokerEnvelopeStream)}
4266}
4267
4268func (_c *MockSessionCodec_Client_Call) Run(run func(brokerEnvelopeStream ports.BrokerEnvelopeStream)) *MockSessionCodec_Client_Call {
4269 _c.Call.Run(func(args mock.Arguments) {
4270 var arg0 ports.BrokerEnvelopeStream
4271 if args[0] != nil {
4272 arg0 = args[0].(ports.BrokerEnvelopeStream)
4273 }
4274 run(
4275 arg0,
4276 )
4277 })
4278 return _c
4279}
4280
4281func (_c *MockSessionCodec_Client_Call) Return(clientConnection ports.ClientConnection) *MockSessionCodec_Client_Call {
4282 _c.Call.Return(clientConnection)
4283 return _c
4284}
4285
4286func (_c *MockSessionCodec_Client_Call) RunAndReturn(run func(brokerEnvelopeStream ports.BrokerEnvelopeStream) ports.ClientConnection) *MockSessionCodec_Client_Call {
4287 _c.Call.Return(run)
4288 return _c
4289}
4290
4291// NewMockBrokerSnapshotStore creates a new instance of MockBrokerSnapshotStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
4292// The first argument is typically a *testing.T value.
4293func NewMockBrokerSnapshotStore(t interface {
4294 mock.TestingT
4295 Cleanup(func())
4296}) *MockBrokerSnapshotStore {
4297 if helper, ok := t.(interface{ Helper() }); ok {
4298 helper.Helper()
4299 }
4300
4301 mock := &MockBrokerSnapshotStore{}
4302 mock.Mock.Test(t)
4303
4304 t.Cleanup(func() {
4305 if helper, ok := t.(interface{ Helper() }); ok {
4306 helper.Helper()
4307 }
4308 mock.AssertExpectations(t)
4309 })
4310
4311 return mock
4312}
4313
4314// MockBrokerSnapshotStore is an autogenerated mock type for the BrokerSnapshotStore type
4315type MockBrokerSnapshotStore struct {
4316 mock.Mock
4317}
4318
4319type MockBrokerSnapshotStore_Expecter struct {
4320 mock *mock.Mock
4321}
4322
4323func (_m *MockBrokerSnapshotStore) EXPECT() *MockBrokerSnapshotStore_Expecter {
4324 return &MockBrokerSnapshotStore_Expecter{mock: &_m.Mock}
4325}
4326
4327// Load provides a mock function for the type MockBrokerSnapshotStore
4328func (_mock *MockBrokerSnapshotStore) Load() (ports.BrokerSnapshot, error) {
4329 ret := _mock.Called()
4330
4331 if len(ret) == 0 {
4332 panic("no return value specified for Load")
4333 }
4334
4335 var r0 ports.BrokerSnapshot
4336 var r1 error
4337 if returnFunc, ok := ret.Get(0).(func() (ports.BrokerSnapshot, error)); ok {
4338 return returnFunc()
4339 }
4340 if returnFunc, ok := ret.Get(0).(func() ports.BrokerSnapshot); ok {
4341 r0 = returnFunc()
4342 } else {
4343 r0 = ret.Get(0).(ports.BrokerSnapshot)
4344 }
4345 if returnFunc, ok := ret.Get(1).(func() error); ok {
4346 r1 = returnFunc()
4347 } else {
4348 r1 = ret.Error(1)
4349 }
4350 return r0, r1
4351}
4352
4353// MockBrokerSnapshotStore_Load_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Load'
4354type MockBrokerSnapshotStore_Load_Call struct {
4355 *mock.Call
4356}
4357
4358// Load is a helper method to define mock.On call
4359func (_e *MockBrokerSnapshotStore_Expecter) Load() *MockBrokerSnapshotStore_Load_Call {
4360 return &MockBrokerSnapshotStore_Load_Call{Call: _e.mock.On("Load")}
4361}
4362
4363func (_c *MockBrokerSnapshotStore_Load_Call) Run(run func()) *MockBrokerSnapshotStore_Load_Call {
4364 _c.Call.Run(func(args mock.Arguments) {
4365 run()
4366 })
4367 return _c
4368}
4369
4370func (_c *MockBrokerSnapshotStore_Load_Call) Return(brokerSnapshot ports.BrokerSnapshot, err error) *MockBrokerSnapshotStore_Load_Call {
4371 _c.Call.Return(brokerSnapshot, err)
4372 return _c
4373}
4374
4375func (_c *MockBrokerSnapshotStore_Load_Call) RunAndReturn(run func() (ports.BrokerSnapshot, error)) *MockBrokerSnapshotStore_Load_Call {
4376 _c.Call.Return(run)
4377 return _c
4378}
4379
4380// Store provides a mock function for the type MockBrokerSnapshotStore
4381func (_mock *MockBrokerSnapshotStore) Store(brokerSnapshot ports.BrokerSnapshot) error {
4382 ret := _mock.Called(brokerSnapshot)
4383
4384 if len(ret) == 0 {
4385 panic("no return value specified for Store")
4386 }
4387
4388 var r0 error
4389 if returnFunc, ok := ret.Get(0).(func(ports.BrokerSnapshot) error); ok {
4390 r0 = returnFunc(brokerSnapshot)
4391 } else {
4392 r0 = ret.Error(0)
4393 }
4394 return r0
4395}
4396
4397// MockBrokerSnapshotStore_Store_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Store'
4398type MockBrokerSnapshotStore_Store_Call struct {
4399 *mock.Call
4400}
4401
4402// Store is a helper method to define mock.On call
4403// - brokerSnapshot ports.BrokerSnapshot
4404func (_e *MockBrokerSnapshotStore_Expecter) Store(brokerSnapshot any) *MockBrokerSnapshotStore_Store_Call {
4405 return &MockBrokerSnapshotStore_Store_Call{Call: _e.mock.On("Store", brokerSnapshot)}
4406}
4407
4408func (_c *MockBrokerSnapshotStore_Store_Call) Run(run func(brokerSnapshot ports.BrokerSnapshot)) *MockBrokerSnapshotStore_Store_Call {
4409 _c.Call.Run(func(args mock.Arguments) {
4410 var arg0 ports.BrokerSnapshot
4411 if args[0] != nil {
4412 arg0 = args[0].(ports.BrokerSnapshot)
4413 }
4414 run(
4415 arg0,
4416 )
4417 })
4418 return _c
4419}
4420
4421func (_c *MockBrokerSnapshotStore_Store_Call) Return(err error) *MockBrokerSnapshotStore_Store_Call {
4422 _c.Call.Return(err)
4423 return _c
4424}
4425
4426func (_c *MockBrokerSnapshotStore_Store_Call) RunAndReturn(run func(brokerSnapshot ports.BrokerSnapshot) error) *MockBrokerSnapshotStore_Store_Call {
4427 _c.Call.Return(run)
4428 return _c
4429}
4430
4431// NewMockBrokerHostProbe creates a new instance of MockBrokerHostProbe. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
4432// The first argument is typically a *testing.T value.
4433func NewMockBrokerHostProbe(t interface {
4434 mock.TestingT
4435 Cleanup(func())
4436}) *MockBrokerHostProbe {
4437 if helper, ok := t.(interface{ Helper() }); ok {
4438 helper.Helper()
4439 }
4440
4441 mock := &MockBrokerHostProbe{}
4442 mock.Mock.Test(t)
4443
4444 t.Cleanup(func() {
4445 if helper, ok := t.(interface{ Helper() }); ok {
4446 helper.Helper()
4447 }
4448 mock.AssertExpectations(t)
4449 })
4450
4451 return mock
4452}
4453
4454// MockBrokerHostProbe is an autogenerated mock type for the BrokerHostProbe type
4455type MockBrokerHostProbe struct {
4456 mock.Mock
4457}
4458
4459type MockBrokerHostProbe_Expecter struct {
4460 mock *mock.Mock
4461}
4462
4463func (_m *MockBrokerHostProbe) EXPECT() *MockBrokerHostProbe_Expecter {
4464 return &MockBrokerHostProbe_Expecter{mock: &_m.Mock}
4465}
4466
4467// Probe provides a mock function for the type MockBrokerHostProbe
4468func (_mock *MockBrokerHostProbe) Probe(ctx context.Context, registration domain.RemoteRegistration) (ports.BrokerDaemonObservation, error) {
4469 ret := _mock.Called(ctx, registration)
4470
4471 if len(ret) == 0 {
4472 panic("no return value specified for Probe")
4473 }
4474
4475 var r0 ports.BrokerDaemonObservation
4476 var r1 error
4477 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteRegistration) (ports.BrokerDaemonObservation, error)); ok {
4478 return returnFunc(ctx, registration)
4479 }
4480 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteRegistration) ports.BrokerDaemonObservation); ok {
4481 r0 = returnFunc(ctx, registration)
4482 } else {
4483 r0 = ret.Get(0).(ports.BrokerDaemonObservation)
4484 }
4485 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RemoteRegistration) error); ok {
4486 r1 = returnFunc(ctx, registration)
4487 } else {
4488 r1 = ret.Error(1)
4489 }
4490 return r0, r1
4491}
4492
4493// MockBrokerHostProbe_Probe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Probe'
4494type MockBrokerHostProbe_Probe_Call struct {
4495 *mock.Call
4496}
4497
4498// Probe is a helper method to define mock.On call
4499// - ctx context.Context
4500// - registration domain.RemoteRegistration
4501func (_e *MockBrokerHostProbe_Expecter) Probe(ctx any, registration any) *MockBrokerHostProbe_Probe_Call {
4502 return &MockBrokerHostProbe_Probe_Call{Call: _e.mock.On("Probe", ctx, registration)}
4503}
4504
4505func (_c *MockBrokerHostProbe_Probe_Call) Run(run func(ctx context.Context, registration domain.RemoteRegistration)) *MockBrokerHostProbe_Probe_Call {
4506 _c.Call.Run(func(args mock.Arguments) {
4507 var arg0 context.Context
4508 if args[0] != nil {
4509 arg0 = args[0].(context.Context)
4510 }
4511 var arg1 domain.RemoteRegistration
4512 if args[1] != nil {
4513 arg1 = args[1].(domain.RemoteRegistration)
4514 }
4515 run(
4516 arg0,
4517 arg1,
4518 )
4519 })
4520 return _c
4521}
4522
4523func (_c *MockBrokerHostProbe_Probe_Call) Return(brokerDaemonObservation ports.BrokerDaemonObservation, err error) *MockBrokerHostProbe_Probe_Call {
4524 _c.Call.Return(brokerDaemonObservation, err)
4525 return _c
4526}
4527
4528func (_c *MockBrokerHostProbe_Probe_Call) RunAndReturn(run func(ctx context.Context, registration domain.RemoteRegistration) (ports.BrokerDaemonObservation, error)) *MockBrokerHostProbe_Probe_Call {
4529 _c.Call.Return(run)
4530 return _c
4531}
4532
4533// NewMockBrokerPhysicalConnection creates a new instance of MockBrokerPhysicalConnection. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
4534// The first argument is typically a *testing.T value.
4535func NewMockBrokerPhysicalConnection(t interface {
4536 mock.TestingT
4537 Cleanup(func())
4538}) *MockBrokerPhysicalConnection {
4539 if helper, ok := t.(interface{ Helper() }); ok {
4540 helper.Helper()
4541 }
4542
4543 mock := &MockBrokerPhysicalConnection{}
4544 mock.Mock.Test(t)
4545
4546 t.Cleanup(func() {
4547 if helper, ok := t.(interface{ Helper() }); ok {
4548 helper.Helper()
4549 }
4550 mock.AssertExpectations(t)
4551 })
4552
4553 return mock
4554}
4555
4556// MockBrokerPhysicalConnection is an autogenerated mock type for the BrokerPhysicalConnection type
4557type MockBrokerPhysicalConnection struct {
4558 mock.Mock
4559}
4560
4561type MockBrokerPhysicalConnection_Expecter struct {
4562 mock *mock.Mock
4563}
4564
4565func (_m *MockBrokerPhysicalConnection) EXPECT() *MockBrokerPhysicalConnection_Expecter {
4566 return &MockBrokerPhysicalConnection_Expecter{mock: &_m.Mock}
4567}
4568
4569// Close provides a mock function for the type MockBrokerPhysicalConnection
4570func (_mock *MockBrokerPhysicalConnection) Close() error {
4571 ret := _mock.Called()
4572
4573 if len(ret) == 0 {
4574 panic("no return value specified for Close")
4575 }
4576
4577 var r0 error
4578 if returnFunc, ok := ret.Get(0).(func() error); ok {
4579 r0 = returnFunc()
4580 } else {
4581 r0 = ret.Error(0)
4582 }
4583 return r0
4584}
4585
4586// MockBrokerPhysicalConnection_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
4587type MockBrokerPhysicalConnection_Close_Call struct {
4588 *mock.Call
4589}
4590
4591// Close is a helper method to define mock.On call
4592func (_e *MockBrokerPhysicalConnection_Expecter) Close() *MockBrokerPhysicalConnection_Close_Call {
4593 return &MockBrokerPhysicalConnection_Close_Call{Call: _e.mock.On("Close")}
4594}
4595
4596func (_c *MockBrokerPhysicalConnection_Close_Call) Run(run func()) *MockBrokerPhysicalConnection_Close_Call {
4597 _c.Call.Run(func(args mock.Arguments) {
4598 run()
4599 })
4600 return _c
4601}
4602
4603func (_c *MockBrokerPhysicalConnection_Close_Call) Return(err error) *MockBrokerPhysicalConnection_Close_Call {
4604 _c.Call.Return(err)
4605 return _c
4606}
4607
4608func (_c *MockBrokerPhysicalConnection_Close_Call) RunAndReturn(run func() error) *MockBrokerPhysicalConnection_Close_Call {
4609 _c.Call.Return(run)
4610 return _c
4611}
4612
4613// Done provides a mock function for the type MockBrokerPhysicalConnection
4614func (_mock *MockBrokerPhysicalConnection) Done() <-chan struct{} {
4615 ret := _mock.Called()
4616
4617 if len(ret) == 0 {
4618 panic("no return value specified for Done")
4619 }
4620
4621 var r0 <-chan struct{}
4622 if returnFunc, ok := ret.Get(0).(func() <-chan struct{}); ok {
4623 r0 = returnFunc()
4624 } else {
4625 if ret.Get(0) != nil {
4626 r0 = ret.Get(0).(<-chan struct{})
4627 }
4628 }
4629 return r0
4630}
4631
4632// MockBrokerPhysicalConnection_Done_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Done'
4633type MockBrokerPhysicalConnection_Done_Call struct {
4634 *mock.Call
4635}
4636
4637// Done is a helper method to define mock.On call
4638func (_e *MockBrokerPhysicalConnection_Expecter) Done() *MockBrokerPhysicalConnection_Done_Call {
4639 return &MockBrokerPhysicalConnection_Done_Call{Call: _e.mock.On("Done")}
4640}
4641
4642func (_c *MockBrokerPhysicalConnection_Done_Call) Run(run func()) *MockBrokerPhysicalConnection_Done_Call {
4643 _c.Call.Run(func(args mock.Arguments) {
4644 run()
4645 })
4646 return _c
4647}
4648
4649func (_c *MockBrokerPhysicalConnection_Done_Call) Return(valCh <-chan struct{}) *MockBrokerPhysicalConnection_Done_Call {
4650 _c.Call.Return(valCh)
4651 return _c
4652}
4653
4654func (_c *MockBrokerPhysicalConnection_Done_Call) RunAndReturn(run func() <-chan struct{}) *MockBrokerPhysicalConnection_Done_Call {
4655 _c.Call.Return(run)
4656 return _c
4657}
4658
4659// Err provides a mock function for the type MockBrokerPhysicalConnection
4660func (_mock *MockBrokerPhysicalConnection) Err() error {
4661 ret := _mock.Called()
4662
4663 if len(ret) == 0 {
4664 panic("no return value specified for Err")
4665 }
4666
4667 var r0 error
4668 if returnFunc, ok := ret.Get(0).(func() error); ok {
4669 r0 = returnFunc()
4670 } else {
4671 r0 = ret.Error(0)
4672 }
4673 return r0
4674}
4675
4676// MockBrokerPhysicalConnection_Err_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Err'
4677type MockBrokerPhysicalConnection_Err_Call struct {
4678 *mock.Call
4679}
4680
4681// Err is a helper method to define mock.On call
4682func (_e *MockBrokerPhysicalConnection_Expecter) Err() *MockBrokerPhysicalConnection_Err_Call {
4683 return &MockBrokerPhysicalConnection_Err_Call{Call: _e.mock.On("Err")}
4684}
4685
4686func (_c *MockBrokerPhysicalConnection_Err_Call) Run(run func()) *MockBrokerPhysicalConnection_Err_Call {
4687 _c.Call.Run(func(args mock.Arguments) {
4688 run()
4689 })
4690 return _c
4691}
4692
4693func (_c *MockBrokerPhysicalConnection_Err_Call) Return(err error) *MockBrokerPhysicalConnection_Err_Call {
4694 _c.Call.Return(err)
4695 return _c
4696}
4697
4698func (_c *MockBrokerPhysicalConnection_Err_Call) RunAndReturn(run func() error) *MockBrokerPhysicalConnection_Err_Call {
4699 _c.Call.Return(run)
4700 return _c
4701}
4702
4703// FailureKind provides a mock function for the type MockBrokerPhysicalConnection
4704func (_mock *MockBrokerPhysicalConnection) FailureKind() domain.RemoteFailureKind {
4705 ret := _mock.Called()
4706
4707 if len(ret) == 0 {
4708 panic("no return value specified for FailureKind")
4709 }
4710
4711 var r0 domain.RemoteFailureKind
4712 if returnFunc, ok := ret.Get(0).(func() domain.RemoteFailureKind); ok {
4713 r0 = returnFunc()
4714 } else {
4715 r0 = ret.Get(0).(domain.RemoteFailureKind)
4716 }
4717 return r0
4718}
4719
4720// MockBrokerPhysicalConnection_FailureKind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FailureKind'
4721type MockBrokerPhysicalConnection_FailureKind_Call struct {
4722 *mock.Call
4723}
4724
4725// FailureKind is a helper method to define mock.On call
4726func (_e *MockBrokerPhysicalConnection_Expecter) FailureKind() *MockBrokerPhysicalConnection_FailureKind_Call {
4727 return &MockBrokerPhysicalConnection_FailureKind_Call{Call: _e.mock.On("FailureKind")}
4728}
4729
4730func (_c *MockBrokerPhysicalConnection_FailureKind_Call) Run(run func()) *MockBrokerPhysicalConnection_FailureKind_Call {
4731 _c.Call.Run(func(args mock.Arguments) {
4732 run()
4733 })
4734 return _c
4735}
4736
4737func (_c *MockBrokerPhysicalConnection_FailureKind_Call) Return(remoteFailureKind domain.RemoteFailureKind) *MockBrokerPhysicalConnection_FailureKind_Call {
4738 _c.Call.Return(remoteFailureKind)
4739 return _c
4740}
4741
4742func (_c *MockBrokerPhysicalConnection_FailureKind_Call) RunAndReturn(run func() domain.RemoteFailureKind) *MockBrokerPhysicalConnection_FailureKind_Call {
4743 _c.Call.Return(run)
4744 return _c
4745}
4746
4747// Identity provides a mock function for the type MockBrokerPhysicalConnection
4748func (_mock *MockBrokerPhysicalConnection) Identity() ports.BrokerDaemonIdentity {
4749 ret := _mock.Called()
4750
4751 if len(ret) == 0 {
4752 panic("no return value specified for Identity")
4753 }
4754
4755 var r0 ports.BrokerDaemonIdentity
4756 if returnFunc, ok := ret.Get(0).(func() ports.BrokerDaemonIdentity); ok {
4757 r0 = returnFunc()
4758 } else {
4759 r0 = ret.Get(0).(ports.BrokerDaemonIdentity)
4760 }
4761 return r0
4762}
4763
4764// MockBrokerPhysicalConnection_Identity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Identity'
4765type MockBrokerPhysicalConnection_Identity_Call struct {
4766 *mock.Call
4767}
4768
4769// Identity is a helper method to define mock.On call
4770func (_e *MockBrokerPhysicalConnection_Expecter) Identity() *MockBrokerPhysicalConnection_Identity_Call {
4771 return &MockBrokerPhysicalConnection_Identity_Call{Call: _e.mock.On("Identity")}
4772}
4773
4774func (_c *MockBrokerPhysicalConnection_Identity_Call) Run(run func()) *MockBrokerPhysicalConnection_Identity_Call {
4775 _c.Call.Run(func(args mock.Arguments) {
4776 run()
4777 })
4778 return _c
4779}
4780
4781func (_c *MockBrokerPhysicalConnection_Identity_Call) Return(brokerDaemonIdentity ports.BrokerDaemonIdentity) *MockBrokerPhysicalConnection_Identity_Call {
4782 _c.Call.Return(brokerDaemonIdentity)
4783 return _c
4784}
4785
4786func (_c *MockBrokerPhysicalConnection_Identity_Call) RunAndReturn(run func() ports.BrokerDaemonIdentity) *MockBrokerPhysicalConnection_Identity_Call {
4787 _c.Call.Return(run)
4788 return _c
4789}
4790
4791// Incarnation provides a mock function for the type MockBrokerPhysicalConnection
4792func (_mock *MockBrokerPhysicalConnection) Incarnation() ports.BrokerDaemonIncarnation {
4793 ret := _mock.Called()
4794
4795 if len(ret) == 0 {
4796 panic("no return value specified for Incarnation")
4797 }
4798
4799 var r0 ports.BrokerDaemonIncarnation
4800 if returnFunc, ok := ret.Get(0).(func() ports.BrokerDaemonIncarnation); ok {
4801 r0 = returnFunc()
4802 } else {
4803 if ret.Get(0) != nil {
4804 r0 = ret.Get(0).(ports.BrokerDaemonIncarnation)
4805 }
4806 }
4807 return r0
4808}
4809
4810// MockBrokerPhysicalConnection_Incarnation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Incarnation'
4811type MockBrokerPhysicalConnection_Incarnation_Call struct {
4812 *mock.Call
4813}
4814
4815// Incarnation is a helper method to define mock.On call
4816func (_e *MockBrokerPhysicalConnection_Expecter) Incarnation() *MockBrokerPhysicalConnection_Incarnation_Call {
4817 return &MockBrokerPhysicalConnection_Incarnation_Call{Call: _e.mock.On("Incarnation")}
4818}
4819
4820func (_c *MockBrokerPhysicalConnection_Incarnation_Call) Run(run func()) *MockBrokerPhysicalConnection_Incarnation_Call {
4821 _c.Call.Run(func(args mock.Arguments) {
4822 run()
4823 })
4824 return _c
4825}
4826
4827func (_c *MockBrokerPhysicalConnection_Incarnation_Call) Return(brokerDaemonIncarnation ports.BrokerDaemonIncarnation) *MockBrokerPhysicalConnection_Incarnation_Call {
4828 _c.Call.Return(brokerDaemonIncarnation)
4829 return _c
4830}
4831
4832func (_c *MockBrokerPhysicalConnection_Incarnation_Call) RunAndReturn(run func() ports.BrokerDaemonIncarnation) *MockBrokerPhysicalConnection_Incarnation_Call {
4833 _c.Call.Return(run)
4834 return _c
4835}
4836
4837// OpenStream provides a mock function for the type MockBrokerPhysicalConnection
4838func (_mock *MockBrokerPhysicalConnection) OpenStream(ctx context.Context, request ports.BrokerOpenStreamRequest) (ports.BrokerEnvelopeStream, error) {
4839 ret := _mock.Called(ctx, request)
4840
4841 if len(ret) == 0 {
4842 panic("no return value specified for OpenStream")
4843 }
4844
4845 var r0 ports.BrokerEnvelopeStream
4846 var r1 error
4847 if returnFunc, ok := ret.Get(0).(func(context.Context, ports.BrokerOpenStreamRequest) (ports.BrokerEnvelopeStream, error)); ok {
4848 return returnFunc(ctx, request)
4849 }
4850 if returnFunc, ok := ret.Get(0).(func(context.Context, ports.BrokerOpenStreamRequest) ports.BrokerEnvelopeStream); ok {
4851 r0 = returnFunc(ctx, request)
4852 } else {
4853 if ret.Get(0) != nil {
4854 r0 = ret.Get(0).(ports.BrokerEnvelopeStream)
4855 }
4856 }
4857 if returnFunc, ok := ret.Get(1).(func(context.Context, ports.BrokerOpenStreamRequest) error); ok {
4858 r1 = returnFunc(ctx, request)
4859 } else {
4860 r1 = ret.Error(1)
4861 }
4862 return r0, r1
4863}
4864
4865// MockBrokerPhysicalConnection_OpenStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OpenStream'
4866type MockBrokerPhysicalConnection_OpenStream_Call struct {
4867 *mock.Call
4868}
4869
4870// OpenStream is a helper method to define mock.On call
4871// - ctx context.Context
4872// - request ports.BrokerOpenStreamRequest
4873func (_e *MockBrokerPhysicalConnection_Expecter) OpenStream(ctx any, request any) *MockBrokerPhysicalConnection_OpenStream_Call {
4874 return &MockBrokerPhysicalConnection_OpenStream_Call{Call: _e.mock.On("OpenStream", ctx, request)}
4875}
4876
4877func (_c *MockBrokerPhysicalConnection_OpenStream_Call) Run(run func(ctx context.Context, request ports.BrokerOpenStreamRequest)) *MockBrokerPhysicalConnection_OpenStream_Call {
4878 _c.Call.Run(func(args mock.Arguments) {
4879 var arg0 context.Context
4880 if args[0] != nil {
4881 arg0 = args[0].(context.Context)
4882 }
4883 var arg1 ports.BrokerOpenStreamRequest
4884 if args[1] != nil {
4885 arg1 = args[1].(ports.BrokerOpenStreamRequest)
4886 }
4887 run(
4888 arg0,
4889 arg1,
4890 )
4891 })
4892 return _c
4893}
4894
4895func (_c *MockBrokerPhysicalConnection_OpenStream_Call) Return(brokerEnvelopeStream ports.BrokerEnvelopeStream, err error) *MockBrokerPhysicalConnection_OpenStream_Call {
4896 _c.Call.Return(brokerEnvelopeStream, err)
4897 return _c
4898}
4899
4900func (_c *MockBrokerPhysicalConnection_OpenStream_Call) RunAndReturn(run func(ctx context.Context, request ports.BrokerOpenStreamRequest) (ports.BrokerEnvelopeStream, error)) *MockBrokerPhysicalConnection_OpenStream_Call {
4901 _c.Call.Return(run)
4902 return _c
4903}
4904
4905// Policy provides a mock function for the type MockBrokerPhysicalConnection
4906func (_mock *MockBrokerPhysicalConnection) Policy() ports.BrokerPolicy {
4907 ret := _mock.Called()
4908
4909 if len(ret) == 0 {
4910 panic("no return value specified for Policy")
4911 }
4912
4913 var r0 ports.BrokerPolicy
4914 if returnFunc, ok := ret.Get(0).(func() ports.BrokerPolicy); ok {
4915 r0 = returnFunc()
4916 } else {
4917 r0 = ret.Get(0).(ports.BrokerPolicy)
4918 }
4919 return r0
4920}
4921
4922// MockBrokerPhysicalConnection_Policy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Policy'
4923type MockBrokerPhysicalConnection_Policy_Call struct {
4924 *mock.Call
4925}
4926
4927// Policy is a helper method to define mock.On call
4928func (_e *MockBrokerPhysicalConnection_Expecter) Policy() *MockBrokerPhysicalConnection_Policy_Call {
4929 return &MockBrokerPhysicalConnection_Policy_Call{Call: _e.mock.On("Policy")}
4930}
4931
4932func (_c *MockBrokerPhysicalConnection_Policy_Call) Run(run func()) *MockBrokerPhysicalConnection_Policy_Call {
4933 _c.Call.Run(func(args mock.Arguments) {
4934 run()
4935 })
4936 return _c
4937}
4938
4939func (_c *MockBrokerPhysicalConnection_Policy_Call) Return(brokerPolicy ports.BrokerPolicy) *MockBrokerPhysicalConnection_Policy_Call {
4940 _c.Call.Return(brokerPolicy)
4941 return _c
4942}
4943
4944func (_c *MockBrokerPhysicalConnection_Policy_Call) RunAndReturn(run func() ports.BrokerPolicy) *MockBrokerPhysicalConnection_Policy_Call {
4945 _c.Call.Return(run)
4946 return _c
4947}
4948
4949// NewMockBrokerEndpointConnector creates a new instance of MockBrokerEndpointConnector. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
4950// The first argument is typically a *testing.T value.
4951func NewMockBrokerEndpointConnector(t interface {
4952 mock.TestingT
4953 Cleanup(func())
4954}) *MockBrokerEndpointConnector {
4955 if helper, ok := t.(interface{ Helper() }); ok {
4956 helper.Helper()
4957 }
4958
4959 mock := &MockBrokerEndpointConnector{}
4960 mock.Mock.Test(t)
4961
4962 t.Cleanup(func() {
4963 if helper, ok := t.(interface{ Helper() }); ok {
4964 helper.Helper()
4965 }
4966 mock.AssertExpectations(t)
4967 })
4968
4969 return mock
4970}
4971
4972// MockBrokerEndpointConnector is an autogenerated mock type for the BrokerEndpointConnector type
4973type MockBrokerEndpointConnector struct {
4974 mock.Mock
4975}
4976
4977type MockBrokerEndpointConnector_Expecter struct {
4978 mock *mock.Mock
4979}
4980
4981func (_m *MockBrokerEndpointConnector) EXPECT() *MockBrokerEndpointConnector_Expecter {
4982 return &MockBrokerEndpointConnector_Expecter{mock: &_m.Mock}
4983}
4984
4985// Connect provides a mock function for the type MockBrokerEndpointConnector
4986func (_mock *MockBrokerEndpointConnector) Connect(ctx context.Context, target ports.BrokerDialTarget) (ports.BrokerPhysicalConnection, error) {
4987 ret := _mock.Called(ctx, target)
4988
4989 if len(ret) == 0 {
4990 panic("no return value specified for Connect")
4991 }
4992
4993 var r0 ports.BrokerPhysicalConnection
4994 var r1 error
4995 if returnFunc, ok := ret.Get(0).(func(context.Context, ports.BrokerDialTarget) (ports.BrokerPhysicalConnection, error)); ok {
4996 return returnFunc(ctx, target)
4997 }
4998 if returnFunc, ok := ret.Get(0).(func(context.Context, ports.BrokerDialTarget) ports.BrokerPhysicalConnection); ok {
4999 r0 = returnFunc(ctx, target)
5000 } else {
5001 if ret.Get(0) != nil {
5002 r0 = ret.Get(0).(ports.BrokerPhysicalConnection)
5003 }
5004 }
5005 if returnFunc, ok := ret.Get(1).(func(context.Context, ports.BrokerDialTarget) error); ok {
5006 r1 = returnFunc(ctx, target)
5007 } else {
5008 r1 = ret.Error(1)
5009 }
5010 return r0, r1
5011}
5012
5013// MockBrokerEndpointConnector_Connect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Connect'
5014type MockBrokerEndpointConnector_Connect_Call struct {
5015 *mock.Call
5016}
5017
5018// Connect is a helper method to define mock.On call
5019// - ctx context.Context
5020// - target ports.BrokerDialTarget
5021func (_e *MockBrokerEndpointConnector_Expecter) Connect(ctx any, target any) *MockBrokerEndpointConnector_Connect_Call {
5022 return &MockBrokerEndpointConnector_Connect_Call{Call: _e.mock.On("Connect", ctx, target)}
5023}
5024
5025func (_c *MockBrokerEndpointConnector_Connect_Call) Run(run func(ctx context.Context, target ports.BrokerDialTarget)) *MockBrokerEndpointConnector_Connect_Call {
5026 _c.Call.Run(func(args mock.Arguments) {
5027 var arg0 context.Context
5028 if args[0] != nil {
5029 arg0 = args[0].(context.Context)
5030 }
5031 var arg1 ports.BrokerDialTarget
5032 if args[1] != nil {
5033 arg1 = args[1].(ports.BrokerDialTarget)
5034 }
5035 run(
5036 arg0,
5037 arg1,
5038 )
5039 })
5040 return _c
5041}
5042
5043func (_c *MockBrokerEndpointConnector_Connect_Call) Return(brokerPhysicalConnection ports.BrokerPhysicalConnection, err error) *MockBrokerEndpointConnector_Connect_Call {
5044 _c.Call.Return(brokerPhysicalConnection, err)
5045 return _c
5046}
5047
5048func (_c *MockBrokerEndpointConnector_Connect_Call) RunAndReturn(run func(ctx context.Context, target ports.BrokerDialTarget) (ports.BrokerPhysicalConnection, error)) *MockBrokerEndpointConnector_Connect_Call {
5049 _c.Call.Return(run)
5050 return _c
5051}
5052
5053// NewMockBrokerConnector creates a new instance of MockBrokerConnector. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
5054// The first argument is typically a *testing.T value.
5055func NewMockBrokerConnector(t interface {
5056 mock.TestingT
5057 Cleanup(func())
5058}) *MockBrokerConnector {
5059 if helper, ok := t.(interface{ Helper() }); ok {
5060 helper.Helper()
5061 }
5062
5063 mock := &MockBrokerConnector{}
5064 mock.Mock.Test(t)
5065
5066 t.Cleanup(func() {
5067 if helper, ok := t.(interface{ Helper() }); ok {
5068 helper.Helper()
5069 }
5070 mock.AssertExpectations(t)
5071 })
5072
5073 return mock
5074}
5075
5076// MockBrokerConnector is an autogenerated mock type for the BrokerConnector type
5077type MockBrokerConnector struct {
5078 mock.Mock
5079}
5080
5081type MockBrokerConnector_Expecter struct {
5082 mock *mock.Mock
5083}
5084
5085func (_m *MockBrokerConnector) EXPECT() *MockBrokerConnector_Expecter {
5086 return &MockBrokerConnector_Expecter{mock: &_m.Mock}
5087}
5088
5089// Connect provides a mock function for the type MockBrokerConnector
5090func (_mock *MockBrokerConnector) Connect(ctx context.Context) (ports.BrokerNavigator, error) {
5091 ret := _mock.Called(ctx)
5092
5093 if len(ret) == 0 {
5094 panic("no return value specified for Connect")
5095 }
5096
5097 var r0 ports.BrokerNavigator
5098 var r1 error
5099 if returnFunc, ok := ret.Get(0).(func(context.Context) (ports.BrokerNavigator, error)); ok {
5100 return returnFunc(ctx)
5101 }
5102 if returnFunc, ok := ret.Get(0).(func(context.Context) ports.BrokerNavigator); ok {
5103 r0 = returnFunc(ctx)
5104 } else {
5105 if ret.Get(0) != nil {
5106 r0 = ret.Get(0).(ports.BrokerNavigator)
5107 }
5108 }
5109 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
5110 r1 = returnFunc(ctx)
5111 } else {
5112 r1 = ret.Error(1)
5113 }
5114 return r0, r1
5115}
5116
5117// MockBrokerConnector_Connect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Connect'
5118type MockBrokerConnector_Connect_Call struct {
5119 *mock.Call
5120}
5121
5122// Connect is a helper method to define mock.On call
5123// - ctx context.Context
5124func (_e *MockBrokerConnector_Expecter) Connect(ctx any) *MockBrokerConnector_Connect_Call {
5125 return &MockBrokerConnector_Connect_Call{Call: _e.mock.On("Connect", ctx)}
5126}
5127
5128func (_c *MockBrokerConnector_Connect_Call) Run(run func(ctx context.Context)) *MockBrokerConnector_Connect_Call {
5129 _c.Call.Run(func(args mock.Arguments) {
5130 var arg0 context.Context
5131 if args[0] != nil {
5132 arg0 = args[0].(context.Context)
5133 }
5134 run(
5135 arg0,
5136 )
5137 })
5138 return _c
5139}
5140
5141func (_c *MockBrokerConnector_Connect_Call) Return(brokerNavigator ports.BrokerNavigator, err error) *MockBrokerConnector_Connect_Call {
5142 _c.Call.Return(brokerNavigator, err)
5143 return _c
5144}
5145
5146func (_c *MockBrokerConnector_Connect_Call) RunAndReturn(run func(ctx context.Context) (ports.BrokerNavigator, error)) *MockBrokerConnector_Connect_Call {
5147 _c.Call.Return(run)
5148 return _c
5149}
5150
5151// NewMockBrokerAuthority creates a new instance of MockBrokerAuthority. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
5152// The first argument is typically a *testing.T value.
5153func NewMockBrokerAuthority(t interface {
5154 mock.TestingT
5155 Cleanup(func())
5156}) *MockBrokerAuthority {
5157 if helper, ok := t.(interface{ Helper() }); ok {
5158 helper.Helper()
5159 }
5160
5161 mock := &MockBrokerAuthority{}
5162 mock.Mock.Test(t)
5163
5164 t.Cleanup(func() {
5165 if helper, ok := t.(interface{ Helper() }); ok {
5166 helper.Helper()
5167 }
5168 mock.AssertExpectations(t)
5169 })
5170
5171 return mock
5172}
5173
5174// MockBrokerAuthority is an autogenerated mock type for the BrokerAuthority type
5175type MockBrokerAuthority struct {
5176 mock.Mock
5177}
5178
5179type MockBrokerAuthority_Expecter struct {
5180 mock *mock.Mock
5181}
5182
5183func (_m *MockBrokerAuthority) EXPECT() *MockBrokerAuthority_Expecter {
5184 return &MockBrokerAuthority_Expecter{mock: &_m.Mock}
5185}
5186
5187// AdmitClient provides a mock function for the type MockBrokerAuthority
5188func (_mock *MockBrokerAuthority) AdmitClient(ctx context.Context) (ports.BrokerCoreService, error) {
5189 ret := _mock.Called(ctx)
5190
5191 if len(ret) == 0 {
5192 panic("no return value specified for AdmitClient")
5193 }
5194
5195 var r0 ports.BrokerCoreService
5196 var r1 error
5197 if returnFunc, ok := ret.Get(0).(func(context.Context) (ports.BrokerCoreService, error)); ok {
5198 return returnFunc(ctx)
5199 }
5200 if returnFunc, ok := ret.Get(0).(func(context.Context) ports.BrokerCoreService); ok {
5201 r0 = returnFunc(ctx)
5202 } else {
5203 if ret.Get(0) != nil {
5204 r0 = ret.Get(0).(ports.BrokerCoreService)
5205 }
5206 }
5207 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
5208 r1 = returnFunc(ctx)
5209 } else {
5210 r1 = ret.Error(1)
5211 }
5212 return r0, r1
5213}
5214
5215// MockBrokerAuthority_AdmitClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AdmitClient'
5216type MockBrokerAuthority_AdmitClient_Call struct {
5217 *mock.Call
5218}
5219
5220// AdmitClient is a helper method to define mock.On call
5221// - ctx context.Context
5222func (_e *MockBrokerAuthority_Expecter) AdmitClient(ctx any) *MockBrokerAuthority_AdmitClient_Call {
5223 return &MockBrokerAuthority_AdmitClient_Call{Call: _e.mock.On("AdmitClient", ctx)}
5224}
5225
5226func (_c *MockBrokerAuthority_AdmitClient_Call) Run(run func(ctx context.Context)) *MockBrokerAuthority_AdmitClient_Call {
5227 _c.Call.Run(func(args mock.Arguments) {
5228 var arg0 context.Context
5229 if args[0] != nil {
5230 arg0 = args[0].(context.Context)
5231 }
5232 run(
5233 arg0,
5234 )
5235 })
5236 return _c
5237}
5238
5239func (_c *MockBrokerAuthority_AdmitClient_Call) Return(brokerCoreService ports.BrokerCoreService, err error) *MockBrokerAuthority_AdmitClient_Call {
5240 _c.Call.Return(brokerCoreService, err)
5241 return _c
5242}
5243
5244func (_c *MockBrokerAuthority_AdmitClient_Call) RunAndReturn(run func(ctx context.Context) (ports.BrokerCoreService, error)) *MockBrokerAuthority_AdmitClient_Call {
5245 _c.Call.Return(run)
5246 return _c
5247}
5248
5249// NewMockBrokerListener creates a new instance of MockBrokerListener. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
5250// The first argument is typically a *testing.T value.
5251func NewMockBrokerListener(t interface {
5252 mock.TestingT
5253 Cleanup(func())
5254}) *MockBrokerListener {
5255 if helper, ok := t.(interface{ Helper() }); ok {
5256 helper.Helper()
5257 }
5258
5259 mock := &MockBrokerListener{}
5260 mock.Mock.Test(t)
5261
5262 t.Cleanup(func() {
5263 if helper, ok := t.(interface{ Helper() }); ok {
5264 helper.Helper()
5265 }
5266 mock.AssertExpectations(t)
5267 })
5268
5269 return mock
5270}
5271
5272// MockBrokerListener is an autogenerated mock type for the BrokerListener type
5273type MockBrokerListener struct {
5274 mock.Mock
5275}
5276
5277type MockBrokerListener_Expecter struct {
5278 mock *mock.Mock
5279}
5280
5281func (_m *MockBrokerListener) EXPECT() *MockBrokerListener_Expecter {
5282 return &MockBrokerListener_Expecter{mock: &_m.Mock}
5283}
5284
5285// Accept provides a mock function for the type MockBrokerListener
5286func (_mock *MockBrokerListener) Accept() (ports.BrokerCoreService, error) {
5287 ret := _mock.Called()
5288
5289 if len(ret) == 0 {
5290 panic("no return value specified for Accept")
5291 }
5292
5293 var r0 ports.BrokerCoreService
5294 var r1 error
5295 if returnFunc, ok := ret.Get(0).(func() (ports.BrokerCoreService, error)); ok {
5296 return returnFunc()
5297 }
5298 if returnFunc, ok := ret.Get(0).(func() ports.BrokerCoreService); ok {
5299 r0 = returnFunc()
5300 } else {
5301 if ret.Get(0) != nil {
5302 r0 = ret.Get(0).(ports.BrokerCoreService)
5303 }
5304 }
5305 if returnFunc, ok := ret.Get(1).(func() error); ok {
5306 r1 = returnFunc()
5307 } else {
5308 r1 = ret.Error(1)
5309 }
5310 return r0, r1
5311}
5312
5313// MockBrokerListener_Accept_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Accept'
5314type MockBrokerListener_Accept_Call struct {
5315 *mock.Call
5316}
5317
5318// Accept is a helper method to define mock.On call
5319func (_e *MockBrokerListener_Expecter) Accept() *MockBrokerListener_Accept_Call {
5320 return &MockBrokerListener_Accept_Call{Call: _e.mock.On("Accept")}
5321}
5322
5323func (_c *MockBrokerListener_Accept_Call) Run(run func()) *MockBrokerListener_Accept_Call {
5324 _c.Call.Run(func(args mock.Arguments) {
5325 run()
5326 })
5327 return _c
5328}
5329
5330func (_c *MockBrokerListener_Accept_Call) Return(brokerCoreService ports.BrokerCoreService, err error) *MockBrokerListener_Accept_Call {
5331 _c.Call.Return(brokerCoreService, err)
5332 return _c
5333}
5334
5335func (_c *MockBrokerListener_Accept_Call) RunAndReturn(run func() (ports.BrokerCoreService, error)) *MockBrokerListener_Accept_Call {
5336 _c.Call.Return(run)
5337 return _c
5338}
5339
5340// Addr provides a mock function for the type MockBrokerListener
5341func (_mock *MockBrokerListener) Addr() string {
5342 ret := _mock.Called()
5343
5344 if len(ret) == 0 {
5345 panic("no return value specified for Addr")
5346 }
5347
5348 var r0 string
5349 if returnFunc, ok := ret.Get(0).(func() string); ok {
5350 r0 = returnFunc()
5351 } else {
5352 r0 = ret.Get(0).(string)
5353 }
5354 return r0
5355}
5356
5357// MockBrokerListener_Addr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Addr'
5358type MockBrokerListener_Addr_Call struct {
5359 *mock.Call
5360}
5361
5362// Addr is a helper method to define mock.On call
5363func (_e *MockBrokerListener_Expecter) Addr() *MockBrokerListener_Addr_Call {
5364 return &MockBrokerListener_Addr_Call{Call: _e.mock.On("Addr")}
5365}
5366
5367func (_c *MockBrokerListener_Addr_Call) Run(run func()) *MockBrokerListener_Addr_Call {
5368 _c.Call.Run(func(args mock.Arguments) {
5369 run()
5370 })
5371 return _c
5372}
5373
5374func (_c *MockBrokerListener_Addr_Call) Return(s string) *MockBrokerListener_Addr_Call {
5375 _c.Call.Return(s)
5376 return _c
5377}
5378
5379func (_c *MockBrokerListener_Addr_Call) RunAndReturn(run func() string) *MockBrokerListener_Addr_Call {
5380 _c.Call.Return(run)
5381 return _c
5382}
5383
5384// Close provides a mock function for the type MockBrokerListener
5385func (_mock *MockBrokerListener) Close() error {
5386 ret := _mock.Called()
5387
5388 if len(ret) == 0 {
5389 panic("no return value specified for Close")
5390 }
5391
5392 var r0 error
5393 if returnFunc, ok := ret.Get(0).(func() error); ok {
5394 r0 = returnFunc()
5395 } else {
5396 r0 = ret.Error(0)
5397 }
5398 return r0
5399}
5400
5401// MockBrokerListener_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
5402type MockBrokerListener_Close_Call struct {
5403 *mock.Call
5404}
5405
5406// Close is a helper method to define mock.On call
5407func (_e *MockBrokerListener_Expecter) Close() *MockBrokerListener_Close_Call {
5408 return &MockBrokerListener_Close_Call{Call: _e.mock.On("Close")}
5409}
5410
5411func (_c *MockBrokerListener_Close_Call) Run(run func()) *MockBrokerListener_Close_Call {
5412 _c.Call.Run(func(args mock.Arguments) {
5413 run()
5414 })
5415 return _c
5416}
5417
5418func (_c *MockBrokerListener_Close_Call) Return(err error) *MockBrokerListener_Close_Call {
5419 _c.Call.Return(err)
5420 return _c
5421}
5422
5423func (_c *MockBrokerListener_Close_Call) RunAndReturn(run func() error) *MockBrokerListener_Close_Call {
5424 _c.Call.Return(run)
5425 return _c
5426}