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+}
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+}
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+}
D internal/ports/mocks/mocks.go +0 -3198
@@ -1,3198 +0,0 @@
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- "io"
10- "log/slog"
11- "time"
12-
13- "github.com/bnema/vev/internal/domain"
14- "github.com/bnema/vev/internal/ports"
15- mock "github.com/stretchr/testify/mock"
16-)
17-
18-// 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.
19-// The first argument is typically a *testing.T value.
20-func NewMockLinkStateReporter(t interface {
21- mock.TestingT
22- Cleanup(func())
23-}) *MockLinkStateReporter {
24- mock := &MockLinkStateReporter{}
25- mock.Mock.Test(t)
26-
27- t.Cleanup(func() { mock.AssertExpectations(t) })
28-
29- return mock
30-}
31-
32-// MockLinkStateReporter is an autogenerated mock type for the LinkStateReporter type
33-type MockLinkStateReporter struct {
34- mock.Mock
35-}
36-
37-type MockLinkStateReporter_Expecter struct {
38- mock *mock.Mock
39-}
40-
41-func (_m *MockLinkStateReporter) EXPECT() *MockLinkStateReporter_Expecter {
42- return &MockLinkStateReporter_Expecter{mock: &_m.Mock}
43-}
44-
45-// LinkEvents provides a mock function for the type MockLinkStateReporter
46-func (_mock *MockLinkStateReporter) LinkEvents() <-chan ports.LinkEvent {
47- ret := _mock.Called()
48-
49- if len(ret) == 0 {
50- panic("no return value specified for LinkEvents")
51- }
52-
53- var r0 <-chan ports.LinkEvent
54- if returnFunc, ok := ret.Get(0).(func() <-chan ports.LinkEvent); ok {
55- r0 = returnFunc()
56- } else {
57- if ret.Get(0) != nil {
58- r0 = ret.Get(0).(<-chan ports.LinkEvent)
59- }
60- }
61- return r0
62-}
63-
64-// MockLinkStateReporter_LinkEvents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LinkEvents'
65-type MockLinkStateReporter_LinkEvents_Call struct {
66- *mock.Call
67-}
68-
69-// LinkEvents is a helper method to define mock.On call
70-func (_e *MockLinkStateReporter_Expecter) LinkEvents() *MockLinkStateReporter_LinkEvents_Call {
71- return &MockLinkStateReporter_LinkEvents_Call{Call: _e.mock.On("LinkEvents")}
72-}
73-
74-func (_c *MockLinkStateReporter_LinkEvents_Call) Run(run func()) *MockLinkStateReporter_LinkEvents_Call {
75- _c.Call.Run(func(args mock.Arguments) {
76- run()
77- })
78- return _c
79-}
80-
81-func (_c *MockLinkStateReporter_LinkEvents_Call) Return(linkEventCh <-chan ports.LinkEvent) *MockLinkStateReporter_LinkEvents_Call {
82- _c.Call.Return(linkEventCh)
83- return _c
84-}
85-
86-func (_c *MockLinkStateReporter_LinkEvents_Call) RunAndReturn(run func() <-chan ports.LinkEvent) *MockLinkStateReporter_LinkEvents_Call {
87- _c.Call.Return(run)
88- return _c
89-}
90-
91-// LinkState provides a mock function for the type MockLinkStateReporter
92-func (_mock *MockLinkStateReporter) LinkState() ports.LinkState {
93- ret := _mock.Called()
94-
95- if len(ret) == 0 {
96- panic("no return value specified for LinkState")
97- }
98-
99- var r0 ports.LinkState
100- if returnFunc, ok := ret.Get(0).(func() ports.LinkState); ok {
101- r0 = returnFunc()
102- } else {
103- r0 = ret.Get(0).(ports.LinkState)
104- }
105- return r0
106-}
107-
108-// MockLinkStateReporter_LinkState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LinkState'
109-type MockLinkStateReporter_LinkState_Call struct {
110- *mock.Call
111-}
112-
113-// LinkState is a helper method to define mock.On call
114-func (_e *MockLinkStateReporter_Expecter) LinkState() *MockLinkStateReporter_LinkState_Call {
115- return &MockLinkStateReporter_LinkState_Call{Call: _e.mock.On("LinkState")}
116-}
117-
118-func (_c *MockLinkStateReporter_LinkState_Call) Run(run func()) *MockLinkStateReporter_LinkState_Call {
119- _c.Call.Run(func(args mock.Arguments) {
120- run()
121- })
122- return _c
123-}
124-
125-func (_c *MockLinkStateReporter_LinkState_Call) Return(linkState ports.LinkState) *MockLinkStateReporter_LinkState_Call {
126- _c.Call.Return(linkState)
127- return _c
128-}
129-
130-func (_c *MockLinkStateReporter_LinkState_Call) RunAndReturn(run func() ports.LinkState) *MockLinkStateReporter_LinkState_Call {
131- _c.Call.Return(run)
132- return _c
133-}
134-
135-// 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.
136-// The first argument is typically a *testing.T value.
137-func NewMockPTY(t interface {
138- mock.TestingT
139- Cleanup(func())
140-}) *MockPTY {
141- mock := &MockPTY{}
142- mock.Mock.Test(t)
143-
144- t.Cleanup(func() { mock.AssertExpectations(t) })
145-
146- return mock
147-}
148-
149-// MockPTY is an autogenerated mock type for the PTY type
150-type MockPTY struct {
151- mock.Mock
152-}
153-
154-type MockPTY_Expecter struct {
155- mock *mock.Mock
156-}
157-
158-func (_m *MockPTY) EXPECT() *MockPTY_Expecter {
159- return &MockPTY_Expecter{mock: &_m.Mock}
160-}
161-
162-// Close provides a mock function for the type MockPTY
163-func (_mock *MockPTY) Close() error {
164- ret := _mock.Called()
165-
166- if len(ret) == 0 {
167- panic("no return value specified for Close")
168- }
169-
170- var r0 error
171- if returnFunc, ok := ret.Get(0).(func() error); ok {
172- r0 = returnFunc()
173- } else {
174- r0 = ret.Error(0)
175- }
176- return r0
177-}
178-
179-// MockPTY_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
180-type MockPTY_Close_Call struct {
181- *mock.Call
182-}
183-
184-// Close is a helper method to define mock.On call
185-func (_e *MockPTY_Expecter) Close() *MockPTY_Close_Call {
186- return &MockPTY_Close_Call{Call: _e.mock.On("Close")}
187-}
188-
189-func (_c *MockPTY_Close_Call) Run(run func()) *MockPTY_Close_Call {
190- _c.Call.Run(func(args mock.Arguments) {
191- run()
192- })
193- return _c
194-}
195-
196-func (_c *MockPTY_Close_Call) Return(err error) *MockPTY_Close_Call {
197- _c.Call.Return(err)
198- return _c
199-}
200-
201-func (_c *MockPTY_Close_Call) RunAndReturn(run func() error) *MockPTY_Close_Call {
202- _c.Call.Return(run)
203- return _c
204-}
205-
206-// ForegroundPgid provides a mock function for the type MockPTY
207-func (_mock *MockPTY) ForegroundPgid() (int, error) {
208- ret := _mock.Called()
209-
210- if len(ret) == 0 {
211- panic("no return value specified for ForegroundPgid")
212- }
213-
214- var r0 int
215- var r1 error
216- if returnFunc, ok := ret.Get(0).(func() (int, error)); ok {
217- return returnFunc()
218- }
219- if returnFunc, ok := ret.Get(0).(func() int); ok {
220- r0 = returnFunc()
221- } else {
222- r0 = ret.Get(0).(int)
223- }
224- if returnFunc, ok := ret.Get(1).(func() error); ok {
225- r1 = returnFunc()
226- } else {
227- r1 = ret.Error(1)
228- }
229- return r0, r1
230-}
231-
232-// MockPTY_ForegroundPgid_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ForegroundPgid'
233-type MockPTY_ForegroundPgid_Call struct {
234- *mock.Call
235-}
236-
237-// ForegroundPgid is a helper method to define mock.On call
238-func (_e *MockPTY_Expecter) ForegroundPgid() *MockPTY_ForegroundPgid_Call {
239- return &MockPTY_ForegroundPgid_Call{Call: _e.mock.On("ForegroundPgid")}
240-}
241-
242-func (_c *MockPTY_ForegroundPgid_Call) Run(run func()) *MockPTY_ForegroundPgid_Call {
243- _c.Call.Run(func(args mock.Arguments) {
244- run()
245- })
246- return _c
247-}
248-
249-func (_c *MockPTY_ForegroundPgid_Call) Return(n int, err error) *MockPTY_ForegroundPgid_Call {
250- _c.Call.Return(n, err)
251- return _c
252-}
253-
254-func (_c *MockPTY_ForegroundPgid_Call) RunAndReturn(run func() (int, error)) *MockPTY_ForegroundPgid_Call {
255- _c.Call.Return(run)
256- return _c
257-}
258-
259-// Pid provides a mock function for the type MockPTY
260-func (_mock *MockPTY) Pid() int {
261- ret := _mock.Called()
262-
263- if len(ret) == 0 {
264- panic("no return value specified for Pid")
265- }
266-
267- var r0 int
268- if returnFunc, ok := ret.Get(0).(func() int); ok {
269- r0 = returnFunc()
270- } else {
271- r0 = ret.Get(0).(int)
272- }
273- return r0
274-}
275-
276-// MockPTY_Pid_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Pid'
277-type MockPTY_Pid_Call struct {
278- *mock.Call
279-}
280-
281-// Pid is a helper method to define mock.On call
282-func (_e *MockPTY_Expecter) Pid() *MockPTY_Pid_Call {
283- return &MockPTY_Pid_Call{Call: _e.mock.On("Pid")}
284-}
285-
286-func (_c *MockPTY_Pid_Call) Run(run func()) *MockPTY_Pid_Call {
287- _c.Call.Run(func(args mock.Arguments) {
288- run()
289- })
290- return _c
291-}
292-
293-func (_c *MockPTY_Pid_Call) Return(n int) *MockPTY_Pid_Call {
294- _c.Call.Return(n)
295- return _c
296-}
297-
298-func (_c *MockPTY_Pid_Call) RunAndReturn(run func() int) *MockPTY_Pid_Call {
299- _c.Call.Return(run)
300- return _c
301-}
302-
303-// Read provides a mock function for the type MockPTY
304-func (_mock *MockPTY) Read(p []byte) (int, error) {
305- ret := _mock.Called(p)
306-
307- if len(ret) == 0 {
308- panic("no return value specified for Read")
309- }
310-
311- var r0 int
312- var r1 error
313- if returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok {
314- return returnFunc(p)
315- }
316- if returnFunc, ok := ret.Get(0).(func([]byte) int); ok {
317- r0 = returnFunc(p)
318- } else {
319- r0 = ret.Get(0).(int)
320- }
321- if returnFunc, ok := ret.Get(1).(func([]byte) error); ok {
322- r1 = returnFunc(p)
323- } else {
324- r1 = ret.Error(1)
325- }
326- return r0, r1
327-}
328-
329-// MockPTY_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read'
330-type MockPTY_Read_Call struct {
331- *mock.Call
332-}
333-
334-// Read is a helper method to define mock.On call
335-// - p []byte
336-func (_e *MockPTY_Expecter) Read(p any) *MockPTY_Read_Call {
337- return &MockPTY_Read_Call{Call: _e.mock.On("Read", p)}
338-}
339-
340-func (_c *MockPTY_Read_Call) Run(run func(p []byte)) *MockPTY_Read_Call {
341- _c.Call.Run(func(args mock.Arguments) {
342- var arg0 []byte
343- if args[0] != nil {
344- arg0 = args[0].([]byte)
345- }
346- run(
347- arg0,
348- )
349- })
350- return _c
351-}
352-
353-func (_c *MockPTY_Read_Call) Return(n int, err error) *MockPTY_Read_Call {
354- _c.Call.Return(n, err)
355- return _c
356-}
357-
358-func (_c *MockPTY_Read_Call) RunAndReturn(run func(p []byte) (int, error)) *MockPTY_Read_Call {
359- _c.Call.Return(run)
360- return _c
361-}
362-
363-// Resize provides a mock function for the type MockPTY
364-func (_mock *MockPTY) Resize(sz domain.Size) error {
365- ret := _mock.Called(sz)
366-
367- if len(ret) == 0 {
368- panic("no return value specified for Resize")
369- }
370-
371- var r0 error
372- if returnFunc, ok := ret.Get(0).(func(domain.Size) error); ok {
373- r0 = returnFunc(sz)
374- } else {
375- r0 = ret.Error(0)
376- }
377- return r0
378-}
379-
380-// MockPTY_Resize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Resize'
381-type MockPTY_Resize_Call struct {
382- *mock.Call
383-}
384-
385-// Resize is a helper method to define mock.On call
386-// - sz domain.Size
387-func (_e *MockPTY_Expecter) Resize(sz any) *MockPTY_Resize_Call {
388- return &MockPTY_Resize_Call{Call: _e.mock.On("Resize", sz)}
389-}
390-
391-func (_c *MockPTY_Resize_Call) Run(run func(sz domain.Size)) *MockPTY_Resize_Call {
392- _c.Call.Run(func(args mock.Arguments) {
393- var arg0 domain.Size
394- if args[0] != nil {
395- arg0 = args[0].(domain.Size)
396- }
397- run(
398- arg0,
399- )
400- })
401- return _c
402-}
403-
404-func (_c *MockPTY_Resize_Call) Return(err error) *MockPTY_Resize_Call {
405- _c.Call.Return(err)
406- return _c
407-}
408-
409-func (_c *MockPTY_Resize_Call) RunAndReturn(run func(sz domain.Size) error) *MockPTY_Resize_Call {
410- _c.Call.Return(run)
411- return _c
412-}
413-
414-// Write provides a mock function for the type MockPTY
415-func (_mock *MockPTY) Write(p []byte) (int, error) {
416- ret := _mock.Called(p)
417-
418- if len(ret) == 0 {
419- panic("no return value specified for Write")
420- }
421-
422- var r0 int
423- var r1 error
424- if returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok {
425- return returnFunc(p)
426- }
427- if returnFunc, ok := ret.Get(0).(func([]byte) int); ok {
428- r0 = returnFunc(p)
429- } else {
430- r0 = ret.Get(0).(int)
431- }
432- if returnFunc, ok := ret.Get(1).(func([]byte) error); ok {
433- r1 = returnFunc(p)
434- } else {
435- r1 = ret.Error(1)
436- }
437- return r0, r1
438-}
439-
440-// MockPTY_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write'
441-type MockPTY_Write_Call struct {
442- *mock.Call
443-}
444-
445-// Write is a helper method to define mock.On call
446-// - p []byte
447-func (_e *MockPTY_Expecter) Write(p any) *MockPTY_Write_Call {
448- return &MockPTY_Write_Call{Call: _e.mock.On("Write", p)}
449-}
450-
451-func (_c *MockPTY_Write_Call) Run(run func(p []byte)) *MockPTY_Write_Call {
452- _c.Call.Run(func(args mock.Arguments) {
453- var arg0 []byte
454- if args[0] != nil {
455- arg0 = args[0].([]byte)
456- }
457- run(
458- arg0,
459- )
460- })
461- return _c
462-}
463-
464-func (_c *MockPTY_Write_Call) Return(n int, err error) *MockPTY_Write_Call {
465- _c.Call.Return(n, err)
466- return _c
467-}
468-
469-func (_c *MockPTY_Write_Call) RunAndReturn(run func(p []byte) (int, error)) *MockPTY_Write_Call {
470- _c.Call.Return(run)
471- return _c
472-}
473-
474-// 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.
475-// The first argument is typically a *testing.T value.
476-func NewMockPTYFactory(t interface {
477- mock.TestingT
478- Cleanup(func())
479-}) *MockPTYFactory {
480- mock := &MockPTYFactory{}
481- mock.Mock.Test(t)
482-
483- t.Cleanup(func() { mock.AssertExpectations(t) })
484-
485- return mock
486-}
487-
488-// MockPTYFactory is an autogenerated mock type for the PTYFactory type
489-type MockPTYFactory struct {
490- mock.Mock
491-}
492-
493-type MockPTYFactory_Expecter struct {
494- mock *mock.Mock
495-}
496-
497-func (_m *MockPTYFactory) EXPECT() *MockPTYFactory_Expecter {
498- return &MockPTYFactory_Expecter{mock: &_m.Mock}
499-}
500-
501-// Open provides a mock function for the type MockPTYFactory
502-func (_mock *MockPTYFactory) Open(ctx context.Context, cmd string, args []string, env []string, dir string, sz domain.Size) (ports.PTY, error) {
503- ret := _mock.Called(ctx, cmd, args, env, dir, sz)
504-
505- if len(ret) == 0 {
506- panic("no return value specified for Open")
507- }
508-
509- var r0 ports.PTY
510- var r1 error
511- if returnFunc, ok := ret.Get(0).(func(context.Context, string, []string, []string, string, domain.Size) (ports.PTY, error)); ok {
512- return returnFunc(ctx, cmd, args, env, dir, sz)
513- }
514- if returnFunc, ok := ret.Get(0).(func(context.Context, string, []string, []string, string, domain.Size) ports.PTY); ok {
515- r0 = returnFunc(ctx, cmd, args, env, dir, sz)
516- } else {
517- if ret.Get(0) != nil {
518- r0 = ret.Get(0).(ports.PTY)
519- }
520- }
521- if returnFunc, ok := ret.Get(1).(func(context.Context, string, []string, []string, string, domain.Size) error); ok {
522- r1 = returnFunc(ctx, cmd, args, env, dir, sz)
523- } else {
524- r1 = ret.Error(1)
525- }
526- return r0, r1
527-}
528-
529-// MockPTYFactory_Open_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Open'
530-type MockPTYFactory_Open_Call struct {
531- *mock.Call
532-}
533-
534-// Open is a helper method to define mock.On call
535-// - ctx context.Context
536-// - cmd string
537-// - args []string
538-// - env []string
539-// - dir string
540-// - sz domain.Size
541-func (_e *MockPTYFactory_Expecter) Open(ctx any, cmd any, args any, env any, dir any, sz any) *MockPTYFactory_Open_Call {
542- return &MockPTYFactory_Open_Call{Call: _e.mock.On("Open", ctx, cmd, args, env, dir, sz)}
543-}
544-
545-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 {
546- _c.Call.Run(func(args mock.Arguments) {
547- var arg0 context.Context
548- if args[0] != nil {
549- arg0 = args[0].(context.Context)
550- }
551- var arg1 string
552- if args[1] != nil {
553- arg1 = args[1].(string)
554- }
555- var arg2 []string
556- if args[2] != nil {
557- arg2 = args[2].([]string)
558- }
559- var arg3 []string
560- if args[3] != nil {
561- arg3 = args[3].([]string)
562- }
563- var arg4 string
564- if args[4] != nil {
565- arg4 = args[4].(string)
566- }
567- var arg5 domain.Size
568- if args[5] != nil {
569- arg5 = args[5].(domain.Size)
570- }
571- run(
572- arg0,
573- arg1,
574- arg2,
575- arg3,
576- arg4,
577- arg5,
578- )
579- })
580- return _c
581-}
582-
583-func (_c *MockPTYFactory_Open_Call) Return(pTY ports.PTY, err error) *MockPTYFactory_Open_Call {
584- _c.Call.Return(pTY, err)
585- return _c
586-}
587-
588-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 {
589- _c.Call.Return(run)
590- return _c
591-}
592-
593-// 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.
594-// The first argument is typically a *testing.T value.
595-func NewMockTerminal(t interface {
596- mock.TestingT
597- Cleanup(func())
598-}) *MockTerminal {
599- mock := &MockTerminal{}
600- mock.Mock.Test(t)
601-
602- t.Cleanup(func() { mock.AssertExpectations(t) })
603-
604- return mock
605-}
606-
607-// MockTerminal is an autogenerated mock type for the Terminal type
608-type MockTerminal struct {
609- mock.Mock
610-}
611-
612-type MockTerminal_Expecter struct {
613- mock *mock.Mock
614-}
615-
616-func (_m *MockTerminal) EXPECT() *MockTerminal_Expecter {
617- return &MockTerminal_Expecter{mock: &_m.Mock}
618-}
619-
620-// EnterRaw provides a mock function for the type MockTerminal
621-func (_mock *MockTerminal) EnterRaw() (func() error, error) {
622- ret := _mock.Called()
623-
624- if len(ret) == 0 {
625- panic("no return value specified for EnterRaw")
626- }
627-
628- var r0 func() error
629- var r1 error
630- if returnFunc, ok := ret.Get(0).(func() (func() error, error)); ok {
631- return returnFunc()
632- }
633- if returnFunc, ok := ret.Get(0).(func() func() error); ok {
634- r0 = returnFunc()
635- } else {
636- if ret.Get(0) != nil {
637- r0 = ret.Get(0).(func() error)
638- }
639- }
640- if returnFunc, ok := ret.Get(1).(func() error); ok {
641- r1 = returnFunc()
642- } else {
643- r1 = ret.Error(1)
644- }
645- return r0, r1
646-}
647-
648-// MockTerminal_EnterRaw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnterRaw'
649-type MockTerminal_EnterRaw_Call struct {
650- *mock.Call
651-}
652-
653-// EnterRaw is a helper method to define mock.On call
654-func (_e *MockTerminal_Expecter) EnterRaw() *MockTerminal_EnterRaw_Call {
655- return &MockTerminal_EnterRaw_Call{Call: _e.mock.On("EnterRaw")}
656-}
657-
658-func (_c *MockTerminal_EnterRaw_Call) Run(run func()) *MockTerminal_EnterRaw_Call {
659- _c.Call.Run(func(args mock.Arguments) {
660- run()
661- })
662- return _c
663-}
664-
665-func (_c *MockTerminal_EnterRaw_Call) Return(restore func() error, err error) *MockTerminal_EnterRaw_Call {
666- _c.Call.Return(restore, err)
667- return _c
668-}
669-
670-func (_c *MockTerminal_EnterRaw_Call) RunAndReturn(run func() (func() error, error)) *MockTerminal_EnterRaw_Call {
671- _c.Call.Return(run)
672- return _c
673-}
674-
675-// Flush provides a mock function for the type MockTerminal
676-func (_mock *MockTerminal) Flush() error {
677- ret := _mock.Called()
678-
679- if len(ret) == 0 {
680- panic("no return value specified for Flush")
681- }
682-
683- var r0 error
684- if returnFunc, ok := ret.Get(0).(func() error); ok {
685- r0 = returnFunc()
686- } else {
687- r0 = ret.Error(0)
688- }
689- return r0
690-}
691-
692-// MockTerminal_Flush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Flush'
693-type MockTerminal_Flush_Call struct {
694- *mock.Call
695-}
696-
697-// Flush is a helper method to define mock.On call
698-func (_e *MockTerminal_Expecter) Flush() *MockTerminal_Flush_Call {
699- return &MockTerminal_Flush_Call{Call: _e.mock.On("Flush")}
700-}
701-
702-func (_c *MockTerminal_Flush_Call) Run(run func()) *MockTerminal_Flush_Call {
703- _c.Call.Run(func(args mock.Arguments) {
704- run()
705- })
706- return _c
707-}
708-
709-func (_c *MockTerminal_Flush_Call) Return(err error) *MockTerminal_Flush_Call {
710- _c.Call.Return(err)
711- return _c
712-}
713-
714-func (_c *MockTerminal_Flush_Call) RunAndReturn(run func() error) *MockTerminal_Flush_Call {
715- _c.Call.Return(run)
716- return _c
717-}
718-
719-// In provides a mock function for the type MockTerminal
720-func (_mock *MockTerminal) In() io.Reader {
721- ret := _mock.Called()
722-
723- if len(ret) == 0 {
724- panic("no return value specified for In")
725- }
726-
727- var r0 io.Reader
728- if returnFunc, ok := ret.Get(0).(func() io.Reader); ok {
729- r0 = returnFunc()
730- } else {
731- if ret.Get(0) != nil {
732- r0 = ret.Get(0).(io.Reader)
733- }
734- }
735- return r0
736-}
737-
738-// MockTerminal_In_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'In'
739-type MockTerminal_In_Call struct {
740- *mock.Call
741-}
742-
743-// In is a helper method to define mock.On call
744-func (_e *MockTerminal_Expecter) In() *MockTerminal_In_Call {
745- return &MockTerminal_In_Call{Call: _e.mock.On("In")}
746-}
747-
748-func (_c *MockTerminal_In_Call) Run(run func()) *MockTerminal_In_Call {
749- _c.Call.Run(func(args mock.Arguments) {
750- run()
751- })
752- return _c
753-}
754-
755-func (_c *MockTerminal_In_Call) Return(reader io.Reader) *MockTerminal_In_Call {
756- _c.Call.Return(reader)
757- return _c
758-}
759-
760-func (_c *MockTerminal_In_Call) RunAndReturn(run func() io.Reader) *MockTerminal_In_Call {
761- _c.Call.Return(run)
762- return _c
763-}
764-
765-// Out provides a mock function for the type MockTerminal
766-func (_mock *MockTerminal) Out() io.Writer {
767- ret := _mock.Called()
768-
769- if len(ret) == 0 {
770- panic("no return value specified for Out")
771- }
772-
773- var r0 io.Writer
774- if returnFunc, ok := ret.Get(0).(func() io.Writer); ok {
775- r0 = returnFunc()
776- } else {
777- if ret.Get(0) != nil {
778- r0 = ret.Get(0).(io.Writer)
779- }
780- }
781- return r0
782-}
783-
784-// MockTerminal_Out_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Out'
785-type MockTerminal_Out_Call struct {
786- *mock.Call
787-}
788-
789-// Out is a helper method to define mock.On call
790-func (_e *MockTerminal_Expecter) Out() *MockTerminal_Out_Call {
791- return &MockTerminal_Out_Call{Call: _e.mock.On("Out")}
792-}
793-
794-func (_c *MockTerminal_Out_Call) Run(run func()) *MockTerminal_Out_Call {
795- _c.Call.Run(func(args mock.Arguments) {
796- run()
797- })
798- return _c
799-}
800-
801-func (_c *MockTerminal_Out_Call) Return(writer io.Writer) *MockTerminal_Out_Call {
802- _c.Call.Return(writer)
803- return _c
804-}
805-
806-func (_c *MockTerminal_Out_Call) RunAndReturn(run func() io.Writer) *MockTerminal_Out_Call {
807- _c.Call.Return(run)
808- return _c
809-}
810-
811-// QueryColors provides a mock function for the type MockTerminal
812-func (_mock *MockTerminal) QueryColors() error {
813- ret := _mock.Called()
814-
815- if len(ret) == 0 {
816- panic("no return value specified for QueryColors")
817- }
818-
819- var r0 error
820- if returnFunc, ok := ret.Get(0).(func() error); ok {
821- r0 = returnFunc()
822- } else {
823- r0 = ret.Error(0)
824- }
825- return r0
826-}
827-
828-// MockTerminal_QueryColors_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'QueryColors'
829-type MockTerminal_QueryColors_Call struct {
830- *mock.Call
831-}
832-
833-// QueryColors is a helper method to define mock.On call
834-func (_e *MockTerminal_Expecter) QueryColors() *MockTerminal_QueryColors_Call {
835- return &MockTerminal_QueryColors_Call{Call: _e.mock.On("QueryColors")}
836-}
837-
838-func (_c *MockTerminal_QueryColors_Call) Run(run func()) *MockTerminal_QueryColors_Call {
839- _c.Call.Run(func(args mock.Arguments) {
840- run()
841- })
842- return _c
843-}
844-
845-func (_c *MockTerminal_QueryColors_Call) Return(err error) *MockTerminal_QueryColors_Call {
846- _c.Call.Return(err)
847- return _c
848-}
849-
850-func (_c *MockTerminal_QueryColors_Call) RunAndReturn(run func() error) *MockTerminal_QueryColors_Call {
851- _c.Call.Return(run)
852- return _c
853-}
854-
855-// ResizeEvents provides a mock function for the type MockTerminal
856-func (_mock *MockTerminal) ResizeEvents() <-chan domain.Size {
857- ret := _mock.Called()
858-
859- if len(ret) == 0 {
860- panic("no return value specified for ResizeEvents")
861- }
862-
863- var r0 <-chan domain.Size
864- if returnFunc, ok := ret.Get(0).(func() <-chan domain.Size); ok {
865- r0 = returnFunc()
866- } else {
867- if ret.Get(0) != nil {
868- r0 = ret.Get(0).(<-chan domain.Size)
869- }
870- }
871- return r0
872-}
873-
874-// MockTerminal_ResizeEvents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResizeEvents'
875-type MockTerminal_ResizeEvents_Call struct {
876- *mock.Call
877-}
878-
879-// ResizeEvents is a helper method to define mock.On call
880-func (_e *MockTerminal_Expecter) ResizeEvents() *MockTerminal_ResizeEvents_Call {
881- return &MockTerminal_ResizeEvents_Call{Call: _e.mock.On("ResizeEvents")}
882-}
883-
884-func (_c *MockTerminal_ResizeEvents_Call) Run(run func()) *MockTerminal_ResizeEvents_Call {
885- _c.Call.Run(func(args mock.Arguments) {
886- run()
887- })
888- return _c
889-}
890-
891-func (_c *MockTerminal_ResizeEvents_Call) Return(sizeCh <-chan domain.Size) *MockTerminal_ResizeEvents_Call {
892- _c.Call.Return(sizeCh)
893- return _c
894-}
895-
896-func (_c *MockTerminal_ResizeEvents_Call) RunAndReturn(run func() <-chan domain.Size) *MockTerminal_ResizeEvents_Call {
897- _c.Call.Return(run)
898- return _c
899-}
900-
901-// Size provides a mock function for the type MockTerminal
902-func (_mock *MockTerminal) Size() (domain.Size, error) {
903- ret := _mock.Called()
904-
905- if len(ret) == 0 {
906- panic("no return value specified for Size")
907- }
908-
909- var r0 domain.Size
910- var r1 error
911- if returnFunc, ok := ret.Get(0).(func() (domain.Size, error)); ok {
912- return returnFunc()
913- }
914- if returnFunc, ok := ret.Get(0).(func() domain.Size); ok {
915- r0 = returnFunc()
916- } else {
917- r0 = ret.Get(0).(domain.Size)
918- }
919- if returnFunc, ok := ret.Get(1).(func() error); ok {
920- r1 = returnFunc()
921- } else {
922- r1 = ret.Error(1)
923- }
924- return r0, r1
925-}
926-
927-// MockTerminal_Size_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Size'
928-type MockTerminal_Size_Call struct {
929- *mock.Call
930-}
931-
932-// Size is a helper method to define mock.On call
933-func (_e *MockTerminal_Expecter) Size() *MockTerminal_Size_Call {
934- return &MockTerminal_Size_Call{Call: _e.mock.On("Size")}
935-}
936-
937-func (_c *MockTerminal_Size_Call) Run(run func()) *MockTerminal_Size_Call {
938- _c.Call.Run(func(args mock.Arguments) {
939- run()
940- })
941- return _c
942-}
943-
944-func (_c *MockTerminal_Size_Call) Return(size domain.Size, err error) *MockTerminal_Size_Call {
945- _c.Call.Return(size, err)
946- return _c
947-}
948-
949-func (_c *MockTerminal_Size_Call) RunAndReturn(run func() (domain.Size, error)) *MockTerminal_Size_Call {
950- _c.Call.Return(run)
951- return _c
952-}
953-
954-// 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.
955-// The first argument is typically a *testing.T value.
956-func NewMockTransport(t interface {
957- mock.TestingT
958- Cleanup(func())
959-}) *MockTransport {
960- mock := &MockTransport{}
961- mock.Mock.Test(t)
962-
963- t.Cleanup(func() { mock.AssertExpectations(t) })
964-
965- return mock
966-}
967-
968-// MockTransport is an autogenerated mock type for the Transport type
969-type MockTransport struct {
970- mock.Mock
971-}
972-
973-type MockTransport_Expecter struct {
974- mock *mock.Mock
975-}
976-
977-func (_m *MockTransport) EXPECT() *MockTransport_Expecter {
978- return &MockTransport_Expecter{mock: &_m.Mock}
979-}
980-
981-// Close provides a mock function for the type MockTransport
982-func (_mock *MockTransport) Close() error {
983- ret := _mock.Called()
984-
985- if len(ret) == 0 {
986- panic("no return value specified for Close")
987- }
988-
989- var r0 error
990- if returnFunc, ok := ret.Get(0).(func() error); ok {
991- r0 = returnFunc()
992- } else {
993- r0 = ret.Error(0)
994- }
995- return r0
996-}
997-
998-// MockTransport_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
999-type MockTransport_Close_Call struct {
1000- *mock.Call
1001-}
1002-
1003-// Close is a helper method to define mock.On call
1004-func (_e *MockTransport_Expecter) Close() *MockTransport_Close_Call {
1005- return &MockTransport_Close_Call{Call: _e.mock.On("Close")}
1006-}
1007-
1008-func (_c *MockTransport_Close_Call) Run(run func()) *MockTransport_Close_Call {
1009- _c.Call.Run(func(args mock.Arguments) {
1010- run()
1011- })
1012- return _c
1013-}
1014-
1015-func (_c *MockTransport_Close_Call) Return(err error) *MockTransport_Close_Call {
1016- _c.Call.Return(err)
1017- return _c
1018-}
1019-
1020-func (_c *MockTransport_Close_Call) RunAndReturn(run func() error) *MockTransport_Close_Call {
1021- _c.Call.Return(run)
1022- return _c
1023-}
1024-
1025-// Recv provides a mock function for the type MockTransport
1026-func (_mock *MockTransport) Recv() (ports.Frame, error) {
1027- ret := _mock.Called()
1028-
1029- if len(ret) == 0 {
1030- panic("no return value specified for Recv")
1031- }
1032-
1033- var r0 ports.Frame
1034- var r1 error
1035- if returnFunc, ok := ret.Get(0).(func() (ports.Frame, error)); ok {
1036- return returnFunc()
1037- }
1038- if returnFunc, ok := ret.Get(0).(func() ports.Frame); ok {
1039- r0 = returnFunc()
1040- } else {
1041- r0 = ret.Get(0).(ports.Frame)
1042- }
1043- if returnFunc, ok := ret.Get(1).(func() error); ok {
1044- r1 = returnFunc()
1045- } else {
1046- r1 = ret.Error(1)
1047- }
1048- return r0, r1
1049-}
1050-
1051-// MockTransport_Recv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recv'
1052-type MockTransport_Recv_Call struct {
1053- *mock.Call
1054-}
1055-
1056-// Recv is a helper method to define mock.On call
1057-func (_e *MockTransport_Expecter) Recv() *MockTransport_Recv_Call {
1058- return &MockTransport_Recv_Call{Call: _e.mock.On("Recv")}
1059-}
1060-
1061-func (_c *MockTransport_Recv_Call) Run(run func()) *MockTransport_Recv_Call {
1062- _c.Call.Run(func(args mock.Arguments) {
1063- run()
1064- })
1065- return _c
1066-}
1067-
1068-func (_c *MockTransport_Recv_Call) Return(frame ports.Frame, err error) *MockTransport_Recv_Call {
1069- _c.Call.Return(frame, err)
1070- return _c
1071-}
1072-
1073-func (_c *MockTransport_Recv_Call) RunAndReturn(run func() (ports.Frame, error)) *MockTransport_Recv_Call {
1074- _c.Call.Return(run)
1075- return _c
1076-}
1077-
1078-// Send provides a mock function for the type MockTransport
1079-func (_mock *MockTransport) Send(frame ports.Frame) error {
1080- ret := _mock.Called(frame)
1081-
1082- if len(ret) == 0 {
1083- panic("no return value specified for Send")
1084- }
1085-
1086- var r0 error
1087- if returnFunc, ok := ret.Get(0).(func(ports.Frame) error); ok {
1088- r0 = returnFunc(frame)
1089- } else {
1090- r0 = ret.Error(0)
1091- }
1092- return r0
1093-}
1094-
1095-// MockTransport_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send'
1096-type MockTransport_Send_Call struct {
1097- *mock.Call
1098-}
1099-
1100-// Send is a helper method to define mock.On call
1101-// - frame ports.Frame
1102-func (_e *MockTransport_Expecter) Send(frame any) *MockTransport_Send_Call {
1103- return &MockTransport_Send_Call{Call: _e.mock.On("Send", frame)}
1104-}
1105-
1106-func (_c *MockTransport_Send_Call) Run(run func(frame ports.Frame)) *MockTransport_Send_Call {
1107- _c.Call.Run(func(args mock.Arguments) {
1108- var arg0 ports.Frame
1109- if args[0] != nil {
1110- arg0 = args[0].(ports.Frame)
1111- }
1112- run(
1113- arg0,
1114- )
1115- })
1116- return _c
1117-}
1118-
1119-func (_c *MockTransport_Send_Call) Return(err error) *MockTransport_Send_Call {
1120- _c.Call.Return(err)
1121- return _c
1122-}
1123-
1124-func (_c *MockTransport_Send_Call) RunAndReturn(run func(frame ports.Frame) error) *MockTransport_Send_Call {
1125- _c.Call.Return(run)
1126- return _c
1127-}
1128-
1129-// 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.
1130-// The first argument is typically a *testing.T value.
1131-func NewMockDatagramTransport(t interface {
1132- mock.TestingT
1133- Cleanup(func())
1134-}) *MockDatagramTransport {
1135- mock := &MockDatagramTransport{}
1136- mock.Mock.Test(t)
1137-
1138- t.Cleanup(func() { mock.AssertExpectations(t) })
1139-
1140- return mock
1141-}
1142-
1143-// MockDatagramTransport is an autogenerated mock type for the DatagramTransport type
1144-type MockDatagramTransport struct {
1145- mock.Mock
1146-}
1147-
1148-type MockDatagramTransport_Expecter struct {
1149- mock *mock.Mock
1150-}
1151-
1152-func (_m *MockDatagramTransport) EXPECT() *MockDatagramTransport_Expecter {
1153- return &MockDatagramTransport_Expecter{mock: &_m.Mock}
1154-}
1155-
1156-// Close provides a mock function for the type MockDatagramTransport
1157-func (_mock *MockDatagramTransport) Close() error {
1158- ret := _mock.Called()
1159-
1160- if len(ret) == 0 {
1161- panic("no return value specified for Close")
1162- }
1163-
1164- var r0 error
1165- if returnFunc, ok := ret.Get(0).(func() error); ok {
1166- r0 = returnFunc()
1167- } else {
1168- r0 = ret.Error(0)
1169- }
1170- return r0
1171-}
1172-
1173-// MockDatagramTransport_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
1174-type MockDatagramTransport_Close_Call struct {
1175- *mock.Call
1176-}
1177-
1178-// Close is a helper method to define mock.On call
1179-func (_e *MockDatagramTransport_Expecter) Close() *MockDatagramTransport_Close_Call {
1180- return &MockDatagramTransport_Close_Call{Call: _e.mock.On("Close")}
1181-}
1182-
1183-func (_c *MockDatagramTransport_Close_Call) Run(run func()) *MockDatagramTransport_Close_Call {
1184- _c.Call.Run(func(args mock.Arguments) {
1185- run()
1186- })
1187- return _c
1188-}
1189-
1190-func (_c *MockDatagramTransport_Close_Call) Return(err error) *MockDatagramTransport_Close_Call {
1191- _c.Call.Return(err)
1192- return _c
1193-}
1194-
1195-func (_c *MockDatagramTransport_Close_Call) RunAndReturn(run func() error) *MockDatagramTransport_Close_Call {
1196- _c.Call.Return(run)
1197- return _c
1198-}
1199-
1200-// DatagramTransport provides a mock function for the type MockDatagramTransport
1201-func (_mock *MockDatagramTransport) DatagramTransport() {
1202- _mock.Called()
1203- return
1204-}
1205-
1206-// MockDatagramTransport_DatagramTransport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DatagramTransport'
1207-type MockDatagramTransport_DatagramTransport_Call struct {
1208- *mock.Call
1209-}
1210-
1211-// DatagramTransport is a helper method to define mock.On call
1212-func (_e *MockDatagramTransport_Expecter) DatagramTransport() *MockDatagramTransport_DatagramTransport_Call {
1213- return &MockDatagramTransport_DatagramTransport_Call{Call: _e.mock.On("DatagramTransport")}
1214-}
1215-
1216-func (_c *MockDatagramTransport_DatagramTransport_Call) Run(run func()) *MockDatagramTransport_DatagramTransport_Call {
1217- _c.Call.Run(func(args mock.Arguments) {
1218- run()
1219- })
1220- return _c
1221-}
1222-
1223-func (_c *MockDatagramTransport_DatagramTransport_Call) Return() *MockDatagramTransport_DatagramTransport_Call {
1224- _c.Call.Return()
1225- return _c
1226-}
1227-
1228-func (_c *MockDatagramTransport_DatagramTransport_Call) RunAndReturn(run func()) *MockDatagramTransport_DatagramTransport_Call {
1229- _c.Run(run)
1230- return _c
1231-}
1232-
1233-// Recv provides a mock function for the type MockDatagramTransport
1234-func (_mock *MockDatagramTransport) Recv() (ports.Frame, error) {
1235- ret := _mock.Called()
1236-
1237- if len(ret) == 0 {
1238- panic("no return value specified for Recv")
1239- }
1240-
1241- var r0 ports.Frame
1242- var r1 error
1243- if returnFunc, ok := ret.Get(0).(func() (ports.Frame, error)); ok {
1244- return returnFunc()
1245- }
1246- if returnFunc, ok := ret.Get(0).(func() ports.Frame); ok {
1247- r0 = returnFunc()
1248- } else {
1249- r0 = ret.Get(0).(ports.Frame)
1250- }
1251- if returnFunc, ok := ret.Get(1).(func() error); ok {
1252- r1 = returnFunc()
1253- } else {
1254- r1 = ret.Error(1)
1255- }
1256- return r0, r1
1257-}
1258-
1259-// MockDatagramTransport_Recv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recv'
1260-type MockDatagramTransport_Recv_Call struct {
1261- *mock.Call
1262-}
1263-
1264-// Recv is a helper method to define mock.On call
1265-func (_e *MockDatagramTransport_Expecter) Recv() *MockDatagramTransport_Recv_Call {
1266- return &MockDatagramTransport_Recv_Call{Call: _e.mock.On("Recv")}
1267-}
1268-
1269-func (_c *MockDatagramTransport_Recv_Call) Run(run func()) *MockDatagramTransport_Recv_Call {
1270- _c.Call.Run(func(args mock.Arguments) {
1271- run()
1272- })
1273- return _c
1274-}
1275-
1276-func (_c *MockDatagramTransport_Recv_Call) Return(frame ports.Frame, err error) *MockDatagramTransport_Recv_Call {
1277- _c.Call.Return(frame, err)
1278- return _c
1279-}
1280-
1281-func (_c *MockDatagramTransport_Recv_Call) RunAndReturn(run func() (ports.Frame, error)) *MockDatagramTransport_Recv_Call {
1282- _c.Call.Return(run)
1283- return _c
1284-}
1285-
1286-// Send provides a mock function for the type MockDatagramTransport
1287-func (_mock *MockDatagramTransport) Send(frame ports.Frame) error {
1288- ret := _mock.Called(frame)
1289-
1290- if len(ret) == 0 {
1291- panic("no return value specified for Send")
1292- }
1293-
1294- var r0 error
1295- if returnFunc, ok := ret.Get(0).(func(ports.Frame) error); ok {
1296- r0 = returnFunc(frame)
1297- } else {
1298- r0 = ret.Error(0)
1299- }
1300- return r0
1301-}
1302-
1303-// MockDatagramTransport_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send'
1304-type MockDatagramTransport_Send_Call struct {
1305- *mock.Call
1306-}
1307-
1308-// Send is a helper method to define mock.On call
1309-// - frame ports.Frame
1310-func (_e *MockDatagramTransport_Expecter) Send(frame any) *MockDatagramTransport_Send_Call {
1311- return &MockDatagramTransport_Send_Call{Call: _e.mock.On("Send", frame)}
1312-}
1313-
1314-func (_c *MockDatagramTransport_Send_Call) Run(run func(frame ports.Frame)) *MockDatagramTransport_Send_Call {
1315- _c.Call.Run(func(args mock.Arguments) {
1316- var arg0 ports.Frame
1317- if args[0] != nil {
1318- arg0 = args[0].(ports.Frame)
1319- }
1320- run(
1321- arg0,
1322- )
1323- })
1324- return _c
1325-}
1326-
1327-func (_c *MockDatagramTransport_Send_Call) Return(err error) *MockDatagramTransport_Send_Call {
1328- _c.Call.Return(err)
1329- return _c
1330-}
1331-
1332-func (_c *MockDatagramTransport_Send_Call) RunAndReturn(run func(frame ports.Frame) error) *MockDatagramTransport_Send_Call {
1333- _c.Call.Return(run)
1334- return _c
1335-}
1336-
1337-// 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.
1338-// The first argument is typically a *testing.T value.
1339-func NewMockAsyncTransport(t interface {
1340- mock.TestingT
1341- Cleanup(func())
1342-}) *MockAsyncTransport {
1343- mock := &MockAsyncTransport{}
1344- mock.Mock.Test(t)
1345-
1346- t.Cleanup(func() { mock.AssertExpectations(t) })
1347-
1348- return mock
1349-}
1350-
1351-// MockAsyncTransport is an autogenerated mock type for the AsyncTransport type
1352-type MockAsyncTransport struct {
1353- mock.Mock
1354-}
1355-
1356-type MockAsyncTransport_Expecter struct {
1357- mock *mock.Mock
1358-}
1359-
1360-func (_m *MockAsyncTransport) EXPECT() *MockAsyncTransport_Expecter {
1361- return &MockAsyncTransport_Expecter{mock: &_m.Mock}
1362-}
1363-
1364-// SendAsync provides a mock function for the type MockAsyncTransport
1365-func (_mock *MockAsyncTransport) SendAsync(frame ports.Frame) error {
1366- ret := _mock.Called(frame)
1367-
1368- if len(ret) == 0 {
1369- panic("no return value specified for SendAsync")
1370- }
1371-
1372- var r0 error
1373- if returnFunc, ok := ret.Get(0).(func(ports.Frame) error); ok {
1374- r0 = returnFunc(frame)
1375- } else {
1376- r0 = ret.Error(0)
1377- }
1378- return r0
1379-}
1380-
1381-// MockAsyncTransport_SendAsync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendAsync'
1382-type MockAsyncTransport_SendAsync_Call struct {
1383- *mock.Call
1384-}
1385-
1386-// SendAsync is a helper method to define mock.On call
1387-// - frame ports.Frame
1388-func (_e *MockAsyncTransport_Expecter) SendAsync(frame any) *MockAsyncTransport_SendAsync_Call {
1389- return &MockAsyncTransport_SendAsync_Call{Call: _e.mock.On("SendAsync", frame)}
1390-}
1391-
1392-func (_c *MockAsyncTransport_SendAsync_Call) Run(run func(frame ports.Frame)) *MockAsyncTransport_SendAsync_Call {
1393- _c.Call.Run(func(args mock.Arguments) {
1394- var arg0 ports.Frame
1395- if args[0] != nil {
1396- arg0 = args[0].(ports.Frame)
1397- }
1398- run(
1399- arg0,
1400- )
1401- })
1402- return _c
1403-}
1404-
1405-func (_c *MockAsyncTransport_SendAsync_Call) Return(err error) *MockAsyncTransport_SendAsync_Call {
1406- _c.Call.Return(err)
1407- return _c
1408-}
1409-
1410-func (_c *MockAsyncTransport_SendAsync_Call) RunAndReturn(run func(frame ports.Frame) error) *MockAsyncTransport_SendAsync_Call {
1411- _c.Call.Return(run)
1412- return _c
1413-}
1414-
1415-// 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.
1416-// The first argument is typically a *testing.T value.
1417-func NewMockOwnedSynchronousTransport(t interface {
1418- mock.TestingT
1419- Cleanup(func())
1420-}) *MockOwnedSynchronousTransport {
1421- mock := &MockOwnedSynchronousTransport{}
1422- mock.Mock.Test(t)
1423-
1424- t.Cleanup(func() { mock.AssertExpectations(t) })
1425-
1426- return mock
1427-}
1428-
1429-// MockOwnedSynchronousTransport is an autogenerated mock type for the OwnedSynchronousTransport type
1430-type MockOwnedSynchronousTransport struct {
1431- mock.Mock
1432-}
1433-
1434-type MockOwnedSynchronousTransport_Expecter struct {
1435- mock *mock.Mock
1436-}
1437-
1438-func (_m *MockOwnedSynchronousTransport) EXPECT() *MockOwnedSynchronousTransport_Expecter {
1439- return &MockOwnedSynchronousTransport_Expecter{mock: &_m.Mock}
1440-}
1441-
1442-// SendSynchronous provides a mock function for the type MockOwnedSynchronousTransport
1443-func (_mock *MockOwnedSynchronousTransport) SendSynchronous(frame ports.Frame) error {
1444- ret := _mock.Called(frame)
1445-
1446- if len(ret) == 0 {
1447- panic("no return value specified for SendSynchronous")
1448- }
1449-
1450- var r0 error
1451- if returnFunc, ok := ret.Get(0).(func(ports.Frame) error); ok {
1452- r0 = returnFunc(frame)
1453- } else {
1454- r0 = ret.Error(0)
1455- }
1456- return r0
1457-}
1458-
1459-// MockOwnedSynchronousTransport_SendSynchronous_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendSynchronous'
1460-type MockOwnedSynchronousTransport_SendSynchronous_Call struct {
1461- *mock.Call
1462-}
1463-
1464-// SendSynchronous is a helper method to define mock.On call
1465-// - frame ports.Frame
1466-func (_e *MockOwnedSynchronousTransport_Expecter) SendSynchronous(frame any) *MockOwnedSynchronousTransport_SendSynchronous_Call {
1467- return &MockOwnedSynchronousTransport_SendSynchronous_Call{Call: _e.mock.On("SendSynchronous", frame)}
1468-}
1469-
1470-func (_c *MockOwnedSynchronousTransport_SendSynchronous_Call) Run(run func(frame ports.Frame)) *MockOwnedSynchronousTransport_SendSynchronous_Call {
1471- _c.Call.Run(func(args mock.Arguments) {
1472- var arg0 ports.Frame
1473- if args[0] != nil {
1474- arg0 = args[0].(ports.Frame)
1475- }
1476- run(
1477- arg0,
1478- )
1479- })
1480- return _c
1481-}
1482-
1483-func (_c *MockOwnedSynchronousTransport_SendSynchronous_Call) Return(err error) *MockOwnedSynchronousTransport_SendSynchronous_Call {
1484- _c.Call.Return(err)
1485- return _c
1486-}
1487-
1488-func (_c *MockOwnedSynchronousTransport_SendSynchronous_Call) RunAndReturn(run func(frame ports.Frame) error) *MockOwnedSynchronousTransport_SendSynchronous_Call {
1489- _c.Call.Return(run)
1490- return _c
1491-}
1492-
1493-// 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.
1494-// The first argument is typically a *testing.T value.
1495-func NewMockDialer(t interface {
1496- mock.TestingT
1497- Cleanup(func())
1498-}) *MockDialer {
1499- mock := &MockDialer{}
1500- mock.Mock.Test(t)
1501-
1502- t.Cleanup(func() { mock.AssertExpectations(t) })
1503-
1504- return mock
1505-}
1506-
1507-// MockDialer is an autogenerated mock type for the Dialer type
1508-type MockDialer struct {
1509- mock.Mock
1510-}
1511-
1512-type MockDialer_Expecter struct {
1513- mock *mock.Mock
1514-}
1515-
1516-func (_m *MockDialer) EXPECT() *MockDialer_Expecter {
1517- return &MockDialer_Expecter{mock: &_m.Mock}
1518-}
1519-
1520-// Dial provides a mock function for the type MockDialer
1521-func (_mock *MockDialer) Dial(ctx context.Context) (ports.Transport, error) {
1522- ret := _mock.Called(ctx)
1523-
1524- if len(ret) == 0 {
1525- panic("no return value specified for Dial")
1526- }
1527-
1528- var r0 ports.Transport
1529- var r1 error
1530- if returnFunc, ok := ret.Get(0).(func(context.Context) (ports.Transport, error)); ok {
1531- return returnFunc(ctx)
1532- }
1533- if returnFunc, ok := ret.Get(0).(func(context.Context) ports.Transport); ok {
1534- r0 = returnFunc(ctx)
1535- } else {
1536- if ret.Get(0) != nil {
1537- r0 = ret.Get(0).(ports.Transport)
1538- }
1539- }
1540- if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1541- r1 = returnFunc(ctx)
1542- } else {
1543- r1 = ret.Error(1)
1544- }
1545- return r0, r1
1546-}
1547-
1548-// MockDialer_Dial_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Dial'
1549-type MockDialer_Dial_Call struct {
1550- *mock.Call
1551-}
1552-
1553-// Dial is a helper method to define mock.On call
1554-// - ctx context.Context
1555-func (_e *MockDialer_Expecter) Dial(ctx any) *MockDialer_Dial_Call {
1556- return &MockDialer_Dial_Call{Call: _e.mock.On("Dial", ctx)}
1557-}
1558-
1559-func (_c *MockDialer_Dial_Call) Run(run func(ctx context.Context)) *MockDialer_Dial_Call {
1560- _c.Call.Run(func(args mock.Arguments) {
1561- var arg0 context.Context
1562- if args[0] != nil {
1563- arg0 = args[0].(context.Context)
1564- }
1565- run(
1566- arg0,
1567- )
1568- })
1569- return _c
1570-}
1571-
1572-func (_c *MockDialer_Dial_Call) Return(transport ports.Transport, err error) *MockDialer_Dial_Call {
1573- _c.Call.Return(transport, err)
1574- return _c
1575-}
1576-
1577-func (_c *MockDialer_Dial_Call) RunAndReturn(run func(ctx context.Context) (ports.Transport, error)) *MockDialer_Dial_Call {
1578- _c.Call.Return(run)
1579- return _c
1580-}
1581-
1582-// 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.
1583-// The first argument is typically a *testing.T value.
1584-func NewMockListener(t interface {
1585- mock.TestingT
1586- Cleanup(func())
1587-}) *MockListener {
1588- mock := &MockListener{}
1589- mock.Mock.Test(t)
1590-
1591- t.Cleanup(func() { mock.AssertExpectations(t) })
1592-
1593- return mock
1594-}
1595-
1596-// MockListener is an autogenerated mock type for the Listener type
1597-type MockListener struct {
1598- mock.Mock
1599-}
1600-
1601-type MockListener_Expecter struct {
1602- mock *mock.Mock
1603-}
1604-
1605-func (_m *MockListener) EXPECT() *MockListener_Expecter {
1606- return &MockListener_Expecter{mock: &_m.Mock}
1607-}
1608-
1609-// Accept provides a mock function for the type MockListener
1610-func (_mock *MockListener) Accept() (ports.Transport, error) {
1611- ret := _mock.Called()
1612-
1613- if len(ret) == 0 {
1614- panic("no return value specified for Accept")
1615- }
1616-
1617- var r0 ports.Transport
1618- var r1 error
1619- if returnFunc, ok := ret.Get(0).(func() (ports.Transport, error)); ok {
1620- return returnFunc()
1621- }
1622- if returnFunc, ok := ret.Get(0).(func() ports.Transport); ok {
1623- r0 = returnFunc()
1624- } else {
1625- if ret.Get(0) != nil {
1626- r0 = ret.Get(0).(ports.Transport)
1627- }
1628- }
1629- if returnFunc, ok := ret.Get(1).(func() error); ok {
1630- r1 = returnFunc()
1631- } else {
1632- r1 = ret.Error(1)
1633- }
1634- return r0, r1
1635-}
1636-
1637-// MockListener_Accept_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Accept'
1638-type MockListener_Accept_Call struct {
1639- *mock.Call
1640-}
1641-
1642-// Accept is a helper method to define mock.On call
1643-func (_e *MockListener_Expecter) Accept() *MockListener_Accept_Call {
1644- return &MockListener_Accept_Call{Call: _e.mock.On("Accept")}
1645-}
1646-
1647-func (_c *MockListener_Accept_Call) Run(run func()) *MockListener_Accept_Call {
1648- _c.Call.Run(func(args mock.Arguments) {
1649- run()
1650- })
1651- return _c
1652-}
1653-
1654-func (_c *MockListener_Accept_Call) Return(transport ports.Transport, err error) *MockListener_Accept_Call {
1655- _c.Call.Return(transport, err)
1656- return _c
1657-}
1658-
1659-func (_c *MockListener_Accept_Call) RunAndReturn(run func() (ports.Transport, error)) *MockListener_Accept_Call {
1660- _c.Call.Return(run)
1661- return _c
1662-}
1663-
1664-// Addr provides a mock function for the type MockListener
1665-func (_mock *MockListener) Addr() string {
1666- ret := _mock.Called()
1667-
1668- if len(ret) == 0 {
1669- panic("no return value specified for Addr")
1670- }
1671-
1672- var r0 string
1673- if returnFunc, ok := ret.Get(0).(func() string); ok {
1674- r0 = returnFunc()
1675- } else {
1676- r0 = ret.Get(0).(string)
1677- }
1678- return r0
1679-}
1680-
1681-// MockListener_Addr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Addr'
1682-type MockListener_Addr_Call struct {
1683- *mock.Call
1684-}
1685-
1686-// Addr is a helper method to define mock.On call
1687-func (_e *MockListener_Expecter) Addr() *MockListener_Addr_Call {
1688- return &MockListener_Addr_Call{Call: _e.mock.On("Addr")}
1689-}
1690-
1691-func (_c *MockListener_Addr_Call) Run(run func()) *MockListener_Addr_Call {
1692- _c.Call.Run(func(args mock.Arguments) {
1693- run()
1694- })
1695- return _c
1696-}
1697-
1698-func (_c *MockListener_Addr_Call) Return(s string) *MockListener_Addr_Call {
1699- _c.Call.Return(s)
1700- return _c
1701-}
1702-
1703-func (_c *MockListener_Addr_Call) RunAndReturn(run func() string) *MockListener_Addr_Call {
1704- _c.Call.Return(run)
1705- return _c
1706-}
1707-
1708-// Close provides a mock function for the type MockListener
1709-func (_mock *MockListener) Close() error {
1710- ret := _mock.Called()
1711-
1712- if len(ret) == 0 {
1713- panic("no return value specified for Close")
1714- }
1715-
1716- var r0 error
1717- if returnFunc, ok := ret.Get(0).(func() error); ok {
1718- r0 = returnFunc()
1719- } else {
1720- r0 = ret.Error(0)
1721- }
1722- return r0
1723-}
1724-
1725-// MockListener_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
1726-type MockListener_Close_Call struct {
1727- *mock.Call
1728-}
1729-
1730-// Close is a helper method to define mock.On call
1731-func (_e *MockListener_Expecter) Close() *MockListener_Close_Call {
1732- return &MockListener_Close_Call{Call: _e.mock.On("Close")}
1733-}
1734-
1735-func (_c *MockListener_Close_Call) Run(run func()) *MockListener_Close_Call {
1736- _c.Call.Run(func(args mock.Arguments) {
1737- run()
1738- })
1739- return _c
1740-}
1741-
1742-func (_c *MockListener_Close_Call) Return(err error) *MockListener_Close_Call {
1743- _c.Call.Return(err)
1744- return _c
1745-}
1746-
1747-func (_c *MockListener_Close_Call) RunAndReturn(run func() error) *MockListener_Close_Call {
1748- _c.Call.Return(run)
1749- return _c
1750-}
1751-
1752-// 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.
1753-// The first argument is typically a *testing.T value.
1754-func NewMockStore(t interface {
1755- mock.TestingT
1756- Cleanup(func())
1757-}) *MockStore {
1758- mock := &MockStore{}
1759- mock.Mock.Test(t)
1760-
1761- t.Cleanup(func() { mock.AssertExpectations(t) })
1762-
1763- return mock
1764-}
1765-
1766-// MockStore is an autogenerated mock type for the Store type
1767-type MockStore struct {
1768- mock.Mock
1769-}
1770-
1771-type MockStore_Expecter struct {
1772- mock *mock.Mock
1773-}
1774-
1775-func (_m *MockStore) EXPECT() *MockStore_Expecter {
1776- return &MockStore_Expecter{mock: &_m.Mock}
1777-}
1778-
1779-// Close provides a mock function for the type MockStore
1780-func (_mock *MockStore) Close() error {
1781- ret := _mock.Called()
1782-
1783- if len(ret) == 0 {
1784- panic("no return value specified for Close")
1785- }
1786-
1787- var r0 error
1788- if returnFunc, ok := ret.Get(0).(func() error); ok {
1789- r0 = returnFunc()
1790- } else {
1791- r0 = ret.Error(0)
1792- }
1793- return r0
1794-}
1795-
1796-// MockStore_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
1797-type MockStore_Close_Call struct {
1798- *mock.Call
1799-}
1800-
1801-// Close is a helper method to define mock.On call
1802-func (_e *MockStore_Expecter) Close() *MockStore_Close_Call {
1803- return &MockStore_Close_Call{Call: _e.mock.On("Close")}
1804-}
1805-
1806-func (_c *MockStore_Close_Call) Run(run func()) *MockStore_Close_Call {
1807- _c.Call.Run(func(args mock.Arguments) {
1808- run()
1809- })
1810- return _c
1811-}
1812-
1813-func (_c *MockStore_Close_Call) Return(err error) *MockStore_Close_Call {
1814- _c.Call.Return(err)
1815- return _c
1816-}
1817-
1818-func (_c *MockStore_Close_Call) RunAndReturn(run func() error) *MockStore_Close_Call {
1819- _c.Call.Return(run)
1820- return _c
1821-}
1822-
1823-// Delete provides a mock function for the type MockStore
1824-func (_mock *MockStore) Delete(key []byte) error {
1825- ret := _mock.Called(key)
1826-
1827- if len(ret) == 0 {
1828- panic("no return value specified for Delete")
1829- }
1830-
1831- var r0 error
1832- if returnFunc, ok := ret.Get(0).(func([]byte) error); ok {
1833- r0 = returnFunc(key)
1834- } else {
1835- r0 = ret.Error(0)
1836- }
1837- return r0
1838-}
1839-
1840-// MockStore_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
1841-type MockStore_Delete_Call struct {
1842- *mock.Call
1843-}
1844-
1845-// Delete is a helper method to define mock.On call
1846-// - key []byte
1847-func (_e *MockStore_Expecter) Delete(key any) *MockStore_Delete_Call {
1848- return &MockStore_Delete_Call{Call: _e.mock.On("Delete", key)}
1849-}
1850-
1851-func (_c *MockStore_Delete_Call) Run(run func(key []byte)) *MockStore_Delete_Call {
1852- _c.Call.Run(func(args mock.Arguments) {
1853- var arg0 []byte
1854- if args[0] != nil {
1855- arg0 = args[0].([]byte)
1856- }
1857- run(
1858- arg0,
1859- )
1860- })
1861- return _c
1862-}
1863-
1864-func (_c *MockStore_Delete_Call) Return(err error) *MockStore_Delete_Call {
1865- _c.Call.Return(err)
1866- return _c
1867-}
1868-
1869-func (_c *MockStore_Delete_Call) RunAndReturn(run func(key []byte) error) *MockStore_Delete_Call {
1870- _c.Call.Return(run)
1871- return _c
1872-}
1873-
1874-// Get provides a mock function for the type MockStore
1875-func (_mock *MockStore) Get(key []byte) ([]byte, bool) {
1876- ret := _mock.Called(key)
1877-
1878- if len(ret) == 0 {
1879- panic("no return value specified for Get")
1880- }
1881-
1882- var r0 []byte
1883- var r1 bool
1884- if returnFunc, ok := ret.Get(0).(func([]byte) ([]byte, bool)); ok {
1885- return returnFunc(key)
1886- }
1887- if returnFunc, ok := ret.Get(0).(func([]byte) []byte); ok {
1888- r0 = returnFunc(key)
1889- } else {
1890- if ret.Get(0) != nil {
1891- r0 = ret.Get(0).([]byte)
1892- }
1893- }
1894- if returnFunc, ok := ret.Get(1).(func([]byte) bool); ok {
1895- r1 = returnFunc(key)
1896- } else {
1897- r1 = ret.Get(1).(bool)
1898- }
1899- return r0, r1
1900-}
1901-
1902-// MockStore_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'
1903-type MockStore_Get_Call struct {
1904- *mock.Call
1905-}
1906-
1907-// Get is a helper method to define mock.On call
1908-// - key []byte
1909-func (_e *MockStore_Expecter) Get(key any) *MockStore_Get_Call {
1910- return &MockStore_Get_Call{Call: _e.mock.On("Get", key)}
1911-}
1912-
1913-func (_c *MockStore_Get_Call) Run(run func(key []byte)) *MockStore_Get_Call {
1914- _c.Call.Run(func(args mock.Arguments) {
1915- var arg0 []byte
1916- if args[0] != nil {
1917- arg0 = args[0].([]byte)
1918- }
1919- run(
1920- arg0,
1921- )
1922- })
1923- return _c
1924-}
1925-
1926-func (_c *MockStore_Get_Call) Return(bytes []byte, b bool) *MockStore_Get_Call {
1927- _c.Call.Return(bytes, b)
1928- return _c
1929-}
1930-
1931-func (_c *MockStore_Get_Call) RunAndReturn(run func(key []byte) ([]byte, bool)) *MockStore_Get_Call {
1932- _c.Call.Return(run)
1933- return _c
1934-}
1935-
1936-// Range provides a mock function for the type MockStore
1937-func (_mock *MockStore) Range(fn func(k []byte, v []byte) bool) {
1938- _mock.Called(fn)
1939- return
1940-}
1941-
1942-// MockStore_Range_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Range'
1943-type MockStore_Range_Call struct {
1944- *mock.Call
1945-}
1946-
1947-// Range is a helper method to define mock.On call
1948-// - fn func(k []byte, v []byte) bool
1949-func (_e *MockStore_Expecter) Range(fn any) *MockStore_Range_Call {
1950- return &MockStore_Range_Call{Call: _e.mock.On("Range", fn)}
1951-}
1952-
1953-func (_c *MockStore_Range_Call) Run(run func(fn func(k []byte, v []byte) bool)) *MockStore_Range_Call {
1954- _c.Call.Run(func(args mock.Arguments) {
1955- var arg0 func(k []byte, v []byte) bool
1956- if args[0] != nil {
1957- arg0 = args[0].(func(k []byte, v []byte) bool)
1958- }
1959- run(
1960- arg0,
1961- )
1962- })
1963- return _c
1964-}
1965-
1966-func (_c *MockStore_Range_Call) Return() *MockStore_Range_Call {
1967- _c.Call.Return()
1968- return _c
1969-}
1970-
1971-func (_c *MockStore_Range_Call) RunAndReturn(run func(fn func(k []byte, v []byte) bool)) *MockStore_Range_Call {
1972- _c.Run(run)
1973- return _c
1974-}
1975-
1976-// Set provides a mock function for the type MockStore
1977-func (_mock *MockStore) Set(key []byte, val []byte) error {
1978- ret := _mock.Called(key, val)
1979-
1980- if len(ret) == 0 {
1981- panic("no return value specified for Set")
1982- }
1983-
1984- var r0 error
1985- if returnFunc, ok := ret.Get(0).(func([]byte, []byte) error); ok {
1986- r0 = returnFunc(key, val)
1987- } else {
1988- r0 = ret.Error(0)
1989- }
1990- return r0
1991-}
1992-
1993-// MockStore_Set_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Set'
1994-type MockStore_Set_Call struct {
1995- *mock.Call
1996-}
1997-
1998-// Set is a helper method to define mock.On call
1999-// - key []byte
2000-// - val []byte
2001-func (_e *MockStore_Expecter) Set(key any, val any) *MockStore_Set_Call {
2002- return &MockStore_Set_Call{Call: _e.mock.On("Set", key, val)}
2003-}
2004-
2005-func (_c *MockStore_Set_Call) Run(run func(key []byte, val []byte)) *MockStore_Set_Call {
2006- _c.Call.Run(func(args mock.Arguments) {
2007- var arg0 []byte
2008- if args[0] != nil {
2009- arg0 = args[0].([]byte)
2010- }
2011- var arg1 []byte
2012- if args[1] != nil {
2013- arg1 = args[1].([]byte)
2014- }
2015- run(
2016- arg0,
2017- arg1,
2018- )
2019- })
2020- return _c
2021-}
2022-
2023-func (_c *MockStore_Set_Call) Return(err error) *MockStore_Set_Call {
2024- _c.Call.Return(err)
2025- return _c
2026-}
2027-
2028-func (_c *MockStore_Set_Call) RunAndReturn(run func(key []byte, val []byte) error) *MockStore_Set_Call {
2029- _c.Call.Return(run)
2030- return _c
2031-}
2032-
2033-// Sync provides a mock function for the type MockStore
2034-func (_mock *MockStore) Sync() error {
2035- ret := _mock.Called()
2036-
2037- if len(ret) == 0 {
2038- panic("no return value specified for Sync")
2039- }
2040-
2041- var r0 error
2042- if returnFunc, ok := ret.Get(0).(func() error); ok {
2043- r0 = returnFunc()
2044- } else {
2045- r0 = ret.Error(0)
2046- }
2047- return r0
2048-}
2049-
2050-// MockStore_Sync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Sync'
2051-type MockStore_Sync_Call struct {
2052- *mock.Call
2053-}
2054-
2055-// Sync is a helper method to define mock.On call
2056-func (_e *MockStore_Expecter) Sync() *MockStore_Sync_Call {
2057- return &MockStore_Sync_Call{Call: _e.mock.On("Sync")}
2058-}
2059-
2060-func (_c *MockStore_Sync_Call) Run(run func()) *MockStore_Sync_Call {
2061- _c.Call.Run(func(args mock.Arguments) {
2062- run()
2063- })
2064- return _c
2065-}
2066-
2067-func (_c *MockStore_Sync_Call) Return(err error) *MockStore_Sync_Call {
2068- _c.Call.Return(err)
2069- return _c
2070-}
2071-
2072-func (_c *MockStore_Sync_Call) RunAndReturn(run func() error) *MockStore_Sync_Call {
2073- _c.Call.Return(run)
2074- return _c
2075-}
2076-
2077-// 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.
2078-// The first argument is typically a *testing.T value.
2079-func NewMockSnapshotStore(t interface {
2080- mock.TestingT
2081- Cleanup(func())
2082-}) *MockSnapshotStore {
2083- mock := &MockSnapshotStore{}
2084- mock.Mock.Test(t)
2085-
2086- t.Cleanup(func() { mock.AssertExpectations(t) })
2087-
2088- return mock
2089-}
2090-
2091-// MockSnapshotStore is an autogenerated mock type for the SnapshotStore type
2092-type MockSnapshotStore struct {
2093- mock.Mock
2094-}
2095-
2096-type MockSnapshotStore_Expecter struct {
2097- mock *mock.Mock
2098-}
2099-
2100-func (_m *MockSnapshotStore) EXPECT() *MockSnapshotStore_Expecter {
2101- return &MockSnapshotStore_Expecter{mock: &_m.Mock}
2102-}
2103-
2104-// Delete provides a mock function for the type MockSnapshotStore
2105-func (_mock *MockSnapshotStore) Delete(name string) error {
2106- ret := _mock.Called(name)
2107-
2108- if len(ret) == 0 {
2109- panic("no return value specified for Delete")
2110- }
2111-
2112- var r0 error
2113- if returnFunc, ok := ret.Get(0).(func(string) error); ok {
2114- r0 = returnFunc(name)
2115- } else {
2116- r0 = ret.Error(0)
2117- }
2118- return r0
2119-}
2120-
2121-// MockSnapshotStore_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
2122-type MockSnapshotStore_Delete_Call struct {
2123- *mock.Call
2124-}
2125-
2126-// Delete is a helper method to define mock.On call
2127-// - name string
2128-func (_e *MockSnapshotStore_Expecter) Delete(name any) *MockSnapshotStore_Delete_Call {
2129- return &MockSnapshotStore_Delete_Call{Call: _e.mock.On("Delete", name)}
2130-}
2131-
2132-func (_c *MockSnapshotStore_Delete_Call) Run(run func(name string)) *MockSnapshotStore_Delete_Call {
2133- _c.Call.Run(func(args mock.Arguments) {
2134- var arg0 string
2135- if args[0] != nil {
2136- arg0 = args[0].(string)
2137- }
2138- run(
2139- arg0,
2140- )
2141- })
2142- return _c
2143-}
2144-
2145-func (_c *MockSnapshotStore_Delete_Call) Return(err error) *MockSnapshotStore_Delete_Call {
2146- _c.Call.Return(err)
2147- return _c
2148-}
2149-
2150-func (_c *MockSnapshotStore_Delete_Call) RunAndReturn(run func(name string) error) *MockSnapshotStore_Delete_Call {
2151- _c.Call.Return(run)
2152- return _c
2153-}
2154-
2155-// Load provides a mock function for the type MockSnapshotStore
2156-func (_mock *MockSnapshotStore) Load() ([]ports.SnapshotBlob, error) {
2157- ret := _mock.Called()
2158-
2159- if len(ret) == 0 {
2160- panic("no return value specified for Load")
2161- }
2162-
2163- var r0 []ports.SnapshotBlob
2164- var r1 error
2165- if returnFunc, ok := ret.Get(0).(func() ([]ports.SnapshotBlob, error)); ok {
2166- return returnFunc()
2167- }
2168- if returnFunc, ok := ret.Get(0).(func() []ports.SnapshotBlob); ok {
2169- r0 = returnFunc()
2170- } else {
2171- if ret.Get(0) != nil {
2172- r0 = ret.Get(0).([]ports.SnapshotBlob)
2173- }
2174- }
2175- if returnFunc, ok := ret.Get(1).(func() error); ok {
2176- r1 = returnFunc()
2177- } else {
2178- r1 = ret.Error(1)
2179- }
2180- return r0, r1
2181-}
2182-
2183-// MockSnapshotStore_Load_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Load'
2184-type MockSnapshotStore_Load_Call struct {
2185- *mock.Call
2186-}
2187-
2188-// Load is a helper method to define mock.On call
2189-func (_e *MockSnapshotStore_Expecter) Load() *MockSnapshotStore_Load_Call {
2190- return &MockSnapshotStore_Load_Call{Call: _e.mock.On("Load")}
2191-}
2192-
2193-func (_c *MockSnapshotStore_Load_Call) Run(run func()) *MockSnapshotStore_Load_Call {
2194- _c.Call.Run(func(args mock.Arguments) {
2195- run()
2196- })
2197- return _c
2198-}
2199-
2200-func (_c *MockSnapshotStore_Load_Call) Return(snapshotBlobs []ports.SnapshotBlob, err error) *MockSnapshotStore_Load_Call {
2201- _c.Call.Return(snapshotBlobs, err)
2202- return _c
2203-}
2204-
2205-func (_c *MockSnapshotStore_Load_Call) RunAndReturn(run func() ([]ports.SnapshotBlob, error)) *MockSnapshotStore_Load_Call {
2206- _c.Call.Return(run)
2207- return _c
2208-}
2209-
2210-// Write provides a mock function for the type MockSnapshotStore
2211-func (_mock *MockSnapshotStore) Write(name string, data []byte) error {
2212- ret := _mock.Called(name, data)
2213-
2214- if len(ret) == 0 {
2215- panic("no return value specified for Write")
2216- }
2217-
2218- var r0 error
2219- if returnFunc, ok := ret.Get(0).(func(string, []byte) error); ok {
2220- r0 = returnFunc(name, data)
2221- } else {
2222- r0 = ret.Error(0)
2223- }
2224- return r0
2225-}
2226-
2227-// MockSnapshotStore_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write'
2228-type MockSnapshotStore_Write_Call struct {
2229- *mock.Call
2230-}
2231-
2232-// Write is a helper method to define mock.On call
2233-// - name string
2234-// - data []byte
2235-func (_e *MockSnapshotStore_Expecter) Write(name any, data any) *MockSnapshotStore_Write_Call {
2236- return &MockSnapshotStore_Write_Call{Call: _e.mock.On("Write", name, data)}
2237-}
2238-
2239-func (_c *MockSnapshotStore_Write_Call) Run(run func(name string, data []byte)) *MockSnapshotStore_Write_Call {
2240- _c.Call.Run(func(args mock.Arguments) {
2241- var arg0 string
2242- if args[0] != nil {
2243- arg0 = args[0].(string)
2244- }
2245- var arg1 []byte
2246- if args[1] != nil {
2247- arg1 = args[1].([]byte)
2248- }
2249- run(
2250- arg0,
2251- arg1,
2252- )
2253- })
2254- return _c
2255-}
2256-
2257-func (_c *MockSnapshotStore_Write_Call) Return(err error) *MockSnapshotStore_Write_Call {
2258- _c.Call.Return(err)
2259- return _c
2260-}
2261-
2262-func (_c *MockSnapshotStore_Write_Call) RunAndReturn(run func(name string, data []byte) error) *MockSnapshotStore_Write_Call {
2263- _c.Call.Return(run)
2264- return _c
2265-}
2266-
2267-// 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.
2268-// The first argument is typically a *testing.T value.
2269-func NewMockClock(t interface {
2270- mock.TestingT
2271- Cleanup(func())
2272-}) *MockClock {
2273- mock := &MockClock{}
2274- mock.Mock.Test(t)
2275-
2276- t.Cleanup(func() { mock.AssertExpectations(t) })
2277-
2278- return mock
2279-}
2280-
2281-// MockClock is an autogenerated mock type for the Clock type
2282-type MockClock struct {
2283- mock.Mock
2284-}
2285-
2286-type MockClock_Expecter struct {
2287- mock *mock.Mock
2288-}
2289-
2290-func (_m *MockClock) EXPECT() *MockClock_Expecter {
2291- return &MockClock_Expecter{mock: &_m.Mock}
2292-}
2293-
2294-// NewTimer provides a mock function for the type MockClock
2295-func (_mock *MockClock) NewTimer(d time.Duration) ports.Timer {
2296- ret := _mock.Called(d)
2297-
2298- if len(ret) == 0 {
2299- panic("no return value specified for NewTimer")
2300- }
2301-
2302- var r0 ports.Timer
2303- if returnFunc, ok := ret.Get(0).(func(time.Duration) ports.Timer); ok {
2304- r0 = returnFunc(d)
2305- } else {
2306- if ret.Get(0) != nil {
2307- r0 = ret.Get(0).(ports.Timer)
2308- }
2309- }
2310- return r0
2311-}
2312-
2313-// MockClock_NewTimer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewTimer'
2314-type MockClock_NewTimer_Call struct {
2315- *mock.Call
2316-}
2317-
2318-// NewTimer is a helper method to define mock.On call
2319-// - d time.Duration
2320-func (_e *MockClock_Expecter) NewTimer(d any) *MockClock_NewTimer_Call {
2321- return &MockClock_NewTimer_Call{Call: _e.mock.On("NewTimer", d)}
2322-}
2323-
2324-func (_c *MockClock_NewTimer_Call) Run(run func(d time.Duration)) *MockClock_NewTimer_Call {
2325- _c.Call.Run(func(args mock.Arguments) {
2326- var arg0 time.Duration
2327- if args[0] != nil {
2328- arg0 = args[0].(time.Duration)
2329- }
2330- run(
2331- arg0,
2332- )
2333- })
2334- return _c
2335-}
2336-
2337-func (_c *MockClock_NewTimer_Call) Return(timer ports.Timer) *MockClock_NewTimer_Call {
2338- _c.Call.Return(timer)
2339- return _c
2340-}
2341-
2342-func (_c *MockClock_NewTimer_Call) RunAndReturn(run func(d time.Duration) ports.Timer) *MockClock_NewTimer_Call {
2343- _c.Call.Return(run)
2344- return _c
2345-}
2346-
2347-// Now provides a mock function for the type MockClock
2348-func (_mock *MockClock) Now() time.Time {
2349- ret := _mock.Called()
2350-
2351- if len(ret) == 0 {
2352- panic("no return value specified for Now")
2353- }
2354-
2355- var r0 time.Time
2356- if returnFunc, ok := ret.Get(0).(func() time.Time); ok {
2357- r0 = returnFunc()
2358- } else {
2359- r0 = ret.Get(0).(time.Time)
2360- }
2361- return r0
2362-}
2363-
2364-// MockClock_Now_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Now'
2365-type MockClock_Now_Call struct {
2366- *mock.Call
2367-}
2368-
2369-// Now is a helper method to define mock.On call
2370-func (_e *MockClock_Expecter) Now() *MockClock_Now_Call {
2371- return &MockClock_Now_Call{Call: _e.mock.On("Now")}
2372-}
2373-
2374-func (_c *MockClock_Now_Call) Run(run func()) *MockClock_Now_Call {
2375- _c.Call.Run(func(args mock.Arguments) {
2376- run()
2377- })
2378- return _c
2379-}
2380-
2381-func (_c *MockClock_Now_Call) Return(time1 time.Time) *MockClock_Now_Call {
2382- _c.Call.Return(time1)
2383- return _c
2384-}
2385-
2386-func (_c *MockClock_Now_Call) RunAndReturn(run func() time.Time) *MockClock_Now_Call {
2387- _c.Call.Return(run)
2388- return _c
2389-}
2390-
2391-// 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.
2392-// The first argument is typically a *testing.T value.
2393-func NewMockTimer(t interface {
2394- mock.TestingT
2395- Cleanup(func())
2396-}) *MockTimer {
2397- mock := &MockTimer{}
2398- mock.Mock.Test(t)
2399-
2400- t.Cleanup(func() { mock.AssertExpectations(t) })
2401-
2402- return mock
2403-}
2404-
2405-// MockTimer is an autogenerated mock type for the Timer type
2406-type MockTimer struct {
2407- mock.Mock
2408-}
2409-
2410-type MockTimer_Expecter struct {
2411- mock *mock.Mock
2412-}
2413-
2414-func (_m *MockTimer) EXPECT() *MockTimer_Expecter {
2415- return &MockTimer_Expecter{mock: &_m.Mock}
2416-}
2417-
2418-// C provides a mock function for the type MockTimer
2419-func (_mock *MockTimer) C() <-chan time.Time {
2420- ret := _mock.Called()
2421-
2422- if len(ret) == 0 {
2423- panic("no return value specified for C")
2424- }
2425-
2426- var r0 <-chan time.Time
2427- if returnFunc, ok := ret.Get(0).(func() <-chan time.Time); ok {
2428- r0 = returnFunc()
2429- } else {
2430- if ret.Get(0) != nil {
2431- r0 = ret.Get(0).(<-chan time.Time)
2432- }
2433- }
2434- return r0
2435-}
2436-
2437-// MockTimer_C_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'C'
2438-type MockTimer_C_Call struct {
2439- *mock.Call
2440-}
2441-
2442-// C is a helper method to define mock.On call
2443-func (_e *MockTimer_Expecter) C() *MockTimer_C_Call {
2444- return &MockTimer_C_Call{Call: _e.mock.On("C")}
2445-}
2446-
2447-func (_c *MockTimer_C_Call) Run(run func()) *MockTimer_C_Call {
2448- _c.Call.Run(func(args mock.Arguments) {
2449- run()
2450- })
2451- return _c
2452-}
2453-
2454-func (_c *MockTimer_C_Call) Return(timeCh <-chan time.Time) *MockTimer_C_Call {
2455- _c.Call.Return(timeCh)
2456- return _c
2457-}
2458-
2459-func (_c *MockTimer_C_Call) RunAndReturn(run func() <-chan time.Time) *MockTimer_C_Call {
2460- _c.Call.Return(run)
2461- return _c
2462-}
2463-
2464-// Reset provides a mock function for the type MockTimer
2465-func (_mock *MockTimer) Reset(d time.Duration) bool {
2466- ret := _mock.Called(d)
2467-
2468- if len(ret) == 0 {
2469- panic("no return value specified for Reset")
2470- }
2471-
2472- var r0 bool
2473- if returnFunc, ok := ret.Get(0).(func(time.Duration) bool); ok {
2474- r0 = returnFunc(d)
2475- } else {
2476- r0 = ret.Get(0).(bool)
2477- }
2478- return r0
2479-}
2480-
2481-// MockTimer_Reset_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reset'
2482-type MockTimer_Reset_Call struct {
2483- *mock.Call
2484-}
2485-
2486-// Reset is a helper method to define mock.On call
2487-// - d time.Duration
2488-func (_e *MockTimer_Expecter) Reset(d any) *MockTimer_Reset_Call {
2489- return &MockTimer_Reset_Call{Call: _e.mock.On("Reset", d)}
2490-}
2491-
2492-func (_c *MockTimer_Reset_Call) Run(run func(d time.Duration)) *MockTimer_Reset_Call {
2493- _c.Call.Run(func(args mock.Arguments) {
2494- var arg0 time.Duration
2495- if args[0] != nil {
2496- arg0 = args[0].(time.Duration)
2497- }
2498- run(
2499- arg0,
2500- )
2501- })
2502- return _c
2503-}
2504-
2505-func (_c *MockTimer_Reset_Call) Return(b bool) *MockTimer_Reset_Call {
2506- _c.Call.Return(b)
2507- return _c
2508-}
2509-
2510-func (_c *MockTimer_Reset_Call) RunAndReturn(run func(d time.Duration) bool) *MockTimer_Reset_Call {
2511- _c.Call.Return(run)
2512- return _c
2513-}
2514-
2515-// Stop provides a mock function for the type MockTimer
2516-func (_mock *MockTimer) Stop() bool {
2517- ret := _mock.Called()
2518-
2519- if len(ret) == 0 {
2520- panic("no return value specified for Stop")
2521- }
2522-
2523- var r0 bool
2524- if returnFunc, ok := ret.Get(0).(func() bool); ok {
2525- r0 = returnFunc()
2526- } else {
2527- r0 = ret.Get(0).(bool)
2528- }
2529- return r0
2530-}
2531-
2532-// MockTimer_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
2533-type MockTimer_Stop_Call struct {
2534- *mock.Call
2535-}
2536-
2537-// Stop is a helper method to define mock.On call
2538-func (_e *MockTimer_Expecter) Stop() *MockTimer_Stop_Call {
2539- return &MockTimer_Stop_Call{Call: _e.mock.On("Stop")}
2540-}
2541-
2542-func (_c *MockTimer_Stop_Call) Run(run func()) *MockTimer_Stop_Call {
2543- _c.Call.Run(func(args mock.Arguments) {
2544- run()
2545- })
2546- return _c
2547-}
2548-
2549-func (_c *MockTimer_Stop_Call) Return(b bool) *MockTimer_Stop_Call {
2550- _c.Call.Return(b)
2551- return _c
2552-}
2553-
2554-func (_c *MockTimer_Stop_Call) RunAndReturn(run func() bool) *MockTimer_Stop_Call {
2555- _c.Call.Return(run)
2556- return _c
2557-}
2558-
2559-// 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.
2560-// The first argument is typically a *testing.T value.
2561-func NewMockShellCommandRunner(t interface {
2562- mock.TestingT
2563- Cleanup(func())
2564-}) *MockShellCommandRunner {
2565- mock := &MockShellCommandRunner{}
2566- mock.Mock.Test(t)
2567-
2568- t.Cleanup(func() { mock.AssertExpectations(t) })
2569-
2570- return mock
2571-}
2572-
2573-// MockShellCommandRunner is an autogenerated mock type for the ShellCommandRunner type
2574-type MockShellCommandRunner struct {
2575- mock.Mock
2576-}
2577-
2578-type MockShellCommandRunner_Expecter struct {
2579- mock *mock.Mock
2580-}
2581-
2582-func (_m *MockShellCommandRunner) EXPECT() *MockShellCommandRunner_Expecter {
2583- return &MockShellCommandRunner_Expecter{mock: &_m.Mock}
2584-}
2585-
2586-// Run provides a mock function for the type MockShellCommandRunner
2587-func (_mock *MockShellCommandRunner) Run(ctx context.Context, spec ports.CommandSpec) ([]byte, error) {
2588- ret := _mock.Called(ctx, spec)
2589-
2590- if len(ret) == 0 {
2591- panic("no return value specified for Run")
2592- }
2593-
2594- var r0 []byte
2595- var r1 error
2596- if returnFunc, ok := ret.Get(0).(func(context.Context, ports.CommandSpec) ([]byte, error)); ok {
2597- return returnFunc(ctx, spec)
2598- }
2599- if returnFunc, ok := ret.Get(0).(func(context.Context, ports.CommandSpec) []byte); ok {
2600- r0 = returnFunc(ctx, spec)
2601- } else {
2602- if ret.Get(0) != nil {
2603- r0 = ret.Get(0).([]byte)
2604- }
2605- }
2606- if returnFunc, ok := ret.Get(1).(func(context.Context, ports.CommandSpec) error); ok {
2607- r1 = returnFunc(ctx, spec)
2608- } else {
2609- r1 = ret.Error(1)
2610- }
2611- return r0, r1
2612-}
2613-
2614-// MockShellCommandRunner_Run_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Run'
2615-type MockShellCommandRunner_Run_Call struct {
2616- *mock.Call
2617-}
2618-
2619-// Run is a helper method to define mock.On call
2620-// - ctx context.Context
2621-// - spec ports.CommandSpec
2622-func (_e *MockShellCommandRunner_Expecter) Run(ctx any, spec any) *MockShellCommandRunner_Run_Call {
2623- return &MockShellCommandRunner_Run_Call{Call: _e.mock.On("Run", ctx, spec)}
2624-}
2625-
2626-func (_c *MockShellCommandRunner_Run_Call) Run(run func(ctx context.Context, spec ports.CommandSpec)) *MockShellCommandRunner_Run_Call {
2627- _c.Call.Run(func(args mock.Arguments) {
2628- var arg0 context.Context
2629- if args[0] != nil {
2630- arg0 = args[0].(context.Context)
2631- }
2632- var arg1 ports.CommandSpec
2633- if args[1] != nil {
2634- arg1 = args[1].(ports.CommandSpec)
2635- }
2636- run(
2637- arg0,
2638- arg1,
2639- )
2640- })
2641- return _c
2642-}
2643-
2644-func (_c *MockShellCommandRunner_Run_Call) Return(bytes []byte, err error) *MockShellCommandRunner_Run_Call {
2645- _c.Call.Return(bytes, err)
2646- return _c
2647-}
2648-
2649-func (_c *MockShellCommandRunner_Run_Call) RunAndReturn(run func(ctx context.Context, spec ports.CommandSpec) ([]byte, error)) *MockShellCommandRunner_Run_Call {
2650- _c.Call.Return(run)
2651- return _c
2652-}
2653-
2654-// 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.
2655-// The first argument is typically a *testing.T value.
2656-func NewMockProcessInspector(t interface {
2657- mock.TestingT
2658- Cleanup(func())
2659-}) *MockProcessInspector {
2660- mock := &MockProcessInspector{}
2661- mock.Mock.Test(t)
2662-
2663- t.Cleanup(func() { mock.AssertExpectations(t) })
2664-
2665- return mock
2666-}
2667-
2668-// MockProcessInspector is an autogenerated mock type for the ProcessInspector type
2669-type MockProcessInspector struct {
2670- mock.Mock
2671-}
2672-
2673-type MockProcessInspector_Expecter struct {
2674- mock *mock.Mock
2675-}
2676-
2677-func (_m *MockProcessInspector) EXPECT() *MockProcessInspector_Expecter {
2678- return &MockProcessInspector_Expecter{mock: &_m.Mock}
2679-}
2680-
2681-// Argv provides a mock function for the type MockProcessInspector
2682-func (_mock *MockProcessInspector) Argv(pid int) ([]string, error) {
2683- ret := _mock.Called(pid)
2684-
2685- if len(ret) == 0 {
2686- panic("no return value specified for Argv")
2687- }
2688-
2689- var r0 []string
2690- var r1 error
2691- if returnFunc, ok := ret.Get(0).(func(int) ([]string, error)); ok {
2692- return returnFunc(pid)
2693- }
2694- if returnFunc, ok := ret.Get(0).(func(int) []string); ok {
2695- r0 = returnFunc(pid)
2696- } else {
2697- if ret.Get(0) != nil {
2698- r0 = ret.Get(0).([]string)
2699- }
2700- }
2701- if returnFunc, ok := ret.Get(1).(func(int) error); ok {
2702- r1 = returnFunc(pid)
2703- } else {
2704- r1 = ret.Error(1)
2705- }
2706- return r0, r1
2707-}
2708-
2709-// MockProcessInspector_Argv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Argv'
2710-type MockProcessInspector_Argv_Call struct {
2711- *mock.Call
2712-}
2713-
2714-// Argv is a helper method to define mock.On call
2715-// - pid int
2716-func (_e *MockProcessInspector_Expecter) Argv(pid any) *MockProcessInspector_Argv_Call {
2717- return &MockProcessInspector_Argv_Call{Call: _e.mock.On("Argv", pid)}
2718-}
2719-
2720-func (_c *MockProcessInspector_Argv_Call) Run(run func(pid int)) *MockProcessInspector_Argv_Call {
2721- _c.Call.Run(func(args mock.Arguments) {
2722- var arg0 int
2723- if args[0] != nil {
2724- arg0 = args[0].(int)
2725- }
2726- run(
2727- arg0,
2728- )
2729- })
2730- return _c
2731-}
2732-
2733-func (_c *MockProcessInspector_Argv_Call) Return(strings []string, err error) *MockProcessInspector_Argv_Call {
2734- _c.Call.Return(strings, err)
2735- return _c
2736-}
2737-
2738-func (_c *MockProcessInspector_Argv_Call) RunAndReturn(run func(pid int) ([]string, error)) *MockProcessInspector_Argv_Call {
2739- _c.Call.Return(run)
2740- return _c
2741-}
2742-
2743-// Comm provides a mock function for the type MockProcessInspector
2744-func (_mock *MockProcessInspector) Comm(pid int) (string, error) {
2745- ret := _mock.Called(pid)
2746-
2747- if len(ret) == 0 {
2748- panic("no return value specified for Comm")
2749- }
2750-
2751- var r0 string
2752- var r1 error
2753- if returnFunc, ok := ret.Get(0).(func(int) (string, error)); ok {
2754- return returnFunc(pid)
2755- }
2756- if returnFunc, ok := ret.Get(0).(func(int) string); ok {
2757- r0 = returnFunc(pid)
2758- } else {
2759- r0 = ret.Get(0).(string)
2760- }
2761- if returnFunc, ok := ret.Get(1).(func(int) error); ok {
2762- r1 = returnFunc(pid)
2763- } else {
2764- r1 = ret.Error(1)
2765- }
2766- return r0, r1
2767-}
2768-
2769-// MockProcessInspector_Comm_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Comm'
2770-type MockProcessInspector_Comm_Call struct {
2771- *mock.Call
2772-}
2773-
2774-// Comm is a helper method to define mock.On call
2775-// - pid int
2776-func (_e *MockProcessInspector_Expecter) Comm(pid any) *MockProcessInspector_Comm_Call {
2777- return &MockProcessInspector_Comm_Call{Call: _e.mock.On("Comm", pid)}
2778-}
2779-
2780-func (_c *MockProcessInspector_Comm_Call) Run(run func(pid int)) *MockProcessInspector_Comm_Call {
2781- _c.Call.Run(func(args mock.Arguments) {
2782- var arg0 int
2783- if args[0] != nil {
2784- arg0 = args[0].(int)
2785- }
2786- run(
2787- arg0,
2788- )
2789- })
2790- return _c
2791-}
2792-
2793-func (_c *MockProcessInspector_Comm_Call) Return(s string, err error) *MockProcessInspector_Comm_Call {
2794- _c.Call.Return(s, err)
2795- return _c
2796-}
2797-
2798-func (_c *MockProcessInspector_Comm_Call) RunAndReturn(run func(pid int) (string, error)) *MockProcessInspector_Comm_Call {
2799- _c.Call.Return(run)
2800- return _c
2801-}
2802-
2803-// Cwd provides a mock function for the type MockProcessInspector
2804-func (_mock *MockProcessInspector) Cwd(pid int) (string, error) {
2805- ret := _mock.Called(pid)
2806-
2807- if len(ret) == 0 {
2808- panic("no return value specified for Cwd")
2809- }
2810-
2811- var r0 string
2812- var r1 error
2813- if returnFunc, ok := ret.Get(0).(func(int) (string, error)); ok {
2814- return returnFunc(pid)
2815- }
2816- if returnFunc, ok := ret.Get(0).(func(int) string); ok {
2817- r0 = returnFunc(pid)
2818- } else {
2819- r0 = ret.Get(0).(string)
2820- }
2821- if returnFunc, ok := ret.Get(1).(func(int) error); ok {
2822- r1 = returnFunc(pid)
2823- } else {
2824- r1 = ret.Error(1)
2825- }
2826- return r0, r1
2827-}
2828-
2829-// MockProcessInspector_Cwd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Cwd'
2830-type MockProcessInspector_Cwd_Call struct {
2831- *mock.Call
2832-}
2833-
2834-// Cwd is a helper method to define mock.On call
2835-// - pid int
2836-func (_e *MockProcessInspector_Expecter) Cwd(pid any) *MockProcessInspector_Cwd_Call {
2837- return &MockProcessInspector_Cwd_Call{Call: _e.mock.On("Cwd", pid)}
2838-}
2839-
2840-func (_c *MockProcessInspector_Cwd_Call) Run(run func(pid int)) *MockProcessInspector_Cwd_Call {
2841- _c.Call.Run(func(args mock.Arguments) {
2842- var arg0 int
2843- if args[0] != nil {
2844- arg0 = args[0].(int)
2845- }
2846- run(
2847- arg0,
2848- )
2849- })
2850- return _c
2851-}
2852-
2853-func (_c *MockProcessInspector_Cwd_Call) Return(s string, err error) *MockProcessInspector_Cwd_Call {
2854- _c.Call.Return(s, err)
2855- return _c
2856-}
2857-
2858-func (_c *MockProcessInspector_Cwd_Call) RunAndReturn(run func(pid int) (string, error)) *MockProcessInspector_Cwd_Call {
2859- _c.Call.Return(run)
2860- return _c
2861-}
2862-
2863-// GroupArgv provides a mock function for the type MockProcessInspector
2864-func (_mock *MockProcessInspector) GroupArgv(pgid int, shellPid int) ([]string, error) {
2865- ret := _mock.Called(pgid, shellPid)
2866-
2867- if len(ret) == 0 {
2868- panic("no return value specified for GroupArgv")
2869- }
2870-
2871- var r0 []string
2872- var r1 error
2873- if returnFunc, ok := ret.Get(0).(func(int, int) ([]string, error)); ok {
2874- return returnFunc(pgid, shellPid)
2875- }
2876- if returnFunc, ok := ret.Get(0).(func(int, int) []string); ok {
2877- r0 = returnFunc(pgid, shellPid)
2878- } else {
2879- if ret.Get(0) != nil {
2880- r0 = ret.Get(0).([]string)
2881- }
2882- }
2883- if returnFunc, ok := ret.Get(1).(func(int, int) error); ok {
2884- r1 = returnFunc(pgid, shellPid)
2885- } else {
2886- r1 = ret.Error(1)
2887- }
2888- return r0, r1
2889-}
2890-
2891-// MockProcessInspector_GroupArgv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupArgv'
2892-type MockProcessInspector_GroupArgv_Call struct {
2893- *mock.Call
2894-}
2895-
2896-// GroupArgv is a helper method to define mock.On call
2897-// - pgid int
2898-// - shellPid int
2899-func (_e *MockProcessInspector_Expecter) GroupArgv(pgid any, shellPid any) *MockProcessInspector_GroupArgv_Call {
2900- return &MockProcessInspector_GroupArgv_Call{Call: _e.mock.On("GroupArgv", pgid, shellPid)}
2901-}
2902-
2903-func (_c *MockProcessInspector_GroupArgv_Call) Run(run func(pgid int, shellPid int)) *MockProcessInspector_GroupArgv_Call {
2904- _c.Call.Run(func(args mock.Arguments) {
2905- var arg0 int
2906- if args[0] != nil {
2907- arg0 = args[0].(int)
2908- }
2909- var arg1 int
2910- if args[1] != nil {
2911- arg1 = args[1].(int)
2912- }
2913- run(
2914- arg0,
2915- arg1,
2916- )
2917- })
2918- return _c
2919-}
2920-
2921-func (_c *MockProcessInspector_GroupArgv_Call) Return(strings []string, err error) *MockProcessInspector_GroupArgv_Call {
2922- _c.Call.Return(strings, err)
2923- return _c
2924-}
2925-
2926-func (_c *MockProcessInspector_GroupArgv_Call) RunAndReturn(run func(pgid int, shellPid int) ([]string, error)) *MockProcessInspector_GroupArgv_Call {
2927- _c.Call.Return(run)
2928- return _c
2929-}
2930-
2931-// 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.
2932-// The first argument is typically a *testing.T value.
2933-func NewMockClipboardReader(t interface {
2934- mock.TestingT
2935- Cleanup(func())
2936-}) *MockClipboardReader {
2937- mock := &MockClipboardReader{}
2938- mock.Mock.Test(t)
2939-
2940- t.Cleanup(func() { mock.AssertExpectations(t) })
2941-
2942- return mock
2943-}
2944-
2945-// MockClipboardReader is an autogenerated mock type for the ClipboardReader type
2946-type MockClipboardReader struct {
2947- mock.Mock
2948-}
2949-
2950-type MockClipboardReader_Expecter struct {
2951- mock *mock.Mock
2952-}
2953-
2954-func (_m *MockClipboardReader) EXPECT() *MockClipboardReader_Expecter {
2955- return &MockClipboardReader_Expecter{mock: &_m.Mock}
2956-}
2957-
2958-// ReadImage provides a mock function for the type MockClipboardReader
2959-func (_mock *MockClipboardReader) ReadImage(ctx context.Context) (string, []byte, error) {
2960- ret := _mock.Called(ctx)
2961-
2962- if len(ret) == 0 {
2963- panic("no return value specified for ReadImage")
2964- }
2965-
2966- var r0 string
2967- var r1 []byte
2968- var r2 error
2969- if returnFunc, ok := ret.Get(0).(func(context.Context) (string, []byte, error)); ok {
2970- return returnFunc(ctx)
2971- }
2972- if returnFunc, ok := ret.Get(0).(func(context.Context) string); ok {
2973- r0 = returnFunc(ctx)
2974- } else {
2975- r0 = ret.Get(0).(string)
2976- }
2977- if returnFunc, ok := ret.Get(1).(func(context.Context) []byte); ok {
2978- r1 = returnFunc(ctx)
2979- } else {
2980- if ret.Get(1) != nil {
2981- r1 = ret.Get(1).([]byte)
2982- }
2983- }
2984- if returnFunc, ok := ret.Get(2).(func(context.Context) error); ok {
2985- r2 = returnFunc(ctx)
2986- } else {
2987- r2 = ret.Error(2)
2988- }
2989- return r0, r1, r2
2990-}
2991-
2992-// MockClipboardReader_ReadImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadImage'
2993-type MockClipboardReader_ReadImage_Call struct {
2994- *mock.Call
2995-}
2996-
2997-// ReadImage is a helper method to define mock.On call
2998-// - ctx context.Context
2999-func (_e *MockClipboardReader_Expecter) ReadImage(ctx any) *MockClipboardReader_ReadImage_Call {
3000- return &MockClipboardReader_ReadImage_Call{Call: _e.mock.On("ReadImage", ctx)}
3001-}
3002-
3003-func (_c *MockClipboardReader_ReadImage_Call) Run(run func(ctx context.Context)) *MockClipboardReader_ReadImage_Call {
3004- _c.Call.Run(func(args mock.Arguments) {
3005- var arg0 context.Context
3006- if args[0] != nil {
3007- arg0 = args[0].(context.Context)
3008- }
3009- run(
3010- arg0,
3011- )
3012- })
3013- return _c
3014-}
3015-
3016-func (_c *MockClipboardReader_ReadImage_Call) Return(mime string, data []byte, err error) *MockClipboardReader_ReadImage_Call {
3017- _c.Call.Return(mime, data, err)
3018- return _c
3019-}
3020-
3021-func (_c *MockClipboardReader_ReadImage_Call) RunAndReturn(run func(ctx context.Context) (string, []byte, error)) *MockClipboardReader_ReadImage_Call {
3022- _c.Call.Return(run)
3023- return _c
3024-}
3025-
3026-// 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.
3027-// The first argument is typically a *testing.T value.
3028-func NewMockRemoteDialerFactory(t interface {
3029- mock.TestingT
3030- Cleanup(func())
3031-}) *MockRemoteDialerFactory {
3032- mock := &MockRemoteDialerFactory{}
3033- mock.Mock.Test(t)
3034-
3035- t.Cleanup(func() { mock.AssertExpectations(t) })
3036-
3037- return mock
3038-}
3039-
3040-// MockRemoteDialerFactory is an autogenerated mock type for the RemoteDialerFactory type
3041-type MockRemoteDialerFactory struct {
3042- mock.Mock
3043-}
3044-
3045-type MockRemoteDialerFactory_Expecter struct {
3046- mock *mock.Mock
3047-}
3048-
3049-func (_m *MockRemoteDialerFactory) EXPECT() *MockRemoteDialerFactory_Expecter {
3050- return &MockRemoteDialerFactory_Expecter{mock: &_m.Mock}
3051-}
3052-
3053-// DialerForRemote provides a mock function for the type MockRemoteDialerFactory
3054-func (_mock *MockRemoteDialerFactory) DialerForRemote(target string, session string, mode ports.RemoteTransportMode, log *slog.Logger) (ports.Dialer, error) {
3055- ret := _mock.Called(target, session, mode, log)
3056-
3057- if len(ret) == 0 {
3058- panic("no return value specified for DialerForRemote")
3059- }
3060-
3061- var r0 ports.Dialer
3062- var r1 error
3063- if returnFunc, ok := ret.Get(0).(func(string, string, ports.RemoteTransportMode, *slog.Logger) (ports.Dialer, error)); ok {
3064- return returnFunc(target, session, mode, log)
3065- }
3066- if returnFunc, ok := ret.Get(0).(func(string, string, ports.RemoteTransportMode, *slog.Logger) ports.Dialer); ok {
3067- r0 = returnFunc(target, session, mode, log)
3068- } else {
3069- if ret.Get(0) != nil {
3070- r0 = ret.Get(0).(ports.Dialer)
3071- }
3072- }
3073- if returnFunc, ok := ret.Get(1).(func(string, string, ports.RemoteTransportMode, *slog.Logger) error); ok {
3074- r1 = returnFunc(target, session, mode, log)
3075- } else {
3076- r1 = ret.Error(1)
3077- }
3078- return r0, r1
3079-}
3080-
3081-// MockRemoteDialerFactory_DialerForRemote_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DialerForRemote'
3082-type MockRemoteDialerFactory_DialerForRemote_Call struct {
3083- *mock.Call
3084-}
3085-
3086-// DialerForRemote is a helper method to define mock.On call
3087-// - target string
3088-// - session string
3089-// - mode ports.RemoteTransportMode
3090-// - log *slog.Logger
3091-func (_e *MockRemoteDialerFactory_Expecter) DialerForRemote(target any, session any, mode any, log any) *MockRemoteDialerFactory_DialerForRemote_Call {
3092- return &MockRemoteDialerFactory_DialerForRemote_Call{Call: _e.mock.On("DialerForRemote", target, session, mode, log)}
3093-}
3094-
3095-func (_c *MockRemoteDialerFactory_DialerForRemote_Call) Run(run func(target string, session string, mode ports.RemoteTransportMode, log *slog.Logger)) *MockRemoteDialerFactory_DialerForRemote_Call {
3096- _c.Call.Run(func(args mock.Arguments) {
3097- var arg0 string
3098- if args[0] != nil {
3099- arg0 = args[0].(string)
3100- }
3101- var arg1 string
3102- if args[1] != nil {
3103- arg1 = args[1].(string)
3104- }
3105- var arg2 ports.RemoteTransportMode
3106- if args[2] != nil {
3107- arg2 = args[2].(ports.RemoteTransportMode)
3108- }
3109- var arg3 *slog.Logger
3110- if args[3] != nil {
3111- arg3 = args[3].(*slog.Logger)
3112- }
3113- run(
3114- arg0,
3115- arg1,
3116- arg2,
3117- arg3,
3118- )
3119- })
3120- return _c
3121-}
3122-
3123-func (_c *MockRemoteDialerFactory_DialerForRemote_Call) Return(dialer ports.Dialer, err error) *MockRemoteDialerFactory_DialerForRemote_Call {
3124- _c.Call.Return(dialer, err)
3125- return _c
3126-}
3127-
3128-func (_c *MockRemoteDialerFactory_DialerForRemote_Call) RunAndReturn(run func(target string, session string, mode ports.RemoteTransportMode, log *slog.Logger) (ports.Dialer, error)) *MockRemoteDialerFactory_DialerForRemote_Call {
3129- _c.Call.Return(run)
3130- return _c
3131-}
3132-
3133-// 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.
3134-// The first argument is typically a *testing.T value.
3135-func NewMockRuntimeObserver(t interface {
3136- mock.TestingT
3137- Cleanup(func())
3138-}) *MockRuntimeObserver {
3139- mock := &MockRuntimeObserver{}
3140- mock.Mock.Test(t)
3141-
3142- t.Cleanup(func() { mock.AssertExpectations(t) })
3143-
3144- return mock
3145-}
3146-
3147-// MockRuntimeObserver is an autogenerated mock type for the RuntimeObserver type
3148-type MockRuntimeObserver struct {
3149- mock.Mock
3150-}
3151-
3152-type MockRuntimeObserver_Expecter struct {
3153- mock *mock.Mock
3154-}
3155-
3156-func (_m *MockRuntimeObserver) EXPECT() *MockRuntimeObserver_Expecter {
3157- return &MockRuntimeObserver_Expecter{mock: &_m.Mock}
3158-}
3159-
3160-// ObserveRuntime provides a mock function for the type MockRuntimeObserver
3161-func (_mock *MockRuntimeObserver) ObserveRuntime(runtimeMark ports.RuntimeMark) {
3162- _mock.Called(runtimeMark)
3163- return
3164-}
3165-
3166-// MockRuntimeObserver_ObserveRuntime_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ObserveRuntime'
3167-type MockRuntimeObserver_ObserveRuntime_Call struct {
3168- *mock.Call
3169-}
3170-
3171-// ObserveRuntime is a helper method to define mock.On call
3172-// - runtimeMark ports.RuntimeMark
3173-func (_e *MockRuntimeObserver_Expecter) ObserveRuntime(runtimeMark any) *MockRuntimeObserver_ObserveRuntime_Call {
3174- return &MockRuntimeObserver_ObserveRuntime_Call{Call: _e.mock.On("ObserveRuntime", runtimeMark)}
3175-}
3176-
3177-func (_c *MockRuntimeObserver_ObserveRuntime_Call) Run(run func(runtimeMark ports.RuntimeMark)) *MockRuntimeObserver_ObserveRuntime_Call {
3178- _c.Call.Run(func(args mock.Arguments) {
3179- var arg0 ports.RuntimeMark
3180- if args[0] != nil {
3181- arg0 = args[0].(ports.RuntimeMark)
3182- }
3183- run(
3184- arg0,
3185- )
3186- })
3187- return _c
3188-}
3189-
3190-func (_c *MockRuntimeObserver_ObserveRuntime_Call) Return() *MockRuntimeObserver_ObserveRuntime_Call {
3191- _c.Call.Return()
3192- return _c
3193-}
3194-
3195-func (_c *MockRuntimeObserver_ObserveRuntime_Call) RunAndReturn(run func(runtimeMark ports.RuntimeMark)) *MockRuntimeObserver_ObserveRuntime_Call {
3196- _c.Run(run)
3197- return _c
3198-}
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+}
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+}
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+}
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+}
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+}
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+}
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+}
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+}

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