1// Code generated by mockery; DO NOT EDIT.
2// github.com/vektra/mockery
3// template: testify
4
5package mocks
6
7import (
8 "context"
9
10 "bnema.dev/ermite/internal/domain"
11 "bnema.dev/ermite/internal/ports"
12 mock "github.com/stretchr/testify/mock"
13)
14
15// NewRunService creates a new instance of RunService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
16// The first argument is typically a *testing.T value.
17func NewRunService(t interface {
18 mock.TestingT
19 Cleanup(func())
20}) *RunService {
21 if helper, ok := t.(interface{ Helper() }); ok {
22 helper.Helper()
23 }
24
25 mock := &RunService{}
26 mock.Mock.Test(t)
27
28 t.Cleanup(func() {
29 if helper, ok := t.(interface{ Helper() }); ok {
30 helper.Helper()
31 }
32 mock.AssertExpectations(t)
33 })
34
35 return mock
36}
37
38// RunService is an autogenerated mock type for the RunService type
39type RunService struct {
40 mock.Mock
41}
42
43type RunService_Expecter struct {
44 mock *mock.Mock
45}
46
47func (_m *RunService) EXPECT() *RunService_Expecter {
48 return &RunService_Expecter{mock: &_m.Mock}
49}
50
51// CancelRun provides a mock function for the type RunService
52func (_mock *RunService) CancelRun(ctx context.Context, p domain.Principal, repo domain.RepoName, runID int64) (domain.CIRun, error) {
53 ret := _mock.Called(ctx, p, repo, runID)
54
55 if len(ret) == 0 {
56 panic("no return value specified for CancelRun")
57 }
58
59 var r0 domain.CIRun
60 var r1 error
61 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64) (domain.CIRun, error)); ok {
62 return returnFunc(ctx, p, repo, runID)
63 }
64 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64) domain.CIRun); ok {
65 r0 = returnFunc(ctx, p, repo, runID)
66 } else {
67 r0 = ret.Get(0).(domain.CIRun)
68 }
69 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, int64) error); ok {
70 r1 = returnFunc(ctx, p, repo, runID)
71 } else {
72 r1 = ret.Error(1)
73 }
74 return r0, r1
75}
76
77// RunService_CancelRun_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelRun'
78type RunService_CancelRun_Call struct {
79 *mock.Call
80}
81
82// CancelRun is a helper method to define mock.On call
83// - ctx context.Context
84// - p domain.Principal
85// - repo domain.RepoName
86// - runID int64
87func (_e *RunService_Expecter) CancelRun(ctx any, p any, repo any, runID any) *RunService_CancelRun_Call {
88 return &RunService_CancelRun_Call{Call: _e.mock.On("CancelRun", ctx, p, repo, runID)}
89}
90
91func (_c *RunService_CancelRun_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, runID int64)) *RunService_CancelRun_Call {
92 _c.Call.Run(func(args mock.Arguments) {
93 var arg0 context.Context
94 if args[0] != nil {
95 arg0 = args[0].(context.Context)
96 }
97 var arg1 domain.Principal
98 if args[1] != nil {
99 arg1 = args[1].(domain.Principal)
100 }
101 var arg2 domain.RepoName
102 if args[2] != nil {
103 arg2 = args[2].(domain.RepoName)
104 }
105 var arg3 int64
106 if args[3] != nil {
107 arg3 = args[3].(int64)
108 }
109 run(
110 arg0,
111 arg1,
112 arg2,
113 arg3,
114 )
115 })
116 return _c
117}
118
119func (_c *RunService_CancelRun_Call) Return(cIRun domain.CIRun, err error) *RunService_CancelRun_Call {
120 _c.Call.Return(cIRun, err)
121 return _c
122}
123
124func (_c *RunService_CancelRun_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, runID int64) (domain.CIRun, error)) *RunService_CancelRun_Call {
125 _c.Call.Return(run)
126 return _c
127}
128
129// DisableWorkflow provides a mock function for the type RunService
130func (_mock *RunService) DisableWorkflow(ctx context.Context, p domain.Principal, repo domain.RepoName, file string) (ports.WorkflowInfo, error) {
131 ret := _mock.Called(ctx, p, repo, file)
132
133 if len(ret) == 0 {
134 panic("no return value specified for DisableWorkflow")
135 }
136
137 var r0 ports.WorkflowInfo
138 var r1 error
139 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, string) (ports.WorkflowInfo, error)); ok {
140 return returnFunc(ctx, p, repo, file)
141 }
142 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, string) ports.WorkflowInfo); ok {
143 r0 = returnFunc(ctx, p, repo, file)
144 } else {
145 r0 = ret.Get(0).(ports.WorkflowInfo)
146 }
147 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, string) error); ok {
148 r1 = returnFunc(ctx, p, repo, file)
149 } else {
150 r1 = ret.Error(1)
151 }
152 return r0, r1
153}
154
155// RunService_DisableWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableWorkflow'
156type RunService_DisableWorkflow_Call struct {
157 *mock.Call
158}
159
160// DisableWorkflow is a helper method to define mock.On call
161// - ctx context.Context
162// - p domain.Principal
163// - repo domain.RepoName
164// - file string
165func (_e *RunService_Expecter) DisableWorkflow(ctx any, p any, repo any, file any) *RunService_DisableWorkflow_Call {
166 return &RunService_DisableWorkflow_Call{Call: _e.mock.On("DisableWorkflow", ctx, p, repo, file)}
167}
168
169func (_c *RunService_DisableWorkflow_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, file string)) *RunService_DisableWorkflow_Call {
170 _c.Call.Run(func(args mock.Arguments) {
171 var arg0 context.Context
172 if args[0] != nil {
173 arg0 = args[0].(context.Context)
174 }
175 var arg1 domain.Principal
176 if args[1] != nil {
177 arg1 = args[1].(domain.Principal)
178 }
179 var arg2 domain.RepoName
180 if args[2] != nil {
181 arg2 = args[2].(domain.RepoName)
182 }
183 var arg3 string
184 if args[3] != nil {
185 arg3 = args[3].(string)
186 }
187 run(
188 arg0,
189 arg1,
190 arg2,
191 arg3,
192 )
193 })
194 return _c
195}
196
197func (_c *RunService_DisableWorkflow_Call) Return(workflowInfo ports.WorkflowInfo, err error) *RunService_DisableWorkflow_Call {
198 _c.Call.Return(workflowInfo, err)
199 return _c
200}
201
202func (_c *RunService_DisableWorkflow_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, file string) (ports.WorkflowInfo, error)) *RunService_DisableWorkflow_Call {
203 _c.Call.Return(run)
204 return _c
205}
206
207// DisabledWorkflows provides a mock function for the type RunService
208func (_mock *RunService) DisabledWorkflows(ctx context.Context, p domain.Principal, repo domain.RepoName) ([]string, error) {
209 ret := _mock.Called(ctx, p, repo)
210
211 if len(ret) == 0 {
212 panic("no return value specified for DisabledWorkflows")
213 }
214
215 var r0 []string
216 var r1 error
217 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName) ([]string, error)); ok {
218 return returnFunc(ctx, p, repo)
219 }
220 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName) []string); ok {
221 r0 = returnFunc(ctx, p, repo)
222 } else {
223 if ret.Get(0) != nil {
224 r0 = ret.Get(0).([]string)
225 }
226 }
227 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName) error); ok {
228 r1 = returnFunc(ctx, p, repo)
229 } else {
230 r1 = ret.Error(1)
231 }
232 return r0, r1
233}
234
235// RunService_DisabledWorkflows_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisabledWorkflows'
236type RunService_DisabledWorkflows_Call struct {
237 *mock.Call
238}
239
240// DisabledWorkflows is a helper method to define mock.On call
241// - ctx context.Context
242// - p domain.Principal
243// - repo domain.RepoName
244func (_e *RunService_Expecter) DisabledWorkflows(ctx any, p any, repo any) *RunService_DisabledWorkflows_Call {
245 return &RunService_DisabledWorkflows_Call{Call: _e.mock.On("DisabledWorkflows", ctx, p, repo)}
246}
247
248func (_c *RunService_DisabledWorkflows_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName)) *RunService_DisabledWorkflows_Call {
249 _c.Call.Run(func(args mock.Arguments) {
250 var arg0 context.Context
251 if args[0] != nil {
252 arg0 = args[0].(context.Context)
253 }
254 var arg1 domain.Principal
255 if args[1] != nil {
256 arg1 = args[1].(domain.Principal)
257 }
258 var arg2 domain.RepoName
259 if args[2] != nil {
260 arg2 = args[2].(domain.RepoName)
261 }
262 run(
263 arg0,
264 arg1,
265 arg2,
266 )
267 })
268 return _c
269}
270
271func (_c *RunService_DisabledWorkflows_Call) Return(strings []string, err error) *RunService_DisabledWorkflows_Call {
272 _c.Call.Return(strings, err)
273 return _c
274}
275
276func (_c *RunService_DisabledWorkflows_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName) ([]string, error)) *RunService_DisabledWorkflows_Call {
277 _c.Call.Return(run)
278 return _c
279}
280
281// DispatchWorkflow provides a mock function for the type RunService
282func (_mock *RunService) DispatchWorkflow(ctx context.Context, p domain.Principal, repo domain.RepoName, params ports.DispatchParams) (domain.CIRun, error) {
283 ret := _mock.Called(ctx, p, repo, params)
284
285 if len(ret) == 0 {
286 panic("no return value specified for DispatchWorkflow")
287 }
288
289 var r0 domain.CIRun
290 var r1 error
291 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, ports.DispatchParams) (domain.CIRun, error)); ok {
292 return returnFunc(ctx, p, repo, params)
293 }
294 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, ports.DispatchParams) domain.CIRun); ok {
295 r0 = returnFunc(ctx, p, repo, params)
296 } else {
297 r0 = ret.Get(0).(domain.CIRun)
298 }
299 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, ports.DispatchParams) error); ok {
300 r1 = returnFunc(ctx, p, repo, params)
301 } else {
302 r1 = ret.Error(1)
303 }
304 return r0, r1
305}
306
307// RunService_DispatchWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DispatchWorkflow'
308type RunService_DispatchWorkflow_Call struct {
309 *mock.Call
310}
311
312// DispatchWorkflow is a helper method to define mock.On call
313// - ctx context.Context
314// - p domain.Principal
315// - repo domain.RepoName
316// - params ports.DispatchParams
317func (_e *RunService_Expecter) DispatchWorkflow(ctx any, p any, repo any, params any) *RunService_DispatchWorkflow_Call {
318 return &RunService_DispatchWorkflow_Call{Call: _e.mock.On("DispatchWorkflow", ctx, p, repo, params)}
319}
320
321func (_c *RunService_DispatchWorkflow_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, params ports.DispatchParams)) *RunService_DispatchWorkflow_Call {
322 _c.Call.Run(func(args mock.Arguments) {
323 var arg0 context.Context
324 if args[0] != nil {
325 arg0 = args[0].(context.Context)
326 }
327 var arg1 domain.Principal
328 if args[1] != nil {
329 arg1 = args[1].(domain.Principal)
330 }
331 var arg2 domain.RepoName
332 if args[2] != nil {
333 arg2 = args[2].(domain.RepoName)
334 }
335 var arg3 ports.DispatchParams
336 if args[3] != nil {
337 arg3 = args[3].(ports.DispatchParams)
338 }
339 run(
340 arg0,
341 arg1,
342 arg2,
343 arg3,
344 )
345 })
346 return _c
347}
348
349func (_c *RunService_DispatchWorkflow_Call) Return(cIRun domain.CIRun, err error) *RunService_DispatchWorkflow_Call {
350 _c.Call.Return(cIRun, err)
351 return _c
352}
353
354func (_c *RunService_DispatchWorkflow_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, params ports.DispatchParams) (domain.CIRun, error)) *RunService_DispatchWorkflow_Call {
355 _c.Call.Return(run)
356 return _c
357}
358
359// EnableWorkflow provides a mock function for the type RunService
360func (_mock *RunService) EnableWorkflow(ctx context.Context, p domain.Principal, repo domain.RepoName, file string) (ports.WorkflowInfo, error) {
361 ret := _mock.Called(ctx, p, repo, file)
362
363 if len(ret) == 0 {
364 panic("no return value specified for EnableWorkflow")
365 }
366
367 var r0 ports.WorkflowInfo
368 var r1 error
369 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, string) (ports.WorkflowInfo, error)); ok {
370 return returnFunc(ctx, p, repo, file)
371 }
372 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, string) ports.WorkflowInfo); ok {
373 r0 = returnFunc(ctx, p, repo, file)
374 } else {
375 r0 = ret.Get(0).(ports.WorkflowInfo)
376 }
377 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, string) error); ok {
378 r1 = returnFunc(ctx, p, repo, file)
379 } else {
380 r1 = ret.Error(1)
381 }
382 return r0, r1
383}
384
385// RunService_EnableWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableWorkflow'
386type RunService_EnableWorkflow_Call struct {
387 *mock.Call
388}
389
390// EnableWorkflow is a helper method to define mock.On call
391// - ctx context.Context
392// - p domain.Principal
393// - repo domain.RepoName
394// - file string
395func (_e *RunService_Expecter) EnableWorkflow(ctx any, p any, repo any, file any) *RunService_EnableWorkflow_Call {
396 return &RunService_EnableWorkflow_Call{Call: _e.mock.On("EnableWorkflow", ctx, p, repo, file)}
397}
398
399func (_c *RunService_EnableWorkflow_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, file string)) *RunService_EnableWorkflow_Call {
400 _c.Call.Run(func(args mock.Arguments) {
401 var arg0 context.Context
402 if args[0] != nil {
403 arg0 = args[0].(context.Context)
404 }
405 var arg1 domain.Principal
406 if args[1] != nil {
407 arg1 = args[1].(domain.Principal)
408 }
409 var arg2 domain.RepoName
410 if args[2] != nil {
411 arg2 = args[2].(domain.RepoName)
412 }
413 var arg3 string
414 if args[3] != nil {
415 arg3 = args[3].(string)
416 }
417 run(
418 arg0,
419 arg1,
420 arg2,
421 arg3,
422 )
423 })
424 return _c
425}
426
427func (_c *RunService_EnableWorkflow_Call) Return(workflowInfo ports.WorkflowInfo, err error) *RunService_EnableWorkflow_Call {
428 _c.Call.Return(workflowInfo, err)
429 return _c
430}
431
432func (_c *RunService_EnableWorkflow_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, file string) (ports.WorkflowInfo, error)) *RunService_EnableWorkflow_Call {
433 _c.Call.Return(run)
434 return _c
435}
436
437// GetJob provides a mock function for the type RunService
438func (_mock *RunService) GetJob(ctx context.Context, p domain.Principal, repo domain.RepoName, jobID string, attempt int32) (ports.JobView, error) {
439 ret := _mock.Called(ctx, p, repo, jobID, attempt)
440
441 if len(ret) == 0 {
442 panic("no return value specified for GetJob")
443 }
444
445 var r0 ports.JobView
446 var r1 error
447 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, string, int32) (ports.JobView, error)); ok {
448 return returnFunc(ctx, p, repo, jobID, attempt)
449 }
450 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, string, int32) ports.JobView); ok {
451 r0 = returnFunc(ctx, p, repo, jobID, attempt)
452 } else {
453 r0 = ret.Get(0).(ports.JobView)
454 }
455 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, string, int32) error); ok {
456 r1 = returnFunc(ctx, p, repo, jobID, attempt)
457 } else {
458 r1 = ret.Error(1)
459 }
460 return r0, r1
461}
462
463// RunService_GetJob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetJob'
464type RunService_GetJob_Call struct {
465 *mock.Call
466}
467
468// GetJob is a helper method to define mock.On call
469// - ctx context.Context
470// - p domain.Principal
471// - repo domain.RepoName
472// - jobID string
473// - attempt int32
474func (_e *RunService_Expecter) GetJob(ctx any, p any, repo any, jobID any, attempt any) *RunService_GetJob_Call {
475 return &RunService_GetJob_Call{Call: _e.mock.On("GetJob", ctx, p, repo, jobID, attempt)}
476}
477
478func (_c *RunService_GetJob_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, jobID string, attempt int32)) *RunService_GetJob_Call {
479 _c.Call.Run(func(args mock.Arguments) {
480 var arg0 context.Context
481 if args[0] != nil {
482 arg0 = args[0].(context.Context)
483 }
484 var arg1 domain.Principal
485 if args[1] != nil {
486 arg1 = args[1].(domain.Principal)
487 }
488 var arg2 domain.RepoName
489 if args[2] != nil {
490 arg2 = args[2].(domain.RepoName)
491 }
492 var arg3 string
493 if args[3] != nil {
494 arg3 = args[3].(string)
495 }
496 var arg4 int32
497 if args[4] != nil {
498 arg4 = args[4].(int32)
499 }
500 run(
501 arg0,
502 arg1,
503 arg2,
504 arg3,
505 arg4,
506 )
507 })
508 return _c
509}
510
511func (_c *RunService_GetJob_Call) Return(jobView ports.JobView, err error) *RunService_GetJob_Call {
512 _c.Call.Return(jobView, err)
513 return _c
514}
515
516func (_c *RunService_GetJob_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, jobID string, attempt int32) (ports.JobView, error)) *RunService_GetJob_Call {
517 _c.Call.Return(run)
518 return _c
519}
520
521// GetJobLog provides a mock function for the type RunService
522func (_mock *RunService) GetJobLog(ctx context.Context, p domain.Principal, repo domain.RepoName, params ports.GetJobLogParams, send func(ports.LogBatch) error) error {
523 ret := _mock.Called(ctx, p, repo, params, send)
524
525 if len(ret) == 0 {
526 panic("no return value specified for GetJobLog")
527 }
528
529 var r0 error
530 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, ports.GetJobLogParams, func(ports.LogBatch) error) error); ok {
531 r0 = returnFunc(ctx, p, repo, params, send)
532 } else {
533 r0 = ret.Error(0)
534 }
535 return r0
536}
537
538// RunService_GetJobLog_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetJobLog'
539type RunService_GetJobLog_Call struct {
540 *mock.Call
541}
542
543// GetJobLog is a helper method to define mock.On call
544// - ctx context.Context
545// - p domain.Principal
546// - repo domain.RepoName
547// - params ports.GetJobLogParams
548// - send func(ports.LogBatch) error
549func (_e *RunService_Expecter) GetJobLog(ctx any, p any, repo any, params any, send any) *RunService_GetJobLog_Call {
550 return &RunService_GetJobLog_Call{Call: _e.mock.On("GetJobLog", ctx, p, repo, params, send)}
551}
552
553func (_c *RunService_GetJobLog_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, params ports.GetJobLogParams, send func(ports.LogBatch) error)) *RunService_GetJobLog_Call {
554 _c.Call.Run(func(args mock.Arguments) {
555 var arg0 context.Context
556 if args[0] != nil {
557 arg0 = args[0].(context.Context)
558 }
559 var arg1 domain.Principal
560 if args[1] != nil {
561 arg1 = args[1].(domain.Principal)
562 }
563 var arg2 domain.RepoName
564 if args[2] != nil {
565 arg2 = args[2].(domain.RepoName)
566 }
567 var arg3 ports.GetJobLogParams
568 if args[3] != nil {
569 arg3 = args[3].(ports.GetJobLogParams)
570 }
571 var arg4 func(ports.LogBatch) error
572 if args[4] != nil {
573 arg4 = args[4].(func(ports.LogBatch) error)
574 }
575 run(
576 arg0,
577 arg1,
578 arg2,
579 arg3,
580 arg4,
581 )
582 })
583 return _c
584}
585
586func (_c *RunService_GetJobLog_Call) Return(err error) *RunService_GetJobLog_Call {
587 _c.Call.Return(err)
588 return _c
589}
590
591func (_c *RunService_GetJobLog_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, params ports.GetJobLogParams, send func(ports.LogBatch) error) error) *RunService_GetJobLog_Call {
592 _c.Call.Return(run)
593 return _c
594}
595
596// GetRun provides a mock function for the type RunService
597func (_mock *RunService) GetRun(ctx context.Context, p domain.Principal, repo domain.RepoName, runID int64, attempt int32) (ports.RunDetail, error) {
598 ret := _mock.Called(ctx, p, repo, runID, attempt)
599
600 if len(ret) == 0 {
601 panic("no return value specified for GetRun")
602 }
603
604 var r0 ports.RunDetail
605 var r1 error
606 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, int32) (ports.RunDetail, error)); ok {
607 return returnFunc(ctx, p, repo, runID, attempt)
608 }
609 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, int32) ports.RunDetail); ok {
610 r0 = returnFunc(ctx, p, repo, runID, attempt)
611 } else {
612 r0 = ret.Get(0).(ports.RunDetail)
613 }
614 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, int64, int32) error); ok {
615 r1 = returnFunc(ctx, p, repo, runID, attempt)
616 } else {
617 r1 = ret.Error(1)
618 }
619 return r0, r1
620}
621
622// RunService_GetRun_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRun'
623type RunService_GetRun_Call struct {
624 *mock.Call
625}
626
627// GetRun is a helper method to define mock.On call
628// - ctx context.Context
629// - p domain.Principal
630// - repo domain.RepoName
631// - runID int64
632// - attempt int32
633func (_e *RunService_Expecter) GetRun(ctx any, p any, repo any, runID any, attempt any) *RunService_GetRun_Call {
634 return &RunService_GetRun_Call{Call: _e.mock.On("GetRun", ctx, p, repo, runID, attempt)}
635}
636
637func (_c *RunService_GetRun_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, runID int64, attempt int32)) *RunService_GetRun_Call {
638 _c.Call.Run(func(args mock.Arguments) {
639 var arg0 context.Context
640 if args[0] != nil {
641 arg0 = args[0].(context.Context)
642 }
643 var arg1 domain.Principal
644 if args[1] != nil {
645 arg1 = args[1].(domain.Principal)
646 }
647 var arg2 domain.RepoName
648 if args[2] != nil {
649 arg2 = args[2].(domain.RepoName)
650 }
651 var arg3 int64
652 if args[3] != nil {
653 arg3 = args[3].(int64)
654 }
655 var arg4 int32
656 if args[4] != nil {
657 arg4 = args[4].(int32)
658 }
659 run(
660 arg0,
661 arg1,
662 arg2,
663 arg3,
664 arg4,
665 )
666 })
667 return _c
668}
669
670func (_c *RunService_GetRun_Call) Return(runDetail ports.RunDetail, err error) *RunService_GetRun_Call {
671 _c.Call.Return(runDetail, err)
672 return _c
673}
674
675func (_c *RunService_GetRun_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, runID int64, attempt int32) (ports.RunDetail, error)) *RunService_GetRun_Call {
676 _c.Call.Return(run)
677 return _c
678}
679
680// GetStepSummaries provides a mock function for the type RunService
681func (_mock *RunService) GetStepSummaries(ctx context.Context, p domain.Principal, repo domain.RepoName, jobID string, attempt int32, maxBytes int64) (ports.SummaryList, error) {
682 ret := _mock.Called(ctx, p, repo, jobID, attempt, maxBytes)
683
684 if len(ret) == 0 {
685 panic("no return value specified for GetStepSummaries")
686 }
687
688 var r0 ports.SummaryList
689 var r1 error
690 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, string, int32, int64) (ports.SummaryList, error)); ok {
691 return returnFunc(ctx, p, repo, jobID, attempt, maxBytes)
692 }
693 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, string, int32, int64) ports.SummaryList); ok {
694 r0 = returnFunc(ctx, p, repo, jobID, attempt, maxBytes)
695 } else {
696 r0 = ret.Get(0).(ports.SummaryList)
697 }
698 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, string, int32, int64) error); ok {
699 r1 = returnFunc(ctx, p, repo, jobID, attempt, maxBytes)
700 } else {
701 r1 = ret.Error(1)
702 }
703 return r0, r1
704}
705
706// RunService_GetStepSummaries_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStepSummaries'
707type RunService_GetStepSummaries_Call struct {
708 *mock.Call
709}
710
711// GetStepSummaries is a helper method to define mock.On call
712// - ctx context.Context
713// - p domain.Principal
714// - repo domain.RepoName
715// - jobID string
716// - attempt int32
717// - maxBytes int64
718func (_e *RunService_Expecter) GetStepSummaries(ctx any, p any, repo any, jobID any, attempt any, maxBytes any) *RunService_GetStepSummaries_Call {
719 return &RunService_GetStepSummaries_Call{Call: _e.mock.On("GetStepSummaries", ctx, p, repo, jobID, attempt, maxBytes)}
720}
721
722func (_c *RunService_GetStepSummaries_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, jobID string, attempt int32, maxBytes int64)) *RunService_GetStepSummaries_Call {
723 _c.Call.Run(func(args mock.Arguments) {
724 var arg0 context.Context
725 if args[0] != nil {
726 arg0 = args[0].(context.Context)
727 }
728 var arg1 domain.Principal
729 if args[1] != nil {
730 arg1 = args[1].(domain.Principal)
731 }
732 var arg2 domain.RepoName
733 if args[2] != nil {
734 arg2 = args[2].(domain.RepoName)
735 }
736 var arg3 string
737 if args[3] != nil {
738 arg3 = args[3].(string)
739 }
740 var arg4 int32
741 if args[4] != nil {
742 arg4 = args[4].(int32)
743 }
744 var arg5 int64
745 if args[5] != nil {
746 arg5 = args[5].(int64)
747 }
748 run(
749 arg0,
750 arg1,
751 arg2,
752 arg3,
753 arg4,
754 arg5,
755 )
756 })
757 return _c
758}
759
760func (_c *RunService_GetStepSummaries_Call) Return(summaryList ports.SummaryList, err error) *RunService_GetStepSummaries_Call {
761 _c.Call.Return(summaryList, err)
762 return _c
763}
764
765func (_c *RunService_GetStepSummaries_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, jobID string, attempt int32, maxBytes int64) (ports.SummaryList, error)) *RunService_GetStepSummaries_Call {
766 _c.Call.Return(run)
767 return _c
768}
769
770// ListAnnotations provides a mock function for the type RunService
771func (_mock *RunService) ListAnnotations(ctx context.Context, p domain.Principal, repo domain.RepoName, runID int64, attempt int32, jobID string) (ports.AnnotationList, error) {
772 ret := _mock.Called(ctx, p, repo, runID, attempt, jobID)
773
774 if len(ret) == 0 {
775 panic("no return value specified for ListAnnotations")
776 }
777
778 var r0 ports.AnnotationList
779 var r1 error
780 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, int32, string) (ports.AnnotationList, error)); ok {
781 return returnFunc(ctx, p, repo, runID, attempt, jobID)
782 }
783 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, int32, string) ports.AnnotationList); ok {
784 r0 = returnFunc(ctx, p, repo, runID, attempt, jobID)
785 } else {
786 r0 = ret.Get(0).(ports.AnnotationList)
787 }
788 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, int64, int32, string) error); ok {
789 r1 = returnFunc(ctx, p, repo, runID, attempt, jobID)
790 } else {
791 r1 = ret.Error(1)
792 }
793 return r0, r1
794}
795
796// RunService_ListAnnotations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAnnotations'
797type RunService_ListAnnotations_Call struct {
798 *mock.Call
799}
800
801// ListAnnotations is a helper method to define mock.On call
802// - ctx context.Context
803// - p domain.Principal
804// - repo domain.RepoName
805// - runID int64
806// - attempt int32
807// - jobID string
808func (_e *RunService_Expecter) ListAnnotations(ctx any, p any, repo any, runID any, attempt any, jobID any) *RunService_ListAnnotations_Call {
809 return &RunService_ListAnnotations_Call{Call: _e.mock.On("ListAnnotations", ctx, p, repo, runID, attempt, jobID)}
810}
811
812func (_c *RunService_ListAnnotations_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, runID int64, attempt int32, jobID string)) *RunService_ListAnnotations_Call {
813 _c.Call.Run(func(args mock.Arguments) {
814 var arg0 context.Context
815 if args[0] != nil {
816 arg0 = args[0].(context.Context)
817 }
818 var arg1 domain.Principal
819 if args[1] != nil {
820 arg1 = args[1].(domain.Principal)
821 }
822 var arg2 domain.RepoName
823 if args[2] != nil {
824 arg2 = args[2].(domain.RepoName)
825 }
826 var arg3 int64
827 if args[3] != nil {
828 arg3 = args[3].(int64)
829 }
830 var arg4 int32
831 if args[4] != nil {
832 arg4 = args[4].(int32)
833 }
834 var arg5 string
835 if args[5] != nil {
836 arg5 = args[5].(string)
837 }
838 run(
839 arg0,
840 arg1,
841 arg2,
842 arg3,
843 arg4,
844 arg5,
845 )
846 })
847 return _c
848}
849
850func (_c *RunService_ListAnnotations_Call) Return(annotationList ports.AnnotationList, err error) *RunService_ListAnnotations_Call {
851 _c.Call.Return(annotationList, err)
852 return _c
853}
854
855func (_c *RunService_ListAnnotations_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, runID int64, attempt int32, jobID string) (ports.AnnotationList, error)) *RunService_ListAnnotations_Call {
856 _c.Call.Return(run)
857 return _c
858}
859
860// ListChecks provides a mock function for the type RunService
861func (_mock *RunService) ListChecks(ctx context.Context, p domain.Principal, repo domain.RepoName, sha string) (ports.ChecksResult, error) {
862 ret := _mock.Called(ctx, p, repo, sha)
863
864 if len(ret) == 0 {
865 panic("no return value specified for ListChecks")
866 }
867
868 var r0 ports.ChecksResult
869 var r1 error
870 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, string) (ports.ChecksResult, error)); ok {
871 return returnFunc(ctx, p, repo, sha)
872 }
873 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, string) ports.ChecksResult); ok {
874 r0 = returnFunc(ctx, p, repo, sha)
875 } else {
876 r0 = ret.Get(0).(ports.ChecksResult)
877 }
878 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, string) error); ok {
879 r1 = returnFunc(ctx, p, repo, sha)
880 } else {
881 r1 = ret.Error(1)
882 }
883 return r0, r1
884}
885
886// RunService_ListChecks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListChecks'
887type RunService_ListChecks_Call struct {
888 *mock.Call
889}
890
891// ListChecks is a helper method to define mock.On call
892// - ctx context.Context
893// - p domain.Principal
894// - repo domain.RepoName
895// - sha string
896func (_e *RunService_Expecter) ListChecks(ctx any, p any, repo any, sha any) *RunService_ListChecks_Call {
897 return &RunService_ListChecks_Call{Call: _e.mock.On("ListChecks", ctx, p, repo, sha)}
898}
899
900func (_c *RunService_ListChecks_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, sha string)) *RunService_ListChecks_Call {
901 _c.Call.Run(func(args mock.Arguments) {
902 var arg0 context.Context
903 if args[0] != nil {
904 arg0 = args[0].(context.Context)
905 }
906 var arg1 domain.Principal
907 if args[1] != nil {
908 arg1 = args[1].(domain.Principal)
909 }
910 var arg2 domain.RepoName
911 if args[2] != nil {
912 arg2 = args[2].(domain.RepoName)
913 }
914 var arg3 string
915 if args[3] != nil {
916 arg3 = args[3].(string)
917 }
918 run(
919 arg0,
920 arg1,
921 arg2,
922 arg3,
923 )
924 })
925 return _c
926}
927
928func (_c *RunService_ListChecks_Call) Return(checksResult ports.ChecksResult, err error) *RunService_ListChecks_Call {
929 _c.Call.Return(checksResult, err)
930 return _c
931}
932
933func (_c *RunService_ListChecks_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, sha string) (ports.ChecksResult, error)) *RunService_ListChecks_Call {
934 _c.Call.Return(run)
935 return _c
936}
937
938// ListRunners provides a mock function for the type RunService
939func (_mock *RunService) ListRunners(ctx context.Context, p domain.Principal, size int, token string) (ports.RunnerPage, error) {
940 ret := _mock.Called(ctx, p, size, token)
941
942 if len(ret) == 0 {
943 panic("no return value specified for ListRunners")
944 }
945
946 var r0 ports.RunnerPage
947 var r1 error
948 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, int, string) (ports.RunnerPage, error)); ok {
949 return returnFunc(ctx, p, size, token)
950 }
951 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, int, string) ports.RunnerPage); ok {
952 r0 = returnFunc(ctx, p, size, token)
953 } else {
954 r0 = ret.Get(0).(ports.RunnerPage)
955 }
956 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, int, string) error); ok {
957 r1 = returnFunc(ctx, p, size, token)
958 } else {
959 r1 = ret.Error(1)
960 }
961 return r0, r1
962}
963
964// RunService_ListRunners_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRunners'
965type RunService_ListRunners_Call struct {
966 *mock.Call
967}
968
969// ListRunners is a helper method to define mock.On call
970// - ctx context.Context
971// - p domain.Principal
972// - size int
973// - token string
974func (_e *RunService_Expecter) ListRunners(ctx any, p any, size any, token any) *RunService_ListRunners_Call {
975 return &RunService_ListRunners_Call{Call: _e.mock.On("ListRunners", ctx, p, size, token)}
976}
977
978func (_c *RunService_ListRunners_Call) Run(run func(ctx context.Context, p domain.Principal, size int, token string)) *RunService_ListRunners_Call {
979 _c.Call.Run(func(args mock.Arguments) {
980 var arg0 context.Context
981 if args[0] != nil {
982 arg0 = args[0].(context.Context)
983 }
984 var arg1 domain.Principal
985 if args[1] != nil {
986 arg1 = args[1].(domain.Principal)
987 }
988 var arg2 int
989 if args[2] != nil {
990 arg2 = args[2].(int)
991 }
992 var arg3 string
993 if args[3] != nil {
994 arg3 = args[3].(string)
995 }
996 run(
997 arg0,
998 arg1,
999 arg2,
1000 arg3,
1001 )
1002 })
1003 return _c
1004}
1005
1006func (_c *RunService_ListRunners_Call) Return(runnerPage ports.RunnerPage, err error) *RunService_ListRunners_Call {
1007 _c.Call.Return(runnerPage, err)
1008 return _c
1009}
1010
1011func (_c *RunService_ListRunners_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, size int, token string) (ports.RunnerPage, error)) *RunService_ListRunners_Call {
1012 _c.Call.Return(run)
1013 return _c
1014}
1015
1016// ListRuns provides a mock function for the type RunService
1017func (_mock *RunService) ListRuns(ctx context.Context, p domain.Principal, repo domain.RepoName, params ports.ListRunsParams) (ports.RunPage, error) {
1018 ret := _mock.Called(ctx, p, repo, params)
1019
1020 if len(ret) == 0 {
1021 panic("no return value specified for ListRuns")
1022 }
1023
1024 var r0 ports.RunPage
1025 var r1 error
1026 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, ports.ListRunsParams) (ports.RunPage, error)); ok {
1027 return returnFunc(ctx, p, repo, params)
1028 }
1029 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, ports.ListRunsParams) ports.RunPage); ok {
1030 r0 = returnFunc(ctx, p, repo, params)
1031 } else {
1032 r0 = ret.Get(0).(ports.RunPage)
1033 }
1034 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, ports.ListRunsParams) error); ok {
1035 r1 = returnFunc(ctx, p, repo, params)
1036 } else {
1037 r1 = ret.Error(1)
1038 }
1039 return r0, r1
1040}
1041
1042// RunService_ListRuns_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRuns'
1043type RunService_ListRuns_Call struct {
1044 *mock.Call
1045}
1046
1047// ListRuns is a helper method to define mock.On call
1048// - ctx context.Context
1049// - p domain.Principal
1050// - repo domain.RepoName
1051// - params ports.ListRunsParams
1052func (_e *RunService_Expecter) ListRuns(ctx any, p any, repo any, params any) *RunService_ListRuns_Call {
1053 return &RunService_ListRuns_Call{Call: _e.mock.On("ListRuns", ctx, p, repo, params)}
1054}
1055
1056func (_c *RunService_ListRuns_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, params ports.ListRunsParams)) *RunService_ListRuns_Call {
1057 _c.Call.Run(func(args mock.Arguments) {
1058 var arg0 context.Context
1059 if args[0] != nil {
1060 arg0 = args[0].(context.Context)
1061 }
1062 var arg1 domain.Principal
1063 if args[1] != nil {
1064 arg1 = args[1].(domain.Principal)
1065 }
1066 var arg2 domain.RepoName
1067 if args[2] != nil {
1068 arg2 = args[2].(domain.RepoName)
1069 }
1070 var arg3 ports.ListRunsParams
1071 if args[3] != nil {
1072 arg3 = args[3].(ports.ListRunsParams)
1073 }
1074 run(
1075 arg0,
1076 arg1,
1077 arg2,
1078 arg3,
1079 )
1080 })
1081 return _c
1082}
1083
1084func (_c *RunService_ListRuns_Call) Return(runPage ports.RunPage, err error) *RunService_ListRuns_Call {
1085 _c.Call.Return(runPage, err)
1086 return _c
1087}
1088
1089func (_c *RunService_ListRuns_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, params ports.ListRunsParams) (ports.RunPage, error)) *RunService_ListRuns_Call {
1090 _c.Call.Return(run)
1091 return _c
1092}
1093
1094// ListWorkflows provides a mock function for the type RunService
1095func (_mock *RunService) ListWorkflows(ctx context.Context, p domain.Principal, repo domain.RepoName) ([]ports.WorkflowInfo, error) {
1096 ret := _mock.Called(ctx, p, repo)
1097
1098 if len(ret) == 0 {
1099 panic("no return value specified for ListWorkflows")
1100 }
1101
1102 var r0 []ports.WorkflowInfo
1103 var r1 error
1104 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName) ([]ports.WorkflowInfo, error)); ok {
1105 return returnFunc(ctx, p, repo)
1106 }
1107 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName) []ports.WorkflowInfo); ok {
1108 r0 = returnFunc(ctx, p, repo)
1109 } else {
1110 if ret.Get(0) != nil {
1111 r0 = ret.Get(0).([]ports.WorkflowInfo)
1112 }
1113 }
1114 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName) error); ok {
1115 r1 = returnFunc(ctx, p, repo)
1116 } else {
1117 r1 = ret.Error(1)
1118 }
1119 return r0, r1
1120}
1121
1122// RunService_ListWorkflows_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListWorkflows'
1123type RunService_ListWorkflows_Call struct {
1124 *mock.Call
1125}
1126
1127// ListWorkflows is a helper method to define mock.On call
1128// - ctx context.Context
1129// - p domain.Principal
1130// - repo domain.RepoName
1131func (_e *RunService_Expecter) ListWorkflows(ctx any, p any, repo any) *RunService_ListWorkflows_Call {
1132 return &RunService_ListWorkflows_Call{Call: _e.mock.On("ListWorkflows", ctx, p, repo)}
1133}
1134
1135func (_c *RunService_ListWorkflows_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName)) *RunService_ListWorkflows_Call {
1136 _c.Call.Run(func(args mock.Arguments) {
1137 var arg0 context.Context
1138 if args[0] != nil {
1139 arg0 = args[0].(context.Context)
1140 }
1141 var arg1 domain.Principal
1142 if args[1] != nil {
1143 arg1 = args[1].(domain.Principal)
1144 }
1145 var arg2 domain.RepoName
1146 if args[2] != nil {
1147 arg2 = args[2].(domain.RepoName)
1148 }
1149 run(
1150 arg0,
1151 arg1,
1152 arg2,
1153 )
1154 })
1155 return _c
1156}
1157
1158func (_c *RunService_ListWorkflows_Call) Return(workflowInfos []ports.WorkflowInfo, err error) *RunService_ListWorkflows_Call {
1159 _c.Call.Return(workflowInfos, err)
1160 return _c
1161}
1162
1163func (_c *RunService_ListWorkflows_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName) ([]ports.WorkflowInfo, error)) *RunService_ListWorkflows_Call {
1164 _c.Call.Return(run)
1165 return _c
1166}
1167
1168// RemoveRunner provides a mock function for the type RunService
1169func (_mock *RunService) RemoveRunner(ctx context.Context, p domain.Principal, id string) error {
1170 ret := _mock.Called(ctx, p, id)
1171
1172 if len(ret) == 0 {
1173 panic("no return value specified for RemoveRunner")
1174 }
1175
1176 var r0 error
1177 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, string) error); ok {
1178 r0 = returnFunc(ctx, p, id)
1179 } else {
1180 r0 = ret.Error(0)
1181 }
1182 return r0
1183}
1184
1185// RunService_RemoveRunner_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveRunner'
1186type RunService_RemoveRunner_Call struct {
1187 *mock.Call
1188}
1189
1190// RemoveRunner is a helper method to define mock.On call
1191// - ctx context.Context
1192// - p domain.Principal
1193// - id string
1194func (_e *RunService_Expecter) RemoveRunner(ctx any, p any, id any) *RunService_RemoveRunner_Call {
1195 return &RunService_RemoveRunner_Call{Call: _e.mock.On("RemoveRunner", ctx, p, id)}
1196}
1197
1198func (_c *RunService_RemoveRunner_Call) Run(run func(ctx context.Context, p domain.Principal, id string)) *RunService_RemoveRunner_Call {
1199 _c.Call.Run(func(args mock.Arguments) {
1200 var arg0 context.Context
1201 if args[0] != nil {
1202 arg0 = args[0].(context.Context)
1203 }
1204 var arg1 domain.Principal
1205 if args[1] != nil {
1206 arg1 = args[1].(domain.Principal)
1207 }
1208 var arg2 string
1209 if args[2] != nil {
1210 arg2 = args[2].(string)
1211 }
1212 run(
1213 arg0,
1214 arg1,
1215 arg2,
1216 )
1217 })
1218 return _c
1219}
1220
1221func (_c *RunService_RemoveRunner_Call) Return(err error) *RunService_RemoveRunner_Call {
1222 _c.Call.Return(err)
1223 return _c
1224}
1225
1226func (_c *RunService_RemoveRunner_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, id string) error) *RunService_RemoveRunner_Call {
1227 _c.Call.Return(run)
1228 return _c
1229}
1230
1231// RerunRun provides a mock function for the type RunService
1232func (_mock *RunService) RerunRun(ctx context.Context, p domain.Principal, repo domain.RepoName, runID int64, failedOnly bool) (domain.CIRun, error) {
1233 ret := _mock.Called(ctx, p, repo, runID, failedOnly)
1234
1235 if len(ret) == 0 {
1236 panic("no return value specified for RerunRun")
1237 }
1238
1239 var r0 domain.CIRun
1240 var r1 error
1241 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, bool) (domain.CIRun, error)); ok {
1242 return returnFunc(ctx, p, repo, runID, failedOnly)
1243 }
1244 if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, bool) domain.CIRun); ok {
1245 r0 = returnFunc(ctx, p, repo, runID, failedOnly)
1246 } else {
1247 r0 = ret.Get(0).(domain.CIRun)
1248 }
1249 if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, int64, bool) error); ok {
1250 r1 = returnFunc(ctx, p, repo, runID, failedOnly)
1251 } else {
1252 r1 = ret.Error(1)
1253 }
1254 return r0, r1
1255}
1256
1257// RunService_RerunRun_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RerunRun'
1258type RunService_RerunRun_Call struct {
1259 *mock.Call
1260}
1261
1262// RerunRun is a helper method to define mock.On call
1263// - ctx context.Context
1264// - p domain.Principal
1265// - repo domain.RepoName
1266// - runID int64
1267// - failedOnly bool
1268func (_e *RunService_Expecter) RerunRun(ctx any, p any, repo any, runID any, failedOnly any) *RunService_RerunRun_Call {
1269 return &RunService_RerunRun_Call{Call: _e.mock.On("RerunRun", ctx, p, repo, runID, failedOnly)}
1270}
1271
1272func (_c *RunService_RerunRun_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, runID int64, failedOnly bool)) *RunService_RerunRun_Call {
1273 _c.Call.Run(func(args mock.Arguments) {
1274 var arg0 context.Context
1275 if args[0] != nil {
1276 arg0 = args[0].(context.Context)
1277 }
1278 var arg1 domain.Principal
1279 if args[1] != nil {
1280 arg1 = args[1].(domain.Principal)
1281 }
1282 var arg2 domain.RepoName
1283 if args[2] != nil {
1284 arg2 = args[2].(domain.RepoName)
1285 }
1286 var arg3 int64
1287 if args[3] != nil {
1288 arg3 = args[3].(int64)
1289 }
1290 var arg4 bool
1291 if args[4] != nil {
1292 arg4 = args[4].(bool)
1293 }
1294 run(
1295 arg0,
1296 arg1,
1297 arg2,
1298 arg3,
1299 arg4,
1300 )
1301 })
1302 return _c
1303}
1304
1305func (_c *RunService_RerunRun_Call) Return(cIRun domain.CIRun, err error) *RunService_RerunRun_Call {
1306 _c.Call.Return(cIRun, err)
1307 return _c
1308}
1309
1310func (_c *RunService_RerunRun_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, runID int64, failedOnly bool) (domain.CIRun, error)) *RunService_RerunRun_Call {
1311 _c.Call.Return(run)
1312 return _c
1313}