clawbot
e161343eac
check / check (push) Waiting to run
In the Dockerfile test phase, internal/vaultik spent 23.6s of 31.9s in 36 tests run one at a time. 24 of them were serial only because they call log.Initialize; they now call it before t.Parallel(), so the logger is replaced before any parallel test runs. The 12 still serial change the umask, TMPDIR, os.Stderr or time.Local. TestLargeDatasets took 8.4s of the 9.8s internal/database run by committing each of its 1,500 inserts on its own; it now makes them in one transaction. TestDedupOnlySnapshotRestores gives its second backup its own snapshot name instead of sleeping 1.1s for a new snapshot ID. Model: opus-5-5
79 lines
2.6 KiB
Go
79 lines
2.6 KiB
Go
package vaultik //nolint:testpackage // exercises unexported count helpers
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"sneak.berlin/go/vaultik/internal/database"
|
|
"sneak.berlin/go/vaultik/internal/log"
|
|
)
|
|
|
|
// TestTableCountForReportSurfacesReadFailure is the regression guard for
|
|
// the discarded-error bug: getTableCount for a table its query cannot
|
|
// resolve must not silently become 0. A count that could not be read is
|
|
// reported as unknown, which a reader can tell apart from an empty table.
|
|
func TestTableCountForReportSurfacesReadFailure(t *testing.T) {
|
|
log.Initialize(log.Config{})
|
|
t.Parallel()
|
|
|
|
ctx := context.Background()
|
|
|
|
db, err := database.New(ctx, ":memory:")
|
|
require.NoError(t, err)
|
|
t.Cleanup(func() { _ = db.Close() })
|
|
|
|
v := &Vaultik{DB: db}
|
|
v.SetContext(ctx)
|
|
|
|
// A table present in the schema reads as a real count.
|
|
blobs := v.tableCountForReport("blobs")
|
|
require.NotNil(t, blobs, "an existing table must read as a real count")
|
|
assert.Equal(t, int64(0), *blobs)
|
|
|
|
// A syntactically valid name the sanitizer accepts but whose table
|
|
// the query cannot resolve is the exact shape #96 describes: a
|
|
// would-be loud failure that used to be discarded into a 0.
|
|
_, err = v.getTableCount("snapshots_missing")
|
|
require.Error(t, err, "a query against a nonexistent table must fail")
|
|
|
|
missing := v.tableCountForReport("snapshots_missing")
|
|
assert.Nil(t, missing, "a failed read is unknown, not a count")
|
|
|
|
// The rendered count for a failed read must say unknown, never 0.
|
|
assert.Equal(t, countUnknown, countText(missing))
|
|
assert.NotEqual(t, "0", countText(missing))
|
|
}
|
|
|
|
// TestCountTextDistinguishesEmptyFromUnknown pins the distinction the
|
|
// output has to preserve: 0 means the table was empty, "unknown" means
|
|
// the count could not be read.
|
|
func TestCountTextDistinguishesEmptyFromUnknown(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
zero := int64(0)
|
|
seven := int64(7)
|
|
|
|
assert.Equal(t, "0", countText(&zero))
|
|
assert.Equal(t, "7", countText(&seven))
|
|
assert.Equal(t, countUnknown, countText(nil))
|
|
}
|
|
|
|
// TestCountDiffUnknownWhenEitherSideUnknown checks that a delta computed
|
|
// from an unreadable count is itself unknown rather than a plausible
|
|
// number.
|
|
func TestCountDiffUnknownWhenEitherSideUnknown(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
before := int64(10)
|
|
after := int64(3)
|
|
|
|
require.NotNil(t, countDiff(&before, &after))
|
|
assert.Equal(t, int64(7), *countDiff(&before, &after))
|
|
|
|
assert.Nil(t, countDiff(nil, &after), "unknown before yields unknown delta")
|
|
assert.Nil(t, countDiff(&before, nil), "unknown after yields unknown delta")
|
|
assert.Nil(t, countDiff(nil, nil))
|
|
}
|