test(badgerd): expand options, dns adapters, and item coverage

Signed-off-by: Adphi <philippe.adrien.nousse@gmail.com>

Author: Adphi

internal/badgerd/db_test.go

@@ -0,0 +1,22 @@
+package badgerd
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestOpenInMemoryAndCloseIdempotent(t *testing.T) {
+	dbi, err := Open(context.Background(), WithInMemory(true))
+	require.NoError(t, err)
+	db := dbi.(*db)
+
+	assert.True(t, db.InMemory())
+	assert.Equal(t, "", db.Path())
+	assert.False(t, db.Replicated())
+
+	require.NoError(t, db.Close())
+	require.NoError(t, db.Close())
+}

internal/badgerd/dns/godns/resolver_test.go

@@ -0,0 +1,19 @@
+package godns
+
+import (
+	"net"
+	"testing"
+
+	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestResolverIsNotFoundTable(t *testing.T) {
+	r := &Resolver{}
+
+	assert.False(t, r.IsNotFound(nil))
+	assert.True(t, r.IsNotFound(&net.DNSError{IsNotFound: true}))
+	assert.False(t, r.IsNotFound(&net.DNSError{IsNotFound: false}))
+	assert.True(t, r.IsNotFound(errors.Wrap(&net.DNSError{IsNotFound: true}, "wrapped")))
+	assert.False(t, r.IsNotFound(errors.New("other")))
+}

internal/badgerd/dns/miekgdns/resolver_test.go

@@ -0,0 +1,35 @@
+package miekgdns
+
+import (
+	"testing"
+
+	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestResolverLookupRecursionLimitTable(t *testing.T) {
+	r := &Resolver{}
+
+	_, _, err := r.lookupSRV("", "", "example.org", 9, 8)
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "maximum number of recursive iterations reached")
+
+	_, err = r.lookupIPAddr("example.org", 9, 8)
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "maximum number of recursive iterations reached")
+}
+
+func TestResolverIsNotFoundTable(t *testing.T) {
+	r := &Resolver{}
+
+	assert.False(t, r.IsNotFound(nil))
+	assert.True(t, r.IsNotFound(ErrNoSuchHost))
+	assert.True(t, r.IsNotFound(errors.Wrap(ErrNoSuchHost, "wrapped")))
+	assert.False(t, r.IsNotFound(errors.New("other")))
+}
+
+func TestFmtErrsJoinsAllErrors(t *testing.T) {
+	got := fmtErrs([]error{errors.New("a"), errors.New("b")})
+	assert.Equal(t, ";a;b", got)
+}

internal/badgerd/options_test.go

@@ -0,0 +1,53 @@
+package badgerd
+
+import (
+	"testing"
+
+	"github.com/dgraph-io/badger/v3"
+	"github.com/stretchr/testify/assert"
+)
+
+type testLogger struct{}
+
+func (testLogger) Errorf(string, ...any)   {}
+func (testLogger) Warningf(string, ...any) {}
+func (testLogger) Infof(string, ...any)    {}
+func (testLogger) Debugf(string, ...any)   {}
+func (testLogger) Tracef(string, ...any)   {}
+
+func TestWithPathTable(t *testing.T) {
+	o := options{}
+	WithPath(":memory:")(&o)
+	assert.True(t, o.inMemory)
+	assert.Equal(t, "", o.path)
+
+	o = options{}
+	WithPath("/tmp/pdb")(&o)
+	assert.False(t, o.inMemory)
+	assert.Equal(t, "/tmp/pdb", o.path)
+}
+
+func TestWithInMemoryTable(t *testing.T) {
+	o := options{path: "/tmp/pdb"}
+	WithInMemory(true)(&o)
+	assert.True(t, o.inMemory)
+	assert.Equal(t, "", o.path)
+
+	WithInMemory(false)(&o)
+	assert.False(t, o.inMemory)
+	assert.Equal(t, "", o.path)
+}
+
+func TestOptionsBuildAppliesBadgerOptionsFunc(t *testing.T) {
+	o := options{inMemory: true, logger: testLogger{}}
+	WithBadgerOptionsFunc(func(opts badger.Options) badger.Options {
+		opts.SyncWrites = false
+		opts.NumMemtables = 7
+		return opts
+	})(&o)
+
+	b := o.build()
+	assert.True(t, b.InMemory)
+	assert.False(t, b.SyncWrites)
+	assert.Equal(t, 7, b.NumMemtables)
+}

internal/badgerd/pending/item_test.go

@@ -0,0 +1,41 @@
+package pending
+
+import (
+	"testing"
+	"time"
+
+	"github.com/dgraph-io/badger/v3"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestItemIsDeletedOrExpiredTable(t *testing.T) {
+	now := uint64(time.Now().Unix())
+
+	tests := []struct {
+		name string
+		e    *badger.Entry
+		want bool
+	}{
+		{name: "deleted", e: &badger.Entry{UserMeta: BitDelete}, want: true},
+		{name: "no_expiry", e: &badger.Entry{ExpiresAt: 0}, want: false},
+		{name: "future_expiry", e: &badger.Entry{ExpiresAt: now + 2}, want: false},
+		{name: "past_expiry", e: &badger.Entry{ExpiresAt: now - 2}, want: true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			i := &item{e: tt.e}
+			assert.Equal(t, tt.want, i.IsDeletedOrExpired())
+		})
+	}
+}
+
+func TestItemValueCopyIsSafeCopy(t *testing.T) {
+	i := &item{e: &badger.Entry{Value: []byte("abc")}}
+	b, err := i.ValueCopy(nil)
+	require.NoError(t, err)
+	require.Equal(t, []byte("abc"), b)
+	b[0] = 'z'
+	assert.Equal(t, []byte("abc"), i.e.Value)
+}