1// Code generated by MockGen. DO NOT EDIT.
2// Source: github.com/bnema/archup/internal/domain/ports (interfaces: FileSystem,File,CommandExecutor,ChrootExecutor,ScriptExecutor,HTTPClient,Response,Logger,InstallationRepository)
3//
4// Generated by this command:
5//
6// mockgen -destination=mocks/mock_ports.go -package=mocks . FileSystem,File,CommandExecutor,ChrootExecutor,ScriptExecutor,HTTPClient,Response,Logger,InstallationRepository
7//
8
9// Package mocks is a generated GoMock package.
10package mocks
11
12import (
13 context "context"
14 os "os"
15 reflect "reflect"
16
17 ports "github.com/bnema/archup/internal/domain/ports"
18 gomock "go.uber.org/mock/gomock"
19)
20
21// MockFileSystem is a mock of FileSystem interface.
22type MockFileSystem struct {
23 ctrl *gomock.Controller
24 recorder *MockFileSystemMockRecorder
25 isgomock struct{}
26}
27
28// MockFileSystemMockRecorder is the mock recorder for MockFileSystem.
29type MockFileSystemMockRecorder struct {
30 mock *MockFileSystem
31}
32
33// NewMockFileSystem creates a new mock instance.
34func NewMockFileSystem(ctrl *gomock.Controller) *MockFileSystem {
35 mock := &MockFileSystem{ctrl: ctrl}
36 mock.recorder = &MockFileSystemMockRecorder{mock}
37 return mock
38}
39
40// EXPECT returns an object that allows the caller to indicate expected use.
41func (m *MockFileSystem) EXPECT() *MockFileSystemMockRecorder {
42 return m.recorder
43}
44
45// Chmod mocks base method.
46func (m *MockFileSystem) Chmod(name string, perm os.FileMode) error {
47 m.ctrl.T.Helper()
48 ret := m.ctrl.Call(m, "Chmod", name, perm)
49 ret0, _ := ret[0].(error)
50 return ret0
51}
52
53// Chmod indicates an expected call of Chmod.
54func (mr *MockFileSystemMockRecorder) Chmod(name, perm any) *gomock.Call {
55 mr.mock.ctrl.T.Helper()
56 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Chmod", reflect.TypeOf((*MockFileSystem)(nil).Chmod), name, perm)
57}
58
59// Create mocks base method.
60func (m *MockFileSystem) Create(name string) (ports.File, error) {
61 m.ctrl.T.Helper()
62 ret := m.ctrl.Call(m, "Create", name)
63 ret0, _ := ret[0].(ports.File)
64 ret1, _ := ret[1].(error)
65 return ret0, ret1
66}
67
68// Create indicates an expected call of Create.
69func (mr *MockFileSystemMockRecorder) Create(name any) *gomock.Call {
70 mr.mock.ctrl.T.Helper()
71 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockFileSystem)(nil).Create), name)
72}
73
74// Exists mocks base method.
75func (m *MockFileSystem) Exists(path string) (bool, error) {
76 m.ctrl.T.Helper()
77 ret := m.ctrl.Call(m, "Exists", path)
78 ret0, _ := ret[0].(bool)
79 ret1, _ := ret[1].(error)
80 return ret0, ret1
81}
82
83// Exists indicates an expected call of Exists.
84func (mr *MockFileSystemMockRecorder) Exists(path any) *gomock.Call {
85 mr.mock.ctrl.T.Helper()
86 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exists", reflect.TypeOf((*MockFileSystem)(nil).Exists), path)
87}
88
89// MkdirAll mocks base method.
90func (m *MockFileSystem) MkdirAll(path string, perm os.FileMode) error {
91 m.ctrl.T.Helper()
92 ret := m.ctrl.Call(m, "MkdirAll", path, perm)
93 ret0, _ := ret[0].(error)
94 return ret0
95}
96
97// MkdirAll indicates an expected call of MkdirAll.
98func (mr *MockFileSystemMockRecorder) MkdirAll(path, perm any) *gomock.Call {
99 mr.mock.ctrl.T.Helper()
100 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MkdirAll", reflect.TypeOf((*MockFileSystem)(nil).MkdirAll), path, perm)
101}
102
103// ReadFile mocks base method.
104func (m *MockFileSystem) ReadFile(name string) ([]byte, error) {
105 m.ctrl.T.Helper()
106 ret := m.ctrl.Call(m, "ReadFile", name)
107 ret0, _ := ret[0].([]byte)
108 ret1, _ := ret[1].(error)
109 return ret0, ret1
110}
111
112// ReadFile indicates an expected call of ReadFile.
113func (mr *MockFileSystemMockRecorder) ReadFile(name any) *gomock.Call {
114 mr.mock.ctrl.T.Helper()
115 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadFile", reflect.TypeOf((*MockFileSystem)(nil).ReadFile), name)
116}
117
118// RemoveAll mocks base method.
119func (m *MockFileSystem) RemoveAll(path string) error {
120 m.ctrl.T.Helper()
121 ret := m.ctrl.Call(m, "RemoveAll", path)
122 ret0, _ := ret[0].(error)
123 return ret0
124}
125
126// RemoveAll indicates an expected call of RemoveAll.
127func (mr *MockFileSystemMockRecorder) RemoveAll(path any) *gomock.Call {
128 mr.mock.ctrl.T.Helper()
129 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveAll", reflect.TypeOf((*MockFileSystem)(nil).RemoveAll), path)
130}
131
132// Stat mocks base method.
133func (m *MockFileSystem) Stat(name string) (os.FileInfo, error) {
134 m.ctrl.T.Helper()
135 ret := m.ctrl.Call(m, "Stat", name)
136 ret0, _ := ret[0].(os.FileInfo)
137 ret1, _ := ret[1].(error)
138 return ret0, ret1
139}
140
141// Stat indicates an expected call of Stat.
142func (mr *MockFileSystemMockRecorder) Stat(name any) *gomock.Call {
143 mr.mock.ctrl.T.Helper()
144 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stat", reflect.TypeOf((*MockFileSystem)(nil).Stat), name)
145}
146
147// WriteFile mocks base method.
148func (m *MockFileSystem) WriteFile(name string, data []byte, perm os.FileMode) error {
149 m.ctrl.T.Helper()
150 ret := m.ctrl.Call(m, "WriteFile", name, data, perm)
151 ret0, _ := ret[0].(error)
152 return ret0
153}
154
155// WriteFile indicates an expected call of WriteFile.
156func (mr *MockFileSystemMockRecorder) WriteFile(name, data, perm any) *gomock.Call {
157 mr.mock.ctrl.T.Helper()
158 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteFile", reflect.TypeOf((*MockFileSystem)(nil).WriteFile), name, data, perm)
159}
160
161// MockFile is a mock of File interface.
162type MockFile struct {
163 ctrl *gomock.Controller
164 recorder *MockFileMockRecorder
165 isgomock struct{}
166}
167
168// MockFileMockRecorder is the mock recorder for MockFile.
169type MockFileMockRecorder struct {
170 mock *MockFile
171}
172
173// NewMockFile creates a new mock instance.
174func NewMockFile(ctrl *gomock.Controller) *MockFile {
175 mock := &MockFile{ctrl: ctrl}
176 mock.recorder = &MockFileMockRecorder{mock}
177 return mock
178}
179
180// EXPECT returns an object that allows the caller to indicate expected use.
181func (m *MockFile) EXPECT() *MockFileMockRecorder {
182 return m.recorder
183}
184
185// Close mocks base method.
186func (m *MockFile) Close() error {
187 m.ctrl.T.Helper()
188 ret := m.ctrl.Call(m, "Close")
189 ret0, _ := ret[0].(error)
190 return ret0
191}
192
193// Close indicates an expected call of Close.
194func (mr *MockFileMockRecorder) Close() *gomock.Call {
195 mr.mock.ctrl.T.Helper()
196 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockFile)(nil).Close))
197}
198
199// Read mocks base method.
200func (m *MockFile) Read(b []byte) (int, error) {
201 m.ctrl.T.Helper()
202 ret := m.ctrl.Call(m, "Read", b)
203 ret0, _ := ret[0].(int)
204 ret1, _ := ret[1].(error)
205 return ret0, ret1
206}
207
208// Read indicates an expected call of Read.
209func (mr *MockFileMockRecorder) Read(b any) *gomock.Call {
210 mr.mock.ctrl.T.Helper()
211 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockFile)(nil).Read), b)
212}
213
214// Write mocks base method.
215func (m *MockFile) Write(b []byte) (int, error) {
216 m.ctrl.T.Helper()
217 ret := m.ctrl.Call(m, "Write", b)
218 ret0, _ := ret[0].(int)
219 ret1, _ := ret[1].(error)
220 return ret0, ret1
221}
222
223// Write indicates an expected call of Write.
224func (mr *MockFileMockRecorder) Write(b any) *gomock.Call {
225 mr.mock.ctrl.T.Helper()
226 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockFile)(nil).Write), b)
227}
228
229// MockCommandExecutor is a mock of CommandExecutor interface.
230type MockCommandExecutor struct {
231 ctrl *gomock.Controller
232 recorder *MockCommandExecutorMockRecorder
233 isgomock struct{}
234}
235
236// MockCommandExecutorMockRecorder is the mock recorder for MockCommandExecutor.
237type MockCommandExecutorMockRecorder struct {
238 mock *MockCommandExecutor
239}
240
241// NewMockCommandExecutor creates a new mock instance.
242func NewMockCommandExecutor(ctrl *gomock.Controller) *MockCommandExecutor {
243 mock := &MockCommandExecutor{ctrl: ctrl}
244 mock.recorder = &MockCommandExecutorMockRecorder{mock}
245 return mock
246}
247
248// EXPECT returns an object that allows the caller to indicate expected use.
249func (m *MockCommandExecutor) EXPECT() *MockCommandExecutorMockRecorder {
250 return m.recorder
251}
252
253// Execute mocks base method.
254func (m *MockCommandExecutor) Execute(ctx context.Context, command string, args ...string) ([]byte, error) {
255 m.ctrl.T.Helper()
256 varargs := []any{ctx, command}
257 for _, a := range args {
258 varargs = append(varargs, a)
259 }
260 ret := m.ctrl.Call(m, "Execute", varargs...)
261 ret0, _ := ret[0].([]byte)
262 ret1, _ := ret[1].(error)
263 return ret0, ret1
264}
265
266// Execute indicates an expected call of Execute.
267func (mr *MockCommandExecutorMockRecorder) Execute(ctx, command any, args ...any) *gomock.Call {
268 mr.mock.ctrl.T.Helper()
269 varargs := append([]any{ctx, command}, args...)
270 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Execute", reflect.TypeOf((*MockCommandExecutor)(nil).Execute), varargs...)
271}
272
273// ExecuteWithStdin mocks base method.
274func (m *MockCommandExecutor) ExecuteWithStdin(ctx context.Context, stdin, command string, args ...string) ([]byte, error) {
275 m.ctrl.T.Helper()
276 varargs := []any{ctx, stdin, command}
277 for _, a := range args {
278 varargs = append(varargs, a)
279 }
280 ret := m.ctrl.Call(m, "ExecuteWithStdin", varargs...)
281 ret0, _ := ret[0].([]byte)
282 ret1, _ := ret[1].(error)
283 return ret0, ret1
284}
285
286// ExecuteWithStdin indicates an expected call of ExecuteWithStdin.
287func (mr *MockCommandExecutorMockRecorder) ExecuteWithStdin(ctx, stdin, command any, args ...any) *gomock.Call {
288 mr.mock.ctrl.T.Helper()
289 varargs := append([]any{ctx, stdin, command}, args...)
290 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteWithStdin", reflect.TypeOf((*MockCommandExecutor)(nil).ExecuteWithStdin), varargs...)
291}
292
293// ExecuteWithEnv mocks base method.
294func (m *MockCommandExecutor) ExecuteWithEnv(ctx context.Context, env map[string]string, command string, args ...string) ([]byte, error) {
295 m.ctrl.T.Helper()
296 varargs := []any{ctx, env, command}
297 for _, a := range args {
298 varargs = append(varargs, a)
299 }
300 ret := m.ctrl.Call(m, "ExecuteWithEnv", varargs...)
301 ret0, _ := ret[0].([]byte)
302 ret1, _ := ret[1].(error)
303 return ret0, ret1
304}
305
306// ExecuteWithEnv indicates an expected call of ExecuteWithEnv.
307func (mr *MockCommandExecutorMockRecorder) ExecuteWithEnv(ctx, env, command any, args ...any) *gomock.Call {
308 mr.mock.ctrl.T.Helper()
309 varargs := append([]any{ctx, env, command}, args...)
310 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteWithEnv", reflect.TypeOf((*MockCommandExecutor)(nil).ExecuteWithEnv), varargs...)
311}
312
313// MockChrootExecutor is a mock of ChrootExecutor interface.
314type MockChrootExecutor struct {
315 ctrl *gomock.Controller
316 recorder *MockChrootExecutorMockRecorder
317 isgomock struct{}
318}
319
320// MockChrootExecutorMockRecorder is the mock recorder for MockChrootExecutor.
321type MockChrootExecutorMockRecorder struct {
322 mock *MockChrootExecutor
323}
324
325// NewMockChrootExecutor creates a new mock instance.
326func NewMockChrootExecutor(ctrl *gomock.Controller) *MockChrootExecutor {
327 mock := &MockChrootExecutor{ctrl: ctrl}
328 mock.recorder = &MockChrootExecutorMockRecorder{mock}
329 return mock
330}
331
332// EXPECT returns an object that allows the caller to indicate expected use.
333func (m *MockChrootExecutor) EXPECT() *MockChrootExecutorMockRecorder {
334 return m.recorder
335}
336
337// ChrootSystemctl mocks base method.
338func (m *MockChrootExecutor) ChrootSystemctl(ctx context.Context, logPath, chrootPath string, args ...string) error {
339 m.ctrl.T.Helper()
340 varargs := []any{ctx, logPath, chrootPath}
341 for _, a := range args {
342 varargs = append(varargs, a)
343 }
344 ret := m.ctrl.Call(m, "ChrootSystemctl", varargs...)
345 ret0, _ := ret[0].(error)
346 return ret0
347}
348
349// ChrootSystemctl indicates an expected call of ChrootSystemctl.
350func (mr *MockChrootExecutorMockRecorder) ChrootSystemctl(ctx, logPath, chrootPath any, args ...any) *gomock.Call {
351 mr.mock.ctrl.T.Helper()
352 varargs := append([]any{ctx, logPath, chrootPath}, args...)
353 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChrootSystemctl", reflect.TypeOf((*MockChrootExecutor)(nil).ChrootSystemctl), varargs...)
354}
355
356// ExecuteInChroot mocks base method.
357func (m *MockChrootExecutor) ExecuteInChroot(ctx context.Context, chrootPath, command string, args ...string) ([]byte, error) {
358 m.ctrl.T.Helper()
359 varargs := []any{ctx, chrootPath, command}
360 for _, a := range args {
361 varargs = append(varargs, a)
362 }
363 ret := m.ctrl.Call(m, "ExecuteInChroot", varargs...)
364 ret0, _ := ret[0].([]byte)
365 ret1, _ := ret[1].(error)
366 return ret0, ret1
367}
368
369// ExecuteInChroot indicates an expected call of ExecuteInChroot.
370func (mr *MockChrootExecutorMockRecorder) ExecuteInChroot(ctx, chrootPath, command any, args ...any) *gomock.Call {
371 mr.mock.ctrl.T.Helper()
372 varargs := append([]any{ctx, chrootPath, command}, args...)
373 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteInChroot", reflect.TypeOf((*MockChrootExecutor)(nil).ExecuteInChroot), varargs...)
374}
375
376// ExecuteInChrootWithStdin mocks base method.
377func (m *MockChrootExecutor) ExecuteInChrootWithStdin(ctx context.Context, chrootPath, stdin, command string, args ...string) error {
378 m.ctrl.T.Helper()
379 varargs := []any{ctx, chrootPath, stdin, command}
380 for _, a := range args {
381 varargs = append(varargs, a)
382 }
383 ret := m.ctrl.Call(m, "ExecuteInChrootWithStdin", varargs...)
384 ret0, _ := ret[0].(error)
385 return ret0
386}
387
388// ExecuteInChrootWithStdin indicates an expected call of ExecuteInChrootWithStdin.
389func (mr *MockChrootExecutorMockRecorder) ExecuteInChrootWithStdin(ctx, chrootPath, stdin, command any, args ...any) *gomock.Call {
390 mr.mock.ctrl.T.Helper()
391 varargs := append([]any{ctx, chrootPath, stdin, command}, args...)
392 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteInChrootWithStdin", reflect.TypeOf((*MockChrootExecutor)(nil).ExecuteInChrootWithStdin), varargs...)
393}
394
395// MockScriptExecutor is a mock of ScriptExecutor interface.
396type MockScriptExecutor struct {
397 ctrl *gomock.Controller
398 recorder *MockScriptExecutorMockRecorder
399 isgomock struct{}
400}
401
402// MockScriptExecutorMockRecorder is the mock recorder for MockScriptExecutor.
403type MockScriptExecutorMockRecorder struct {
404 mock *MockScriptExecutor
405}
406
407// NewMockScriptExecutor creates a new mock instance.
408func NewMockScriptExecutor(ctrl *gomock.Controller) *MockScriptExecutor {
409 mock := &MockScriptExecutor{ctrl: ctrl}
410 mock.recorder = &MockScriptExecutorMockRecorder{mock}
411 return mock
412}
413
414// EXPECT returns an object that allows the caller to indicate expected use.
415func (m *MockScriptExecutor) EXPECT() *MockScriptExecutorMockRecorder {
416 return m.recorder
417}
418
419// ExecuteScript mocks base method.
420func (m *MockScriptExecutor) ExecuteScript(ctx context.Context, scriptPath string, env map[string]string) error {
421 m.ctrl.T.Helper()
422 ret := m.ctrl.Call(m, "ExecuteScript", ctx, scriptPath, env)
423 ret0, _ := ret[0].(error)
424 return ret0
425}
426
427// ExecuteScript indicates an expected call of ExecuteScript.
428func (mr *MockScriptExecutorMockRecorder) ExecuteScript(ctx, scriptPath, env any) *gomock.Call {
429 mr.mock.ctrl.T.Helper()
430 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteScript", reflect.TypeOf((*MockScriptExecutor)(nil).ExecuteScript), ctx, scriptPath, env)
431}
432
433// MockHTTPClient is a mock of HTTPClient interface.
434type MockHTTPClient struct {
435 ctrl *gomock.Controller
436 recorder *MockHTTPClientMockRecorder
437 isgomock struct{}
438}
439
440// MockHTTPClientMockRecorder is the mock recorder for MockHTTPClient.
441type MockHTTPClientMockRecorder struct {
442 mock *MockHTTPClient
443}
444
445// NewMockHTTPClient creates a new mock instance.
446func NewMockHTTPClient(ctrl *gomock.Controller) *MockHTTPClient {
447 mock := &MockHTTPClient{ctrl: ctrl}
448 mock.recorder = &MockHTTPClientMockRecorder{mock}
449 return mock
450}
451
452// EXPECT returns an object that allows the caller to indicate expected use.
453func (m *MockHTTPClient) EXPECT() *MockHTTPClientMockRecorder {
454 return m.recorder
455}
456
457// Get mocks base method.
458func (m *MockHTTPClient) Get(url string) (ports.Response, error) {
459 m.ctrl.T.Helper()
460 ret := m.ctrl.Call(m, "Get", url)
461 ret0, _ := ret[0].(ports.Response)
462 ret1, _ := ret[1].(error)
463 return ret0, ret1
464}
465
466// Get indicates an expected call of Get.
467func (mr *MockHTTPClientMockRecorder) Get(url any) *gomock.Call {
468 mr.mock.ctrl.T.Helper()
469 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockHTTPClient)(nil).Get), url)
470}
471
472// Post mocks base method.
473func (m *MockHTTPClient) Post(url, contentType string, body []byte) (ports.Response, error) {
474 m.ctrl.T.Helper()
475 ret := m.ctrl.Call(m, "Post", url, contentType, body)
476 ret0, _ := ret[0].(ports.Response)
477 ret1, _ := ret[1].(error)
478 return ret0, ret1
479}
480
481// Post indicates an expected call of Post.
482func (mr *MockHTTPClientMockRecorder) Post(url, contentType, body any) *gomock.Call {
483 mr.mock.ctrl.T.Helper()
484 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Post", reflect.TypeOf((*MockHTTPClient)(nil).Post), url, contentType, body)
485}
486
487// MockResponse is a mock of Response interface.
488type MockResponse struct {
489 ctrl *gomock.Controller
490 recorder *MockResponseMockRecorder
491 isgomock struct{}
492}
493
494// MockResponseMockRecorder is the mock recorder for MockResponse.
495type MockResponseMockRecorder struct {
496 mock *MockResponse
497}
498
499// NewMockResponse creates a new mock instance.
500func NewMockResponse(ctrl *gomock.Controller) *MockResponse {
501 mock := &MockResponse{ctrl: ctrl}
502 mock.recorder = &MockResponseMockRecorder{mock}
503 return mock
504}
505
506// EXPECT returns an object that allows the caller to indicate expected use.
507func (m *MockResponse) EXPECT() *MockResponseMockRecorder {
508 return m.recorder
509}
510
511// Body mocks base method.
512func (m *MockResponse) Body() []byte {
513 m.ctrl.T.Helper()
514 ret := m.ctrl.Call(m, "Body")
515 ret0, _ := ret[0].([]byte)
516 return ret0
517}
518
519// Body indicates an expected call of Body.
520func (mr *MockResponseMockRecorder) Body() *gomock.Call {
521 mr.mock.ctrl.T.Helper()
522 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Body", reflect.TypeOf((*MockResponse)(nil).Body))
523}
524
525// Close mocks base method.
526func (m *MockResponse) Close() error {
527 m.ctrl.T.Helper()
528 ret := m.ctrl.Call(m, "Close")
529 ret0, _ := ret[0].(error)
530 return ret0
531}
532
533// Close indicates an expected call of Close.
534func (mr *MockResponseMockRecorder) Close() *gomock.Call {
535 mr.mock.ctrl.T.Helper()
536 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockResponse)(nil).Close))
537}
538
539// StatusCode mocks base method.
540func (m *MockResponse) StatusCode() int {
541 m.ctrl.T.Helper()
542 ret := m.ctrl.Call(m, "StatusCode")
543 ret0, _ := ret[0].(int)
544 return ret0
545}
546
547// StatusCode indicates an expected call of StatusCode.
548func (mr *MockResponseMockRecorder) StatusCode() *gomock.Call {
549 mr.mock.ctrl.T.Helper()
550 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatusCode", reflect.TypeOf((*MockResponse)(nil).StatusCode))
551}
552
553// MockLogger is a mock of Logger interface.
554type MockLogger struct {
555 ctrl *gomock.Controller
556 recorder *MockLoggerMockRecorder
557 isgomock struct{}
558}
559
560// MockLoggerMockRecorder is the mock recorder for MockLogger.
561type MockLoggerMockRecorder struct {
562 mock *MockLogger
563}
564
565// NewMockLogger creates a new mock instance.
566func NewMockLogger(ctrl *gomock.Controller) *MockLogger {
567 mock := &MockLogger{ctrl: ctrl}
568 mock.recorder = &MockLoggerMockRecorder{mock}
569 return mock
570}
571
572// EXPECT returns an object that allows the caller to indicate expected use.
573func (m *MockLogger) EXPECT() *MockLoggerMockRecorder {
574 return m.recorder
575}
576
577// Debug mocks base method.
578func (m *MockLogger) Debug(msg string, keysAndValues ...any) {
579 m.ctrl.T.Helper()
580 varargs := []any{msg}
581 for _, a := range keysAndValues {
582 varargs = append(varargs, a)
583 }
584 m.ctrl.Call(m, "Debug", varargs...)
585}
586
587// Debug indicates an expected call of Debug.
588func (mr *MockLoggerMockRecorder) Debug(msg any, keysAndValues ...any) *gomock.Call {
589 mr.mock.ctrl.T.Helper()
590 varargs := append([]any{msg}, keysAndValues...)
591 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debug", reflect.TypeOf((*MockLogger)(nil).Debug), varargs...)
592}
593
594// Error mocks base method.
595func (m *MockLogger) Error(msg string, keysAndValues ...any) {
596 m.ctrl.T.Helper()
597 varargs := []any{msg}
598 for _, a := range keysAndValues {
599 varargs = append(varargs, a)
600 }
601 m.ctrl.Call(m, "Error", varargs...)
602}
603
604// Error indicates an expected call of Error.
605func (mr *MockLoggerMockRecorder) Error(msg any, keysAndValues ...any) *gomock.Call {
606 mr.mock.ctrl.T.Helper()
607 varargs := append([]any{msg}, keysAndValues...)
608 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Error", reflect.TypeOf((*MockLogger)(nil).Error), varargs...)
609}
610
611// Info mocks base method.
612func (m *MockLogger) Info(msg string, keysAndValues ...any) {
613 m.ctrl.T.Helper()
614 varargs := []any{msg}
615 for _, a := range keysAndValues {
616 varargs = append(varargs, a)
617 }
618 m.ctrl.Call(m, "Info", varargs...)
619}
620
621// Info indicates an expected call of Info.
622func (mr *MockLoggerMockRecorder) Info(msg any, keysAndValues ...any) *gomock.Call {
623 mr.mock.ctrl.T.Helper()
624 varargs := append([]any{msg}, keysAndValues...)
625 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockLogger)(nil).Info), varargs...)
626}
627
628// LogPath mocks base method.
629func (m *MockLogger) LogPath() string {
630 m.ctrl.T.Helper()
631 ret := m.ctrl.Call(m, "LogPath")
632 ret0, _ := ret[0].(string)
633 return ret0
634}
635
636// LogPath indicates an expected call of LogPath.
637func (mr *MockLoggerMockRecorder) LogPath() *gomock.Call {
638 mr.mock.ctrl.T.Helper()
639 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogPath", reflect.TypeOf((*MockLogger)(nil).LogPath))
640}
641
642// Warn mocks base method.
643func (m *MockLogger) Warn(msg string, keysAndValues ...any) {
644 m.ctrl.T.Helper()
645 varargs := []any{msg}
646 for _, a := range keysAndValues {
647 varargs = append(varargs, a)
648 }
649 m.ctrl.Call(m, "Warn", varargs...)
650}
651
652// Warn indicates an expected call of Warn.
653func (mr *MockLoggerMockRecorder) Warn(msg any, keysAndValues ...any) *gomock.Call {
654 mr.mock.ctrl.T.Helper()
655 varargs := append([]any{msg}, keysAndValues...)
656 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Warn", reflect.TypeOf((*MockLogger)(nil).Warn), varargs...)
657}
658
659// MockInstallationRepository is a mock of InstallationRepository interface.
660type MockInstallationRepository struct {
661 ctrl *gomock.Controller
662 recorder *MockInstallationRepositoryMockRecorder
663 isgomock struct{}
664}
665
666// MockInstallationRepositoryMockRecorder is the mock recorder for MockInstallationRepository.
667type MockInstallationRepositoryMockRecorder struct {
668 mock *MockInstallationRepository
669}
670
671// NewMockInstallationRepository creates a new mock instance.
672func NewMockInstallationRepository(ctrl *gomock.Controller) *MockInstallationRepository {
673 mock := &MockInstallationRepository{ctrl: ctrl}
674 mock.recorder = &MockInstallationRepositoryMockRecorder{mock}
675 return mock
676}
677
678// EXPECT returns an object that allows the caller to indicate expected use.
679func (m *MockInstallationRepository) EXPECT() *MockInstallationRepositoryMockRecorder {
680 return m.recorder
681}
682
683// Exists mocks base method.
684func (m *MockInstallationRepository) Exists(ctx context.Context, installationID string) (bool, error) {
685 m.ctrl.T.Helper()
686 ret := m.ctrl.Call(m, "Exists", ctx, installationID)
687 ret0, _ := ret[0].(bool)
688 ret1, _ := ret[1].(error)
689 return ret0, ret1
690}
691
692// Exists indicates an expected call of Exists.
693func (mr *MockInstallationRepositoryMockRecorder) Exists(ctx, installationID any) *gomock.Call {
694 mr.mock.ctrl.T.Helper()
695 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exists", reflect.TypeOf((*MockInstallationRepository)(nil).Exists), ctx, installationID)
696}
697
698// Load mocks base method.
699func (m *MockInstallationRepository) Load(ctx context.Context, installationID string) (string, error) {
700 m.ctrl.T.Helper()
701 ret := m.ctrl.Call(m, "Load", ctx, installationID)
702 ret0, _ := ret[0].(string)
703 ret1, _ := ret[1].(error)
704 return ret0, ret1
705}
706
707// Load indicates an expected call of Load.
708func (mr *MockInstallationRepositoryMockRecorder) Load(ctx, installationID any) *gomock.Call {
709 mr.mock.ctrl.T.Helper()
710 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Load", reflect.TypeOf((*MockInstallationRepository)(nil).Load), ctx, installationID)
711}
712
713// Save mocks base method.
714func (m *MockInstallationRepository) Save(ctx context.Context, installationID, state string) error {
715 m.ctrl.T.Helper()
716 ret := m.ctrl.Call(m, "Save", ctx, installationID, state)
717 ret0, _ := ret[0].(error)
718 return ret0
719}
720
721// Save indicates an expected call of Save.
722func (mr *MockInstallationRepositoryMockRecorder) Save(ctx, installationID, state any) *gomock.Call {
723 mr.mock.ctrl.T.Helper()
724 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockInstallationRepository)(nil).Save), ctx, installationID, state)
725}