(to squash) add purging test when sweeps are online

Author: starius

sweepbatcher/sweep_batcher_presigned_test.go

@@ -1330,10 +1330,12 @@ func testPresigned_presigned_and_regular_sweeps(t *testing.T, store testStore,
 }
 
 // testPresigned_purging tests what happens if a non-final version of the batch
-// is confirmed. Missing sweeps must are added to new batch(es) having valid
-// presigned transactions even if the sweeps are offline at that moment.
+// is confirmed. Missing sweeps may be online or offline at that moment, which
+// depends on the last argument of the function. In online case they are added
+// to another online batch. In offline case they must are added to a new batch
+// having valid presigned transactions.
 func testPresigned_purging(t *testing.T, numSwaps, numConfirmedSwaps int,
-	store testStore, batcherStore testBatcherStore) {
+	store testStore, batcherStore testBatcherStore, online bool) {
 
 	defer test.Guard(t)()
 
@@ -1448,6 +1450,67 @@ func testPresigned_purging(t *testing.T, numSwaps, numConfirmedSwaps int,
 		presignedHelper.SetOutpointOnline(op, false)
 	}
 
+	// In case we are testing the addition of the remaining sweeps to a
+	// batch in online state, we need to create that batch now.
+	opx := wire.OutPoint{Hash: chainhash.Hash{3, 2, 1}, Index: 1}
+	if online && numConfirmedSwaps < numSwaps {
+		swapHash := lntypes.Hash{1, 2, 3}
+		const amount = 1_234_567
+		group := []Input{
+			{
+				Outpoint: opx,
+				Value:    amount,
+			},
+		}
+
+		// Create a swap in DB.
+		swap := &loopdb.LoopOutContract{
+			SwapContract: loopdb.SwapContract{
+				CltvExpiry:      111,
+				AmountRequested: amount,
+				ProtocolVersion: loopdb.ProtocolVersionMuSig2,
+				HtlcKeys:        htlcKeys,
+
+				// Make preimage unique to pass SQL constraints.
+				Preimage: lntypes.Preimage{1, 2, 3},
+			},
+
+			DestAddr:        destAddr,
+			SwapInvoice:     swapInvoice,
+			SweepConfTarget: 111,
+		}
+		err := store.CreateLoopOut(ctx, swapHash, swap)
+		require.NoError(t, err)
+		store.AssertLoopOutStored()
+
+		// Enable the sweep.
+		presignedHelper.SetOutpointOnline(opx, true)
+
+		// An attempt to presign must succeed.
+		err = batcher.PresignSweepsGroup(
+			ctx, group, sweepTimeout, destAddr,
+		)
+		require.NoError(t, err)
+
+		// Add the sweep, triggering the publish attempt.
+		require.NoError(t, batcher.AddSweep(ctx, &SweepRequest{
+			SwapHash: swapHash,
+			Inputs:   group,
+			Notifier: &dummyNotifier,
+		}))
+
+		<-lnd.RegisterSpendChannel
+		tx := <-lnd.TxPublishChannel
+		require.Len(t, tx.TxIn, 1)
+		require.Equal(t, opx, tx.TxIn[0].PreviousOutPoint)
+
+		// Now enable our main sweeps again so the remaining ones are
+		// added to this new batch.
+		for _, op := range allOps {
+			presignedHelper.SetOutpointOnline(op, true)
+		}
+	}
+
 	// Now mine the transaction which includes first numConfirmedSwaps.
 	tx := txs[numConfirmedSwaps-1]
 
@@ -1477,14 +1540,21 @@ func testPresigned_purging(t *testing.T, numSwaps, numConfirmedSwaps int,
 		return
 	}
 
-	// Missing sweeps in the confirmed transaction should be re-added to the
-	// batcher as new batch. The groups are added incrementally, so we need
-	// to wait until the batch reaches the expected size.
-	<-lnd.RegisterSpendChannel
-	<-lnd.TxPublishChannel
+	if !online {
+		// If the sweeps are offline, the missing sweeps in the
+		// confirmed transaction should be re-added to the batcher as
+		// new batch. The groups are added incrementally, so we need
+		// to wait until the batch reaches the expected size.
+		<-lnd.RegisterSpendChannel
+		<-lnd.TxPublishChannel
+	}
 
 	// Wait to new batch to appear and to have the expected size.
 	wantSize := (numSwaps - numConfirmedSwaps) * sweepsPerSwap
+	if online {
+		// Add opx to the list of expected inputs.
+		wantSize++
+	}
 	require.Eventually(t, func() bool {
 		// Wait for a batch with new ID to appear.
 		batches := getBatches(ctx, batcher)
@@ -1508,6 +1578,11 @@ func testPresigned_purging(t *testing.T, numSwaps, numConfirmedSwaps int,
 	)))
 	tx2 := <-lnd.TxPublishChannel
 	wantOps := allOps[numConfirmedSwaps*sweepsPerSwap:]
+	if online {
+		// Deep copy wantOps to unlink from allOps.
+		wantOps = append([]wire.OutPoint{}, wantOps...)
+		wantOps = append(wantOps, opx)
+	}
 	gotOps := make([]wire.OutPoint, 0, len(tx2.TxIn))
 	for _, txIn := range tx2.TxIn {
 		gotOps = append(gotOps, txIn.PreviousOutPoint)
@@ -1551,27 +1626,41 @@ func TestPresigned(t *testing.T) {
 	})
 
 	t.Run("purging", func(t *testing.T) {
-		testPurging := func(numSwaps, numConfirmedSwaps int) {
+		testPurging := func(numSwaps, numConfirmedSwaps int,
+			online bool) {
+
 			name := fmt.Sprintf("%d of %d swaps confirmed",
 				numConfirmedSwaps, numSwaps)
+			if online {
+				name += ", sweeps online"
+			} else {
+				name += ", sweeps offline"
+			}
 
 			t.Run(name, func(t *testing.T) {
 				runTests(t, func(t *testing.T, store testStore,
 					batcherStore testBatcherStore) {
 
 					testPresigned_purging(
 						t, numSwaps, numConfirmedSwaps,
-						store, batcherStore,
+						store, batcherStore, online,
 					)
 				})
 			})
 		}
 
-		testPurging(1, 1)
-		testPurging(2, 1)
-		testPurging(2, 2)
-		testPurging(3, 1)
-		testPurging(3, 2)
-		testPurging(5, 2)
+		// Test cases in which the sweeps are offline.
+		testPurging(1, 1, false)
+		testPurging(2, 1, false)
+		testPurging(2, 2, false)
+		testPurging(3, 1, false)
+		testPurging(3, 2, false)
+		testPurging(5, 2, false)
+
+		// Test cases in which the sweeps are online.
+		testPurging(2, 1, true)
+		testPurging(3, 1, true)
+		testPurging(3, 2, true)
+		testPurging(5, 2, true)
 	})
 }