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