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