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 // GetNip07OwnerPubkey provides a mock function for the type MockConfig
588 func (_mock *MockConfig) GetNip07OwnerPubkey() string {
589 ret := _mock.Called()
590
591 if len(ret) == 0 {
592 panic("no return value specified for GetNip07OwnerPubkey")
593 }
594
595 var r0 string
596 if returnFunc, ok := ret.Get(0).(func() string); ok {
597 r0 = returnFunc()
598 } else {
599 r0 = ret.Get(0).(string)
600 }
601 return r0
602 }
603
604 // GetSessionSecret provides a mock function for the type MockConfig
605 func (_mock *MockConfig) GetSessionSecret() (string, error) {
606 ret := _mock.Called()
607
608 if len(ret) == 0 {
609 panic("no return value specified for GetSessionSecret")
610 }
611
612 var r0 string
613 var r1 error
614 if returnFunc, ok := ret.Get(0).(func() (string, error)); ok {
615 return returnFunc()
616 }
617 if returnFunc, ok := ret.Get(0).(func() string); ok {
618 r0 = returnFunc()
619 } else {
620 r0 = ret.Get(0).(string)
621 }
622 if returnFunc, ok := ret.Get(1).(func() error); ok {
623 r1 = returnFunc()
624 } else {
625 r1 = ret.Error(1)
626 }
627 return r0, r1
628 }
629
630 // LoadJWTSecret provides a mock function for the type MockConfig
631 func (_mock *MockConfig) LoadJWTSecret(encryptionKey string) error {
632 ret := _mock.Called(encryptionKey)
633
634 if len(ret) == 0 {
635 panic("no return value specified for LoadJWTSecret")
636 }
637
638 var r0 error
639 if returnFunc, ok := ret.Get(0).(func(string) error); ok {
640 r0 = returnFunc(encryptionKey)
641 } else {
642 r0 = ret.Error(0)
643 }
644 return r0
645 }
646
647 // MockConfig_LoadJWTSecret_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadJWTSecret'
648 type MockConfig_LoadJWTSecret_Call struct {
649 *mock.Call
650 }
651
652 // LoadJWTSecret is a helper method to define mock.On call
653 // - encryptionKey string
654 func (_e *MockConfig_Expecter) LoadJWTSecret(encryptionKey interface{}) *MockConfig_LoadJWTSecret_Call {
655 return &MockConfig_LoadJWTSecret_Call{Call: _e.mock.On("LoadJWTSecret", encryptionKey)}
656 }
657
658 func (_c *MockConfig_LoadJWTSecret_Call) Run(run func(encryptionKey string)) *MockConfig_LoadJWTSecret_Call {
659 _c.Call.Run(func(args mock.Arguments) {
660 var arg0 string
661 if args[0] != nil {
662 arg0 = args[0].(string)
663 }
664 run(
665 arg0,
666 )
667 })
668 return _c
669 }
670
671 func (_c *MockConfig_LoadJWTSecret_Call) Return(err error) *MockConfig_LoadJWTSecret_Call {
672 _c.Call.Return(err)
673 return _c
674 }
675
676 func (_c *MockConfig_LoadJWTSecret_Call) RunAndReturn(run func(encryptionKey string) error) *MockConfig_LoadJWTSecret_Call {
677 _c.Call.Return(run)
678 return _c
679 }
680
681 // SaveUnlockPasswordCheck provides a mock function for the type MockConfig
682 func (_mock *MockConfig) SaveUnlockPasswordCheck(encryptionKey string) error {
683 ret := _mock.Called(encryptionKey)
684
685 if len(ret) == 0 {
686 panic("no return value specified for SaveUnlockPasswordCheck")
687 }
688
689 var r0 error
690 if returnFunc, ok := ret.Get(0).(func(string) error); ok {
691 r0 = returnFunc(encryptionKey)
692 } else {
693 r0 = ret.Error(0)
694 }
695 return r0
696 }
697
698 // MockConfig_SaveUnlockPasswordCheck_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveUnlockPasswordCheck'
699 type MockConfig_SaveUnlockPasswordCheck_Call struct {
700 *mock.Call
701 }
702
703 // SaveUnlockPasswordCheck is a helper method to define mock.On call
704 // - encryptionKey string
705 func (_e *MockConfig_Expecter) SaveUnlockPasswordCheck(encryptionKey interface{}) *MockConfig_SaveUnlockPasswordCheck_Call {
706 return &MockConfig_SaveUnlockPasswordCheck_Call{Call: _e.mock.On("SaveUnlockPasswordCheck", encryptionKey)}
707 }
708
709 func (_c *MockConfig_SaveUnlockPasswordCheck_Call) Run(run func(encryptionKey string)) *MockConfig_SaveUnlockPasswordCheck_Call {
710 _c.Call.Run(func(args mock.Arguments) {
711 var arg0 string
712 if args[0] != nil {
713 arg0 = args[0].(string)
714 }
715 run(
716 arg0,
717 )
718 })
719 return _c
720 }
721
722 func (_c *MockConfig_SaveUnlockPasswordCheck_Call) Return(err error) *MockConfig_SaveUnlockPasswordCheck_Call {
723 _c.Call.Return(err)
724 return _c
725 }
726
727 func (_c *MockConfig_SaveUnlockPasswordCheck_Call) RunAndReturn(run func(encryptionKey string) error) *MockConfig_SaveUnlockPasswordCheck_Call {
728 _c.Call.Return(run)
729 return _c
730 }
731
732 // SetAutoUnlockPassword provides a mock function for the type MockConfig
733 func (_mock *MockConfig) SetAutoUnlockPassword(unlockPassword string) error {
734 ret := _mock.Called(unlockPassword)
735
736 if len(ret) == 0 {
737 panic("no return value specified for SetAutoUnlockPassword")
738 }
739
740 var r0 error
741 if returnFunc, ok := ret.Get(0).(func(string) error); ok {
742 r0 = returnFunc(unlockPassword)
743 } else {
744 r0 = ret.Error(0)
745 }
746 return r0
747 }
748
749 // MockConfig_SetAutoUnlockPassword_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetAutoUnlockPassword'
750 type MockConfig_SetAutoUnlockPassword_Call struct {
751 *mock.Call
752 }
753
754 // SetAutoUnlockPassword is a helper method to define mock.On call
755 // - unlockPassword string
756 func (_e *MockConfig_Expecter) SetAutoUnlockPassword(unlockPassword interface{}) *MockConfig_SetAutoUnlockPassword_Call {
757 return &MockConfig_SetAutoUnlockPassword_Call{Call: _e.mock.On("SetAutoUnlockPassword", unlockPassword)}
758 }
759
760 func (_c *MockConfig_SetAutoUnlockPassword_Call) Run(run func(unlockPassword string)) *MockConfig_SetAutoUnlockPassword_Call {
761 _c.Call.Run(func(args mock.Arguments) {
762 var arg0 string
763 if args[0] != nil {
764 arg0 = args[0].(string)
765 }
766 run(
767 arg0,
768 )
769 })
770 return _c
771 }
772
773 func (_c *MockConfig_SetAutoUnlockPassword_Call) Return(err error) *MockConfig_SetAutoUnlockPassword_Call {
774 _c.Call.Return(err)
775 return _c
776 }
777
778 func (_c *MockConfig_SetAutoUnlockPassword_Call) RunAndReturn(run func(unlockPassword string) error) *MockConfig_SetAutoUnlockPassword_Call {
779 _c.Call.Return(run)
780 return _c
781 }
782
783 // SetBitcoinDisplayFormat provides a mock function for the type MockConfig
784 func (_mock *MockConfig) SetBitcoinDisplayFormat(value string) error {
785 ret := _mock.Called(value)
786
787 if len(ret) == 0 {
788 panic("no return value specified for SetBitcoinDisplayFormat")
789 }
790
791 var r0 error
792 if returnFunc, ok := ret.Get(0).(func(string) error); ok {
793 r0 = returnFunc(value)
794 } else {
795 r0 = ret.Error(0)
796 }
797 return r0
798 }
799
800 // MockConfig_SetBitcoinDisplayFormat_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetBitcoinDisplayFormat'
801 type MockConfig_SetBitcoinDisplayFormat_Call struct {
802 *mock.Call
803 }
804
805 // SetBitcoinDisplayFormat is a helper method to define mock.On call
806 // - value string
807 func (_e *MockConfig_Expecter) SetBitcoinDisplayFormat(value interface{}) *MockConfig_SetBitcoinDisplayFormat_Call {
808 return &MockConfig_SetBitcoinDisplayFormat_Call{Call: _e.mock.On("SetBitcoinDisplayFormat", value)}
809 }
810
811 func (_c *MockConfig_SetBitcoinDisplayFormat_Call) Run(run func(value string)) *MockConfig_SetBitcoinDisplayFormat_Call {
812 _c.Call.Run(func(args mock.Arguments) {
813 var arg0 string
814 if args[0] != nil {
815 arg0 = args[0].(string)
816 }
817 run(
818 arg0,
819 )
820 })
821 return _c
822 }
823
824 func (_c *MockConfig_SetBitcoinDisplayFormat_Call) Return(err error) *MockConfig_SetBitcoinDisplayFormat_Call {
825 _c.Call.Return(err)
826 return _c
827 }
828
829 func (_c *MockConfig_SetBitcoinDisplayFormat_Call) RunAndReturn(run func(value string) error) *MockConfig_SetBitcoinDisplayFormat_Call {
830 _c.Call.Return(run)
831 return _c
832 }
833
834 // SetCurrency provides a mock function for the type MockConfig
835 func (_mock *MockConfig) SetCurrency(value string) error {
836 ret := _mock.Called(value)
837
838 if len(ret) == 0 {
839 panic("no return value specified for SetCurrency")
840 }
841
842 var r0 error
843 if returnFunc, ok := ret.Get(0).(func(string) error); ok {
844 r0 = returnFunc(value)
845 } else {
846 r0 = ret.Error(0)
847 }
848 return r0
849 }
850
851 // MockConfig_SetCurrency_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCurrency'
852 type MockConfig_SetCurrency_Call struct {
853 *mock.Call
854 }
855
856 // SetCurrency is a helper method to define mock.On call
857 // - value string
858 func (_e *MockConfig_Expecter) SetCurrency(value interface{}) *MockConfig_SetCurrency_Call {
859 return &MockConfig_SetCurrency_Call{Call: _e.mock.On("SetCurrency", value)}
860 }
861
862 func (_c *MockConfig_SetCurrency_Call) Run(run func(value string)) *MockConfig_SetCurrency_Call {
863 _c.Call.Run(func(args mock.Arguments) {
864 var arg0 string
865 if args[0] != nil {
866 arg0 = args[0].(string)
867 }
868 run(
869 arg0,
870 )
871 })
872 return _c
873 }
874
875 func (_c *MockConfig_SetCurrency_Call) Return(err error) *MockConfig_SetCurrency_Call {
876 _c.Call.Return(err)
877 return _c
878 }
879
880 func (_c *MockConfig_SetCurrency_Call) RunAndReturn(run func(value string) error) *MockConfig_SetCurrency_Call {
881 _c.Call.Return(run)
882 return _c
883 }
884
885 // SetIgnore provides a mock function for the type MockConfig
886 func (_mock *MockConfig) SetIgnore(key string, value string, encryptionKey string) error {
887 ret := _mock.Called(key, value, encryptionKey)
888
889 if len(ret) == 0 {
890 panic("no return value specified for SetIgnore")
891 }
892
893 var r0 error
894 if returnFunc, ok := ret.Get(0).(func(string, string, string) error); ok {
895 r0 = returnFunc(key, value, encryptionKey)
896 } else {
897 r0 = ret.Error(0)
898 }
899 return r0
900 }
901
902 // MockConfig_SetIgnore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetIgnore'
903 type MockConfig_SetIgnore_Call struct {
904 *mock.Call
905 }
906
907 // SetIgnore is a helper method to define mock.On call
908 // - key string
909 // - value string
910 // - encryptionKey string
911 func (_e *MockConfig_Expecter) SetIgnore(key interface{}, value interface{}, encryptionKey interface{}) *MockConfig_SetIgnore_Call {
912 return &MockConfig_SetIgnore_Call{Call: _e.mock.On("SetIgnore", key, value, encryptionKey)}
913 }
914
915 func (_c *MockConfig_SetIgnore_Call) Run(run func(key string, value string, encryptionKey string)) *MockConfig_SetIgnore_Call {
916 _c.Call.Run(func(args mock.Arguments) {
917 var arg0 string
918 if args[0] != nil {
919 arg0 = args[0].(string)
920 }
921 var arg1 string
922 if args[1] != nil {
923 arg1 = args[1].(string)
924 }
925 var arg2 string
926 if args[2] != nil {
927 arg2 = args[2].(string)
928 }
929 run(
930 arg0,
931 arg1,
932 arg2,
933 )
934 })
935 return _c
936 }
937
938 func (_c *MockConfig_SetIgnore_Call) Return(err error) *MockConfig_SetIgnore_Call {
939 _c.Call.Return(err)
940 return _c
941 }
942
943 func (_c *MockConfig_SetIgnore_Call) RunAndReturn(run func(key string, value string, encryptionKey string) error) *MockConfig_SetIgnore_Call {
944 _c.Call.Return(run)
945 return _c
946 }
947
948 // SetUpdate provides a mock function for the type MockConfig
949 func (_mock *MockConfig) SetUpdate(key string, value string, encryptionKey string) error {
950 ret := _mock.Called(key, value, encryptionKey)
951
952 if len(ret) == 0 {
953 panic("no return value specified for SetUpdate")
954 }
955
956 var r0 error
957 if returnFunc, ok := ret.Get(0).(func(string, string, string) error); ok {
958 r0 = returnFunc(key, value, encryptionKey)
959 } else {
960 r0 = ret.Error(0)
961 }
962 return r0
963 }
964
965 // MockConfig_SetUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetUpdate'
966 type MockConfig_SetUpdate_Call struct {
967 *mock.Call
968 }
969
970 // SetUpdate is a helper method to define mock.On call
971 // - key string
972 // - value string
973 // - encryptionKey string
974 func (_e *MockConfig_Expecter) SetUpdate(key interface{}, value interface{}, encryptionKey interface{}) *MockConfig_SetUpdate_Call {
975 return &MockConfig_SetUpdate_Call{Call: _e.mock.On("SetUpdate", key, value, encryptionKey)}
976 }
977
978 func (_c *MockConfig_SetUpdate_Call) Run(run func(key string, value string, encryptionKey string)) *MockConfig_SetUpdate_Call {
979 _c.Call.Run(func(args mock.Arguments) {
980 var arg0 string
981 if args[0] != nil {
982 arg0 = args[0].(string)
983 }
984 var arg1 string
985 if args[1] != nil {
986 arg1 = args[1].(string)
987 }
988 var arg2 string
989 if args[2] != nil {
990 arg2 = args[2].(string)
991 }
992 run(
993 arg0,
994 arg1,
995 arg2,
996 )
997 })
998 return _c
999 }
1000
1001 func (_c *MockConfig_SetUpdate_Call) Return(err error) *MockConfig_SetUpdate_Call {
1002 _c.Call.Return(err)
1003 return _c
1004 }
1005
1006 func (_c *MockConfig_SetUpdate_Call) RunAndReturn(run func(key string, value string, encryptionKey string) error) *MockConfig_SetUpdate_Call {
1007 _c.Call.Return(run)
1008 return _c
1009 }
1010
1011 // SetupCompleted provides a mock function for the type MockConfig
1012 func (_mock *MockConfig) SetupCompleted() (bool, error) {
1013 ret := _mock.Called()
1014
1015 if len(ret) == 0 {
1016 panic("no return value specified for SetupCompleted")
1017 }
1018
1019 var r0 bool
1020 var r1 error
1021 if returnFunc, ok := ret.Get(0).(func() (bool, error)); ok {
1022 return returnFunc()
1023 }
1024 if returnFunc, ok := ret.Get(0).(func() bool); ok {
1025 r0 = returnFunc()
1026 } else {
1027 r0 = ret.Get(0).(bool)
1028 }
1029 if returnFunc, ok := ret.Get(1).(func() error); ok {
1030 r1 = returnFunc()
1031 } else {
1032 r1 = ret.Error(1)
1033 }
1034 return r0, r1
1035 }
1036
1037 // MockConfig_SetupCompleted_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetupCompleted'
1038 type MockConfig_SetupCompleted_Call struct {
1039 *mock.Call
1040 }
1041
1042 // SetupCompleted is a helper method to define mock.On call
1043 func (_e *MockConfig_Expecter) SetupCompleted() *MockConfig_SetupCompleted_Call {
1044 return &MockConfig_SetupCompleted_Call{Call: _e.mock.On("SetupCompleted")}
1045 }
1046
1047 func (_c *MockConfig_SetupCompleted_Call) Run(run func()) *MockConfig_SetupCompleted_Call {
1048 _c.Call.Run(func(args mock.Arguments) {
1049 run()
1050 })
1051 return _c
1052 }
1053
1054 func (_c *MockConfig_SetupCompleted_Call) Return(b bool, err error) *MockConfig_SetupCompleted_Call {
1055 _c.Call.Return(b, err)
1056 return _c
1057 }
1058
1059 func (_c *MockConfig_SetupCompleted_Call) RunAndReturn(run func() (bool, error)) *MockConfig_SetupCompleted_Call {
1060 _c.Call.Return(run)
1061 return _c
1062 }
1063