1// Code generated by mockery; DO NOT EDIT.
2// github.com/vektra/mockery
3// template: testify
4
5package mocks
6
7import (
8 "context"
9
10 "github.com/bnema/dumber/internal/application/port"
11 mock "github.com/stretchr/testify/mock"
12)
13
14// NewMockKeybindingsProvider creates a new instance of MockKeybindingsProvider. 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.
16func NewMockKeybindingsProvider(t interface {
17 mock.TestingT
18 Cleanup(func())
19}) *MockKeybindingsProvider {
20 mock := &MockKeybindingsProvider{}
21 mock.Mock.Test(t)
22
23 t.Cleanup(func() { mock.AssertExpectations(t) })
24
25 return mock
26}
27
28// MockKeybindingsProvider is an autogenerated mock type for the KeybindingsProvider type
29type MockKeybindingsProvider struct {
30 mock.Mock
31}
32
33type MockKeybindingsProvider_Expecter struct {
34 mock *mock.Mock
35}
36
37func (_m *MockKeybindingsProvider) EXPECT() *MockKeybindingsProvider_Expecter {
38 return &MockKeybindingsProvider_Expecter{mock: &_m.Mock}
39}
40
41// CheckConflicts provides a mock function for the type MockKeybindingsProvider
42func (_mock *MockKeybindingsProvider) CheckConflicts(ctx context.Context, mode string, action string, keys []string) ([]port.KeybindingConflict, error) {
43 ret := _mock.Called(ctx, mode, action, keys)
44
45 if len(ret) == 0 {
46 panic("no return value specified for CheckConflicts")
47 }
48
49 var r0 []port.KeybindingConflict
50 var r1 error
51 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, []string) ([]port.KeybindingConflict, error)); ok {
52 return returnFunc(ctx, mode, action, keys)
53 }
54 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, []string) []port.KeybindingConflict); ok {
55 r0 = returnFunc(ctx, mode, action, keys)
56 } else {
57 if ret.Get(0) != nil {
58 r0 = ret.Get(0).([]port.KeybindingConflict)
59 }
60 }
61 if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, []string) error); ok {
62 r1 = returnFunc(ctx, mode, action, keys)
63 } else {
64 r1 = ret.Error(1)
65 }
66 return r0, r1
67}
68
69// MockKeybindingsProvider_CheckConflicts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckConflicts'
70type MockKeybindingsProvider_CheckConflicts_Call struct {
71 *mock.Call
72}
73
74// CheckConflicts is a helper method to define mock.On call
75// - ctx context.Context
76// - mode string
77// - action string
78// - keys []string
79func (_e *MockKeybindingsProvider_Expecter) CheckConflicts(ctx any, mode any, action any, keys any) *MockKeybindingsProvider_CheckConflicts_Call {
80 return &MockKeybindingsProvider_CheckConflicts_Call{Call: _e.mock.On("CheckConflicts", ctx, mode, action, keys)}
81}
82
83func (_c *MockKeybindingsProvider_CheckConflicts_Call) Run(run func(ctx context.Context, mode string, action string, keys []string)) *MockKeybindingsProvider_CheckConflicts_Call {
84 _c.Call.Run(func(args mock.Arguments) {
85 var arg0 context.Context
86 if args[0] != nil {
87 arg0 = args[0].(context.Context)
88 }
89 var arg1 string
90 if args[1] != nil {
91 arg1 = args[1].(string)
92 }
93 var arg2 string
94 if args[2] != nil {
95 arg2 = args[2].(string)
96 }
97 var arg3 []string
98 if args[3] != nil {
99 arg3 = args[3].([]string)
100 }
101 run(
102 arg0,
103 arg1,
104 arg2,
105 arg3,
106 )
107 })
108 return _c
109}
110
111func (_c *MockKeybindingsProvider_CheckConflicts_Call) Return(keybindingConflicts []port.KeybindingConflict, err error) *MockKeybindingsProvider_CheckConflicts_Call {
112 _c.Call.Return(keybindingConflicts, err)
113 return _c
114}
115
116func (_c *MockKeybindingsProvider_CheckConflicts_Call) RunAndReturn(run func(ctx context.Context, mode string, action string, keys []string) ([]port.KeybindingConflict, error)) *MockKeybindingsProvider_CheckConflicts_Call {
117 _c.Call.Return(run)
118 return _c
119}
120
121// GetDefaultKeybindings provides a mock function for the type MockKeybindingsProvider
122func (_mock *MockKeybindingsProvider) GetDefaultKeybindings(ctx context.Context) (port.KeybindingsConfig, error) {
123 ret := _mock.Called(ctx)
124
125 if len(ret) == 0 {
126 panic("no return value specified for GetDefaultKeybindings")
127 }
128
129 var r0 port.KeybindingsConfig
130 var r1 error
131 if returnFunc, ok := ret.Get(0).(func(context.Context) (port.KeybindingsConfig, error)); ok {
132 return returnFunc(ctx)
133 }
134 if returnFunc, ok := ret.Get(0).(func(context.Context) port.KeybindingsConfig); ok {
135 r0 = returnFunc(ctx)
136 } else {
137 r0 = ret.Get(0).(port.KeybindingsConfig)
138 }
139 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
140 r1 = returnFunc(ctx)
141 } else {
142 r1 = ret.Error(1)
143 }
144 return r0, r1
145}
146
147// MockKeybindingsProvider_GetDefaultKeybindings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDefaultKeybindings'
148type MockKeybindingsProvider_GetDefaultKeybindings_Call struct {
149 *mock.Call
150}
151
152// GetDefaultKeybindings is a helper method to define mock.On call
153// - ctx context.Context
154func (_e *MockKeybindingsProvider_Expecter) GetDefaultKeybindings(ctx any) *MockKeybindingsProvider_GetDefaultKeybindings_Call {
155 return &MockKeybindingsProvider_GetDefaultKeybindings_Call{Call: _e.mock.On("GetDefaultKeybindings", ctx)}
156}
157
158func (_c *MockKeybindingsProvider_GetDefaultKeybindings_Call) Run(run func(ctx context.Context)) *MockKeybindingsProvider_GetDefaultKeybindings_Call {
159 _c.Call.Run(func(args mock.Arguments) {
160 var arg0 context.Context
161 if args[0] != nil {
162 arg0 = args[0].(context.Context)
163 }
164 run(
165 arg0,
166 )
167 })
168 return _c
169}
170
171func (_c *MockKeybindingsProvider_GetDefaultKeybindings_Call) Return(keybindingsConfig port.KeybindingsConfig, err error) *MockKeybindingsProvider_GetDefaultKeybindings_Call {
172 _c.Call.Return(keybindingsConfig, err)
173 return _c
174}
175
176func (_c *MockKeybindingsProvider_GetDefaultKeybindings_Call) RunAndReturn(run func(ctx context.Context) (port.KeybindingsConfig, error)) *MockKeybindingsProvider_GetDefaultKeybindings_Call {
177 _c.Call.Return(run)
178 return _c
179}
180
181// GetKeybindings provides a mock function for the type MockKeybindingsProvider
182func (_mock *MockKeybindingsProvider) GetKeybindings(ctx context.Context) (port.KeybindingsConfig, error) {
183 ret := _mock.Called(ctx)
184
185 if len(ret) == 0 {
186 panic("no return value specified for GetKeybindings")
187 }
188
189 var r0 port.KeybindingsConfig
190 var r1 error
191 if returnFunc, ok := ret.Get(0).(func(context.Context) (port.KeybindingsConfig, error)); ok {
192 return returnFunc(ctx)
193 }
194 if returnFunc, ok := ret.Get(0).(func(context.Context) port.KeybindingsConfig); ok {
195 r0 = returnFunc(ctx)
196 } else {
197 r0 = ret.Get(0).(port.KeybindingsConfig)
198 }
199 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
200 r1 = returnFunc(ctx)
201 } else {
202 r1 = ret.Error(1)
203 }
204 return r0, r1
205}
206
207// MockKeybindingsProvider_GetKeybindings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetKeybindings'
208type MockKeybindingsProvider_GetKeybindings_Call struct {
209 *mock.Call
210}
211
212// GetKeybindings is a helper method to define mock.On call
213// - ctx context.Context
214func (_e *MockKeybindingsProvider_Expecter) GetKeybindings(ctx any) *MockKeybindingsProvider_GetKeybindings_Call {
215 return &MockKeybindingsProvider_GetKeybindings_Call{Call: _e.mock.On("GetKeybindings", ctx)}
216}
217
218func (_c *MockKeybindingsProvider_GetKeybindings_Call) Run(run func(ctx context.Context)) *MockKeybindingsProvider_GetKeybindings_Call {
219 _c.Call.Run(func(args mock.Arguments) {
220 var arg0 context.Context
221 if args[0] != nil {
222 arg0 = args[0].(context.Context)
223 }
224 run(
225 arg0,
226 )
227 })
228 return _c
229}
230
231func (_c *MockKeybindingsProvider_GetKeybindings_Call) Return(keybindingsConfig port.KeybindingsConfig, err error) *MockKeybindingsProvider_GetKeybindings_Call {
232 _c.Call.Return(keybindingsConfig, err)
233 return _c
234}
235
236func (_c *MockKeybindingsProvider_GetKeybindings_Call) RunAndReturn(run func(ctx context.Context) (port.KeybindingsConfig, error)) *MockKeybindingsProvider_GetKeybindings_Call {
237 _c.Call.Return(run)
238 return _c
239}
240
241// NewMockKeybindingsSaver creates a new instance of MockKeybindingsSaver. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
242// The first argument is typically a *testing.T value.
243func NewMockKeybindingsSaver(t interface {
244 mock.TestingT
245 Cleanup(func())
246}) *MockKeybindingsSaver {
247 mock := &MockKeybindingsSaver{}
248 mock.Mock.Test(t)
249
250 t.Cleanup(func() { mock.AssertExpectations(t) })
251
252 return mock
253}
254
255// MockKeybindingsSaver is an autogenerated mock type for the KeybindingsSaver type
256type MockKeybindingsSaver struct {
257 mock.Mock
258}
259
260type MockKeybindingsSaver_Expecter struct {
261 mock *mock.Mock
262}
263
264func (_m *MockKeybindingsSaver) EXPECT() *MockKeybindingsSaver_Expecter {
265 return &MockKeybindingsSaver_Expecter{mock: &_m.Mock}
266}
267
268// ResetAllKeybindings provides a mock function for the type MockKeybindingsSaver
269func (_mock *MockKeybindingsSaver) ResetAllKeybindings(ctx context.Context) error {
270 ret := _mock.Called(ctx)
271
272 if len(ret) == 0 {
273 panic("no return value specified for ResetAllKeybindings")
274 }
275
276 var r0 error
277 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
278 r0 = returnFunc(ctx)
279 } else {
280 r0 = ret.Error(0)
281 }
282 return r0
283}
284
285// MockKeybindingsSaver_ResetAllKeybindings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetAllKeybindings'
286type MockKeybindingsSaver_ResetAllKeybindings_Call struct {
287 *mock.Call
288}
289
290// ResetAllKeybindings is a helper method to define mock.On call
291// - ctx context.Context
292func (_e *MockKeybindingsSaver_Expecter) ResetAllKeybindings(ctx any) *MockKeybindingsSaver_ResetAllKeybindings_Call {
293 return &MockKeybindingsSaver_ResetAllKeybindings_Call{Call: _e.mock.On("ResetAllKeybindings", ctx)}
294}
295
296func (_c *MockKeybindingsSaver_ResetAllKeybindings_Call) Run(run func(ctx context.Context)) *MockKeybindingsSaver_ResetAllKeybindings_Call {
297 _c.Call.Run(func(args mock.Arguments) {
298 var arg0 context.Context
299 if args[0] != nil {
300 arg0 = args[0].(context.Context)
301 }
302 run(
303 arg0,
304 )
305 })
306 return _c
307}
308
309func (_c *MockKeybindingsSaver_ResetAllKeybindings_Call) Return(err error) *MockKeybindingsSaver_ResetAllKeybindings_Call {
310 _c.Call.Return(err)
311 return _c
312}
313
314func (_c *MockKeybindingsSaver_ResetAllKeybindings_Call) RunAndReturn(run func(ctx context.Context) error) *MockKeybindingsSaver_ResetAllKeybindings_Call {
315 _c.Call.Return(run)
316 return _c
317}
318
319// ResetKeybinding provides a mock function for the type MockKeybindingsSaver
320func (_mock *MockKeybindingsSaver) ResetKeybinding(ctx context.Context, req port.ResetKeybindingRequest) error {
321 ret := _mock.Called(ctx, req)
322
323 if len(ret) == 0 {
324 panic("no return value specified for ResetKeybinding")
325 }
326
327 var r0 error
328 if returnFunc, ok := ret.Get(0).(func(context.Context, port.ResetKeybindingRequest) error); ok {
329 r0 = returnFunc(ctx, req)
330 } else {
331 r0 = ret.Error(0)
332 }
333 return r0
334}
335
336// MockKeybindingsSaver_ResetKeybinding_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetKeybinding'
337type MockKeybindingsSaver_ResetKeybinding_Call struct {
338 *mock.Call
339}
340
341// ResetKeybinding is a helper method to define mock.On call
342// - ctx context.Context
343// - req port.ResetKeybindingRequest
344func (_e *MockKeybindingsSaver_Expecter) ResetKeybinding(ctx any, req any) *MockKeybindingsSaver_ResetKeybinding_Call {
345 return &MockKeybindingsSaver_ResetKeybinding_Call{Call: _e.mock.On("ResetKeybinding", ctx, req)}
346}
347
348func (_c *MockKeybindingsSaver_ResetKeybinding_Call) Run(run func(ctx context.Context, req port.ResetKeybindingRequest)) *MockKeybindingsSaver_ResetKeybinding_Call {
349 _c.Call.Run(func(args mock.Arguments) {
350 var arg0 context.Context
351 if args[0] != nil {
352 arg0 = args[0].(context.Context)
353 }
354 var arg1 port.ResetKeybindingRequest
355 if args[1] != nil {
356 arg1 = args[1].(port.ResetKeybindingRequest)
357 }
358 run(
359 arg0,
360 arg1,
361 )
362 })
363 return _c
364}
365
366func (_c *MockKeybindingsSaver_ResetKeybinding_Call) Return(err error) *MockKeybindingsSaver_ResetKeybinding_Call {
367 _c.Call.Return(err)
368 return _c
369}
370
371func (_c *MockKeybindingsSaver_ResetKeybinding_Call) RunAndReturn(run func(ctx context.Context, req port.ResetKeybindingRequest) error) *MockKeybindingsSaver_ResetKeybinding_Call {
372 _c.Call.Return(run)
373 return _c
374}
375
376// SetKeybinding provides a mock function for the type MockKeybindingsSaver
377func (_mock *MockKeybindingsSaver) SetKeybinding(ctx context.Context, req port.SetKeybindingRequest) error {
378 ret := _mock.Called(ctx, req)
379
380 if len(ret) == 0 {
381 panic("no return value specified for SetKeybinding")
382 }
383
384 var r0 error
385 if returnFunc, ok := ret.Get(0).(func(context.Context, port.SetKeybindingRequest) error); ok {
386 r0 = returnFunc(ctx, req)
387 } else {
388 r0 = ret.Error(0)
389 }
390 return r0
391}
392
393// MockKeybindingsSaver_SetKeybinding_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetKeybinding'
394type MockKeybindingsSaver_SetKeybinding_Call struct {
395 *mock.Call
396}
397
398// SetKeybinding is a helper method to define mock.On call
399// - ctx context.Context
400// - req port.SetKeybindingRequest
401func (_e *MockKeybindingsSaver_Expecter) SetKeybinding(ctx any, req any) *MockKeybindingsSaver_SetKeybinding_Call {
402 return &MockKeybindingsSaver_SetKeybinding_Call{Call: _e.mock.On("SetKeybinding", ctx, req)}
403}
404
405func (_c *MockKeybindingsSaver_SetKeybinding_Call) Run(run func(ctx context.Context, req port.SetKeybindingRequest)) *MockKeybindingsSaver_SetKeybinding_Call {
406 _c.Call.Run(func(args mock.Arguments) {
407 var arg0 context.Context
408 if args[0] != nil {
409 arg0 = args[0].(context.Context)
410 }
411 var arg1 port.SetKeybindingRequest
412 if args[1] != nil {
413 arg1 = args[1].(port.SetKeybindingRequest)
414 }
415 run(
416 arg0,
417 arg1,
418 )
419 })
420 return _c
421}
422
423func (_c *MockKeybindingsSaver_SetKeybinding_Call) Return(err error) *MockKeybindingsSaver_SetKeybinding_Call {
424 _c.Call.Return(err)
425 return _c
426}
427
428func (_c *MockKeybindingsSaver_SetKeybinding_Call) RunAndReturn(run func(ctx context.Context, req port.SetKeybindingRequest) error) *MockKeybindingsSaver_SetKeybinding_Call {
429 _c.Call.Return(run)
430 return _c
431}
432
433// NewMockKeybindingsGetter creates a new instance of MockKeybindingsGetter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
434// The first argument is typically a *testing.T value.
435func NewMockKeybindingsGetter(t interface {
436 mock.TestingT
437 Cleanup(func())
438}) *MockKeybindingsGetter {
439 mock := &MockKeybindingsGetter{}
440 mock.Mock.Test(t)
441
442 t.Cleanup(func() { mock.AssertExpectations(t) })
443
444 return mock
445}
446
447// MockKeybindingsGetter is an autogenerated mock type for the KeybindingsGetter type
448type MockKeybindingsGetter struct {
449 mock.Mock
450}
451
452type MockKeybindingsGetter_Expecter struct {
453 mock *mock.Mock
454}
455
456func (_m *MockKeybindingsGetter) EXPECT() *MockKeybindingsGetter_Expecter {
457 return &MockKeybindingsGetter_Expecter{mock: &_m.Mock}
458}
459
460// Execute provides a mock function for the type MockKeybindingsGetter
461func (_mock *MockKeybindingsGetter) Execute(ctx context.Context) (port.KeybindingsConfig, error) {
462 ret := _mock.Called(ctx)
463
464 if len(ret) == 0 {
465 panic("no return value specified for Execute")
466 }
467
468 var r0 port.KeybindingsConfig
469 var r1 error
470 if returnFunc, ok := ret.Get(0).(func(context.Context) (port.KeybindingsConfig, error)); ok {
471 return returnFunc(ctx)
472 }
473 if returnFunc, ok := ret.Get(0).(func(context.Context) port.KeybindingsConfig); ok {
474 r0 = returnFunc(ctx)
475 } else {
476 r0 = ret.Get(0).(port.KeybindingsConfig)
477 }
478 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
479 r1 = returnFunc(ctx)
480 } else {
481 r1 = ret.Error(1)
482 }
483 return r0, r1
484}
485
486// MockKeybindingsGetter_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute'
487type MockKeybindingsGetter_Execute_Call struct {
488 *mock.Call
489}
490
491// Execute is a helper method to define mock.On call
492// - ctx context.Context
493func (_e *MockKeybindingsGetter_Expecter) Execute(ctx any) *MockKeybindingsGetter_Execute_Call {
494 return &MockKeybindingsGetter_Execute_Call{Call: _e.mock.On("Execute", ctx)}
495}
496
497func (_c *MockKeybindingsGetter_Execute_Call) Run(run func(ctx context.Context)) *MockKeybindingsGetter_Execute_Call {
498 _c.Call.Run(func(args mock.Arguments) {
499 var arg0 context.Context
500 if args[0] != nil {
501 arg0 = args[0].(context.Context)
502 }
503 run(
504 arg0,
505 )
506 })
507 return _c
508}
509
510func (_c *MockKeybindingsGetter_Execute_Call) Return(keybindingsConfig port.KeybindingsConfig, err error) *MockKeybindingsGetter_Execute_Call {
511 _c.Call.Return(keybindingsConfig, err)
512 return _c
513}
514
515func (_c *MockKeybindingsGetter_Execute_Call) RunAndReturn(run func(ctx context.Context) (port.KeybindingsConfig, error)) *MockKeybindingsGetter_Execute_Call {
516 _c.Call.Return(run)
517 return _c
518}
519
520// NewMockKeybindingSetter creates a new instance of MockKeybindingSetter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
521// The first argument is typically a *testing.T value.
522func NewMockKeybindingSetter(t interface {
523 mock.TestingT
524 Cleanup(func())
525}) *MockKeybindingSetter {
526 mock := &MockKeybindingSetter{}
527 mock.Mock.Test(t)
528
529 t.Cleanup(func() { mock.AssertExpectations(t) })
530
531 return mock
532}
533
534// MockKeybindingSetter is an autogenerated mock type for the KeybindingSetter type
535type MockKeybindingSetter struct {
536 mock.Mock
537}
538
539type MockKeybindingSetter_Expecter struct {
540 mock *mock.Mock
541}
542
543func (_m *MockKeybindingSetter) EXPECT() *MockKeybindingSetter_Expecter {
544 return &MockKeybindingSetter_Expecter{mock: &_m.Mock}
545}
546
547// Execute provides a mock function for the type MockKeybindingSetter
548func (_mock *MockKeybindingSetter) Execute(ctx context.Context, req port.SetKeybindingRequest) (port.SetKeybindingResponse, error) {
549 ret := _mock.Called(ctx, req)
550
551 if len(ret) == 0 {
552 panic("no return value specified for Execute")
553 }
554
555 var r0 port.SetKeybindingResponse
556 var r1 error
557 if returnFunc, ok := ret.Get(0).(func(context.Context, port.SetKeybindingRequest) (port.SetKeybindingResponse, error)); ok {
558 return returnFunc(ctx, req)
559 }
560 if returnFunc, ok := ret.Get(0).(func(context.Context, port.SetKeybindingRequest) port.SetKeybindingResponse); ok {
561 r0 = returnFunc(ctx, req)
562 } else {
563 r0 = ret.Get(0).(port.SetKeybindingResponse)
564 }
565 if returnFunc, ok := ret.Get(1).(func(context.Context, port.SetKeybindingRequest) error); ok {
566 r1 = returnFunc(ctx, req)
567 } else {
568 r1 = ret.Error(1)
569 }
570 return r0, r1
571}
572
573// MockKeybindingSetter_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute'
574type MockKeybindingSetter_Execute_Call struct {
575 *mock.Call
576}
577
578// Execute is a helper method to define mock.On call
579// - ctx context.Context
580// - req port.SetKeybindingRequest
581func (_e *MockKeybindingSetter_Expecter) Execute(ctx any, req any) *MockKeybindingSetter_Execute_Call {
582 return &MockKeybindingSetter_Execute_Call{Call: _e.mock.On("Execute", ctx, req)}
583}
584
585func (_c *MockKeybindingSetter_Execute_Call) Run(run func(ctx context.Context, req port.SetKeybindingRequest)) *MockKeybindingSetter_Execute_Call {
586 _c.Call.Run(func(args mock.Arguments) {
587 var arg0 context.Context
588 if args[0] != nil {
589 arg0 = args[0].(context.Context)
590 }
591 var arg1 port.SetKeybindingRequest
592 if args[1] != nil {
593 arg1 = args[1].(port.SetKeybindingRequest)
594 }
595 run(
596 arg0,
597 arg1,
598 )
599 })
600 return _c
601}
602
603func (_c *MockKeybindingSetter_Execute_Call) Return(setKeybindingResponse port.SetKeybindingResponse, err error) *MockKeybindingSetter_Execute_Call {
604 _c.Call.Return(setKeybindingResponse, err)
605 return _c
606}
607
608func (_c *MockKeybindingSetter_Execute_Call) RunAndReturn(run func(ctx context.Context, req port.SetKeybindingRequest) (port.SetKeybindingResponse, error)) *MockKeybindingSetter_Execute_Call {
609 _c.Call.Return(run)
610 return _c
611}
612
613// NewMockKeybindingResetter creates a new instance of MockKeybindingResetter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
614// The first argument is typically a *testing.T value.
615func NewMockKeybindingResetter(t interface {
616 mock.TestingT
617 Cleanup(func())
618}) *MockKeybindingResetter {
619 mock := &MockKeybindingResetter{}
620 mock.Mock.Test(t)
621
622 t.Cleanup(func() { mock.AssertExpectations(t) })
623
624 return mock
625}
626
627// MockKeybindingResetter is an autogenerated mock type for the KeybindingResetter type
628type MockKeybindingResetter struct {
629 mock.Mock
630}
631
632type MockKeybindingResetter_Expecter struct {
633 mock *mock.Mock
634}
635
636func (_m *MockKeybindingResetter) EXPECT() *MockKeybindingResetter_Expecter {
637 return &MockKeybindingResetter_Expecter{mock: &_m.Mock}
638}
639
640// Execute provides a mock function for the type MockKeybindingResetter
641func (_mock *MockKeybindingResetter) Execute(ctx context.Context, req port.ResetKeybindingRequest) error {
642 ret := _mock.Called(ctx, req)
643
644 if len(ret) == 0 {
645 panic("no return value specified for Execute")
646 }
647
648 var r0 error
649 if returnFunc, ok := ret.Get(0).(func(context.Context, port.ResetKeybindingRequest) error); ok {
650 r0 = returnFunc(ctx, req)
651 } else {
652 r0 = ret.Error(0)
653 }
654 return r0
655}
656
657// MockKeybindingResetter_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute'
658type MockKeybindingResetter_Execute_Call struct {
659 *mock.Call
660}
661
662// Execute is a helper method to define mock.On call
663// - ctx context.Context
664// - req port.ResetKeybindingRequest
665func (_e *MockKeybindingResetter_Expecter) Execute(ctx any, req any) *MockKeybindingResetter_Execute_Call {
666 return &MockKeybindingResetter_Execute_Call{Call: _e.mock.On("Execute", ctx, req)}
667}
668
669func (_c *MockKeybindingResetter_Execute_Call) Run(run func(ctx context.Context, req port.ResetKeybindingRequest)) *MockKeybindingResetter_Execute_Call {
670 _c.Call.Run(func(args mock.Arguments) {
671 var arg0 context.Context
672 if args[0] != nil {
673 arg0 = args[0].(context.Context)
674 }
675 var arg1 port.ResetKeybindingRequest
676 if args[1] != nil {
677 arg1 = args[1].(port.ResetKeybindingRequest)
678 }
679 run(
680 arg0,
681 arg1,
682 )
683 })
684 return _c
685}
686
687func (_c *MockKeybindingResetter_Execute_Call) Return(err error) *MockKeybindingResetter_Execute_Call {
688 _c.Call.Return(err)
689 return _c
690}
691
692func (_c *MockKeybindingResetter_Execute_Call) RunAndReturn(run func(ctx context.Context, req port.ResetKeybindingRequest) error) *MockKeybindingResetter_Execute_Call {
693 _c.Call.Return(run)
694 return _c
695}
696
697// NewMockAllKeybindingsResetter creates a new instance of MockAllKeybindingsResetter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
698// The first argument is typically a *testing.T value.
699func NewMockAllKeybindingsResetter(t interface {
700 mock.TestingT
701 Cleanup(func())
702}) *MockAllKeybindingsResetter {
703 mock := &MockAllKeybindingsResetter{}
704 mock.Mock.Test(t)
705
706 t.Cleanup(func() { mock.AssertExpectations(t) })
707
708 return mock
709}
710
711// MockAllKeybindingsResetter is an autogenerated mock type for the AllKeybindingsResetter type
712type MockAllKeybindingsResetter struct {
713 mock.Mock
714}
715
716type MockAllKeybindingsResetter_Expecter struct {
717 mock *mock.Mock
718}
719
720func (_m *MockAllKeybindingsResetter) EXPECT() *MockAllKeybindingsResetter_Expecter {
721 return &MockAllKeybindingsResetter_Expecter{mock: &_m.Mock}
722}
723
724// Execute provides a mock function for the type MockAllKeybindingsResetter
725func (_mock *MockAllKeybindingsResetter) Execute(ctx context.Context) error {
726 ret := _mock.Called(ctx)
727
728 if len(ret) == 0 {
729 panic("no return value specified for Execute")
730 }
731
732 var r0 error
733 if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
734 r0 = returnFunc(ctx)
735 } else {
736 r0 = ret.Error(0)
737 }
738 return r0
739}
740
741// MockAllKeybindingsResetter_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute'
742type MockAllKeybindingsResetter_Execute_Call struct {
743 *mock.Call
744}
745
746// Execute is a helper method to define mock.On call
747// - ctx context.Context
748func (_e *MockAllKeybindingsResetter_Expecter) Execute(ctx any) *MockAllKeybindingsResetter_Execute_Call {
749 return &MockAllKeybindingsResetter_Execute_Call{Call: _e.mock.On("Execute", ctx)}
750}
751
752func (_c *MockAllKeybindingsResetter_Execute_Call) Run(run func(ctx context.Context)) *MockAllKeybindingsResetter_Execute_Call {
753 _c.Call.Run(func(args mock.Arguments) {
754 var arg0 context.Context
755 if args[0] != nil {
756 arg0 = args[0].(context.Context)
757 }
758 run(
759 arg0,
760 )
761 })
762 return _c
763}
764
765func (_c *MockAllKeybindingsResetter_Execute_Call) Return(err error) *MockAllKeybindingsResetter_Execute_Call {
766 _c.Call.Return(err)
767 return _c
768}
769
770func (_c *MockAllKeybindingsResetter_Execute_Call) RunAndReturn(run func(ctx context.Context) error) *MockAllKeybindingsResetter_Execute_Call {
771 _c.Call.Return(run)
772 return _c
773}