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