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// ListRefs provides a mock function for the type RepoReader
287func (_mock *RepoReader) ListRefs(ctx context.Context, repo domain.RepoName) ([]domain.Ref, error) {
288 ret := _mock.Called(ctx, repo)
289
290 if len(ret) == 0 {
291 panic("no return value specified for ListRefs")
292 }
293
294 var r0 []domain.Ref
295 var r1 error
296 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName) ([]domain.Ref, error)); ok {
297 return returnFunc(ctx, repo)
298 }
299 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName) []domain.Ref); ok {
300 r0 = returnFunc(ctx, repo)
301 } else {
302 if ret.Get(0) != nil {
303 r0 = ret.Get(0).([]domain.Ref)
304 }
305 }
306 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RepoName) error); ok {
307 r1 = returnFunc(ctx, repo)
308 } else {
309 r1 = ret.Error(1)
310 }
311 return r0, r1
312}
313
314// RepoReader_ListRefs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRefs'
315type RepoReader_ListRefs_Call struct {
316 *mock.Call
317}
318
319// ListRefs is a helper method to define mock.On call
320// - ctx context.Context
321// - repo domain.RepoName
322func (_e *RepoReader_Expecter) ListRefs(ctx any, repo any) *RepoReader_ListRefs_Call {
323 return &RepoReader_ListRefs_Call{Call: _e.mock.On("ListRefs", ctx, repo)}
324}
325
326func (_c *RepoReader_ListRefs_Call) Run(run func(ctx context.Context, repo domain.RepoName)) *RepoReader_ListRefs_Call {
327 _c.Call.Run(func(args mock.Arguments) {
328 var arg0 context.Context
329 if args[0] != nil {
330 arg0 = args[0].(context.Context)
331 }
332 var arg1 domain.RepoName
333 if args[1] != nil {
334 arg1 = args[1].(domain.RepoName)
335 }
336 run(
337 arg0,
338 arg1,
339 )
340 })
341 return _c
342}
343
344func (_c *RepoReader_ListRefs_Call) Return(refs []domain.Ref, err error) *RepoReader_ListRefs_Call {
345 _c.Call.Return(refs, err)
346 return _c
347}
348
349func (_c *RepoReader_ListRefs_Call) RunAndReturn(run func(ctx context.Context, repo domain.RepoName) ([]domain.Ref, error)) *RepoReader_ListRefs_Call {
350 _c.Call.Return(run)
351 return _c
352}
353
354// OpenBlob provides a mock function for the type RepoReader
355func (_mock *RepoReader) OpenBlob(ctx context.Context, repo domain.RepoName, rev domain.Revision, path domain.TreePath) (domain.BlobInfo, io.ReadCloser, error) {
356 ret := _mock.Called(ctx, repo, rev, path)
357
358 if len(ret) == 0 {
359 panic("no return value specified for OpenBlob")
360 }
361
362 var r0 domain.BlobInfo
363 var r1 io.ReadCloser
364 var r2 error
365 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName, domain.Revision, domain.TreePath) (domain.BlobInfo, io.ReadCloser, error)); ok {
366 return returnFunc(ctx, repo, rev, path)
367 }
368 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName, domain.Revision, domain.TreePath) domain.BlobInfo); ok {
369 r0 = returnFunc(ctx, repo, rev, path)
370 } else {
371 r0 = ret.Get(0).(domain.BlobInfo)
372 }
373 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RepoName, domain.Revision, domain.TreePath) io.ReadCloser); ok {
374 r1 = returnFunc(ctx, repo, rev, path)
375 } else {
376 if ret.Get(1) != nil {
377 r1 = ret.Get(1).(io.ReadCloser)
378 }
379 }
380 if returnFunc, ok := ret.Get(2).(func(context.Context, domain.RepoName, domain.Revision, domain.TreePath) error); ok {
381 r2 = returnFunc(ctx, repo, rev, path)
382 } else {
383 r2 = ret.Error(2)
384 }
385 return r0, r1, r2
386}
387
388// RepoReader_OpenBlob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OpenBlob'
389type RepoReader_OpenBlob_Call struct {
390 *mock.Call
391}
392
393// OpenBlob is a helper method to define mock.On call
394// - ctx context.Context
395// - repo domain.RepoName
396// - rev domain.Revision
397// - path domain.TreePath
398func (_e *RepoReader_Expecter) OpenBlob(ctx any, repo any, rev any, path any) *RepoReader_OpenBlob_Call {
399 return &RepoReader_OpenBlob_Call{Call: _e.mock.On("OpenBlob", ctx, repo, rev, path)}
400}
401
402func (_c *RepoReader_OpenBlob_Call) Run(run func(ctx context.Context, repo domain.RepoName, rev domain.Revision, path domain.TreePath)) *RepoReader_OpenBlob_Call {
403 _c.Call.Run(func(args mock.Arguments) {
404 var arg0 context.Context
405 if args[0] != nil {
406 arg0 = args[0].(context.Context)
407 }
408 var arg1 domain.RepoName
409 if args[1] != nil {
410 arg1 = args[1].(domain.RepoName)
411 }
412 var arg2 domain.Revision
413 if args[2] != nil {
414 arg2 = args[2].(domain.Revision)
415 }
416 var arg3 domain.TreePath
417 if args[3] != nil {
418 arg3 = args[3].(domain.TreePath)
419 }
420 run(
421 arg0,
422 arg1,
423 arg2,
424 arg3,
425 )
426 })
427 return _c
428}
429
430func (_c *RepoReader_OpenBlob_Call) Return(blobInfo domain.BlobInfo, readCloser io.ReadCloser, err error) *RepoReader_OpenBlob_Call {
431 _c.Call.Return(blobInfo, readCloser, err)
432 return _c
433}
434
435func (_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 {
436 _c.Call.Return(run)
437 return _c
438}
439
440// ResolveRefPath provides a mock function for the type RepoReader
441func (_mock *RepoReader) ResolveRefPath(ctx context.Context, repo domain.RepoName, path string) (domain.RefPath, error) {
442 ret := _mock.Called(ctx, repo, path)
443
444 if len(ret) == 0 {
445 panic("no return value specified for ResolveRefPath")
446 }
447
448 var r0 domain.RefPath
449 var r1 error
450 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName, string) (domain.RefPath, error)); ok {
451 return returnFunc(ctx, repo, path)
452 }
453 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName, string) domain.RefPath); ok {
454 r0 = returnFunc(ctx, repo, path)
455 } else {
456 r0 = ret.Get(0).(domain.RefPath)
457 }
458 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RepoName, string) error); ok {
459 r1 = returnFunc(ctx, repo, path)
460 } else {
461 r1 = ret.Error(1)
462 }
463 return r0, r1
464}
465
466// RepoReader_ResolveRefPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResolveRefPath'
467type RepoReader_ResolveRefPath_Call struct {
468 *mock.Call
469}
470
471// ResolveRefPath is a helper method to define mock.On call
472// - ctx context.Context
473// - repo domain.RepoName
474// - path string
475func (_e *RepoReader_Expecter) ResolveRefPath(ctx any, repo any, path any) *RepoReader_ResolveRefPath_Call {
476 return &RepoReader_ResolveRefPath_Call{Call: _e.mock.On("ResolveRefPath", ctx, repo, path)}
477}
478
479func (_c *RepoReader_ResolveRefPath_Call) Run(run func(ctx context.Context, repo domain.RepoName, path string)) *RepoReader_ResolveRefPath_Call {
480 _c.Call.Run(func(args mock.Arguments) {
481 var arg0 context.Context
482 if args[0] != nil {
483 arg0 = args[0].(context.Context)
484 }
485 var arg1 domain.RepoName
486 if args[1] != nil {
487 arg1 = args[1].(domain.RepoName)
488 }
489 var arg2 string
490 if args[2] != nil {
491 arg2 = args[2].(string)
492 }
493 run(
494 arg0,
495 arg1,
496 arg2,
497 )
498 })
499 return _c
500}
501
502func (_c *RepoReader_ResolveRefPath_Call) Return(refPath domain.RefPath, err error) *RepoReader_ResolveRefPath_Call {
503 _c.Call.Return(refPath, err)
504 return _c
505}
506
507func (_c *RepoReader_ResolveRefPath_Call) RunAndReturn(run func(ctx context.Context, repo domain.RepoName, path string) (domain.RefPath, error)) *RepoReader_ResolveRefPath_Call {
508 _c.Call.Return(run)
509 return _c
510}
511
512// ResolveRevision provides a mock function for the type RepoReader
513func (_mock *RepoReader) ResolveRevision(ctx context.Context, repo domain.RepoName, rev domain.Revision) (domain.ResolvedRevision, error) {
514 ret := _mock.Called(ctx, repo, rev)
515
516 if len(ret) == 0 {
517 panic("no return value specified for ResolveRevision")
518 }
519
520 var r0 domain.ResolvedRevision
521 var r1 error
522 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName, domain.Revision) (domain.ResolvedRevision, error)); ok {
523 return returnFunc(ctx, repo, rev)
524 }
525 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName, domain.Revision) domain.ResolvedRevision); ok {
526 r0 = returnFunc(ctx, repo, rev)
527 } else {
528 r0 = ret.Get(0).(domain.ResolvedRevision)
529 }
530 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RepoName, domain.Revision) error); ok {
531 r1 = returnFunc(ctx, repo, rev)
532 } else {
533 r1 = ret.Error(1)
534 }
535 return r0, r1
536}
537
538// RepoReader_ResolveRevision_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResolveRevision'
539type RepoReader_ResolveRevision_Call struct {
540 *mock.Call
541}
542
543// ResolveRevision is a helper method to define mock.On call
544// - ctx context.Context
545// - repo domain.RepoName
546// - rev domain.Revision
547func (_e *RepoReader_Expecter) ResolveRevision(ctx any, repo any, rev any) *RepoReader_ResolveRevision_Call {
548 return &RepoReader_ResolveRevision_Call{Call: _e.mock.On("ResolveRevision", ctx, repo, rev)}
549}
550
551func (_c *RepoReader_ResolveRevision_Call) Run(run func(ctx context.Context, repo domain.RepoName, rev domain.Revision)) *RepoReader_ResolveRevision_Call {
552 _c.Call.Run(func(args mock.Arguments) {
553 var arg0 context.Context
554 if args[0] != nil {
555 arg0 = args[0].(context.Context)
556 }
557 var arg1 domain.RepoName
558 if args[1] != nil {
559 arg1 = args[1].(domain.RepoName)
560 }
561 var arg2 domain.Revision
562 if args[2] != nil {
563 arg2 = args[2].(domain.Revision)
564 }
565 run(
566 arg0,
567 arg1,
568 arg2,
569 )
570 })
571 return _c
572}
573
574func (_c *RepoReader_ResolveRevision_Call) Return(resolvedRevision domain.ResolvedRevision, err error) *RepoReader_ResolveRevision_Call {
575 _c.Call.Return(resolvedRevision, err)
576 return _c
577}
578
579func (_c *RepoReader_ResolveRevision_Call) RunAndReturn(run func(ctx context.Context, repo domain.RepoName, rev domain.Revision) (domain.ResolvedRevision, error)) *RepoReader_ResolveRevision_Call {
580 _c.Call.Return(run)
581 return _c
582}