Config.go raw
1 // Code generated by mockery; DO NOT EDIT.
2 // github.com/vektra/mockery
3 // template: testify
4
5 package mocks
6
7 import (
8 "github.com/getAlby/hub/config"
9 mock "github.com/stretchr/testify/mock"
10 )
11
12 // NewMockConfig creates a new instance of MockConfig. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
13 // The first argument is typically a *testing.T value.
14 func NewMockConfig(t interface {
15 mock.TestingT
16 Cleanup(func())
17 }) *MockConfig {
18 mock := &MockConfig{}
19 mock.Mock.Test(t)
20
21 t.Cleanup(func() { mock.AssertExpectations(t) })
22
23 return mock
24 }
25
26 // MockConfig is an autogenerated mock type for the Config type
27 type MockConfig struct {
28 mock.Mock
29 }
30
31 type MockConfig_Expecter struct {
32 mock *mock.Mock
33 }
34
35 func (_m *MockConfig) EXPECT() *MockConfig_Expecter {
36 return &MockConfig_Expecter{mock: &_m.Mock}
37 }
38
39 // ChangeUnlockPassword provides a mock function for the type MockConfig
40 func (_mock *MockConfig) ChangeUnlockPassword(currentUnlockPassword string, newUnlockPassword string) error {
41 ret := _mock.Called(currentUnlockPassword, newUnlockPassword)
42
43 if len(ret) == 0 {
44 panic("no return value specified for ChangeUnlockPassword")
45 }
46
47 var r0 error
48 if returnFunc, ok := ret.Get(0).(func(string, string) error); ok {
49 r0 = returnFunc(currentUnlockPassword, newUnlockPassword)
50 } else {
51 r0 = ret.Error(0)
52 }
53 return r0
54 }
55
56 // MockConfig_ChangeUnlockPassword_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ChangeUnlockPassword'
57 type MockConfig_ChangeUnlockPassword_Call struct {
58 *mock.Call
59 }
60
61 // ChangeUnlockPassword is a helper method to define mock.On call
62 // - currentUnlockPassword string
63 // - newUnlockPassword string
64 func (_e *MockConfig_Expecter) ChangeUnlockPassword(currentUnlockPassword interface{}, newUnlockPassword interface{}) *MockConfig_ChangeUnlockPassword_Call {
65 return &MockConfig_ChangeUnlockPassword_Call{Call: _e.mock.On("ChangeUnlockPassword", currentUnlockPassword, newUnlockPassword)}
66 }
67
68 func (_c *MockConfig_ChangeUnlockPassword_Call) Run(run func(currentUnlockPassword string, newUnlockPassword string)) *MockConfig_ChangeUnlockPassword_Call {
69 _c.Call.Run(func(args mock.Arguments) {
70 var arg0 string
71 if args[0] != nil {
72 arg0 = args[0].(string)
73 }
74 var arg1 string
75 if args[1] != nil {
76 arg1 = args[1].(string)
77 }
78 run(
79 arg0,
80 arg1,
81 )
82 })
83 return _c
84 }
85
86 func (_c *MockConfig_ChangeUnlockPassword_Call) Return(err error) *MockConfig_ChangeUnlockPassword_Call {
87 _c.Call.Return(err)
88 return _c
89 }
90
91 func (_c *MockConfig_ChangeUnlockPassword_Call) RunAndReturn(run func(currentUnlockPassword string, newUnlockPassword string) error) *MockConfig_ChangeUnlockPassword_Call {
92 _c.Call.Return(run)
93 return _c
94 }
95
96 // CheckUnlockPassword provides a mock function for the type MockConfig
97 func (_mock *MockConfig) CheckUnlockPassword(password string) bool {
98 ret := _mock.Called(password)
99
100 if len(ret) == 0 {
101 panic("no return value specified for CheckUnlockPassword")
102 }
103
104 var r0 bool
105 if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
106 r0 = returnFunc(password)
107 } else {
108 r0 = ret.Get(0).(bool)
109 }
110 return r0
111 }
112
113 // MockConfig_CheckUnlockPassword_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckUnlockPassword'
114 type MockConfig_CheckUnlockPassword_Call struct {
115 *mock.Call
116 }
117
118 // CheckUnlockPassword is a helper method to define mock.On call
119 // - password string
120 func (_e *MockConfig_Expecter) CheckUnlockPassword(password interface{}) *MockConfig_CheckUnlockPassword_Call {
121 return &MockConfig_CheckUnlockPassword_Call{Call: _e.mock.On("CheckUnlockPassword", password)}
122 }
123
124 func (_c *MockConfig_CheckUnlockPassword_Call) Run(run func(password string)) *MockConfig_CheckUnlockPassword_Call {
125 _c.Call.Run(func(args mock.Arguments) {
126 var arg0 string
127 if args[0] != nil {
128 arg0 = args[0].(string)
129 }
130 run(
131 arg0,
132 )
133 })
134 return _c
135 }
136
137 func (_c *MockConfig_CheckUnlockPassword_Call) Return(b bool) *MockConfig_CheckUnlockPassword_Call {
138 _c.Call.Return(b)
139 return _c
140 }
141
142 func (_c *MockConfig_CheckUnlockPassword_Call) RunAndReturn(run func(password string) bool) *MockConfig_CheckUnlockPassword_Call {
143 _c.Call.Return(run)
144 return _c
145 }
146
147 // Get provides a mock function for the type MockConfig
148 func (_mock *MockConfig) Get(key string, encryptionKey string) (string, error) {
149 ret := _mock.Called(key, encryptionKey)
150
151 if len(ret) == 0 {
152 panic("no return value specified for Get")
153 }
154
155 var r0 string
156 var r1 error
157 if returnFunc, ok := ret.Get(0).(func(string, string) (string, error)); ok {
158 return returnFunc(key, encryptionKey)
159 }
160 if returnFunc, ok := ret.Get(0).(func(string, string) string); ok {
161 r0 = returnFunc(key, encryptionKey)
162 } else {
163 r0 = ret.Get(0).(string)
164 }
165 if returnFunc, ok := ret.Get(1).(func(string, string) error); ok {
166 r1 = returnFunc(key, encryptionKey)
167 } else {
168 r1 = ret.Error(1)
169 }
170 return r0, r1
171 }
172
173 // MockConfig_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'
174 type MockConfig_Get_Call struct {
175 *mock.Call
176 }
177
178 // Get is a helper method to define mock.On call
179 // - key string
180 // - encryptionKey string
181 func (_e *MockConfig_Expecter) Get(key interface{}, encryptionKey interface{}) *MockConfig_Get_Call {
182 return &MockConfig_Get_Call{Call: _e.mock.On("Get", key, encryptionKey)}
183 }
184
185 func (_c *MockConfig_Get_Call) Run(run func(key string, encryptionKey string)) *MockConfig_Get_Call {
186 _c.Call.Run(func(args mock.Arguments) {
187 var arg0 string
188 if args[0] != nil {
189 arg0 = args[0].(string)
190 }
191 var arg1 string
192 if args[1] != nil {
193 arg1 = args[1].(string)
194 }
195 run(
196 arg0,
197 arg1,
198 )
199 })
200 return _c
201 }
202
203 func (_c *MockConfig_Get_Call) Return(s string, err error) *MockConfig_Get_Call {
204 _c.Call.Return(s, err)
205 return _c
206 }
207
208 func (_c *MockConfig_Get_Call) RunAndReturn(run func(key string, encryptionKey string) (string, error)) *MockConfig_Get_Call {
209 _c.Call.Return(run)
210 return _c
211 }
212
213 // GetBitcoinDisplayFormat provides a mock function for the type MockConfig
214 func (_mock *MockConfig) GetBitcoinDisplayFormat() string {
215 ret := _mock.Called()
216
217 if len(ret) == 0 {
218 panic("no return value specified for GetBitcoinDisplayFormat")
219 }
220
221 var r0 string
222 if returnFunc, ok := ret.Get(0).(func() string); ok {
223 r0 = returnFunc()
224 } else {
225 r0 = ret.Get(0).(string)
226 }
227 return r0
228 }
229
230 // MockConfig_GetBitcoinDisplayFormat_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBitcoinDisplayFormat'
231 type MockConfig_GetBitcoinDisplayFormat_Call struct {
232 *mock.Call
233 }
234
235 // GetBitcoinDisplayFormat is a helper method to define mock.On call
236 func (_e *MockConfig_Expecter) GetBitcoinDisplayFormat() *MockConfig_GetBitcoinDisplayFormat_Call {
237 return &MockConfig_GetBitcoinDisplayFormat_Call{Call: _e.mock.On("GetBitcoinDisplayFormat")}
238 }
239
240 func (_c *MockConfig_GetBitcoinDisplayFormat_Call) Run(run func()) *MockConfig_GetBitcoinDisplayFormat_Call {
241 _c.Call.Run(func(args mock.Arguments) {
242 run()
243 })
244 return _c
245 }
246
247 func (_c *MockConfig_GetBitcoinDisplayFormat_Call) Return(s string) *MockConfig_GetBitcoinDisplayFormat_Call {
248 _c.Call.Return(s)
249 return _c
250 }
251
252 func (_c *MockConfig_GetBitcoinDisplayFormat_Call) RunAndReturn(run func() string) *MockConfig_GetBitcoinDisplayFormat_Call {
253 _c.Call.Return(run)
254 return _c
255 }
256
257 // GetCurrency provides a mock function for the type MockConfig
258 func (_mock *MockConfig) GetCurrency() string {
259 ret := _mock.Called()
260
261 if len(ret) == 0 {
262 panic("no return value specified for GetCurrency")
263 }
264
265 var r0 string
266 if returnFunc, ok := ret.Get(0).(func() string); ok {
267 r0 = returnFunc()
268 } else {
269 r0 = ret.Get(0).(string)
270 }
271 return r0
272 }
273
274 // MockConfig_GetCurrency_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCurrency'
275 type MockConfig_GetCurrency_Call struct {
276 *mock.Call
277 }
278
279 // GetCurrency is a helper method to define mock.On call
280 func (_e *MockConfig_Expecter) GetCurrency() *MockConfig_GetCurrency_Call {
281 return &MockConfig_GetCurrency_Call{Call: _e.mock.On("GetCurrency")}
282 }
283
284 func (_c *MockConfig_GetCurrency_Call) Run(run func()) *MockConfig_GetCurrency_Call {
285 _c.Call.Run(func(args mock.Arguments) {
286 run()
287 })
288 return _c
289 }
290
291 func (_c *MockConfig_GetCurrency_Call) Return(s string) *MockConfig_GetCurrency_Call {
292 _c.Call.Return(s)
293 return _c
294 }
295
296 func (_c *MockConfig_GetCurrency_Call) RunAndReturn(run func() string) *MockConfig_GetCurrency_Call {
297 _c.Call.Return(run)
298 return _c
299 }
300
301 // GetEnv provides a mock function for the type MockConfig
302 func (_mock *MockConfig) GetEnv() *config.AppConfig {
303 ret := _mock.Called()
304
305 if len(ret) == 0 {
306 panic("no return value specified for GetEnv")
307 }
308
309 var r0 *config.AppConfig
310 if returnFunc, ok := ret.Get(0).(func() *config.AppConfig); ok {
311 r0 = returnFunc()
312 } else {
313 if ret.Get(0) != nil {
314 r0 = ret.Get(0).(*config.AppConfig)
315 }
316 }
317 return r0
318 }
319
320 // MockConfig_GetEnv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEnv'
321 type MockConfig_GetEnv_Call struct {
322 *mock.Call
323 }
324
325 // GetEnv is a helper method to define mock.On call
326 func (_e *MockConfig_Expecter) GetEnv() *MockConfig_GetEnv_Call {
327 return &MockConfig_GetEnv_Call{Call: _e.mock.On("GetEnv")}
328 }
329
330 func (_c *MockConfig_GetEnv_Call) Run(run func()) *MockConfig_GetEnv_Call {
331 _c.Call.Run(func(args mock.Arguments) {
332 run()
333 })
334 return _c
335 }
336
337 func (_c *MockConfig_GetEnv_Call) Return(appConfig *config.AppConfig) *MockConfig_GetEnv_Call {
338 _c.Call.Return(appConfig)
339 return _c
340 }
341
342 func (_c *MockConfig_GetEnv_Call) RunAndReturn(run func() *config.AppConfig) *MockConfig_GetEnv_Call {
343 _c.Call.Return(run)
344 return _c
345 }
346
347 // GetJWTSecret provides a mock function for the type MockConfig
348 func (_mock *MockConfig) GetJWTSecret() (string, error) {
349 ret := _mock.Called()
350
351 if len(ret) == 0 {
352 panic("no return value specified for GetJWTSecret")
353 }
354
355 var r0 string
356 var r1 error
357 if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
358 return returnFunc()
359 }
360 if returnFunc, ok := ret.Get(0).(func() string); ok {
361 r0 = returnFunc()
362 } else {
363 r0 = ret.Get(0).(string)
364 }
365 if returnFunc, ok := ret.Get(1).(func() error); ok {
366 r1 = returnFunc()
367 } else {
368 r1 = ret.Error(1)
369 }
370 return r0, r1
371 }
372
373 // MockConfig_GetJWTSecret_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetJWTSecret'
374 type MockConfig_GetJWTSecret_Call struct {
375 *mock.Call
376 }
377
378 // GetJWTSecret is a helper method to define mock.On call
379 func (_e *MockConfig_Expecter) GetJWTSecret() *MockConfig_GetJWTSecret_Call {
380 return &MockConfig_GetJWTSecret_Call{Call: _e.mock.On("GetJWTSecret")}
381 }
382
383 func (_c *MockConfig_GetJWTSecret_Call) Run(run func()) *MockConfig_GetJWTSecret_Call {
384 _c.Call.Run(func(args mock.Arguments) {
385 run()
386 })
387 return _c
388 }
389
390 func (_c *MockConfig_GetJWTSecret_Call) Return(s string, err error) *MockConfig_GetJWTSecret_Call {
391 _c.Call.Return(s, err)
392 return _c
393 }
394
395 func (_c *MockConfig_GetJWTSecret_Call) RunAndReturn(run func() (string, error)) *MockConfig_GetJWTSecret_Call {
396 _c.Call.Return(run)
397 return _c
398 }
399
400 // GetMempoolUrl provides a mock function for the type MockConfig
401 func (_mock *MockConfig) GetMempoolUrl() string {
402 ret := _mock.Called()
403
404 if len(ret) == 0 {
405 panic("no return value specified for GetMempoolUrl")
406 }
407
408 var r0 string
409 if returnFunc, ok := ret.Get(0).(func() string); ok {
410 r0 = returnFunc()
411 } else {
412 r0 = ret.Get(0).(string)
413 }
414 return r0
415 }
416
417 // MockConfig_GetMempoolUrl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMempoolUrl'
418 type MockConfig_GetMempoolUrl_Call struct {
419 *mock.Call
420 }
421
422 // GetMempoolUrl is a helper method to define mock.On call
423 func (_e *MockConfig_Expecter) GetMempoolUrl() *MockConfig_GetMempoolUrl_Call {
424 return &MockConfig_GetMempoolUrl_Call{Call: _e.mock.On("GetMempoolUrl")}
425 }
426
427 func (_c *MockConfig_GetMempoolUrl_Call) Run(run func()) *MockConfig_GetMempoolUrl_Call {
428 _c.Call.Run(func(args mock.Arguments) {
429 run()
430 })
431 return _c
432 }
433
434 func (_c *MockConfig_GetMempoolUrl_Call) Return(s string) *MockConfig_GetMempoolUrl_Call {
435 _c.Call.Return(s)
436 return _c
437 }
438
439 func (_c *MockConfig_GetMempoolUrl_Call) RunAndReturn(run func() string) *MockConfig_GetMempoolUrl_Call {
440 _c.Call.Return(run)
441 return _c
442 }
443
444 // GetNetwork provides a mock function for the type MockConfig
445 func (_mock *MockConfig) GetNetwork() string {
446 ret := _mock.Called()
447
448 if len(ret) == 0 {
449 panic("no return value specified for GetNetwork")
450 }
451
452 var r0 string
453 if returnFunc, ok := ret.Get(0).(func() string); ok {
454 r0 = returnFunc()
455 } else {
456 r0 = ret.Get(0).(string)
457 }
458 return r0
459 }
460
461 // MockConfig_GetNetwork_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNetwork'
462 type MockConfig_GetNetwork_Call struct {
463 *mock.Call
464 }
465
466 // GetNetwork is a helper method to define mock.On call
467 func (_e *MockConfig_Expecter) GetNetwork() *MockConfig_GetNetwork_Call {
468 return &MockConfig_GetNetwork_Call{Call: _e.mock.On("GetNetwork")}
469 }
470
471 func (_c *MockConfig_GetNetwork_Call) Run(run func()) *MockConfig_GetNetwork_Call {
472 _c.Call.Run(func(args mock.Arguments) {
473 run()
474 })
475 return _c
476 }
477
478 func (_c *MockConfig_GetNetwork_Call) Return(s string) *MockConfig_GetNetwork_Call {
479 _c.Call.Return(s)
480 return _c
481 }
482
483 func (_c *MockConfig_GetNetwork_Call) RunAndReturn(run func() string) *MockConfig_GetNetwork_Call {
484 _c.Call.Return(run)
485 return _c
486 }
487
488 // GetRelayUrls provides a mock function for the type MockConfig
489 func (_mock *MockConfig) GetRelayUrls() []string {
490 ret := _mock.Called()
491
492 if len(ret) == 0 {
493 panic("no return value specified for GetRelayUrls")
494 }
495
496 var r0 []string
497 if returnFunc, ok := ret.Get(0).(func() []string); ok {
498 r0 = returnFunc()
499 } else {
500 if ret.Get(0) != nil {
501 r0 = ret.Get(0).([]string)
502 }
503 }
504 return r0
505 }
506
507 // MockConfig_GetRelayUrls_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRelayUrls'
508 type MockConfig_GetRelayUrls_Call struct {
509 *mock.Call
510 }
511
512 // GetRelayUrls is a helper method to define mock.On call
513 func (_e *MockConfig_Expecter) GetRelayUrls() *MockConfig_GetRelayUrls_Call {
514 return &MockConfig_GetRelayUrls_Call{Call: _e.mock.On("GetRelayUrls")}
515 }
516
517 func (_c *MockConfig_GetRelayUrls_Call) Run(run func()) *MockConfig_GetRelayUrls_Call {
518 _c.Call.Run(func(args mock.Arguments) {
519 run()
520 })
521 return _c
522 }
523
524 func (_c *MockConfig_GetRelayUrls_Call) Return(strings []string) *MockConfig_GetRelayUrls_Call {
525 _c.Call.Return(strings)
526 return _c
527 }
528
529 func (_c *MockConfig_GetRelayUrls_Call) RunAndReturn(run func() []string) *MockConfig_GetRelayUrls_Call {
530 _c.Call.Return(run)
531 return _c
532 }
533
534 // IsUnlockPasswordCheckSet provides a mock function for the type MockConfig
535 func (_mock *MockConfig) IsUnlockPasswordCheckSet() (bool, error) {
536 ret := _mock.Called()
537
538 if len(ret) == 0 {
539 panic("no return value specified for IsUnlockPasswordCheckSet")
540 }
541
542 var r0 bool
543 var r1 error
544 if returnFunc, ok := ret.Get(0).(func() (bool, error)); ok {
545 return returnFunc()
546 }
547 if returnFunc, ok := ret.Get(0).(func() bool); ok {
548 r0 = returnFunc()
549 } else {
550 r0 = ret.Get(0).(bool)
551 }
552 if returnFunc, ok := ret.Get(1).(func() error); ok {
553 r1 = returnFunc()
554 } else {
555 r1 = ret.Error(1)
556 }
557 return r0, r1
558 }
559
560 // MockConfig_IsUnlockPasswordCheckSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsUnlockPasswordCheckSet'
561 type MockConfig_IsUnlockPasswordCheckSet_Call struct {
562 *mock.Call
563 }
564
565 // IsUnlockPasswordCheckSet is a helper method to define mock.On call
566 func (_e *MockConfig_Expecter) IsUnlockPasswordCheckSet() *MockConfig_IsUnlockPasswordCheckSet_Call {
567 return &MockConfig_IsUnlockPasswordCheckSet_Call{Call: _e.mock.On("IsUnlockPasswordCheckSet")}
568 }
569
570 func (_c *MockConfig_IsUnlockPasswordCheckSet_Call) Run(run func()) *MockConfig_IsUnlockPasswordCheckSet_Call {
571 _c.Call.Run(func(args mock.Arguments) {
572 run()
573 })
574 return _c
575 }
576
577 func (_c *MockConfig_IsUnlockPasswordCheckSet_Call) Return(b bool, err error) *MockConfig_IsUnlockPasswordCheckSet_Call {
578 _c.Call.Return(b, err)
579 return _c
580 }
581
582 func (_c *MockConfig_IsUnlockPasswordCheckSet_Call) RunAndReturn(run func() (bool, error)) *MockConfig_IsUnlockPasswordCheckSet_Call {
583 _c.Call.Return(run)
584 return _c
585 }
586
587 // LoadJWTSecret provides a mock function for the type MockConfig
588 func (_mock *MockConfig) LoadJWTSecret(encryptionKey string) error {
589 ret := _mock.Called(encryptionKey)
590
591 if len(ret) == 0 {
592 panic("no return value specified for LoadJWTSecret")
593 }
594
595 var r0 error
596 if returnFunc, ok := ret.Get(0).(func(string) error); ok {
597 r0 = returnFunc(encryptionKey)
598 } else {
599 r0 = ret.Error(0)
600 }
601 return r0
602 }
603
604 // MockConfig_LoadJWTSecret_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadJWTSecret'
605 type MockConfig_LoadJWTSecret_Call struct {
606 *mock.Call
607 }
608
609 // LoadJWTSecret is a helper method to define mock.On call
610 // - encryptionKey string
611 func (_e *MockConfig_Expecter) LoadJWTSecret(encryptionKey interface{}) *MockConfig_LoadJWTSecret_Call {
612 return &MockConfig_LoadJWTSecret_Call{Call: _e.mock.On("LoadJWTSecret", encryptionKey)}
613 }
614
615 func (_c *MockConfig_LoadJWTSecret_Call) Run(run func(encryptionKey string)) *MockConfig_LoadJWTSecret_Call {
616 _c.Call.Run(func(args mock.Arguments) {
617 var arg0 string
618 if args[0] != nil {
619 arg0 = args[0].(string)
620 }
621 run(
622 arg0,
623 )
624 })
625 return _c
626 }
627
628 func (_c *MockConfig_LoadJWTSecret_Call) Return(err error) *MockConfig_LoadJWTSecret_Call {
629 _c.Call.Return(err)
630 return _c
631 }
632
633 func (_c *MockConfig_LoadJWTSecret_Call) RunAndReturn(run func(encryptionKey string) error) *MockConfig_LoadJWTSecret_Call {
634 _c.Call.Return(run)
635 return _c
636 }
637
638 // SaveUnlockPasswordCheck provides a mock function for the type MockConfig
639 func (_mock *MockConfig) SaveUnlockPasswordCheck(encryptionKey string) error {
640 ret := _mock.Called(encryptionKey)
641
642 if len(ret) == 0 {
643 panic("no return value specified for SaveUnlockPasswordCheck")
644 }
645
646 var r0 error
647 if returnFunc, ok := ret.Get(0).(func(string) error); ok {
648 r0 = returnFunc(encryptionKey)
649 } else {
650 r0 = ret.Error(0)
651 }
652 return r0
653 }
654
655 // MockConfig_SaveUnlockPasswordCheck_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveUnlockPasswordCheck'
656 type MockConfig_SaveUnlockPasswordCheck_Call struct {
657 *mock.Call
658 }
659
660 // SaveUnlockPasswordCheck is a helper method to define mock.On call
661 // - encryptionKey string
662 func (_e *MockConfig_Expecter) SaveUnlockPasswordCheck(encryptionKey interface{}) *MockConfig_SaveUnlockPasswordCheck_Call {
663 return &MockConfig_SaveUnlockPasswordCheck_Call{Call: _e.mock.On("SaveUnlockPasswordCheck", encryptionKey)}
664 }
665
666 func (_c *MockConfig_SaveUnlockPasswordCheck_Call) Run(run func(encryptionKey string)) *MockConfig_SaveUnlockPasswordCheck_Call {
667 _c.Call.Run(func(args mock.Arguments) {
668 var arg0 string
669 if args[0] != nil {
670 arg0 = args[0].(string)
671 }
672 run(
673 arg0,
674 )
675 })
676 return _c
677 }
678
679 func (_c *MockConfig_SaveUnlockPasswordCheck_Call) Return(err error) *MockConfig_SaveUnlockPasswordCheck_Call {
680 _c.Call.Return(err)
681 return _c
682 }
683
684 func (_c *MockConfig_SaveUnlockPasswordCheck_Call) RunAndReturn(run func(encryptionKey string) error) *MockConfig_SaveUnlockPasswordCheck_Call {
685 _c.Call.Return(run)
686 return _c
687 }
688
689 // SetAutoUnlockPassword provides a mock function for the type MockConfig
690 func (_mock *MockConfig) SetAutoUnlockPassword(unlockPassword string) error {
691 ret := _mock.Called(unlockPassword)
692
693 if len(ret) == 0 {
694 panic("no return value specified for SetAutoUnlockPassword")
695 }
696
697 var r0 error
698 if returnFunc, ok := ret.Get(0).(func(string) error); ok {
699 r0 = returnFunc(unlockPassword)
700 } else {
701 r0 = ret.Error(0)
702 }
703 return r0
704 }
705
706 // MockConfig_SetAutoUnlockPassword_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetAutoUnlockPassword'
707 type MockConfig_SetAutoUnlockPassword_Call struct {
708 *mock.Call
709 }
710
711 // SetAutoUnlockPassword is a helper method to define mock.On call
712 // - unlockPassword string
713 func (_e *MockConfig_Expecter) SetAutoUnlockPassword(unlockPassword interface{}) *MockConfig_SetAutoUnlockPassword_Call {
714 return &MockConfig_SetAutoUnlockPassword_Call{Call: _e.mock.On("SetAutoUnlockPassword", unlockPassword)}
715 }
716
717 func (_c *MockConfig_SetAutoUnlockPassword_Call) Run(run func(unlockPassword string)) *MockConfig_SetAutoUnlockPassword_Call {
718 _c.Call.Run(func(args mock.Arguments) {
719 var arg0 string
720 if args[0] != nil {
721 arg0 = args[0].(string)
722 }
723 run(
724 arg0,
725 )
726 })
727 return _c
728 }
729
730 func (_c *MockConfig_SetAutoUnlockPassword_Call) Return(err error) *MockConfig_SetAutoUnlockPassword_Call {
731 _c.Call.Return(err)
732 return _c
733 }
734
735 func (_c *MockConfig_SetAutoUnlockPassword_Call) RunAndReturn(run func(unlockPassword string) error) *MockConfig_SetAutoUnlockPassword_Call {
736 _c.Call.Return(run)
737 return _c
738 }
739
740 // SetBitcoinDisplayFormat provides a mock function for the type MockConfig
741 func (_mock *MockConfig) SetBitcoinDisplayFormat(value string) error {
742 ret := _mock.Called(value)
743
744 if len(ret) == 0 {
745 panic("no return value specified for SetBitcoinDisplayFormat")
746 }
747
748 var r0 error
749 if returnFunc, ok := ret.Get(0).(func(string) error); ok {
750 r0 = returnFunc(value)
751 } else {
752 r0 = ret.Error(0)
753 }
754 return r0
755 }
756
757 // MockConfig_SetBitcoinDisplayFormat_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetBitcoinDisplayFormat'
758 type MockConfig_SetBitcoinDisplayFormat_Call struct {
759 *mock.Call
760 }
761
762 // SetBitcoinDisplayFormat is a helper method to define mock.On call
763 // - value string
764 func (_e *MockConfig_Expecter) SetBitcoinDisplayFormat(value interface{}) *MockConfig_SetBitcoinDisplayFormat_Call {
765 return &MockConfig_SetBitcoinDisplayFormat_Call{Call: _e.mock.On("SetBitcoinDisplayFormat", value)}
766 }
767
768 func (_c *MockConfig_SetBitcoinDisplayFormat_Call) Run(run func(value string)) *MockConfig_SetBitcoinDisplayFormat_Call {
769 _c.Call.Run(func(args mock.Arguments) {
770 var arg0 string
771 if args[0] != nil {
772 arg0 = args[0].(string)
773 }
774 run(
775 arg0,
776 )
777 })
778 return _c
779 }
780
781 func (_c *MockConfig_SetBitcoinDisplayFormat_Call) Return(err error) *MockConfig_SetBitcoinDisplayFormat_Call {
782 _c.Call.Return(err)
783 return _c
784 }
785
786 func (_c *MockConfig_SetBitcoinDisplayFormat_Call) RunAndReturn(run func(value string) error) *MockConfig_SetBitcoinDisplayFormat_Call {
787 _c.Call.Return(run)
788 return _c
789 }
790
791 // SetCurrency provides a mock function for the type MockConfig
792 func (_mock *MockConfig) SetCurrency(value string) error {
793 ret := _mock.Called(value)
794
795 if len(ret) == 0 {
796 panic("no return value specified for SetCurrency")
797 }
798
799 var r0 error
800 if returnFunc, ok := ret.Get(0).(func(string) error); ok {
801 r0 = returnFunc(value)
802 } else {
803 r0 = ret.Error(0)
804 }
805 return r0
806 }
807
808 // MockConfig_SetCurrency_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCurrency'
809 type MockConfig_SetCurrency_Call struct {
810 *mock.Call
811 }
812
813 // SetCurrency is a helper method to define mock.On call
814 // - value string
815 func (_e *MockConfig_Expecter) SetCurrency(value interface{}) *MockConfig_SetCurrency_Call {
816 return &MockConfig_SetCurrency_Call{Call: _e.mock.On("SetCurrency", value)}
817 }
818
819 func (_c *MockConfig_SetCurrency_Call) Run(run func(value string)) *MockConfig_SetCurrency_Call {
820 _c.Call.Run(func(args mock.Arguments) {
821 var arg0 string
822 if args[0] != nil {
823 arg0 = args[0].(string)
824 }
825 run(
826 arg0,
827 )
828 })
829 return _c
830 }
831
832 func (_c *MockConfig_SetCurrency_Call) Return(err error) *MockConfig_SetCurrency_Call {
833 _c.Call.Return(err)
834 return _c
835 }
836
837 func (_c *MockConfig_SetCurrency_Call) RunAndReturn(run func(value string) error) *MockConfig_SetCurrency_Call {
838 _c.Call.Return(run)
839 return _c
840 }
841
842 // SetIgnore provides a mock function for the type MockConfig
843 func (_mock *MockConfig) SetIgnore(key string, value string, encryptionKey string) error {
844 ret := _mock.Called(key, value, encryptionKey)
845
846 if len(ret) == 0 {
847 panic("no return value specified for SetIgnore")
848 }
849
850 var r0 error
851 if returnFunc, ok := ret.Get(0).(func(string, string, string) error); ok {
852 r0 = returnFunc(key, value, encryptionKey)
853 } else {
854 r0 = ret.Error(0)
855 }
856 return r0
857 }
858
859 // MockConfig_SetIgnore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetIgnore'
860 type MockConfig_SetIgnore_Call struct {
861 *mock.Call
862 }
863
864 // SetIgnore is a helper method to define mock.On call
865 // - key string
866 // - value string
867 // - encryptionKey string
868 func (_e *MockConfig_Expecter) SetIgnore(key interface{}, value interface{}, encryptionKey interface{}) *MockConfig_SetIgnore_Call {
869 return &MockConfig_SetIgnore_Call{Call: _e.mock.On("SetIgnore", key, value, encryptionKey)}
870 }
871
872 func (_c *MockConfig_SetIgnore_Call) Run(run func(key string, value string, encryptionKey string)) *MockConfig_SetIgnore_Call {
873 _c.Call.Run(func(args mock.Arguments) {
874 var arg0 string
875 if args[0] != nil {
876 arg0 = args[0].(string)
877 }
878 var arg1 string
879 if args[1] != nil {
880 arg1 = args[1].(string)
881 }
882 var arg2 string
883 if args[2] != nil {
884 arg2 = args[2].(string)
885 }
886 run(
887 arg0,
888 arg1,
889 arg2,
890 )
891 })
892 return _c
893 }
894
895 func (_c *MockConfig_SetIgnore_Call) Return(err error) *MockConfig_SetIgnore_Call {
896 _c.Call.Return(err)
897 return _c
898 }
899
900 func (_c *MockConfig_SetIgnore_Call) RunAndReturn(run func(key string, value string, encryptionKey string) error) *MockConfig_SetIgnore_Call {
901 _c.Call.Return(run)
902 return _c
903 }
904
905 // SetUpdate provides a mock function for the type MockConfig
906 func (_mock *MockConfig) SetUpdate(key string, value string, encryptionKey string) error {
907 ret := _mock.Called(key, value, encryptionKey)
908
909 if len(ret) == 0 {
910 panic("no return value specified for SetUpdate")
911 }
912
913 var r0 error
914 if returnFunc, ok := ret.Get(0).(func(string, string, string) error); ok {
915 r0 = returnFunc(key, value, encryptionKey)
916 } else {
917 r0 = ret.Error(0)
918 }
919 return r0
920 }
921
922 // MockConfig_SetUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetUpdate'
923 type MockConfig_SetUpdate_Call struct {
924 *mock.Call
925 }
926
927 // SetUpdate is a helper method to define mock.On call
928 // - key string
929 // - value string
930 // - encryptionKey string
931 func (_e *MockConfig_Expecter) SetUpdate(key interface{}, value interface{}, encryptionKey interface{}) *MockConfig_SetUpdate_Call {
932 return &MockConfig_SetUpdate_Call{Call: _e.mock.On("SetUpdate", key, value, encryptionKey)}
933 }
934
935 func (_c *MockConfig_SetUpdate_Call) Run(run func(key string, value string, encryptionKey string)) *MockConfig_SetUpdate_Call {
936 _c.Call.Run(func(args mock.Arguments) {
937 var arg0 string
938 if args[0] != nil {
939 arg0 = args[0].(string)
940 }
941 var arg1 string
942 if args[1] != nil {
943 arg1 = args[1].(string)
944 }
945 var arg2 string
946 if args[2] != nil {
947 arg2 = args[2].(string)
948 }
949 run(
950 arg0,
951 arg1,
952 arg2,
953 )
954 })
955 return _c
956 }
957
958 func (_c *MockConfig_SetUpdate_Call) Return(err error) *MockConfig_SetUpdate_Call {
959 _c.Call.Return(err)
960 return _c
961 }
962
963 func (_c *MockConfig_SetUpdate_Call) RunAndReturn(run func(key string, value string, encryptionKey string) error) *MockConfig_SetUpdate_Call {
964 _c.Call.Return(run)
965 return _c
966 }
967
968 // SetupCompleted provides a mock function for the type MockConfig
969 func (_mock *MockConfig) SetupCompleted() (bool, error) {
970 ret := _mock.Called()
971
972 if len(ret) == 0 {
973 panic("no return value specified for SetupCompleted")
974 }
975
976 var r0 bool
977 var r1 error
978 if returnFunc, ok := ret.Get(0).(func() (bool, error)); ok {
979 return returnFunc()
980 }
981 if returnFunc, ok := ret.Get(0).(func() bool); ok {
982 r0 = returnFunc()
983 } else {
984 r0 = ret.Get(0).(bool)
985 }
986 if returnFunc, ok := ret.Get(1).(func() error); ok {
987 r1 = returnFunc()
988 } else {
989 r1 = ret.Error(1)
990 }
991 return r0, r1
992 }
993
994 // MockConfig_SetupCompleted_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetupCompleted'
995 type MockConfig_SetupCompleted_Call struct {
996 *mock.Call
997 }
998
999 // SetupCompleted is a helper method to define mock.On call
1000 func (_e *MockConfig_Expecter) SetupCompleted() *MockConfig_SetupCompleted_Call {
1001 return &MockConfig_SetupCompleted_Call{Call: _e.mock.On("SetupCompleted")}
1002 }
1003
1004 func (_c *MockConfig_SetupCompleted_Call) Run(run func()) *MockConfig_SetupCompleted_Call {
1005 _c.Call.Run(func(args mock.Arguments) {
1006 run()
1007 })
1008 return _c
1009 }
1010
1011 func (_c *MockConfig_SetupCompleted_Call) Return(b bool, err error) *MockConfig_SetupCompleted_Call {
1012 _c.Call.Return(b, err)
1013 return _c
1014 }
1015
1016 func (_c *MockConfig_SetupCompleted_Call) RunAndReturn(run func() (bool, error)) *MockConfig_SetupCompleted_Call {
1017 _c.Call.Return(run)
1018 return _c
1019 }
1020