Archives
/
loop
mirror of https://github.com/lightninglabs/loop
2
0
Fork 0
Code Issues Releases Wiki Activity

Merge pull request #778 from starius/sweepbatcher-sql-test

Browse Source 
sweepbatcher: unit tests with SQL loopdb as well
pull/782/head
Boris Nagaev 1 week ago committed by GitHub
parent a4e01027ea 029d0870b5
commit 0ec63a61d4
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
2 changed files with 457 additions and 91 deletions
Show Stats Download Patch File Download Diff File

10
sweepbatcher/sweep_batcher.go
Unescape Escape View File

@ -701,7 +701,7 @@ func (b *Batcher) convertSweep(ctx context.Context, dbSweep *dbSweep) (
s, err := b.sweepStore.FetchSweep(ctx, dbSweep.SwapHash)
if err != nil {
return nil, fmt.Errorf("failed to fetch sweep data for %x: %v",
return nil, fmt.Errorf("failed to fetch sweep data for %x: %w",
dbSweep.SwapHash[:6], err)
}
@ -748,7 +748,7 @@ func (f *SwapStoreWrapper) FetchSweep(ctx context.Context,
swap, err := f.swapStore.FetchLoopOutSwap(ctx, swapHash)
if err != nil {
return nil, fmt.Errorf("failed to fetch loop out for %x: %v",
return nil, fmt.Errorf("failed to fetch loop out for %x: %w",
swapHash[:6], err)
}
@ -756,14 +756,14 @@ func (f *SwapStoreWrapper) FetchSweep(ctx context.Context,
swapHash, &swap.Contract.SwapContract, f.chainParams,
)
if err != nil {
return nil, fmt.Errorf("failed to get htlc: %v", err)
return nil, fmt.Errorf("failed to get htlc: %w", err)
}
swapPaymentAddr, err := utils.ObtainSwapPaymentAddr(
swap.Contract.SwapInvoice, f.chainParams,
)
if err != nil {
return nil, fmt.Errorf("failed to get payment addr: %v", err)
return nil, fmt.Errorf("failed to get payment addr: %w", err)
}
return &SweepInfo{
@ -798,7 +798,7 @@ func (b *Batcher) fetchSweep(ctx context.Context,
s, err := b.sweepStore.FetchSweep(ctx, sweepReq.SwapHash)
if err != nil {
return nil, fmt.Errorf("failed to fetch sweep data for %x: %v",
return nil, fmt.Errorf("failed to fetch sweep data for %x: %w",
sweepReq.SwapHash[:6], err)
}

538
sweepbatcher/sweep_batcher_test.go
Unescape Escape View File

@ -3,6 +3,7 @@ package sweepbatcher
import (
"context"
"errors"
"fmt"
"sync"
"testing"
"time"
@ -30,6 +31,17 @@ const (
ntfnBufferSize = 1024
)
// destAddr is a dummy p2wkh address to use as the destination address for
// the swaps.
var destAddr = func() btcutil.Address {
p2wkhAddr := "bcrt1qq68r6ff4k4pjx39efs44gcyccf7unqnu5qtjjz"
addr, err := btcutil.DecodeAddress(p2wkhAddr, nil)
if err != nil {
panic(err)
}
return addr
}()
func testMuSig2SignSweep(ctx context.Context,
protocolVersion loopdb.ProtocolVersion, swapHash lntypes.Hash,
paymentAddr [32]byte, nonce []byte, sweepTxPsbt []byte,
@ -54,21 +66,34 @@ func checkBatcherError(t *testing.T, err error) {
}
}
// TestSweepBatcherBatchCreation tests that sweep requests enter the expected
// getOnlyBatch makes sure the batcher has exactly one batch and returns it.
func getOnlyBatch(batcher *Batcher) *batch {
if len(batcher.batches) != 1 {
panic(fmt.Sprintf("getOnlyBatch called on a batcher having "+
"%d batches", len(batcher.batches)))
}
for _, batch := range batcher.batches {
return batch
}
panic("unreachable")
}
// testSweepBatcherBatchCreation tests that sweep requests enter the expected
// batch based on their timeout distance.
func TestSweepBatcherBatchCreation(t *testing.T) {
func testSweepBatcherBatchCreation(t *testing.T, store testStore,
batcherStore testBatcherStore) {
defer test.Guard(t)()
lnd := test.NewMockLnd()
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
store := loopdb.NewStoreMock(t)
sweepStore, err := NewSweepFetcherFromSwapStore(store, lnd.ChainParams)
require.NoError(t, err)
batcherStore := NewStoreMock()
batcher := NewBatcher(lnd.WalletKit, lnd.ChainNotifier, lnd.Signer,
testMuSig2SignSweep, nil, lnd.ChainParams, batcherStore,
sweepStore)
@ -94,6 +119,7 @@ func TestSweepBatcherBatchCreation(t *testing.T) {
AmountRequested: 111,
},
DestAddr: destAddr,
SwapInvoice: swapInvoice,
}
@ -133,7 +159,11 @@ func TestSweepBatcherBatchCreation(t *testing.T) {
SwapContract: loopdb.SwapContract{
CltvExpiry: 111 + defaultMaxTimeoutDistance - 1,
AmountRequested: 222,
// Make preimage unique to pass SQL constraints.
Preimage: lntypes.Preimage{2},
},
DestAddr: destAddr,
SwapInvoice: swapInvoice,
}
@ -165,7 +195,11 @@ func TestSweepBatcherBatchCreation(t *testing.T) {
SwapContract: loopdb.SwapContract{
CltvExpiry: 111 + defaultMaxTimeoutDistance + 1,
AmountRequested: 333,
// Make preimage unique to pass SQL constraints.
Preimage: lntypes.Preimage{3},
},
DestAddr: destAddr,
SwapInvoice: swapInvoice,
}
@ -211,21 +245,20 @@ func TestSweepBatcherBatchCreation(t *testing.T) {
require.True(t, batcherStore.AssertSweepStored(sweepReq3.SwapHash))
}
// TestSweepBatcherSimpleLifecycle tests the simple lifecycle of the batches
// testSweepBatcherSimpleLifecycle tests the simple lifecycle of the batches
// that are created and run by the batcher.
func TestSweepBatcherSimpleLifecycle(t *testing.T) {
func testSweepBatcherSimpleLifecycle(t *testing.T, store testStore,
batcherStore testBatcherStore) {
defer test.Guard(t)()
lnd := test.NewMockLnd()
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
store := loopdb.NewStoreMock(t)
sweepStore, err := NewSweepFetcherFromSwapStore(store, lnd.ChainParams)
require.NoError(t, err)
batcherStore := NewStoreMock()
batcher := NewBatcher(lnd.WalletKit, lnd.ChainNotifier, lnd.Signer,
testMuSig2SignSweep, nil, lnd.ChainParams, batcherStore,
sweepStore)
@ -250,6 +283,7 @@ func TestSweepBatcherSimpleLifecycle(t *testing.T) {
CltvExpiry: 111,
AmountRequested: 111,
},
DestAddr: destAddr,
SwapInvoice: swapInvoice,
SweepConfTarget: 111,
}
@ -351,21 +385,20 @@ func TestSweepBatcherSimpleLifecycle(t *testing.T) {
}, test.Timeout, eventuallyCheckFrequency)
}
// TestSweepBatcherSweepReentry tests that when an old version of the batch tx
// testSweepBatcherSweepReentry tests that when an old version of the batch tx
// gets confirmed the sweep leftovers are sent back to the batcher.
func TestSweepBatcherSweepReentry(t *testing.T) {
func testSweepBatcherSweepReentry(t *testing.T, store testStore,
batcherStore testBatcherStore) {
defer test.Guard(t)()
lnd := test.NewMockLnd()
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
store := loopdb.NewStoreMock(t)
sweepStore, err := NewSweepFetcherFromSwapStore(store, lnd.ChainParams)
require.NoError(t, err)
batcherStore := NewStoreMock()
batcher := NewBatcher(lnd.WalletKit, lnd.ChainNotifier, lnd.Signer,
testMuSig2SignSweep, nil, lnd.ChainParams, batcherStore,
sweepStore)
@ -391,6 +424,7 @@ func TestSweepBatcherSweepReentry(t *testing.T) {
CltvExpiry: 111,
AmountRequested: 111,
},
DestAddr: destAddr,
SwapInvoice: swapInvoice,
SweepConfTarget: 111,
}
@ -413,7 +447,11 @@ func TestSweepBatcherSweepReentry(t *testing.T) {
SwapContract: loopdb.SwapContract{
CltvExpiry: 111,
AmountRequested: 222,
// Make preimage unique to pass SQL constraints.
Preimage: lntypes.Preimage{2},
},
DestAddr: destAddr,
SwapInvoice: swapInvoice,
SweepConfTarget: 111,
}
@ -436,7 +474,11 @@ func TestSweepBatcherSweepReentry(t *testing.T) {
SwapContract: loopdb.SwapContract{
CltvExpiry: 111,
AmountRequested: 333,
// Make preimage unique to pass SQL constraints.
Preimage: lntypes.Preimage{3},
},
DestAddr: destAddr,
SwapInvoice: swapInvoice,
SweepConfTarget: 111,
}
@ -561,21 +603,20 @@ func TestSweepBatcherSweepReentry(t *testing.T) {
require.Equal(t, b.state, Open)
}
// TestSweepBatcherNonWalletAddr tests that sweep requests that sweep to a non
// testSweepBatcherNonWalletAddr tests that sweep requests that sweep to a non
// wallet address enter individual batches.
func TestSweepBatcherNonWalletAddr(t *testing.T) {
func testSweepBatcherNonWalletAddr(t *testing.T, store testStore,
batcherStore testBatcherStore) {
defer test.Guard(t)()
lnd := test.NewMockLnd()
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
store := loopdb.NewStoreMock(t)
sweepStore, err := NewSweepFetcherFromSwapStore(store, lnd.ChainParams)
require.NoError(t, err)
batcherStore := NewStoreMock()
batcher := NewBatcher(lnd.WalletKit, lnd.ChainNotifier, lnd.Signer,
testMuSig2SignSweep, nil, lnd.ChainParams, batcherStore,
sweepStore)
@ -601,6 +642,7 @@ func TestSweepBatcherNonWalletAddr(t *testing.T) {
AmountRequested: 111,
},
IsExternalAddr: true,
DestAddr: destAddr,
SwapInvoice: swapInvoice,
}
@ -640,7 +682,11 @@ func TestSweepBatcherNonWalletAddr(t *testing.T) {
SwapContract: loopdb.SwapContract{
CltvExpiry: 111 + defaultMaxTimeoutDistance - 1,
AmountRequested: 222,
// Make preimage unique to pass SQL constraints.
Preimage: lntypes.Preimage{2},
},
DestAddr: destAddr,
SwapInvoice: swapInvoice,
IsExternalAddr: true,
}
@ -677,7 +723,11 @@ func TestSweepBatcherNonWalletAddr(t *testing.T) {
SwapContract: loopdb.SwapContract{
CltvExpiry: 111 + defaultMaxTimeoutDistance + 1,
AmountRequested: 333,
// Make preimage unique to pass SQL constraints.
Preimage: lntypes.Preimage{3},
},
DestAddr: destAddr,
SwapInvoice: swapInvoice,
IsExternalAddr: true,
}
@ -729,21 +779,20 @@ func TestSweepBatcherNonWalletAddr(t *testing.T) {
require.True(t, batcherStore.AssertSweepStored(sweepReq3.SwapHash))
}
// TestSweepBatcherComposite tests that sweep requests that sweep to both wallet
// testSweepBatcherComposite tests that sweep requests that sweep to both wallet
// addresses and non-wallet addresses enter the correct batches.
func TestSweepBatcherComposite(t *testing.T) {
func testSweepBatcherComposite(t *testing.T, store testStore,
batcherStore testBatcherStore) {
defer test.Guard(t)()
lnd := test.NewMockLnd()
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
store := loopdb.NewStoreMock(t)
sweepStore, err := NewSweepFetcherFromSwapStore(store, lnd.ChainParams)
require.NoError(t, err)
batcherStore := NewStoreMock()
batcher := NewBatcher(lnd.WalletKit, lnd.ChainNotifier, lnd.Signer,
testMuSig2SignSweep, nil, lnd.ChainParams, batcherStore,
sweepStore)
@ -769,6 +818,7 @@ func TestSweepBatcherComposite(t *testing.T) {
AmountRequested: 111,
},
DestAddr: destAddr,
SwapInvoice: swapInvoice,
}
@ -792,7 +842,11 @@ func TestSweepBatcherComposite(t *testing.T) {
SwapContract: loopdb.SwapContract{
CltvExpiry: 111 + defaultMaxTimeoutDistance - 1,
AmountRequested: 222,
// Make preimage unique to pass SQL constraints.
Preimage: lntypes.Preimage{2},
},
DestAddr: destAddr,
SwapInvoice: swapInvoice,
}
@ -816,7 +870,11 @@ func TestSweepBatcherComposite(t *testing.T) {
SwapContract: loopdb.SwapContract{
CltvExpiry: 111 + defaultMaxTimeoutDistance - 3,
AmountRequested: 333,
// Make preimage unique to pass SQL constraints.
Preimage: lntypes.Preimage{3},
},
DestAddr: destAddr,
SwapInvoice: swapInvoice,
IsExternalAddr: true,
}
@ -841,7 +899,11 @@ func TestSweepBatcherComposite(t *testing.T) {
SwapContract: loopdb.SwapContract{
CltvExpiry: 111 + defaultMaxTimeoutDistance + 1,
AmountRequested: 444,
// Make preimage unique to pass SQL constraints.
Preimage: lntypes.Preimage{4},
},
DestAddr: destAddr,
SwapInvoice: swapInvoice,
}
@ -865,7 +927,11 @@ func TestSweepBatcherComposite(t *testing.T) {
SwapContract: loopdb.SwapContract{
CltvExpiry: 111 + defaultMaxTimeoutDistance + 5,
AmountRequested: 555,
// Make preimage unique to pass SQL constraints.
Preimage: lntypes.Preimage{5},
},
DestAddr: destAddr,
SwapInvoice: swapInvoice,
}
@ -889,7 +955,11 @@ func TestSweepBatcherComposite(t *testing.T) {
SwapContract: loopdb.SwapContract{
CltvExpiry: 111 + defaultMaxTimeoutDistance + 6,
AmountRequested: 666,
// Make preimage unique to pass SQL constraints.
Preimage: lntypes.Preimage{6},
},
DestAddr: destAddr,
SwapInvoice: swapInvoice,
IsExternalAddr: true,
}
@ -1013,9 +1083,11 @@ func makeTestTx(value int64) *wire.MsgTx {
return tx
}
// TestGetFeePortionForSweep tests that the fee portion for a sweep is correctly
// testGetFeePortionForSweep tests that the fee portion for a sweep is correctly
// calculated.
func TestGetFeePortionForSweep(t *testing.T) {
func testGetFeePortionForSweep(t *testing.T, store testStore,
batcherStore testBatcherStore) {
tests := []struct {
name string
spendTxValue int64
@ -1050,19 +1122,19 @@ func TestGetFeePortionForSweep(t *testing.T) {
}
}
// TestRestoringEmptyBatch tests that the batcher can be restored with an empty
// testRestoringEmptyBatch tests that the batcher can be restored with an empty
// batch.
func TestRestoringEmptyBatch(t *testing.T) {
func testRestoringEmptyBatch(t *testing.T, store testStore,
batcherStore testBatcherStore) {
defer test.Guard(t)()
lnd := test.NewMockLnd()
ctx, cancel := context.WithCancel(context.Background())
store := loopdb.NewStoreMock(t)
sweepStore, err := NewSweepFetcherFromSwapStore(store, lnd.ChainParams)
require.NoError(t, err)
batcherStore := NewStoreMock()
_, err = batcherStore.InsertSweepBatch(ctx, &dbBatch{})
require.NoError(t, err)
@ -1099,6 +1171,7 @@ func TestRestoringEmptyBatch(t *testing.T) {
AmountRequested: 111,
},
DestAddr: destAddr,
SwapInvoice: swapInvoice,
}
@ -1138,11 +1211,20 @@ func TestRestoringEmptyBatch(t *testing.T) {
type loopStoreMock struct {
loops map[lntypes.Hash]*loopdb.LoopOut
mu sync.Mutex
// backend is the store passed to the test. An empty swap with the ID
// passed is stored to this place to satisfy SQL foreign key constraint.
backend testStore
// preimage is last preimage first byte used in fake swap in backend.
// It has to be unique to satisfy SQL constraint.
preimage byte
}
func newLoopStoreMock() *loopStoreMock {
func newLoopStoreMock(backend testStore) *loopStoreMock {
return &loopStoreMock{
loops: make(map[lntypes.Hash]*loopdb.LoopOut),
loops: make(map[lntypes.Hash]*loopdb.LoopOut),
backend: backend,
}
}
@ -1164,23 +1246,67 @@ func (s *loopStoreMock) putLoopOutSwap(hash lntypes.Hash, out *loopdb.LoopOut) {
s.mu.Lock()
defer s.mu.Unlock()
_, existed := s.loops[hash]
s.loops[hash] = out
if existed {
// The swap exists, no need to create one in backend, since it
// stores fake data anyway.
return
}
if _, ok := s.backend.(*loopdb.StoreMock); ok {
// Do not create a fake loop in loopdb.StoreMock, because it
// blocks on notification channels and this is not needed.
return
}
// Put a swap with the same ID to backend store to satisfy SQL foreign
// key constraint. Don't store the data to ensure it is not used.
err := s.backend.CreateLoopOut(context.Background(), hash,
&loopdb.LoopOutContract{
SwapContract: loopdb.SwapContract{
CltvExpiry: 999,
AmountRequested: 999,
// Make preimage unique to pass SQL constraints.
Preimage: lntypes.Preimage{s.preimage},
},
DestAddr: destAddr,
SwapInvoice: swapInvoice,
},
)
s.backend.AssertLoopOutStored()
// Make preimage unique to pass SQL constraints.
s.preimage++
if err != nil {
panic(err)
}
}
// TestHandleSweepTwice tests that handing the same sweep twice must not
// AssertLoopOutStored asserts that a swap is stored.
func (s *loopStoreMock) AssertLoopOutStored() {
s.backend.AssertLoopOutStored()
}
// testHandleSweepTwice tests that handing the same sweep twice must not
// add it to different batches.
func TestHandleSweepTwice(t *testing.T) {
func testHandleSweepTwice(t *testing.T, backend testStore,
batcherStore testBatcherStore) {
defer test.Guard(t)()
lnd := test.NewMockLnd()
ctx, cancel := context.WithCancel(context.Background())
store := newLoopStoreMock()
store := newLoopStoreMock(backend)
sweepStore, err := NewSweepFetcherFromSwapStore(store, lnd.ChainParams)
require.NoError(t, err)
batcherStore := NewStoreMock()
batcher := NewBatcher(lnd.WalletKit, lnd.ChainNotifier, lnd.Signer,
testMuSig2SignSweep, nil, lnd.ChainParams, batcherStore,
sweepStore)
@ -1221,6 +1347,7 @@ func TestHandleSweepTwice(t *testing.T) {
CltvExpiry: shortCltv,
AmountRequested: 111,
},
DestAddr: destAddr,
SwapInvoice: swapInvoice,
},
}
@ -1244,6 +1371,7 @@ func TestHandleSweepTwice(t *testing.T) {
CltvExpiry: longCltv,
AmountRequested: 222,
},
DestAddr: destAddr,
SwapInvoice: swapInvoice,
},
}
@ -1284,6 +1412,7 @@ func TestHandleSweepTwice(t *testing.T) {
CltvExpiry: shortCltv,
AmountRequested: 222,
},
DestAddr: destAddr,
SwapInvoice: swapInvoice,
},
}
@ -1300,24 +1429,31 @@ func TestHandleSweepTwice(t *testing.T) {
return false
}
// Find the batch with largest ID. It must be the second batch.
// Variable batches is a map, not a slice, so we have to visit
// all the items and find the one with maximum id.
var secondBatch *batch
for _, batch := range batches {
if secondBatch == nil || batch.id > secondBatch.id {
secondBatch = batch
}
}
// Make sure the second batch has the second sweep.
sweep2, has := batches[1].sweeps[sweepReq2.SwapHash]
sweep2, has := secondBatch.sweeps[sweepReq2.SwapHash]
if !has {
return false
}
// Make sure the second sweep's timeout has been updated.
if sweep2.timeout != shortCltv {
return false
}
return true
return sweep2.timeout == shortCltv
}, test.Timeout, eventuallyCheckFrequency)
// Make sure each batch has one sweep. If the second sweep was added to
// both batches, the following check won't pass.
require.Equal(t, 1, len(batcher.batches[0].sweeps))
require.Equal(t, 1, len(batcher.batches[1].sweeps))
for _, batch := range batcher.batches {
require.Equal(t, 1, len(batch.sweeps))
}
// Now make the batcher quit by canceling the context.
cancel()
@ -1326,20 +1462,19 @@ func TestHandleSweepTwice(t *testing.T) {
checkBatcherError(t, runErr)
}
// TestRestoringPreservesConfTarget tests that after the batch is written to DB
// testRestoringPreservesConfTarget tests that after the batch is written to DB
// and loaded back, its batchConfTarget value is preserved.
func TestRestoringPreservesConfTarget(t *testing.T) {
func testRestoringPreservesConfTarget(t *testing.T, store testStore,
batcherStore testBatcherStore) {
defer test.Guard(t)()
lnd := test.NewMockLnd()
ctx, cancel := context.WithCancel(context.Background())
store := loopdb.NewStoreMock(t)
sweepStore, err := NewSweepFetcherFromSwapStore(store, lnd.ChainParams)
require.NoError(t, err)
batcherStore := NewStoreMock()
batcher := NewBatcher(lnd.WalletKit, lnd.ChainNotifier, lnd.Signer,
testMuSig2SignSweep, nil, lnd.ChainParams, batcherStore,
sweepStore)
@ -1373,6 +1508,7 @@ func TestRestoringPreservesConfTarget(t *testing.T) {
AmountRequested: 111,
},
DestAddr: destAddr,
SwapInvoice: swapInvoice,
SweepConfTarget: 123,
}
@ -1391,12 +1527,26 @@ func TestRestoringPreservesConfTarget(t *testing.T) {
// Once batcher receives sweep request it will eventually spin up a
// batch.
require.Eventually(t, func() bool {
// Make sure that the sweep was stored and we have exactly one
// active batch, with one sweep and proper batchConfTarget.
return batcherStore.AssertSweepStored(sweepReq.SwapHash) &&
len(batcher.batches) == 1 &&
len(batcher.batches[0].sweeps) == 1 &&
batcher.batches[0].cfg.batchConfTarget == 123
// Make sure that the sweep was stored
if !batcherStore.AssertSweepStored(sweepReq.SwapHash) {
return false
}
// Make sure there is exactly one active batch.
if len(batcher.batches) != 1 {
return false
}
// Get the batch.
batch := getOnlyBatch(batcher)
// Make sure the batch has one sweep.
if len(batch.sweeps) != 1 {
return false
}
// Make sure the batch has proper batchConfTarget.
return batch.cfg.batchConfTarget == 123
}, test.Timeout, eventuallyCheckFrequency)
// Make sure we have stored the batch.
@ -1427,13 +1577,25 @@ func TestRestoringPreservesConfTarget(t *testing.T) {
// Wait for batch to load.
require.Eventually(t, func() bool {
return batcherStore.AssertSweepStored(sweepReq.SwapHash) &&
len(batcher.batches) == 1 &&
len(batcher.batches[0].sweeps) == 1
// Make sure that the sweep was stored
if !batcherStore.AssertSweepStored(sweepReq.SwapHash) {
return false
}
// Make sure there is exactly one active batch.
if len(batcher.batches) != 1 {
return false
}
// Get the batch.
batch := getOnlyBatch(batcher)
// Make sure the batch has one sweep.
return len(batch.sweeps) == 1
}, test.Timeout, eventuallyCheckFrequency)
// Make sure batchConfTarget was preserved.
require.Equal(t, 123, int(batcher.batches[0].cfg.batchConfTarget))
require.Equal(t, 123, int(getOnlyBatch(batcher).cfg.batchConfTarget))
// Expect registration for spend notification.
<-lnd.RegisterSpendChannel
@ -1456,8 +1618,10 @@ func (f *sweepFetcherMock) FetchSweep(ctx context.Context, hash lntypes.Hash) (
return f.store[hash], nil
}
// TestSweepFetcher tests providing custom sweep fetcher to Batcher.
func TestSweepFetcher(t *testing.T) {
// testSweepFetcher tests providing custom sweep fetcher to Batcher.
func testSweepFetcher(t *testing.T, store testStore,
batcherStore testBatcherStore) {
defer test.Guard(t)()
lnd := test.NewMockLnd()
@ -1479,7 +1643,33 @@ func TestSweepFetcher(t *testing.T) {
},
}
batcherStore := NewStoreMock()
// Create a sweep request.
sweepReq := SweepRequest{
SwapHash: lntypes.Hash{1, 1, 1},
Value: 111,
Outpoint: wire.OutPoint{
Hash: chainhash.Hash{1, 1},
Index: 1,
},
Notifier: &dummyNotifier,
}
// Create a swap in the DB. It is needed to satisfy SQL constraints in
// case of SQL test. The data is not actually used, since we pass sweep
// fetcher, so put different conf target to make sure it is not used.
swap := &loopdb.LoopOutContract{
SwapContract: loopdb.SwapContract{
CltvExpiry: 222,
AmountRequested: 222,
},
DestAddr: destAddr,
SwapInvoice: swapInvoice,
SweepConfTarget: 321,
}
err = store.CreateLoopOut(ctx, sweepReq.SwapHash, swap)
require.NoError(t, err)
store.AssertLoopOutStored()
batcher := NewBatcher(lnd.WalletKit, lnd.ChainNotifier, lnd.Signer,
testMuSig2SignSweep, nil, lnd.ChainParams, batcherStore,
@ -1497,17 +1687,6 @@ func TestSweepFetcher(t *testing.T) {
// Wait for the batcher to be initialized.
<-batcher.initDone
// Create a sweep request.
sweepReq := SweepRequest{
SwapHash: lntypes.Hash{1, 1, 1},
Value: 111,
Outpoint: wire.OutPoint{
Hash: chainhash.Hash{1, 1},
Index: 1,
},
Notifier: &dummyNotifier,
}
// Deliver sweep request to batcher.
require.NoError(t, batcher.AddSweep(&sweepReq))
@ -1518,12 +1697,26 @@ func TestSweepFetcher(t *testing.T) {
// Once batcher receives sweep request it will eventually spin up a
// batch.
require.Eventually(t, func() bool {
// Make sure that the sweep was stored and we have exactly one
// active batch, with one sweep and proper batchConfTarget.
return batcherStore.AssertSweepStored(sweepReq.SwapHash) &&
len(batcher.batches) == 1 &&
len(batcher.batches[0].sweeps) == 1 &&
batcher.batches[0].cfg.batchConfTarget == 123
// Make sure that the sweep was stored
if !batcherStore.AssertSweepStored(sweepReq.SwapHash) {
return false
}
// Make sure there is exactly one active batch.
if len(batcher.batches) != 1 {
return false
}
// Get the batch.
batch := getOnlyBatch(batcher)
// Make sure the batch has one sweep.
if len(batch.sweeps) != 1 {
return false
}
// Make sure the batch has proper batchConfTarget.
return batch.cfg.batchConfTarget == 123
}, test.Timeout, eventuallyCheckFrequency)
// Make sure we have stored the batch.
@ -1539,21 +1732,20 @@ func TestSweepFetcher(t *testing.T) {
checkBatcherError(t, runErr)
}
// TestSweepBatcherCloseDuringAdding tests that sweep batcher works correctly
// testSweepBatcherCloseDuringAdding tests that sweep batcher works correctly
// if it is closed (stops running) during AddSweep call.
func TestSweepBatcherCloseDuringAdding(t *testing.T) {
func testSweepBatcherCloseDuringAdding(t *testing.T, store testStore,
batcherStore testBatcherStore) {
defer test.Guard(t)()
lnd := test.NewMockLnd()
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
store := loopdb.NewStoreMock(t)
sweepStore, err := NewSweepFetcherFromSwapStore(store, lnd.ChainParams)
require.NoError(t, err)
batcherStore := NewStoreMock()
batcher := NewBatcher(lnd.WalletKit, lnd.ChainNotifier, lnd.Signer,
testMuSig2SignSweep, nil, lnd.ChainParams, batcherStore,
sweepStore)
@ -1571,8 +1763,12 @@ func TestSweepBatcherCloseDuringAdding(t *testing.T) {
SwapContract: loopdb.SwapContract{
CltvExpiry: 111,
AmountRequested: 111,
// Make preimage unique to pass SQL constraints.
Preimage: lntypes.Preimage{i},
},
DestAddr: destAddr,
SwapInvoice: swapInvoice,
}
@ -1634,3 +1830,173 @@ func TestSweepBatcherCloseDuringAdding(t *testing.T) {
close(quit)
<-registrationChan
}
// TestSweepBatcherBatchCreation tests that sweep requests enter the expected
// batch based on their timeout distance.
func TestSweepBatcherBatchCreation(t *testing.T) {
runTests(t, testSweepBatcherBatchCreation)
}
// TestSweepBatcherSimpleLifecycle tests the simple lifecycle of the batches
// that are created and run by the batcher.
func TestSweepBatcherSimpleLifecycle(t *testing.T) {
runTests(t, testSweepBatcherSimpleLifecycle)
}
// TestSweepBatcherSweepReentry tests that when an old version of the batch tx
// gets confirmed the sweep leftovers are sent back to the batcher.
func TestSweepBatcherSweepReentry(t *testing.T) {
runTests(t, testSweepBatcherSweepReentry)
}
// TestSweepBatcherNonWalletAddr tests that sweep requests that sweep to a non
// wallet address enter individual batches.
func TestSweepBatcherNonWalletAddr(t *testing.T) {
runTests(t, testSweepBatcherNonWalletAddr)
}
// TestSweepBatcherComposite tests that sweep requests that sweep to both wallet
// addresses and non-wallet addresses enter the correct batches.
func TestSweepBatcherComposite(t *testing.T) {
runTests(t, testSweepBatcherComposite)
}
// TestGetFeePortionForSweep tests that the fee portion for a sweep is correctly
// calculated.
func TestGetFeePortionForSweep(t *testing.T) {
runTests(t, testGetFeePortionForSweep)
}
// TestRestoringEmptyBatch tests that the batcher can be restored with an empty
// batch.
func TestRestoringEmptyBatch(t *testing.T) {
runTests(t, testRestoringEmptyBatch)
}
// TestHandleSweepTwice tests that handing the same sweep twice must not
// add it to different batches.
func TestHandleSweepTwice(t *testing.T) {
runTests(t, testHandleSweepTwice)
}
// TestRestoringPreservesConfTarget tests that after the batch is written to DB
// and loaded back, its batchConfTarget value is preserved.
func TestRestoringPreservesConfTarget(t *testing.T) {
runTests(t, testRestoringPreservesConfTarget)
}
// TestSweepFetcher tests providing custom sweep fetcher to Batcher.
func TestSweepFetcher(t *testing.T) {
runTests(t, testSweepFetcher)
}
// TestSweepBatcherCloseDuringAdding tests that sweep batcher works correctly
// if it is closed (stops running) during AddSweep call.
func TestSweepBatcherCloseDuringAdding(t *testing.T) {
runTests(t, testSweepBatcherCloseDuringAdding)
}
// testBatcherStore is BatcherStore used in tests.
type testBatcherStore interface {
BatcherStore
// AssertSweepStored asserts that a sweep is stored.
AssertSweepStored(id lntypes.Hash) bool
}
type loopdbBatcherStore struct {
BatcherStore
sweepsSet map[lntypes.Hash]struct{}
}
// UpsertSweep inserts a sweep into the database, or updates an existing sweep
// if it already exists. This wrapper was added to update sweepsSet.
func (s *loopdbBatcherStore) UpsertSweep(ctx context.Context,
sweep *dbSweep) error {
err := s.BatcherStore.UpsertSweep(ctx, sweep)
if err == nil {
s.sweepsSet[sweep.SwapHash] = struct{}{}
}
return err
}
// AssertSweepStored asserts that a sweep is stored.
func (s *loopdbBatcherStore) AssertSweepStored(id lntypes.Hash) bool {
_, has := s.sweepsSet[id]
return has
}
// testStore is loopdb used in tests.
type testStore interface {
loopdb.SwapStore
// AssertLoopOutStored asserts that a swap is stored.
AssertLoopOutStored()
}
// loopdbStore wraps loopdb.SwapStore and implements testStore interface.
type loopdbStore struct {
loopdb.SwapStore
t *testing.T
loopOutStoreChan chan struct{}
}
// newLoopdbStore creates new loopdbStore instance.
func newLoopdbStore(t *testing.T, swapStore loopdb.SwapStore) *loopdbStore {
return &loopdbStore{
SwapStore: swapStore,
t: t,
loopOutStoreChan: make(chan struct{}, 1),
}
}
// CreateLoopOut adds an initiated swap to the store.
func (s *loopdbStore) CreateLoopOut(ctx context.Context, hash lntypes.Hash,
swap *loopdb.LoopOutContract) error {
err := s.SwapStore.CreateLoopOut(ctx, hash, swap)
if err == nil {
s.loopOutStoreChan <- struct{}{}
}
return err
}
// AssertLoopOutStored asserts that a swap is stored.
func (s *loopdbStore) AssertLoopOutStored() {
s.t.Helper()
select {
case <-s.loopOutStoreChan:
case <-time.After(test.Timeout):
s.t.Fatalf("expected swap to be stored")
}
}
// runTests runs a test with both mock and loopdb.
func runTests(t *testing.T, testFn func(t *testing.T, store testStore,
batcherStore testBatcherStore)) {
t.Run("mocks", func(t *testing.T) {
store := loopdb.NewStoreMock(t)
batcherStore := NewStoreMock()
testFn(t, store, batcherStore)
})
t.Run("loopdb", func(t *testing.T) {
sqlDB := loopdb.NewTestDB(t)
typedSqlDB := loopdb.NewTypedStore[Querier](sqlDB)
lnd := test.NewMockLnd()
batcherStore := NewSQLStore(typedSqlDB, lnd.ChainParams)
testStore := newLoopdbStore(t, sqlDB)
testBatcherStore := &loopdbBatcherStore{
BatcherStore: batcherStore,
sweepsSet: make(map[lntypes.Hash]struct{}),
}
testFn(t, testStore, testBatcherStore)
})
}

Write Preview
Loading…
Cancel
Save