detached d2997ba

test(ports): generate source-aligned mocks

commit
d2997ba1b96251fefb61792c4aa972694f3dd6de
author
brice · · 2026-07-14 19:24 UTC
parent
6cc7912
signature
GPG VerifiedCD88F9E564E0102646FB6077A1A07C7C7C3E349D · arch-gpg Verified for the committer email
12 files · +3438 -3198
Unified
UnifiedSplit
A internal/ports/mocks/clipboard_mock.go +106 -0
@@ -0,0 +1,106 @@
1+// Code generated by mockery; DO NOT EDIT.
2+// github.com/vektra/mockery
3+// template: testify
4+
5+package portsmocks
6+
7+import (
8+ "context"
9+
10+ mock "github.com/stretchr/testify/mock"
11+)
12+
13+// NewMockClipboardReader creates a new instance of MockClipboardReader. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
14+// The first argument is typically a *testing.T value.
15+func NewMockClipboardReader(t interface {
16+ mock.TestingT
17+ Cleanup(func())
18+}) *MockClipboardReader {
19+ mock := &MockClipboardReader{}
20+ mock.Mock.Test(t)
21+
22+ t.Cleanup(func() { mock.AssertExpectations(t) })
23+
24+ return mock
25+}
26+
27+// MockClipboardReader is an autogenerated mock type for the ClipboardReader type
28+type MockClipboardReader struct {
29+ mock.Mock
30+}
31+
32+type MockClipboardReader_Expecter struct {
33+ mock *mock.Mock
34+}
35+
36+func (_m *MockClipboardReader) EXPECT() *MockClipboardReader_Expecter {
37+ return &MockClipboardReader_Expecter{mock: &_m.Mock}
38+}
39+
40+// ReadImage provides a mock function for the type MockClipboardReader
41+func (_mock *MockClipboardReader) ReadImage(ctx context.Context) (string, []byte, error) {
42+ ret := _mock.Called(ctx)
43+
44+ if len(ret) == 0 {
45+ panic("no return value specified for ReadImage")
46+ }
47+
48+ var r0 string
49+ var r1 []byte
50+ var r2 error
51+ if returnFunc, ok := ret.Get(0).(func(context.Context) (string, []byte, error)); ok {
52+ return returnFunc(ctx)
53+ }
54+ if returnFunc, ok := ret.Get(0).(func(context.Context) string); ok {
55+ r0 = returnFunc(ctx)
56+ } else {
57+ r0 = ret.Get(0).(string)
58+ }
59+ if returnFunc, ok := ret.Get(1).(func(context.Context) []byte); ok {
60+ r1 = returnFunc(ctx)
61+ } else {
62+ if ret.Get(1) != nil {
63+ r1 = ret.Get(1).([]byte)
64+ }
65+ }
66+ if returnFunc, ok := ret.Get(2).(func(context.Context) error); ok {
67+ r2 = returnFunc(ctx)
68+ } else {
69+ r2 = ret.Error(2)
70+ }
71+ return r0, r1, r2
72+}
73+
74+// MockClipboardReader_ReadImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadImage'
75+type MockClipboardReader_ReadImage_Call struct {
76+ *mock.Call
77+}
78+
79+// ReadImage is a helper method to define mock.On call
80+// - ctx context.Context
81+func (_e *MockClipboardReader_Expecter) ReadImage(ctx any) *MockClipboardReader_ReadImage_Call {
82+ return &MockClipboardReader_ReadImage_Call{Call: _e.mock.On("ReadImage", ctx)}
83+}
84+
85+func (_c *MockClipboardReader_ReadImage_Call) Run(run func(ctx context.Context)) *MockClipboardReader_ReadImage_Call {
86+ _c.Call.Run(func(args mock.Arguments) {
87+ var arg0 context.Context
88+ if args[0] != nil {
89+ arg0 = args[0].(context.Context)
90+ }
91+ run(
92+ arg0,
93+ )
94+ })
95+ return _c
96+}
97+
98+func (_c *MockClipboardReader_ReadImage_Call) Return(mime string, data []byte, err error) *MockClipboardReader_ReadImage_Call {
99+ _c.Call.Return(mime, data, err)
100+ return _c
101+}
102+
103+func (_c *MockClipboardReader_ReadImage_Call) RunAndReturn(run func(ctx context.Context) (string, []byte, error)) *MockClipboardReader_ReadImage_Call {
104+ _c.Call.Return(run)
105+ return _c
106+}
@@ -0,0 +1,106 @@
1+// Code generated by mockery; DO NOT EDIT.
2+// github.com/vektra/mockery
3+// template: testify
4+
5+package portsmocks
6+
7+import (
8+ "context"
9+
10+ mock "github.com/stretchr/testify/mock"
11+)
12+
13+// NewMockClipboardReader creates a new instance of MockClipboardReader. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
14+// The first argument is typically a *testing.T value.
15+func NewMockClipboardReader(t interface {
16+ mock.TestingT
17+ Cleanup(func())
18+}) *MockClipboardReader {
19+ mock := &MockClipboardReader{}
20+ mock.Mock.Test(t)
21+
22+ t.Cleanup(func() { mock.AssertExpectations(t) })
23+
24+ return mock
25+}
26+
27+// MockClipboardReader is an autogenerated mock type for the ClipboardReader type
28+type MockClipboardReader struct {
29+ mock.Mock
30+}
31+
32+type MockClipboardReader_Expecter struct {
33+ mock *mock.Mock
34+}
35+
36+func (_m *MockClipboardReader) EXPECT() *MockClipboardReader_Expecter {
37+ return &MockClipboardReader_Expecter{mock: &_m.Mock}
38+}
39+
40+// ReadImage provides a mock function for the type MockClipboardReader
41+func (_mock *MockClipboardReader) ReadImage(ctx context.Context) (string, []byte, error) {
42+ ret := _mock.Called(ctx)
43+
44+ if len(ret) == 0 {
45+ panic("no return value specified for ReadImage")
46+ }
47+
48+ var r0 string
49+ var r1 []byte
50+ var r2 error
51+ if returnFunc, ok := ret.Get(0).(func(context.Context) (string, []byte, error)); ok {
52+ return returnFunc(ctx)
53+ }
54+ if returnFunc, ok := ret.Get(0).(func(context.Context) string); ok {
55+ r0 = returnFunc(ctx)
56+ } else {
57+ r0 = ret.Get(0).(string)
58+ }
59+ if returnFunc, ok := ret.Get(1).(func(context.Context) []byte); ok {
60+ r1 = returnFunc(ctx)
61+ } else {
62+ if ret.Get(1) != nil {
63+ r1 = ret.Get(1).([]byte)
64+ }
65+ }
66+ if returnFunc, ok := ret.Get(2).(func(context.Context) error); ok {
67+ r2 = returnFunc(ctx)
68+ } else {
69+ r2 = ret.Error(2)
70+ }
71+ return r0, r1, r2
72+}
73+
74+// MockClipboardReader_ReadImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadImage'
75+type MockClipboardReader_ReadImage_Call struct {
76+ *mock.Call
77+}
78+
79+// ReadImage is a helper method to define mock.On call
80+// - ctx context.Context
81+func (_e *MockClipboardReader_Expecter) ReadImage(ctx any) *MockClipboardReader_ReadImage_Call {
82+ return &MockClipboardReader_ReadImage_Call{Call: _e.mock.On("ReadImage", ctx)}
83+}
84+
85+func (_c *MockClipboardReader_ReadImage_Call) Run(run func(ctx context.Context)) *MockClipboardReader_ReadImage_Call {
86+ _c.Call.Run(func(args mock.Arguments) {
87+ var arg0 context.Context
88+ if args[0] != nil {
89+ arg0 = args[0].(context.Context)
90+ }
91+ run(
92+ arg0,
93+ )
94+ })
95+ return _c
96+}
97+
98+func (_c *MockClipboardReader_ReadImage_Call) Return(mime string, data []byte, err error) *MockClipboardReader_ReadImage_Call {
99+ _c.Call.Return(mime, data, err)
100+ return _c
101+}
102+
103+func (_c *MockClipboardReader_ReadImage_Call) RunAndReturn(run func(ctx context.Context) (string, []byte, error)) *MockClipboardReader_ReadImage_Call {
104+ _c.Call.Return(run)
105+ return _c
106+}
A internal/ports/mocks/clock_mock.go +304 -0
@@ -0,0 +1,304 @@
1+// Code generated by mockery; DO NOT EDIT.
2+// github.com/vektra/mockery
3+// template: testify
4+
5+package portsmocks
6+
7+import (
8+ "time"
9+
10+ "github.com/bnema/vev/internal/ports"
11+ mock "github.com/stretchr/testify/mock"
12+)
13+
14+// NewMockClock creates a new instance of MockClock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
15+// The first argument is typically a *testing.T value.
16+func NewMockClock(t interface {
17+ mock.TestingT
18+ Cleanup(func())
19+}) *MockClock {
20+ mock := &MockClock{}
21+ mock.Mock.Test(t)
22+
23+ t.Cleanup(func() { mock.AssertExpectations(t) })
24+
25+ return mock
26+}
27+
28+// MockClock is an autogenerated mock type for the Clock type
29+type MockClock struct {
30+ mock.Mock
31+}
32+
33+type MockClock_Expecter struct {
34+ mock *mock.Mock
35+}
36+
37+func (_m *MockClock) EXPECT() *MockClock_Expecter {
38+ return &MockClock_Expecter{mock: &_m.Mock}
39+}
40+
41+// NewTimer provides a mock function for the type MockClock
42+func (_mock *MockClock) NewTimer(d time.Duration) ports.Timer {
43+ ret := _mock.Called(d)
44+
45+ if len(ret) == 0 {
46+ panic("no return value specified for NewTimer")
47+ }
48+
49+ var r0 ports.Timer
50+ if returnFunc, ok := ret.Get(0).(func(time.Duration) ports.Timer); ok {
51+ r0 = returnFunc(d)
52+ } else {
53+ if ret.Get(0) != nil {
54+ r0 = ret.Get(0).(ports.Timer)
55+ }
56+ }
57+ return r0
58+}
59+
60+// MockClock_NewTimer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewTimer'
61+type MockClock_NewTimer_Call struct {
62+ *mock.Call
63+}
64+
65+// NewTimer is a helper method to define mock.On call
66+// - d time.Duration
67+func (_e *MockClock_Expecter) NewTimer(d any) *MockClock_NewTimer_Call {
68+ return &MockClock_NewTimer_Call{Call: _e.mock.On("NewTimer", d)}
69+}
70+
71+func (_c *MockClock_NewTimer_Call) Run(run func(d time.Duration)) *MockClock_NewTimer_Call {
72+ _c.Call.Run(func(args mock.Arguments) {
73+ var arg0 time.Duration
74+ if args[0] != nil {
75+ arg0 = args[0].(time.Duration)
76+ }
77+ run(
78+ arg0,
79+ )
80+ })
81+ return _c
82+}
83+
84+func (_c *MockClock_NewTimer_Call) Return(timer ports.Timer) *MockClock_NewTimer_Call {
85+ _c.Call.Return(timer)
86+ return _c
87+}
88+
89+func (_c *MockClock_NewTimer_Call) RunAndReturn(run func(d time.Duration) ports.Timer) *MockClock_NewTimer_Call {
90+ _c.Call.Return(run)
91+ return _c
92+}
93+
94+// Now provides a mock function for the type MockClock
95+func (_mock *MockClock) Now() time.Time {
96+ ret := _mock.Called()
97+
98+ if len(ret) == 0 {
99+ panic("no return value specified for Now")
100+ }
101+
102+ var r0 time.Time
103+ if returnFunc, ok := ret.Get(0).(func() time.Time); ok {
104+ r0 = returnFunc()
105+ } else {
106+ r0 = ret.Get(0).(time.Time)
107+ }
108+ return r0
109+}
110+
111+// MockClock_Now_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Now'
112+type MockClock_Now_Call struct {
113+ *mock.Call
114+}
115+
116+// Now is a helper method to define mock.On call
117+func (_e *MockClock_Expecter) Now() *MockClock_Now_Call {
118+ return &MockClock_Now_Call{Call: _e.mock.On("Now")}
119+}
120+
121+func (_c *MockClock_Now_Call) Run(run func()) *MockClock_Now_Call {
122+ _c.Call.Run(func(args mock.Arguments) {
123+ run()
124+ })
125+ return _c
126+}
127+
128+func (_c *MockClock_Now_Call) Return(time1 time.Time) *MockClock_Now_Call {
129+ _c.Call.Return(time1)
130+ return _c
131+}
132+
133+func (_c *MockClock_Now_Call) RunAndReturn(run func() time.Time) *MockClock_Now_Call {
134+ _c.Call.Return(run)
135+ return _c
136+}
137+
138+// NewMockTimer creates a new instance of MockTimer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
139+// The first argument is typically a *testing.T value.
140+func NewMockTimer(t interface {
141+ mock.TestingT
142+ Cleanup(func())
143+}) *MockTimer {
144+ mock := &MockTimer{}
145+ mock.Mock.Test(t)
146+
147+ t.Cleanup(func() { mock.AssertExpectations(t) })
148+
149+ return mock
150+}
151+
152+// MockTimer is an autogenerated mock type for the Timer type
153+type MockTimer struct {
154+ mock.Mock
155+}
156+
157+type MockTimer_Expecter struct {
158+ mock *mock.Mock
159+}
160+
161+func (_m *MockTimer) EXPECT() *MockTimer_Expecter {
162+ return &MockTimer_Expecter{mock: &_m.Mock}
163+}
164+
165+// C provides a mock function for the type MockTimer
166+func (_mock *MockTimer) C() <-chan time.Time {
167+ ret := _mock.Called()
168+
169+ if len(ret) == 0 {
170+ panic("no return value specified for C")
171+ }
172+
173+ var r0 <-chan time.Time
174+ if returnFunc, ok := ret.Get(0).(func() <-chan time.Time); ok {
175+ r0 = returnFunc()
176+ } else {
177+ if ret.Get(0) != nil {
178+ r0 = ret.Get(0).(<-chan time.Time)
179+ }
180+ }
181+ return r0
182+}
183+
184+// MockTimer_C_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'C'
185+type MockTimer_C_Call struct {
186+ *mock.Call
187+}
188+
189+// C is a helper method to define mock.On call
190+func (_e *MockTimer_Expecter) C() *MockTimer_C_Call {
191+ return &MockTimer_C_Call{Call: _e.mock.On("C")}
192+}
193+
194+func (_c *MockTimer_C_Call) Run(run func()) *MockTimer_C_Call {
195+ _c.Call.Run(func(args mock.Arguments) {
196+ run()
197+ })
198+ return _c
199+}
200+
201+func (_c *MockTimer_C_Call) Return(timeCh <-chan time.Time) *MockTimer_C_Call {
202+ _c.Call.Return(timeCh)
203+ return _c
204+}
205+
206+func (_c *MockTimer_C_Call) RunAndReturn(run func() <-chan time.Time) *MockTimer_C_Call {
207+ _c.Call.Return(run)
208+ return _c
209+}
210+
211+// Reset provides a mock function for the type MockTimer
212+func (_mock *MockTimer) Reset(d time.Duration) bool {
213+ ret := _mock.Called(d)
214+
215+ if len(ret) == 0 {
216+ panic("no return value specified for Reset")
217+ }
218+
219+ var r0 bool
220+ if returnFunc, ok := ret.Get(0).(func(time.Duration) bool); ok {
221+ r0 = returnFunc(d)
222+ } else {
223+ r0 = ret.Get(0).(bool)
224+ }
225+ return r0
226+}
227+
228+// MockTimer_Reset_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reset'
229+type MockTimer_Reset_Call struct {
230+ *mock.Call
231+}
232+
233+// Reset is a helper method to define mock.On call
234+// - d time.Duration
235+func (_e *MockTimer_Expecter) Reset(d any) *MockTimer_Reset_Call {
236+ return &MockTimer_Reset_Call{Call: _e.mock.On("Reset", d)}
237+}
238+
239+func (_c *MockTimer_Reset_Call) Run(run func(d time.Duration)) *MockTimer_Reset_Call {
240+ _c.Call.Run(func(args mock.Arguments) {
241+ var arg0 time.Duration
242+ if args[0] != nil {
243+ arg0 = args[0].(time.Duration)
244+ }
245+ run(
246+ arg0,
247+ )
248+ })
249+ return _c
250+}
251+
252+func (_c *MockTimer_Reset_Call) Return(b bool) *MockTimer_Reset_Call {
253+ _c.Call.Return(b)
254+ return _c
255+}
256+
257+func (_c *MockTimer_Reset_Call) RunAndReturn(run func(d time.Duration) bool) *MockTimer_Reset_Call {
258+ _c.Call.Return(run)
259+ return _c
260+}
261+
262+// Stop provides a mock function for the type MockTimer
263+func (_mock *MockTimer) Stop() bool {
264+ ret := _mock.Called()
265+
266+ if len(ret) == 0 {
267+ panic("no return value specified for Stop")
268+ }
269+
270+ var r0 bool
271+ if returnFunc, ok := ret.Get(0).(func() bool); ok {
272+ r0 = returnFunc()
273+ } else {
274+ r0 = ret.Get(0).(bool)
275+ }
276+ return r0
277+}
278+
279+// MockTimer_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
280+type MockTimer_Stop_Call struct {
281+ *mock.Call
282+}
283+
284+// Stop is a helper method to define mock.On call
285+func (_e *MockTimer_Expecter) Stop() *MockTimer_Stop_Call {
286+ return &MockTimer_Stop_Call{Call: _e.mock.On("Stop")}
287+}
288+
289+func (_c *MockTimer_Stop_Call) Run(run func()) *MockTimer_Stop_Call {
290+ _c.Call.Run(func(args mock.Arguments) {
291+ run()
292+ })
293+ return _c
294+}
295+
296+func (_c *MockTimer_Stop_Call) Return(b bool) *MockTimer_Stop_Call {
297+ _c.Call.Return(b)
298+ return _c
299+}
300+
301+func (_c *MockTimer_Stop_Call) RunAndReturn(run func() bool) *MockTimer_Stop_Call {
302+ _c.Call.Return(run)
303+ return _c
304+}
@@ -0,0 +1,304 @@
1+// Code generated by mockery; DO NOT EDIT.
2+// github.com/vektra/mockery
3+// template: testify
4+
5+package portsmocks
6+
7+import (
8+ "time"
9+
10+ "github.com/bnema/vev/internal/ports"
11+ mock "github.com/stretchr/testify/mock"
12+)
13+
14+// NewMockClock creates a new instance of MockClock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
15+// The first argument is typically a *testing.T value.
16+func NewMockClock(t interface {
17+ mock.TestingT
18+ Cleanup(func())
19+}) *MockClock {
20+ mock := &MockClock{}
21+ mock.Mock.Test(t)
22+
23+ t.Cleanup(func() { mock.AssertExpectations(t) })
24+
25+ return mock
26+}
27+
28+// MockClock is an autogenerated mock type for the Clock type
29+type MockClock struct {
30+ mock.Mock
31+}
32+
33+type MockClock_Expecter struct {
34+ mock *mock.Mock
35+}
36+
37+func (_m *MockClock) EXPECT() *MockClock_Expecter {
38+ return &MockClock_Expecter{mock: &_m.Mock}
39+}
40+
41+// NewTimer provides a mock function for the type MockClock
42+func (_mock *MockClock) NewTimer(d time.Duration) ports.Timer {
43+ ret := _mock.Called(d)
44+
45+ if len(ret) == 0 {
46+ panic("no return value specified for NewTimer")
47+ }
48+
49+ var r0 ports.Timer
50+ if returnFunc, ok := ret.Get(0).(func(time.Duration) ports.Timer); ok {
51+ r0 = returnFunc(d)
52+ } else {
53+ if ret.Get(0) != nil {
54+ r0 = ret.Get(0).(ports.Timer)
55+ }
56+ }
57+ return r0
58+}
59+
60+// MockClock_NewTimer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewTimer'
61+type MockClock_NewTimer_Call struct {
62+ *mock.Call
63+}
64+
65+// NewTimer is a helper method to define mock.On call
66+// - d time.Duration
67+func (_e *MockClock_Expecter) NewTimer(d any) *MockClock_NewTimer_Call {
68+ return &MockClock_NewTimer_Call{Call: _e.mock.On("NewTimer", d)}
69+}
70+
71+func (_c *MockClock_NewTimer_Call) Run(run func(d time.Duration)) *MockClock_NewTimer_Call {
72+ _c.Call.Run(func(args mock.Arguments) {
73+ var arg0 time.Duration
74+ if args[0] != nil {
75+ arg0 = args[0].(time.Duration)
76+ }
77+ run(
78+ arg0,
79+ )
80+ })
81+ return _c
82+}
83+
84+func (_c *MockClock_NewTimer_Call) Return(timer ports.Timer) *MockClock_NewTimer_Call {
85+ _c.Call.Return(timer)
86+ return _c
87+}
88+
89+func (_c *MockClock_NewTimer_Call) RunAndReturn(run func(d time.Duration) ports.Timer) *MockClock_NewTimer_Call {
90+ _c.Call.Return(run)
91+ return _c
92+}
93+
94+// Now provides a mock function for the type MockClock
95+func (_mock *MockClock) Now() time.Time {
96+ ret := _mock.Called()
97+
98+ if len(ret) == 0 {
99+ panic("no return value specified for Now")
100+ }
101+
102+ var r0 time.Time
103+ if returnFunc, ok := ret.Get(0).(func() time.Time); ok {
104+ r0 = returnFunc()
105+ } else {
106+ r0 = ret.Get(0).(time.Time)
107+ }
108+ return r0
109+}
110+
111+// MockClock_Now_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Now'
112+type MockClock_Now_Call struct {
113+ *mock.Call
114+}
115+
116+// Now is a helper method to define mock.On call
117+func (_e *MockClock_Expecter) Now() *MockClock_Now_Call {
118+ return &MockClock_Now_Call{Call: _e.mock.On("Now")}
119+}
120+
121+func (_c *MockClock_Now_Call) Run(run func()) *MockClock_Now_Call {
122+ _c.Call.Run(func(args mock.Arguments) {
123+ run()
124+ })
125+ return _c
126+}
127+
128+func (_c *MockClock_Now_Call) Return(time1 time.Time) *MockClock_Now_Call {
129+ _c.Call.Return(time1)
130+ return _c
131+}
132+
133+func (_c *MockClock_Now_Call) RunAndReturn(run func() time.Time) *MockClock_Now_Call {
134+ _c.Call.Return(run)
135+ return _c
136+}
137+
138+// NewMockTimer creates a new instance of MockTimer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
139+// The first argument is typically a *testing.T value.
140+func NewMockTimer(t interface {
141+ mock.TestingT
142+ Cleanup(func())
143+}) *MockTimer {
144+ mock := &MockTimer{}
145+ mock.Mock.Test(t)
146+
147+ t.Cleanup(func() { mock.AssertExpectations(t) })
148+
149+ return mock
150+}
151+
152+// MockTimer is an autogenerated mock type for the Timer type
153+type MockTimer struct {
154+ mock.Mock
155+}
156+
157+type MockTimer_Expecter struct {
158+ mock *mock.Mock
159+}
160+
161+func (_m *MockTimer) EXPECT() *MockTimer_Expecter {
162+ return &MockTimer_Expecter{mock: &_m.Mock}
163+}
164+
165+// C provides a mock function for the type MockTimer
166+func (_mock *MockTimer) C() <-chan time.Time {
167+ ret := _mock.Called()
168+
169+ if len(ret) == 0 {
170+ panic("no return value specified for C")
171+ }
172+
173+ var r0 <-chan time.Time
174+ if returnFunc, ok := ret.Get(0).(func() <-chan time.Time); ok {
175+ r0 = returnFunc()
176+ } else {
177+ if ret.Get(0) != nil {
178+ r0 = ret.Get(0).(<-chan time.Time)
179+ }
180+ }
181+ return r0
182+}
183+
184+// MockTimer_C_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'C'
185+type MockTimer_C_Call struct {
186+ *mock.Call
187+}
188+
189+// C is a helper method to define mock.On call
190+func (_e *MockTimer_Expecter) C() *MockTimer_C_Call {
191+ return &MockTimer_C_Call{Call: _e.mock.On("C")}
192+}
193+
194+func (_c *MockTimer_C_Call) Run(run func()) *MockTimer_C_Call {
195+ _c.Call.Run(func(args mock.Arguments) {
196+ run()
197+ })
198+ return _c
199+}
200+
201+func (_c *MockTimer_C_Call) Return(timeCh <-chan time.Time) *MockTimer_C_Call {
202+ _c.Call.Return(timeCh)
203+ return _c
204+}
205+
206+func (_c *MockTimer_C_Call) RunAndReturn(run func() <-chan time.Time) *MockTimer_C_Call {
207+ _c.Call.Return(run)
208+ return _c
209+}
210+
211+// Reset provides a mock function for the type MockTimer
212+func (_mock *MockTimer) Reset(d time.Duration) bool {
213+ ret := _mock.Called(d)
214+
215+ if len(ret) == 0 {
216+ panic("no return value specified for Reset")
217+ }
218+
219+ var r0 bool
220+ if returnFunc, ok := ret.Get(0).(func(time.Duration) bool); ok {
221+ r0 = returnFunc(d)
222+ } else {
223+ r0 = ret.Get(0).(bool)
224+ }
225+ return r0
226+}
227+
228+// MockTimer_Reset_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reset'
229+type MockTimer_Reset_Call struct {
230+ *mock.Call
231+}
232+
233+// Reset is a helper method to define mock.On call
234+// - d time.Duration
235+func (_e *MockTimer_Expecter) Reset(d any) *MockTimer_Reset_Call {
236+ return &MockTimer_Reset_Call{Call: _e.mock.On("Reset", d)}
237+}
238+
239+func (_c *MockTimer_Reset_Call) Run(run func(d time.Duration)) *MockTimer_Reset_Call {
240+ _c.Call.Run(func(args mock.Arguments) {
241+ var arg0 time.Duration
242+ if args[0] != nil {
243+ arg0 = args[0].(time.Duration)
244+ }
245+ run(
246+ arg0,
247+ )
248+ })
249+ return _c
250+}
251+
252+func (_c *MockTimer_Reset_Call) Return(b bool) *MockTimer_Reset_Call {
253+ _c.Call.Return(b)
254+ return _c
255+}
256+
257+func (_c *MockTimer_Reset_Call) RunAndReturn(run func(d time.Duration) bool) *MockTimer_Reset_Call {
258+ _c.Call.Return(run)
259+ return _c
260+}
261+
262+// Stop provides a mock function for the type MockTimer
263+func (_mock *MockTimer) Stop() bool {
264+ ret := _mock.Called()
265+
266+ if len(ret) == 0 {
267+ panic("no return value specified for Stop")
268+ }
269+
270+ var r0 bool
271+ if returnFunc, ok := ret.Get(0).(func() bool); ok {
272+ r0 = returnFunc()
273+ } else {
274+ r0 = ret.Get(0).(bool)
275+ }
276+ return r0
277+}
278+
279+// MockTimer_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
280+type MockTimer_Stop_Call struct {
281+ *mock.Call
282+}
283+
284+// Stop is a helper method to define mock.On call
285+func (_e *MockTimer_Expecter) Stop() *MockTimer_Stop_Call {
286+ return &MockTimer_Stop_Call{Call: _e.mock.On("Stop")}
287+}
288+
289+func (_c *MockTimer_Stop_Call) Run(run func()) *MockTimer_Stop_Call {
290+ _c.Call.Run(func(args mock.Arguments) {
291+ run()
292+ })
293+ return _c
294+}
295+
296+func (_c *MockTimer_Stop_Call) Return(b bool) *MockTimer_Stop_Call {
297+ _c.Call.Return(b)
298+ return _c
299+}
300+
301+func (_c *MockTimer_Stop_Call) RunAndReturn(run func() bool) *MockTimer_Stop_Call {
302+ _c.Call.Return(run)
303+ return _c
304+}
A internal/ports/mocks/link_mock.go +127 -0
@@ -0,0 +1,127 @@
1+// Code generated by mockery; DO NOT EDIT.
2+// github.com/vektra/mockery
3+// template: testify
4+
5+package portsmocks
6+
7+import (
8+ "github.com/bnema/vev/internal/ports"
9+ mock "github.com/stretchr/testify/mock"
10+)
11+
12+// NewMockLinkStateReporter creates a new instance of MockLinkStateReporter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
13+// The first argument is typically a *testing.T value.
14+func NewMockLinkStateReporter(t interface {
15+ mock.TestingT
16+ Cleanup(func())
17+}) *MockLinkStateReporter {
18+ mock := &MockLinkStateReporter{}
19+ mock.Mock.Test(t)
20+
21+ t.Cleanup(func() { mock.AssertExpectations(t) })
22+
23+ return mock
24+}
25+
26+// MockLinkStateReporter is an autogenerated mock type for the LinkStateReporter type
27+type MockLinkStateReporter struct {
28+ mock.Mock
29+}
30+
31+type MockLinkStateReporter_Expecter struct {
32+ mock *mock.Mock
33+}
34+
35+func (_m *MockLinkStateReporter) EXPECT() *MockLinkStateReporter_Expecter {
36+ return &MockLinkStateReporter_Expecter{mock: &_m.Mock}
37+}
38+
39+// LinkEvents provides a mock function for the type MockLinkStateReporter
40+func (_mock *MockLinkStateReporter) LinkEvents() <-chan ports.LinkEvent {
41+ ret := _mock.Called()
42+
43+ if len(ret) == 0 {
44+ panic("no return value specified for LinkEvents")
45+ }
46+
47+ var r0 <-chan ports.LinkEvent
48+ if returnFunc, ok := ret.Get(0).(func() <-chan ports.LinkEvent); ok {
49+ r0 = returnFunc()
50+ } else {
51+ if ret.Get(0) != nil {
52+ r0 = ret.Get(0).(<-chan ports.LinkEvent)
53+ }
54+ }
55+ return r0
56+}
57+
58+// MockLinkStateReporter_LinkEvents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LinkEvents'
59+type MockLinkStateReporter_LinkEvents_Call struct {
60+ *mock.Call
61+}
62+
63+// LinkEvents is a helper method to define mock.On call
64+func (_e *MockLinkStateReporter_Expecter) LinkEvents() *MockLinkStateReporter_LinkEvents_Call {
65+ return &MockLinkStateReporter_LinkEvents_Call{Call: _e.mock.On("LinkEvents")}
66+}
67+
68+func (_c *MockLinkStateReporter_LinkEvents_Call) Run(run func()) *MockLinkStateReporter_LinkEvents_Call {
69+ _c.Call.Run(func(args mock.Arguments) {
70+ run()
71+ })
72+ return _c
73+}
74+
75+func (_c *MockLinkStateReporter_LinkEvents_Call) Return(linkEventCh <-chan ports.LinkEvent) *MockLinkStateReporter_LinkEvents_Call {
76+ _c.Call.Return(linkEventCh)
77+ return _c
78+}
79+
80+func (_c *MockLinkStateReporter_LinkEvents_Call) RunAndReturn(run func() <-chan ports.LinkEvent) *MockLinkStateReporter_LinkEvents_Call {
81+ _c.Call.Return(run)
82+ return _c
83+}
84+
85+// LinkState provides a mock function for the type MockLinkStateReporter
86+func (_mock *MockLinkStateReporter) LinkState() ports.LinkState {
87+ ret := _mock.Called()
88+
89+ if len(ret) == 0 {
90+ panic("no return value specified for LinkState")
91+ }
92+
93+ var r0 ports.LinkState
94+ if returnFunc, ok := ret.Get(0).(func() ports.LinkState); ok {
95+ r0 = returnFunc()
96+ } else {
97+ r0 = ret.Get(0).(ports.LinkState)
98+ }
99+ return r0
100+}
101+
102+// MockLinkStateReporter_LinkState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LinkState'
103+type MockLinkStateReporter_LinkState_Call struct {
104+ *mock.Call
105+}
106+
107+// LinkState is a helper method to define mock.On call
108+func (_e *MockLinkStateReporter_Expecter) LinkState() *MockLinkStateReporter_LinkState_Call {
109+ return &MockLinkStateReporter_LinkState_Call{Call: _e.mock.On("LinkState")}
110+}
111+
112+func (_c *MockLinkStateReporter_LinkState_Call) Run(run func()) *MockLinkStateReporter_LinkState_Call {
113+ _c.Call.Run(func(args mock.Arguments) {
114+ run()
115+ })
116+ return _c
117+}
118+
119+func (_c *MockLinkStateReporter_LinkState_Call) Return(linkState ports.LinkState) *MockLinkStateReporter_LinkState_Call {
120+ _c.Call.Return(linkState)
121+ return _c
122+}
123+
124+func (_c *MockLinkStateReporter_LinkState_Call) RunAndReturn(run func() ports.LinkState) *MockLinkStateReporter_LinkState_Call {
125+ _c.Call.Return(run)
126+ return _c
127+}
@@ -0,0 +1,127 @@
1+// Code generated by mockery; DO NOT EDIT.
2+// github.com/vektra/mockery
3+// template: testify
4+
5+package portsmocks
6+
7+import (
8+ "github.com/bnema/vev/internal/ports"
9+ mock "github.com/stretchr/testify/mock"
10+)
11+
12+// NewMockLinkStateReporter creates a new instance of MockLinkStateReporter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
13+// The first argument is typically a *testing.T value.
14+func NewMockLinkStateReporter(t interface {
15+ mock.TestingT
16+ Cleanup(func())
17+}) *MockLinkStateReporter {
18+ mock := &MockLinkStateReporter{}
19+ mock.Mock.Test(t)
20+
21+ t.Cleanup(func() { mock.AssertExpectations(t) })
22+
23+ return mock
24+}
25+
26+// MockLinkStateReporter is an autogenerated mock type for the LinkStateReporter type
27+type MockLinkStateReporter struct {
28+ mock.Mock
29+}
30+
31+type MockLinkStateReporter_Expecter struct {
32+ mock *mock.Mock
33+}
34+
35+func (_m *MockLinkStateReporter) EXPECT() *MockLinkStateReporter_Expecter {
36+ return &MockLinkStateReporter_Expecter{mock: &_m.Mock}
37+}
38+
39+// LinkEvents provides a mock function for the type MockLinkStateReporter
40+func (_mock *MockLinkStateReporter) LinkEvents() <-chan ports.LinkEvent {
41+ ret := _mock.Called()
42+
43+ if len(ret) == 0 {
44+ panic("no return value specified for LinkEvents")
45+ }
46+
47+ var r0 <-chan ports.LinkEvent
48+ if returnFunc, ok := ret.Get(0).(func() <-chan ports.LinkEvent); ok {
49+ r0 = returnFunc()
50+ } else {
51+ if ret.Get(0) != nil {
52+ r0 = ret.Get(0).(<-chan ports.LinkEvent)
53+ }
54+ }
55+ return r0
56+}
57+
58+// MockLinkStateReporter_LinkEvents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LinkEvents'
59+type MockLinkStateReporter_LinkEvents_Call struct {
60+ *mock.Call
61+}
62+
63+// LinkEvents is a helper method to define mock.On call
64+func (_e *MockLinkStateReporter_Expecter) LinkEvents() *MockLinkStateReporter_LinkEvents_Call {
65+ return &MockLinkStateReporter_LinkEvents_Call{Call: _e.mock.On("LinkEvents")}
66+}
67+
68+func (_c *MockLinkStateReporter_LinkEvents_Call) Run(run func()) *MockLinkStateReporter_LinkEvents_Call {
69+ _c.Call.Run(func(args mock.Arguments) {
70+ run()
71+ })
72+ return _c
73+}
74+
75+func (_c *MockLinkStateReporter_LinkEvents_Call) Return(linkEventCh <-chan ports.LinkEvent) *MockLinkStateReporter_LinkEvents_Call {
76+ _c.Call.Return(linkEventCh)
77+ return _c
78+}
79+
80+func (_c *MockLinkStateReporter_LinkEvents_Call) RunAndReturn(run func() <-chan ports.LinkEvent) *MockLinkStateReporter_LinkEvents_Call {
81+ _c.Call.Return(run)
82+ return _c
83+}
84+
85+// LinkState provides a mock function for the type MockLinkStateReporter
86+func (_mock *MockLinkStateReporter) LinkState() ports.LinkState {
87+ ret := _mock.Called()
88+
89+ if len(ret) == 0 {
90+ panic("no return value specified for LinkState")
91+ }
92+
93+ var r0 ports.LinkState
94+ if returnFunc, ok := ret.Get(0).(func() ports.LinkState); ok {
95+ r0 = returnFunc()
96+ } else {
97+ r0 = ret.Get(0).(ports.LinkState)
98+ }
99+ return r0
100+}
101+
102+// MockLinkStateReporter_LinkState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LinkState'
103+type MockLinkStateReporter_LinkState_Call struct {
104+ *mock.Call
105+}
106+
107+// LinkState is a helper method to define mock.On call
108+func (_e *MockLinkStateReporter_Expecter) LinkState() *MockLinkStateReporter_LinkState_Call {
109+ return &MockLinkStateReporter_LinkState_Call{Call: _e.mock.On("LinkState")}
110+}
111+
112+func (_c *MockLinkStateReporter_LinkState_Call) Run(run func()) *MockLinkStateReporter_LinkState_Call {
113+ _c.Call.Run(func(args mock.Arguments) {
114+ run()
115+ })
116+ return _c
117+}
118+
119+func (_c *MockLinkStateReporter_LinkState_Call) Return(linkState ports.LinkState) *MockLinkStateReporter_LinkState_Call {
120+ _c.Call.Return(linkState)
121+ return _c
122+}
123+
124+func (_c *MockLinkStateReporter_LinkState_Call) RunAndReturn(run func() ports.LinkState) *MockLinkStateReporter_LinkState_Call {
125+ _c.Call.Return(run)
126+ return _c
127+}
D internal/ports/mocks/mocks.go +0 -3198 large diff (3198 lines changed): collapsed
load diff
A internal/ports/mocks/process_mock.go +286 -0
@@ -0,0 +1,286 @@
1+// Code generated by mockery; DO NOT EDIT.
2+// github.com/vektra/mockery
3+// template: testify
4+
5+package portsmocks
6+
7+import (
8+ mock "github.com/stretchr/testify/mock"
9+)
10+
11+// NewMockProcessInspector creates a new instance of MockProcessInspector. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
12+// The first argument is typically a *testing.T value.
13+func NewMockProcessInspector(t interface {
14+ mock.TestingT
15+ Cleanup(func())
16+}) *MockProcessInspector {
17+ mock := &MockProcessInspector{}
18+ mock.Mock.Test(t)
19+
20+ t.Cleanup(func() { mock.AssertExpectations(t) })
21+
22+ return mock
23+}
24+
25+// MockProcessInspector is an autogenerated mock type for the ProcessInspector type
26+type MockProcessInspector struct {
27+ mock.Mock
28+}
29+
30+type MockProcessInspector_Expecter struct {
31+ mock *mock.Mock
32+}
33+
34+func (_m *MockProcessInspector) EXPECT() *MockProcessInspector_Expecter {
35+ return &MockProcessInspector_Expecter{mock: &_m.Mock}
36+}
37+
38+// Argv provides a mock function for the type MockProcessInspector
39+func (_mock *MockProcessInspector) Argv(pid int) ([]string, error) {
40+ ret := _mock.Called(pid)
41+
42+ if len(ret) == 0 {
43+ panic("no return value specified for Argv")
44+ }
45+
46+ var r0 []string
47+ var r1 error
48+ if returnFunc, ok := ret.Get(0).(func(int) ([]string, error)); ok {
49+ return returnFunc(pid)
50+ }
51+ if returnFunc, ok := ret.Get(0).(func(int) []string); ok {
52+ r0 = returnFunc(pid)
53+ } else {
54+ if ret.Get(0) != nil {
55+ r0 = ret.Get(0).([]string)
56+ }
57+ }
58+ if returnFunc, ok := ret.Get(1).(func(int) error); ok {
59+ r1 = returnFunc(pid)
60+ } else {
61+ r1 = ret.Error(1)
62+ }
63+ return r0, r1
64+}
65+
66+// MockProcessInspector_Argv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Argv'
67+type MockProcessInspector_Argv_Call struct {
68+ *mock.Call
69+}
70+
71+// Argv is a helper method to define mock.On call
72+// - pid int
73+func (_e *MockProcessInspector_Expecter) Argv(pid any) *MockProcessInspector_Argv_Call {
74+ return &MockProcessInspector_Argv_Call{Call: _e.mock.On("Argv", pid)}
75+}
76+
77+func (_c *MockProcessInspector_Argv_Call) Run(run func(pid int)) *MockProcessInspector_Argv_Call {
78+ _c.Call.Run(func(args mock.Arguments) {
79+ var arg0 int
80+ if args[0] != nil {
81+ arg0 = args[0].(int)
82+ }
83+ run(
84+ arg0,
85+ )
86+ })
87+ return _c
88+}
89+
90+func (_c *MockProcessInspector_Argv_Call) Return(strings []string, err error) *MockProcessInspector_Argv_Call {
91+ _c.Call.Return(strings, err)
92+ return _c
93+}
94+
95+func (_c *MockProcessInspector_Argv_Call) RunAndReturn(run func(pid int) ([]string, error)) *MockProcessInspector_Argv_Call {
96+ _c.Call.Return(run)
97+ return _c
98+}
99+
100+// Comm provides a mock function for the type MockProcessInspector
101+func (_mock *MockProcessInspector) Comm(pid int) (string, error) {
102+ ret := _mock.Called(pid)
103+
104+ if len(ret) == 0 {
105+ panic("no return value specified for Comm")
106+ }
107+
108+ var r0 string
109+ var r1 error
110+ if returnFunc, ok := ret.Get(0).(func(int) (string, error)); ok {
111+ return returnFunc(pid)
112+ }
113+ if returnFunc, ok := ret.Get(0).(func(int) string); ok {
114+ r0 = returnFunc(pid)
115+ } else {
116+ r0 = ret.Get(0).(string)
117+ }
118+ if returnFunc, ok := ret.Get(1).(func(int) error); ok {
119+ r1 = returnFunc(pid)
120+ } else {
121+ r1 = ret.Error(1)
122+ }
123+ return r0, r1
124+}
125+
126+// MockProcessInspector_Comm_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Comm'
127+type MockProcessInspector_Comm_Call struct {
128+ *mock.Call
129+}
130+
131+// Comm is a helper method to define mock.On call
132+// - pid int
133+func (_e *MockProcessInspector_Expecter) Comm(pid any) *MockProcessInspector_Comm_Call {
134+ return &MockProcessInspector_Comm_Call{Call: _e.mock.On("Comm", pid)}
135+}
136+
137+func (_c *MockProcessInspector_Comm_Call) Run(run func(pid int)) *MockProcessInspector_Comm_Call {
138+ _c.Call.Run(func(args mock.Arguments) {
139+ var arg0 int
140+ if args[0] != nil {
141+ arg0 = args[0].(int)
142+ }
143+ run(
144+ arg0,
145+ )
146+ })
147+ return _c
148+}
149+
150+func (_c *MockProcessInspector_Comm_Call) Return(s string, err error) *MockProcessInspector_Comm_Call {
151+ _c.Call.Return(s, err)
152+ return _c
153+}
154+
155+func (_c *MockProcessInspector_Comm_Call) RunAndReturn(run func(pid int) (string, error)) *MockProcessInspector_Comm_Call {
156+ _c.Call.Return(run)
157+ return _c
158+}
159+
160+// Cwd provides a mock function for the type MockProcessInspector
161+func (_mock *MockProcessInspector) Cwd(pid int) (string, error) {
162+ ret := _mock.Called(pid)
163+
164+ if len(ret) == 0 {
165+ panic("no return value specified for Cwd")
166+ }
167+
168+ var r0 string
169+ var r1 error
170+ if returnFunc, ok := ret.Get(0).(func(int) (string, error)); ok {
171+ return returnFunc(pid)
172+ }
173+ if returnFunc, ok := ret.Get(0).(func(int) string); ok {
174+ r0 = returnFunc(pid)
175+ } else {
176+ r0 = ret.Get(0).(string)
177+ }
178+ if returnFunc, ok := ret.Get(1).(func(int) error); ok {
179+ r1 = returnFunc(pid)
180+ } else {
181+ r1 = ret.Error(1)
182+ }
183+ return r0, r1
184+}
185+
186+// MockProcessInspector_Cwd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Cwd'
187+type MockProcessInspector_Cwd_Call struct {
188+ *mock.Call
189+}
190+
191+// Cwd is a helper method to define mock.On call
192+// - pid int
193+func (_e *MockProcessInspector_Expecter) Cwd(pid any) *MockProcessInspector_Cwd_Call {
194+ return &MockProcessInspector_Cwd_Call{Call: _e.mock.On("Cwd", pid)}
195+}
196+
197+func (_c *MockProcessInspector_Cwd_Call) Run(run func(pid int)) *MockProcessInspector_Cwd_Call {
198+ _c.Call.Run(func(args mock.Arguments) {
199+ var arg0 int
200+ if args[0] != nil {
201+ arg0 = args[0].(int)
202+ }
203+ run(
204+ arg0,
205+ )
206+ })
207+ return _c
208+}
209+
210+func (_c *MockProcessInspector_Cwd_Call) Return(s string, err error) *MockProcessInspector_Cwd_Call {
211+ _c.Call.Return(s, err)
212+ return _c
213+}
214+
215+func (_c *MockProcessInspector_Cwd_Call) RunAndReturn(run func(pid int) (string, error)) *MockProcessInspector_Cwd_Call {
216+ _c.Call.Return(run)
217+ return _c
218+}
219+
220+// GroupArgv provides a mock function for the type MockProcessInspector
221+func (_mock *MockProcessInspector) GroupArgv(pgid int, shellPid int) ([]string, error) {
222+ ret := _mock.Called(pgid, shellPid)
223+
224+ if len(ret) == 0 {
225+ panic("no return value specified for GroupArgv")
226+ }
227+
228+ var r0 []string
229+ var r1 error
230+ if returnFunc, ok := ret.Get(0).(func(int, int) ([]string, error)); ok {
231+ return returnFunc(pgid, shellPid)
232+ }
233+ if returnFunc, ok := ret.Get(0).(func(int, int) []string); ok {
234+ r0 = returnFunc(pgid, shellPid)
235+ } else {
236+ if ret.Get(0) != nil {
237+ r0 = ret.Get(0).([]string)
238+ }
239+ }
240+ if returnFunc, ok := ret.Get(1).(func(int, int) error); ok {
241+ r1 = returnFunc(pgid, shellPid)
242+ } else {
243+ r1 = ret.Error(1)
244+ }
245+ return r0, r1
246+}
247+
248+// MockProcessInspector_GroupArgv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupArgv'
249+type MockProcessInspector_GroupArgv_Call struct {
250+ *mock.Call
251+}
252+
253+// GroupArgv is a helper method to define mock.On call
254+// - pgid int
255+// - shellPid int
256+func (_e *MockProcessInspector_Expecter) GroupArgv(pgid any, shellPid any) *MockProcessInspector_GroupArgv_Call {
257+ return &MockProcessInspector_GroupArgv_Call{Call: _e.mock.On("GroupArgv", pgid, shellPid)}
258+}
259+
260+func (_c *MockProcessInspector_GroupArgv_Call) Run(run func(pgid int, shellPid int)) *MockProcessInspector_GroupArgv_Call {
261+ _c.Call.Run(func(args mock.Arguments) {
262+ var arg0 int
263+ if args[0] != nil {
264+ arg0 = args[0].(int)
265+ }
266+ var arg1 int
267+ if args[1] != nil {
268+ arg1 = args[1].(int)
269+ }
270+ run(
271+ arg0,
272+ arg1,
273+ )
274+ })
275+ return _c
276+}
277+
278+func (_c *MockProcessInspector_GroupArgv_Call) Return(strings []string, err error) *MockProcessInspector_GroupArgv_Call {
279+ _c.Call.Return(strings, err)
280+ return _c
281+}
282+
283+func (_c *MockProcessInspector_GroupArgv_Call) RunAndReturn(run func(pgid int, shellPid int) ([]string, error)) *MockProcessInspector_GroupArgv_Call {
284+ _c.Call.Return(run)
285+ return _c
286+}
@@ -0,0 +1,286 @@
1+// Code generated by mockery; DO NOT EDIT.
2+// github.com/vektra/mockery
3+// template: testify
4+
5+package portsmocks
6+
7+import (
8+ mock "github.com/stretchr/testify/mock"
9+)
10+
11+// NewMockProcessInspector creates a new instance of MockProcessInspector. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
12+// The first argument is typically a *testing.T value.
13+func NewMockProcessInspector(t interface {
14+ mock.TestingT
15+ Cleanup(func())
16+}) *MockProcessInspector {
17+ mock := &MockProcessInspector{}
18+ mock.Mock.Test(t)
19+
20+ t.Cleanup(func() { mock.AssertExpectations(t) })
21+
22+ return mock
23+}
24+
25+// MockProcessInspector is an autogenerated mock type for the ProcessInspector type
26+type MockProcessInspector struct {
27+ mock.Mock
28+}
29+
30+type MockProcessInspector_Expecter struct {
31+ mock *mock.Mock
32+}
33+
34+func (_m *MockProcessInspector) EXPECT() *MockProcessInspector_Expecter {
35+ return &MockProcessInspector_Expecter{mock: &_m.Mock}
36+}
37+
38+// Argv provides a mock function for the type MockProcessInspector
39+func (_mock *MockProcessInspector) Argv(pid int) ([]string, error) {
40+ ret := _mock.Called(pid)
41+
42+ if len(ret) == 0 {
43+ panic("no return value specified for Argv")
44+ }
45+
46+ var r0 []string
47+ var r1 error
48+ if returnFunc, ok := ret.Get(0).(func(int) ([]string, error)); ok {
49+ return returnFunc(pid)
50+ }
51+ if returnFunc, ok := ret.Get(0).(func(int) []string); ok {
52+ r0 = returnFunc(pid)
53+ } else {
54+ if ret.Get(0) != nil {
55+ r0 = ret.Get(0).([]string)
56+ }
57+ }
58+ if returnFunc, ok := ret.Get(1).(func(int) error); ok {
59+ r1 = returnFunc(pid)
60+ } else {
61+ r1 = ret.Error(1)
62+ }
63+ return r0, r1
64+}
65+
66+// MockProcessInspector_Argv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Argv'
67+type MockProcessInspector_Argv_Call struct {
68+ *mock.Call
69+}
70+
71+// Argv is a helper method to define mock.On call
72+// - pid int
73+func (_e *MockProcessInspector_Expecter) Argv(pid any) *MockProcessInspector_Argv_Call {
74+ return &MockProcessInspector_Argv_Call{Call: _e.mock.On("Argv", pid)}
75+}
76+
77+func (_c *MockProcessInspector_Argv_Call) Run(run func(pid int)) *MockProcessInspector_Argv_Call {
78+ _c.Call.Run(func(args mock.Arguments) {
79+ var arg0 int
80+ if args[0] != nil {
81+ arg0 = args[0].(int)
82+ }
83+ run(
84+ arg0,
85+ )
86+ })
87+ return _c
88+}
89+
90+func (_c *MockProcessInspector_Argv_Call) Return(strings []string, err error) *MockProcessInspector_Argv_Call {
91+ _c.Call.Return(strings, err)
92+ return _c
93+}
94+
95+func (_c *MockProcessInspector_Argv_Call) RunAndReturn(run func(pid int) ([]string, error)) *MockProcessInspector_Argv_Call {
96+ _c.Call.Return(run)
97+ return _c
98+}
99+
100+// Comm provides a mock function for the type MockProcessInspector
101+func (_mock *MockProcessInspector) Comm(pid int) (string, error) {
102+ ret := _mock.Called(pid)
103+
104+ if len(ret) == 0 {
105+ panic("no return value specified for Comm")
106+ }
107+
108+ var r0 string
109+ var r1 error
110+ if returnFunc, ok := ret.Get(0).(func(int) (string, error)); ok {
111+ return returnFunc(pid)
112+ }
113+ if returnFunc, ok := ret.Get(0).(func(int) string); ok {
114+ r0 = returnFunc(pid)
115+ } else {
116+ r0 = ret.Get(0).(string)
117+ }
118+ if returnFunc, ok := ret.Get(1).(func(int) error); ok {
119+ r1 = returnFunc(pid)
120+ } else {
121+ r1 = ret.Error(1)
122+ }
123+ return r0, r1
124+}
125+
126+// MockProcessInspector_Comm_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Comm'
127+type MockProcessInspector_Comm_Call struct {
128+ *mock.Call
129+}
130+
131+// Comm is a helper method to define mock.On call
132+// - pid int
133+func (_e *MockProcessInspector_Expecter) Comm(pid any) *MockProcessInspector_Comm_Call {
134+ return &MockProcessInspector_Comm_Call{Call: _e.mock.On("Comm", pid)}
135+}
136+
137+func (_c *MockProcessInspector_Comm_Call) Run(run func(pid int)) *MockProcessInspector_Comm_Call {
138+ _c.Call.Run(func(args mock.Arguments) {
139+ var arg0 int
140+ if args[0] != nil {
141+ arg0 = args[0].(int)
142+ }
143+ run(
144+ arg0,
145+ )
146+ })
147+ return _c
148+}
149+
150+func (_c *MockProcessInspector_Comm_Call) Return(s string, err error) *MockProcessInspector_Comm_Call {
151+ _c.Call.Return(s, err)
152+ return _c
153+}
154+
155+func (_c *MockProcessInspector_Comm_Call) RunAndReturn(run func(pid int) (string, error)) *MockProcessInspector_Comm_Call {
156+ _c.Call.Return(run)
157+ return _c
158+}
159+
160+// Cwd provides a mock function for the type MockProcessInspector
161+func (_mock *MockProcessInspector) Cwd(pid int) (string, error) {
162+ ret := _mock.Called(pid)
163+
164+ if len(ret) == 0 {
165+ panic("no return value specified for Cwd")
166+ }
167+
168+ var r0 string
169+ var r1 error
170+ if returnFunc, ok := ret.Get(0).(func(int) (string, error)); ok {
171+ return returnFunc(pid)
172+ }
173+ if returnFunc, ok := ret.Get(0).(func(int) string); ok {
174+ r0 = returnFunc(pid)
175+ } else {
176+ r0 = ret.Get(0).(string)
177+ }
178+ if returnFunc, ok := ret.Get(1).(func(int) error); ok {
179+ r1 = returnFunc(pid)
180+ } else {
181+ r1 = ret.Error(1)
182+ }
183+ return r0, r1
184+}
185+
186+// MockProcessInspector_Cwd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Cwd'
187+type MockProcessInspector_Cwd_Call struct {
188+ *mock.Call
189+}
190+
191+// Cwd is a helper method to define mock.On call
192+// - pid int
193+func (_e *MockProcessInspector_Expecter) Cwd(pid any) *MockProcessInspector_Cwd_Call {
194+ return &MockProcessInspector_Cwd_Call{Call: _e.mock.On("Cwd", pid)}
195+}
196+
197+func (_c *MockProcessInspector_Cwd_Call) Run(run func(pid int)) *MockProcessInspector_Cwd_Call {
198+ _c.Call.Run(func(args mock.Arguments) {
199+ var arg0 int
200+ if args[0] != nil {
201+ arg0 = args[0].(int)
202+ }
203+ run(
204+ arg0,
205+ )
206+ })
207+ return _c
208+}
209+
210+func (_c *MockProcessInspector_Cwd_Call) Return(s string, err error) *MockProcessInspector_Cwd_Call {
211+ _c.Call.Return(s, err)
212+ return _c
213+}
214+
215+func (_c *MockProcessInspector_Cwd_Call) RunAndReturn(run func(pid int) (string, error)) *MockProcessInspector_Cwd_Call {
216+ _c.Call.Return(run)
217+ return _c
218+}
219+
220+// GroupArgv provides a mock function for the type MockProcessInspector
221+func (_mock *MockProcessInspector) GroupArgv(pgid int, shellPid int) ([]string, error) {
222+ ret := _mock.Called(pgid, shellPid)
223+
224+ if len(ret) == 0 {
225+ panic("no return value specified for GroupArgv")
226+ }
227+
228+ var r0 []string
229+ var r1 error
230+ if returnFunc, ok := ret.Get(0).(func(int, int) ([]string, error)); ok {
231+ return returnFunc(pgid, shellPid)
232+ }
233+ if returnFunc, ok := ret.Get(0).(func(int, int) []string); ok {
234+ r0 = returnFunc(pgid, shellPid)
235+ } else {
236+ if ret.Get(0) != nil {
237+ r0 = ret.Get(0).([]string)
238+ }
239+ }
240+ if returnFunc, ok := ret.Get(1).(func(int, int) error); ok {
241+ r1 = returnFunc(pgid, shellPid)
242+ } else {
243+ r1 = ret.Error(1)
244+ }
245+ return r0, r1
246+}
247+
248+// MockProcessInspector_GroupArgv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupArgv'
249+type MockProcessInspector_GroupArgv_Call struct {
250+ *mock.Call
251+}
252+
253+// GroupArgv is a helper method to define mock.On call
254+// - pgid int
255+// - shellPid int
256+func (_e *MockProcessInspector_Expecter) GroupArgv(pgid any, shellPid any) *MockProcessInspector_GroupArgv_Call {
257+ return &MockProcessInspector_GroupArgv_Call{Call: _e.mock.On("GroupArgv", pgid, shellPid)}
258+}
259+
260+func (_c *MockProcessInspector_GroupArgv_Call) Run(run func(pgid int, shellPid int)) *MockProcessInspector_GroupArgv_Call {
261+ _c.Call.Run(func(args mock.Arguments) {
262+ var arg0 int
263+ if args[0] != nil {
264+ arg0 = args[0].(int)
265+ }
266+ var arg1 int
267+ if args[1] != nil {
268+ arg1 = args[1].(int)
269+ }
270+ run(
271+ arg0,
272+ arg1,
273+ )
274+ })
275+ return _c
276+}
277+
278+func (_c *MockProcessInspector_GroupArgv_Call) Return(strings []string, err error) *MockProcessInspector_GroupArgv_Call {
279+ _c.Call.Return(strings, err)
280+ return _c
281+}
282+
283+func (_c *MockProcessInspector_GroupArgv_Call) RunAndReturn(run func(pgid int, shellPid int) ([]string, error)) *MockProcessInspector_GroupArgv_Call {
284+ _c.Call.Return(run)
285+ return _c
286+}
A internal/ports/mocks/pty_mock.go +471 -0
@@ -0,0 +1,471 @@
1+// Code generated by mockery; DO NOT EDIT.
2+// github.com/vektra/mockery
3+// template: testify
4+
5+package portsmocks
6+
7+import (
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+// NewMockPTY creates a new instance of MockPTY. 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.
17+func NewMockPTY(t interface {
18+ mock.TestingT
19+ Cleanup(func())
20+}) *MockPTY {
21+ mock := &MockPTY{}
22+ mock.Mock.Test(t)
23+
24+ t.Cleanup(func() { mock.AssertExpectations(t) })
25+
26+ return mock
27+}
28+
29+// MockPTY is an autogenerated mock type for the PTY type
30+type MockPTY struct {
31+ mock.Mock
32+}
33+
34+type MockPTY_Expecter struct {
35+ mock *mock.Mock
36+}
37+
38+func (_m *MockPTY) EXPECT() *MockPTY_Expecter {
39+ return &MockPTY_Expecter{mock: &_m.Mock}
40+}
41+
42+// Close provides a mock function for the type MockPTY
43+func (_mock *MockPTY) Close() error {
44+ ret := _mock.Called()
45+
46+ if len(ret) == 0 {
47+ panic("no return value specified for Close")
48+ }
49+
50+ var r0 error
51+ if returnFunc, ok := ret.Get(0).(func() error); ok {
52+ r0 = returnFunc()
53+ } else {
54+ r0 = ret.Error(0)
55+ }
56+ return r0
57+}
58+
59+// MockPTY_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
60+type MockPTY_Close_Call struct {
61+ *mock.Call
62+}
63+
64+// Close is a helper method to define mock.On call
65+func (_e *MockPTY_Expecter) Close() *MockPTY_Close_Call {
66+ return &MockPTY_Close_Call{Call: _e.mock.On("Close")}
67+}
68+
69+func (_c *MockPTY_Close_Call) Run(run func()) *MockPTY_Close_Call {
70+ _c.Call.Run(func(args mock.Arguments) {
71+ run()
72+ })
73+ return _c
74+}
75+
76+func (_c *MockPTY_Close_Call) Return(err error) *MockPTY_Close_Call {
77+ _c.Call.Return(err)
78+ return _c
79+}
80+
81+func (_c *MockPTY_Close_Call) RunAndReturn(run func() error) *MockPTY_Close_Call {
82+ _c.Call.Return(run)
83+ return _c
84+}
85+
86+// ForegroundPgid provides a mock function for the type MockPTY
87+func (_mock *MockPTY) ForegroundPgid() (int, error) {
88+ ret := _mock.Called()
89+
90+ if len(ret) == 0 {
91+ panic("no return value specified for ForegroundPgid")
92+ }
93+
94+ var r0 int
95+ var r1 error
96+ if returnFunc, ok := ret.Get(0).(func() (int, error)); ok {
97+ return returnFunc()
98+ }
99+ if returnFunc, ok := ret.Get(0).(func() int); ok {
100+ r0 = returnFunc()
101+ } else {
102+ r0 = ret.Get(0).(int)
103+ }
104+ if returnFunc, ok := ret.Get(1).(func() error); ok {
105+ r1 = returnFunc()
106+ } else {
107+ r1 = ret.Error(1)
108+ }
109+ return r0, r1
110+}
111+
112+// MockPTY_ForegroundPgid_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ForegroundPgid'
113+type MockPTY_ForegroundPgid_Call struct {
114+ *mock.Call
115+}
116+
117+// ForegroundPgid is a helper method to define mock.On call
118+func (_e *MockPTY_Expecter) ForegroundPgid() *MockPTY_ForegroundPgid_Call {
119+ return &MockPTY_ForegroundPgid_Call{Call: _e.mock.On("ForegroundPgid")}
120+}
121+
122+func (_c *MockPTY_ForegroundPgid_Call) Run(run func()) *MockPTY_ForegroundPgid_Call {
123+ _c.Call.Run(func(args mock.Arguments) {
124+ run()
125+ })
126+ return _c
127+}
128+
129+func (_c *MockPTY_ForegroundPgid_Call) Return(n int, err error) *MockPTY_ForegroundPgid_Call {
130+ _c.Call.Return(n, err)
131+ return _c
132+}
133+
134+func (_c *MockPTY_ForegroundPgid_Call) RunAndReturn(run func() (int, error)) *MockPTY_ForegroundPgid_Call {
135+ _c.Call.Return(run)
136+ return _c
137+}
138+
139+// Pid provides a mock function for the type MockPTY
140+func (_mock *MockPTY) Pid() int {
141+ ret := _mock.Called()
142+
143+ if len(ret) == 0 {
144+ panic("no return value specified for Pid")
145+ }
146+
147+ var r0 int
148+ if returnFunc, ok := ret.Get(0).(func() int); ok {
149+ r0 = returnFunc()
150+ } else {
151+ r0 = ret.Get(0).(int)
152+ }
153+ return r0
154+}
155+
156+// MockPTY_Pid_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Pid'
157+type MockPTY_Pid_Call struct {
158+ *mock.Call
159+}
160+
161+// Pid is a helper method to define mock.On call
162+func (_e *MockPTY_Expecter) Pid() *MockPTY_Pid_Call {
163+ return &MockPTY_Pid_Call{Call: _e.mock.On("Pid")}
164+}
165+
166+func (_c *MockPTY_Pid_Call) Run(run func()) *MockPTY_Pid_Call {
167+ _c.Call.Run(func(args mock.Arguments) {
168+ run()
169+ })
170+ return _c
171+}
172+
173+func (_c *MockPTY_Pid_Call) Return(n int) *MockPTY_Pid_Call {
174+ _c.Call.Return(n)
175+ return _c
176+}
177+
178+func (_c *MockPTY_Pid_Call) RunAndReturn(run func() int) *MockPTY_Pid_Call {
179+ _c.Call.Return(run)
180+ return _c
181+}
182+
183+// Read provides a mock function for the type MockPTY
184+func (_mock *MockPTY) Read(p []byte) (int, error) {
185+ ret := _mock.Called(p)
186+
187+ if len(ret) == 0 {
188+ panic("no return value specified for Read")
189+ }
190+
191+ var r0 int
192+ var r1 error
193+ if returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok {
194+ return returnFunc(p)
195+ }
196+ if returnFunc, ok := ret.Get(0).(func([]byte) int); ok {
197+ r0 = returnFunc(p)
198+ } else {
199+ r0 = ret.Get(0).(int)
200+ }
201+ if returnFunc, ok := ret.Get(1).(func([]byte) error); ok {
202+ r1 = returnFunc(p)
203+ } else {
204+ r1 = ret.Error(1)
205+ }
206+ return r0, r1
207+}
208+
209+// MockPTY_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read'
210+type MockPTY_Read_Call struct {
211+ *mock.Call
212+}
213+
214+// Read is a helper method to define mock.On call
215+// - p []byte
216+func (_e *MockPTY_Expecter) Read(p any) *MockPTY_Read_Call {
217+ return &MockPTY_Read_Call{Call: _e.mock.On("Read", p)}
218+}
219+
220+func (_c *MockPTY_Read_Call) Run(run func(p []byte)) *MockPTY_Read_Call {
221+ _c.Call.Run(func(args mock.Arguments) {
222+ var arg0 []byte
223+ if args[0] != nil {
224+ arg0 = args[0].([]byte)
225+ }
226+ run(
227+ arg0,
228+ )
229+ })
230+ return _c
231+}
232+
233+func (_c *MockPTY_Read_Call) Return(n int, err error) *MockPTY_Read_Call {
234+ _c.Call.Return(n, err)
235+ return _c
236+}
237+
238+func (_c *MockPTY_Read_Call) RunAndReturn(run func(p []byte) (int, error)) *MockPTY_Read_Call {
239+ _c.Call.Return(run)
240+ return _c
241+}
242+
243+// Resize provides a mock function for the type MockPTY
244+func (_mock *MockPTY) Resize(sz domain.Size) error {
245+ ret := _mock.Called(sz)
246+
247+ if len(ret) == 0 {
248+ panic("no return value specified for Resize")
249+ }
250+
251+ var r0 error
252+ if returnFunc, ok := ret.Get(0).(func(domain.Size) error); ok {
253+ r0 = returnFunc(sz)
254+ } else {
255+ r0 = ret.Error(0)
256+ }
257+ return r0
258+}
259+
260+// MockPTY_Resize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Resize'
261+type MockPTY_Resize_Call struct {
262+ *mock.Call
263+}
264+
265+// Resize is a helper method to define mock.On call
266+// - sz domain.Size
267+func (_e *MockPTY_Expecter) Resize(sz any) *MockPTY_Resize_Call {
268+ return &MockPTY_Resize_Call{Call: _e.mock.On("Resize", sz)}
269+}
270+
271+func (_c *MockPTY_Resize_Call) Run(run func(sz domain.Size)) *MockPTY_Resize_Call {
272+ _c.Call.Run(func(args mock.Arguments) {
273+ var arg0 domain.Size
274+ if args[0] != nil {
275+ arg0 = args[0].(domain.Size)
276+ }
277+ run(
278+ arg0,
279+ )
280+ })
281+ return _c
282+}
283+
284+func (_c *MockPTY_Resize_Call) Return(err error) *MockPTY_Resize_Call {
285+ _c.Call.Return(err)
286+ return _c
287+}
288+
289+func (_c *MockPTY_Resize_Call) RunAndReturn(run func(sz domain.Size) error) *MockPTY_Resize_Call {
290+ _c.Call.Return(run)
291+ return _c
292+}
293+
294+// Write provides a mock function for the type MockPTY
295+func (_mock *MockPTY) Write(p []byte) (int, error) {
296+ ret := _mock.Called(p)
297+
298+ if len(ret) == 0 {
299+ panic("no return value specified for Write")
300+ }
301+
302+ var r0 int
303+ var r1 error
304+ if returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok {
305+ return returnFunc(p)
306+ }
307+ if returnFunc, ok := ret.Get(0).(func([]byte) int); ok {
308+ r0 = returnFunc(p)
309+ } else {
310+ r0 = ret.Get(0).(int)
311+ }
312+ if returnFunc, ok := ret.Get(1).(func([]byte) error); ok {
313+ r1 = returnFunc(p)
314+ } else {
315+ r1 = ret.Error(1)
316+ }
317+ return r0, r1
318+}
319+
320+// MockPTY_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write'
321+type MockPTY_Write_Call struct {
322+ *mock.Call
323+}
324+
325+// Write is a helper method to define mock.On call
326+// - p []byte
327+func (_e *MockPTY_Expecter) Write(p any) *MockPTY_Write_Call {
328+ return &MockPTY_Write_Call{Call: _e.mock.On("Write", p)}
329+}
330+
331+func (_c *MockPTY_Write_Call) Run(run func(p []byte)) *MockPTY_Write_Call {
332+ _c.Call.Run(func(args mock.Arguments) {
333+ var arg0 []byte
334+ if args[0] != nil {
335+ arg0 = args[0].([]byte)
336+ }
337+ run(
338+ arg0,
339+ )
340+ })
341+ return _c
342+}
343+
344+func (_c *MockPTY_Write_Call) Return(n int, err error) *MockPTY_Write_Call {
345+ _c.Call.Return(n, err)
346+ return _c
347+}
348+
349+func (_c *MockPTY_Write_Call) RunAndReturn(run func(p []byte) (int, error)) *MockPTY_Write_Call {
350+ _c.Call.Return(run)
351+ return _c
352+}
353+
354+// NewMockPTYFactory creates a new instance of MockPTYFactory. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
355+// The first argument is typically a *testing.T value.
356+func NewMockPTYFactory(t interface {
357+ mock.TestingT
358+ Cleanup(func())
359+}) *MockPTYFactory {
360+ mock := &MockPTYFactory{}
361+ mock.Mock.Test(t)
362+
363+ t.Cleanup(func() { mock.AssertExpectations(t) })
364+
365+ return mock
366+}
367+
368+// MockPTYFactory is an autogenerated mock type for the PTYFactory type
369+type MockPTYFactory struct {
370+ mock.Mock
371+}
372+
373+type MockPTYFactory_Expecter struct {
374+ mock *mock.Mock
375+}
376+
377+func (_m *MockPTYFactory) EXPECT() *MockPTYFactory_Expecter {
378+ return &MockPTYFactory_Expecter{mock: &_m.Mock}
379+}
380+
381+// Open provides a mock function for the type MockPTYFactory
382+func (_mock *MockPTYFactory) Open(ctx context.Context, cmd string, args []string, env []string, dir string, sz domain.Size) (ports.PTY, error) {
383+ ret := _mock.Called(ctx, cmd, args, env, dir, sz)
384+
385+ if len(ret) == 0 {
386+ panic("no return value specified for Open")
387+ }
388+
389+ var r0 ports.PTY
390+ var r1 error
391+ if returnFunc, ok := ret.Get(0).(func(context.Context, string, []string, []string, string, domain.Size) (ports.PTY, error)); ok {
392+ return returnFunc(ctx, cmd, args, env, dir, sz)
393+ }
394+ if returnFunc, ok := ret.Get(0).(func(context.Context, string, []string, []string, string, domain.Size) ports.PTY); ok {
395+ r0 = returnFunc(ctx, cmd, args, env, dir, sz)
396+ } else {
397+ if ret.Get(0) != nil {
398+ r0 = ret.Get(0).(ports.PTY)
399+ }
400+ }
401+ if returnFunc, ok := ret.Get(1).(func(context.Context, string, []string, []string, string, domain.Size) error); ok {
402+ r1 = returnFunc(ctx, cmd, args, env, dir, sz)
403+ } else {
404+ r1 = ret.Error(1)
405+ }
406+ return r0, r1
407+}
408+
409+// MockPTYFactory_Open_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Open'
410+type MockPTYFactory_Open_Call struct {
411+ *mock.Call
412+}
413+
414+// Open is a helper method to define mock.On call
415+// - ctx context.Context
416+// - cmd string
417+// - args []string
418+// - env []string
419+// - dir string
420+// - sz domain.Size
421+func (_e *MockPTYFactory_Expecter) Open(ctx any, cmd any, args any, env any, dir any, sz any) *MockPTYFactory_Open_Call {
422+ return &MockPTYFactory_Open_Call{Call: _e.mock.On("Open", ctx, cmd, args, env, dir, sz)}
423+}
424+
425+func (_c *MockPTYFactory_Open_Call) Run(run func(ctx context.Context, cmd string, args []string, env []string, dir string, sz domain.Size)) *MockPTYFactory_Open_Call {
426+ _c.Call.Run(func(args mock.Arguments) {
427+ var arg0 context.Context
428+ if args[0] != nil {
429+ arg0 = args[0].(context.Context)
430+ }
431+ var arg1 string
432+ if args[1] != nil {
433+ arg1 = args[1].(string)
434+ }
435+ var arg2 []string
436+ if args[2] != nil {
437+ arg2 = args[2].([]string)
438+ }
439+ var arg3 []string
440+ if args[3] != nil {
441+ arg3 = args[3].([]string)
442+ }
443+ var arg4 string
444+ if args[4] != nil {
445+ arg4 = args[4].(string)
446+ }
447+ var arg5 domain.Size
448+ if args[5] != nil {
449+ arg5 = args[5].(domain.Size)
450+ }
451+ run(
452+ arg0,
453+ arg1,
454+ arg2,
455+ arg3,
456+ arg4,
457+ arg5,
458+ )
459+ })
460+ return _c
461+}
462+
463+func (_c *MockPTYFactory_Open_Call) Return(pTY ports.PTY, err error) *MockPTYFactory_Open_Call {
464+ _c.Call.Return(pTY, err)
465+ return _c
466+}
467+
468+func (_c *MockPTYFactory_Open_Call) RunAndReturn(run func(ctx context.Context, cmd string, args []string, env []string, dir string, sz domain.Size) (ports.PTY, error)) *MockPTYFactory_Open_Call {
469+ _c.Call.Return(run)
470+ return _c
471+}
@@ -0,0 +1,471 @@
1+// Code generated by mockery; DO NOT EDIT.
2+// github.com/vektra/mockery
3+// template: testify
4+
5+package portsmocks
6+
7+import (
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+// NewMockPTY creates a new instance of MockPTY. 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.
17+func NewMockPTY(t interface {
18+ mock.TestingT
19+ Cleanup(func())
20+}) *MockPTY {
21+ mock := &MockPTY{}
22+ mock.Mock.Test(t)
23+
24+ t.Cleanup(func() { mock.AssertExpectations(t) })
25+
26+ return mock
27+}
28+
29+// MockPTY is an autogenerated mock type for the PTY type
30+type MockPTY struct {
31+ mock.Mock
32+}
33+
34+type MockPTY_Expecter struct {
35+ mock *mock.Mock
36+}
37+
38+func (_m *MockPTY) EXPECT() *MockPTY_Expecter {
39+ return &MockPTY_Expecter{mock: &_m.Mock}
40+}
41+
42+// Close provides a mock function for the type MockPTY
43+func (_mock *MockPTY) Close() error {
44+ ret := _mock.Called()
45+
46+ if len(ret) == 0 {
47+ panic("no return value specified for Close")
48+ }
49+
50+ var r0 error
51+ if returnFunc, ok := ret.Get(0).(func() error); ok {
52+ r0 = returnFunc()
53+ } else {
54+ r0 = ret.Error(0)
55+ }
56+ return r0
57+}
58+
59+// MockPTY_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
60+type MockPTY_Close_Call struct {
61+ *mock.Call
62+}
63+
64+// Close is a helper method to define mock.On call
65+func (_e *MockPTY_Expecter) Close() *MockPTY_Close_Call {
66+ return &MockPTY_Close_Call{Call: _e.mock.On("Close")}
67+}
68+
69+func (_c *MockPTY_Close_Call) Run(run func()) *MockPTY_Close_Call {
70+ _c.Call.Run(func(args mock.Arguments) {
71+ run()
72+ })
73+ return _c
74+}
75+
76+func (_c *MockPTY_Close_Call) Return(err error) *MockPTY_Close_Call {
77+ _c.Call.Return(err)
78+ return _c
79+}
80+
81+func (_c *MockPTY_Close_Call) RunAndReturn(run func() error) *MockPTY_Close_Call {
82+ _c.Call.Return(run)
83+ return _c
84+}
85+
86+// ForegroundPgid provides a mock function for the type MockPTY
87+func (_mock *MockPTY) ForegroundPgid() (int, error) {
88+ ret := _mock.Called()
89+
90+ if len(ret) == 0 {
91+ panic("no return value specified for ForegroundPgid")
92+ }
93+
94+ var r0 int
95+ var r1 error
96+ if returnFunc, ok := ret.Get(0).(func() (int, error)); ok {
97+ return returnFunc()
98+ }
99+ if returnFunc, ok := ret.Get(0).(func() int); ok {
100+ r0 = returnFunc()
101+ } else {
102+ r0 = ret.Get(0).(int)
103+ }
104+ if returnFunc, ok := ret.Get(1).(func() error); ok {
105+ r1 = returnFunc()
106+ } else {
107+ r1 = ret.Error(1)
108+ }
109+ return r0, r1
110+}
111+
112+// MockPTY_ForegroundPgid_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ForegroundPgid'
113+type MockPTY_ForegroundPgid_Call struct {
114+ *mock.Call
115+}
116+
117+// ForegroundPgid is a helper method to define mock.On call
118+func (_e *MockPTY_Expecter) ForegroundPgid() *MockPTY_ForegroundPgid_Call {
119+ return &MockPTY_ForegroundPgid_Call{Call: _e.mock.On("ForegroundPgid")}
120+}
121+
122+func (_c *MockPTY_ForegroundPgid_Call) Run(run func()) *MockPTY_ForegroundPgid_Call {
123+ _c.Call.Run(func(args mock.Arguments) {
124+ run()
125+ })
126+ return _c
127+}
128+
129+func (_c *MockPTY_ForegroundPgid_Call) Return(n int, err error) *MockPTY_ForegroundPgid_Call {
130+ _c.Call.Return(n, err)
131+ return _c
132+}
133+
134+func (_c *MockPTY_ForegroundPgid_Call) RunAndReturn(run func() (int, error)) *MockPTY_ForegroundPgid_Call {
135+ _c.Call.Return(run)
136+ return _c
137+}
138+
139+// Pid provides a mock function for the type MockPTY
140+func (_mock *MockPTY) Pid() int {
141+ ret := _mock.Called()
142+
143+ if len(ret) == 0 {
144+ panic("no return value specified for Pid")
145+ }
146+
147+ var r0 int
148+ if returnFunc, ok := ret.Get(0).(func() int); ok {
149+ r0 = returnFunc()
150+ } else {
151+ r0 = ret.Get(0).(int)
152+ }
153+ return r0
154+}
155+
156+// MockPTY_Pid_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Pid'
157+type MockPTY_Pid_Call struct {
158+ *mock.Call
159+}
160+
161+// Pid is a helper method to define mock.On call
162+func (_e *MockPTY_Expecter) Pid() *MockPTY_Pid_Call {
163+ return &MockPTY_Pid_Call{Call: _e.mock.On("Pid")}
164+}
165+
166+func (_c *MockPTY_Pid_Call) Run(run func()) *MockPTY_Pid_Call {
167+ _c.Call.Run(func(args mock.Arguments) {
168+ run()
169+ })
170+ return _c
171+}
172+
173+func (_c *MockPTY_Pid_Call) Return(n int) *MockPTY_Pid_Call {
174+ _c.Call.Return(n)
175+ return _c
176+}
177+
178+func (_c *MockPTY_Pid_Call) RunAndReturn(run func() int) *MockPTY_Pid_Call {
179+ _c.Call.Return(run)
180+ return _c
181+}
182+
183+// Read provides a mock function for the type MockPTY
184+func (_mock *MockPTY) Read(p []byte) (int, error) {
185+ ret := _mock.Called(p)
186+
187+ if len(ret) == 0 {
188+ panic("no return value specified for Read")
189+ }
190+
191+ var r0 int
192+ var r1 error
193+ if returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok {
194+ return returnFunc(p)
195+ }
196+ if returnFunc, ok := ret.Get(0).(func([]byte) int); ok {
197+ r0 = returnFunc(p)
198+ } else {
199+ r0 = ret.Get(0).(int)
200+ }
201+ if returnFunc, ok := ret.Get(1).(func([]byte) error); ok {
202+ r1 = returnFunc(p)
203+ } else {
204+ r1 = ret.Error(1)
205+ }
206+ return r0, r1
207+}
208+
209+// MockPTY_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read'
210+type MockPTY_Read_Call struct {
211+ *mock.Call
212+}
213+
214+// Read is a helper method to define mock.On call
215+// - p []byte
216+func (_e *MockPTY_Expecter) Read(p any) *MockPTY_Read_Call {
217+ return &MockPTY_Read_Call{Call: _e.mock.On("Read", p)}
218+}
219+
220+func (_c *MockPTY_Read_Call) Run(run func(p []byte)) *MockPTY_Read_Call {
221+ _c.Call.Run(func(args mock.Arguments) {
222+ var arg0 []byte
223+ if args[0] != nil {
224+ arg0 = args[0].([]byte)
225+ }
226+ run(
227+ arg0,
228+ )
229+ })
230+ return _c
231+}
232+
233+func (_c *MockPTY_Read_Call) Return(n int, err error) *MockPTY_Read_Call {
234+ _c.Call.Return(n, err)
235+ return _c
236+}
237+
238+func (_c *MockPTY_Read_Call) RunAndReturn(run func(p []byte) (int, error)) *MockPTY_Read_Call {
239+ _c.Call.Return(run)
240+ return _c
241+}
242+
243+// Resize provides a mock function for the type MockPTY
244+func (_mock *MockPTY) Resize(sz domain.Size) error {
245+ ret := _mock.Called(sz)
246+
247+ if len(ret) == 0 {
248+ panic("no return value specified for Resize")
249+ }
250+
251+ var r0 error
252+ if returnFunc, ok := ret.Get(0).(func(domain.Size) error); ok {
253+ r0 = returnFunc(sz)
254+ } else {
255+ r0 = ret.Error(0)
256+ }
257+ return r0
258+}
259+
260+// MockPTY_Resize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Resize'
261+type MockPTY_Resize_Call struct {
262+ *mock.Call
263+}
264+
265+// Resize is a helper method to define mock.On call
266+// - sz domain.Size
267+func (_e *MockPTY_Expecter) Resize(sz any) *MockPTY_Resize_Call {
268+ return &MockPTY_Resize_Call{Call: _e.mock.On("Resize", sz)}
269+}
270+
271+func (_c *MockPTY_Resize_Call) Run(run func(sz domain.Size)) *MockPTY_Resize_Call {
272+ _c.Call.Run(func(args mock.Arguments) {
273+ var arg0 domain.Size
274+ if args[0] != nil {
275+ arg0 = args[0].(domain.Size)
276+ }
277+ run(
278+ arg0,
279+ )
280+ })
281+ return _c
282+}
283+
284+func (_c *MockPTY_Resize_Call) Return(err error) *MockPTY_Resize_Call {
285+ _c.Call.Return(err)
286+ return _c
287+}
288+
289+func (_c *MockPTY_Resize_Call) RunAndReturn(run func(sz domain.Size) error) *MockPTY_Resize_Call {
290+ _c.Call.Return(run)
291+ return _c
292+}
293+
294+// Write provides a mock function for the type MockPTY
295+func (_mock *MockPTY) Write(p []byte) (int, error) {
296+ ret := _mock.Called(p)
297+
298+ if len(ret) == 0 {
299+ panic("no return value specified for Write")
300+ }
301+
302+ var r0 int
303+ var r1 error
304+ if returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok {
305+ return returnFunc(p)
306+ }
307+ if returnFunc, ok := ret.Get(0).(func([]byte) int); ok {
308+ r0 = returnFunc(p)
309+ } else {
310+ r0 = ret.Get(0).(int)
311+ }
312+ if returnFunc, ok := ret.Get(1).(func([]byte) error); ok {
313+ r1 = returnFunc(p)
314+ } else {
315+ r1 = ret.Error(1)
316+ }
317+ return r0, r1
318+}
319+
320+// MockPTY_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write'
321+type MockPTY_Write_Call struct {
322+ *mock.Call
323+}
324+
325+// Write is a helper method to define mock.On call
326+// - p []byte
327+func (_e *MockPTY_Expecter) Write(p any) *MockPTY_Write_Call {
328+ return &MockPTY_Write_Call{Call: _e.mock.On("Write", p)}
329+}
330+
331+func (_c *MockPTY_Write_Call) Run(run func(p []byte)) *MockPTY_Write_Call {
332+ _c.Call.Run(func(args mock.Arguments) {
333+ var arg0 []byte
334+ if args[0] != nil {
335+ arg0 = args[0].([]byte)
336+ }
337+ run(
338+ arg0,
339+ )
340+ })
341+ return _c
342+}
343+
344+func (_c *MockPTY_Write_Call) Return(n int, err error) *MockPTY_Write_Call {
345+ _c.Call.Return(n, err)
346+ return _c
347+}
348+
349+func (_c *MockPTY_Write_Call) RunAndReturn(run func(p []byte) (int, error)) *MockPTY_Write_Call {
350+ _c.Call.Return(run)
351+ return _c
352+}
353+
354+// NewMockPTYFactory creates a new instance of MockPTYFactory. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
355+// The first argument is typically a *testing.T value.
356+func NewMockPTYFactory(t interface {
357+ mock.TestingT
358+ Cleanup(func())
359+}) *MockPTYFactory {
360+ mock := &MockPTYFactory{}
361+ mock.Mock.Test(t)
362+
363+ t.Cleanup(func() { mock.AssertExpectations(t) })
364+
365+ return mock
366+}
367+
368+// MockPTYFactory is an autogenerated mock type for the PTYFactory type
369+type MockPTYFactory struct {
370+ mock.Mock
371+}
372+
373+type MockPTYFactory_Expecter struct {
374+ mock *mock.Mock
375+}
376+
377+func (_m *MockPTYFactory) EXPECT() *MockPTYFactory_Expecter {
378+ return &MockPTYFactory_Expecter{mock: &_m.Mock}
379+}
380+
381+// Open provides a mock function for the type MockPTYFactory
382+func (_mock *MockPTYFactory) Open(ctx context.Context, cmd string, args []string, env []string, dir string, sz domain.Size) (ports.PTY, error) {
383+ ret := _mock.Called(ctx, cmd, args, env, dir, sz)
384+
385+ if len(ret) == 0 {
386+ panic("no return value specified for Open")
387+ }
388+
389+ var r0 ports.PTY
390+ var r1 error
391+ if returnFunc, ok := ret.Get(0).(func(context.Context, string, []string, []string, string, domain.Size) (ports.PTY, error)); ok {
392+ return returnFunc(ctx, cmd, args, env, dir, sz)
393+ }
394+ if returnFunc, ok := ret.Get(0).(func(context.Context, string, []string, []string, string, domain.Size) ports.PTY); ok {
395+ r0 = returnFunc(ctx, cmd, args, env, dir, sz)
396+ } else {
397+ if ret.Get(0) != nil {
398+ r0 = ret.Get(0).(ports.PTY)
399+ }
400+ }
401+ if returnFunc, ok := ret.Get(1).(func(context.Context, string, []string, []string, string, domain.Size) error); ok {
402+ r1 = returnFunc(ctx, cmd, args, env, dir, sz)
403+ } else {
404+ r1 = ret.Error(1)
405+ }
406+ return r0, r1
407+}
408+
409+// MockPTYFactory_Open_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Open'
410+type MockPTYFactory_Open_Call struct {
411+ *mock.Call
412+}
413+
414+// Open is a helper method to define mock.On call
415+// - ctx context.Context
416+// - cmd string
417+// - args []string
418+// - env []string
419+// - dir string
420+// - sz domain.Size
421+func (_e *MockPTYFactory_Expecter) Open(ctx any, cmd any, args any, env any, dir any, sz any) *MockPTYFactory_Open_Call {
422+ return &MockPTYFactory_Open_Call{Call: _e.mock.On("Open", ctx, cmd, args, env, dir, sz)}
423+}
424+
425+func (_c *MockPTYFactory_Open_Call) Run(run func(ctx context.Context, cmd string, args []string, env []string, dir string, sz domain.Size)) *MockPTYFactory_Open_Call {
426+ _c.Call.Run(func(args mock.Arguments) {
427+ var arg0 context.Context
428+ if args[0] != nil {
429+ arg0 = args[0].(context.Context)
430+ }
431+ var arg1 string
432+ if args[1] != nil {
433+ arg1 = args[1].(string)
434+ }
435+ var arg2 []string
436+ if args[2] != nil {
437+ arg2 = args[2].([]string)
438+ }
439+ var arg3 []string
440+ if args[3] != nil {
441+ arg3 = args[3].([]string)
442+ }
443+ var arg4 string
444+ if args[4] != nil {
445+ arg4 = args[4].(string)
446+ }
447+ var arg5 domain.Size
448+ if args[5] != nil {
449+ arg5 = args[5].(domain.Size)
450+ }
451+ run(
452+ arg0,
453+ arg1,
454+ arg2,
455+ arg3,
456+ arg4,
457+ arg5,
458+ )
459+ })
460+ return _c
461+}
462+
463+func (_c *MockPTYFactory_Open_Call) Return(pTY ports.PTY, err error) *MockPTYFactory_Open_Call {
464+ _c.Call.Return(pTY, err)
465+ return _c
466+}
467+
468+func (_c *MockPTYFactory_Open_Call) RunAndReturn(run func(ctx context.Context, cmd string, args []string, env []string, dir string, sz domain.Size) (ports.PTY, error)) *MockPTYFactory_Open_Call {
469+ _c.Call.Return(run)
470+ return _c
471+}
A internal/ports/mocks/remote_mock.go +119 -0
@@ -0,0 +1,119 @@
1+// Code generated by mockery; DO NOT EDIT.
2+// github.com/vektra/mockery
3+// template: testify
4+
5+package portsmocks
6+
7+import (
8+ "log/slog"
9+
10+ "github.com/bnema/vev/internal/ports"
11+ mock "github.com/stretchr/testify/mock"
12+)
13+
14+// NewMockRemoteDialerFactory creates a new instance of MockRemoteDialerFactory. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
15+// The first argument is typically a *testing.T value.
16+func NewMockRemoteDialerFactory(t interface {
17+ mock.TestingT
18+ Cleanup(func())
19+}) *MockRemoteDialerFactory {
20+ mock := &MockRemoteDialerFactory{}
21+ mock.Mock.Test(t)
22+
23+ t.Cleanup(func() { mock.AssertExpectations(t) })
24+
25+ return mock
26+}
27+
28+// MockRemoteDialerFactory is an autogenerated mock type for the RemoteDialerFactory type
29+type MockRemoteDialerFactory struct {
30+ mock.Mock
31+}
32+
33+type MockRemoteDialerFactory_Expecter struct {
34+ mock *mock.Mock
35+}
36+
37+func (_m *MockRemoteDialerFactory) EXPECT() *MockRemoteDialerFactory_Expecter {
38+ return &MockRemoteDialerFactory_Expecter{mock: &_m.Mock}
39+}
40+
41+// DialerForRemote provides a mock function for the type MockRemoteDialerFactory
42+func (_mock *MockRemoteDialerFactory) DialerForRemote(target string, session string, mode ports.RemoteTransportMode, log *slog.Logger) (ports.Dialer, error) {
43+ ret := _mock.Called(target, session, mode, log)
44+
45+ if len(ret) == 0 {
46+ panic("no return value specified for DialerForRemote")
47+ }
48+
49+ var r0 ports.Dialer
50+ var r1 error
51+ if returnFunc, ok := ret.Get(0).(func(string, string, ports.RemoteTransportMode, *slog.Logger) (ports.Dialer, error)); ok {
52+ return returnFunc(target, session, mode, log)
53+ }
54+ if returnFunc, ok := ret.Get(0).(func(string, string, ports.RemoteTransportMode, *slog.Logger) ports.Dialer); ok {
55+ r0 = returnFunc(target, session, mode, log)
56+ } else {
57+ if ret.Get(0) != nil {
58+ r0 = ret.Get(0).(ports.Dialer)
59+ }
60+ }
61+ if returnFunc, ok := ret.Get(1).(func(string, string, ports.RemoteTransportMode, *slog.Logger) error); ok {
62+ r1 = returnFunc(target, session, mode, log)
63+ } else {
64+ r1 = ret.Error(1)
65+ }
66+ return r0, r1
67+}
68+
69+// MockRemoteDialerFactory_DialerForRemote_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DialerForRemote'
70+type MockRemoteDialerFactory_DialerForRemote_Call struct {
71+ *mock.Call
72+}
73+
74+// DialerForRemote is a helper method to define mock.On call
75+// - target string
76+// - session string
77+// - mode ports.RemoteTransportMode
78+// - log *slog.Logger
79+func (_e *MockRemoteDialerFactory_Expecter) DialerForRemote(target any, session any, mode any, log any) *MockRemoteDialerFactory_DialerForRemote_Call {
80+ return &MockRemoteDialerFactory_DialerForRemote_Call{Call: _e.mock.On("DialerForRemote", target, session, mode, log)}
81+}
82+
83+func (_c *MockRemoteDialerFactory_DialerForRemote_Call) Run(run func(target string, session string, mode ports.RemoteTransportMode, log *slog.Logger)) *MockRemoteDialerFactory_DialerForRemote_Call {
84+ _c.Call.Run(func(args mock.Arguments) {
85+ var arg0 string
86+ if args[0] != nil {
87+ arg0 = args[0].(string)
88+ }
89+ var arg1 string
90+ if args[1] != nil {
91+ arg1 = args[1].(string)
92+ }
93+ var arg2 ports.RemoteTransportMode
94+ if args[2] != nil {
95+ arg2 = args[2].(ports.RemoteTransportMode)
96+ }
97+ var arg3 *slog.Logger
98+ if args[3] != nil {
99+ arg3 = args[3].(*slog.Logger)
100+ }
101+ run(
102+ arg0,
103+ arg1,
104+ arg2,
105+ arg3,
106+ )
107+ })
108+ return _c
109+}
110+
111+func (_c *MockRemoteDialerFactory_DialerForRemote_Call) Return(dialer ports.Dialer, err error) *MockRemoteDialerFactory_DialerForRemote_Call {
112+ _c.Call.Return(dialer, err)
113+ return _c
114+}
115+
116+func (_c *MockRemoteDialerFactory_DialerForRemote_Call) RunAndReturn(run func(target string, session string, mode ports.RemoteTransportMode, log *slog.Logger) (ports.Dialer, error)) *MockRemoteDialerFactory_DialerForRemote_Call {
117+ _c.Call.Return(run)
118+ return _c
119+}
@@ -0,0 +1,119 @@
1+// Code generated by mockery; DO NOT EDIT.
2+// github.com/vektra/mockery
3+// template: testify
4+
5+package portsmocks
6+
7+import (
8+ "log/slog"
9+
10+ "github.com/bnema/vev/internal/ports"
11+ mock "github.com/stretchr/testify/mock"
12+)
13+
14+// NewMockRemoteDialerFactory creates a new instance of MockRemoteDialerFactory. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
15+// The first argument is typically a *testing.T value.
16+func NewMockRemoteDialerFactory(t interface {
17+ mock.TestingT
18+ Cleanup(func())
19+}) *MockRemoteDialerFactory {
20+ mock := &MockRemoteDialerFactory{}
21+ mock.Mock.Test(t)
22+
23+ t.Cleanup(func() { mock.AssertExpectations(t) })
24+
25+ return mock
26+}
27+
28+// MockRemoteDialerFactory is an autogenerated mock type for the RemoteDialerFactory type
29+type MockRemoteDialerFactory struct {
30+ mock.Mock
31+}
32+
33+type MockRemoteDialerFactory_Expecter struct {
34+ mock *mock.Mock
35+}
36+
37+func (_m *MockRemoteDialerFactory) EXPECT() *MockRemoteDialerFactory_Expecter {
38+ return &MockRemoteDialerFactory_Expecter{mock: &_m.Mock}
39+}
40+
41+// DialerForRemote provides a mock function for the type MockRemoteDialerFactory
42+func (_mock *MockRemoteDialerFactory) DialerForRemote(target string, session string, mode ports.RemoteTransportMode, log *slog.Logger) (ports.Dialer, error) {
43+ ret := _mock.Called(target, session, mode, log)
44+
45+ if len(ret) == 0 {
46+ panic("no return value specified for DialerForRemote")
47+ }
48+
49+ var r0 ports.Dialer
50+ var r1 error
51+ if returnFunc, ok := ret.Get(0).(func(string, string, ports.RemoteTransportMode, *slog.Logger) (ports.Dialer, error)); ok {
52+ return returnFunc(target, session, mode, log)
53+ }
54+ if returnFunc, ok := ret.Get(0).(func(string, string, ports.RemoteTransportMode, *slog.Logger) ports.Dialer); ok {
55+ r0 = returnFunc(target, session, mode, log)
56+ } else {
57+ if ret.Get(0) != nil {
58+ r0 = ret.Get(0).(ports.Dialer)
59+ }
60+ }
61+ if returnFunc, ok := ret.Get(1).(func(string, string, ports.RemoteTransportMode, *slog.Logger) error); ok {
62+ r1 = returnFunc(target, session, mode, log)
63+ } else {
64+ r1 = ret.Error(1)
65+ }
66+ return r0, r1
67+}
68+
69+// MockRemoteDialerFactory_DialerForRemote_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DialerForRemote'
70+type MockRemoteDialerFactory_DialerForRemote_Call struct {
71+ *mock.Call
72+}
73+
74+// DialerForRemote is a helper method to define mock.On call
75+// - target string
76+// - session string
77+// - mode ports.RemoteTransportMode
78+// - log *slog.Logger
79+func (_e *MockRemoteDialerFactory_Expecter) DialerForRemote(target any, session any, mode any, log any) *MockRemoteDialerFactory_DialerForRemote_Call {
80+ return &MockRemoteDialerFactory_DialerForRemote_Call{Call: _e.mock.On("DialerForRemote", target, session, mode, log)}
81+}
82+
83+func (_c *MockRemoteDialerFactory_DialerForRemote_Call) Run(run func(target string, session string, mode ports.RemoteTransportMode, log *slog.Logger)) *MockRemoteDialerFactory_DialerForRemote_Call {
84+ _c.Call.Run(func(args mock.Arguments) {
85+ var arg0 string
86+ if args[0] != nil {
87+ arg0 = args[0].(string)
88+ }
89+ var arg1 string
90+ if args[1] != nil {
91+ arg1 = args[1].(string)
92+ }
93+ var arg2 ports.RemoteTransportMode
94+ if args[2] != nil {
95+ arg2 = args[2].(ports.RemoteTransportMode)
96+ }
97+ var arg3 *slog.Logger
98+ if args[3] != nil {
99+ arg3 = args[3].(*slog.Logger)
100+ }
101+ run(
102+ arg0,
103+ arg1,
104+ arg2,
105+ arg3,
106+ )
107+ })
108+ return _c
109+}
110+
111+func (_c *MockRemoteDialerFactory_DialerForRemote_Call) Return(dialer ports.Dialer, err error) *MockRemoteDialerFactory_DialerForRemote_Call {
112+ _c.Call.Return(dialer, err)
113+ return _c
114+}
115+
116+func (_c *MockRemoteDialerFactory_DialerForRemote_Call) RunAndReturn(run func(target string, session string, mode ports.RemoteTransportMode, log *slog.Logger) (ports.Dialer, error)) *MockRemoteDialerFactory_DialerForRemote_Call {
117+ _c.Call.Return(run)
118+ return _c
119+}
A internal/ports/mocks/runtime_observer_mock.go +210 -0
@@ -0,0 +1,210 @@
1+// Code generated by mockery; DO NOT EDIT.
2+// github.com/vektra/mockery
3+// template: testify
4+
5+package portsmocks
6+
7+import (
8+ "github.com/bnema/vev/internal/ports"
9+ mock "github.com/stretchr/testify/mock"
10+)
11+
12+// NewMockRuntimeObserver creates a new instance of MockRuntimeObserver. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
13+// The first argument is typically a *testing.T value.
14+func NewMockRuntimeObserver(t interface {
15+ mock.TestingT
16+ Cleanup(func())
17+}) *MockRuntimeObserver {
18+ mock := &MockRuntimeObserver{}
19+ mock.Mock.Test(t)
20+
21+ t.Cleanup(func() { mock.AssertExpectations(t) })
22+
23+ return mock
24+}
25+
26+// MockRuntimeObserver is an autogenerated mock type for the RuntimeObserver type
27+type MockRuntimeObserver struct {
28+ mock.Mock
29+}
30+
31+type MockRuntimeObserver_Expecter struct {
32+ mock *mock.Mock
33+}
34+
35+func (_m *MockRuntimeObserver) EXPECT() *MockRuntimeObserver_Expecter {
36+ return &MockRuntimeObserver_Expecter{mock: &_m.Mock}
37+}
38+
39+// ObserveRuntime provides a mock function for the type MockRuntimeObserver
40+func (_mock *MockRuntimeObserver) ObserveRuntime(runtimeMark ports.RuntimeMark) {
41+ _mock.Called(runtimeMark)
42+ return
43+}
44+
45+// MockRuntimeObserver_ObserveRuntime_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ObserveRuntime'
46+type MockRuntimeObserver_ObserveRuntime_Call struct {
47+ *mock.Call
48+}
49+
50+// ObserveRuntime is a helper method to define mock.On call
51+// - runtimeMark ports.RuntimeMark
52+func (_e *MockRuntimeObserver_Expecter) ObserveRuntime(runtimeMark any) *MockRuntimeObserver_ObserveRuntime_Call {
53+ return &MockRuntimeObserver_ObserveRuntime_Call{Call: _e.mock.On("ObserveRuntime", runtimeMark)}
54+}
55+
56+func (_c *MockRuntimeObserver_ObserveRuntime_Call) Run(run func(runtimeMark ports.RuntimeMark)) *MockRuntimeObserver_ObserveRuntime_Call {
57+ _c.Call.Run(func(args mock.Arguments) {
58+ var arg0 ports.RuntimeMark
59+ if args[0] != nil {
60+ arg0 = args[0].(ports.RuntimeMark)
61+ }
62+ run(
63+ arg0,
64+ )
65+ })
66+ return _c
67+}
68+
69+func (_c *MockRuntimeObserver_ObserveRuntime_Call) Return() *MockRuntimeObserver_ObserveRuntime_Call {
70+ _c.Call.Return()
71+ return _c
72+}
73+
74+func (_c *MockRuntimeObserver_ObserveRuntime_Call) RunAndReturn(run func(runtimeMark ports.RuntimeMark)) *MockRuntimeObserver_ObserveRuntime_Call {
75+ _c.Run(run)
76+ return _c
77+}
78+
79+// NewMockSerializedRuntimeObserver creates a new instance of MockSerializedRuntimeObserver. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
80+// The first argument is typically a *testing.T value.
81+func NewMockSerializedRuntimeObserver(t interface {
82+ mock.TestingT
83+ Cleanup(func())
84+}) *MockSerializedRuntimeObserver {
85+ mock := &MockSerializedRuntimeObserver{}
86+ mock.Mock.Test(t)
87+
88+ t.Cleanup(func() { mock.AssertExpectations(t) })
89+
90+ return mock
91+}
92+
93+// MockSerializedRuntimeObserver is an autogenerated mock type for the SerializedRuntimeObserver type
94+type MockSerializedRuntimeObserver struct {
95+ mock.Mock
96+}
97+
98+type MockSerializedRuntimeObserver_Expecter struct {
99+ mock *mock.Mock
100+}
101+
102+func (_m *MockSerializedRuntimeObserver) EXPECT() *MockSerializedRuntimeObserver_Expecter {
103+ return &MockSerializedRuntimeObserver_Expecter{mock: &_m.Mock}
104+}
105+
106+// Close provides a mock function for the type MockSerializedRuntimeObserver
107+func (_mock *MockSerializedRuntimeObserver) Close() {
108+ _mock.Called()
109+ return
110+}
111+
112+// MockSerializedRuntimeObserver_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
113+type MockSerializedRuntimeObserver_Close_Call struct {
114+ *mock.Call
115+}
116+
117+// Close is a helper method to define mock.On call
118+func (_e *MockSerializedRuntimeObserver_Expecter) Close() *MockSerializedRuntimeObserver_Close_Call {
119+ return &MockSerializedRuntimeObserver_Close_Call{Call: _e.mock.On("Close")}
120+}
121+
122+func (_c *MockSerializedRuntimeObserver_Close_Call) Run(run func()) *MockSerializedRuntimeObserver_Close_Call {
123+ _c.Call.Run(func(args mock.Arguments) {
124+ run()
125+ })
126+ return _c
127+}
128+
129+func (_c *MockSerializedRuntimeObserver_Close_Call) Return() *MockSerializedRuntimeObserver_Close_Call {
130+ _c.Call.Return()
131+ return _c
132+}
133+
134+func (_c *MockSerializedRuntimeObserver_Close_Call) RunAndReturn(run func()) *MockSerializedRuntimeObserver_Close_Call {
135+ _c.Run(run)
136+ return _c
137+}
138+
139+// Flush provides a mock function for the type MockSerializedRuntimeObserver
140+func (_mock *MockSerializedRuntimeObserver) Flush() {
141+ _mock.Called()
142+ return
143+}
144+
145+// MockSerializedRuntimeObserver_Flush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Flush'
146+type MockSerializedRuntimeObserver_Flush_Call struct {
147+ *mock.Call
148+}
149+
150+// Flush is a helper method to define mock.On call
151+func (_e *MockSerializedRuntimeObserver_Expecter) Flush() *MockSerializedRuntimeObserver_Flush_Call {
152+ return &MockSerializedRuntimeObserver_Flush_Call{Call: _e.mock.On("Flush")}
153+}
154+
155+func (_c *MockSerializedRuntimeObserver_Flush_Call) Run(run func()) *MockSerializedRuntimeObserver_Flush_Call {
156+ _c.Call.Run(func(args mock.Arguments) {
157+ run()
158+ })
159+ return _c
160+}
161+
162+func (_c *MockSerializedRuntimeObserver_Flush_Call) Return() *MockSerializedRuntimeObserver_Flush_Call {
163+ _c.Call.Return()
164+ return _c
165+}
166+
167+func (_c *MockSerializedRuntimeObserver_Flush_Call) RunAndReturn(run func()) *MockSerializedRuntimeObserver_Flush_Call {
168+ _c.Run(run)
169+ return _c
170+}
171+
172+// ObserveRuntime provides a mock function for the type MockSerializedRuntimeObserver
173+func (_mock *MockSerializedRuntimeObserver) ObserveRuntime(runtimeMark ports.RuntimeMark) {
174+ _mock.Called(runtimeMark)
175+ return
176+}
177+
178+// MockSerializedRuntimeObserver_ObserveRuntime_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ObserveRuntime'
179+type MockSerializedRuntimeObserver_ObserveRuntime_Call struct {
180+ *mock.Call
181+}
182+
183+// ObserveRuntime is a helper method to define mock.On call
184+// - runtimeMark ports.RuntimeMark
185+func (_e *MockSerializedRuntimeObserver_Expecter) ObserveRuntime(runtimeMark any) *MockSerializedRuntimeObserver_ObserveRuntime_Call {
186+ return &MockSerializedRuntimeObserver_ObserveRuntime_Call{Call: _e.mock.On("ObserveRuntime", runtimeMark)}
187+}
188+
189+func (_c *MockSerializedRuntimeObserver_ObserveRuntime_Call) Run(run func(runtimeMark ports.RuntimeMark)) *MockSerializedRuntimeObserver_ObserveRuntime_Call {
190+ _c.Call.Run(func(args mock.Arguments) {
191+ var arg0 ports.RuntimeMark
192+ if args[0] != nil {
193+ arg0 = args[0].(ports.RuntimeMark)
194+ }
195+ run(
196+ arg0,
197+ )
198+ })
199+ return _c
200+}
201+
202+func (_c *MockSerializedRuntimeObserver_ObserveRuntime_Call) Return() *MockSerializedRuntimeObserver_ObserveRuntime_Call {
203+ _c.Call.Return()
204+ return _c
205+}
206+
207+func (_c *MockSerializedRuntimeObserver_ObserveRuntime_Call) RunAndReturn(run func(runtimeMark ports.RuntimeMark)) *MockSerializedRuntimeObserver_ObserveRuntime_Call {
208+ _c.Run(run)
209+ return _c
210+}
@@ -0,0 +1,210 @@
1+// Code generated by mockery; DO NOT EDIT.
2+// github.com/vektra/mockery
3+// template: testify
4+
5+package portsmocks
6+
7+import (
8+ "github.com/bnema/vev/internal/ports"
9+ mock "github.com/stretchr/testify/mock"
10+)
11+
12+// NewMockRuntimeObserver creates a new instance of MockRuntimeObserver. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
13+// The first argument is typically a *testing.T value.
14+func NewMockRuntimeObserver(t interface {
15+ mock.TestingT
16+ Cleanup(func())
17+}) *MockRuntimeObserver {
18+ mock := &MockRuntimeObserver{}
19+ mock.Mock.Test(t)
20+
21+ t.Cleanup(func() { mock.AssertExpectations(t) })
22+
23+ return mock
24+}
25+
26+// MockRuntimeObserver is an autogenerated mock type for the RuntimeObserver type
27+type MockRuntimeObserver struct {
28+ mock.Mock
29+}
30+
31+type MockRuntimeObserver_Expecter struct {
32+ mock *mock.Mock
33+}
34+
35+func (_m *MockRuntimeObserver) EXPECT() *MockRuntimeObserver_Expecter {
36+ return &MockRuntimeObserver_Expecter{mock: &_m.Mock}
37+}
38+
39+// ObserveRuntime provides a mock function for the type MockRuntimeObserver
40+func (_mock *MockRuntimeObserver) ObserveRuntime(runtimeMark ports.RuntimeMark) {
41+ _mock.Called(runtimeMark)
42+ return
43+}
44+
45+// MockRuntimeObserver_ObserveRuntime_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ObserveRuntime'
46+type MockRuntimeObserver_ObserveRuntime_Call struct {
47+ *mock.Call
48+}
49+
50+// ObserveRuntime is a helper method to define mock.On call
51+// - runtimeMark ports.RuntimeMark
52+func (_e *MockRuntimeObserver_Expecter) ObserveRuntime(runtimeMark any) *MockRuntimeObserver_ObserveRuntime_Call {
53+ return &MockRuntimeObserver_ObserveRuntime_Call{Call: _e.mock.On("ObserveRuntime", runtimeMark)}
54+}
55+
56+func (_c *MockRuntimeObserver_ObserveRuntime_Call) Run(run func(runtimeMark ports.RuntimeMark)) *MockRuntimeObserver_ObserveRuntime_Call {
57+ _c.Call.Run(func(args mock.Arguments) {
58+ var arg0 ports.RuntimeMark
59+ if args[0] != nil {
60+ arg0 = args[0].(ports.RuntimeMark)
61+ }
62+ run(
63+ arg0,
64+ )
65+ })
66+ return _c
67+}
68+
69+func (_c *MockRuntimeObserver_ObserveRuntime_Call) Return() *MockRuntimeObserver_ObserveRuntime_Call {
70+ _c.Call.Return()
71+ return _c
72+}
73+
74+func (_c *MockRuntimeObserver_ObserveRuntime_Call) RunAndReturn(run func(runtimeMark ports.RuntimeMark)) *MockRuntimeObserver_ObserveRuntime_Call {
75+ _c.Run(run)
76+ return _c
77+}
78+
79+// NewMockSerializedRuntimeObserver creates a new instance of MockSerializedRuntimeObserver. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
80+// The first argument is typically a *testing.T value.
81+func NewMockSerializedRuntimeObserver(t interface {
82+ mock.TestingT
83+ Cleanup(func())
84+}) *MockSerializedRuntimeObserver {
85+ mock := &MockSerializedRuntimeObserver{}
86+ mock.Mock.Test(t)
87+
88+ t.Cleanup(func() { mock.AssertExpectations(t) })
89+
90+ return mock
91+}
92+
93+// MockSerializedRuntimeObserver is an autogenerated mock type for the SerializedRuntimeObserver type
94+type MockSerializedRuntimeObserver struct {
95+ mock.Mock
96+}
97+
98+type MockSerializedRuntimeObserver_Expecter struct {
99+ mock *mock.Mock
100+}
101+
102+func (_m *MockSerializedRuntimeObserver) EXPECT() *MockSerializedRuntimeObserver_Expecter {
103+ return &MockSerializedRuntimeObserver_Expecter{mock: &_m.Mock}
104+}
105+
106+// Close provides a mock function for the type MockSerializedRuntimeObserver
107+func (_mock *MockSerializedRuntimeObserver) Close() {
108+ _mock.Called()
109+ return
110+}
111+
112+// MockSerializedRuntimeObserver_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
113+type MockSerializedRuntimeObserver_Close_Call struct {
114+ *mock.Call
115+}
116+
117+// Close is a helper method to define mock.On call
118+func (_e *MockSerializedRuntimeObserver_Expecter) Close() *MockSerializedRuntimeObserver_Close_Call {
119+ return &MockSerializedRuntimeObserver_Close_Call{Call: _e.mock.On("Close")}
120+}
121+
122+func (_c *MockSerializedRuntimeObserver_Close_Call) Run(run func()) *MockSerializedRuntimeObserver_Close_Call {
123+ _c.Call.Run(func(args mock.Arguments) {
124+ run()
125+ })
126+ return _c
127+}
128+
129+func (_c *MockSerializedRuntimeObserver_Close_Call) Return() *MockSerializedRuntimeObserver_Close_Call {
130+ _c.Call.Return()
131+ return _c
132+}
133+
134+func (_c *MockSerializedRuntimeObserver_Close_Call) RunAndReturn(run func()) *MockSerializedRuntimeObserver_Close_Call {
135+ _c.Run(run)
136+ return _c
137+}
138+
139+// Flush provides a mock function for the type MockSerializedRuntimeObserver
140+func (_mock *MockSerializedRuntimeObserver) Flush() {
141+ _mock.Called()
142+ return
143+}
144+
145+// MockSerializedRuntimeObserver_Flush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Flush'
146+type MockSerializedRuntimeObserver_Flush_Call struct {
147+ *mock.Call
148+}
149+
150+// Flush is a helper method to define mock.On call
151+func (_e *MockSerializedRuntimeObserver_Expecter) Flush() *MockSerializedRuntimeObserver_Flush_Call {
152+ return &MockSerializedRuntimeObserver_Flush_Call{Call: _e.mock.On("Flush")}
153+}
154+
155+func (_c *MockSerializedRuntimeObserver_Flush_Call) Run(run func()) *MockSerializedRuntimeObserver_Flush_Call {
156+ _c.Call.Run(func(args mock.Arguments) {
157+ run()
158+ })
159+ return _c
160+}
161+
162+func (_c *MockSerializedRuntimeObserver_Flush_Call) Return() *MockSerializedRuntimeObserver_Flush_Call {
163+ _c.Call.Return()
164+ return _c
165+}
166+
167+func (_c *MockSerializedRuntimeObserver_Flush_Call) RunAndReturn(run func()) *MockSerializedRuntimeObserver_Flush_Call {
168+ _c.Run(run)
169+ return _c
170+}
171+
172+// ObserveRuntime provides a mock function for the type MockSerializedRuntimeObserver
173+func (_mock *MockSerializedRuntimeObserver) ObserveRuntime(runtimeMark ports.RuntimeMark) {
174+ _mock.Called(runtimeMark)
175+ return
176+}
177+
178+// MockSerializedRuntimeObserver_ObserveRuntime_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ObserveRuntime'
179+type MockSerializedRuntimeObserver_ObserveRuntime_Call struct {
180+ *mock.Call
181+}
182+
183+// ObserveRuntime is a helper method to define mock.On call
184+// - runtimeMark ports.RuntimeMark
185+func (_e *MockSerializedRuntimeObserver_Expecter) ObserveRuntime(runtimeMark any) *MockSerializedRuntimeObserver_ObserveRuntime_Call {
186+ return &MockSerializedRuntimeObserver_ObserveRuntime_Call{Call: _e.mock.On("ObserveRuntime", runtimeMark)}
187+}
188+
189+func (_c *MockSerializedRuntimeObserver_ObserveRuntime_Call) Run(run func(runtimeMark ports.RuntimeMark)) *MockSerializedRuntimeObserver_ObserveRuntime_Call {
190+ _c.Call.Run(func(args mock.Arguments) {
191+ var arg0 ports.RuntimeMark
192+ if args[0] != nil {
193+ arg0 = args[0].(ports.RuntimeMark)
194+ }
195+ run(
196+ arg0,
197+ )
198+ })
199+ return _c
200+}
201+
202+func (_c *MockSerializedRuntimeObserver_ObserveRuntime_Call) Return() *MockSerializedRuntimeObserver_ObserveRuntime_Call {
203+ _c.Call.Return()
204+ return _c
205+}
206+
207+func (_c *MockSerializedRuntimeObserver_ObserveRuntime_Call) RunAndReturn(run func(runtimeMark ports.RuntimeMark)) *MockSerializedRuntimeObserver_ObserveRuntime_Call {
208+ _c.Run(run)
209+ return _c
210+}
A internal/ports/mocks/shell_mock.go +107 -0
@@ -0,0 +1,107 @@
1+// Code generated by mockery; DO NOT EDIT.
2+// github.com/vektra/mockery
3+// template: testify
4+
5+package portsmocks
6+
7+import (
8+ "context"
9+
10+ "github.com/bnema/vev/internal/ports"
11+ mock "github.com/stretchr/testify/mock"
12+)
13+
14+// NewMockShellCommandRunner creates a new instance of MockShellCommandRunner. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
15+// The first argument is typically a *testing.T value.
16+func NewMockShellCommandRunner(t interface {
17+ mock.TestingT
18+ Cleanup(func())
19+}) *MockShellCommandRunner {
20+ mock := &MockShellCommandRunner{}
21+ mock.Mock.Test(t)
22+
23+ t.Cleanup(func() { mock.AssertExpectations(t) })
24+
25+ return mock
26+}
27+
28+// MockShellCommandRunner is an autogenerated mock type for the ShellCommandRunner type
29+type MockShellCommandRunner struct {
30+ mock.Mock
31+}
32+
33+type MockShellCommandRunner_Expecter struct {
34+ mock *mock.Mock
35+}
36+
37+func (_m *MockShellCommandRunner) EXPECT() *MockShellCommandRunner_Expecter {
38+ return &MockShellCommandRunner_Expecter{mock: &_m.Mock}
39+}
40+
41+// Run provides a mock function for the type MockShellCommandRunner
42+func (_mock *MockShellCommandRunner) Run(ctx context.Context, spec ports.CommandSpec) ([]byte, error) {
43+ ret := _mock.Called(ctx, spec)
44+
45+ if len(ret) == 0 {
46+ panic("no return value specified for Run")
47+ }
48+
49+ var r0 []byte
50+ var r1 error
51+ if returnFunc, ok := ret.Get(0).(func(context.Context, ports.CommandSpec) ([]byte, error)); ok {
52+ return returnFunc(ctx, spec)
53+ }
54+ if returnFunc, ok := ret.Get(0).(func(context.Context, ports.CommandSpec) []byte); ok {
55+ r0 = returnFunc(ctx, spec)
56+ } else {
57+ if ret.Get(0) != nil {
58+ r0 = ret.Get(0).([]byte)
59+ }
60+ }
61+ if returnFunc, ok := ret.Get(1).(func(context.Context, ports.CommandSpec) error); ok {
62+ r1 = returnFunc(ctx, spec)
63+ } else {
64+ r1 = ret.Error(1)
65+ }
66+ return r0, r1
67+}
68+
69+// MockShellCommandRunner_Run_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Run'
70+type MockShellCommandRunner_Run_Call struct {
71+ *mock.Call
72+}
73+
74+// Run is a helper method to define mock.On call
75+// - ctx context.Context
76+// - spec ports.CommandSpec
77+func (_e *MockShellCommandRunner_Expecter) Run(ctx any, spec any) *MockShellCommandRunner_Run_Call {
78+ return &MockShellCommandRunner_Run_Call{Call: _e.mock.On("Run", ctx, spec)}
79+}
80+
81+func (_c *MockShellCommandRunner_Run_Call) Run(run func(ctx context.Context, spec ports.CommandSpec)) *MockShellCommandRunner_Run_Call {
82+ _c.Call.Run(func(args mock.Arguments) {
83+ var arg0 context.Context
84+ if args[0] != nil {
85+ arg0 = args[0].(context.Context)
86+ }
87+ var arg1 ports.CommandSpec
88+ if args[1] != nil {
89+ arg1 = args[1].(ports.CommandSpec)
90+ }
91+ run(
92+ arg0,
93+ arg1,
94+ )
95+ })
96+ return _c
97+}
98+
99+func (_c *MockShellCommandRunner_Run_Call) Return(bytes []byte, err error) *MockShellCommandRunner_Run_Call {
100+ _c.Call.Return(bytes, err)
101+ return _c
102+}
103+
104+func (_c *MockShellCommandRunner_Run_Call) RunAndReturn(run func(ctx context.Context, spec ports.CommandSpec) ([]byte, error)) *MockShellCommandRunner_Run_Call {
105+ _c.Call.Return(run)
106+ return _c
107+}
@@ -0,0 +1,107 @@
1+// Code generated by mockery; DO NOT EDIT.
2+// github.com/vektra/mockery
3+// template: testify
4+
5+package portsmocks
6+
7+import (
8+ "context"
9+
10+ "github.com/bnema/vev/internal/ports"
11+ mock "github.com/stretchr/testify/mock"
12+)
13+
14+// NewMockShellCommandRunner creates a new instance of MockShellCommandRunner. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
15+// The first argument is typically a *testing.T value.
16+func NewMockShellCommandRunner(t interface {
17+ mock.TestingT
18+ Cleanup(func())
19+}) *MockShellCommandRunner {
20+ mock := &MockShellCommandRunner{}
21+ mock.Mock.Test(t)
22+
23+ t.Cleanup(func() { mock.AssertExpectations(t) })
24+
25+ return mock
26+}
27+
28+// MockShellCommandRunner is an autogenerated mock type for the ShellCommandRunner type
29+type MockShellCommandRunner struct {
30+ mock.Mock
31+}
32+
33+type MockShellCommandRunner_Expecter struct {
34+ mock *mock.Mock
35+}
36+
37+func (_m *MockShellCommandRunner) EXPECT() *MockShellCommandRunner_Expecter {
38+ return &MockShellCommandRunner_Expecter{mock: &_m.Mock}
39+}
40+
41+// Run provides a mock function for the type MockShellCommandRunner
42+func (_mock *MockShellCommandRunner) Run(ctx context.Context, spec ports.CommandSpec) ([]byte, error) {
43+ ret := _mock.Called(ctx, spec)
44+
45+ if len(ret) == 0 {
46+ panic("no return value specified for Run")
47+ }
48+
49+ var r0 []byte
50+ var r1 error
51+ if returnFunc, ok := ret.Get(0).(func(context.Context, ports.CommandSpec) ([]byte, error)); ok {
52+ return returnFunc(ctx, spec)
53+ }
54+ if returnFunc, ok := ret.Get(0).(func(context.Context, ports.CommandSpec) []byte); ok {
55+ r0 = returnFunc(ctx, spec)
56+ } else {
57+ if ret.Get(0) != nil {
58+ r0 = ret.Get(0).([]byte)
59+ }
60+ }
61+ if returnFunc, ok := ret.Get(1).(func(context.Context, ports.CommandSpec) error); ok {
62+ r1 = returnFunc(ctx, spec)
63+ } else {
64+ r1 = ret.Error(1)
65+ }
66+ return r0, r1
67+}
68+
69+// MockShellCommandRunner_Run_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Run'
70+type MockShellCommandRunner_Run_Call struct {
71+ *mock.Call
72+}
73+
74+// Run is a helper method to define mock.On call
75+// - ctx context.Context
76+// - spec ports.CommandSpec
77+func (_e *MockShellCommandRunner_Expecter) Run(ctx any, spec any) *MockShellCommandRunner_Run_Call {
78+ return &MockShellCommandRunner_Run_Call{Call: _e.mock.On("Run", ctx, spec)}
79+}
80+
81+func (_c *MockShellCommandRunner_Run_Call) Run(run func(ctx context.Context, spec ports.CommandSpec)) *MockShellCommandRunner_Run_Call {
82+ _c.Call.Run(func(args mock.Arguments) {
83+ var arg0 context.Context
84+ if args[0] != nil {
85+ arg0 = args[0].(context.Context)
86+ }
87+ var arg1 ports.CommandSpec
88+ if args[1] != nil {
89+ arg1 = args[1].(ports.CommandSpec)
90+ }
91+ run(
92+ arg0,
93+ arg1,
94+ )
95+ })
96+ return _c
97+}
98+
99+func (_c *MockShellCommandRunner_Run_Call) Return(bytes []byte, err error) *MockShellCommandRunner_Run_Call {
100+ _c.Call.Return(bytes, err)
101+ return _c
102+}
103+
104+func (_c *MockShellCommandRunner_Run_Call) RunAndReturn(run func(ctx context.Context, spec ports.CommandSpec) ([]byte, error)) *MockShellCommandRunner_Run_Call {
105+ _c.Call.Return(run)
106+ return _c
107+}
A internal/ports/mocks/store_mock.go +525 -0
@@ -0,0 +1,525 @@
1+// Code generated by mockery; DO NOT EDIT.
2+// github.com/vektra/mockery
3+// template: testify
4+
5+package portsmocks
6+
7+import (
8+ "github.com/bnema/vev/internal/ports"
9+ mock "github.com/stretchr/testify/mock"
10+)
11+
12+// NewMockStore creates a new instance of MockStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
13+// The first argument is typically a *testing.T value.
14+func NewMockStore(t interface {
15+ mock.TestingT
16+ Cleanup(func())
17+}) *MockStore {
18+ mock := &MockStore{}
19+ mock.Mock.Test(t)
20+
21+ t.Cleanup(func() { mock.AssertExpectations(t) })
22+
23+ return mock
24+}
25+
26+// MockStore is an autogenerated mock type for the Store type
27+type MockStore struct {
28+ mock.Mock
29+}
30+
31+type MockStore_Expecter struct {
32+ mock *mock.Mock
33+}
34+
35+func (_m *MockStore) EXPECT() *MockStore_Expecter {
36+ return &MockStore_Expecter{mock: &_m.Mock}
37+}
38+
39+// Close provides a mock function for the type MockStore
40+func (_mock *MockStore) Close() error {
41+ ret := _mock.Called()
42+
43+ if len(ret) == 0 {
44+ panic("no return value specified for Close")
45+ }
46+
47+ var r0 error
48+ if returnFunc, ok := ret.Get(0).(func() error); ok {
49+ r0 = returnFunc()
50+ } else {
51+ r0 = ret.Error(0)
52+ }
53+ return r0
54+}
55+
56+// MockStore_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
57+type MockStore_Close_Call struct {
58+ *mock.Call
59+}
60+
61+// Close is a helper method to define mock.On call
62+func (_e *MockStore_Expecter) Close() *MockStore_Close_Call {
63+ return &MockStore_Close_Call{Call: _e.mock.On("Close")}
64+}
65+
66+func (_c *MockStore_Close_Call) Run(run func()) *MockStore_Close_Call {
67+ _c.Call.Run(func(args mock.Arguments) {
68+ run()
69+ })
70+ return _c
71+}
72+
73+func (_c *MockStore_Close_Call) Return(err error) *MockStore_Close_Call {
74+ _c.Call.Return(err)
75+ return _c
76+}
77+
78+func (_c *MockStore_Close_Call) RunAndReturn(run func() error) *MockStore_Close_Call {
79+ _c.Call.Return(run)
80+ return _c
81+}
82+
83+// Delete provides a mock function for the type MockStore
84+func (_mock *MockStore) Delete(key []byte) error {
85+ ret := _mock.Called(key)
86+
87+ if len(ret) == 0 {
88+ panic("no return value specified for Delete")
89+ }
90+
91+ var r0 error
92+ if returnFunc, ok := ret.Get(0).(func([]byte) error); ok {
93+ r0 = returnFunc(key)
94+ } else {
95+ r0 = ret.Error(0)
96+ }
97+ return r0
98+}
99+
100+// MockStore_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
101+type MockStore_Delete_Call struct {
102+ *mock.Call
103+}
104+
105+// Delete is a helper method to define mock.On call
106+// - key []byte
107+func (_e *MockStore_Expecter) Delete(key any) *MockStore_Delete_Call {
108+ return &MockStore_Delete_Call{Call: _e.mock.On("Delete", key)}
109+}
110+
111+func (_c *MockStore_Delete_Call) Run(run func(key []byte)) *MockStore_Delete_Call {
112+ _c.Call.Run(func(args mock.Arguments) {
113+ var arg0 []byte
114+ if args[0] != nil {
115+ arg0 = args[0].([]byte)
116+ }
117+ run(
118+ arg0,
119+ )
120+ })
121+ return _c
122+}
123+
124+func (_c *MockStore_Delete_Call) Return(err error) *MockStore_Delete_Call {
125+ _c.Call.Return(err)
126+ return _c
127+}
128+
129+func (_c *MockStore_Delete_Call) RunAndReturn(run func(key []byte) error) *MockStore_Delete_Call {
130+ _c.Call.Return(run)
131+ return _c
132+}
133+
134+// Get provides a mock function for the type MockStore
135+func (_mock *MockStore) Get(key []byte) ([]byte, bool) {
136+ ret := _mock.Called(key)
137+
138+ if len(ret) == 0 {
139+ panic("no return value specified for Get")
140+ }
141+
142+ var r0 []byte
143+ var r1 bool
144+ if returnFunc, ok := ret.Get(0).(func([]byte) ([]byte, bool)); ok {
145+ return returnFunc(key)
146+ }
147+ if returnFunc, ok := ret.Get(0).(func([]byte) []byte); ok {
148+ r0 = returnFunc(key)
149+ } else {
150+ if ret.Get(0) != nil {
151+ r0 = ret.Get(0).([]byte)
152+ }
153+ }
154+ if returnFunc, ok := ret.Get(1).(func([]byte) bool); ok {
155+ r1 = returnFunc(key)
156+ } else {
157+ r1 = ret.Get(1).(bool)
158+ }
159+ return r0, r1
160+}
161+
162+// MockStore_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'
163+type MockStore_Get_Call struct {
164+ *mock.Call
165+}
166+
167+// Get is a helper method to define mock.On call
168+// - key []byte
169+func (_e *MockStore_Expecter) Get(key any) *MockStore_Get_Call {
170+ return &MockStore_Get_Call{Call: _e.mock.On("Get", key)}
171+}
172+
173+func (_c *MockStore_Get_Call) Run(run func(key []byte)) *MockStore_Get_Call {
174+ _c.Call.Run(func(args mock.Arguments) {
175+ var arg0 []byte
176+ if args[0] != nil {
177+ arg0 = args[0].([]byte)
178+ }
179+ run(
180+ arg0,
181+ )
182+ })
183+ return _c
184+}
185+
186+func (_c *MockStore_Get_Call) Return(bytes []byte, b bool) *MockStore_Get_Call {
187+ _c.Call.Return(bytes, b)
188+ return _c
189+}
190+
191+func (_c *MockStore_Get_Call) RunAndReturn(run func(key []byte) ([]byte, bool)) *MockStore_Get_Call {
192+ _c.Call.Return(run)
193+ return _c
194+}
195+
196+// Range provides a mock function for the type MockStore
197+func (_mock *MockStore) Range(fn func(k []byte, v []byte) bool) {
198+ _mock.Called(fn)
199+ return
200+}
201+
202+// MockStore_Range_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Range'
203+type MockStore_Range_Call struct {
204+ *mock.Call
205+}
206+
207+// Range is a helper method to define mock.On call
208+// - fn func(k []byte, v []byte) bool
209+func (_e *MockStore_Expecter) Range(fn any) *MockStore_Range_Call {
210+ return &MockStore_Range_Call{Call: _e.mock.On("Range", fn)}
211+}
212+
213+func (_c *MockStore_Range_Call) Run(run func(fn func(k []byte, v []byte) bool)) *MockStore_Range_Call {
214+ _c.Call.Run(func(args mock.Arguments) {
215+ var arg0 func(k []byte, v []byte) bool
216+ if args[0] != nil {
217+ arg0 = args[0].(func(k []byte, v []byte) bool)
218+ }
219+ run(
220+ arg0,
221+ )
222+ })
223+ return _c
224+}
225+
226+func (_c *MockStore_Range_Call) Return() *MockStore_Range_Call {
227+ _c.Call.Return()
228+ return _c
229+}
230+
231+func (_c *MockStore_Range_Call) RunAndReturn(run func(fn func(k []byte, v []byte) bool)) *MockStore_Range_Call {
232+ _c.Run(run)
233+ return _c
234+}
235+
236+// Set provides a mock function for the type MockStore
237+func (_mock *MockStore) Set(key []byte, val []byte) error {
238+ ret := _mock.Called(key, val)
239+
240+ if len(ret) == 0 {
241+ panic("no return value specified for Set")
242+ }
243+
244+ var r0 error
245+ if returnFunc, ok := ret.Get(0).(func([]byte, []byte) error); ok {
246+ r0 = returnFunc(key, val)
247+ } else {
248+ r0 = ret.Error(0)
249+ }
250+ return r0
251+}
252+
253+// MockStore_Set_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Set'
254+type MockStore_Set_Call struct {
255+ *mock.Call
256+}
257+
258+// Set is a helper method to define mock.On call
259+// - key []byte
260+// - val []byte
261+func (_e *MockStore_Expecter) Set(key any, val any) *MockStore_Set_Call {
262+ return &MockStore_Set_Call{Call: _e.mock.On("Set", key, val)}
263+}
264+
265+func (_c *MockStore_Set_Call) Run(run func(key []byte, val []byte)) *MockStore_Set_Call {
266+ _c.Call.Run(func(args mock.Arguments) {
267+ var arg0 []byte
268+ if args[0] != nil {
269+ arg0 = args[0].([]byte)
270+ }
271+ var arg1 []byte
272+ if args[1] != nil {
273+ arg1 = args[1].([]byte)
274+ }
275+ run(
276+ arg0,
277+ arg1,
278+ )
279+ })
280+ return _c
281+}
282+
283+func (_c *MockStore_Set_Call) Return(err error) *MockStore_Set_Call {
284+ _c.Call.Return(err)
285+ return _c
286+}
287+
288+func (_c *MockStore_Set_Call) RunAndReturn(run func(key []byte, val []byte) error) *MockStore_Set_Call {
289+ _c.Call.Return(run)
290+ return _c
291+}
292+
293+// Sync provides a mock function for the type MockStore
294+func (_mock *MockStore) Sync() error {
295+ ret := _mock.Called()
296+
297+ if len(ret) == 0 {
298+ panic("no return value specified for Sync")
299+ }
300+
301+ var r0 error
302+ if returnFunc, ok := ret.Get(0).(func() error); ok {
303+ r0 = returnFunc()
304+ } else {
305+ r0 = ret.Error(0)
306+ }
307+ return r0
308+}
309+
310+// MockStore_Sync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Sync'
311+type MockStore_Sync_Call struct {
312+ *mock.Call
313+}
314+
315+// Sync is a helper method to define mock.On call
316+func (_e *MockStore_Expecter) Sync() *MockStore_Sync_Call {
317+ return &MockStore_Sync_Call{Call: _e.mock.On("Sync")}
318+}
319+
320+func (_c *MockStore_Sync_Call) Run(run func()) *MockStore_Sync_Call {
321+ _c.Call.Run(func(args mock.Arguments) {
322+ run()
323+ })
324+ return _c
325+}
326+
327+func (_c *MockStore_Sync_Call) Return(err error) *MockStore_Sync_Call {
328+ _c.Call.Return(err)
329+ return _c
330+}
331+
332+func (_c *MockStore_Sync_Call) RunAndReturn(run func() error) *MockStore_Sync_Call {
333+ _c.Call.Return(run)
334+ return _c
335+}
336+
337+// NewMockSnapshotStore creates a new instance of MockSnapshotStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
338+// The first argument is typically a *testing.T value.
339+func NewMockSnapshotStore(t interface {
340+ mock.TestingT
341+ Cleanup(func())
342+}) *MockSnapshotStore {
343+ mock := &MockSnapshotStore{}
344+ mock.Mock.Test(t)
345+
346+ t.Cleanup(func() { mock.AssertExpectations(t) })
347+
348+ return mock
349+}
350+
351+// MockSnapshotStore is an autogenerated mock type for the SnapshotStore type
352+type MockSnapshotStore struct {
353+ mock.Mock
354+}
355+
356+type MockSnapshotStore_Expecter struct {
357+ mock *mock.Mock
358+}
359+
360+func (_m *MockSnapshotStore) EXPECT() *MockSnapshotStore_Expecter {
361+ return &MockSnapshotStore_Expecter{mock: &_m.Mock}
362+}
363+
364+// Delete provides a mock function for the type MockSnapshotStore
365+func (_mock *MockSnapshotStore) Delete(name string) error {
366+ ret := _mock.Called(name)
367+
368+ if len(ret) == 0 {
369+ panic("no return value specified for Delete")
370+ }
371+
372+ var r0 error
373+ if returnFunc, ok := ret.Get(0).(func(string) error); ok {
374+ r0 = returnFunc(name)
375+ } else {
376+ r0 = ret.Error(0)
377+ }
378+ return r0
379+}
380+
381+// MockSnapshotStore_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
382+type MockSnapshotStore_Delete_Call struct {
383+ *mock.Call
384+}
385+
386+// Delete is a helper method to define mock.On call
387+// - name string
388+func (_e *MockSnapshotStore_Expecter) Delete(name any) *MockSnapshotStore_Delete_Call {
389+ return &MockSnapshotStore_Delete_Call{Call: _e.mock.On("Delete", name)}
390+}
391+
392+func (_c *MockSnapshotStore_Delete_Call) Run(run func(name string)) *MockSnapshotStore_Delete_Call {
393+ _c.Call.Run(func(args mock.Arguments) {
394+ var arg0 string
395+ if args[0] != nil {
396+ arg0 = args[0].(string)
397+ }
398+ run(
399+ arg0,
400+ )
401+ })
402+ return _c
403+}
404+
405+func (_c *MockSnapshotStore_Delete_Call) Return(err error) *MockSnapshotStore_Delete_Call {
406+ _c.Call.Return(err)
407+ return _c
408+}
409+
410+func (_c *MockSnapshotStore_Delete_Call) RunAndReturn(run func(name string) error) *MockSnapshotStore_Delete_Call {
411+ _c.Call.Return(run)
412+ return _c
413+}
414+
415+// Load provides a mock function for the type MockSnapshotStore
416+func (_mock *MockSnapshotStore) Load() ([]ports.SnapshotBlob, error) {
417+ ret := _mock.Called()
418+
419+ if len(ret) == 0 {
420+ panic("no return value specified for Load")
421+ }
422+
423+ var r0 []ports.SnapshotBlob
424+ var r1 error
425+ if returnFunc, ok := ret.Get(0).(func() ([]ports.SnapshotBlob, error)); ok {
426+ return returnFunc()
427+ }
428+ if returnFunc, ok := ret.Get(0).(func() []ports.SnapshotBlob); ok {
429+ r0 = returnFunc()
430+ } else {
431+ if ret.Get(0) != nil {
432+ r0 = ret.Get(0).([]ports.SnapshotBlob)
433+ }
434+ }
435+ if returnFunc, ok := ret.Get(1).(func() error); ok {
436+ r1 = returnFunc()
437+ } else {
438+ r1 = ret.Error(1)
439+ }
440+ return r0, r1
441+}
442+
443+// MockSnapshotStore_Load_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Load'
444+type MockSnapshotStore_Load_Call struct {
445+ *mock.Call
446+}
447+
448+// Load is a helper method to define mock.On call
449+func (_e *MockSnapshotStore_Expecter) Load() *MockSnapshotStore_Load_Call {
450+ return &MockSnapshotStore_Load_Call{Call: _e.mock.On("Load")}
451+}
452+
453+func (_c *MockSnapshotStore_Load_Call) Run(run func()) *MockSnapshotStore_Load_Call {
454+ _c.Call.Run(func(args mock.Arguments) {
455+ run()
456+ })
457+ return _c
458+}
459+
460+func (_c *MockSnapshotStore_Load_Call) Return(snapshotBlobs []ports.SnapshotBlob, err error) *MockSnapshotStore_Load_Call {
461+ _c.Call.Return(snapshotBlobs, err)
462+ return _c
463+}
464+
465+func (_c *MockSnapshotStore_Load_Call) RunAndReturn(run func() ([]ports.SnapshotBlob, error)) *MockSnapshotStore_Load_Call {
466+ _c.Call.Return(run)
467+ return _c
468+}
469+
470+// Write provides a mock function for the type MockSnapshotStore
471+func (_mock *MockSnapshotStore) Write(name string, data []byte) error {
472+ ret := _mock.Called(name, data)
473+
474+ if len(ret) == 0 {
475+ panic("no return value specified for Write")
476+ }
477+
478+ var r0 error
479+ if returnFunc, ok := ret.Get(0).(func(string, []byte) error); ok {
480+ r0 = returnFunc(name, data)
481+ } else {
482+ r0 = ret.Error(0)
483+ }
484+ return r0
485+}
486+
487+// MockSnapshotStore_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write'
488+type MockSnapshotStore_Write_Call struct {
489+ *mock.Call
490+}
491+
492+// Write is a helper method to define mock.On call
493+// - name string
494+// - data []byte
495+func (_e *MockSnapshotStore_Expecter) Write(name any, data any) *MockSnapshotStore_Write_Call {
496+ return &MockSnapshotStore_Write_Call{Call: _e.mock.On("Write", name, data)}
497+}
498+
499+func (_c *MockSnapshotStore_Write_Call) Run(run func(name string, data []byte)) *MockSnapshotStore_Write_Call {
500+ _c.Call.Run(func(args mock.Arguments) {
501+ var arg0 string
502+ if args[0] != nil {
503+ arg0 = args[0].(string)
504+ }
505+ var arg1 []byte
506+ if args[1] != nil {
507+ arg1 = args[1].([]byte)
508+ }
509+ run(
510+ arg0,
511+ arg1,
512+ )
513+ })
514+ return _c
515+}
516+
517+func (_c *MockSnapshotStore_Write_Call) Return(err error) *MockSnapshotStore_Write_Call {
518+ _c.Call.Return(err)
519+ return _c
520+}
521+
522+func (_c *MockSnapshotStore_Write_Call) RunAndReturn(run func(name string, data []byte) error) *MockSnapshotStore_Write_Call {
523+ _c.Call.Return(run)
524+ return _c
525+}
@@ -0,0 +1,525 @@
1+// Code generated by mockery; DO NOT EDIT.
2+// github.com/vektra/mockery
3+// template: testify
4+
5+package portsmocks
6+
7+import (
8+ "github.com/bnema/vev/internal/ports"
9+ mock "github.com/stretchr/testify/mock"
10+)
11+
12+// NewMockStore creates a new instance of MockStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
13+// The first argument is typically a *testing.T value.
14+func NewMockStore(t interface {
15+ mock.TestingT
16+ Cleanup(func())
17+}) *MockStore {
18+ mock := &MockStore{}
19+ mock.Mock.Test(t)
20+
21+ t.Cleanup(func() { mock.AssertExpectations(t) })
22+
23+ return mock
24+}
25+
26+// MockStore is an autogenerated mock type for the Store type
27+type MockStore struct {
28+ mock.Mock
29+}
30+
31+type MockStore_Expecter struct {
32+ mock *mock.Mock
33+}
34+
35+func (_m *MockStore) EXPECT() *MockStore_Expecter {
36+ return &MockStore_Expecter{mock: &_m.Mock}
37+}
38+
39+// Close provides a mock function for the type MockStore
40+func (_mock *MockStore) Close() error {
41+ ret := _mock.Called()
42+
43+ if len(ret) == 0 {
44+ panic("no return value specified for Close")
45+ }
46+
47+ var r0 error
48+ if returnFunc, ok := ret.Get(0).(func() error); ok {
49+ r0 = returnFunc()
50+ } else {
51+ r0 = ret.Error(0)
52+ }
53+ return r0
54+}
55+
56+// MockStore_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
57+type MockStore_Close_Call struct {
58+ *mock.Call
59+}
60+
61+// Close is a helper method to define mock.On call
62+func (_e *MockStore_Expecter) Close() *MockStore_Close_Call {
63+ return &MockStore_Close_Call{Call: _e.mock.On("Close")}
64+}
65+
66+func (_c *MockStore_Close_Call) Run(run func()) *MockStore_Close_Call {
67+ _c.Call.Run(func(args mock.Arguments) {
68+ run()
69+ })
70+ return _c
71+}
72+
73+func (_c *MockStore_Close_Call) Return(err error) *MockStore_Close_Call {
74+ _c.Call.Return(err)
75+ return _c
76+}
77+
78+func (_c *MockStore_Close_Call) RunAndReturn(run func() error) *MockStore_Close_Call {
79+ _c.Call.Return(run)
80+ return _c
81+}
82+
83+// Delete provides a mock function for the type MockStore
84+func (_mock *MockStore) Delete(key []byte) error {
85+ ret := _mock.Called(key)
86+
87+ if len(ret) == 0 {
88+ panic("no return value specified for Delete")
89+ }
90+
91+ var r0 error
92+ if returnFunc, ok := ret.Get(0).(func([]byte) error); ok {
93+ r0 = returnFunc(key)
94+ } else {
95+ r0 = ret.Error(0)
96+ }
97+ return r0
98+}
99+
100+// MockStore_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
101+type MockStore_Delete_Call struct {
102+ *mock.Call
103+}
104+
105+// Delete is a helper method to define mock.On call
106+// - key []byte
107+func (_e *MockStore_Expecter) Delete(key any) *MockStore_Delete_Call {
108+ return &MockStore_Delete_Call{Call: _e.mock.On("Delete", key)}
109+}
110+
111+func (_c *MockStore_Delete_Call) Run(run func(key []byte)) *MockStore_Delete_Call {
112+ _c.Call.Run(func(args mock.Arguments) {
113+ var arg0 []byte
114+ if args[0] != nil {
115+ arg0 = args[0].([]byte)
116+ }
117+ run(
118+ arg0,
119+ )
120+ })
121+ return _c
122+}
123+
124+func (_c *MockStore_Delete_Call) Return(err error) *MockStore_Delete_Call {
125+ _c.Call.Return(err)
126+ return _c
127+}
128+
129+func (_c *MockStore_Delete_Call) RunAndReturn(run func(key []byte) error) *MockStore_Delete_Call {
130+ _c.Call.Return(run)
131+ return _c
132+}
133+
134+// Get provides a mock function for the type MockStore
135+func (_mock *MockStore) Get(key []byte) ([]byte, bool) {
136+ ret := _mock.Called(key)
137+
138+ if len(ret) == 0 {
139+ panic("no return value specified for Get")
140+ }
141+
142+ var r0 []byte
143+ var r1 bool
144+ if returnFunc, ok := ret.Get(0).(func([]byte) ([]byte, bool)); ok {
145+ return returnFunc(key)
146+ }
147+ if returnFunc, ok := ret.Get(0).(func([]byte) []byte); ok {
148+ r0 = returnFunc(key)
149+ } else {
150+ if ret.Get(0) != nil {
151+ r0 = ret.Get(0).([]byte)
152+ }
153+ }
154+ if returnFunc, ok := ret.Get(1).(func([]byte) bool); ok {
155+ r1 = returnFunc(key)
156+ } else {
157+ r1 = ret.Get(1).(bool)
158+ }
159+ return r0, r1
160+}
161+
162+// MockStore_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'
163+type MockStore_Get_Call struct {
164+ *mock.Call
165+}
166+
167+// Get is a helper method to define mock.On call
168+// - key []byte
169+func (_e *MockStore_Expecter) Get(key any) *MockStore_Get_Call {
170+ return &MockStore_Get_Call{Call: _e.mock.On("Get", key)}
171+}
172+
173+func (_c *MockStore_Get_Call) Run(run func(key []byte)) *MockStore_Get_Call {
174+ _c.Call.Run(func(args mock.Arguments) {
175+ var arg0 []byte
176+ if args[0] != nil {
177+ arg0 = args[0].([]byte)
178+ }
179+ run(
180+ arg0,
181+ )
182+ })
183+ return _c
184+}
185+
186+func (_c *MockStore_Get_Call) Return(bytes []byte, b bool) *MockStore_Get_Call {
187+ _c.Call.Return(bytes, b)
188+ return _c
189+}
190+
191+func (_c *MockStore_Get_Call) RunAndReturn(run func(key []byte) ([]byte, bool)) *MockStore_Get_Call {
192+ _c.Call.Return(run)
193+ return _c
194+}
195+
196+// Range provides a mock function for the type MockStore
197+func (_mock *MockStore) Range(fn func(k []byte, v []byte) bool) {
198+ _mock.Called(fn)
199+ return
200+}
201+
202+// MockStore_Range_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Range'
203+type MockStore_Range_Call struct {
204+ *mock.Call
205+}
206+
207+// Range is a helper method to define mock.On call
208+// - fn func(k []byte, v []byte) bool
209+func (_e *MockStore_Expecter) Range(fn any) *MockStore_Range_Call {
210+ return &MockStore_Range_Call{Call: _e.mock.On("Range", fn)}
211+}
212+
213+func (_c *MockStore_Range_Call) Run(run func(fn func(k []byte, v []byte) bool)) *MockStore_Range_Call {
214+ _c.Call.Run(func(args mock.Arguments) {
215+ var arg0 func(k []byte, v []byte) bool
216+ if args[0] != nil {
217+ arg0 = args[0].(func(k []byte, v []byte) bool)
218+ }
219+ run(
220+ arg0,
221+ )
222+ })
223+ return _c
224+}
225+
226+func (_c *MockStore_Range_Call) Return() *MockStore_Range_Call {
227+ _c.Call.Return()
228+ return _c
229+}
230+
231+func (_c *MockStore_Range_Call) RunAndReturn(run func(fn func(k []byte, v []byte) bool)) *MockStore_Range_Call {
232+ _c.Run(run)
233+ return _c
234+}
235+
236+// Set provides a mock function for the type MockStore
237+func (_mock *MockStore) Set(key []byte, val []byte) error {
238+ ret := _mock.Called(key, val)
239+
240+ if len(ret) == 0 {
241+ panic("no return value specified for Set")
242+ }
243+
244+ var r0 error
245+ if returnFunc, ok := ret.Get(0).(func([]byte, []byte) error); ok {
246+ r0 = returnFunc(key, val)
247+ } else {
248+ r0 = ret.Error(0)
249+ }
250+ return r0
251+}
252+
253+// MockStore_Set_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Set'
254+type MockStore_Set_Call struct {
255+ *mock.Call
256+}
257+
258+// Set is a helper method to define mock.On call
259+// - key []byte
260+// - val []byte
261+func (_e *MockStore_Expecter) Set(key any, val any) *MockStore_Set_Call {
262+ return &MockStore_Set_Call{Call: _e.mock.On("Set", key, val)}
263+}
264+
265+func (_c *MockStore_Set_Call) Run(run func(key []byte, val []byte)) *MockStore_Set_Call {
266+ _c.Call.Run(func(args mock.Arguments) {
267+ var arg0 []byte
268+ if args[0] != nil {
269+ arg0 = args[0].([]byte)
270+ }
271+ var arg1 []byte
272+ if args[1] != nil {
273+ arg1 = args[1].([]byte)
274+ }
275+ run(
276+ arg0,
277+ arg1,
278+ )
279+ })
280+ return _c
281+}
282+
283+func (_c *MockStore_Set_Call) Return(err error) *MockStore_Set_Call {
284+ _c.Call.Return(err)
285+ return _c
286+}
287+
288+func (_c *MockStore_Set_Call) RunAndReturn(run func(key []byte, val []byte) error) *MockStore_Set_Call {
289+ _c.Call.Return(run)
290+ return _c
291+}
292+
293+// Sync provides a mock function for the type MockStore
294+func (_mock *MockStore) Sync() error {
295+ ret := _mock.Called()
296+
297+ if len(ret) == 0 {
298+ panic("no return value specified for Sync")
299+ }
300+
301+ var r0 error
302+ if returnFunc, ok := ret.Get(0).(func() error); ok {
303+ r0 = returnFunc()
304+ } else {
305+ r0 = ret.Error(0)
306+ }
307+ return r0
308+}
309+
310+// MockStore_Sync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Sync'
311+type MockStore_Sync_Call struct {
312+ *mock.Call
313+}
314+
315+// Sync is a helper method to define mock.On call
316+func (_e *MockStore_Expecter) Sync() *MockStore_Sync_Call {
317+ return &MockStore_Sync_Call{Call: _e.mock.On("Sync")}
318+}
319+
320+func (_c *MockStore_Sync_Call) Run(run func()) *MockStore_Sync_Call {
321+ _c.Call.Run(func(args mock.Arguments) {
322+ run()
323+ })
324+ return _c
325+}
326+
327+func (_c *MockStore_Sync_Call) Return(err error) *MockStore_Sync_Call {
328+ _c.Call.Return(err)
329+ return _c
330+}
331+
332+func (_c *MockStore_Sync_Call) RunAndReturn(run func() error) *MockStore_Sync_Call {
333+ _c.Call.Return(run)
334+ return _c
335+}
336+
337+// NewMockSnapshotStore creates a new instance of MockSnapshotStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
338+// The first argument is typically a *testing.T value.
339+func NewMockSnapshotStore(t interface {
340+ mock.TestingT
341+ Cleanup(func())
342+}) *MockSnapshotStore {
343+ mock := &MockSnapshotStore{}
344+ mock.Mock.Test(t)
345+
346+ t.Cleanup(func() { mock.AssertExpectations(t) })
347+
348+ return mock
349+}
350+
351+// MockSnapshotStore is an autogenerated mock type for the SnapshotStore type
352+type MockSnapshotStore struct {
353+ mock.Mock
354+}
355+
356+type MockSnapshotStore_Expecter struct {
357+ mock *mock.Mock
358+}
359+
360+func (_m *MockSnapshotStore) EXPECT() *MockSnapshotStore_Expecter {
361+ return &MockSnapshotStore_Expecter{mock: &_m.Mock}
362+}
363+
364+// Delete provides a mock function for the type MockSnapshotStore
365+func (_mock *MockSnapshotStore) Delete(name string) error {
366+ ret := _mock.Called(name)
367+
368+ if len(ret) == 0 {
369+ panic("no return value specified for Delete")
370+ }
371+
372+ var r0 error
373+ if returnFunc, ok := ret.Get(0).(func(string) error); ok {
374+ r0 = returnFunc(name)
375+ } else {
376+ r0 = ret.Error(0)
377+ }
378+ return r0
379+}
380+
381+// MockSnapshotStore_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
382+type MockSnapshotStore_Delete_Call struct {
383+ *mock.Call
384+}
385+
386+// Delete is a helper method to define mock.On call
387+// - name string
388+func (_e *MockSnapshotStore_Expecter) Delete(name any) *MockSnapshotStore_Delete_Call {
389+ return &MockSnapshotStore_Delete_Call{Call: _e.mock.On("Delete", name)}
390+}
391+
392+func (_c *MockSnapshotStore_Delete_Call) Run(run func(name string)) *MockSnapshotStore_Delete_Call {
393+ _c.Call.Run(func(args mock.Arguments) {
394+ var arg0 string
395+ if args[0] != nil {
396+ arg0 = args[0].(string)
397+ }
398+ run(
399+ arg0,
400+ )
401+ })
402+ return _c
403+}
404+
405+func (_c *MockSnapshotStore_Delete_Call) Return(err error) *MockSnapshotStore_Delete_Call {
406+ _c.Call.Return(err)
407+ return _c
408+}
409+
410+func (_c *MockSnapshotStore_Delete_Call) RunAndReturn(run func(name string) error) *MockSnapshotStore_Delete_Call {
411+ _c.Call.Return(run)
412+ return _c
413+}
414+
415+// Load provides a mock function for the type MockSnapshotStore
416+func (_mock *MockSnapshotStore) Load() ([]ports.SnapshotBlob, error) {
417+ ret := _mock.Called()
418+
419+ if len(ret) == 0 {
420+ panic("no return value specified for Load")
421+ }
422+
423+ var r0 []ports.SnapshotBlob
424+ var r1 error
425+ if returnFunc, ok := ret.Get(0).(func() ([]ports.SnapshotBlob, error)); ok {
426+ return returnFunc()
427+ }
428+ if returnFunc, ok := ret.Get(0).(func() []ports.SnapshotBlob); ok {
429+ r0 = returnFunc()
430+ } else {
431+ if ret.Get(0) != nil {
432+ r0 = ret.Get(0).([]ports.SnapshotBlob)
433+ }
434+ }
435+ if returnFunc, ok := ret.Get(1).(func() error); ok {
436+ r1 = returnFunc()
437+ } else {
438+ r1 = ret.Error(1)
439+ }
440+ return r0, r1
441+}
442+
443+// MockSnapshotStore_Load_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Load'
444+type MockSnapshotStore_Load_Call struct {
445+ *mock.Call
446+}
447+
448+// Load is a helper method to define mock.On call
449+func (_e *MockSnapshotStore_Expecter) Load() *MockSnapshotStore_Load_Call {
450+ return &MockSnapshotStore_Load_Call{Call: _e.mock.On("Load")}
451+}
452+
453+func (_c *MockSnapshotStore_Load_Call) Run(run func()) *MockSnapshotStore_Load_Call {
454+ _c.Call.Run(func(args mock.Arguments) {
455+ run()
456+ })
457+ return _c
458+}
459+
460+func (_c *MockSnapshotStore_Load_Call) Return(snapshotBlobs []ports.SnapshotBlob, err error) *MockSnapshotStore_Load_Call {
461+ _c.Call.Return(snapshotBlobs, err)
462+ return _c
463+}
464+
465+func (_c *MockSnapshotStore_Load_Call) RunAndReturn(run func() ([]ports.SnapshotBlob, error)) *MockSnapshotStore_Load_Call {
466+ _c.Call.Return(run)
467+ return _c
468+}
469+
470+// Write provides a mock function for the type MockSnapshotStore
471+func (_mock *MockSnapshotStore) Write(name string, data []byte) error {
472+ ret := _mock.Called(name, data)
473+
474+ if len(ret) == 0 {
475+ panic("no return value specified for Write")
476+ }
477+
478+ var r0 error
479+ if returnFunc, ok := ret.Get(0).(func(string, []byte) error); ok {
480+ r0 = returnFunc(name, data)
481+ } else {
482+ r0 = ret.Error(0)
483+ }
484+ return r0
485+}
486+
487+// MockSnapshotStore_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write'
488+type MockSnapshotStore_Write_Call struct {
489+ *mock.Call
490+}
491+
492+// Write is a helper method to define mock.On call
493+// - name string
494+// - data []byte
495+func (_e *MockSnapshotStore_Expecter) Write(name any, data any) *MockSnapshotStore_Write_Call {
496+ return &MockSnapshotStore_Write_Call{Call: _e.mock.On("Write", name, data)}
497+}
498+
499+func (_c *MockSnapshotStore_Write_Call) Run(run func(name string, data []byte)) *MockSnapshotStore_Write_Call {
500+ _c.Call.Run(func(args mock.Arguments) {
501+ var arg0 string
502+ if args[0] != nil {
503+ arg0 = args[0].(string)
504+ }
505+ var arg1 []byte
506+ if args[1] != nil {
507+ arg1 = args[1].([]byte)
508+ }
509+ run(
510+ arg0,
511+ arg1,
512+ )
513+ })
514+ return _c
515+}
516+
517+func (_c *MockSnapshotStore_Write_Call) Return(err error) *MockSnapshotStore_Write_Call {
518+ _c.Call.Return(err)
519+ return _c
520+}
521+
522+func (_c *MockSnapshotStore_Write_Call) RunAndReturn(run func(name string, data []byte) error) *MockSnapshotStore_Write_Call {
523+ _c.Call.Return(run)
524+ return _c
525+}
A internal/ports/mocks/terminal_mock.go +373 -0
@@ -0,0 +1,373 @@
1+// Code generated by mockery; DO NOT EDIT.
2+// github.com/vektra/mockery
3+// template: testify
4+
5+package portsmocks
6+
7+import (
8+ "io"
9+
10+ "github.com/bnema/vev/internal/domain"
11+ mock "github.com/stretchr/testify/mock"
12+)
13+
14+// NewMockTerminal creates a new instance of MockTerminal. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
15+// The first argument is typically a *testing.T value.
16+func NewMockTerminal(t interface {
17+ mock.TestingT
18+ Cleanup(func())
19+}) *MockTerminal {
20+ mock := &MockTerminal{}
21+ mock.Mock.Test(t)
22+
23+ t.Cleanup(func() { mock.AssertExpectations(t) })
24+
25+ return mock
26+}
27+
28+// MockTerminal is an autogenerated mock type for the Terminal type
29+type MockTerminal struct {
30+ mock.Mock
31+}
32+
33+type MockTerminal_Expecter struct {
34+ mock *mock.Mock
35+}
36+
37+func (_m *MockTerminal) EXPECT() *MockTerminal_Expecter {
38+ return &MockTerminal_Expecter{mock: &_m.Mock}
39+}
40+
41+// EnterRaw provides a mock function for the type MockTerminal
42+func (_mock *MockTerminal) EnterRaw() (func() error, error) {
43+ ret := _mock.Called()
44+
45+ if len(ret) == 0 {
46+ panic("no return value specified for EnterRaw")
47+ }
48+
49+ var r0 func() error
50+ var r1 error
51+ if returnFunc, ok := ret.Get(0).(func() (func() error, error)); ok {
52+ return returnFunc()
53+ }
54+ if returnFunc, ok := ret.Get(0).(func() func() error); ok {
55+ r0 = returnFunc()
56+ } else {
57+ if ret.Get(0) != nil {
58+ r0 = ret.Get(0).(func() error)
59+ }
60+ }
61+ if returnFunc, ok := ret.Get(1).(func() error); ok {
62+ r1 = returnFunc()
63+ } else {
64+ r1 = ret.Error(1)
65+ }
66+ return r0, r1
67+}
68+
69+// MockTerminal_EnterRaw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnterRaw'
70+type MockTerminal_EnterRaw_Call struct {
71+ *mock.Call
72+}
73+
74+// EnterRaw is a helper method to define mock.On call
75+func (_e *MockTerminal_Expecter) EnterRaw() *MockTerminal_EnterRaw_Call {
76+ return &MockTerminal_EnterRaw_Call{Call: _e.mock.On("EnterRaw")}
77+}
78+
79+func (_c *MockTerminal_EnterRaw_Call) Run(run func()) *MockTerminal_EnterRaw_Call {
80+ _c.Call.Run(func(args mock.Arguments) {
81+ run()
82+ })
83+ return _c
84+}
85+
86+func (_c *MockTerminal_EnterRaw_Call) Return(restore func() error, err error) *MockTerminal_EnterRaw_Call {
87+ _c.Call.Return(restore, err)
88+ return _c
89+}
90+
91+func (_c *MockTerminal_EnterRaw_Call) RunAndReturn(run func() (func() error, error)) *MockTerminal_EnterRaw_Call {
92+ _c.Call.Return(run)
93+ return _c
94+}
95+
96+// Flush provides a mock function for the type MockTerminal
97+func (_mock *MockTerminal) Flush() error {
98+ ret := _mock.Called()
99+
100+ if len(ret) == 0 {
101+ panic("no return value specified for Flush")
102+ }
103+
104+ var r0 error
105+ if returnFunc, ok := ret.Get(0).(func() error); ok {
106+ r0 = returnFunc()
107+ } else {
108+ r0 = ret.Error(0)
109+ }
110+ return r0
111+}
112+
113+// MockTerminal_Flush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Flush'
114+type MockTerminal_Flush_Call struct {
115+ *mock.Call
116+}
117+
118+// Flush is a helper method to define mock.On call
119+func (_e *MockTerminal_Expecter) Flush() *MockTerminal_Flush_Call {
120+ return &MockTerminal_Flush_Call{Call: _e.mock.On("Flush")}
121+}
122+
123+func (_c *MockTerminal_Flush_Call) Run(run func()) *MockTerminal_Flush_Call {
124+ _c.Call.Run(func(args mock.Arguments) {
125+ run()
126+ })
127+ return _c
128+}
129+
130+func (_c *MockTerminal_Flush_Call) Return(err error) *MockTerminal_Flush_Call {
131+ _c.Call.Return(err)
132+ return _c
133+}
134+
135+func (_c *MockTerminal_Flush_Call) RunAndReturn(run func() error) *MockTerminal_Flush_Call {
136+ _c.Call.Return(run)
137+ return _c
138+}
139+
140+// In provides a mock function for the type MockTerminal
141+func (_mock *MockTerminal) In() io.Reader {
142+ ret := _mock.Called()
143+
144+ if len(ret) == 0 {
145+ panic("no return value specified for In")
146+ }
147+
148+ var r0 io.Reader
149+ if returnFunc, ok := ret.Get(0).(func() io.Reader); ok {
150+ r0 = returnFunc()
151+ } else {
152+ if ret.Get(0) != nil {
153+ r0 = ret.Get(0).(io.Reader)
154+ }
155+ }
156+ return r0
157+}
158+
159+// MockTerminal_In_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'In'
160+type MockTerminal_In_Call struct {
161+ *mock.Call
162+}
163+
164+// In is a helper method to define mock.On call
165+func (_e *MockTerminal_Expecter) In() *MockTerminal_In_Call {
166+ return &MockTerminal_In_Call{Call: _e.mock.On("In")}
167+}
168+
169+func (_c *MockTerminal_In_Call) Run(run func()) *MockTerminal_In_Call {
170+ _c.Call.Run(func(args mock.Arguments) {
171+ run()
172+ })
173+ return _c
174+}
175+
176+func (_c *MockTerminal_In_Call) Return(reader io.Reader) *MockTerminal_In_Call {
177+ _c.Call.Return(reader)
178+ return _c
179+}
180+
181+func (_c *MockTerminal_In_Call) RunAndReturn(run func() io.Reader) *MockTerminal_In_Call {
182+ _c.Call.Return(run)
183+ return _c
184+}
185+
186+// Out provides a mock function for the type MockTerminal
187+func (_mock *MockTerminal) Out() io.Writer {
188+ ret := _mock.Called()
189+
190+ if len(ret) == 0 {
191+ panic("no return value specified for Out")
192+ }
193+
194+ var r0 io.Writer
195+ if returnFunc, ok := ret.Get(0).(func() io.Writer); ok {
196+ r0 = returnFunc()
197+ } else {
198+ if ret.Get(0) != nil {
199+ r0 = ret.Get(0).(io.Writer)
200+ }
201+ }
202+ return r0
203+}
204+
205+// MockTerminal_Out_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Out'
206+type MockTerminal_Out_Call struct {
207+ *mock.Call
208+}
209+
210+// Out is a helper method to define mock.On call
211+func (_e *MockTerminal_Expecter) Out() *MockTerminal_Out_Call {
212+ return &MockTerminal_Out_Call{Call: _e.mock.On("Out")}
213+}
214+
215+func (_c *MockTerminal_Out_Call) Run(run func()) *MockTerminal_Out_Call {
216+ _c.Call.Run(func(args mock.Arguments) {
217+ run()
218+ })
219+ return _c
220+}
221+
222+func (_c *MockTerminal_Out_Call) Return(writer io.Writer) *MockTerminal_Out_Call {
223+ _c.Call.Return(writer)
224+ return _c
225+}
226+
227+func (_c *MockTerminal_Out_Call) RunAndReturn(run func() io.Writer) *MockTerminal_Out_Call {
228+ _c.Call.Return(run)
229+ return _c
230+}
231+
232+// QueryColors provides a mock function for the type MockTerminal
233+func (_mock *MockTerminal) QueryColors() error {
234+ ret := _mock.Called()
235+
236+ if len(ret) == 0 {
237+ panic("no return value specified for QueryColors")
238+ }
239+
240+ var r0 error
241+ if returnFunc, ok := ret.Get(0).(func() error); ok {
242+ r0 = returnFunc()
243+ } else {
244+ r0 = ret.Error(0)
245+ }
246+ return r0
247+}
248+
249+// MockTerminal_QueryColors_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'QueryColors'
250+type MockTerminal_QueryColors_Call struct {
251+ *mock.Call
252+}
253+
254+// QueryColors is a helper method to define mock.On call
255+func (_e *MockTerminal_Expecter) QueryColors() *MockTerminal_QueryColors_Call {
256+ return &MockTerminal_QueryColors_Call{Call: _e.mock.On("QueryColors")}
257+}
258+
259+func (_c *MockTerminal_QueryColors_Call) Run(run func()) *MockTerminal_QueryColors_Call {
260+ _c.Call.Run(func(args mock.Arguments) {
261+ run()
262+ })
263+ return _c
264+}
265+
266+func (_c *MockTerminal_QueryColors_Call) Return(err error) *MockTerminal_QueryColors_Call {
267+ _c.Call.Return(err)
268+ return _c
269+}
270+
271+func (_c *MockTerminal_QueryColors_Call) RunAndReturn(run func() error) *MockTerminal_QueryColors_Call {
272+ _c.Call.Return(run)
273+ return _c
274+}
275+
276+// ResizeEvents provides a mock function for the type MockTerminal
277+func (_mock *MockTerminal) ResizeEvents() <-chan domain.Size {
278+ ret := _mock.Called()
279+
280+ if len(ret) == 0 {
281+ panic("no return value specified for ResizeEvents")
282+ }
283+
284+ var r0 <-chan domain.Size
285+ if returnFunc, ok := ret.Get(0).(func() <-chan domain.Size); ok {
286+ r0 = returnFunc()
287+ } else {
288+ if ret.Get(0) != nil {
289+ r0 = ret.Get(0).(<-chan domain.Size)
290+ }
291+ }
292+ return r0
293+}
294+
295+// MockTerminal_ResizeEvents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResizeEvents'
296+type MockTerminal_ResizeEvents_Call struct {
297+ *mock.Call
298+}
299+
300+// ResizeEvents is a helper method to define mock.On call
301+func (_e *MockTerminal_Expecter) ResizeEvents() *MockTerminal_ResizeEvents_Call {
302+ return &MockTerminal_ResizeEvents_Call{Call: _e.mock.On("ResizeEvents")}
303+}
304+
305+func (_c *MockTerminal_ResizeEvents_Call) Run(run func()) *MockTerminal_ResizeEvents_Call {
306+ _c.Call.Run(func(args mock.Arguments) {
307+ run()
308+ })
309+ return _c
310+}
311+
312+func (_c *MockTerminal_ResizeEvents_Call) Return(sizeCh <-chan domain.Size) *MockTerminal_ResizeEvents_Call {
313+ _c.Call.Return(sizeCh)
314+ return _c
315+}
316+
317+func (_c *MockTerminal_ResizeEvents_Call) RunAndReturn(run func() <-chan domain.Size) *MockTerminal_ResizeEvents_Call {
318+ _c.Call.Return(run)
319+ return _c
320+}
321+
322+// Size provides a mock function for the type MockTerminal
323+func (_mock *MockTerminal) Size() (domain.Size, error) {
324+ ret := _mock.Called()
325+
326+ if len(ret) == 0 {
327+ panic("no return value specified for Size")
328+ }
329+
330+ var r0 domain.Size
331+ var r1 error
332+ if returnFunc, ok := ret.Get(0).(func() (domain.Size, error)); ok {
333+ return returnFunc()
334+ }
335+ if returnFunc, ok := ret.Get(0).(func() domain.Size); ok {
336+ r0 = returnFunc()
337+ } else {
338+ r0 = ret.Get(0).(domain.Size)
339+ }
340+ if returnFunc, ok := ret.Get(1).(func() error); ok {
341+ r1 = returnFunc()
342+ } else {
343+ r1 = ret.Error(1)
344+ }
345+ return r0, r1
346+}
347+
348+// MockTerminal_Size_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Size'
349+type MockTerminal_Size_Call struct {
350+ *mock.Call
351+}
352+
353+// Size is a helper method to define mock.On call
354+func (_e *MockTerminal_Expecter) Size() *MockTerminal_Size_Call {
355+ return &MockTerminal_Size_Call{Call: _e.mock.On("Size")}
356+}
357+
358+func (_c *MockTerminal_Size_Call) Run(run func()) *MockTerminal_Size_Call {
359+ _c.Call.Run(func(args mock.Arguments) {
360+ run()
361+ })
362+ return _c
363+}
364+
365+func (_c *MockTerminal_Size_Call) Return(size domain.Size, err error) *MockTerminal_Size_Call {
366+ _c.Call.Return(size, err)
367+ return _c
368+}
369+
370+func (_c *MockTerminal_Size_Call) RunAndReturn(run func() (domain.Size, error)) *MockTerminal_Size_Call {
371+ _c.Call.Return(run)
372+ return _c
373+}
@@ -0,0 +1,373 @@
1+// Code generated by mockery; DO NOT EDIT.
2+// github.com/vektra/mockery
3+// template: testify
4+
5+package portsmocks
6+
7+import (
8+ "io"
9+
10+ "github.com/bnema/vev/internal/domain"
11+ mock "github.com/stretchr/testify/mock"
12+)
13+
14+// NewMockTerminal creates a new instance of MockTerminal. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
15+// The first argument is typically a *testing.T value.
16+func NewMockTerminal(t interface {
17+ mock.TestingT
18+ Cleanup(func())
19+}) *MockTerminal {
20+ mock := &MockTerminal{}
21+ mock.Mock.Test(t)
22+
23+ t.Cleanup(func() { mock.AssertExpectations(t) })
24+
25+ return mock
26+}
27+
28+// MockTerminal is an autogenerated mock type for the Terminal type
29+type MockTerminal struct {
30+ mock.Mock
31+}
32+
33+type MockTerminal_Expecter struct {
34+ mock *mock.Mock
35+}
36+
37+func (_m *MockTerminal) EXPECT() *MockTerminal_Expecter {
38+ return &MockTerminal_Expecter{mock: &_m.Mock}
39+}
40+
41+// EnterRaw provides a mock function for the type MockTerminal
42+func (_mock *MockTerminal) EnterRaw() (func() error, error) {
43+ ret := _mock.Called()
44+
45+ if len(ret) == 0 {
46+ panic("no return value specified for EnterRaw")
47+ }
48+
49+ var r0 func() error
50+ var r1 error
51+ if returnFunc, ok := ret.Get(0).(func() (func() error, error)); ok {
52+ return returnFunc()
53+ }
54+ if returnFunc, ok := ret.Get(0).(func() func() error); ok {
55+ r0 = returnFunc()
56+ } else {
57+ if ret.Get(0) != nil {
58+ r0 = ret.Get(0).(func() error)
59+ }
60+ }
61+ if returnFunc, ok := ret.Get(1).(func() error); ok {
62+ r1 = returnFunc()
63+ } else {
64+ r1 = ret.Error(1)
65+ }
66+ return r0, r1
67+}
68+
69+// MockTerminal_EnterRaw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnterRaw'
70+type MockTerminal_EnterRaw_Call struct {
71+ *mock.Call
72+}
73+
74+// EnterRaw is a helper method to define mock.On call
75+func (_e *MockTerminal_Expecter) EnterRaw() *MockTerminal_EnterRaw_Call {
76+ return &MockTerminal_EnterRaw_Call{Call: _e.mock.On("EnterRaw")}
77+}
78+
79+func (_c *MockTerminal_EnterRaw_Call) Run(run func()) *MockTerminal_EnterRaw_Call {
80+ _c.Call.Run(func(args mock.Arguments) {
81+ run()
82+ })
83+ return _c
84+}
85+
86+func (_c *MockTerminal_EnterRaw_Call) Return(restore func() error, err error) *MockTerminal_EnterRaw_Call {
87+ _c.Call.Return(restore, err)
88+ return _c
89+}
90+
91+func (_c *MockTerminal_EnterRaw_Call) RunAndReturn(run func() (func() error, error)) *MockTerminal_EnterRaw_Call {
92+ _c.Call.Return(run)
93+ return _c
94+}
95+
96+// Flush provides a mock function for the type MockTerminal
97+func (_mock *MockTerminal) Flush() error {
98+ ret := _mock.Called()
99+
100+ if len(ret) == 0 {
101+ panic("no return value specified for Flush")
102+ }
103+
104+ var r0 error
105+ if returnFunc, ok := ret.Get(0).(func() error); ok {
106+ r0 = returnFunc()
107+ } else {
108+ r0 = ret.Error(0)
109+ }
110+ return r0
111+}
112+
113+// MockTerminal_Flush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Flush'
114+type MockTerminal_Flush_Call struct {
115+ *mock.Call
116+}
117+
118+// Flush is a helper method to define mock.On call
119+func (_e *MockTerminal_Expecter) Flush() *MockTerminal_Flush_Call {
120+ return &MockTerminal_Flush_Call{Call: _e.mock.On("Flush")}
121+}
122+
123+func (_c *MockTerminal_Flush_Call) Run(run func()) *MockTerminal_Flush_Call {
124+ _c.Call.Run(func(args mock.Arguments) {
125+ run()
126+ })
127+ return _c
128+}
129+
130+func (_c *MockTerminal_Flush_Call) Return(err error) *MockTerminal_Flush_Call {
131+ _c.Call.Return(err)
132+ return _c
133+}
134+
135+func (_c *MockTerminal_Flush_Call) RunAndReturn(run func() error) *MockTerminal_Flush_Call {
136+ _c.Call.Return(run)
137+ return _c
138+}
139+
140+// In provides a mock function for the type MockTerminal
141+func (_mock *MockTerminal) In() io.Reader {
142+ ret := _mock.Called()
143+
144+ if len(ret) == 0 {
145+ panic("no return value specified for In")
146+ }
147+
148+ var r0 io.Reader
149+ if returnFunc, ok := ret.Get(0).(func() io.Reader); ok {
150+ r0 = returnFunc()
151+ } else {
152+ if ret.Get(0) != nil {
153+ r0 = ret.Get(0).(io.Reader)
154+ }
155+ }
156+ return r0
157+}
158+
159+// MockTerminal_In_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'In'
160+type MockTerminal_In_Call struct {
161+ *mock.Call
162+}
163+
164+// In is a helper method to define mock.On call
165+func (_e *MockTerminal_Expecter) In() *MockTerminal_In_Call {
166+ return &MockTerminal_In_Call{Call: _e.mock.On("In")}
167+}
168+
169+func (_c *MockTerminal_In_Call) Run(run func()) *MockTerminal_In_Call {
170+ _c.Call.Run(func(args mock.Arguments) {
171+ run()
172+ })
173+ return _c
174+}
175+
176+func (_c *MockTerminal_In_Call) Return(reader io.Reader) *MockTerminal_In_Call {
177+ _c.Call.Return(reader)
178+ return _c
179+}
180+
181+func (_c *MockTerminal_In_Call) RunAndReturn(run func() io.Reader) *MockTerminal_In_Call {
182+ _c.Call.Return(run)
183+ return _c
184+}
185+
186+// Out provides a mock function for the type MockTerminal
187+func (_mock *MockTerminal) Out() io.Writer {
188+ ret := _mock.Called()
189+
190+ if len(ret) == 0 {
191+ panic("no return value specified for Out")
192+ }
193+
194+ var r0 io.Writer
195+ if returnFunc, ok := ret.Get(0).(func() io.Writer); ok {
196+ r0 = returnFunc()
197+ } else {
198+ if ret.Get(0) != nil {
199+ r0 = ret.Get(0).(io.Writer)
200+ }
201+ }
202+ return r0
203+}
204+
205+// MockTerminal_Out_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Out'
206+type MockTerminal_Out_Call struct {
207+ *mock.Call
208+}
209+
210+// Out is a helper method to define mock.On call
211+func (_e *MockTerminal_Expecter) Out() *MockTerminal_Out_Call {
212+ return &MockTerminal_Out_Call{Call: _e.mock.On("Out")}
213+}
214+
215+func (_c *MockTerminal_Out_Call) Run(run func()) *MockTerminal_Out_Call {
216+ _c.Call.Run(func(args mock.Arguments) {
217+ run()
218+ })
219+ return _c
220+}
221+
222+func (_c *MockTerminal_Out_Call) Return(writer io.Writer) *MockTerminal_Out_Call {
223+ _c.Call.Return(writer)
224+ return _c
225+}
226+
227+func (_c *MockTerminal_Out_Call) RunAndReturn(run func() io.Writer) *MockTerminal_Out_Call {
228+ _c.Call.Return(run)
229+ return _c
230+}
231+
232+// QueryColors provides a mock function for the type MockTerminal
233+func (_mock *MockTerminal) QueryColors() error {
234+ ret := _mock.Called()
235+
236+ if len(ret) == 0 {
237+ panic("no return value specified for QueryColors")
238+ }
239+
240+ var r0 error
241+ if returnFunc, ok := ret.Get(0).(func() error); ok {
242+ r0 = returnFunc()
243+ } else {
244+ r0 = ret.Error(0)
245+ }
246+ return r0
247+}
248+
249+// MockTerminal_QueryColors_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'QueryColors'
250+type MockTerminal_QueryColors_Call struct {
251+ *mock.Call
252+}
253+
254+// QueryColors is a helper method to define mock.On call
255+func (_e *MockTerminal_Expecter) QueryColors() *MockTerminal_QueryColors_Call {
256+ return &MockTerminal_QueryColors_Call{Call: _e.mock.On("QueryColors")}
257+}
258+
259+func (_c *MockTerminal_QueryColors_Call) Run(run func()) *MockTerminal_QueryColors_Call {
260+ _c.Call.Run(func(args mock.Arguments) {
261+ run()
262+ })
263+ return _c
264+}
265+
266+func (_c *MockTerminal_QueryColors_Call) Return(err error) *MockTerminal_QueryColors_Call {
267+ _c.Call.Return(err)
268+ return _c
269+}
270+
271+func (_c *MockTerminal_QueryColors_Call) RunAndReturn(run func() error) *MockTerminal_QueryColors_Call {
272+ _c.Call.Return(run)
273+ return _c
274+}
275+
276+// ResizeEvents provides a mock function for the type MockTerminal
277+func (_mock *MockTerminal) ResizeEvents() <-chan domain.Size {
278+ ret := _mock.Called()
279+
280+ if len(ret) == 0 {
281+ panic("no return value specified for ResizeEvents")
282+ }
283+
284+ var r0 <-chan domain.Size
285+ if returnFunc, ok := ret.Get(0).(func() <-chan domain.Size); ok {
286+ r0 = returnFunc()
287+ } else {
288+ if ret.Get(0) != nil {
289+ r0 = ret.Get(0).(<-chan domain.Size)
290+ }
291+ }
292+ return r0
293+}
294+
295+// MockTerminal_ResizeEvents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResizeEvents'
296+type MockTerminal_ResizeEvents_Call struct {
297+ *mock.Call
298+}
299+
300+// ResizeEvents is a helper method to define mock.On call
301+func (_e *MockTerminal_Expecter) ResizeEvents() *MockTerminal_ResizeEvents_Call {
302+ return &MockTerminal_ResizeEvents_Call{Call: _e.mock.On("ResizeEvents")}
303+}
304+
305+func (_c *MockTerminal_ResizeEvents_Call) Run(run func()) *MockTerminal_ResizeEvents_Call {
306+ _c.Call.Run(func(args mock.Arguments) {
307+ run()
308+ })
309+ return _c
310+}
311+
312+func (_c *MockTerminal_ResizeEvents_Call) Return(sizeCh <-chan domain.Size) *MockTerminal_ResizeEvents_Call {
313+ _c.Call.Return(sizeCh)
314+ return _c
315+}
316+
317+func (_c *MockTerminal_ResizeEvents_Call) RunAndReturn(run func() <-chan domain.Size) *MockTerminal_ResizeEvents_Call {
318+ _c.Call.Return(run)
319+ return _c
320+}
321+
322+// Size provides a mock function for the type MockTerminal
323+func (_mock *MockTerminal) Size() (domain.Size, error) {
324+ ret := _mock.Called()
325+
326+ if len(ret) == 0 {
327+ panic("no return value specified for Size")
328+ }
329+
330+ var r0 domain.Size
331+ var r1 error
332+ if returnFunc, ok := ret.Get(0).(func() (domain.Size, error)); ok {
333+ return returnFunc()
334+ }
335+ if returnFunc, ok := ret.Get(0).(func() domain.Size); ok {
336+ r0 = returnFunc()
337+ } else {
338+ r0 = ret.Get(0).(domain.Size)
339+ }
340+ if returnFunc, ok := ret.Get(1).(func() error); ok {
341+ r1 = returnFunc()
342+ } else {
343+ r1 = ret.Error(1)
344+ }
345+ return r0, r1
346+}
347+
348+// MockTerminal_Size_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Size'
349+type MockTerminal_Size_Call struct {
350+ *mock.Call
351+}
352+
353+// Size is a helper method to define mock.On call
354+func (_e *MockTerminal_Expecter) Size() *MockTerminal_Size_Call {
355+ return &MockTerminal_Size_Call{Call: _e.mock.On("Size")}
356+}
357+
358+func (_c *MockTerminal_Size_Call) Run(run func()) *MockTerminal_Size_Call {
359+ _c.Call.Run(func(args mock.Arguments) {
360+ run()
361+ })
362+ return _c
363+}
364+
365+func (_c *MockTerminal_Size_Call) Return(size domain.Size, err error) *MockTerminal_Size_Call {
366+ _c.Call.Return(size, err)
367+ return _c
368+}
369+
370+func (_c *MockTerminal_Size_Call) RunAndReturn(run func() (domain.Size, error)) *MockTerminal_Size_Call {
371+ _c.Call.Return(run)
372+ return _c
373+}
A internal/ports/mocks/transport_mock.go +810 -0
@@ -0,0 +1,810 @@
1+// Code generated by mockery; DO NOT EDIT.
2+// github.com/vektra/mockery
3+// template: testify
4+
5+package portsmocks
6+
7+import (
8+ "context"
9+
10+ "github.com/bnema/vev/internal/ports"
11+ mock "github.com/stretchr/testify/mock"
12+)
13+
14+// NewMockTransport creates a new instance of MockTransport. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
15+// The first argument is typically a *testing.T value.
16+func NewMockTransport(t interface {
17+ mock.TestingT
18+ Cleanup(func())
19+}) *MockTransport {
20+ mock := &MockTransport{}
21+ mock.Mock.Test(t)
22+
23+ t.Cleanup(func() { mock.AssertExpectations(t) })
24+
25+ return mock
26+}
27+
28+// MockTransport is an autogenerated mock type for the Transport type
29+type MockTransport struct {
30+ mock.Mock
31+}
32+
33+type MockTransport_Expecter struct {
34+ mock *mock.Mock
35+}
36+
37+func (_m *MockTransport) EXPECT() *MockTransport_Expecter {
38+ return &MockTransport_Expecter{mock: &_m.Mock}
39+}
40+
41+// Close provides a mock function for the type MockTransport
42+func (_mock *MockTransport) Close() error {
43+ ret := _mock.Called()
44+
45+ if len(ret) == 0 {
46+ panic("no return value specified for Close")
47+ }
48+
49+ var r0 error
50+ if returnFunc, ok := ret.Get(0).(func() error); ok {
51+ r0 = returnFunc()
52+ } else {
53+ r0 = ret.Error(0)
54+ }
55+ return r0
56+}
57+
58+// MockTransport_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
59+type MockTransport_Close_Call struct {
60+ *mock.Call
61+}
62+
63+// Close is a helper method to define mock.On call
64+func (_e *MockTransport_Expecter) Close() *MockTransport_Close_Call {
65+ return &MockTransport_Close_Call{Call: _e.mock.On("Close")}
66+}
67+
68+func (_c *MockTransport_Close_Call) Run(run func()) *MockTransport_Close_Call {
69+ _c.Call.Run(func(args mock.Arguments) {
70+ run()
71+ })
72+ return _c
73+}
74+
75+func (_c *MockTransport_Close_Call) Return(err error) *MockTransport_Close_Call {
76+ _c.Call.Return(err)
77+ return _c
78+}
79+
80+func (_c *MockTransport_Close_Call) RunAndReturn(run func() error) *MockTransport_Close_Call {
81+ _c.Call.Return(run)
82+ return _c
83+}
84+
85+// Recv provides a mock function for the type MockTransport
86+func (_mock *MockTransport) Recv() (ports.Frame, error) {
87+ ret := _mock.Called()
88+
89+ if len(ret) == 0 {
90+ panic("no return value specified for Recv")
91+ }
92+
93+ var r0 ports.Frame
94+ var r1 error
95+ if returnFunc, ok := ret.Get(0).(func() (ports.Frame, error)); ok {
96+ return returnFunc()
97+ }
98+ if returnFunc, ok := ret.Get(0).(func() ports.Frame); ok {
99+ r0 = returnFunc()
100+ } else {
101+ r0 = ret.Get(0).(ports.Frame)
102+ }
103+ if returnFunc, ok := ret.Get(1).(func() error); ok {
104+ r1 = returnFunc()
105+ } else {
106+ r1 = ret.Error(1)
107+ }
108+ return r0, r1
109+}
110+
111+// MockTransport_Recv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recv'
112+type MockTransport_Recv_Call struct {
113+ *mock.Call
114+}
115+
116+// Recv is a helper method to define mock.On call
117+func (_e *MockTransport_Expecter) Recv() *MockTransport_Recv_Call {
118+ return &MockTransport_Recv_Call{Call: _e.mock.On("Recv")}
119+}
120+
121+func (_c *MockTransport_Recv_Call) Run(run func()) *MockTransport_Recv_Call {
122+ _c.Call.Run(func(args mock.Arguments) {
123+ run()
124+ })
125+ return _c
126+}
127+
128+func (_c *MockTransport_Recv_Call) Return(frame ports.Frame, err error) *MockTransport_Recv_Call {
129+ _c.Call.Return(frame, err)
130+ return _c
131+}
132+
133+func (_c *MockTransport_Recv_Call) RunAndReturn(run func() (ports.Frame, error)) *MockTransport_Recv_Call {
134+ _c.Call.Return(run)
135+ return _c
136+}
137+
138+// Send provides a mock function for the type MockTransport
139+func (_mock *MockTransport) Send(frame ports.Frame) error {
140+ ret := _mock.Called(frame)
141+
142+ if len(ret) == 0 {
143+ panic("no return value specified for Send")
144+ }
145+
146+ var r0 error
147+ if returnFunc, ok := ret.Get(0).(func(ports.Frame) error); ok {
148+ r0 = returnFunc(frame)
149+ } else {
150+ r0 = ret.Error(0)
151+ }
152+ return r0
153+}
154+
155+// MockTransport_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send'
156+type MockTransport_Send_Call struct {
157+ *mock.Call
158+}
159+
160+// Send is a helper method to define mock.On call
161+// - frame ports.Frame
162+func (_e *MockTransport_Expecter) Send(frame any) *MockTransport_Send_Call {
163+ return &MockTransport_Send_Call{Call: _e.mock.On("Send", frame)}
164+}
165+
166+func (_c *MockTransport_Send_Call) Run(run func(frame ports.Frame)) *MockTransport_Send_Call {
167+ _c.Call.Run(func(args mock.Arguments) {
168+ var arg0 ports.Frame
169+ if args[0] != nil {
170+ arg0 = args[0].(ports.Frame)
171+ }
172+ run(
173+ arg0,
174+ )
175+ })
176+ return _c
177+}
178+
179+func (_c *MockTransport_Send_Call) Return(err error) *MockTransport_Send_Call {
180+ _c.Call.Return(err)
181+ return _c
182+}
183+
184+func (_c *MockTransport_Send_Call) RunAndReturn(run func(frame ports.Frame) error) *MockTransport_Send_Call {
185+ _c.Call.Return(run)
186+ return _c
187+}
188+
189+// NewMockDatagramTransport creates a new instance of MockDatagramTransport. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
190+// The first argument is typically a *testing.T value.
191+func NewMockDatagramTransport(t interface {
192+ mock.TestingT
193+ Cleanup(func())
194+}) *MockDatagramTransport {
195+ mock := &MockDatagramTransport{}
196+ mock.Mock.Test(t)
197+
198+ t.Cleanup(func() { mock.AssertExpectations(t) })
199+
200+ return mock
201+}
202+
203+// MockDatagramTransport is an autogenerated mock type for the DatagramTransport type
204+type MockDatagramTransport struct {
205+ mock.Mock
206+}
207+
208+type MockDatagramTransport_Expecter struct {
209+ mock *mock.Mock
210+}
211+
212+func (_m *MockDatagramTransport) EXPECT() *MockDatagramTransport_Expecter {
213+ return &MockDatagramTransport_Expecter{mock: &_m.Mock}
214+}
215+
216+// Close provides a mock function for the type MockDatagramTransport
217+func (_mock *MockDatagramTransport) Close() error {
218+ ret := _mock.Called()
219+
220+ if len(ret) == 0 {
221+ panic("no return value specified for Close")
222+ }
223+
224+ var r0 error
225+ if returnFunc, ok := ret.Get(0).(func() error); ok {
226+ r0 = returnFunc()
227+ } else {
228+ r0 = ret.Error(0)
229+ }
230+ return r0
231+}
232+
233+// MockDatagramTransport_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
234+type MockDatagramTransport_Close_Call struct {
235+ *mock.Call
236+}
237+
238+// Close is a helper method to define mock.On call
239+func (_e *MockDatagramTransport_Expecter) Close() *MockDatagramTransport_Close_Call {
240+ return &MockDatagramTransport_Close_Call{Call: _e.mock.On("Close")}
241+}
242+
243+func (_c *MockDatagramTransport_Close_Call) Run(run func()) *MockDatagramTransport_Close_Call {
244+ _c.Call.Run(func(args mock.Arguments) {
245+ run()
246+ })
247+ return _c
248+}
249+
250+func (_c *MockDatagramTransport_Close_Call) Return(err error) *MockDatagramTransport_Close_Call {
251+ _c.Call.Return(err)
252+ return _c
253+}
254+
255+func (_c *MockDatagramTransport_Close_Call) RunAndReturn(run func() error) *MockDatagramTransport_Close_Call {
256+ _c.Call.Return(run)
257+ return _c
258+}
259+
260+// DatagramTransport provides a mock function for the type MockDatagramTransport
261+func (_mock *MockDatagramTransport) DatagramTransport() {
262+ _mock.Called()
263+ return
264+}
265+
266+// MockDatagramTransport_DatagramTransport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DatagramTransport'
267+type MockDatagramTransport_DatagramTransport_Call struct {
268+ *mock.Call
269+}
270+
271+// DatagramTransport is a helper method to define mock.On call
272+func (_e *MockDatagramTransport_Expecter) DatagramTransport() *MockDatagramTransport_DatagramTransport_Call {
273+ return &MockDatagramTransport_DatagramTransport_Call{Call: _e.mock.On("DatagramTransport")}
274+}
275+
276+func (_c *MockDatagramTransport_DatagramTransport_Call) Run(run func()) *MockDatagramTransport_DatagramTransport_Call {
277+ _c.Call.Run(func(args mock.Arguments) {
278+ run()
279+ })
280+ return _c
281+}
282+
283+func (_c *MockDatagramTransport_DatagramTransport_Call) Return() *MockDatagramTransport_DatagramTransport_Call {
284+ _c.Call.Return()
285+ return _c
286+}
287+
288+func (_c *MockDatagramTransport_DatagramTransport_Call) RunAndReturn(run func()) *MockDatagramTransport_DatagramTransport_Call {
289+ _c.Run(run)
290+ return _c
291+}
292+
293+// Recv provides a mock function for the type MockDatagramTransport
294+func (_mock *MockDatagramTransport) Recv() (ports.Frame, error) {
295+ ret := _mock.Called()
296+
297+ if len(ret) == 0 {
298+ panic("no return value specified for Recv")
299+ }
300+
301+ var r0 ports.Frame
302+ var r1 error
303+ if returnFunc, ok := ret.Get(0).(func() (ports.Frame, error)); ok {
304+ return returnFunc()
305+ }
306+ if returnFunc, ok := ret.Get(0).(func() ports.Frame); ok {
307+ r0 = returnFunc()
308+ } else {
309+ r0 = ret.Get(0).(ports.Frame)
310+ }
311+ if returnFunc, ok := ret.Get(1).(func() error); ok {
312+ r1 = returnFunc()
313+ } else {
314+ r1 = ret.Error(1)
315+ }
316+ return r0, r1
317+}
318+
319+// MockDatagramTransport_Recv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recv'
320+type MockDatagramTransport_Recv_Call struct {
321+ *mock.Call
322+}
323+
324+// Recv is a helper method to define mock.On call
325+func (_e *MockDatagramTransport_Expecter) Recv() *MockDatagramTransport_Recv_Call {
326+ return &MockDatagramTransport_Recv_Call{Call: _e.mock.On("Recv")}
327+}
328+
329+func (_c *MockDatagramTransport_Recv_Call) Run(run func()) *MockDatagramTransport_Recv_Call {
330+ _c.Call.Run(func(args mock.Arguments) {
331+ run()
332+ })
333+ return _c
334+}
335+
336+func (_c *MockDatagramTransport_Recv_Call) Return(frame ports.Frame, err error) *MockDatagramTransport_Recv_Call {
337+ _c.Call.Return(frame, err)
338+ return _c
339+}
340+
341+func (_c *MockDatagramTransport_Recv_Call) RunAndReturn(run func() (ports.Frame, error)) *MockDatagramTransport_Recv_Call {
342+ _c.Call.Return(run)
343+ return _c
344+}
345+
346+// Send provides a mock function for the type MockDatagramTransport
347+func (_mock *MockDatagramTransport) Send(frame ports.Frame) error {
348+ ret := _mock.Called(frame)
349+
350+ if len(ret) == 0 {
351+ panic("no return value specified for Send")
352+ }
353+
354+ var r0 error
355+ if returnFunc, ok := ret.Get(0).(func(ports.Frame) error); ok {
356+ r0 = returnFunc(frame)
357+ } else {
358+ r0 = ret.Error(0)
359+ }
360+ return r0
361+}
362+
363+// MockDatagramTransport_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send'
364+type MockDatagramTransport_Send_Call struct {
365+ *mock.Call
366+}
367+
368+// Send is a helper method to define mock.On call
369+// - frame ports.Frame
370+func (_e *MockDatagramTransport_Expecter) Send(frame any) *MockDatagramTransport_Send_Call {
371+ return &MockDatagramTransport_Send_Call{Call: _e.mock.On("Send", frame)}
372+}
373+
374+func (_c *MockDatagramTransport_Send_Call) Run(run func(frame ports.Frame)) *MockDatagramTransport_Send_Call {
375+ _c.Call.Run(func(args mock.Arguments) {
376+ var arg0 ports.Frame
377+ if args[0] != nil {
378+ arg0 = args[0].(ports.Frame)
379+ }
380+ run(
381+ arg0,
382+ )
383+ })
384+ return _c
385+}
386+
387+func (_c *MockDatagramTransport_Send_Call) Return(err error) *MockDatagramTransport_Send_Call {
388+ _c.Call.Return(err)
389+ return _c
390+}
391+
392+func (_c *MockDatagramTransport_Send_Call) RunAndReturn(run func(frame ports.Frame) error) *MockDatagramTransport_Send_Call {
393+ _c.Call.Return(run)
394+ return _c
395+}
396+
397+// NewMockAsyncTransport creates a new instance of MockAsyncTransport. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
398+// The first argument is typically a *testing.T value.
399+func NewMockAsyncTransport(t interface {
400+ mock.TestingT
401+ Cleanup(func())
402+}) *MockAsyncTransport {
403+ mock := &MockAsyncTransport{}
404+ mock.Mock.Test(t)
405+
406+ t.Cleanup(func() { mock.AssertExpectations(t) })
407+
408+ return mock
409+}
410+
411+// MockAsyncTransport is an autogenerated mock type for the AsyncTransport type
412+type MockAsyncTransport struct {
413+ mock.Mock
414+}
415+
416+type MockAsyncTransport_Expecter struct {
417+ mock *mock.Mock
418+}
419+
420+func (_m *MockAsyncTransport) EXPECT() *MockAsyncTransport_Expecter {
421+ return &MockAsyncTransport_Expecter{mock: &_m.Mock}
422+}
423+
424+// SendAsync provides a mock function for the type MockAsyncTransport
425+func (_mock *MockAsyncTransport) SendAsync(frame ports.Frame) error {
426+ ret := _mock.Called(frame)
427+
428+ if len(ret) == 0 {
429+ panic("no return value specified for SendAsync")
430+ }
431+
432+ var r0 error
433+ if returnFunc, ok := ret.Get(0).(func(ports.Frame) error); ok {
434+ r0 = returnFunc(frame)
435+ } else {
436+ r0 = ret.Error(0)
437+ }
438+ return r0
439+}
440+
441+// MockAsyncTransport_SendAsync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendAsync'
442+type MockAsyncTransport_SendAsync_Call struct {
443+ *mock.Call
444+}
445+
446+// SendAsync is a helper method to define mock.On call
447+// - frame ports.Frame
448+func (_e *MockAsyncTransport_Expecter) SendAsync(frame any) *MockAsyncTransport_SendAsync_Call {
449+ return &MockAsyncTransport_SendAsync_Call{Call: _e.mock.On("SendAsync", frame)}
450+}
451+
452+func (_c *MockAsyncTransport_SendAsync_Call) Run(run func(frame ports.Frame)) *MockAsyncTransport_SendAsync_Call {
453+ _c.Call.Run(func(args mock.Arguments) {
454+ var arg0 ports.Frame
455+ if args[0] != nil {
456+ arg0 = args[0].(ports.Frame)
457+ }
458+ run(
459+ arg0,
460+ )
461+ })
462+ return _c
463+}
464+
465+func (_c *MockAsyncTransport_SendAsync_Call) Return(err error) *MockAsyncTransport_SendAsync_Call {
466+ _c.Call.Return(err)
467+ return _c
468+}
469+
470+func (_c *MockAsyncTransport_SendAsync_Call) RunAndReturn(run func(frame ports.Frame) error) *MockAsyncTransport_SendAsync_Call {
471+ _c.Call.Return(run)
472+ return _c
473+}
474+
475+// NewMockOwnedSynchronousTransport creates a new instance of MockOwnedSynchronousTransport. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
476+// The first argument is typically a *testing.T value.
477+func NewMockOwnedSynchronousTransport(t interface {
478+ mock.TestingT
479+ Cleanup(func())
480+}) *MockOwnedSynchronousTransport {
481+ mock := &MockOwnedSynchronousTransport{}
482+ mock.Mock.Test(t)
483+
484+ t.Cleanup(func() { mock.AssertExpectations(t) })
485+
486+ return mock
487+}
488+
489+// MockOwnedSynchronousTransport is an autogenerated mock type for the OwnedSynchronousTransport type
490+type MockOwnedSynchronousTransport struct {
491+ mock.Mock
492+}
493+
494+type MockOwnedSynchronousTransport_Expecter struct {
495+ mock *mock.Mock
496+}
497+
498+func (_m *MockOwnedSynchronousTransport) EXPECT() *MockOwnedSynchronousTransport_Expecter {
499+ return &MockOwnedSynchronousTransport_Expecter{mock: &_m.Mock}
500+}
501+
502+// SendSynchronous provides a mock function for the type MockOwnedSynchronousTransport
503+func (_mock *MockOwnedSynchronousTransport) SendSynchronous(frame ports.Frame) error {
504+ ret := _mock.Called(frame)
505+
506+ if len(ret) == 0 {
507+ panic("no return value specified for SendSynchronous")
508+ }
509+
510+ var r0 error
511+ if returnFunc, ok := ret.Get(0).(func(ports.Frame) error); ok {
512+ r0 = returnFunc(frame)
513+ } else {
514+ r0 = ret.Error(0)
515+ }
516+ return r0
517+}
518+
519+// MockOwnedSynchronousTransport_SendSynchronous_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendSynchronous'
520+type MockOwnedSynchronousTransport_SendSynchronous_Call struct {
521+ *mock.Call
522+}
523+
524+// SendSynchronous is a helper method to define mock.On call
525+// - frame ports.Frame
526+func (_e *MockOwnedSynchronousTransport_Expecter) SendSynchronous(frame any) *MockOwnedSynchronousTransport_SendSynchronous_Call {
527+ return &MockOwnedSynchronousTransport_SendSynchronous_Call{Call: _e.mock.On("SendSynchronous", frame)}
528+}
529+
530+func (_c *MockOwnedSynchronousTransport_SendSynchronous_Call) Run(run func(frame ports.Frame)) *MockOwnedSynchronousTransport_SendSynchronous_Call {
531+ _c.Call.Run(func(args mock.Arguments) {
532+ var arg0 ports.Frame
533+ if args[0] != nil {
534+ arg0 = args[0].(ports.Frame)
535+ }
536+ run(
537+ arg0,
538+ )
539+ })
540+ return _c
541+}
542+
543+func (_c *MockOwnedSynchronousTransport_SendSynchronous_Call) Return(err error) *MockOwnedSynchronousTransport_SendSynchronous_Call {
544+ _c.Call.Return(err)
545+ return _c
546+}
547+
548+func (_c *MockOwnedSynchronousTransport_SendSynchronous_Call) RunAndReturn(run func(frame ports.Frame) error) *MockOwnedSynchronousTransport_SendSynchronous_Call {
549+ _c.Call.Return(run)
550+ return _c
551+}
552+
553+// NewMockDialer creates a new instance of MockDialer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
554+// The first argument is typically a *testing.T value.
555+func NewMockDialer(t interface {
556+ mock.TestingT
557+ Cleanup(func())
558+}) *MockDialer {
559+ mock := &MockDialer{}
560+ mock.Mock.Test(t)
561+
562+ t.Cleanup(func() { mock.AssertExpectations(t) })
563+
564+ return mock
565+}
566+
567+// MockDialer is an autogenerated mock type for the Dialer type
568+type MockDialer struct {
569+ mock.Mock
570+}
571+
572+type MockDialer_Expecter struct {
573+ mock *mock.Mock
574+}
575+
576+func (_m *MockDialer) EXPECT() *MockDialer_Expecter {
577+ return &MockDialer_Expecter{mock: &_m.Mock}
578+}
579+
580+// Dial provides a mock function for the type MockDialer
581+func (_mock *MockDialer) Dial(ctx context.Context) (ports.Transport, error) {
582+ ret := _mock.Called(ctx)
583+
584+ if len(ret) == 0 {
585+ panic("no return value specified for Dial")
586+ }
587+
588+ var r0 ports.Transport
589+ var r1 error
590+ if returnFunc, ok := ret.Get(0).(func(context.Context) (ports.Transport, error)); ok {
591+ return returnFunc(ctx)
592+ }
593+ if returnFunc, ok := ret.Get(0).(func(context.Context) ports.Transport); ok {
594+ r0 = returnFunc(ctx)
595+ } else {
596+ if ret.Get(0) != nil {
597+ r0 = ret.Get(0).(ports.Transport)
598+ }
599+ }
600+ if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
601+ r1 = returnFunc(ctx)
602+ } else {
603+ r1 = ret.Error(1)
604+ }
605+ return r0, r1
606+}
607+
608+// MockDialer_Dial_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Dial'
609+type MockDialer_Dial_Call struct {
610+ *mock.Call
611+}
612+
613+// Dial is a helper method to define mock.On call
614+// - ctx context.Context
615+func (_e *MockDialer_Expecter) Dial(ctx any) *MockDialer_Dial_Call {
616+ return &MockDialer_Dial_Call{Call: _e.mock.On("Dial", ctx)}
617+}
618+
619+func (_c *MockDialer_Dial_Call) Run(run func(ctx context.Context)) *MockDialer_Dial_Call {
620+ _c.Call.Run(func(args mock.Arguments) {
621+ var arg0 context.Context
622+ if args[0] != nil {
623+ arg0 = args[0].(context.Context)
624+ }
625+ run(
626+ arg0,
627+ )
628+ })
629+ return _c
630+}
631+
632+func (_c *MockDialer_Dial_Call) Return(transport ports.Transport, err error) *MockDialer_Dial_Call {
633+ _c.Call.Return(transport, err)
634+ return _c
635+}
636+
637+func (_c *MockDialer_Dial_Call) RunAndReturn(run func(ctx context.Context) (ports.Transport, error)) *MockDialer_Dial_Call {
638+ _c.Call.Return(run)
639+ return _c
640+}
641+
642+// NewMockListener creates a new instance of MockListener. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
643+// The first argument is typically a *testing.T value.
644+func NewMockListener(t interface {
645+ mock.TestingT
646+ Cleanup(func())
647+}) *MockListener {
648+ mock := &MockListener{}
649+ mock.Mock.Test(t)
650+
651+ t.Cleanup(func() { mock.AssertExpectations(t) })
652+
653+ return mock
654+}
655+
656+// MockListener is an autogenerated mock type for the Listener type
657+type MockListener struct {
658+ mock.Mock
659+}
660+
661+type MockListener_Expecter struct {
662+ mock *mock.Mock
663+}
664+
665+func (_m *MockListener) EXPECT() *MockListener_Expecter {
666+ return &MockListener_Expecter{mock: &_m.Mock}
667+}
668+
669+// Accept provides a mock function for the type MockListener
670+func (_mock *MockListener) Accept() (ports.Transport, error) {
671+ ret := _mock.Called()
672+
673+ if len(ret) == 0 {
674+ panic("no return value specified for Accept")
675+ }
676+
677+ var r0 ports.Transport
678+ var r1 error
679+ if returnFunc, ok := ret.Get(0).(func() (ports.Transport, error)); ok {
680+ return returnFunc()
681+ }
682+ if returnFunc, ok := ret.Get(0).(func() ports.Transport); ok {
683+ r0 = returnFunc()
684+ } else {
685+ if ret.Get(0) != nil {
686+ r0 = ret.Get(0).(ports.Transport)
687+ }
688+ }
689+ if returnFunc, ok := ret.Get(1).(func() error); ok {
690+ r1 = returnFunc()
691+ } else {
692+ r1 = ret.Error(1)
693+ }
694+ return r0, r1
695+}
696+
697+// MockListener_Accept_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Accept'
698+type MockListener_Accept_Call struct {
699+ *mock.Call
700+}
701+
702+// Accept is a helper method to define mock.On call
703+func (_e *MockListener_Expecter) Accept() *MockListener_Accept_Call {
704+ return &MockListener_Accept_Call{Call: _e.mock.On("Accept")}
705+}
706+
707+func (_c *MockListener_Accept_Call) Run(run func()) *MockListener_Accept_Call {
708+ _c.Call.Run(func(args mock.Arguments) {
709+ run()
710+ })
711+ return _c
712+}
713+
714+func (_c *MockListener_Accept_Call) Return(transport ports.Transport, err error) *MockListener_Accept_Call {
715+ _c.Call.Return(transport, err)
716+ return _c
717+}
718+
719+func (_c *MockListener_Accept_Call) RunAndReturn(run func() (ports.Transport, error)) *MockListener_Accept_Call {
720+ _c.Call.Return(run)
721+ return _c
722+}
723+
724+// Addr provides a mock function for the type MockListener
725+func (_mock *MockListener) Addr() string {
726+ ret := _mock.Called()
727+
728+ if len(ret) == 0 {
729+ panic("no return value specified for Addr")
730+ }
731+
732+ var r0 string
733+ if returnFunc, ok := ret.Get(0).(func() string); ok {
734+ r0 = returnFunc()
735+ } else {
736+ r0 = ret.Get(0).(string)
737+ }
738+ return r0
739+}
740+
741+// MockListener_Addr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Addr'
742+type MockListener_Addr_Call struct {
743+ *mock.Call
744+}
745+
746+// Addr is a helper method to define mock.On call
747+func (_e *MockListener_Expecter) Addr() *MockListener_Addr_Call {
748+ return &MockListener_Addr_Call{Call: _e.mock.On("Addr")}
749+}
750+
751+func (_c *MockListener_Addr_Call) Run(run func()) *MockListener_Addr_Call {
752+ _c.Call.Run(func(args mock.Arguments) {
753+ run()
754+ })
755+ return _c
756+}
757+
758+func (_c *MockListener_Addr_Call) Return(s string) *MockListener_Addr_Call {
759+ _c.Call.Return(s)
760+ return _c
761+}
762+
763+func (_c *MockListener_Addr_Call) RunAndReturn(run func() string) *MockListener_Addr_Call {
764+ _c.Call.Return(run)
765+ return _c
766+}
767+
768+// Close provides a mock function for the type MockListener
769+func (_mock *MockListener) Close() error {
770+ ret := _mock.Called()
771+
772+ if len(ret) == 0 {
773+ panic("no return value specified for Close")
774+ }
775+
776+ var r0 error
777+ if returnFunc, ok := ret.Get(0).(func() error); ok {
778+ r0 = returnFunc()
779+ } else {
780+ r0 = ret.Error(0)
781+ }
782+ return r0
783+}
784+
785+// MockListener_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
786+type MockListener_Close_Call struct {
787+ *mock.Call
788+}
789+
790+// Close is a helper method to define mock.On call
791+func (_e *MockListener_Expecter) Close() *MockListener_Close_Call {
792+ return &MockListener_Close_Call{Call: _e.mock.On("Close")}
793+}
794+
795+func (_c *MockListener_Close_Call) Run(run func()) *MockListener_Close_Call {
796+ _c.Call.Run(func(args mock.Arguments) {
797+ run()
798+ })
799+ return _c
800+}
801+
802+func (_c *MockListener_Close_Call) Return(err error) *MockListener_Close_Call {
803+ _c.Call.Return(err)
804+ return _c
805+}
806+
807+func (_c *MockListener_Close_Call) RunAndReturn(run func() error) *MockListener_Close_Call {
808+ _c.Call.Return(run)
809+ return _c
810+}
@@ -0,0 +1,810 @@
1+// Code generated by mockery; DO NOT EDIT.
2+// github.com/vektra/mockery
3+// template: testify
4+
5+package portsmocks
6+
7+import (
8+ "context"
9+
10+ "github.com/bnema/vev/internal/ports"
11+ mock "github.com/stretchr/testify/mock"
12+)
13+
14+// NewMockTransport creates a new instance of MockTransport. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
15+// The first argument is typically a *testing.T value.
16+func NewMockTransport(t interface {
17+ mock.TestingT
18+ Cleanup(func())
19+}) *MockTransport {
20+ mock := &MockTransport{}
21+ mock.Mock.Test(t)
22+
23+ t.Cleanup(func() { mock.AssertExpectations(t) })
24+
25+ return mock
26+}
27+
28+// MockTransport is an autogenerated mock type for the Transport type
29+type MockTransport struct {
30+ mock.Mock
31+}
32+
33+type MockTransport_Expecter struct {
34+ mock *mock.Mock
35+}
36+
37+func (_m *MockTransport) EXPECT() *MockTransport_Expecter {
38+ return &MockTransport_Expecter{mock: &_m.Mock}
39+}
40+
41+// Close provides a mock function for the type MockTransport
42+func (_mock *MockTransport) Close() error {
43+ ret := _mock.Called()
44+
45+ if len(ret) == 0 {
46+ panic("no return value specified for Close")
47+ }
48+
49+ var r0 error
50+ if returnFunc, ok := ret.Get(0).(func() error); ok {
51+ r0 = returnFunc()
52+ } else {
53+ r0 = ret.Error(0)
54+ }
55+ return r0
56+}
57+
58+// MockTransport_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
59+type MockTransport_Close_Call struct {
60+ *mock.Call
61+}
62+
63+// Close is a helper method to define mock.On call
64+func (_e *MockTransport_Expecter) Close() *MockTransport_Close_Call {
65+ return &MockTransport_Close_Call{Call: _e.mock.On("Close")}
66+}
67+
68+func (_c *MockTransport_Close_Call) Run(run func()) *MockTransport_Close_Call {
69+ _c.Call.Run(func(args mock.Arguments) {
70+ run()
71+ })
72+ return _c
73+}
74+
75+func (_c *MockTransport_Close_Call) Return(err error) *MockTransport_Close_Call {
76+ _c.Call.Return(err)
77+ return _c
78+}
79+
80+func (_c *MockTransport_Close_Call) RunAndReturn(run func() error) *MockTransport_Close_Call {
81+ _c.Call.Return(run)
82+ return _c
83+}
84+
85+// Recv provides a mock function for the type MockTransport
86+func (_mock *MockTransport) Recv() (ports.Frame, error) {
87+ ret := _mock.Called()
88+
89+ if len(ret) == 0 {
90+ panic("no return value specified for Recv")
91+ }
92+
93+ var r0 ports.Frame
94+ var r1 error
95+ if returnFunc, ok := ret.Get(0).(func() (ports.Frame, error)); ok {
96+ return returnFunc()
97+ }
98+ if returnFunc, ok := ret.Get(0).(func() ports.Frame); ok {
99+ r0 = returnFunc()
100+ } else {
101+ r0 = ret.Get(0).(ports.Frame)
102+ }
103+ if returnFunc, ok := ret.Get(1).(func() error); ok {
104+ r1 = returnFunc()
105+ } else {
106+ r1 = ret.Error(1)
107+ }
108+ return r0, r1
109+}
110+
111+// MockTransport_Recv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recv'
112+type MockTransport_Recv_Call struct {
113+ *mock.Call
114+}
115+
116+// Recv is a helper method to define mock.On call
117+func (_e *MockTransport_Expecter) Recv() *MockTransport_Recv_Call {
118+ return &MockTransport_Recv_Call{Call: _e.mock.On("Recv")}
119+}
120+
121+func (_c *MockTransport_Recv_Call) Run(run func()) *MockTransport_Recv_Call {
122+ _c.Call.Run(func(args mock.Arguments) {
123+ run()
124+ })
125+ return _c
126+}
127+
128+func (_c *MockTransport_Recv_Call) Return(frame ports.Frame, err error) *MockTransport_Recv_Call {
129+ _c.Call.Return(frame, err)
130+ return _c
131+}
132+
133+func (_c *MockTransport_Recv_Call) RunAndReturn(run func() (ports.Frame, error)) *MockTransport_Recv_Call {
134+ _c.Call.Return(run)
135+ return _c
136+}
137+
138+// Send provides a mock function for the type MockTransport
139+func (_mock *MockTransport) Send(frame ports.Frame) error {
140+ ret := _mock.Called(frame)
141+
142+ if len(ret) == 0 {
143+ panic("no return value specified for Send")
144+ }
145+
146+ var r0 error
147+ if returnFunc, ok := ret.Get(0).(func(ports.Frame) error); ok {
148+ r0 = returnFunc(frame)
149+ } else {
150+ r0 = ret.Error(0)
151+ }
152+ return r0
153+}
154+
155+// MockTransport_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send'
156+type MockTransport_Send_Call struct {
157+ *mock.Call
158+}
159+
160+// Send is a helper method to define mock.On call
161+// - frame ports.Frame
162+func (_e *MockTransport_Expecter) Send(frame any) *MockTransport_Send_Call {
163+ return &MockTransport_Send_Call{Call: _e.mock.On("Send", frame)}
164+}
165+
166+func (_c *MockTransport_Send_Call) Run(run func(frame ports.Frame)) *MockTransport_Send_Call {
167+ _c.Call.Run(func(args mock.Arguments) {
168+ var arg0 ports.Frame
169+ if args[0] != nil {
170+ arg0 = args[0].(ports.Frame)
171+ }
172+ run(
173+ arg0,
174+ )
175+ })
176+ return _c
177+}
178+
179+func (_c *MockTransport_Send_Call) Return(err error) *MockTransport_Send_Call {
180+ _c.Call.Return(err)
181+ return _c
182+}
183+
184+func (_c *MockTransport_Send_Call) RunAndReturn(run func(frame ports.Frame) error) *MockTransport_Send_Call {
185+ _c.Call.Return(run)
186+ return _c
187+}
188+
189+// NewMockDatagramTransport creates a new instance of MockDatagramTransport. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
190+// The first argument is typically a *testing.T value.
191+func NewMockDatagramTransport(t interface {
192+ mock.TestingT
193+ Cleanup(func())
194+}) *MockDatagramTransport {
195+ mock := &MockDatagramTransport{}
196+ mock.Mock.Test(t)
197+
198+ t.Cleanup(func() { mock.AssertExpectations(t) })
199+
200+ return mock
201+}
202+
203+// MockDatagramTransport is an autogenerated mock type for the DatagramTransport type
204+type MockDatagramTransport struct {
205+ mock.Mock
206+}
207+
208+type MockDatagramTransport_Expecter struct {
209+ mock *mock.Mock
210+}
211+
212+func (_m *MockDatagramTransport) EXPECT() *MockDatagramTransport_Expecter {
213+ return &MockDatagramTransport_Expecter{mock: &_m.Mock}
214+}
215+
216+// Close provides a mock function for the type MockDatagramTransport
217+func (_mock *MockDatagramTransport) Close() error {
218+ ret := _mock.Called()
219+
220+ if len(ret) == 0 {
221+ panic("no return value specified for Close")
222+ }
223+
224+ var r0 error
225+ if returnFunc, ok := ret.Get(0).(func() error); ok {
226+ r0 = returnFunc()
227+ } else {
228+ r0 = ret.Error(0)
229+ }
230+ return r0
231+}
232+
233+// MockDatagramTransport_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
234+type MockDatagramTransport_Close_Call struct {
235+ *mock.Call
236+}
237+
238+// Close is a helper method to define mock.On call
239+func (_e *MockDatagramTransport_Expecter) Close() *MockDatagramTransport_Close_Call {
240+ return &MockDatagramTransport_Close_Call{Call: _e.mock.On("Close")}
241+}
242+
243+func (_c *MockDatagramTransport_Close_Call) Run(run func()) *MockDatagramTransport_Close_Call {
244+ _c.Call.Run(func(args mock.Arguments) {
245+ run()
246+ })
247+ return _c
248+}
249+
250+func (_c *MockDatagramTransport_Close_Call) Return(err error) *MockDatagramTransport_Close_Call {
251+ _c.Call.Return(err)
252+ return _c
253+}
254+
255+func (_c *MockDatagramTransport_Close_Call) RunAndReturn(run func() error) *MockDatagramTransport_Close_Call {
256+ _c.Call.Return(run)
257+ return _c
258+}
259+
260+// DatagramTransport provides a mock function for the type MockDatagramTransport
261+func (_mock *MockDatagramTransport) DatagramTransport() {
262+ _mock.Called()
263+ return
264+}
265+
266+// MockDatagramTransport_DatagramTransport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DatagramTransport'
267+type MockDatagramTransport_DatagramTransport_Call struct {
268+ *mock.Call
269+}
270+
271+// DatagramTransport is a helper method to define mock.On call
272+func (_e *MockDatagramTransport_Expecter) DatagramTransport() *MockDatagramTransport_DatagramTransport_Call {
273+ return &MockDatagramTransport_DatagramTransport_Call{Call: _e.mock.On("DatagramTransport")}
274+}
275+
276+func (_c *MockDatagramTransport_DatagramTransport_Call) Run(run func()) *MockDatagramTransport_DatagramTransport_Call {
277+ _c.Call.Run(func(args mock.Arguments) {
278+ run()
279+ })
280+ return _c
281+}
282+
283+func (_c *MockDatagramTransport_DatagramTransport_Call) Return() *MockDatagramTransport_DatagramTransport_Call {
284+ _c.Call.Return()
285+ return _c
286+}
287+
288+func (_c *MockDatagramTransport_DatagramTransport_Call) RunAndReturn(run func()) *MockDatagramTransport_DatagramTransport_Call {
289+ _c.Run(run)
290+ return _c
291+}
292+
293+// Recv provides a mock function for the type MockDatagramTransport
294+func (_mock *MockDatagramTransport) Recv() (ports.Frame, error) {
295+ ret := _mock.Called()
296+
297+ if len(ret) == 0 {
298+ panic("no return value specified for Recv")
299+ }
300+
301+ var r0 ports.Frame
302+ var r1 error
303+ if returnFunc, ok := ret.Get(0).(func() (ports.Frame, error)); ok {
304+ return returnFunc()
305+ }
306+ if returnFunc, ok := ret.Get(0).(func() ports.Frame); ok {
307+ r0 = returnFunc()
308+ } else {
309+ r0 = ret.Get(0).(ports.Frame)
310+ }
311+ if returnFunc, ok := ret.Get(1).(func() error); ok {
312+ r1 = returnFunc()
313+ } else {
314+ r1 = ret.Error(1)
315+ }
316+ return r0, r1
317+}
318+
319+// MockDatagramTransport_Recv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recv'
320+type MockDatagramTransport_Recv_Call struct {
321+ *mock.Call
322+}
323+
324+// Recv is a helper method to define mock.On call
325+func (_e *MockDatagramTransport_Expecter) Recv() *MockDatagramTransport_Recv_Call {
326+ return &MockDatagramTransport_Recv_Call{Call: _e.mock.On("Recv")}
327+}
328+
329+func (_c *MockDatagramTransport_Recv_Call) Run(run func()) *MockDatagramTransport_Recv_Call {
330+ _c.Call.Run(func(args mock.Arguments) {
331+ run()
332+ })
333+ return _c
334+}
335+
336+func (_c *MockDatagramTransport_Recv_Call) Return(frame ports.Frame, err error) *MockDatagramTransport_Recv_Call {
337+ _c.Call.Return(frame, err)
338+ return _c
339+}
340+
341+func (_c *MockDatagramTransport_Recv_Call) RunAndReturn(run func() (ports.Frame, error)) *MockDatagramTransport_Recv_Call {
342+ _c.Call.Return(run)
343+ return _c
344+}
345+
346+// Send provides a mock function for the type MockDatagramTransport
347+func (_mock *MockDatagramTransport) Send(frame ports.Frame) error {
348+ ret := _mock.Called(frame)
349+
350+ if len(ret) == 0 {
351+ panic("no return value specified for Send")
352+ }
353+
354+ var r0 error
355+ if returnFunc, ok := ret.Get(0).(func(ports.Frame) error); ok {
356+ r0 = returnFunc(frame)
357+ } else {
358+ r0 = ret.Error(0)
359+ }
360+ return r0
361+}
362+
363+// MockDatagramTransport_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send'
364+type MockDatagramTransport_Send_Call struct {
365+ *mock.Call
366+}
367+
368+// Send is a helper method to define mock.On call
369+// - frame ports.Frame
370+func (_e *MockDatagramTransport_Expecter) Send(frame any) *MockDatagramTransport_Send_Call {
371+ return &MockDatagramTransport_Send_Call{Call: _e.mock.On("Send", frame)}
372+}
373+
374+func (_c *MockDatagramTransport_Send_Call) Run(run func(frame ports.Frame)) *MockDatagramTransport_Send_Call {
375+ _c.Call.Run(func(args mock.Arguments) {
376+ var arg0 ports.Frame
377+ if args[0] != nil {
378+ arg0 = args[0].(ports.Frame)
379+ }
380+ run(
381+ arg0,
382+ )
383+ })
384+ return _c
385+}
386+
387+func (_c *MockDatagramTransport_Send_Call) Return(err error) *MockDatagramTransport_Send_Call {
388+ _c.Call.Return(err)
389+ return _c
390+}
391+
392+func (_c *MockDatagramTransport_Send_Call) RunAndReturn(run func(frame ports.Frame) error) *MockDatagramTransport_Send_Call {
393+ _c.Call.Return(run)
394+ return _c
395+}
396+
397+// NewMockAsyncTransport creates a new instance of MockAsyncTransport. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
398+// The first argument is typically a *testing.T value.
399+func NewMockAsyncTransport(t interface {
400+ mock.TestingT
401+ Cleanup(func())
402+}) *MockAsyncTransport {
403+ mock := &MockAsyncTransport{}
404+ mock.Mock.Test(t)
405+
406+ t.Cleanup(func() { mock.AssertExpectations(t) })
407+
408+ return mock
409+}
410+
411+// MockAsyncTransport is an autogenerated mock type for the AsyncTransport type
412+type MockAsyncTransport struct {
413+ mock.Mock
414+}
415+
416+type MockAsyncTransport_Expecter struct {
417+ mock *mock.Mock
418+}
419+
420+func (_m *MockAsyncTransport) EXPECT() *MockAsyncTransport_Expecter {
421+ return &MockAsyncTransport_Expecter{mock: &_m.Mock}
422+}
423+
424+// SendAsync provides a mock function for the type MockAsyncTransport
425+func (_mock *MockAsyncTransport) SendAsync(frame ports.Frame) error {
426+ ret := _mock.Called(frame)
427+
428+ if len(ret) == 0 {
429+ panic("no return value specified for SendAsync")
430+ }
431+
432+ var r0 error
433+ if returnFunc, ok := ret.Get(0).(func(ports.Frame) error); ok {
434+ r0 = returnFunc(frame)
435+ } else {
436+ r0 = ret.Error(0)
437+ }
438+ return r0
439+}
440+
441+// MockAsyncTransport_SendAsync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendAsync'
442+type MockAsyncTransport_SendAsync_Call struct {
443+ *mock.Call
444+}
445+
446+// SendAsync is a helper method to define mock.On call
447+// - frame ports.Frame
448+func (_e *MockAsyncTransport_Expecter) SendAsync(frame any) *MockAsyncTransport_SendAsync_Call {
449+ return &MockAsyncTransport_SendAsync_Call{Call: _e.mock.On("SendAsync", frame)}
450+}
451+
452+func (_c *MockAsyncTransport_SendAsync_Call) Run(run func(frame ports.Frame)) *MockAsyncTransport_SendAsync_Call {
453+ _c.Call.Run(func(args mock.Arguments) {
454+ var arg0 ports.Frame
455+ if args[0] != nil {
456+ arg0 = args[0].(ports.Frame)
457+ }
458+ run(
459+ arg0,
460+ )
461+ })
462+ return _c
463+}
464+
465+func (_c *MockAsyncTransport_SendAsync_Call) Return(err error) *MockAsyncTransport_SendAsync_Call {
466+ _c.Call.Return(err)
467+ return _c
468+}
469+
470+func (_c *MockAsyncTransport_SendAsync_Call) RunAndReturn(run func(frame ports.Frame) error) *MockAsyncTransport_SendAsync_Call {
471+ _c.Call.Return(run)
472+ return _c
473+}
474+
475+// NewMockOwnedSynchronousTransport creates a new instance of MockOwnedSynchronousTransport. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
476+// The first argument is typically a *testing.T value.
477+func NewMockOwnedSynchronousTransport(t interface {
478+ mock.TestingT
479+ Cleanup(func())
480+}) *MockOwnedSynchronousTransport {
481+ mock := &MockOwnedSynchronousTransport{}
482+ mock.Mock.Test(t)
483+
484+ t.Cleanup(func() { mock.AssertExpectations(t) })
485+
486+ return mock
487+}
488+
489+// MockOwnedSynchronousTransport is an autogenerated mock type for the OwnedSynchronousTransport type
490+type MockOwnedSynchronousTransport struct {
491+ mock.Mock
492+}
493+
494+type MockOwnedSynchronousTransport_Expecter struct {
495+ mock *mock.Mock
496+}
497+
498+func (_m *MockOwnedSynchronousTransport) EXPECT() *MockOwnedSynchronousTransport_Expecter {
499+ return &MockOwnedSynchronousTransport_Expecter{mock: &_m.Mock}
500+}
501+
502+// SendSynchronous provides a mock function for the type MockOwnedSynchronousTransport
503+func (_mock *MockOwnedSynchronousTransport) SendSynchronous(frame ports.Frame) error {
504+ ret := _mock.Called(frame)
505+
506+ if len(ret) == 0 {
507+ panic("no return value specified for SendSynchronous")
508+ }
509+
510+ var r0 error
511+ if returnFunc, ok := ret.Get(0).(func(ports.Frame) error); ok {
512+ r0 = returnFunc(frame)
513+ } else {
514+ r0 = ret.Error(0)
515+ }
516+ return r0
517+}
518+
519+// MockOwnedSynchronousTransport_SendSynchronous_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendSynchronous'
520+type MockOwnedSynchronousTransport_SendSynchronous_Call struct {
521+ *mock.Call
522+}
523+
524+// SendSynchronous is a helper method to define mock.On call
525+// - frame ports.Frame
526+func (_e *MockOwnedSynchronousTransport_Expecter) SendSynchronous(frame any) *MockOwnedSynchronousTransport_SendSynchronous_Call {
527+ return &MockOwnedSynchronousTransport_SendSynchronous_Call{Call: _e.mock.On("SendSynchronous", frame)}
528+}
529+
530+func (_c *MockOwnedSynchronousTransport_SendSynchronous_Call) Run(run func(frame ports.Frame)) *MockOwnedSynchronousTransport_SendSynchronous_Call {
531+ _c.Call.Run(func(args mock.Arguments) {
532+ var arg0 ports.Frame
533+ if args[0] != nil {
534+ arg0 = args[0].(ports.Frame)
535+ }
536+ run(
537+ arg0,
538+ )
539+ })
540+ return _c
541+}
542+
543+func (_c *MockOwnedSynchronousTransport_SendSynchronous_Call) Return(err error) *MockOwnedSynchronousTransport_SendSynchronous_Call {
544+ _c.Call.Return(err)
545+ return _c
546+}
547+
548+func (_c *MockOwnedSynchronousTransport_SendSynchronous_Call) RunAndReturn(run func(frame ports.Frame) error) *MockOwnedSynchronousTransport_SendSynchronous_Call {
549+ _c.Call.Return(run)
550+ return _c
551+}
552+
553+// NewMockDialer creates a new instance of MockDialer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
554+// The first argument is typically a *testing.T value.
555+func NewMockDialer(t interface {
556+ mock.TestingT
557+ Cleanup(func())
558+}) *MockDialer {
559+ mock := &MockDialer{}
560+ mock.Mock.Test(t)
561+
562+ t.Cleanup(func() { mock.AssertExpectations(t) })
563+
564+ return mock
565+}
566+
567+// MockDialer is an autogenerated mock type for the Dialer type
568+type MockDialer struct {
569+ mock.Mock
570+}
571+
572+type MockDialer_Expecter struct {
573+ mock *mock.Mock
574+}
575+
576+func (_m *MockDialer) EXPECT() *MockDialer_Expecter {
577+ return &MockDialer_Expecter{mock: &_m.Mock}
578+}
579+
580+// Dial provides a mock function for the type MockDialer
581+func (_mock *MockDialer) Dial(ctx context.Context) (ports.Transport, error) {
582+ ret := _mock.Called(ctx)
583+
584+ if len(ret) == 0 {
585+ panic("no return value specified for Dial")
586+ }
587+
588+ var r0 ports.Transport
589+ var r1 error
590+ if returnFunc, ok := ret.Get(0).(func(context.Context) (ports.Transport, error)); ok {
591+ return returnFunc(ctx)
592+ }
593+ if returnFunc, ok := ret.Get(0).(func(context.Context) ports.Transport); ok {
594+ r0 = returnFunc(ctx)
595+ } else {
596+ if ret.Get(0) != nil {
597+ r0 = ret.Get(0).(ports.Transport)
598+ }
599+ }
600+ if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
601+ r1 = returnFunc(ctx)
602+ } else {
603+ r1 = ret.Error(1)
604+ }
605+ return r0, r1
606+}
607+
608+// MockDialer_Dial_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Dial'
609+type MockDialer_Dial_Call struct {
610+ *mock.Call
611+}
612+
613+// Dial is a helper method to define mock.On call
614+// - ctx context.Context
615+func (_e *MockDialer_Expecter) Dial(ctx any) *MockDialer_Dial_Call {
616+ return &MockDialer_Dial_Call{Call: _e.mock.On("Dial", ctx)}
617+}
618+
619+func (_c *MockDialer_Dial_Call) Run(run func(ctx context.Context)) *MockDialer_Dial_Call {
620+ _c.Call.Run(func(args mock.Arguments) {
621+ var arg0 context.Context
622+ if args[0] != nil {
623+ arg0 = args[0].(context.Context)
624+ }
625+ run(
626+ arg0,
627+ )
628+ })
629+ return _c
630+}
631+
632+func (_c *MockDialer_Dial_Call) Return(transport ports.Transport, err error) *MockDialer_Dial_Call {
633+ _c.Call.Return(transport, err)
634+ return _c
635+}
636+
637+func (_c *MockDialer_Dial_Call) RunAndReturn(run func(ctx context.Context) (ports.Transport, error)) *MockDialer_Dial_Call {
638+ _c.Call.Return(run)
639+ return _c
640+}
641+
642+// NewMockListener creates a new instance of MockListener. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
643+// The first argument is typically a *testing.T value.
644+func NewMockListener(t interface {
645+ mock.TestingT
646+ Cleanup(func())
647+}) *MockListener {
648+ mock := &MockListener{}
649+ mock.Mock.Test(t)
650+
651+ t.Cleanup(func() { mock.AssertExpectations(t) })
652+
653+ return mock
654+}
655+
656+// MockListener is an autogenerated mock type for the Listener type
657+type MockListener struct {
658+ mock.Mock
659+}
660+
661+type MockListener_Expecter struct {
662+ mock *mock.Mock
663+}
664+
665+func (_m *MockListener) EXPECT() *MockListener_Expecter {
666+ return &MockListener_Expecter{mock: &_m.Mock}
667+}
668+
669+// Accept provides a mock function for the type MockListener
670+func (_mock *MockListener) Accept() (ports.Transport, error) {
671+ ret := _mock.Called()
672+
673+ if len(ret) == 0 {
674+ panic("no return value specified for Accept")
675+ }
676+
677+ var r0 ports.Transport
678+ var r1 error
679+ if returnFunc, ok := ret.Get(0).(func() (ports.Transport, error)); ok {
680+ return returnFunc()
681+ }
682+ if returnFunc, ok := ret.Get(0).(func() ports.Transport); ok {
683+ r0 = returnFunc()
684+ } else {
685+ if ret.Get(0) != nil {
686+ r0 = ret.Get(0).(ports.Transport)
687+ }
688+ }
689+ if returnFunc, ok := ret.Get(1).(func() error); ok {
690+ r1 = returnFunc()
691+ } else {
692+ r1 = ret.Error(1)
693+ }
694+ return r0, r1
695+}
696+
697+// MockListener_Accept_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Accept'
698+type MockListener_Accept_Call struct {
699+ *mock.Call
700+}
701+
702+// Accept is a helper method to define mock.On call
703+func (_e *MockListener_Expecter) Accept() *MockListener_Accept_Call {
704+ return &MockListener_Accept_Call{Call: _e.mock.On("Accept")}
705+}
706+
707+func (_c *MockListener_Accept_Call) Run(run func()) *MockListener_Accept_Call {
708+ _c.Call.Run(func(args mock.Arguments) {
709+ run()
710+ })
711+ return _c
712+}
713+
714+func (_c *MockListener_Accept_Call) Return(transport ports.Transport, err error) *MockListener_Accept_Call {
715+ _c.Call.Return(transport, err)
716+ return _c
717+}
718+
719+func (_c *MockListener_Accept_Call) RunAndReturn(run func() (ports.Transport, error)) *MockListener_Accept_Call {
720+ _c.Call.Return(run)
721+ return _c
722+}
723+
724+// Addr provides a mock function for the type MockListener
725+func (_mock *MockListener) Addr() string {
726+ ret := _mock.Called()
727+
728+ if len(ret) == 0 {
729+ panic("no return value specified for Addr")
730+ }
731+
732+ var r0 string
733+ if returnFunc, ok := ret.Get(0).(func() string); ok {
734+ r0 = returnFunc()
735+ } else {
736+ r0 = ret.Get(0).(string)
737+ }
738+ return r0
739+}
740+
741+// MockListener_Addr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Addr'
742+type MockListener_Addr_Call struct {
743+ *mock.Call
744+}
745+
746+// Addr is a helper method to define mock.On call
747+func (_e *MockListener_Expecter) Addr() *MockListener_Addr_Call {
748+ return &MockListener_Addr_Call{Call: _e.mock.On("Addr")}
749+}
750+
751+func (_c *MockListener_Addr_Call) Run(run func()) *MockListener_Addr_Call {
752+ _c.Call.Run(func(args mock.Arguments) {
753+ run()
754+ })
755+ return _c
756+}
757+
758+func (_c *MockListener_Addr_Call) Return(s string) *MockListener_Addr_Call {
759+ _c.Call.Return(s)
760+ return _c
761+}
762+
763+func (_c *MockListener_Addr_Call) RunAndReturn(run func() string) *MockListener_Addr_Call {
764+ _c.Call.Return(run)
765+ return _c
766+}
767+
768+// Close provides a mock function for the type MockListener
769+func (_mock *MockListener) Close() error {
770+ ret := _mock.Called()
771+
772+ if len(ret) == 0 {
773+ panic("no return value specified for Close")
774+ }
775+
776+ var r0 error
777+ if returnFunc, ok := ret.Get(0).(func() error); ok {
778+ r0 = returnFunc()
779+ } else {
780+ r0 = ret.Error(0)
781+ }
782+ return r0
783+}
784+
785+// MockListener_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
786+type MockListener_Close_Call struct {
787+ *mock.Call
788+}
789+
790+// Close is a helper method to define mock.On call
791+func (_e *MockListener_Expecter) Close() *MockListener_Close_Call {
792+ return &MockListener_Close_Call{Call: _e.mock.On("Close")}
793+}
794+
795+func (_c *MockListener_Close_Call) Run(run func()) *MockListener_Close_Call {
796+ _c.Call.Run(func(args mock.Arguments) {
797+ run()
798+ })
799+ return _c
800+}
801+
802+func (_c *MockListener_Close_Call) Return(err error) *MockListener_Close_Call {
803+ _c.Call.Return(err)
804+ return _c
805+}
806+
807+func (_c *MockListener_Close_Call) RunAndReturn(run func() error) *MockListener_Close_Call {
808+ _c.Call.Return(run)
809+ return _c
810+}

Keyboard shortcuts

Single-key shortcuts are on. ctrl k and esc work whatever this says.

ctrl k :
go to a section, branch, tag, file or repository
?
this list
j k
move the row cursor down / up
enter
open the row under the cursor; on Files, a directory opens or closes in place
↑ ↓ ← → home end
in the file tree (focus on a row): previous / next row, close / open a directory or go to its parent / first entry, first / last row. They never open a file
l h
on Files: open a directory or a file / close a directory or go up to its parent, then to the parent page. Elsewhere: into the side panel (on a merge request, its files) / back to the content; there j k move between its controls
g g G
first / last row
/
filter the list; on Files, find a file anywhere in the repository (esc clears, enter opens the best match)
b
switch branch or tag
g s g f g c g b g m g i g r g a
tabs: summary, files, commits, branches & tags, merge requests, issues, releases, actions (when available)
g h
home
w
wide mode: use the whole width of the screen, or not (remembered)
y
copy a permalink pinned to the commit
d u x
diff: split / unified / collapse or expand all
e E
diff: the whole file in view / every file, with the lines the hunks hide
n
merge request: next note in the diff
esc
close a dialog, leave a field

Branches 12

Tags 11

↑↓ moveenter openesc close