diff --git a/channeldb/invoice_test.go b/channeldb/invoice_test.go index 73c58270..5c648112 100644 --- a/channeldb/invoice_test.go +++ b/channeldb/invoice_test.go @@ -377,7 +377,7 @@ func TestDuplicateSettleInvoice(t *testing.T) { } // TestQueryInvoices ensures that we can properly query the invoice database for -// invoices between specific time intervals. +// invoices using different types of queries. func TestQueryInvoices(t *testing.T) { t.Parallel() @@ -387,11 +387,11 @@ func TestQueryInvoices(t *testing.T) { t.Fatalf("unable to make test db: %v", err) } - // To begin the test, we'll add 100 invoices to the database. We'll + // To begin the test, we'll add 50 invoices to the database. We'll // assume that the index of the invoice within the database is the same // as the amount of the invoice itself. - const numInvoices = 100 - for i := lnwire.MilliSatoshi(0); i < numInvoices; i++ { + const numInvoices = 50 + for i := lnwire.MilliSatoshi(1); i <= numInvoices; i++ { invoice, err := randInvoice(i) if err != nil { t.Fatalf("unable to create invoice: %v", err) @@ -410,93 +410,112 @@ func TestQueryInvoices(t *testing.T) { } } - // With the invoices created, we can begin querying the database. We'll - // start with a simple query to retrieve all invoices. - query := InvoiceQuery{ - NumMaxInvoices: numInvoices, - } - res, err := db.QueryInvoices(query) + // We'll then retrieve the set of all invoices and pending invoices. + // This will serve useful when comparing the expected responses of the + // query with the actual ones. + invoices, err := db.FetchAllInvoices(false) if err != nil { - t.Fatalf("unable to query invoices: %v", err) + t.Fatalf("unable to retrieve invoices: %v", err) } - if len(res.Invoices) != numInvoices { - t.Fatalf("expected %d invoices, got %d", numInvoices, - len(res.Invoices)) + pendingInvoices, err := db.FetchAllInvoices(true) + if err != nil { + t.Fatalf("unable to retrieve pending invoices: %v", err) } - // Now, we'll limit the query to only return the latest 30 invoices. - query.IndexOffset = 70 - res, err = db.QueryInvoices(query) - if err != nil { - t.Fatalf("unable to query invoices: %v", err) + // The test will consist of several queries along with their respective + // expected response. Each query response should match its expected one. + testCases := []struct { + query InvoiceQuery + expected []Invoice + }{ + // Fetch all invoices with a single query. + { + query: InvoiceQuery{ + NumMaxInvoices: numInvoices, + }, + expected: invoices, + }, + // Fetch the first 25 invoices. + { + query: InvoiceQuery{ + NumMaxInvoices: numInvoices / 2, + }, + expected: invoices[:numInvoices/2], + }, + // Fetch the first 10 invoices, but this time iterating + // backwards. + { + query: InvoiceQuery{ + IndexOffset: 11, + Reversed: true, + NumMaxInvoices: numInvoices, + }, + expected: invoices[:10], + }, + // Fetch the last 40 invoices. + { + query: InvoiceQuery{ + IndexOffset: 10, + NumMaxInvoices: numInvoices, + }, + expected: invoices[10:], + }, + // Fetch all pending invoices with a single query. + { + query: InvoiceQuery{ + PendingOnly: true, + NumMaxInvoices: numInvoices, + }, + expected: pendingInvoices, + }, + // Fetch the first 12 pending invoices. + { + query: InvoiceQuery{ + PendingOnly: true, + NumMaxInvoices: numInvoices / 4, + }, + expected: pendingInvoices[:len(pendingInvoices)/2], + }, + // Fetch the first 5 pending invoices, but this time iterating + // backwards. + { + query: InvoiceQuery{ + IndexOffset: 10, + PendingOnly: true, + Reversed: true, + NumMaxInvoices: numInvoices, + }, + // Since we seek to the invoice with index 10 and + // iterate backwards, there should only be 5 pending + // invoices before it as every other invoice within the + // index is settled. + expected: pendingInvoices[:5], + }, + // Fetch the last 15 invoices. + { + query: InvoiceQuery{ + IndexOffset: 20, + PendingOnly: true, + NumMaxInvoices: numInvoices, + }, + // Since we seek to the invoice with index 20, there are + // 30 invoices left. From these 30, only 15 of them are + // still pending. + expected: pendingInvoices[len(pendingInvoices)-15:], + }, } - if uint32(len(res.Invoices)) != numInvoices-query.IndexOffset { - t.Fatalf("expected %d invoices, got %d", - numInvoices-query.IndexOffset, len(res.Invoices)) - } - for _, invoice := range res.Invoices { - if uint32(invoice.Terms.Value) < query.IndexOffset { - t.Fatalf("found invoice with index %v before offset %v", - invoice.Terms.Value, query.IndexOffset) + + for i, testCase := range testCases { + response, err := db.QueryInvoices(testCase.query) + if err != nil { + t.Fatalf("unable to query invoice database: %v", err) } - } - // Limit the query from above to return 25 invoices max. - query.NumMaxInvoices = 25 - res, err = db.QueryInvoices(query) - if err != nil { - t.Fatalf("unable to query invoices: %v", err) - } - if uint32(len(res.Invoices)) != query.NumMaxInvoices { - t.Fatalf("expected %d invoices, got %d", query.NumMaxInvoices, - len(res.Invoices)) - } - - // Reset the query to fetch all unsettled invoices within the time - // slice. - query = InvoiceQuery{ - PendingOnly: true, - NumMaxInvoices: numInvoices, - } - res, err = db.QueryInvoices(query) - if err != nil { - t.Fatalf("unable to query invoices: %v", err) - } - // Since only invoices with even amounts were settled, we should see - // that there are 50 invoices within the response. - if len(res.Invoices) != numInvoices/2 { - t.Fatalf("expected %d pending invoices, got %d", numInvoices/2, - len(res.Invoices)) - } - for _, invoice := range res.Invoices { - if invoice.Terms.Value%2 == 0 { - t.Fatal("retrieved unexpected settled invoice") - } - } - - // Finally, we'll skip the first 10 invoices from the set of unsettled - // invoices. - query.IndexOffset = 10 - res, err = db.QueryInvoices(query) - if err != nil { - t.Fatalf("unable to query invoices: %v", err) - } - if uint32(len(res.Invoices)) != (numInvoices/2)-query.IndexOffset { - t.Fatalf("expected %d invoices, got %d", - (numInvoices/2)-query.IndexOffset, len(res.Invoices)) - } - // To ensure the correct invoices were returned, we'll make sure each - // invoice has an odd value (meaning unsettled). Since the 10 invoices - // skipped should be unsettled, the value of the invoice must be at - // least the index of the 11th unsettled invoice. - for _, invoice := range res.Invoices { - if uint32(invoice.Terms.Value) < query.IndexOffset*2 { - t.Fatalf("found invoice with index %v before offset %v", - invoice.Terms.Value, query.IndexOffset*2) - } - if invoice.Terms.Value%2 == 0 { - t.Fatalf("found unexpected settled invoice with index %v", - invoice.Terms.Value) + if !reflect.DeepEqual(response.Invoices, testCase.expected) { + t.Fatalf("test #%d: query returned incorrect set of "+ + "invoices: expcted %v, got %v", i, + spew.Sdump(response.Invoices), + spew.Sdump(testCase.expected)) } } }