Some difficulty with BadgerDB

main_test.go

package main

import (
	"fmt"
	"io"
	"io/ioutil"
	"log"
	"os"
	"testing"

	"github.com/dgraph-io/badger"
)

func TestBadger(t *testing.T) {
	dir, err := ioutil.TempDir("", "test-badger")
	if err != nil {
		t.Fatal(err)
	}
	defer os.RemoveAll(dir)
	var created byte
	func() {
		db, err := badger.Open(badger.DefaultOptions(dir))
		if err != nil {
			t.Fatal(err)
		}
		defer db.Close()
		// The following line must be included for the bug to occur. Notice the
		// sequence is neither used nor released: just creating it triggers the bug.
		db.GetSequence([]byte{0}, 1)
		created, err = CreateOne(db)
		if err != nil {
			t.Fatal(err)
		} else if created != 1 {
			t.Error("want 1, got", created)
		}
		// Here we verify that the previous update was effective by counting the
		// resulting keys. There should be exactly one.
		got, err := CountAll(db)
		Dump(db, os.Stderr)
		if err != nil {
			t.Fatal(err)
		} else if got != 1 {
			t.Errorf("want 1, got %v", got)
		}
		db.Sync()
	}()
	func() {
		db, err := badger.Open(badger.DefaultOptions(dir))
		if err != nil {
			t.Fatal(err)
		}
		defer db.Close()
		got, err := CountAll(db)
		Dump(db, os.Stderr)
		if err != nil {
			t.Fatal(err)
		} else if got != 1 {
			t.Errorf("want 1, got %v", got)
		}
	}()
}

func KeyForTest() []byte { return []byte{0, 0, 1} }

func CreateOne(db *badger.DB) (byte, error) {
	txn := db.NewTransaction(true)
	defer txn.Discard()
	key := KeyForTest()
	if err := txn.Set(key, []byte("42")); err != nil {
		return 0, err
	}
	if err := txn.Commit(); err != nil {
		return 0, err
	}
	log.Println("CreateOne: committed the transaction")
	return 1, nil
}

func CountAll(db *badger.DB) (int, error) {
	txn := db.NewTransaction(false)
	defer txn.Discard()
	prefix := KeyForTest()[:2]
	opts := badger.DefaultIteratorOptions
	opts.Prefix = prefix
	iter := txn.NewIterator(opts)
	defer iter.Close()
	bstart := append(prefix, 1)
	count := 0
	for iter.Seek(bstart); iter.Valid(); iter.Next() {
		count++
	}
	log.Println("CountAll: found", count)
	return count, nil
}

func Dump(db *badger.DB, w io.Writer) {
	txn := db.NewTransaction(false)
	defer txn.Discard()
	opts := badger.DefaultIteratorOptions
	iter := txn.NewIterator(opts)
	defer iter.Close()
	count := 0
	for iter.Seek([]byte{0}); iter.Valid(); iter.Next() {
		item := iter.Item()
		key := item.Key()
		value, err := item.ValueCopy(nil)
		if err != nil {
			fmt.Fprintf(w, "%x\t%v", key, err)
			break
		}
		fmt.Fprintf(w, "%x\t%x\n", key, value)
		count++
	}
	fmt.Fprintf(w, "%v keys\n", count)
}

output.txt

$ go test
badger 2019/08/17 13:38:04 INFO: All 0 tables opened in 0s
2019/08/17 13:38:04 CreateOne: committed the transaction
2019/08/17 13:38:04 CountAll: found 1
00	0000000000000001
000001	3432
2 keys
badger 2019/08/17 13:38:04 DEBUG: Storing value log head: {Fid:0 Len:29 Offset:77}
badger 2019/08/17 13:38:04 INFO: Got compaction priority: {level:0 score:1.73 dropPrefix:[]}
badger 2019/08/17 13:38:04 INFO: Running for level: 0
badger 2019/08/17 13:38:04 DEBUG: LOG Compact. Added 3 keys. Skipped 0 keys. Iteration took: 86.018µs
badger 2019/08/17 13:38:04 DEBUG: Discard stats: map[]
badger 2019/08/17 13:38:04 INFO: LOG Compact 0->1, del 1 tables, add 1 tables, took 8.128421ms
badger 2019/08/17 13:38:04 INFO: Compaction for level: 0 DONE
badger 2019/08/17 13:38:04 INFO: Force compaction on level 0 done
badger 2019/08/17 13:38:04 INFO: All 1 tables opened in 0s
badger 2019/08/17 13:38:04 INFO: Replaying file id: 0 at offset: 106
badger 2019/08/17 13:38:04 INFO: Replay took: 9.945µs
badger 2019/08/17 13:38:04 DEBUG: Value log discard stats empty
2019/08/17 13:38:04 CountAll: found 0
00	0000000000000001
000001	3432
2 keys
badger 2019/08/17 13:38:04 INFO: Got compaction priority: {level:0 score:1.73 dropPrefix:[]}
--- FAIL: TestBadger (0.08s)
    main_test.go:58: want 1, got 0
FAIL
exit status 1