1// Code generated by mockery; DO NOT EDIT.
2// github.com/vektra/mockery
3// template: testify
4
5package mocks
6
7import (
8 "context"
9 "time"
10
11 "bnema.dev/ermite/internal/domain"
12 "bnema.dev/ermite/internal/ports"
13 mock "github.com/stretchr/testify/mock"
14)
15
16// NewCIStore creates a new instance of CIStore. 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 NewCIStore(t interface {
19 mock.TestingT
20 Cleanup(func())
21}) *CIStore {
22 if helper, ok := t.(interface{ Helper() }); ok {
23 helper.Helper()
24 }
25
26 mock := &CIStore{}
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// CIStore is an autogenerated mock type for the CIStore type
40type CIStore struct {
41 mock.Mock
42}
43
44type CIStore_Expecter struct {
45 mock *mock.Mock
46}
47
48func (_m *CIStore) EXPECT() *CIStore_Expecter {
49 return &CIStore_Expecter{mock: &_m.Mock}
50}
51
52// Apply provides a mock function for the type CIStore
53func (_mock *CIStore) Apply(ctx context.Context, w ports.CIWrite) (uint64, error) {
54 ret := _mock.Called(ctx, w)
55
56 if len(ret) == 0 {
57 panic("no return value specified for Apply")
58 }
59
60 var r0 uint64
61 var r1 error
62 if returnFunc, ok := ret.Get(0).(func(context.Context, ports.CIWrite) (uint64, error)); ok {
63 return returnFunc(ctx, w)
64 }
65 if returnFunc, ok := ret.Get(0).(func(context.Context, ports.CIWrite) uint64); ok {
66 r0 = returnFunc(ctx, w)
67 } else {
68 r0 = ret.Get(0).(uint64)
69 }
70 if returnFunc, ok := ret.Get(1).(func(context.Context, ports.CIWrite) error); ok {
71 r1 = returnFunc(ctx, w)
72 } else {
73 r1 = ret.Error(1)
74 }
75 return r0, r1
76}
77
78// CIStore_Apply_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Apply'
79type CIStore_Apply_Call struct {
80 *mock.Call
81}
82
83// Apply is a helper method to define mock.On call
84// - ctx context.Context
85// - w ports.CIWrite
86func (_e *CIStore_Expecter) Apply(ctx any, w any) *CIStore_Apply_Call {
87 return &CIStore_Apply_Call{Call: _e.mock.On("Apply", ctx, w)}
88}
89
90func (_c *CIStore_Apply_Call) Run(run func(ctx context.Context, w ports.CIWrite)) *CIStore_Apply_Call {
91 _c.Call.Run(func(args mock.Arguments) {
92 var arg0 context.Context
93 if args[0] != nil {
94 arg0 = args[0].(context.Context)
95 }
96 var arg1 ports.CIWrite
97 if args[1] != nil {
98 arg1 = args[1].(ports.CIWrite)
99 }
100 run(
101 arg0,
102 arg1,
103 )
104 })
105 return _c
106}
107
108func (_c *CIStore_Apply_Call) Return(version uint64, err error) *CIStore_Apply_Call {
109 _c.Call.Return(version, err)
110 return _c
111}
112
113func (_c *CIStore_Apply_Call) RunAndReturn(run func(ctx context.Context, w ports.CIWrite) (uint64, error)) *CIStore_Apply_Call {
114 _c.Call.Return(run)
115 return _c
116}
117
118// CreateRun provides a mock function for the type CIStore
119func (_mock *CIStore) CreateRun(ctx context.Context, repo domain.RepoName, workflowPath string, build func(id int64, number int64) ports.CIRunDraft) (ports.CIRunDraft, error) {
120 ret := _mock.Called(ctx, repo, workflowPath, build)
121
122 if len(ret) == 0 {
123 panic("no return value specified for CreateRun")
124 }
125
126 var r0 ports.CIRunDraft
127 var r1 error
128 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName, string, func(id int64, number int64) ports.CIRunDraft) (ports.CIRunDraft, error)); ok {
129 return returnFunc(ctx, repo, workflowPath, build)
130 }
131 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName, string, func(id int64, number int64) ports.CIRunDraft) ports.CIRunDraft); ok {
132 r0 = returnFunc(ctx, repo, workflowPath, build)
133 } else {
134 r0 = ret.Get(0).(ports.CIRunDraft)
135 }
136 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RepoName, string, func(id int64, number int64) ports.CIRunDraft) error); ok {
137 r1 = returnFunc(ctx, repo, workflowPath, build)
138 } else {
139 r1 = ret.Error(1)
140 }
141 return r0, r1
142}
143
144// CIStore_CreateRun_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRun'
145type CIStore_CreateRun_Call struct {
146 *mock.Call
147}
148
149// CreateRun is a helper method to define mock.On call
150// - ctx context.Context
151// - repo domain.RepoName
152// - workflowPath string
153// - build func(id int64, number int64) ports.CIRunDraft
154func (_e *CIStore_Expecter) CreateRun(ctx any, repo any, workflowPath any, build any) *CIStore_CreateRun_Call {
155 return &CIStore_CreateRun_Call{Call: _e.mock.On("CreateRun", ctx, repo, workflowPath, build)}
156}
157
158func (_c *CIStore_CreateRun_Call) Run(run func(ctx context.Context, repo domain.RepoName, workflowPath string, build func(id int64, number int64) ports.CIRunDraft)) *CIStore_CreateRun_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 var arg1 domain.RepoName
165 if args[1] != nil {
166 arg1 = args[1].(domain.RepoName)
167 }
168 var arg2 string
169 if args[2] != nil {
170 arg2 = args[2].(string)
171 }
172 var arg3 func(id int64, number int64) ports.CIRunDraft
173 if args[3] != nil {
174 arg3 = args[3].(func(id int64, number int64) ports.CIRunDraft)
175 }
176 run(
177 arg0,
178 arg1,
179 arg2,
180 arg3,
181 )
182 })
183 return _c
184}
185
186func (_c *CIStore_CreateRun_Call) Return(cIRunDraft ports.CIRunDraft, err error) *CIStore_CreateRun_Call {
187 _c.Call.Return(cIRunDraft, err)
188 return _c
189}
190
191func (_c *CIStore_CreateRun_Call) RunAndReturn(run func(ctx context.Context, repo domain.RepoName, workflowPath string, build func(id int64, number int64) ports.CIRunDraft) (ports.CIRunDraft, error)) *CIStore_CreateRun_Call {
192 _c.Call.Return(run)
193 return _c
194}
195
196// CreateRunner provides a mock function for the type CIStore
197func (_mock *CIStore) CreateRunner(ctx context.Context, r domain.CIRunner, replace bool) ([]domain.CIRunner, error) {
198 ret := _mock.Called(ctx, r, replace)
199
200 if len(ret) == 0 {
201 panic("no return value specified for CreateRunner")
202 }
203
204 var r0 []domain.CIRunner
205 var r1 error
206 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.CIRunner, bool) ([]domain.CIRunner, error)); ok {
207 return returnFunc(ctx, r, replace)
208 }
209 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.CIRunner, bool) []domain.CIRunner); ok {
210 r0 = returnFunc(ctx, r, replace)
211 } else {
212 if ret.Get(0) != nil {
213 r0 = ret.Get(0).([]domain.CIRunner)
214 }
215 }
216 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.CIRunner, bool) error); ok {
217 r1 = returnFunc(ctx, r, replace)
218 } else {
219 r1 = ret.Error(1)
220 }
221 return r0, r1
222}
223
224// CIStore_CreateRunner_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRunner'
225type CIStore_CreateRunner_Call struct {
226 *mock.Call
227}
228
229// CreateRunner is a helper method to define mock.On call
230// - ctx context.Context
231// - r domain.CIRunner
232// - replace bool
233func (_e *CIStore_Expecter) CreateRunner(ctx any, r any, replace any) *CIStore_CreateRunner_Call {
234 return &CIStore_CreateRunner_Call{Call: _e.mock.On("CreateRunner", ctx, r, replace)}
235}
236
237func (_c *CIStore_CreateRunner_Call) Run(run func(ctx context.Context, r domain.CIRunner, replace bool)) *CIStore_CreateRunner_Call {
238 _c.Call.Run(func(args mock.Arguments) {
239 var arg0 context.Context
240 if args[0] != nil {
241 arg0 = args[0].(context.Context)
242 }
243 var arg1 domain.CIRunner
244 if args[1] != nil {
245 arg1 = args[1].(domain.CIRunner)
246 }
247 var arg2 bool
248 if args[2] != nil {
249 arg2 = args[2].(bool)
250 }
251 run(
252 arg0,
253 arg1,
254 arg2,
255 )
256 })
257 return _c
258}
259
260func (_c *CIStore_CreateRunner_Call) Return(removed []domain.CIRunner, err error) *CIStore_CreateRunner_Call {
261 _c.Call.Return(removed, err)
262 return _c
263}
264
265func (_c *CIStore_CreateRunner_Call) RunAndReturn(run func(ctx context.Context, r domain.CIRunner, replace bool) ([]domain.CIRunner, error)) *CIStore_CreateRunner_Call {
266 _c.Call.Return(run)
267 return _c
268}
269
270// FindJobByToken provides a mock function for the type CIStore
271func (_mock *CIStore) FindJobByToken(ctx context.Context, hash domain.TokenHash, now time.Time) (domain.CIJob, error) {
272 ret := _mock.Called(ctx, hash, now)
273
274 if len(ret) == 0 {
275 panic("no return value specified for FindJobByToken")
276 }
277
278 var r0 domain.CIJob
279 var r1 error
280 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.TokenHash, time.Time) (domain.CIJob, error)); ok {
281 return returnFunc(ctx, hash, now)
282 }
283 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.TokenHash, time.Time) domain.CIJob); ok {
284 r0 = returnFunc(ctx, hash, now)
285 } else {
286 r0 = ret.Get(0).(domain.CIJob)
287 }
288 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.TokenHash, time.Time) error); ok {
289 r1 = returnFunc(ctx, hash, now)
290 } else {
291 r1 = ret.Error(1)
292 }
293 return r0, r1
294}
295
296// CIStore_FindJobByToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindJobByToken'
297type CIStore_FindJobByToken_Call struct {
298 *mock.Call
299}
300
301// FindJobByToken is a helper method to define mock.On call
302// - ctx context.Context
303// - hash domain.TokenHash
304// - now time.Time
305func (_e *CIStore_Expecter) FindJobByToken(ctx any, hash any, now any) *CIStore_FindJobByToken_Call {
306 return &CIStore_FindJobByToken_Call{Call: _e.mock.On("FindJobByToken", ctx, hash, now)}
307}
308
309func (_c *CIStore_FindJobByToken_Call) Run(run func(ctx context.Context, hash domain.TokenHash, now time.Time)) *CIStore_FindJobByToken_Call {
310 _c.Call.Run(func(args mock.Arguments) {
311 var arg0 context.Context
312 if args[0] != nil {
313 arg0 = args[0].(context.Context)
314 }
315 var arg1 domain.TokenHash
316 if args[1] != nil {
317 arg1 = args[1].(domain.TokenHash)
318 }
319 var arg2 time.Time
320 if args[2] != nil {
321 arg2 = args[2].(time.Time)
322 }
323 run(
324 arg0,
325 arg1,
326 arg2,
327 )
328 })
329 return _c
330}
331
332func (_c *CIStore_FindJobByToken_Call) Return(cIJob domain.CIJob, err error) *CIStore_FindJobByToken_Call {
333 _c.Call.Return(cIJob, err)
334 return _c
335}
336
337func (_c *CIStore_FindJobByToken_Call) RunAndReturn(run func(ctx context.Context, hash domain.TokenHash, now time.Time) (domain.CIJob, error)) *CIStore_FindJobByToken_Call {
338 _c.Call.Return(run)
339 return _c
340}
341
342// FindRunnerByToken provides a mock function for the type CIStore
343func (_mock *CIStore) FindRunnerByToken(ctx context.Context, hash domain.TokenHash) (domain.CIRunner, error) {
344 ret := _mock.Called(ctx, hash)
345
346 if len(ret) == 0 {
347 panic("no return value specified for FindRunnerByToken")
348 }
349
350 var r0 domain.CIRunner
351 var r1 error
352 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.TokenHash) (domain.CIRunner, error)); ok {
353 return returnFunc(ctx, hash)
354 }
355 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.TokenHash) domain.CIRunner); ok {
356 r0 = returnFunc(ctx, hash)
357 } else {
358 r0 = ret.Get(0).(domain.CIRunner)
359 }
360 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.TokenHash) error); ok {
361 r1 = returnFunc(ctx, hash)
362 } else {
363 r1 = ret.Error(1)
364 }
365 return r0, r1
366}
367
368// CIStore_FindRunnerByToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindRunnerByToken'
369type CIStore_FindRunnerByToken_Call struct {
370 *mock.Call
371}
372
373// FindRunnerByToken is a helper method to define mock.On call
374// - ctx context.Context
375// - hash domain.TokenHash
376func (_e *CIStore_Expecter) FindRunnerByToken(ctx any, hash any) *CIStore_FindRunnerByToken_Call {
377 return &CIStore_FindRunnerByToken_Call{Call: _e.mock.On("FindRunnerByToken", ctx, hash)}
378}
379
380func (_c *CIStore_FindRunnerByToken_Call) Run(run func(ctx context.Context, hash domain.TokenHash)) *CIStore_FindRunnerByToken_Call {
381 _c.Call.Run(func(args mock.Arguments) {
382 var arg0 context.Context
383 if args[0] != nil {
384 arg0 = args[0].(context.Context)
385 }
386 var arg1 domain.TokenHash
387 if args[1] != nil {
388 arg1 = args[1].(domain.TokenHash)
389 }
390 run(
391 arg0,
392 arg1,
393 )
394 })
395 return _c
396}
397
398func (_c *CIStore_FindRunnerByToken_Call) Return(cIRunner domain.CIRunner, err error) *CIStore_FindRunnerByToken_Call {
399 _c.Call.Return(cIRunner, err)
400 return _c
401}
402
403func (_c *CIStore_FindRunnerByToken_Call) RunAndReturn(run func(ctx context.Context, hash domain.TokenHash) (domain.CIRunner, error)) *CIStore_FindRunnerByToken_Call {
404 _c.Call.Return(run)
405 return _c
406}
407
408// GetActionResolution provides a mock function for the type CIStore
409func (_mock *CIStore) GetActionResolution(ctx context.Context, runID int64, runAttempt int32, key string) (domain.CIActionResolution, error) {
410 ret := _mock.Called(ctx, runID, runAttempt, key)
411
412 if len(ret) == 0 {
413 panic("no return value specified for GetActionResolution")
414 }
415
416 var r0 domain.CIActionResolution
417 var r1 error
418 if returnFunc, ok := ret.Get(0).(func(context.Context, int64, int32, string) (domain.CIActionResolution, error)); ok {
419 return returnFunc(ctx, runID, runAttempt, key)
420 }
421 if returnFunc, ok := ret.Get(0).(func(context.Context, int64, int32, string) domain.CIActionResolution); ok {
422 r0 = returnFunc(ctx, runID, runAttempt, key)
423 } else {
424 r0 = ret.Get(0).(domain.CIActionResolution)
425 }
426 if returnFunc, ok := ret.Get(1).(func(context.Context, int64, int32, string) error); ok {
427 r1 = returnFunc(ctx, runID, runAttempt, key)
428 } else {
429 r1 = ret.Error(1)
430 }
431 return r0, r1
432}
433
434// CIStore_GetActionResolution_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetActionResolution'
435type CIStore_GetActionResolution_Call struct {
436 *mock.Call
437}
438
439// GetActionResolution is a helper method to define mock.On call
440// - ctx context.Context
441// - runID int64
442// - runAttempt int32
443// - key string
444func (_e *CIStore_Expecter) GetActionResolution(ctx any, runID any, runAttempt any, key any) *CIStore_GetActionResolution_Call {
445 return &CIStore_GetActionResolution_Call{Call: _e.mock.On("GetActionResolution", ctx, runID, runAttempt, key)}
446}
447
448func (_c *CIStore_GetActionResolution_Call) Run(run func(ctx context.Context, runID int64, runAttempt int32, key string)) *CIStore_GetActionResolution_Call {
449 _c.Call.Run(func(args mock.Arguments) {
450 var arg0 context.Context
451 if args[0] != nil {
452 arg0 = args[0].(context.Context)
453 }
454 var arg1 int64
455 if args[1] != nil {
456 arg1 = args[1].(int64)
457 }
458 var arg2 int32
459 if args[2] != nil {
460 arg2 = args[2].(int32)
461 }
462 var arg3 string
463 if args[3] != nil {
464 arg3 = args[3].(string)
465 }
466 run(
467 arg0,
468 arg1,
469 arg2,
470 arg3,
471 )
472 })
473 return _c
474}
475
476func (_c *CIStore_GetActionResolution_Call) Return(cIActionResolution domain.CIActionResolution, err error) *CIStore_GetActionResolution_Call {
477 _c.Call.Return(cIActionResolution, err)
478 return _c
479}
480
481func (_c *CIStore_GetActionResolution_Call) RunAndReturn(run func(ctx context.Context, runID int64, runAttempt int32, key string) (domain.CIActionResolution, error)) *CIStore_GetActionResolution_Call {
482 _c.Call.Return(run)
483 return _c
484}
485
486// GetJob provides a mock function for the type CIStore
487func (_mock *CIStore) GetJob(ctx context.Context, runID int64, runAttempt int32, jobID string) (domain.CIJob, error) {
488 ret := _mock.Called(ctx, runID, runAttempt, jobID)
489
490 if len(ret) == 0 {
491 panic("no return value specified for GetJob")
492 }
493
494 var r0 domain.CIJob
495 var r1 error
496 if returnFunc, ok := ret.Get(0).(func(context.Context, int64, int32, string) (domain.CIJob, error)); ok {
497 return returnFunc(ctx, runID, runAttempt, jobID)
498 }
499 if returnFunc, ok := ret.Get(0).(func(context.Context, int64, int32, string) domain.CIJob); ok {
500 r0 = returnFunc(ctx, runID, runAttempt, jobID)
501 } else {
502 r0 = ret.Get(0).(domain.CIJob)
503 }
504 if returnFunc, ok := ret.Get(1).(func(context.Context, int64, int32, string) error); ok {
505 r1 = returnFunc(ctx, runID, runAttempt, jobID)
506 } else {
507 r1 = ret.Error(1)
508 }
509 return r0, r1
510}
511
512// CIStore_GetJob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetJob'
513type CIStore_GetJob_Call struct {
514 *mock.Call
515}
516
517// GetJob is a helper method to define mock.On call
518// - ctx context.Context
519// - runID int64
520// - runAttempt int32
521// - jobID string
522func (_e *CIStore_Expecter) GetJob(ctx any, runID any, runAttempt any, jobID any) *CIStore_GetJob_Call {
523 return &CIStore_GetJob_Call{Call: _e.mock.On("GetJob", ctx, runID, runAttempt, jobID)}
524}
525
526func (_c *CIStore_GetJob_Call) Run(run func(ctx context.Context, runID int64, runAttempt int32, jobID string)) *CIStore_GetJob_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 var arg1 int64
533 if args[1] != nil {
534 arg1 = args[1].(int64)
535 }
536 var arg2 int32
537 if args[2] != nil {
538 arg2 = args[2].(int32)
539 }
540 var arg3 string
541 if args[3] != nil {
542 arg3 = args[3].(string)
543 }
544 run(
545 arg0,
546 arg1,
547 arg2,
548 arg3,
549 )
550 })
551 return _c
552}
553
554func (_c *CIStore_GetJob_Call) Return(cIJob domain.CIJob, err error) *CIStore_GetJob_Call {
555 _c.Call.Return(cIJob, err)
556 return _c
557}
558
559func (_c *CIStore_GetJob_Call) RunAndReturn(run func(ctx context.Context, runID int64, runAttempt int32, jobID string) (domain.CIJob, error)) *CIStore_GetJob_Call {
560 _c.Call.Return(run)
561 return _c
562}
563
564// GetRun provides a mock function for the type CIStore
565func (_mock *CIStore) GetRun(ctx context.Context, repo domain.RepoName, id int64) (domain.CIRun, error) {
566 ret := _mock.Called(ctx, repo, id)
567
568 if len(ret) == 0 {
569 panic("no return value specified for GetRun")
570 }
571
572 var r0 domain.CIRun
573 var r1 error
574 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName, int64) (domain.CIRun, error)); ok {
575 return returnFunc(ctx, repo, id)
576 }
577 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName, int64) domain.CIRun); ok {
578 r0 = returnFunc(ctx, repo, id)
579 } else {
580 r0 = ret.Get(0).(domain.CIRun)
581 }
582 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RepoName, int64) error); ok {
583 r1 = returnFunc(ctx, repo, id)
584 } else {
585 r1 = ret.Error(1)
586 }
587 return r0, r1
588}
589
590// CIStore_GetRun_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRun'
591type CIStore_GetRun_Call struct {
592 *mock.Call
593}
594
595// GetRun is a helper method to define mock.On call
596// - ctx context.Context
597// - repo domain.RepoName
598// - id int64
599func (_e *CIStore_Expecter) GetRun(ctx any, repo any, id any) *CIStore_GetRun_Call {
600 return &CIStore_GetRun_Call{Call: _e.mock.On("GetRun", ctx, repo, id)}
601}
602
603func (_c *CIStore_GetRun_Call) Run(run func(ctx context.Context, repo domain.RepoName, id int64)) *CIStore_GetRun_Call {
604 _c.Call.Run(func(args mock.Arguments) {
605 var arg0 context.Context
606 if args[0] != nil {
607 arg0 = args[0].(context.Context)
608 }
609 var arg1 domain.RepoName
610 if args[1] != nil {
611 arg1 = args[1].(domain.RepoName)
612 }
613 var arg2 int64
614 if args[2] != nil {
615 arg2 = args[2].(int64)
616 }
617 run(
618 arg0,
619 arg1,
620 arg2,
621 )
622 })
623 return _c
624}
625
626func (_c *CIStore_GetRun_Call) Return(cIRun domain.CIRun, err error) *CIStore_GetRun_Call {
627 _c.Call.Return(cIRun, err)
628 return _c
629}
630
631func (_c *CIStore_GetRun_Call) RunAndReturn(run func(ctx context.Context, repo domain.RepoName, id int64) (domain.CIRun, error)) *CIStore_GetRun_Call {
632 _c.Call.Return(run)
633 return _c
634}
635
636// GetRunSource provides a mock function for the type CIStore
637func (_mock *CIStore) GetRunSource(ctx context.Context, runID int64) (domain.CIRunSource, error) {
638 ret := _mock.Called(ctx, runID)
639
640 if len(ret) == 0 {
641 panic("no return value specified for GetRunSource")
642 }
643
644 var r0 domain.CIRunSource
645 var r1 error
646 if returnFunc, ok := ret.Get(0).(func(context.Context, int64) (domain.CIRunSource, error)); ok {
647 return returnFunc(ctx, runID)
648 }
649 if returnFunc, ok := ret.Get(0).(func(context.Context, int64) domain.CIRunSource); ok {
650 r0 = returnFunc(ctx, runID)
651 } else {
652 r0 = ret.Get(0).(domain.CIRunSource)
653 }
654 if returnFunc, ok := ret.Get(1).(func(context.Context, int64) error); ok {
655 r1 = returnFunc(ctx, runID)
656 } else {
657 r1 = ret.Error(1)
658 }
659 return r0, r1
660}
661
662// CIStore_GetRunSource_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRunSource'
663type CIStore_GetRunSource_Call struct {
664 *mock.Call
665}
666
667// GetRunSource is a helper method to define mock.On call
668// - ctx context.Context
669// - runID int64
670func (_e *CIStore_Expecter) GetRunSource(ctx any, runID any) *CIStore_GetRunSource_Call {
671 return &CIStore_GetRunSource_Call{Call: _e.mock.On("GetRunSource", ctx, runID)}
672}
673
674func (_c *CIStore_GetRunSource_Call) Run(run func(ctx context.Context, runID int64)) *CIStore_GetRunSource_Call {
675 _c.Call.Run(func(args mock.Arguments) {
676 var arg0 context.Context
677 if args[0] != nil {
678 arg0 = args[0].(context.Context)
679 }
680 var arg1 int64
681 if args[1] != nil {
682 arg1 = args[1].(int64)
683 }
684 run(
685 arg0,
686 arg1,
687 )
688 })
689 return _c
690}
691
692func (_c *CIStore_GetRunSource_Call) Return(cIRunSource domain.CIRunSource, err error) *CIStore_GetRunSource_Call {
693 _c.Call.Return(cIRunSource, err)
694 return _c
695}
696
697func (_c *CIStore_GetRunSource_Call) RunAndReturn(run func(ctx context.Context, runID int64) (domain.CIRunSource, error)) *CIStore_GetRunSource_Call {
698 _c.Call.Return(run)
699 return _c
700}
701
702// GetRunner provides a mock function for the type CIStore
703func (_mock *CIStore) GetRunner(ctx context.Context, id string) (domain.CIRunner, error) {
704 ret := _mock.Called(ctx, id)
705
706 if len(ret) == 0 {
707 panic("no return value specified for GetRunner")
708 }
709
710 var r0 domain.CIRunner
711 var r1 error
712 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (domain.CIRunner, error)); ok {
713 return returnFunc(ctx, id)
714 }
715 if returnFunc, ok := ret.Get(0).(func(context.Context, string) domain.CIRunner); ok {
716 r0 = returnFunc(ctx, id)
717 } else {
718 r0 = ret.Get(0).(domain.CIRunner)
719 }
720 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
721 r1 = returnFunc(ctx, id)
722 } else {
723 r1 = ret.Error(1)
724 }
725 return r0, r1
726}
727
728// CIStore_GetRunner_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRunner'
729type CIStore_GetRunner_Call struct {
730 *mock.Call
731}
732
733// GetRunner is a helper method to define mock.On call
734// - ctx context.Context
735// - id string
736func (_e *CIStore_Expecter) GetRunner(ctx any, id any) *CIStore_GetRunner_Call {
737 return &CIStore_GetRunner_Call{Call: _e.mock.On("GetRunner", ctx, id)}
738}
739
740func (_c *CIStore_GetRunner_Call) Run(run func(ctx context.Context, id string)) *CIStore_GetRunner_Call {
741 _c.Call.Run(func(args mock.Arguments) {
742 var arg0 context.Context
743 if args[0] != nil {
744 arg0 = args[0].(context.Context)
745 }
746 var arg1 string
747 if args[1] != nil {
748 arg1 = args[1].(string)
749 }
750 run(
751 arg0,
752 arg1,
753 )
754 })
755 return _c
756}
757
758func (_c *CIStore_GetRunner_Call) Return(cIRunner domain.CIRunner, err error) *CIStore_GetRunner_Call {
759 _c.Call.Return(cIRunner, err)
760 return _c
761}
762
763func (_c *CIStore_GetRunner_Call) RunAndReturn(run func(ctx context.Context, id string) (domain.CIRunner, error)) *CIStore_GetRunner_Call {
764 _c.Call.Return(run)
765 return _c
766}
767
768// JobAnnotations provides a mock function for the type CIStore
769func (_mock *CIStore) JobAnnotations(ctx context.Context, runID int64, attempt int32, jobID string) ([]domain.CIAnnotation, error) {
770 ret := _mock.Called(ctx, runID, attempt, jobID)
771
772 if len(ret) == 0 {
773 panic("no return value specified for JobAnnotations")
774 }
775
776 var r0 []domain.CIAnnotation
777 var r1 error
778 if returnFunc, ok := ret.Get(0).(func(context.Context, int64, int32, string) ([]domain.CIAnnotation, error)); ok {
779 return returnFunc(ctx, runID, attempt, jobID)
780 }
781 if returnFunc, ok := ret.Get(0).(func(context.Context, int64, int32, string) []domain.CIAnnotation); ok {
782 r0 = returnFunc(ctx, runID, attempt, jobID)
783 } else {
784 if ret.Get(0) != nil {
785 r0 = ret.Get(0).([]domain.CIAnnotation)
786 }
787 }
788 if returnFunc, ok := ret.Get(1).(func(context.Context, int64, int32, string) error); ok {
789 r1 = returnFunc(ctx, runID, attempt, jobID)
790 } else {
791 r1 = ret.Error(1)
792 }
793 return r0, r1
794}
795
796// CIStore_JobAnnotations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JobAnnotations'
797type CIStore_JobAnnotations_Call struct {
798 *mock.Call
799}
800
801// JobAnnotations is a helper method to define mock.On call
802// - ctx context.Context
803// - runID int64
804// - attempt int32
805// - jobID string
806func (_e *CIStore_Expecter) JobAnnotations(ctx any, runID any, attempt any, jobID any) *CIStore_JobAnnotations_Call {
807 return &CIStore_JobAnnotations_Call{Call: _e.mock.On("JobAnnotations", ctx, runID, attempt, jobID)}
808}
809
810func (_c *CIStore_JobAnnotations_Call) Run(run func(ctx context.Context, runID int64, attempt int32, jobID string)) *CIStore_JobAnnotations_Call {
811 _c.Call.Run(func(args mock.Arguments) {
812 var arg0 context.Context
813 if args[0] != nil {
814 arg0 = args[0].(context.Context)
815 }
816 var arg1 int64
817 if args[1] != nil {
818 arg1 = args[1].(int64)
819 }
820 var arg2 int32
821 if args[2] != nil {
822 arg2 = args[2].(int32)
823 }
824 var arg3 string
825 if args[3] != nil {
826 arg3 = args[3].(string)
827 }
828 run(
829 arg0,
830 arg1,
831 arg2,
832 arg3,
833 )
834 })
835 return _c
836}
837
838func (_c *CIStore_JobAnnotations_Call) Return(cIAnnotations []domain.CIAnnotation, err error) *CIStore_JobAnnotations_Call {
839 _c.Call.Return(cIAnnotations, err)
840 return _c
841}
842
843func (_c *CIStore_JobAnnotations_Call) RunAndReturn(run func(ctx context.Context, runID int64, attempt int32, jobID string) ([]domain.CIAnnotation, error)) *CIStore_JobAnnotations_Call {
844 _c.Call.Return(run)
845 return _c
846}
847
848// ListActiveJobs provides a mock function for the type CIStore
849func (_mock *CIStore) ListActiveJobs(ctx context.Context) ([]domain.CIJob, error) {
850 ret := _mock.Called(ctx)
851
852 if len(ret) == 0 {
853 panic("no return value specified for ListActiveJobs")
854 }
855
856 var r0 []domain.CIJob
857 var r1 error
858 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]domain.CIJob, error)); ok {
859 return returnFunc(ctx)
860 }
861 if returnFunc, ok := ret.Get(0).(func(context.Context) []domain.CIJob); ok {
862 r0 = returnFunc(ctx)
863 } else {
864 if ret.Get(0) != nil {
865 r0 = ret.Get(0).([]domain.CIJob)
866 }
867 }
868 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
869 r1 = returnFunc(ctx)
870 } else {
871 r1 = ret.Error(1)
872 }
873 return r0, r1
874}
875
876// CIStore_ListActiveJobs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListActiveJobs'
877type CIStore_ListActiveJobs_Call struct {
878 *mock.Call
879}
880
881// ListActiveJobs is a helper method to define mock.On call
882// - ctx context.Context
883func (_e *CIStore_Expecter) ListActiveJobs(ctx any) *CIStore_ListActiveJobs_Call {
884 return &CIStore_ListActiveJobs_Call{Call: _e.mock.On("ListActiveJobs", ctx)}
885}
886
887func (_c *CIStore_ListActiveJobs_Call) Run(run func(ctx context.Context)) *CIStore_ListActiveJobs_Call {
888 _c.Call.Run(func(args mock.Arguments) {
889 var arg0 context.Context
890 if args[0] != nil {
891 arg0 = args[0].(context.Context)
892 }
893 run(
894 arg0,
895 )
896 })
897 return _c
898}
899
900func (_c *CIStore_ListActiveJobs_Call) Return(cIJobs []domain.CIJob, err error) *CIStore_ListActiveJobs_Call {
901 _c.Call.Return(cIJobs, err)
902 return _c
903}
904
905func (_c *CIStore_ListActiveJobs_Call) RunAndReturn(run func(ctx context.Context) ([]domain.CIJob, error)) *CIStore_ListActiveJobs_Call {
906 _c.Call.Return(run)
907 return _c
908}
909
910// ListChecks provides a mock function for the type CIStore
911func (_mock *CIStore) ListChecks(ctx context.Context, repo domain.RepoName, sha string, limit int) ([]domain.CICheck, bool, error) {
912 ret := _mock.Called(ctx, repo, sha, limit)
913
914 if len(ret) == 0 {
915 panic("no return value specified for ListChecks")
916 }
917
918 var r0 []domain.CICheck
919 var r1 bool
920 var r2 error
921 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName, string, int) ([]domain.CICheck, bool, error)); ok {
922 return returnFunc(ctx, repo, sha, limit)
923 }
924 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName, string, int) []domain.CICheck); ok {
925 r0 = returnFunc(ctx, repo, sha, limit)
926 } else {
927 if ret.Get(0) != nil {
928 r0 = ret.Get(0).([]domain.CICheck)
929 }
930 }
931 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RepoName, string, int) bool); ok {
932 r1 = returnFunc(ctx, repo, sha, limit)
933 } else {
934 r1 = ret.Get(1).(bool)
935 }
936 if returnFunc, ok := ret.Get(2).(func(context.Context, domain.RepoName, string, int) error); ok {
937 r2 = returnFunc(ctx, repo, sha, limit)
938 } else {
939 r2 = ret.Error(2)
940 }
941 return r0, r1, r2
942}
943
944// CIStore_ListChecks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListChecks'
945type CIStore_ListChecks_Call struct {
946 *mock.Call
947}
948
949// ListChecks is a helper method to define mock.On call
950// - ctx context.Context
951// - repo domain.RepoName
952// - sha string
953// - limit int
954func (_e *CIStore_Expecter) ListChecks(ctx any, repo any, sha any, limit any) *CIStore_ListChecks_Call {
955 return &CIStore_ListChecks_Call{Call: _e.mock.On("ListChecks", ctx, repo, sha, limit)}
956}
957
958func (_c *CIStore_ListChecks_Call) Run(run func(ctx context.Context, repo domain.RepoName, sha string, limit int)) *CIStore_ListChecks_Call {
959 _c.Call.Run(func(args mock.Arguments) {
960 var arg0 context.Context
961 if args[0] != nil {
962 arg0 = args[0].(context.Context)
963 }
964 var arg1 domain.RepoName
965 if args[1] != nil {
966 arg1 = args[1].(domain.RepoName)
967 }
968 var arg2 string
969 if args[2] != nil {
970 arg2 = args[2].(string)
971 }
972 var arg3 int
973 if args[3] != nil {
974 arg3 = args[3].(int)
975 }
976 run(
977 arg0,
978 arg1,
979 arg2,
980 arg3,
981 )
982 })
983 return _c
984}
985
986func (_c *CIStore_ListChecks_Call) Return(checks []domain.CICheck, more bool, err error) *CIStore_ListChecks_Call {
987 _c.Call.Return(checks, more, err)
988 return _c
989}
990
991func (_c *CIStore_ListChecks_Call) RunAndReturn(run func(ctx context.Context, repo domain.RepoName, sha string, limit int) ([]domain.CICheck, bool, error)) *CIStore_ListChecks_Call {
992 _c.Call.Return(run)
993 return _c
994}
995
996// ListConcurrency provides a mock function for the type CIStore
997func (_mock *CIStore) ListConcurrency(ctx context.Context) ([]ports.CIConcurrencyGroup, error) {
998 ret := _mock.Called(ctx)
999
1000 if len(ret) == 0 {
1001 panic("no return value specified for ListConcurrency")
1002 }
1003
1004 var r0 []ports.CIConcurrencyGroup
1005 var r1 error
1006 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]ports.CIConcurrencyGroup, error)); ok {
1007 return returnFunc(ctx)
1008 }
1009 if returnFunc, ok := ret.Get(0).(func(context.Context) []ports.CIConcurrencyGroup); ok {
1010 r0 = returnFunc(ctx)
1011 } else {
1012 if ret.Get(0) != nil {
1013 r0 = ret.Get(0).([]ports.CIConcurrencyGroup)
1014 }
1015 }
1016 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1017 r1 = returnFunc(ctx)
1018 } else {
1019 r1 = ret.Error(1)
1020 }
1021 return r0, r1
1022}
1023
1024// CIStore_ListConcurrency_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListConcurrency'
1025type CIStore_ListConcurrency_Call struct {
1026 *mock.Call
1027}
1028
1029// ListConcurrency is a helper method to define mock.On call
1030// - ctx context.Context
1031func (_e *CIStore_Expecter) ListConcurrency(ctx any) *CIStore_ListConcurrency_Call {
1032 return &CIStore_ListConcurrency_Call{Call: _e.mock.On("ListConcurrency", ctx)}
1033}
1034
1035func (_c *CIStore_ListConcurrency_Call) Run(run func(ctx context.Context)) *CIStore_ListConcurrency_Call {
1036 _c.Call.Run(func(args mock.Arguments) {
1037 var arg0 context.Context
1038 if args[0] != nil {
1039 arg0 = args[0].(context.Context)
1040 }
1041 run(
1042 arg0,
1043 )
1044 })
1045 return _c
1046}
1047
1048func (_c *CIStore_ListConcurrency_Call) Return(cIConcurrencyGroups []ports.CIConcurrencyGroup, err error) *CIStore_ListConcurrency_Call {
1049 _c.Call.Return(cIConcurrencyGroups, err)
1050 return _c
1051}
1052
1053func (_c *CIStore_ListConcurrency_Call) RunAndReturn(run func(ctx context.Context) ([]ports.CIConcurrencyGroup, error)) *CIStore_ListConcurrency_Call {
1054 _c.Call.Return(run)
1055 return _c
1056}
1057
1058// ListJobs provides a mock function for the type CIStore
1059func (_mock *CIStore) ListJobs(ctx context.Context, runID int64, runAttempt int32) ([]domain.CIJob, error) {
1060 ret := _mock.Called(ctx, runID, runAttempt)
1061
1062 if len(ret) == 0 {
1063 panic("no return value specified for ListJobs")
1064 }
1065
1066 var r0 []domain.CIJob
1067 var r1 error
1068 if returnFunc, ok := ret.Get(0).(func(context.Context, int64, int32) ([]domain.CIJob, error)); ok {
1069 return returnFunc(ctx, runID, runAttempt)
1070 }
1071 if returnFunc, ok := ret.Get(0).(func(context.Context, int64, int32) []domain.CIJob); ok {
1072 r0 = returnFunc(ctx, runID, runAttempt)
1073 } else {
1074 if ret.Get(0) != nil {
1075 r0 = ret.Get(0).([]domain.CIJob)
1076 }
1077 }
1078 if returnFunc, ok := ret.Get(1).(func(context.Context, int64, int32) error); ok {
1079 r1 = returnFunc(ctx, runID, runAttempt)
1080 } else {
1081 r1 = ret.Error(1)
1082 }
1083 return r0, r1
1084}
1085
1086// CIStore_ListJobs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListJobs'
1087type CIStore_ListJobs_Call struct {
1088 *mock.Call
1089}
1090
1091// ListJobs is a helper method to define mock.On call
1092// - ctx context.Context
1093// - runID int64
1094// - runAttempt int32
1095func (_e *CIStore_Expecter) ListJobs(ctx any, runID any, runAttempt any) *CIStore_ListJobs_Call {
1096 return &CIStore_ListJobs_Call{Call: _e.mock.On("ListJobs", ctx, runID, runAttempt)}
1097}
1098
1099func (_c *CIStore_ListJobs_Call) Run(run func(ctx context.Context, runID int64, runAttempt int32)) *CIStore_ListJobs_Call {
1100 _c.Call.Run(func(args mock.Arguments) {
1101 var arg0 context.Context
1102 if args[0] != nil {
1103 arg0 = args[0].(context.Context)
1104 }
1105 var arg1 int64
1106 if args[1] != nil {
1107 arg1 = args[1].(int64)
1108 }
1109 var arg2 int32
1110 if args[2] != nil {
1111 arg2 = args[2].(int32)
1112 }
1113 run(
1114 arg0,
1115 arg1,
1116 arg2,
1117 )
1118 })
1119 return _c
1120}
1121
1122func (_c *CIStore_ListJobs_Call) Return(cIJobs []domain.CIJob, err error) *CIStore_ListJobs_Call {
1123 _c.Call.Return(cIJobs, err)
1124 return _c
1125}
1126
1127func (_c *CIStore_ListJobs_Call) RunAndReturn(run func(ctx context.Context, runID int64, runAttempt int32) ([]domain.CIJob, error)) *CIStore_ListJobs_Call {
1128 _c.Call.Return(run)
1129 return _c
1130}
1131
1132// ListOpenRuns provides a mock function for the type CIStore
1133func (_mock *CIStore) ListOpenRuns(ctx context.Context) ([]domain.CIRun, error) {
1134 ret := _mock.Called(ctx)
1135
1136 if len(ret) == 0 {
1137 panic("no return value specified for ListOpenRuns")
1138 }
1139
1140 var r0 []domain.CIRun
1141 var r1 error
1142 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]domain.CIRun, error)); ok {
1143 return returnFunc(ctx)
1144 }
1145 if returnFunc, ok := ret.Get(0).(func(context.Context) []domain.CIRun); ok {
1146 r0 = returnFunc(ctx)
1147 } else {
1148 if ret.Get(0) != nil {
1149 r0 = ret.Get(0).([]domain.CIRun)
1150 }
1151 }
1152 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1153 r1 = returnFunc(ctx)
1154 } else {
1155 r1 = ret.Error(1)
1156 }
1157 return r0, r1
1158}
1159
1160// CIStore_ListOpenRuns_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOpenRuns'
1161type CIStore_ListOpenRuns_Call struct {
1162 *mock.Call
1163}
1164
1165// ListOpenRuns is a helper method to define mock.On call
1166// - ctx context.Context
1167func (_e *CIStore_Expecter) ListOpenRuns(ctx any) *CIStore_ListOpenRuns_Call {
1168 return &CIStore_ListOpenRuns_Call{Call: _e.mock.On("ListOpenRuns", ctx)}
1169}
1170
1171func (_c *CIStore_ListOpenRuns_Call) Run(run func(ctx context.Context)) *CIStore_ListOpenRuns_Call {
1172 _c.Call.Run(func(args mock.Arguments) {
1173 var arg0 context.Context
1174 if args[0] != nil {
1175 arg0 = args[0].(context.Context)
1176 }
1177 run(
1178 arg0,
1179 )
1180 })
1181 return _c
1182}
1183
1184func (_c *CIStore_ListOpenRuns_Call) Return(cIRuns []domain.CIRun, err error) *CIStore_ListOpenRuns_Call {
1185 _c.Call.Return(cIRuns, err)
1186 return _c
1187}
1188
1189func (_c *CIStore_ListOpenRuns_Call) RunAndReturn(run func(ctx context.Context) ([]domain.CIRun, error)) *CIStore_ListOpenRuns_Call {
1190 _c.Call.Return(run)
1191 return _c
1192}
1193
1194// ListReadyJobs provides a mock function for the type CIStore
1195func (_mock *CIStore) ListReadyJobs(ctx context.Context, limit int) ([]domain.CIJob, error) {
1196 ret := _mock.Called(ctx, limit)
1197
1198 if len(ret) == 0 {
1199 panic("no return value specified for ListReadyJobs")
1200 }
1201
1202 var r0 []domain.CIJob
1203 var r1 error
1204 if returnFunc, ok := ret.Get(0).(func(context.Context, int) ([]domain.CIJob, error)); ok {
1205 return returnFunc(ctx, limit)
1206 }
1207 if returnFunc, ok := ret.Get(0).(func(context.Context, int) []domain.CIJob); ok {
1208 r0 = returnFunc(ctx, limit)
1209 } else {
1210 if ret.Get(0) != nil {
1211 r0 = ret.Get(0).([]domain.CIJob)
1212 }
1213 }
1214 if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
1215 r1 = returnFunc(ctx, limit)
1216 } else {
1217 r1 = ret.Error(1)
1218 }
1219 return r0, r1
1220}
1221
1222// CIStore_ListReadyJobs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListReadyJobs'
1223type CIStore_ListReadyJobs_Call struct {
1224 *mock.Call
1225}
1226
1227// ListReadyJobs is a helper method to define mock.On call
1228// - ctx context.Context
1229// - limit int
1230func (_e *CIStore_Expecter) ListReadyJobs(ctx any, limit any) *CIStore_ListReadyJobs_Call {
1231 return &CIStore_ListReadyJobs_Call{Call: _e.mock.On("ListReadyJobs", ctx, limit)}
1232}
1233
1234func (_c *CIStore_ListReadyJobs_Call) Run(run func(ctx context.Context, limit int)) *CIStore_ListReadyJobs_Call {
1235 _c.Call.Run(func(args mock.Arguments) {
1236 var arg0 context.Context
1237 if args[0] != nil {
1238 arg0 = args[0].(context.Context)
1239 }
1240 var arg1 int
1241 if args[1] != nil {
1242 arg1 = args[1].(int)
1243 }
1244 run(
1245 arg0,
1246 arg1,
1247 )
1248 })
1249 return _c
1250}
1251
1252func (_c *CIStore_ListReadyJobs_Call) Return(cIJobs []domain.CIJob, err error) *CIStore_ListReadyJobs_Call {
1253 _c.Call.Return(cIJobs, err)
1254 return _c
1255}
1256
1257func (_c *CIStore_ListReadyJobs_Call) RunAndReturn(run func(ctx context.Context, limit int) ([]domain.CIJob, error)) *CIStore_ListReadyJobs_Call {
1258 _c.Call.Return(run)
1259 return _c
1260}
1261
1262// ListRunners provides a mock function for the type CIStore
1263func (_mock *CIStore) ListRunners(ctx context.Context) ([]domain.CIRunner, error) {
1264 ret := _mock.Called(ctx)
1265
1266 if len(ret) == 0 {
1267 panic("no return value specified for ListRunners")
1268 }
1269
1270 var r0 []domain.CIRunner
1271 var r1 error
1272 if returnFunc, ok := ret.Get(0).(func(context.Context) ([]domain.CIRunner, error)); ok {
1273 return returnFunc(ctx)
1274 }
1275 if returnFunc, ok := ret.Get(0).(func(context.Context) []domain.CIRunner); ok {
1276 r0 = returnFunc(ctx)
1277 } else {
1278 if ret.Get(0) != nil {
1279 r0 = ret.Get(0).([]domain.CIRunner)
1280 }
1281 }
1282 if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1283 r1 = returnFunc(ctx)
1284 } else {
1285 r1 = ret.Error(1)
1286 }
1287 return r0, r1
1288}
1289
1290// CIStore_ListRunners_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRunners'
1291type CIStore_ListRunners_Call struct {
1292 *mock.Call
1293}
1294
1295// ListRunners is a helper method to define mock.On call
1296// - ctx context.Context
1297func (_e *CIStore_Expecter) ListRunners(ctx any) *CIStore_ListRunners_Call {
1298 return &CIStore_ListRunners_Call{Call: _e.mock.On("ListRunners", ctx)}
1299}
1300
1301func (_c *CIStore_ListRunners_Call) Run(run func(ctx context.Context)) *CIStore_ListRunners_Call {
1302 _c.Call.Run(func(args mock.Arguments) {
1303 var arg0 context.Context
1304 if args[0] != nil {
1305 arg0 = args[0].(context.Context)
1306 }
1307 run(
1308 arg0,
1309 )
1310 })
1311 return _c
1312}
1313
1314func (_c *CIStore_ListRunners_Call) Return(cIRunners []domain.CIRunner, err error) *CIStore_ListRunners_Call {
1315 _c.Call.Return(cIRunners, err)
1316 return _c
1317}
1318
1319func (_c *CIStore_ListRunners_Call) RunAndReturn(run func(ctx context.Context) ([]domain.CIRunner, error)) *CIStore_ListRunners_Call {
1320 _c.Call.Return(run)
1321 return _c
1322}
1323
1324// ListRuns provides a mock function for the type CIStore
1325func (_mock *CIStore) ListRuns(ctx context.Context, repo domain.RepoName, before int64, limit int) ([]domain.CIRun, error) {
1326 ret := _mock.Called(ctx, repo, before, limit)
1327
1328 if len(ret) == 0 {
1329 panic("no return value specified for ListRuns")
1330 }
1331
1332 var r0 []domain.CIRun
1333 var r1 error
1334 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName, int64, int) ([]domain.CIRun, error)); ok {
1335 return returnFunc(ctx, repo, before, limit)
1336 }
1337 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName, int64, int) []domain.CIRun); ok {
1338 r0 = returnFunc(ctx, repo, before, limit)
1339 } else {
1340 if ret.Get(0) != nil {
1341 r0 = ret.Get(0).([]domain.CIRun)
1342 }
1343 }
1344 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RepoName, int64, int) error); ok {
1345 r1 = returnFunc(ctx, repo, before, limit)
1346 } else {
1347 r1 = ret.Error(1)
1348 }
1349 return r0, r1
1350}
1351
1352// CIStore_ListRuns_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRuns'
1353type CIStore_ListRuns_Call struct {
1354 *mock.Call
1355}
1356
1357// ListRuns is a helper method to define mock.On call
1358// - ctx context.Context
1359// - repo domain.RepoName
1360// - before int64
1361// - limit int
1362func (_e *CIStore_Expecter) ListRuns(ctx any, repo any, before any, limit any) *CIStore_ListRuns_Call {
1363 return &CIStore_ListRuns_Call{Call: _e.mock.On("ListRuns", ctx, repo, before, limit)}
1364}
1365
1366func (_c *CIStore_ListRuns_Call) Run(run func(ctx context.Context, repo domain.RepoName, before int64, limit int)) *CIStore_ListRuns_Call {
1367 _c.Call.Run(func(args mock.Arguments) {
1368 var arg0 context.Context
1369 if args[0] != nil {
1370 arg0 = args[0].(context.Context)
1371 }
1372 var arg1 domain.RepoName
1373 if args[1] != nil {
1374 arg1 = args[1].(domain.RepoName)
1375 }
1376 var arg2 int64
1377 if args[2] != nil {
1378 arg2 = args[2].(int64)
1379 }
1380 var arg3 int
1381 if args[3] != nil {
1382 arg3 = args[3].(int)
1383 }
1384 run(
1385 arg0,
1386 arg1,
1387 arg2,
1388 arg3,
1389 )
1390 })
1391 return _c
1392}
1393
1394func (_c *CIStore_ListRuns_Call) Return(cIRuns []domain.CIRun, err error) *CIStore_ListRuns_Call {
1395 _c.Call.Return(cIRuns, err)
1396 return _c
1397}
1398
1399func (_c *CIStore_ListRuns_Call) RunAndReturn(run func(ctx context.Context, repo domain.RepoName, before int64, limit int) ([]domain.CIRun, error)) *CIStore_ListRuns_Call {
1400 _c.Call.Return(run)
1401 return _c
1402}
1403
1404// RemoveRunner provides a mock function for the type CIStore
1405func (_mock *CIStore) RemoveRunner(ctx context.Context, id string) (domain.CIRunner, error) {
1406 ret := _mock.Called(ctx, id)
1407
1408 if len(ret) == 0 {
1409 panic("no return value specified for RemoveRunner")
1410 }
1411
1412 var r0 domain.CIRunner
1413 var r1 error
1414 if returnFunc, ok := ret.Get(0).(func(context.Context, string) (domain.CIRunner, error)); ok {
1415 return returnFunc(ctx, id)
1416 }
1417 if returnFunc, ok := ret.Get(0).(func(context.Context, string) domain.CIRunner); ok {
1418 r0 = returnFunc(ctx, id)
1419 } else {
1420 r0 = ret.Get(0).(domain.CIRunner)
1421 }
1422 if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
1423 r1 = returnFunc(ctx, id)
1424 } else {
1425 r1 = ret.Error(1)
1426 }
1427 return r0, r1
1428}
1429
1430// CIStore_RemoveRunner_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveRunner'
1431type CIStore_RemoveRunner_Call struct {
1432 *mock.Call
1433}
1434
1435// RemoveRunner is a helper method to define mock.On call
1436// - ctx context.Context
1437// - id string
1438func (_e *CIStore_Expecter) RemoveRunner(ctx any, id any) *CIStore_RemoveRunner_Call {
1439 return &CIStore_RemoveRunner_Call{Call: _e.mock.On("RemoveRunner", ctx, id)}
1440}
1441
1442func (_c *CIStore_RemoveRunner_Call) Run(run func(ctx context.Context, id string)) *CIStore_RemoveRunner_Call {
1443 _c.Call.Run(func(args mock.Arguments) {
1444 var arg0 context.Context
1445 if args[0] != nil {
1446 arg0 = args[0].(context.Context)
1447 }
1448 var arg1 string
1449 if args[1] != nil {
1450 arg1 = args[1].(string)
1451 }
1452 run(
1453 arg0,
1454 arg1,
1455 )
1456 })
1457 return _c
1458}
1459
1460func (_c *CIStore_RemoveRunner_Call) Return(cIRunner domain.CIRunner, err error) *CIStore_RemoveRunner_Call {
1461 _c.Call.Return(cIRunner, err)
1462 return _c
1463}
1464
1465func (_c *CIStore_RemoveRunner_Call) RunAndReturn(run func(ctx context.Context, id string) (domain.CIRunner, error)) *CIStore_RemoveRunner_Call {
1466 _c.Call.Return(run)
1467 return _c
1468}
1469
1470// RunIDs provides a mock function for the type CIStore
1471func (_mock *CIStore) RunIDs(ctx context.Context, repo domain.RepoName) ([]int64, error) {
1472 ret := _mock.Called(ctx, repo)
1473
1474 if len(ret) == 0 {
1475 panic("no return value specified for RunIDs")
1476 }
1477
1478 var r0 []int64
1479 var r1 error
1480 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName) ([]int64, error)); ok {
1481 return returnFunc(ctx, repo)
1482 }
1483 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName) []int64); ok {
1484 r0 = returnFunc(ctx, repo)
1485 } else {
1486 if ret.Get(0) != nil {
1487 r0 = ret.Get(0).([]int64)
1488 }
1489 }
1490 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RepoName) error); ok {
1491 r1 = returnFunc(ctx, repo)
1492 } else {
1493 r1 = ret.Error(1)
1494 }
1495 return r0, r1
1496}
1497
1498// CIStore_RunIDs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunIDs'
1499type CIStore_RunIDs_Call struct {
1500 *mock.Call
1501}
1502
1503// RunIDs is a helper method to define mock.On call
1504// - ctx context.Context
1505// - repo domain.RepoName
1506func (_e *CIStore_Expecter) RunIDs(ctx any, repo any) *CIStore_RunIDs_Call {
1507 return &CIStore_RunIDs_Call{Call: _e.mock.On("RunIDs", ctx, repo)}
1508}
1509
1510func (_c *CIStore_RunIDs_Call) Run(run func(ctx context.Context, repo domain.RepoName)) *CIStore_RunIDs_Call {
1511 _c.Call.Run(func(args mock.Arguments) {
1512 var arg0 context.Context
1513 if args[0] != nil {
1514 arg0 = args[0].(context.Context)
1515 }
1516 var arg1 domain.RepoName
1517 if args[1] != nil {
1518 arg1 = args[1].(domain.RepoName)
1519 }
1520 run(
1521 arg0,
1522 arg1,
1523 )
1524 })
1525 return _c
1526}
1527
1528func (_c *CIStore_RunIDs_Call) Return(int64s []int64, err error) *CIStore_RunIDs_Call {
1529 _c.Call.Return(int64s, err)
1530 return _c
1531}
1532
1533func (_c *CIStore_RunIDs_Call) RunAndReturn(run func(ctx context.Context, repo domain.RepoName) ([]int64, error)) *CIStore_RunIDs_Call {
1534 _c.Call.Return(run)
1535 return _c
1536}
1537
1538// SetRunnerVersion provides a mock function for the type CIStore
1539func (_mock *CIStore) SetRunnerVersion(ctx context.Context, id string, version string) error {
1540 ret := _mock.Called(ctx, id, version)
1541
1542 if len(ret) == 0 {
1543 panic("no return value specified for SetRunnerVersion")
1544 }
1545
1546 var r0 error
1547 if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
1548 r0 = returnFunc(ctx, id, version)
1549 } else {
1550 r0 = ret.Error(0)
1551 }
1552 return r0
1553}
1554
1555// CIStore_SetRunnerVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetRunnerVersion'
1556type CIStore_SetRunnerVersion_Call struct {
1557 *mock.Call
1558}
1559
1560// SetRunnerVersion is a helper method to define mock.On call
1561// - ctx context.Context
1562// - id string
1563// - version string
1564func (_e *CIStore_Expecter) SetRunnerVersion(ctx any, id any, version any) *CIStore_SetRunnerVersion_Call {
1565 return &CIStore_SetRunnerVersion_Call{Call: _e.mock.On("SetRunnerVersion", ctx, id, version)}
1566}
1567
1568func (_c *CIStore_SetRunnerVersion_Call) Run(run func(ctx context.Context, id string, version string)) *CIStore_SetRunnerVersion_Call {
1569 _c.Call.Run(func(args mock.Arguments) {
1570 var arg0 context.Context
1571 if args[0] != nil {
1572 arg0 = args[0].(context.Context)
1573 }
1574 var arg1 string
1575 if args[1] != nil {
1576 arg1 = args[1].(string)
1577 }
1578 var arg2 string
1579 if args[2] != nil {
1580 arg2 = args[2].(string)
1581 }
1582 run(
1583 arg0,
1584 arg1,
1585 arg2,
1586 )
1587 })
1588 return _c
1589}
1590
1591func (_c *CIStore_SetRunnerVersion_Call) Return(err error) *CIStore_SetRunnerVersion_Call {
1592 _c.Call.Return(err)
1593 return _c
1594}
1595
1596func (_c *CIStore_SetRunnerVersion_Call) RunAndReturn(run func(ctx context.Context, id string, version string) error) *CIStore_SetRunnerVersion_Call {
1597 _c.Call.Return(run)
1598 return _c
1599}
1600
1601// Sweep provides a mock function for the type CIStore
1602func (_mock *CIStore) Sweep(ctx context.Context, before time.Time) ([]int64, error) {
1603 ret := _mock.Called(ctx, before)
1604
1605 if len(ret) == 0 {
1606 panic("no return value specified for Sweep")
1607 }
1608
1609 var r0 []int64
1610 var r1 error
1611 if returnFunc, ok := ret.Get(0).(func(context.Context, time.Time) ([]int64, error)); ok {
1612 return returnFunc(ctx, before)
1613 }
1614 if returnFunc, ok := ret.Get(0).(func(context.Context, time.Time) []int64); ok {
1615 r0 = returnFunc(ctx, before)
1616 } else {
1617 if ret.Get(0) != nil {
1618 r0 = ret.Get(0).([]int64)
1619 }
1620 }
1621 if returnFunc, ok := ret.Get(1).(func(context.Context, time.Time) error); ok {
1622 r1 = returnFunc(ctx, before)
1623 } else {
1624 r1 = ret.Error(1)
1625 }
1626 return r0, r1
1627}
1628
1629// CIStore_Sweep_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Sweep'
1630type CIStore_Sweep_Call struct {
1631 *mock.Call
1632}
1633
1634// Sweep is a helper method to define mock.On call
1635// - ctx context.Context
1636// - before time.Time
1637func (_e *CIStore_Expecter) Sweep(ctx any, before any) *CIStore_Sweep_Call {
1638 return &CIStore_Sweep_Call{Call: _e.mock.On("Sweep", ctx, before)}
1639}
1640
1641func (_c *CIStore_Sweep_Call) Run(run func(ctx context.Context, before time.Time)) *CIStore_Sweep_Call {
1642 _c.Call.Run(func(args mock.Arguments) {
1643 var arg0 context.Context
1644 if args[0] != nil {
1645 arg0 = args[0].(context.Context)
1646 }
1647 var arg1 time.Time
1648 if args[1] != nil {
1649 arg1 = args[1].(time.Time)
1650 }
1651 run(
1652 arg0,
1653 arg1,
1654 )
1655 })
1656 return _c
1657}
1658
1659func (_c *CIStore_Sweep_Call) Return(int64s []int64, err error) *CIStore_Sweep_Call {
1660 _c.Call.Return(int64s, err)
1661 return _c
1662}
1663
1664func (_c *CIStore_Sweep_Call) RunAndReturn(run func(ctx context.Context, before time.Time) ([]int64, error)) *CIStore_Sweep_Call {
1665 _c.Call.Return(run)
1666 return _c
1667}
1668
1669// UpdateConcurrency provides a mock function for the type CIStore
1670func (_mock *CIStore) UpdateConcurrency(ctx context.Context, repo domain.RepoName, group string, fn func(*domain.CIConcurrencyGroupState) error) error {
1671 ret := _mock.Called(ctx, repo, group, fn)
1672
1673 if len(ret) == 0 {
1674 panic("no return value specified for UpdateConcurrency")
1675 }
1676
1677 var r0 error
1678 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName, string, func(*domain.CIConcurrencyGroupState) error) error); ok {
1679 r0 = returnFunc(ctx, repo, group, fn)
1680 } else {
1681 r0 = ret.Error(0)
1682 }
1683 return r0
1684}
1685
1686// CIStore_UpdateConcurrency_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateConcurrency'
1687type CIStore_UpdateConcurrency_Call struct {
1688 *mock.Call
1689}
1690
1691// UpdateConcurrency is a helper method to define mock.On call
1692// - ctx context.Context
1693// - repo domain.RepoName
1694// - group string
1695// - fn func(*domain.CIConcurrencyGroupState) error
1696func (_e *CIStore_Expecter) UpdateConcurrency(ctx any, repo any, group any, fn any) *CIStore_UpdateConcurrency_Call {
1697 return &CIStore_UpdateConcurrency_Call{Call: _e.mock.On("UpdateConcurrency", ctx, repo, group, fn)}
1698}
1699
1700func (_c *CIStore_UpdateConcurrency_Call) Run(run func(ctx context.Context, repo domain.RepoName, group string, fn func(*domain.CIConcurrencyGroupState) error)) *CIStore_UpdateConcurrency_Call {
1701 _c.Call.Run(func(args mock.Arguments) {
1702 var arg0 context.Context
1703 if args[0] != nil {
1704 arg0 = args[0].(context.Context)
1705 }
1706 var arg1 domain.RepoName
1707 if args[1] != nil {
1708 arg1 = args[1].(domain.RepoName)
1709 }
1710 var arg2 string
1711 if args[2] != nil {
1712 arg2 = args[2].(string)
1713 }
1714 var arg3 func(*domain.CIConcurrencyGroupState) error
1715 if args[3] != nil {
1716 arg3 = args[3].(func(*domain.CIConcurrencyGroupState) error)
1717 }
1718 run(
1719 arg0,
1720 arg1,
1721 arg2,
1722 arg3,
1723 )
1724 })
1725 return _c
1726}
1727
1728func (_c *CIStore_UpdateConcurrency_Call) Return(err error) *CIStore_UpdateConcurrency_Call {
1729 _c.Call.Return(err)
1730 return _c
1731}
1732
1733func (_c *CIStore_UpdateConcurrency_Call) RunAndReturn(run func(ctx context.Context, repo domain.RepoName, group string, fn func(*domain.CIConcurrencyGroupState) error) error) *CIStore_UpdateConcurrency_Call {
1734 _c.Call.Return(run)
1735 return _c
1736}