filterdb: lint and modernize the pkg

Lint the files and update the tests to use the `require` package.

Author: ellemouton

filterdb/db.go

@@ -18,9 +18,13 @@ var (
 
 	// regBucket is the bucket that stores the regular filters.
 	regBucket = []byte("regular")
+
+	// ErrFilterNotFound is returned when a filter for a target block hash
+	// is unable to be located.
+	ErrFilterNotFound = fmt.Errorf("unable to find filter")
 )
 
-// FilterType is a enum-like type that represents the various filter types
+// FilterType is an enum-like type that represents the various filter types
 // currently defined.
 type FilterType uint8
 
@@ -30,15 +34,9 @@ const (
 	RegularFilter FilterType = iota
 )
 
-var (
-	// ErrFilterNotFound is returned when a filter for a target block hash is
-	// unable to be located.
-	ErrFilterNotFound = fmt.Errorf("unable to find filter")
-)
-
 // FilterDatabase is an interface which represents an object that is capable of
-// storing and retrieving filters according to their corresponding block hash and
-// also their filter type.
+// storing and retrieving filters according to their corresponding block hash
+// and also their filter type.
 //
 // TODO(roasbeef): similar interface for headerfs?
 type FilterDatabase interface {
@@ -52,7 +50,8 @@ type FilterDatabase interface {
 	// returned.
 	FetchFilter(*chainhash.Hash, FilterType) (*gcs.Filter, error)
 
-	// PurgeFilters purge all filters with a given type from persistent storage.
+	// PurgeFilters purge all filters with a given type from persistent
+	// storage.
 	PurgeFilters(FilterType) error
 }
 
@@ -117,10 +116,13 @@ func (f *FilterStore) PurgeFilters(fType FilterType) error {
 
 		switch fType {
 		case RegularFilter:
-			if err := filters.DeleteNestedBucket(regBucket); err != nil {
+			err := filters.DeleteNestedBucket(regBucket)
+			if err != nil {
 				return err
 			}
-			if _, err := filters.CreateBucket(regBucket); err != nil {
+
+			_, err = filters.CreateBucket(regBucket)
+			if err != nil {
 				return err
 			}
 		default:

filterdb/db_test.go

@@ -1,10 +1,7 @@
 package filterdb
 
 import (
-	"io/ioutil"
 	"math/rand"
-	"os"
-	"reflect"
 	"testing"
 	"time"
 
@@ -14,116 +11,87 @@ import (
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcwallet/walletdb"
 	_ "github.com/btcsuite/btcwallet/walletdb/bdb"
+	"github.com/stretchr/testify/require"
 )
 
-func createTestDatabase() (func(), FilterDatabase, error) {
-	tempDir, err := ioutil.TempDir("", "neutrino")
-	if err != nil {
-		return nil, nil, err
-	}
+func createTestDatabase(t *testing.T) FilterDatabase {
+	tempDir := t.TempDir()
 
 	db, err := walletdb.Create(
 		"bdb", tempDir+"/test.db", true, time.Second*10,
 	)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	cleanUp := func() {
-		os.RemoveAll(tempDir)
-		db.Close()
-	}
+	require.NoError(t, err)
+	t.Cleanup(func() {
+		require.NoError(t, db.Close())
+	})
 
 	filterDB, err := New(db, chaincfg.SimNetParams)
-	if err != nil {
-		return nil, nil, err
-	}
+	require.NoError(t, err)
 
-	return cleanUp, filterDB, nil
+	return filterDB
 }
 
+// TestGenesisFilterCreation tests the fetching of the genesis block filter.
 func TestGenesisFilterCreation(t *testing.T) {
-	cleanUp, database, err := createTestDatabase()
-	defer cleanUp()
-	if err != nil {
-		t.Fatalf("unable to create test db: %v", err)
-	}
-
-	genesisHash := chaincfg.SimNetParams.GenesisHash
+	var (
+		database    = createTestDatabase(t)
+		genesisHash = chaincfg.SimNetParams.GenesisHash
+	)
 
 	// With the database initialized, we should be able to fetch the
 	// regular filter for the genesis block.
-	regGenesisFilter, err := database.FetchFilter(genesisHash, RegularFilter)
-	if err != nil {
-		t.Fatalf("unable to fetch regular genesis filter: %v", err)
-	}
+	regGenesisFilter, err := database.FetchFilter(
+		genesisHash, RegularFilter,
+	)
+	require.NoError(t, err)
 
 	// The regular filter should be non-nil as the gensis block's output
 	// and the coinbase txid should be indexed.
-	if regGenesisFilter == nil {
-		t.Fatalf("regular genesis filter is nil")
-	}
+	require.NotNil(t, regGenesisFilter)
 }
 
-func genRandFilter(numElements uint32) (*gcs.Filter, error) {
+func genRandFilter(t *testing.T, numElements uint32) *gcs.Filter {
 	elements := make([][]byte, numElements)
 	for i := uint32(0); i < numElements; i++ {
 		var elem [20]byte
-		if _, err := rand.Read(elem[:]); err != nil {
-			return nil, err
-		}
+		_, err := rand.Read(elem[:])
+		require.NoError(t, err)
 
 		elements[i] = elem[:]
 	}
 
 	var key [16]byte
-	if _, err := rand.Read(key[:]); err != nil {
-		return nil, err
-	}
+	_, err := rand.Read(key[:])
+	require.NoError(t, err)
 
 	filter, err := gcs.BuildGCSFilter(
 		builder.DefaultP, builder.DefaultM, key, elements,
 	)
-	if err != nil {
-		return nil, err
-	}
+	require.NoError(t, err)
 
-	return filter, nil
+	return filter
 }
 
+// TestFilterStorage test writing to and reading from the filter DB.
 func TestFilterStorage(t *testing.T) {
-	// TODO(roasbeef): use testing.Quick
-	cleanUp, database, err := createTestDatabase()
-	defer cleanUp()
-	if err != nil {
-		t.Fatalf("unable to create test db: %v", err)
-	}
+	database := createTestDatabase(t)
 
 	// We'll generate a random block hash to create our test filters
 	// against.
 	var randHash chainhash.Hash
-	if _, err := rand.Read(randHash[:]); err != nil {
-		t.Fatalf("unable to generate random hash: %v", err)
-	}
+	_, err := rand.Read(randHash[:])
+	require.NoError(t, err)
 
-	// First, we'll create and store a random fitler for the regular filter
+	// First, we'll create and store a random filter for the regular filter
 	// type for the block hash generate above.
-	regFilter, err := genRandFilter(100)
-	if err != nil {
-		t.Fatalf("unable to create random filter: %v", err)
-	}
+	regFilter := genRandFilter(t, 100)
+
 	err = database.PutFilter(&randHash, regFilter, RegularFilter)
-	if err != nil {
-		t.Fatalf("unable to store regular filter: %v", err)
-	}
+	require.NoError(t, err)
 
 	// With the filter stored, we should be able to retrieve the filter
 	// without any issue, and it should match the stored filter exactly.
 	regFilterDB, err := database.FetchFilter(&randHash, RegularFilter)
-	if err != nil {
-		t.Fatalf("unable to retrieve reg filter: %v", err)
-	}
-	if !reflect.DeepEqual(regFilter, regFilterDB) {
-		t.Fatalf("regular filter doesn't match!")
-	}
+	require.NoError(t, err)
+	require.Equal(t, regFilter, regFilterDB)
 }