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