CIStore.go RawHistoryFolder

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// ListJobs provides a mock function for the type CIStore
997func (_mock *CIStore) ListJobs(ctx context.Context, runID int64, runAttempt int32) ([]domain.CIJob, error) {
998	ret := _mock.Called(ctx, runID, runAttempt)
999
1000	if len(ret) == 0 {
1001		panic("no return value specified for ListJobs")
1002	}
1003
1004	var r0 []domain.CIJob
1005	var r1 error
1006	if returnFunc, ok := ret.Get(0).(func(context.Context, int64, int32) ([]domain.CIJob, error)); ok {
1007		return returnFunc(ctx, runID, runAttempt)
1008	}
1009	if returnFunc, ok := ret.Get(0).(func(context.Context, int64, int32) []domain.CIJob); ok {
1010		r0 = returnFunc(ctx, runID, runAttempt)
1011	} else {
1012		if ret.Get(0) != nil {
1013			r0 = ret.Get(0).([]domain.CIJob)
1014		}
1015	}
1016	if returnFunc, ok := ret.Get(1).(func(context.Context, int64, int32) error); ok {
1017		r1 = returnFunc(ctx, runID, runAttempt)
1018	} else {
1019		r1 = ret.Error(1)
1020	}
1021	return r0, r1
1022}
1023
1024// CIStore_ListJobs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListJobs'
1025type CIStore_ListJobs_Call struct {
1026	*mock.Call
1027}
1028
1029// ListJobs is a helper method to define mock.On call
1030//   - ctx context.Context
1031//   - runID int64
1032//   - runAttempt int32
1033func (_e *CIStore_Expecter) ListJobs(ctx any, runID any, runAttempt any) *CIStore_ListJobs_Call {
1034	return &CIStore_ListJobs_Call{Call: _e.mock.On("ListJobs", ctx, runID, runAttempt)}
1035}
1036
1037func (_c *CIStore_ListJobs_Call) Run(run func(ctx context.Context, runID int64, runAttempt int32)) *CIStore_ListJobs_Call {
1038	_c.Call.Run(func(args mock.Arguments) {
1039		var arg0 context.Context
1040		if args[0] != nil {
1041			arg0 = args[0].(context.Context)
1042		}
1043		var arg1 int64
1044		if args[1] != nil {
1045			arg1 = args[1].(int64)
1046		}
1047		var arg2 int32
1048		if args[2] != nil {
1049			arg2 = args[2].(int32)
1050		}
1051		run(
1052			arg0,
1053			arg1,
1054			arg2,
1055		)
1056	})
1057	return _c
1058}
1059
1060func (_c *CIStore_ListJobs_Call) Return(cIJobs []domain.CIJob, err error) *CIStore_ListJobs_Call {
1061	_c.Call.Return(cIJobs, err)
1062	return _c
1063}
1064
1065func (_c *CIStore_ListJobs_Call) RunAndReturn(run func(ctx context.Context, runID int64, runAttempt int32) ([]domain.CIJob, error)) *CIStore_ListJobs_Call {
1066	_c.Call.Return(run)
1067	return _c
1068}
1069
1070// ListOpenRuns provides a mock function for the type CIStore
1071func (_mock *CIStore) ListOpenRuns(ctx context.Context) ([]domain.CIRun, error) {
1072	ret := _mock.Called(ctx)
1073
1074	if len(ret) == 0 {
1075		panic("no return value specified for ListOpenRuns")
1076	}
1077
1078	var r0 []domain.CIRun
1079	var r1 error
1080	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]domain.CIRun, error)); ok {
1081		return returnFunc(ctx)
1082	}
1083	if returnFunc, ok := ret.Get(0).(func(context.Context) []domain.CIRun); ok {
1084		r0 = returnFunc(ctx)
1085	} else {
1086		if ret.Get(0) != nil {
1087			r0 = ret.Get(0).([]domain.CIRun)
1088		}
1089	}
1090	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1091		r1 = returnFunc(ctx)
1092	} else {
1093		r1 = ret.Error(1)
1094	}
1095	return r0, r1
1096}
1097
1098// CIStore_ListOpenRuns_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOpenRuns'
1099type CIStore_ListOpenRuns_Call struct {
1100	*mock.Call
1101}
1102
1103// ListOpenRuns is a helper method to define mock.On call
1104//   - ctx context.Context
1105func (_e *CIStore_Expecter) ListOpenRuns(ctx any) *CIStore_ListOpenRuns_Call {
1106	return &CIStore_ListOpenRuns_Call{Call: _e.mock.On("ListOpenRuns", ctx)}
1107}
1108
1109func (_c *CIStore_ListOpenRuns_Call) Run(run func(ctx context.Context)) *CIStore_ListOpenRuns_Call {
1110	_c.Call.Run(func(args mock.Arguments) {
1111		var arg0 context.Context
1112		if args[0] != nil {
1113			arg0 = args[0].(context.Context)
1114		}
1115		run(
1116			arg0,
1117		)
1118	})
1119	return _c
1120}
1121
1122func (_c *CIStore_ListOpenRuns_Call) Return(cIRuns []domain.CIRun, err error) *CIStore_ListOpenRuns_Call {
1123	_c.Call.Return(cIRuns, err)
1124	return _c
1125}
1126
1127func (_c *CIStore_ListOpenRuns_Call) RunAndReturn(run func(ctx context.Context) ([]domain.CIRun, error)) *CIStore_ListOpenRuns_Call {
1128	_c.Call.Return(run)
1129	return _c
1130}
1131
1132// ListReadyJobs provides a mock function for the type CIStore
1133func (_mock *CIStore) ListReadyJobs(ctx context.Context, limit int) ([]domain.CIJob, error) {
1134	ret := _mock.Called(ctx, limit)
1135
1136	if len(ret) == 0 {
1137		panic("no return value specified for ListReadyJobs")
1138	}
1139
1140	var r0 []domain.CIJob
1141	var r1 error
1142	if returnFunc, ok := ret.Get(0).(func(context.Context, int) ([]domain.CIJob, error)); ok {
1143		return returnFunc(ctx, limit)
1144	}
1145	if returnFunc, ok := ret.Get(0).(func(context.Context, int) []domain.CIJob); ok {
1146		r0 = returnFunc(ctx, limit)
1147	} else {
1148		if ret.Get(0) != nil {
1149			r0 = ret.Get(0).([]domain.CIJob)
1150		}
1151	}
1152	if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
1153		r1 = returnFunc(ctx, limit)
1154	} else {
1155		r1 = ret.Error(1)
1156	}
1157	return r0, r1
1158}
1159
1160// CIStore_ListReadyJobs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListReadyJobs'
1161type CIStore_ListReadyJobs_Call struct {
1162	*mock.Call
1163}
1164
1165// ListReadyJobs is a helper method to define mock.On call
1166//   - ctx context.Context
1167//   - limit int
1168func (_e *CIStore_Expecter) ListReadyJobs(ctx any, limit any) *CIStore_ListReadyJobs_Call {
1169	return &CIStore_ListReadyJobs_Call{Call: _e.mock.On("ListReadyJobs", ctx, limit)}
1170}
1171
1172func (_c *CIStore_ListReadyJobs_Call) Run(run func(ctx context.Context, limit int)) *CIStore_ListReadyJobs_Call {
1173	_c.Call.Run(func(args mock.Arguments) {
1174		var arg0 context.Context
1175		if args[0] != nil {
1176			arg0 = args[0].(context.Context)
1177		}
1178		var arg1 int
1179		if args[1] != nil {
1180			arg1 = args[1].(int)
1181		}
1182		run(
1183			arg0,
1184			arg1,
1185		)
1186	})
1187	return _c
1188}
1189
1190func (_c *CIStore_ListReadyJobs_Call) Return(cIJobs []domain.CIJob, err error) *CIStore_ListReadyJobs_Call {
1191	_c.Call.Return(cIJobs, err)
1192	return _c
1193}
1194
1195func (_c *CIStore_ListReadyJobs_Call) RunAndReturn(run func(ctx context.Context, limit int) ([]domain.CIJob, error)) *CIStore_ListReadyJobs_Call {
1196	_c.Call.Return(run)
1197	return _c
1198}
1199
1200// ListRunners provides a mock function for the type CIStore
1201func (_mock *CIStore) ListRunners(ctx context.Context) ([]domain.CIRunner, error) {
1202	ret := _mock.Called(ctx)
1203
1204	if len(ret) == 0 {
1205		panic("no return value specified for ListRunners")
1206	}
1207
1208	var r0 []domain.CIRunner
1209	var r1 error
1210	if returnFunc, ok := ret.Get(0).(func(context.Context) ([]domain.CIRunner, error)); ok {
1211		return returnFunc(ctx)
1212	}
1213	if returnFunc, ok := ret.Get(0).(func(context.Context) []domain.CIRunner); ok {
1214		r0 = returnFunc(ctx)
1215	} else {
1216		if ret.Get(0) != nil {
1217			r0 = ret.Get(0).([]domain.CIRunner)
1218		}
1219	}
1220	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
1221		r1 = returnFunc(ctx)
1222	} else {
1223		r1 = ret.Error(1)
1224	}
1225	return r0, r1
1226}
1227
1228// CIStore_ListRunners_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRunners'
1229type CIStore_ListRunners_Call struct {
1230	*mock.Call
1231}
1232
1233// ListRunners is a helper method to define mock.On call
1234//   - ctx context.Context
1235func (_e *CIStore_Expecter) ListRunners(ctx any) *CIStore_ListRunners_Call {
1236	return &CIStore_ListRunners_Call{Call: _e.mock.On("ListRunners", ctx)}
1237}
1238
1239func (_c *CIStore_ListRunners_Call) Run(run func(ctx context.Context)) *CIStore_ListRunners_Call {
1240	_c.Call.Run(func(args mock.Arguments) {
1241		var arg0 context.Context
1242		if args[0] != nil {
1243			arg0 = args[0].(context.Context)
1244		}
1245		run(
1246			arg0,
1247		)
1248	})
1249	return _c
1250}
1251
1252func (_c *CIStore_ListRunners_Call) Return(cIRunners []domain.CIRunner, err error) *CIStore_ListRunners_Call {
1253	_c.Call.Return(cIRunners, err)
1254	return _c
1255}
1256
1257func (_c *CIStore_ListRunners_Call) RunAndReturn(run func(ctx context.Context) ([]domain.CIRunner, error)) *CIStore_ListRunners_Call {
1258	_c.Call.Return(run)
1259	return _c
1260}
1261
1262// ListRuns provides a mock function for the type CIStore
1263func (_mock *CIStore) ListRuns(ctx context.Context, repo domain.RepoName, before int64, limit int) ([]domain.CIRun, error) {
1264	ret := _mock.Called(ctx, repo, before, limit)
1265
1266	if len(ret) == 0 {
1267		panic("no return value specified for ListRuns")
1268	}
1269
1270	var r0 []domain.CIRun
1271	var r1 error
1272	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName, int64, int) ([]domain.CIRun, error)); ok {
1273		return returnFunc(ctx, repo, before, limit)
1274	}
1275	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName, int64, int) []domain.CIRun); ok {
1276		r0 = returnFunc(ctx, repo, before, limit)
1277	} else {
1278		if ret.Get(0) != nil {
1279			r0 = ret.Get(0).([]domain.CIRun)
1280		}
1281	}
1282	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RepoName, int64, int) error); ok {
1283		r1 = returnFunc(ctx, repo, before, limit)
1284	} else {
1285		r1 = ret.Error(1)
1286	}
1287	return r0, r1
1288}
1289
1290// CIStore_ListRuns_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRuns'
1291type CIStore_ListRuns_Call struct {
1292	*mock.Call
1293}
1294
1295// ListRuns is a helper method to define mock.On call
1296//   - ctx context.Context
1297//   - repo domain.RepoName
1298//   - before int64
1299//   - limit int
1300func (_e *CIStore_Expecter) ListRuns(ctx any, repo any, before any, limit any) *CIStore_ListRuns_Call {
1301	return &CIStore_ListRuns_Call{Call: _e.mock.On("ListRuns", ctx, repo, before, limit)}
1302}
1303
1304func (_c *CIStore_ListRuns_Call) Run(run func(ctx context.Context, repo domain.RepoName, before int64, limit int)) *CIStore_ListRuns_Call {
1305	_c.Call.Run(func(args mock.Arguments) {
1306		var arg0 context.Context
1307		if args[0] != nil {
1308			arg0 = args[0].(context.Context)
1309		}
1310		var arg1 domain.RepoName
1311		if args[1] != nil {
1312			arg1 = args[1].(domain.RepoName)
1313		}
1314		var arg2 int64
1315		if args[2] != nil {
1316			arg2 = args[2].(int64)
1317		}
1318		var arg3 int
1319		if args[3] != nil {
1320			arg3 = args[3].(int)
1321		}
1322		run(
1323			arg0,
1324			arg1,
1325			arg2,
1326			arg3,
1327		)
1328	})
1329	return _c
1330}
1331
1332func (_c *CIStore_ListRuns_Call) Return(cIRuns []domain.CIRun, err error) *CIStore_ListRuns_Call {
1333	_c.Call.Return(cIRuns, err)
1334	return _c
1335}
1336
1337func (_c *CIStore_ListRuns_Call) RunAndReturn(run func(ctx context.Context, repo domain.RepoName, before int64, limit int) ([]domain.CIRun, error)) *CIStore_ListRuns_Call {
1338	_c.Call.Return(run)
1339	return _c
1340}
1341
1342// RemoveRunner provides a mock function for the type CIStore
1343func (_mock *CIStore) RemoveRunner(ctx context.Context, id string) (domain.CIRunner, error) {
1344	ret := _mock.Called(ctx, id)
1345
1346	if len(ret) == 0 {
1347		panic("no return value specified for RemoveRunner")
1348	}
1349
1350	var r0 domain.CIRunner
1351	var r1 error
1352	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (domain.CIRunner, error)); ok {
1353		return returnFunc(ctx, id)
1354	}
1355	if returnFunc, ok := ret.Get(0).(func(context.Context, string) domain.CIRunner); ok {
1356		r0 = returnFunc(ctx, id)
1357	} else {
1358		r0 = ret.Get(0).(domain.CIRunner)
1359	}
1360	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
1361		r1 = returnFunc(ctx, id)
1362	} else {
1363		r1 = ret.Error(1)
1364	}
1365	return r0, r1
1366}
1367
1368// CIStore_RemoveRunner_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveRunner'
1369type CIStore_RemoveRunner_Call struct {
1370	*mock.Call
1371}
1372
1373// RemoveRunner is a helper method to define mock.On call
1374//   - ctx context.Context
1375//   - id string
1376func (_e *CIStore_Expecter) RemoveRunner(ctx any, id any) *CIStore_RemoveRunner_Call {
1377	return &CIStore_RemoveRunner_Call{Call: _e.mock.On("RemoveRunner", ctx, id)}
1378}
1379
1380func (_c *CIStore_RemoveRunner_Call) Run(run func(ctx context.Context, id string)) *CIStore_RemoveRunner_Call {
1381	_c.Call.Run(func(args mock.Arguments) {
1382		var arg0 context.Context
1383		if args[0] != nil {
1384			arg0 = args[0].(context.Context)
1385		}
1386		var arg1 string
1387		if args[1] != nil {
1388			arg1 = args[1].(string)
1389		}
1390		run(
1391			arg0,
1392			arg1,
1393		)
1394	})
1395	return _c
1396}
1397
1398func (_c *CIStore_RemoveRunner_Call) Return(cIRunner domain.CIRunner, err error) *CIStore_RemoveRunner_Call {
1399	_c.Call.Return(cIRunner, err)
1400	return _c
1401}
1402
1403func (_c *CIStore_RemoveRunner_Call) RunAndReturn(run func(ctx context.Context, id string) (domain.CIRunner, error)) *CIStore_RemoveRunner_Call {
1404	_c.Call.Return(run)
1405	return _c
1406}
1407
1408// RunIDs provides a mock function for the type CIStore
1409func (_mock *CIStore) RunIDs(ctx context.Context, repo domain.RepoName) ([]int64, error) {
1410	ret := _mock.Called(ctx, repo)
1411
1412	if len(ret) == 0 {
1413		panic("no return value specified for RunIDs")
1414	}
1415
1416	var r0 []int64
1417	var r1 error
1418	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName) ([]int64, error)); ok {
1419		return returnFunc(ctx, repo)
1420	}
1421	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RepoName) []int64); ok {
1422		r0 = returnFunc(ctx, repo)
1423	} else {
1424		if ret.Get(0) != nil {
1425			r0 = ret.Get(0).([]int64)
1426		}
1427	}
1428	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RepoName) error); ok {
1429		r1 = returnFunc(ctx, repo)
1430	} else {
1431		r1 = ret.Error(1)
1432	}
1433	return r0, r1
1434}
1435
1436// CIStore_RunIDs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunIDs'
1437type CIStore_RunIDs_Call struct {
1438	*mock.Call
1439}
1440
1441// RunIDs is a helper method to define mock.On call
1442//   - ctx context.Context
1443//   - repo domain.RepoName
1444func (_e *CIStore_Expecter) RunIDs(ctx any, repo any) *CIStore_RunIDs_Call {
1445	return &CIStore_RunIDs_Call{Call: _e.mock.On("RunIDs", ctx, repo)}
1446}
1447
1448func (_c *CIStore_RunIDs_Call) Run(run func(ctx context.Context, repo domain.RepoName)) *CIStore_RunIDs_Call {
1449	_c.Call.Run(func(args mock.Arguments) {
1450		var arg0 context.Context
1451		if args[0] != nil {
1452			arg0 = args[0].(context.Context)
1453		}
1454		var arg1 domain.RepoName
1455		if args[1] != nil {
1456			arg1 = args[1].(domain.RepoName)
1457		}
1458		run(
1459			arg0,
1460			arg1,
1461		)
1462	})
1463	return _c
1464}
1465
1466func (_c *CIStore_RunIDs_Call) Return(int64s []int64, err error) *CIStore_RunIDs_Call {
1467	_c.Call.Return(int64s, err)
1468	return _c
1469}
1470
1471func (_c *CIStore_RunIDs_Call) RunAndReturn(run func(ctx context.Context, repo domain.RepoName) ([]int64, error)) *CIStore_RunIDs_Call {
1472	_c.Call.Return(run)
1473	return _c
1474}
1475
1476// Sweep provides a mock function for the type CIStore
1477func (_mock *CIStore) Sweep(ctx context.Context, before time.Time) ([]int64, error) {
1478	ret := _mock.Called(ctx, before)
1479
1480	if len(ret) == 0 {
1481		panic("no return value specified for Sweep")
1482	}
1483
1484	var r0 []int64
1485	var r1 error
1486	if returnFunc, ok := ret.Get(0).(func(context.Context, time.Time) ([]int64, error)); ok {
1487		return returnFunc(ctx, before)
1488	}
1489	if returnFunc, ok := ret.Get(0).(func(context.Context, time.Time) []int64); ok {
1490		r0 = returnFunc(ctx, before)
1491	} else {
1492		if ret.Get(0) != nil {
1493			r0 = ret.Get(0).([]int64)
1494		}
1495	}
1496	if returnFunc, ok := ret.Get(1).(func(context.Context, time.Time) error); ok {
1497		r1 = returnFunc(ctx, before)
1498	} else {
1499		r1 = ret.Error(1)
1500	}
1501	return r0, r1
1502}
1503
1504// CIStore_Sweep_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Sweep'
1505type CIStore_Sweep_Call struct {
1506	*mock.Call
1507}
1508
1509// Sweep is a helper method to define mock.On call
1510//   - ctx context.Context
1511//   - before time.Time
1512func (_e *CIStore_Expecter) Sweep(ctx any, before any) *CIStore_Sweep_Call {
1513	return &CIStore_Sweep_Call{Call: _e.mock.On("Sweep", ctx, before)}
1514}
1515
1516func (_c *CIStore_Sweep_Call) Run(run func(ctx context.Context, before time.Time)) *CIStore_Sweep_Call {
1517	_c.Call.Run(func(args mock.Arguments) {
1518		var arg0 context.Context
1519		if args[0] != nil {
1520			arg0 = args[0].(context.Context)
1521		}
1522		var arg1 time.Time
1523		if args[1] != nil {
1524			arg1 = args[1].(time.Time)
1525		}
1526		run(
1527			arg0,
1528			arg1,
1529		)
1530	})
1531	return _c
1532}
1533
1534func (_c *CIStore_Sweep_Call) Return(int64s []int64, err error) *CIStore_Sweep_Call {
1535	_c.Call.Return(int64s, err)
1536	return _c
1537}
1538
1539func (_c *CIStore_Sweep_Call) RunAndReturn(run func(ctx context.Context, before time.Time) ([]int64, error)) *CIStore_Sweep_Call {
1540	_c.Call.Return(run)
1541	return _c
1542}