list_transactions_test.go raw
1 package transactions
2
3 import (
4 "context"
5 "testing"
6 "time"
7
8 "github.com/stretchr/testify/assert"
9 "github.com/stretchr/testify/require"
10
11 "github.com/getAlby/hub/constants"
12 "github.com/getAlby/hub/db"
13 "github.com/getAlby/hub/tests"
14 "gorm.io/datatypes"
15 )
16
17 func TestListTransactions_Paid(t *testing.T) {
18 ctx := context.TODO()
19
20 svc, err := tests.CreateTestService(t)
21 require.NoError(t, err)
22 defer svc.Remove()
23
24 mockPreimage := tests.MockLNClientTransaction.Preimage
25 svc.DB.Create(&db.Transaction{
26 State: constants.TRANSACTION_STATE_SETTLED,
27 Type: constants.TRANSACTION_TYPE_INCOMING,
28 PaymentRequest: tests.MockLNClientTransaction.Invoice,
29 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
30 Preimage: &mockPreimage,
31 AmountMsat: 123000,
32 })
33 svc.DB.Create(&db.Transaction{
34 State: constants.TRANSACTION_STATE_PENDING,
35 Type: constants.TRANSACTION_TYPE_INCOMING,
36 PaymentRequest: tests.MockLNClientTransaction.Invoice,
37 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
38 Preimage: &mockPreimage,
39 AmountMsat: 123000,
40 })
41 svc.DB.Create(&db.Transaction{
42 State: constants.TRANSACTION_STATE_PENDING,
43 Type: constants.TRANSACTION_TYPE_OUTGOING,
44 PaymentRequest: tests.MockLNClientTransaction.Invoice,
45 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
46 Preimage: &mockPreimage,
47 AmountMsat: 123000,
48 })
49
50 transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
51
52 incomingTransactions, totalCount, err := transactionsService.ListTransactions(ctx, 0, 0, 0, 0, false, false, svc.LNClient, nil, false, nil)
53 assert.NoError(t, err)
54 assert.Equal(t, uint64(1), totalCount)
55 assert.Equal(t, 1, len(incomingTransactions))
56 assert.Equal(t, uint64(123000), incomingTransactions[0].AmountMsat)
57 assert.Equal(t, constants.TRANSACTION_STATE_SETTLED, incomingTransactions[0].State)
58 assert.Equal(t, tests.MockLNClientTransaction.Preimage, *incomingTransactions[0].Preimage)
59 assert.Zero(t, incomingTransactions[0].FeeReserveMsat)
60 }
61
62 func TestListTransactions_UnpaidIncoming(t *testing.T) {
63 ctx := context.TODO()
64
65 svc, err := tests.CreateTestService(t)
66 require.NoError(t, err)
67 defer svc.Remove()
68
69 mockPreimage := tests.MockLNClientTransaction.Preimage
70 svc.DB.Create(&db.Transaction{
71 State: constants.TRANSACTION_STATE_SETTLED,
72 Type: constants.TRANSACTION_TYPE_INCOMING,
73 PaymentRequest: tests.MockLNClientTransaction.Invoice,
74 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
75 Preimage: &mockPreimage,
76 AmountMsat: 123000,
77 UpdatedAt: time.Now(),
78 })
79 svc.DB.Create(&db.Transaction{
80 State: constants.TRANSACTION_STATE_FAILED,
81 Type: constants.TRANSACTION_TYPE_INCOMING,
82 PaymentRequest: tests.MockLNClientTransaction.Invoice,
83 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
84 Preimage: &mockPreimage,
85 AmountMsat: 123000,
86 UpdatedAt: time.Now().Add(-1 * time.Second),
87 })
88 svc.DB.Create(&db.Transaction{
89 State: constants.TRANSACTION_STATE_PENDING,
90 Type: constants.TRANSACTION_TYPE_INCOMING,
91 PaymentRequest: tests.MockLNClientTransaction.Invoice,
92 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
93 Preimage: &mockPreimage,
94 AmountMsat: 123000,
95 UpdatedAt: time.Now().Add(-2 * time.Second),
96 })
97 svc.DB.Create(&db.Transaction{
98 State: constants.TRANSACTION_STATE_FAILED,
99 Type: constants.TRANSACTION_TYPE_OUTGOING,
100 PaymentRequest: tests.MockLNClientTransaction.Invoice,
101 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
102 Preimage: &mockPreimage,
103 AmountMsat: 123000,
104 UpdatedAt: time.Now().Add(-2 * time.Second),
105 })
106 svc.DB.Create(&db.Transaction{
107 State: constants.TRANSACTION_STATE_PENDING,
108 Type: constants.TRANSACTION_TYPE_OUTGOING,
109 PaymentRequest: tests.MockLNClientTransaction.Invoice,
110 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
111 Preimage: &mockPreimage,
112 AmountMsat: 123000,
113 UpdatedAt: time.Now().Add(-2 * time.Second),
114 })
115
116 transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
117
118 incomingTransactions, totalCount, err := transactionsService.ListTransactions(ctx, 0, 0, 0, 0, false, true, svc.LNClient, nil, false, nil)
119 assert.NoError(t, err)
120 assert.Equal(t, uint64(3), totalCount)
121 assert.Equal(t, 3, len(incomingTransactions))
122 assert.Equal(t, constants.TRANSACTION_STATE_SETTLED, incomingTransactions[0].State)
123 assert.Equal(t, constants.TRANSACTION_STATE_FAILED, incomingTransactions[1].State)
124 assert.Equal(t, constants.TRANSACTION_STATE_PENDING, incomingTransactions[2].State)
125 for _, transaction := range incomingTransactions {
126 assert.Equal(t, constants.TRANSACTION_TYPE_INCOMING, transaction.Type)
127 }
128 }
129
130 func TestListTransactions_UnpaidOutgoing(t *testing.T) {
131 ctx := context.TODO()
132
133 svc, err := tests.CreateTestService(t)
134 require.NoError(t, err)
135 defer svc.Remove()
136
137 mockPreimage := tests.MockLNClientTransaction.Preimage
138 svc.DB.Create(&db.Transaction{
139 State: constants.TRANSACTION_STATE_SETTLED,
140 Type: constants.TRANSACTION_TYPE_OUTGOING,
141 PaymentRequest: tests.MockLNClientTransaction.Invoice,
142 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
143 Preimage: &mockPreimage,
144 AmountMsat: 123000,
145 UpdatedAt: time.Now(),
146 })
147 svc.DB.Create(&db.Transaction{
148 State: constants.TRANSACTION_STATE_FAILED,
149 Type: constants.TRANSACTION_TYPE_OUTGOING,
150 PaymentRequest: tests.MockLNClientTransaction.Invoice,
151 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
152 Preimage: &mockPreimage,
153 AmountMsat: 123000,
154 UpdatedAt: time.Now().Add(-1 * time.Second),
155 })
156 svc.DB.Create(&db.Transaction{
157 State: constants.TRANSACTION_STATE_PENDING,
158 Type: constants.TRANSACTION_TYPE_OUTGOING,
159 PaymentRequest: tests.MockLNClientTransaction.Invoice,
160 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
161 Preimage: &mockPreimage,
162 AmountMsat: 123000,
163 UpdatedAt: time.Now().Add(-2 * time.Second),
164 })
165 svc.DB.Create(&db.Transaction{
166 State: constants.TRANSACTION_STATE_FAILED,
167 Type: constants.TRANSACTION_TYPE_INCOMING,
168 PaymentRequest: tests.MockLNClientTransaction.Invoice,
169 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
170 Preimage: &mockPreimage,
171 AmountMsat: 123000,
172 UpdatedAt: time.Now().Add(-2 * time.Second),
173 })
174 svc.DB.Create(&db.Transaction{
175 State: constants.TRANSACTION_STATE_PENDING,
176 Type: constants.TRANSACTION_TYPE_INCOMING,
177 PaymentRequest: tests.MockLNClientTransaction.Invoice,
178 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
179 Preimage: &mockPreimage,
180 AmountMsat: 123000,
181 UpdatedAt: time.Now().Add(-2 * time.Second),
182 })
183
184 transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
185
186 outgoingTransactions, totalCount, err := transactionsService.ListTransactions(ctx, 0, 0, 0, 0, true, false, svc.LNClient, nil, false, nil)
187 assert.NoError(t, err)
188 assert.Equal(t, uint64(3), totalCount)
189 assert.Equal(t, 3, len(outgoingTransactions))
190 assert.Equal(t, constants.TRANSACTION_STATE_SETTLED, outgoingTransactions[0].State)
191 assert.Equal(t, constants.TRANSACTION_STATE_FAILED, outgoingTransactions[1].State)
192 assert.Equal(t, constants.TRANSACTION_STATE_PENDING, outgoingTransactions[2].State)
193 for _, transaction := range outgoingTransactions {
194 assert.Equal(t, constants.TRANSACTION_TYPE_OUTGOING, transaction.Type)
195 }
196 }
197
198 func TestListTransactions_Unpaid(t *testing.T) {
199 ctx := context.TODO()
200
201 svc, err := tests.CreateTestService(t)
202 require.NoError(t, err)
203 defer svc.Remove()
204
205 mockPreimage := tests.MockLNClientTransaction.Preimage
206 svc.DB.Create(&db.Transaction{
207 State: constants.TRANSACTION_STATE_SETTLED,
208 Type: constants.TRANSACTION_TYPE_OUTGOING,
209 PaymentRequest: tests.MockLNClientTransaction.Invoice,
210 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
211 Preimage: &mockPreimage,
212 AmountMsat: 123000,
213 UpdatedAt: time.Now(),
214 })
215 svc.DB.Create(&db.Transaction{
216 State: constants.TRANSACTION_STATE_FAILED,
217 Type: constants.TRANSACTION_TYPE_OUTGOING,
218 PaymentRequest: tests.MockLNClientTransaction.Invoice,
219 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
220 Preimage: &mockPreimage,
221 AmountMsat: 123000,
222 UpdatedAt: time.Now().Add(-1 * time.Second),
223 })
224 svc.DB.Create(&db.Transaction{
225 State: constants.TRANSACTION_STATE_PENDING,
226 Type: constants.TRANSACTION_TYPE_OUTGOING,
227 PaymentRequest: tests.MockLNClientTransaction.Invoice,
228 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
229 Preimage: &mockPreimage,
230 AmountMsat: 123000,
231 UpdatedAt: time.Now().Add(-2 * time.Second),
232 })
233 svc.DB.Create(&db.Transaction{
234 State: constants.TRANSACTION_STATE_FAILED,
235 Type: constants.TRANSACTION_TYPE_INCOMING,
236 PaymentRequest: tests.MockLNClientTransaction.Invoice,
237 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
238 Preimage: &mockPreimage,
239 AmountMsat: 123000,
240 UpdatedAt: time.Now().Add(-2 * time.Second),
241 })
242 svc.DB.Create(&db.Transaction{
243 State: constants.TRANSACTION_STATE_PENDING,
244 Type: constants.TRANSACTION_TYPE_INCOMING,
245 PaymentRequest: tests.MockLNClientTransaction.Invoice,
246 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
247 Preimage: &mockPreimage,
248 AmountMsat: 123000,
249 UpdatedAt: time.Now().Add(-2 * time.Second),
250 })
251
252 transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
253
254 outgoingTransactions, totalCount, err := transactionsService.ListTransactions(ctx, 0, 0, 0, 0, true, true, svc.LNClient, nil, false, nil)
255 assert.NoError(t, err)
256 assert.Equal(t, uint64(5), totalCount)
257 assert.Equal(t, 5, len(outgoingTransactions))
258 }
259
260 func TestListTransactions_Limit(t *testing.T) {
261 ctx := context.TODO()
262
263 svc, err := tests.CreateTestService(t)
264 require.NoError(t, err)
265 defer svc.Remove()
266
267 mockPreimage := tests.MockLNClientTransaction.Preimage
268 svc.DB.Create(&db.Transaction{
269 State: constants.TRANSACTION_STATE_SETTLED,
270 Type: constants.TRANSACTION_TYPE_INCOMING,
271 PaymentRequest: tests.MockLNClientTransaction.Invoice,
272 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
273 Preimage: &mockPreimage,
274 AmountMsat: 123000,
275 Description: "first",
276 UpdatedAt: time.Now().Add(1 * time.Minute),
277 })
278 svc.DB.Create(&db.Transaction{
279 State: constants.TRANSACTION_STATE_SETTLED,
280 Type: constants.TRANSACTION_TYPE_INCOMING,
281 PaymentRequest: tests.MockLNClientTransaction.Invoice,
282 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
283 Preimage: &mockPreimage,
284 AmountMsat: 123000,
285 Description: "second",
286 })
287
288 transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
289
290 incomingTransactions, totalCount, err := transactionsService.ListTransactions(ctx, 0, 0, 1, 0, false, false, svc.LNClient, nil, false, nil)
291 assert.NoError(t, err)
292 assert.Equal(t, uint64(2), totalCount)
293 assert.Equal(t, 1, len(incomingTransactions))
294 assert.Equal(t, "first", incomingTransactions[0].Description)
295 }
296
297 func TestListTransactions_Offset(t *testing.T) {
298 ctx := context.TODO()
299
300 svc, err := tests.CreateTestService(t)
301 require.NoError(t, err)
302 defer svc.Remove()
303
304 mockPreimage := tests.MockLNClientTransaction.Preimage
305 svc.DB.Create(&db.Transaction{
306 State: constants.TRANSACTION_STATE_SETTLED,
307 Type: constants.TRANSACTION_TYPE_INCOMING,
308 PaymentRequest: tests.MockLNClientTransaction.Invoice,
309 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
310 Preimage: &mockPreimage,
311 AmountMsat: 123000,
312 Description: "first",
313 UpdatedAt: time.Now().Add(3 * time.Minute),
314 })
315 svc.DB.Create(&db.Transaction{
316 State: constants.TRANSACTION_STATE_SETTLED,
317 Type: constants.TRANSACTION_TYPE_INCOMING,
318 PaymentRequest: tests.MockLNClientTransaction.Invoice,
319 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
320 Preimage: &mockPreimage,
321 AmountMsat: 123000,
322 Description: "second",
323 UpdatedAt: time.Now().Add(2 * time.Minute),
324 })
325 svc.DB.Create(&db.Transaction{
326 State: constants.TRANSACTION_STATE_SETTLED,
327 Type: constants.TRANSACTION_TYPE_INCOMING,
328 PaymentRequest: tests.MockLNClientTransaction.Invoice,
329 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
330 Preimage: &mockPreimage,
331 AmountMsat: 123000,
332 Description: "third",
333 UpdatedAt: time.Now().Add(1 * time.Minute),
334 })
335 svc.DB.Create(&db.Transaction{
336 State: constants.TRANSACTION_STATE_SETTLED,
337 Type: constants.TRANSACTION_TYPE_INCOMING,
338 PaymentRequest: tests.MockLNClientTransaction.Invoice,
339 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
340 Preimage: &mockPreimage,
341 AmountMsat: 123000,
342 Description: "fourth",
343 })
344
345 transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
346
347 incomingTransactions, totalCount, err := transactionsService.ListTransactions(ctx, 0, 0, 1, 2, false, false, svc.LNClient, nil, false, nil)
348 assert.NoError(t, err)
349 assert.Equal(t, uint64(4), totalCount)
350 assert.Equal(t, 1, len(incomingTransactions))
351 assert.Equal(t, "third", incomingTransactions[0].Description)
352 }
353
354 func TestListTransactions_MinAmount(t *testing.T) {
355 ctx := context.TODO()
356
357 svc, err := tests.CreateTestService(t)
358 require.NoError(t, err)
359 defer svc.Remove()
360
361 mockPreimage := tests.MockLNClientTransaction.Preimage
362 svc.DB.Create(&db.Transaction{
363 State: constants.TRANSACTION_STATE_SETTLED,
364 Type: constants.TRANSACTION_TYPE_INCOMING,
365 PaymentRequest: tests.MockLNClientTransaction.Invoice,
366 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
367 Preimage: &mockPreimage,
368 AmountMsat: 1000,
369 Description: "small",
370 })
371 svc.DB.Create(&db.Transaction{
372 State: constants.TRANSACTION_STATE_SETTLED,
373 Type: constants.TRANSACTION_TYPE_INCOMING,
374 PaymentRequest: tests.MockLNClientTransaction.Invoice,
375 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
376 Preimage: &mockPreimage,
377 AmountMsat: 10000,
378 Description: "large",
379 })
380
381 transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
382 minAmountMsat := uint64(5000)
383
384 filteredTransactions, totalCount, err := transactionsService.ListTransactions(ctx, 0, 0, 0, 0, false, false, svc.LNClient, nil, false, &ListTransactionsFilters{
385 MinAmountMsat: &minAmountMsat,
386 })
387 assert.NoError(t, err)
388 assert.Equal(t, uint64(1), totalCount)
389 require.Len(t, filteredTransactions, 1)
390 assert.Equal(t, "large", filteredTransactions[0].Description)
391 }
392
393 func TestListTransactions_HideFailed(t *testing.T) {
394 ctx := context.TODO()
395
396 svc, err := tests.CreateTestService(t)
397 require.NoError(t, err)
398 defer svc.Remove()
399
400 mockPreimage := tests.MockLNClientTransaction.Preimage
401 svc.DB.Create(&db.Transaction{
402 State: constants.TRANSACTION_STATE_SETTLED,
403 Type: constants.TRANSACTION_TYPE_OUTGOING,
404 PaymentRequest: tests.MockLNClientTransaction.Invoice,
405 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
406 Preimage: &mockPreimage,
407 AmountMsat: 123000,
408 Description: "settled",
409 UpdatedAt: time.Now().Add(2 * time.Minute),
410 })
411 svc.DB.Create(&db.Transaction{
412 State: constants.TRANSACTION_STATE_FAILED,
413 Type: constants.TRANSACTION_TYPE_OUTGOING,
414 PaymentRequest: tests.MockLNClientTransaction.Invoice,
415 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
416 Preimage: &mockPreimage,
417 AmountMsat: 123000,
418 Description: "failed",
419 UpdatedAt: time.Now().Add(1 * time.Minute),
420 })
421 svc.DB.Create(&db.Transaction{
422 State: constants.TRANSACTION_STATE_PENDING,
423 Type: constants.TRANSACTION_TYPE_OUTGOING,
424 PaymentRequest: tests.MockLNClientTransaction.Invoice,
425 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
426 Preimage: &mockPreimage,
427 AmountMsat: 123000,
428 Description: "pending",
429 })
430
431 transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
432
433 filteredTransactions, totalCount, err := transactionsService.ListTransactions(ctx, 0, 0, 0, 0, true, false, svc.LNClient, nil, false, &ListTransactionsFilters{
434 HideFailed: true,
435 })
436 assert.NoError(t, err)
437 assert.Equal(t, uint64(2), totalCount)
438 require.Len(t, filteredTransactions, 2)
439 assert.Equal(t, "settled", filteredTransactions[0].Description)
440 assert.Equal(t, "pending", filteredTransactions[1].Description)
441 }
442
443 func TestListTransactions_Type(t *testing.T) {
444 ctx := context.TODO()
445
446 svc, err := tests.CreateTestService(t)
447 require.NoError(t, err)
448 defer svc.Remove()
449
450 mockPreimage := tests.MockLNClientTransaction.Preimage
451 svc.DB.Create(&db.Transaction{
452 State: constants.TRANSACTION_STATE_SETTLED,
453 Type: constants.TRANSACTION_TYPE_INCOMING,
454 PaymentRequest: tests.MockLNClientTransaction.Invoice,
455 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
456 Preimage: &mockPreimage,
457 AmountMsat: 123000,
458 Description: "received",
459 })
460 svc.DB.Create(&db.Transaction{
461 State: constants.TRANSACTION_STATE_SETTLED,
462 Type: constants.TRANSACTION_TYPE_OUTGOING,
463 PaymentRequest: tests.MockLNClientTransaction.Invoice,
464 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
465 Preimage: &mockPreimage,
466 AmountMsat: 123000,
467 Description: "sent",
468 })
469
470 transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
471 transactionType := constants.TRANSACTION_TYPE_OUTGOING
472
473 filteredTransactions, totalCount, err := transactionsService.ListTransactions(ctx, 0, 0, 0, 0, false, false, svc.LNClient, nil, false, &ListTransactionsFilters{
474 Type: &transactionType,
475 })
476 assert.NoError(t, err)
477 assert.Equal(t, uint64(1), totalCount)
478 require.Len(t, filteredTransactions, 1)
479 assert.Equal(t, "sent", filteredTransactions[0].Description)
480 }
481
482 func TestListTransactions_Search(t *testing.T) {
483 ctx := context.TODO()
484
485 svc, err := tests.CreateTestService(t)
486 require.NoError(t, err)
487 defer svc.Remove()
488
489 mockPreimage := tests.MockLNClientTransaction.Preimage
490 svc.DB.Create(&db.Transaction{
491 State: constants.TRANSACTION_STATE_SETTLED,
492 Type: constants.TRANSACTION_TYPE_OUTGOING,
493 PaymentRequest: "lnbc1coffee",
494 PaymentHash: "3086c621ecbef1ba99446fca8f484e2dbef77b28ee76a94ab8bb8b0e7f60a0f1",
495 Preimage: &mockPreimage,
496 AmountMsat: 123000,
497 Description: "Coffee shop",
498 })
499 svc.DB.Create(&db.Transaction{
500 State: constants.TRANSACTION_STATE_SETTLED,
501 Type: constants.TRANSACTION_TYPE_INCOMING,
502 PaymentRequest: tests.MockLNClientTransaction.Invoice,
503 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
504 Preimage: &mockPreimage,
505 AmountMsat: 123000,
506 Description: "Zap",
507 Metadata: datatypes.JSON(`{"user_labels":{"category":"Drinks"}}`),
508 })
509 svc.DB.Create(&db.Transaction{
510 State: constants.TRANSACTION_STATE_SETTLED,
511 Type: constants.TRANSACTION_TYPE_OUTGOING,
512 PaymentRequest: "lnbc1discount",
513 PaymentHash: "af88b1571c1a0b2b1e8c05bf74e6a2f6b3a4f4a2be27077b1c5f5e2e4f6a8b9c",
514 Preimage: &mockPreimage,
515 AmountMsat: 123000,
516 Description: "50% discount",
517 })
518
519 transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
520
521 for _, testCase := range []struct {
522 searchTerm string
523 expectedDescriptions []string
524 }{
525 {"COFFEE", []string{"Coffee shop"}},
526 // exact payment hash
527 {tests.MockLNClientTransaction.PaymentHash, []string{"Zap"}},
528 // full invoice is decoded and matched by its payment hash
529 {tests.MockLNClientTransaction.Invoice, []string{"Zap"}},
530 // invoices are not matched by substring
531 {"lnbc1disc", []string{}},
532 // partial payment hashes are not matched
533 {tests.MockLNClientTransaction.PaymentHash[:32], []string{}},
534 {"drinks", []string{"Zap"}},
535 {"category", []string{"Zap"}},
536 {"50%", []string{"50% discount"}},
537 {"nonexistent", []string{}},
538 } {
539 filteredTransactions, totalCount, err := transactionsService.ListTransactions(ctx, 0, 0, 0, 0, false, false, svc.LNClient, nil, false, &ListTransactionsFilters{
540 SearchTerm: testCase.searchTerm,
541 })
542 assert.NoError(t, err, "search: %s", testCase.searchTerm)
543 assert.Equal(t, uint64(len(testCase.expectedDescriptions)), totalCount, "search: %s", testCase.searchTerm)
544 require.Len(t, filteredTransactions, len(testCase.expectedDescriptions), "search: %s", testCase.searchTerm)
545 for i, description := range testCase.expectedDescriptions {
546 assert.Equal(t, description, filteredTransactions[i].Description, "search: %s", testCase.searchTerm)
547 }
548 }
549 }
550
551 func TestListTransactions_FromUntil(t *testing.T) {
552 ctx := context.TODO()
553
554 svc, err := tests.CreateTestService(t)
555 require.NoError(t, err)
556 defer svc.Remove()
557
558 mockPreimage := tests.MockLNClientTransaction.Preimage
559 svc.DB.Create(&db.Transaction{
560 State: constants.TRANSACTION_STATE_SETTLED,
561 Type: constants.TRANSACTION_TYPE_INCOMING,
562 PaymentRequest: tests.MockLNClientTransaction.Invoice,
563 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
564 Preimage: &mockPreimage,
565 AmountMsat: 123000,
566 Description: "first",
567 UpdatedAt: time.Now().Add(10 * time.Minute),
568 CreatedAt: time.Now().Add(10 * time.Minute),
569 })
570 svc.DB.Create(&db.Transaction{
571 State: constants.TRANSACTION_STATE_SETTLED,
572 Type: constants.TRANSACTION_TYPE_INCOMING,
573 PaymentRequest: tests.MockLNClientTransaction.Invoice,
574 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
575 Preimage: &mockPreimage,
576 AmountMsat: 123000,
577 Description: "second",
578 UpdatedAt: time.Now().Add(5 * time.Minute),
579 CreatedAt: time.Now().Add(5 * time.Minute),
580 })
581 svc.DB.Create(&db.Transaction{
582 State: constants.TRANSACTION_STATE_SETTLED,
583 Type: constants.TRANSACTION_TYPE_INCOMING,
584 PaymentRequest: tests.MockLNClientTransaction.Invoice,
585 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
586 Preimage: &mockPreimage,
587 AmountMsat: 123000,
588 Description: "third",
589 CreatedAt: time.Now(),
590 UpdatedAt: time.Now(),
591 })
592
593 transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
594
595 incomingTransactions, totalCount, err := transactionsService.ListTransactions(ctx, uint64(time.Now().Add(4*time.Minute).Unix()), uint64(time.Now().Add(6*time.Minute).Unix()), 0, 0, false, false, svc.LNClient, nil, false, nil)
596 assert.NoError(t, err)
597 assert.Equal(t, uint64(1), totalCount)
598 assert.Equal(t, 1, len(incomingTransactions))
599 assert.Equal(t, "second", incomingTransactions[0].Description)
600 }
601
602 func TestListTransactions_FromUntilUnpaidOutgoing(t *testing.T) {
603 ctx := context.TODO()
604
605 svc, err := tests.CreateTestService(t)
606 require.NoError(t, err)
607 defer svc.Remove()
608
609 mockPreimage := tests.MockLNClientTransaction.Preimage
610 svc.DB.Create(&db.Transaction{
611 State: constants.TRANSACTION_STATE_PENDING,
612 Type: constants.TRANSACTION_TYPE_OUTGOING,
613 PaymentRequest: tests.MockLNClientTransaction.Invoice,
614 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
615 Preimage: &mockPreimage,
616 AmountMsat: 123000,
617 Description: "first",
618 UpdatedAt: time.Now().Add(10 * time.Minute),
619 CreatedAt: time.Now().Add(10 * time.Minute),
620 })
621 svc.DB.Create(&db.Transaction{
622 State: constants.TRANSACTION_STATE_PENDING,
623 Type: constants.TRANSACTION_TYPE_OUTGOING,
624 PaymentRequest: tests.MockLNClientTransaction.Invoice,
625 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
626 Preimage: &mockPreimage,
627 AmountMsat: 123000,
628 Description: "second",
629 UpdatedAt: time.Now().Add(5 * time.Minute),
630 CreatedAt: time.Now().Add(5 * time.Minute),
631 })
632 svc.DB.Create(&db.Transaction{
633 State: constants.TRANSACTION_STATE_PENDING,
634 Type: constants.TRANSACTION_TYPE_INCOMING,
635 PaymentRequest: tests.MockLNClientTransaction.Invoice,
636 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
637 Preimage: &mockPreimage,
638 AmountMsat: 123000,
639 Description: "second",
640 UpdatedAt: time.Now().Add(5 * time.Minute),
641 CreatedAt: time.Now().Add(5 * time.Minute),
642 })
643 svc.DB.Create(&db.Transaction{
644 State: constants.TRANSACTION_STATE_PENDING,
645 Type: constants.TRANSACTION_TYPE_OUTGOING,
646 PaymentRequest: tests.MockLNClientTransaction.Invoice,
647 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
648 Preimage: &mockPreimage,
649 AmountMsat: 123000,
650 Description: "third",
651 CreatedAt: time.Now(),
652 UpdatedAt: time.Now(),
653 })
654
655 transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
656
657 incomingTransactions, totalCount, err := transactionsService.ListTransactions(ctx, uint64(time.Now().Add(4*time.Minute).Unix()), uint64(time.Now().Add(6*time.Minute).Unix()), 0, 0, true, false, svc.LNClient, nil, false, nil)
658 assert.NoError(t, err)
659 assert.Equal(t, uint64(1), totalCount)
660 assert.Equal(t, "second", incomingTransactions[0].Description)
661 assert.Equal(t, constants.TRANSACTION_TYPE_OUTGOING, incomingTransactions[0].Type)
662 }
663
664 func TestListTransactions_FromUntilUnpaidIncoming(t *testing.T) {
665 ctx := context.TODO()
666
667 svc, err := tests.CreateTestService(t)
668 require.NoError(t, err)
669 defer svc.Remove()
670
671 mockPreimage := tests.MockLNClientTransaction.Preimage
672 svc.DB.Create(&db.Transaction{
673 State: constants.TRANSACTION_STATE_PENDING,
674 Type: constants.TRANSACTION_TYPE_INCOMING,
675 PaymentRequest: tests.MockLNClientTransaction.Invoice,
676 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
677 Preimage: &mockPreimage,
678 AmountMsat: 123000,
679 Description: "first",
680 UpdatedAt: time.Now().Add(10 * time.Minute),
681 CreatedAt: time.Now().Add(10 * time.Minute),
682 })
683 svc.DB.Create(&db.Transaction{
684 State: constants.TRANSACTION_STATE_PENDING,
685 Type: constants.TRANSACTION_TYPE_INCOMING,
686 PaymentRequest: tests.MockLNClientTransaction.Invoice,
687 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
688 Preimage: &mockPreimage,
689 AmountMsat: 123000,
690 Description: "second",
691 UpdatedAt: time.Now().Add(5 * time.Minute),
692 CreatedAt: time.Now().Add(5 * time.Minute),
693 })
694 svc.DB.Create(&db.Transaction{
695 State: constants.TRANSACTION_STATE_PENDING,
696 Type: constants.TRANSACTION_TYPE_OUTGOING,
697 PaymentRequest: tests.MockLNClientTransaction.Invoice,
698 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
699 Preimage: &mockPreimage,
700 AmountMsat: 123000,
701 Description: "second",
702 UpdatedAt: time.Now().Add(5 * time.Minute),
703 CreatedAt: time.Now().Add(5 * time.Minute),
704 })
705 svc.DB.Create(&db.Transaction{
706 State: constants.TRANSACTION_STATE_PENDING,
707 Type: constants.TRANSACTION_TYPE_INCOMING,
708 PaymentRequest: tests.MockLNClientTransaction.Invoice,
709 PaymentHash: tests.MockLNClientTransaction.PaymentHash,
710 Preimage: &mockPreimage,
711 AmountMsat: 123000,
712 Description: "third",
713 CreatedAt: time.Now(),
714 UpdatedAt: time.Now(),
715 })
716
717 transactionsService := NewTransactionsService(svc.DB, svc.EventPublisher)
718
719 incomingTransactions, totalCount, err := transactionsService.ListTransactions(ctx, uint64(time.Now().Add(4*time.Minute).Unix()), uint64(time.Now().Add(6*time.Minute).Unix()), 0, 0, false, true, svc.LNClient, nil, false, nil)
720 assert.NoError(t, err)
721 assert.Equal(t, uint64(1), totalCount)
722 assert.Equal(t, "second", incomingTransactions[0].Description)
723 assert.Equal(t, constants.TRANSACTION_TYPE_INCOMING, incomingTransactions[0].Type)
724 }
725