looprpc: add test for ListSwaps pagination and filtering

Author: kornpow

loopd/swapclient_server_test.go

@@ -4,15 +4,19 @@ import (
 	"context"
 	"os"
 	"testing"
+	"time"
 
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/btcsuite/btclog/v2"
 	"github.com/lightninglabs/lndclient"
 	"github.com/lightninglabs/loop"
 	"github.com/lightninglabs/loop/labels"
+	"github.com/lightninglabs/loop/loopdb"
 	"github.com/lightninglabs/loop/looprpc"
+	"github.com/lightninglabs/loop/swap"
 	mock_lnd "github.com/lightninglabs/loop/test"
+	"github.com/lightningnetwork/lnd/lntypes"
 	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/lightningnetwork/lnd/routing/route"
 	"github.com/stretchr/testify/require"
@@ -595,3 +599,273 @@ func TestHasBandwidth(t *testing.T) {
 		})
 	}
 }
+
+// TestListSwapsFilterAndPagination tests the filtering and
+// paging of the ListSwaps command.
+func TestListSwapsFilterAndPagination(t *testing.T) {
+	// Create a set of test swaps of various types which contain the minimal
+	// viable amount of info to successfully be run through marshallSwap.
+	swapInOrder0 := loop.SwapInfo{
+		SwapStateData: loopdb.SwapStateData{
+			State: loopdb.StateInitiated,
+			Cost:  loopdb.SwapCost{},
+		},
+		SwapContract: loopdb.SwapContract{
+			InitiationTime: time.Now().Add(time.Duration(0)),
+		},
+		LastUpdate:       time.Now(),
+		SwapHash:         lntypes.Hash{1},
+		SwapType:         swap.Type(swap.TypeIn),
+		HtlcAddressP2WSH: testnetAddr,
+		HtlcAddressP2TR:  testnetAddr,
+	}
+
+	swapOutOrder1 := loop.SwapInfo{
+		SwapStateData: loopdb.SwapStateData{
+			State: loopdb.StateInitiated,
+			Cost:  loopdb.SwapCost{},
+		},
+		SwapContract: loopdb.SwapContract{
+			InitiationTime: time.Now().Add(time.Duration(50)),
+		},
+		LastUpdate:       time.Now(),
+		SwapHash:         lntypes.Hash{2},
+		SwapType:         swap.Type(swap.TypeOut),
+		HtlcAddressP2WSH: testnetAddr,
+		HtlcAddressP2TR:  testnetAddr,
+	}
+
+	swapOutOrder2 := loop.SwapInfo{
+		SwapStateData: loopdb.SwapStateData{
+			State: loopdb.StateInitiated,
+			Cost:  loopdb.SwapCost{},
+		},
+		SwapContract: loopdb.SwapContract{
+			InitiationTime: time.Now().Add(time.Duration(100)),
+		},
+		LastUpdate:       time.Now(),
+		SwapHash:         lntypes.Hash{3},
+		SwapType:         swap.Type(swap.TypeOut),
+		HtlcAddressP2WSH: testnetAddr,
+		HtlcAddressP2TR:  testnetAddr,
+	}
+
+	mockSwaps := []loop.SwapInfo{swapInOrder0, swapOutOrder1, swapOutOrder2}
+
+	tests := []struct {
+		name string
+		// Define the mock swaps that will be stored in the mock client.
+		mockSwaps                  []loop.SwapInfo
+		req                        *looprpc.ListSwapsRequest
+		expectedReturnedSwaps      []lntypes.Hash
+		expectedFirstIdx           uint64
+		expectedLastIdx            uint64
+		expectedFilteredTotalCount uint64
+	}{
+		{
+			name:      "fetch all swaps no pagination",
+			mockSwaps: mockSwaps,
+			req:       &looprpc.ListSwapsRequest{},
+			expectedReturnedSwaps: []lntypes.Hash{
+				swapOutOrder2.SwapHash,
+				swapOutOrder1.SwapHash,
+				swapInOrder0.SwapHash,
+			},
+			expectedFirstIdx:           0,
+			expectedLastIdx:            2,
+			expectedFilteredTotalCount: 3,
+		},
+		{
+			name:      "fetch all swaps no pagination alt-order1",
+			mockSwaps: []loop.SwapInfo{swapOutOrder1, swapInOrder0, swapOutOrder2},
+			req:       &looprpc.ListSwapsRequest{},
+			expectedReturnedSwaps: []lntypes.Hash{
+				swapOutOrder2.SwapHash,
+				swapOutOrder1.SwapHash,
+				swapInOrder0.SwapHash,
+			},
+			expectedFirstIdx:           0,
+			expectedLastIdx:            2,
+			expectedFilteredTotalCount: 3,
+		},
+		{
+			name:      "fetch all swaps no pagination alt-order2",
+			mockSwaps: []loop.SwapInfo{swapOutOrder2, swapOutOrder1, swapInOrder0},
+			req:       &looprpc.ListSwapsRequest{},
+			expectedReturnedSwaps: []lntypes.Hash{
+				swapOutOrder2.SwapHash,
+				swapOutOrder1.SwapHash,
+				swapInOrder0.SwapHash,
+			},
+			expectedFirstIdx:           0,
+			expectedLastIdx:            2,
+			expectedFilteredTotalCount: 3,
+		},
+		{
+			name:      "fetch swaps-ins no pagination",
+			mockSwaps: mockSwaps,
+			req: &looprpc.ListSwapsRequest{
+				ListSwapFilter: &looprpc.ListSwapsFilter{
+					SwapType: looprpc.ListSwapsFilter_LOOP_IN},
+			},
+			expectedReturnedSwaps: []lntypes.Hash{
+				swapInOrder0.SwapHash,
+			},
+			expectedFirstIdx:           0,
+			expectedLastIdx:            0,
+			expectedFilteredTotalCount: 1,
+		},
+		{
+			name:      "fetch swaps-outs no pagination",
+			mockSwaps: mockSwaps,
+			req: &looprpc.ListSwapsRequest{
+				ListSwapFilter: &looprpc.ListSwapsFilter{
+					SwapType: looprpc.ListSwapsFilter_LOOP_OUT,
+				},
+			},
+			expectedReturnedSwaps: []lntypes.Hash{
+				swapOutOrder2.SwapHash,
+				swapOutOrder1.SwapHash,
+			},
+			expectedFirstIdx:           0,
+			expectedLastIdx:            1,
+			expectedFilteredTotalCount: 2,
+		},
+		{
+			name:      "fetch swaps-outs increment start_index",
+			mockSwaps: mockSwaps,
+			req: &looprpc.ListSwapsRequest{
+				ListSwapFilter: &looprpc.ListSwapsFilter{
+					SwapType: looprpc.ListSwapsFilter_LOOP_OUT,
+				},
+				IndexOffset: 1,
+			},
+			expectedReturnedSwaps: []lntypes.Hash{
+				swapOutOrder1.SwapHash,
+			},
+			expectedFirstIdx:           1,
+			expectedLastIdx:            1,
+			expectedFilteredTotalCount: 2,
+		},
+		{
+			name:      "fetch all swaps set swap limit",
+			mockSwaps: mockSwaps,
+			req: &looprpc.ListSwapsRequest{
+				MaxSwaps: 2,
+			},
+			expectedReturnedSwaps: []lntypes.Hash{
+				swapOutOrder2.SwapHash,
+				swapOutOrder1.SwapHash,
+			},
+			expectedFirstIdx:           0,
+			expectedLastIdx:            1,
+			expectedFilteredTotalCount: 3,
+		},
+		{
+			name:      "fetch all swaps set swap limit set start index",
+			mockSwaps: mockSwaps,
+			req: &looprpc.ListSwapsRequest{
+				IndexOffset: 1,
+				MaxSwaps:    1,
+			},
+			expectedReturnedSwaps: []lntypes.Hash{
+				swapOutOrder1.SwapHash,
+			},
+			expectedFirstIdx:           1,
+			expectedLastIdx:            1,
+			expectedFilteredTotalCount: 3,
+		},
+		{
+			name:      "fetch all swaps set start index out of bounds",
+			mockSwaps: mockSwaps,
+			req: &looprpc.ListSwapsRequest{
+				IndexOffset: 5,
+			},
+			expectedReturnedSwaps:      []lntypes.Hash{},
+			expectedFirstIdx:           5,
+			expectedLastIdx:            0,
+			expectedFilteredTotalCount: 3,
+		},
+		{
+			name:      "fetch all swaps set limit to 0",
+			mockSwaps: mockSwaps,
+			req: &looprpc.ListSwapsRequest{
+				MaxSwaps: 0,
+			},
+			expectedReturnedSwaps: []lntypes.Hash{
+				swapOutOrder2.SwapHash,
+				swapOutOrder1.SwapHash,
+				swapInOrder0.SwapHash,
+			},
+			expectedLastIdx:            2,
+			expectedFilteredTotalCount: 3,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+
+			// Create the swap client server with our mock client.
+			server := &swapClientServer{
+				swaps: make(map[lntypes.Hash]loop.SwapInfo),
+			}
+
+			// Populate the server's swap cache with our mock swaps.
+			for _, swap := range test.mockSwaps {
+				server.swaps[swap.SwapHash] = swap
+			}
+
+			// Call the ListSwaps method.
+			resp, err := server.ListSwaps(context.Background(), test.req)
+			require.NoError(t, err)
+
+			require.Len(
+				t,
+				resp.Swaps,
+				len(test.expectedReturnedSwaps),
+				"incorrect returned count",
+			)
+
+			require.Equal(
+				t,
+				test.expectedFirstIdx,
+				resp.FirstIndexOffset,
+				"incorrect first index",
+			)
+
+			require.Equal(
+				t,
+				test.expectedLastIdx,
+				resp.LastIndexOffset,
+				"incorrect last index",
+			)
+
+			require.Equal(
+				t,
+				test.expectedFilteredTotalCount,
+				resp.TotalFilteredSwaps,
+				"incorrect total",
+			)
+
+			// Subtest function to check consistent iteration order.
+			swapOrderCheck := func(
+				hashes []lntypes.Hash,
+				swaps *looprpc.ListSwapsResponse) {
+				for idx, aswap := range swaps.Swaps {
+					newhash, err := lntypes.MakeHash(aswap.GetIdBytes())
+					require.NoError(t, err)
+					require.Equal(
+						t,
+						hashes[idx],
+						newhash,
+						"iteration order mismatch",
+					)
+
+				}
+
+			}
+			swapOrderCheck(test.expectedReturnedSwaps, resp)
+		})
+	}
+}