channeldb: refactor payments code

Go-fmt files. Refactored code according to the guidelines.
Enhanced payment test: add error checking
and individual context for each API call.
Add Timestamp field to payment struct.

channeldb/payments_test.go

@@ -1,20 +1,20 @@
 package channeldb
 
 import (
-	"testing"
-	"time"
-	"github.com/roasbeef/btcutil"
 	"bytes"
-	"reflect"
-	"github.com/davecgh/go-spew/spew"
-	"math/rand"
 	"fmt"
 	"github.com/btcsuite/fastsha256"
+	"github.com/davecgh/go-spew/spew"
+	"github.com/roasbeef/btcutil"
+	"math/rand"
+	"reflect"
+	"testing"
+	"time"
 )
 
 func makeFakePayment() *OutgoingPayment {
-	// Create a fake invoice which we'll use several times in the tests
-	// below.
+	// Create a fake invoice which
+	// we'll use several times in the tests below.
 	fakeInvoice := &Invoice{
 		CreationDate: time.Now(),
 	}
@@ -23,63 +23,84 @@ func makeFakePayment() *OutgoingPayment {
 	copy(fakeInvoice.Terms.PaymentPreimage[:], rev[:])
 	fakeInvoice.Terms.Value = btcutil.Amount(10000)
 	// Make fake path
-	fakePath := make([][]byte, 3)
-	for i:=0; i<3; i++ {
-		fakePath[i] = make([]byte, 33)
-		for j:=0; j<33; j++ {
+	fakePath := make([][33]byte, 3)
+	for i := 0; i < 3; i++ {
+		for j := 0; j < 33; j++ {
 			fakePath[i][j] = byte(i)
 		}
 	}
 	var rHash [32]byte = fastsha256.Sum256(rev[:])
-	fakePayment := & OutgoingPayment{
-		Invoice: *fakeInvoice,
-		Fee: 101,
-		Path: fakePath,
+	fakePayment := &OutgoingPayment{
+		Invoice:        *fakeInvoice,
+		Fee:            101,
+		Path:           fakePath,
 		TimeLockLength: 1000,
-		RHash: rHash,
+		RHash:          rHash,
+		Timestamp:      time.Unix(100000, 0),
 	}
 	return fakePayment
 }
 
 // randomBytes creates random []byte with length
 // in range [minLen, maxLen)
-func randomBytes(minLen, maxLen int) []byte {
+func randomBytes(minLen, maxLen int) ([]byte, error) {
 	l := minLen + rand.Intn(maxLen-minLen)
 	b := make([]byte, l)
 	_, err := rand.Read(b)
 	if err != nil {
-		panic(fmt.Sprintf("Internal error. Cannot generate random string: %v", err))
+		return nil, fmt.Errorf("Internal error. "+
+			"Cannot generate random string: %v", err)
 	}
-	return b
+	return b, nil
 }
 
-func makeRandomFakePayment() *OutgoingPayment {
-	// Create a fake invoice which we'll use several times in the tests
-	// below.
+func makeRandomFakePayment() (*OutgoingPayment, error) {
+	var err error
 	fakeInvoice := &Invoice{
 		CreationDate: time.Now(),
 	}
-	fakeInvoice.Memo = randomBytes(1, 50)
-	fakeInvoice.Receipt = randomBytes(1, 50)
-	copy(fakeInvoice.Terms.PaymentPreimage[:], randomBytes(32, 33))
+
+	fakeInvoice.Memo, err = randomBytes(1, 50)
+	if err != nil {
+		return nil, err
+	}
+
+	fakeInvoice.Receipt, err = randomBytes(1, 50)
+	if err != nil {
+		return nil, err
+	}
+
+	preImg, err := randomBytes(32, 33)
+	if err != nil {
+		return nil, err
+	}
+	copy(fakeInvoice.Terms.PaymentPreimage[:], preImg)
+
 	fakeInvoice.Terms.Value = btcutil.Amount(rand.Intn(10000))
+
 	// Make fake path
 	fakePathLen := 1 + rand.Intn(5)
-	fakePath := make([][]byte, fakePathLen)
-	for i:=0; i<fakePathLen; i++ {
-		fakePath[i] = randomBytes(33, 34)
+	fakePath := make([][33]byte, fakePathLen)
+	for i := 0; i < fakePathLen; i++ {
+		b, err := randomBytes(33, 34)
+		if err != nil {
+			return nil, err
+		}
+		copy(fakePath[i][:], b)
 	}
+
 	var rHash [32]byte = fastsha256.Sum256(
 		fakeInvoice.Terms.PaymentPreimage[:],
 	)
-	fakePayment := & OutgoingPayment{
-		Invoice: *fakeInvoice,
-		Fee: btcutil.Amount(rand.Intn(1001)),
-		Path: fakePath,
-		TimeLockLength: uint64(rand.Intn(10000)),
-		RHash: rHash,
+	fakePayment := &OutgoingPayment{
+		Invoice:        *fakeInvoice,
+		Fee:            btcutil.Amount(rand.Intn(1001)),
+		Path:           fakePath,
+		TimeLockLength: uint32(rand.Intn(10000)),
+		RHash:          rHash,
+		Timestamp:      time.Unix(rand.Int63n(10000), 0),
 	}
-	return fakePayment
+	return fakePayment, nil
 }
 
 func TestOutgoingPaymentSerialization(t *testing.T) {
@@ -89,12 +110,15 @@ func TestOutgoingPaymentSerialization(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Can't serialize outgoing payment: %v", err)
 	}
+
 	newPayment, err := deserializeOutgoingPayment(b)
 	if err != nil {
 		t.Fatalf("Can't deserialize outgoing payment: %v", err)
 	}
+
 	if !reflect.DeepEqual(fakePayment, newPayment) {
-		t.Fatalf("Payments do not match after serialization/deserialization %v vs %v",
+		t.Fatalf("Payments do not match after "+
+			"serialization/deserialization %v vs %v",
 			spew.Sdump(fakePayment),
 			spew.Sdump(newPayment),
 		)
@@ -128,18 +152,23 @@ func TestOutgoingPaymentWorkflow(t *testing.T) {
 	}
 
 	// Make some random payments
-	for i:=0; i<5; i++ {
-		randomPayment := makeRandomFakePayment()
-		err := db.AddPayment(randomPayment)
+	for i := 0; i < 5; i++ {
+		randomPayment, err := makeRandomFakePayment()
+		if err != nil {
+			t.Fatalf("Internal error in tests: %v", err)
+		}
+		err = db.AddPayment(randomPayment)
 		if err != nil {
 			t.Fatalf("Can't put payment in DB: %v", err)
 		}
 		correctPayments = append(correctPayments, randomPayment)
 	}
+
 	payments, err = db.FetchAllPayments()
 	if err != nil {
 		t.Fatalf("Can't get payments from DB: %v", err)
 	}
+
 	if !reflect.DeepEqual(payments, correctPayments) {
 		t.Fatalf("Wrong payments after reading from DB."+
 			"Got %v, want %v",
@@ -153,11 +182,14 @@ func TestOutgoingPaymentWorkflow(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Can't delete payments from DB: %v", err)
 	}
+
+	// Check that there is no payments after deletion
 	paymentsAfterDeletion, err := db.FetchAllPayments()
 	if err != nil {
 		t.Fatalf("Can't get payments after deletion: %v", err)
 	}
 	if len(paymentsAfterDeletion) != 0 {
-		t.Fatalf("After deletion DB has %v payments, want %v", len(paymentsAfterDeletion), 0)
+		t.Fatalf("After deletion DB has %v payments, want %v",
+			len(paymentsAfterDeletion), 0)
 	}
 }