diff --git a/server/storage/backend/backend_test.go b/server/storage/backend/backend_test.go index fc024b88bc1f..e53d1ac73d11 100644 --- a/server/storage/backend/backend_test.go +++ b/server/storage/backend/backend_test.go @@ -37,10 +37,7 @@ func TestBackendClose(t *testing.T) { // check close could work done := make(chan struct{}, 1) go func() { - err := b.Close() - if err != nil { - t.Errorf("close error = %v, want nil", err) - } + assert.NoErrorf(t, b.Close(), "close error") done <- struct{}{} }() select { @@ -63,14 +60,11 @@ func TestBackendSnapshot(t *testing.T) { // write snapshot to a new file f, err := os.CreateTemp(t.TempDir(), "etcd_backend_test") - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) snap := b.Snapshot() defer func() { assert.NoError(t, snap.Close()) }() - if _, err := snap.WriteTo(f); err != nil { - t.Fatal(err) - } + _, err = snap.WriteTo(f) + require.NoError(t, err) require.NoError(t, f.Close()) // bootstrap new backend from the snapshot @@ -82,9 +76,7 @@ func TestBackendSnapshot(t *testing.T) { newTx := nb.BatchTx() newTx.Lock() ks, _ := newTx.UnsafeRange(schema.Test, []byte("foo"), []byte("goo"), 0) - if len(ks) != 1 { - t.Errorf("len(kvs) = %d, want 1", len(ks)) - } + assert.Lenf(t, ks, 1, "len(kvs) = %d, want 1", len(ks)) newTx.Unlock() } @@ -116,10 +108,7 @@ func TestBackendBatchIntervalCommit(t *testing.T) { t.Errorf("bucket test does not exit") return nil } - v := bucket.Get([]byte("foo")) - if v == nil { - t.Errorf("foo key failed to written in backend") - } + assert.NotNilf(t, bucket.Get([]byte("foo")), "foo key failed to written in backend") return nil })) } @@ -160,31 +149,18 @@ func TestBackendDefrag(t *testing.T) { // shrink and check hash oh, err := b.Hash(nil) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) - err = b.Defrag() - if err != nil { - t.Fatal(err) - } + require.NoError(t, b.Defrag()) nh, err := b.Hash(nil) - if err != nil { - t.Fatal(err) - } - if oh != nh { - t.Errorf("hash = %v, want %v", nh, oh) - } + require.NoError(t, err) + assert.Equalf(t, oh, nh, "hash = %v, want %v", nh, oh) nsize := b.Size() - if nsize >= size { - t.Errorf("new size = %v, want < %d", nsize, size) - } + assert.Lessf(t, nsize, size, "new size = %v, want < %d", nsize, size) db := backend.DbFromBackendForTest(b) - if db.FreelistType != bcfg.BackendFreelistType { - t.Errorf("db FreelistType = [%v], want [%v]", db.FreelistType, bcfg.BackendFreelistType) - } + assert.Equalf(t, db.FreelistType, bcfg.BackendFreelistType, "db FreelistType = [%v], want [%v]", db.FreelistType, bcfg.BackendFreelistType) // try put more keys after shrink. tx = b.BatchTx() @@ -345,7 +321,5 @@ func TestBackendWritebackForEach(t *testing.T) { require.NoError(t, tx.UnsafeForEach(schema.Key, getSeq)) tx.Unlock() - if seq != partialSeq { - t.Fatalf("expected %q, got %q", seq, partialSeq) - } + require.Equalf(t, seq, partialSeq, "expected %q, got %q", seq, partialSeq) } diff --git a/server/storage/backend/batch_tx_test.go b/server/storage/backend/batch_tx_test.go index 279f199a5dbd..dbd027a602c9 100644 --- a/server/storage/backend/batch_tx_test.go +++ b/server/storage/backend/batch_tx_test.go @@ -22,6 +22,7 @@ import ( "time" "github.com/google/go-cmp/cmp" + "github.com/stretchr/testify/assert" bolt "go.etcd.io/bbolt" "go.etcd.io/etcd/server/v3/storage/backend" @@ -51,9 +52,7 @@ func TestBatchTxPut(t *testing.T) { tx.Lock() _, gv := tx.UnsafeRange(schema.Test, []byte("foo"), nil, 0) tx.Unlock() - if !reflect.DeepEqual(gv[0], v) { - t.Errorf("v = %s, want %s", gv[0], v) - } + assert.Truef(t, reflect.DeepEqual(gv[0], v), "v = %s, want %s", gv[0], v) tx.Commit() } } @@ -120,12 +119,8 @@ func TestBatchTxRange(t *testing.T) { } for i, tt := range tests { keys, vals := tx.UnsafeRange(schema.Test, tt.key, tt.endKey, tt.limit) - if !reflect.DeepEqual(keys, tt.wkeys) { - t.Errorf("#%d: keys = %+v, want %+v", i, keys, tt.wkeys) - } - if !reflect.DeepEqual(vals, tt.wvals) { - t.Errorf("#%d: vals = %+v, want %+v", i, vals, tt.wvals) - } + assert.Truef(t, reflect.DeepEqual(keys, tt.wkeys), "#%d: keys = %+v, want %+v", i, keys, tt.wkeys) + assert.Truef(t, reflect.DeepEqual(vals, tt.wvals), "#%d: vals = %+v, want %+v", i, vals, tt.wvals) } } @@ -148,9 +143,7 @@ func TestBatchTxDelete(t *testing.T) { tx.Lock() ks, _ := tx.UnsafeRange(schema.Test, []byte("foo"), nil, 0) tx.Unlock() - if len(ks) != 0 { - t.Errorf("keys on foo = %v, want nil", ks) - } + assert.Emptyf(t, ks, "keys on foo = %v, want nil", ks) tx.Commit() } } @@ -174,10 +167,7 @@ func TestBatchTxCommit(t *testing.T) { t.Errorf("bucket test does not exit") return nil } - v := bucket.Get([]byte("foo")) - if v == nil { - t.Errorf("foo key failed to written in backend") - } + assert.NotNilf(t, bucket.Get([]byte("foo")), "foo key failed to written in backend") return nil }) } @@ -202,10 +192,7 @@ func TestBatchTxBatchLimitCommit(t *testing.T) { t.Errorf("bucket test does not exit") return nil } - v := bucket.Get([]byte("foo")) - if v == nil { - t.Errorf("foo key failed to written in backend") - } + assert.NotNilf(t, bucket.Get([]byte("foo")), "foo key failed to written in backend") return nil }) } diff --git a/server/storage/backend/verify_test.go b/server/storage/backend/verify_test.go index 1a0b571cc3f9..c39a07f8cfe3 100644 --- a/server/storage/backend/verify_test.go +++ b/server/storage/backend/verify_test.go @@ -18,6 +18,8 @@ import ( "testing" "time" + "github.com/stretchr/testify/assert" + "go.etcd.io/etcd/client/pkg/v3/verify" "go.etcd.io/etcd/server/v3/storage/backend" betesting "go.etcd.io/etcd/server/v3/storage/backend/testing" @@ -83,9 +85,7 @@ func TestLockVerify(t *testing.T) { tc.lock(be.BatchTx()) } }) != nil - if hasPaniced != tc.expectPanic { - t.Errorf("%v != %v", hasPaniced, tc.expectPanic) - } + assert.Equalf(t, hasPaniced, tc.expectPanic, "%v != %v", hasPaniced, tc.expectPanic) }) } } diff --git a/server/storage/mvcc/hash_test.go b/server/storage/mvcc/hash_test.go index 9555293aaa9d..0156ef43c4e6 100644 --- a/server/storage/mvcc/hash_test.go +++ b/server/storage/mvcc/hash_test.go @@ -192,18 +192,10 @@ func TestHasherStore(t *testing.T) { for _, want := range hashes { got, _, err := s.HashByRev(want.Revision) - if err != nil { - t.Fatal(err) - } - if want.Hash != got.Hash { - t.Errorf("Expected stored hash to match, got: %d, expected: %d", want.Hash, got.Hash) - } - if want.Revision != got.Revision { - t.Errorf("Expected stored revision to match, got: %d, expected: %d", want.Revision, got.Revision) - } - if want.CompactRevision != got.CompactRevision { - t.Errorf("Expected stored compact revision to match, got: %d, expected: %d", want.CompactRevision, got.CompactRevision) - } + require.NoError(t, err) + assert.Equalf(t, want.Hash, got.Hash, "Expected stored hash to match, got: %d, expected: %d", want.Hash, got.Hash) + assert.Equalf(t, want.Revision, got.Revision, "Expected stored revision to match, got: %d, expected: %d", want.Revision, got.Revision) + assert.Equalf(t, want.CompactRevision, got.CompactRevision, "Expected stored compact revision to match, got: %d, expected: %d", want.CompactRevision, got.CompactRevision) } } @@ -222,13 +214,9 @@ func TestHasherStoreFull(t *testing.T) { // Hash for old revision should be discarded as storage is already full s.Store(KeyValueHash{Revision: minRevision - 1}) hash, _, err := s.HashByRev(minRevision - 1) - if err == nil { - t.Errorf("Expected an error as old revision should be discarded, got: %v", hash) - } + require.Errorf(t, err, "Expected an error as old revision should be discarded, got: %v", hash) // Hash for new revision should be stored even when storage is full s.Store(KeyValueHash{Revision: maxRevision + 1}) _, _, err = s.HashByRev(maxRevision + 1) - if err != nil { - t.Errorf("Didn't expect error for new revision, err: %v", err) - } + assert.NoErrorf(t, err, "Didn't expect error for new revision, err: %v", err) } diff --git a/server/storage/mvcc/index_test.go b/server/storage/mvcc/index_test.go index d7f32fded2d8..e374135fbe88 100644 --- a/server/storage/mvcc/index_test.go +++ b/server/storage/mvcc/index_test.go @@ -15,10 +15,10 @@ package mvcc import ( - "errors" "reflect" "testing" + "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "go.uber.org/zap/zaptest" ) @@ -47,18 +47,10 @@ func TestIndexGet(t *testing.T) { } for i, tt := range tests { rev, created, ver, err := ti.Get([]byte("foo"), tt.rev) - if !errors.Is(err, tt.werr) { - t.Errorf("#%d: err = %v, want %v", i, err, tt.werr) - } - if rev != tt.wrev { - t.Errorf("#%d: rev = %+v, want %+v", i, rev, tt.wrev) - } - if created != tt.wcreated { - t.Errorf("#%d: created = %+v, want %+v", i, created, tt.wcreated) - } - if ver != tt.wver { - t.Errorf("#%d: ver = %d, want %d", i, ver, tt.wver) - } + require.ErrorIsf(t, err, tt.werr, "#%d: err = %v, want %v", i, err, tt.werr) + assert.Equalf(t, rev, tt.wrev, "#%d: rev = %+v, want %+v", i, rev, tt.wrev) + assert.Equalf(t, created, tt.wcreated, "#%d: created = %+v, want %+v", i, created, tt.wcreated) + assert.Equalf(t, ver, tt.wver, "#%d: ver = %d, want %d", i, ver, tt.wver) } } @@ -112,12 +104,8 @@ func TestIndexRange(t *testing.T) { } for i, tt := range tests { keys, revs := ti.Range(tt.key, tt.end, atRev) - if !reflect.DeepEqual(keys, tt.wkeys) { - t.Errorf("#%d: keys = %+v, want %+v", i, keys, tt.wkeys) - } - if !reflect.DeepEqual(revs, tt.wrevs) { - t.Errorf("#%d: revs = %+v, want %+v", i, revs, tt.wrevs) - } + assert.Truef(t, reflect.DeepEqual(keys, tt.wkeys), "#%d: keys = %+v, want %+v", i, keys, tt.wkeys) + assert.Truef(t, reflect.DeepEqual(revs, tt.wrevs), "#%d: revs = %+v, want %+v", i, revs, tt.wrevs) } } @@ -125,19 +113,11 @@ func TestIndexTombstone(t *testing.T) { ti := newTreeIndex(zaptest.NewLogger(t)) ti.Put([]byte("foo"), Revision{Main: 1}) - err := ti.Tombstone([]byte("foo"), Revision{Main: 2}) - if err != nil { - t.Errorf("tombstone error = %v, want nil", err) - } + require.NoErrorf(t, ti.Tombstone([]byte("foo"), Revision{Main: 2}), "tombstone error") - _, _, _, err = ti.Get([]byte("foo"), 2) - if !errors.Is(err, ErrRevisionNotFound) { - t.Errorf("get error = %v, want ErrRevisionNotFound", err) - } - err = ti.Tombstone([]byte("foo"), Revision{Main: 3}) - if !errors.Is(err, ErrRevisionNotFound) { - t.Errorf("tombstone error = %v, want %v", err, ErrRevisionNotFound) - } + _, _, _, err := ti.Get([]byte("foo"), 2) + require.ErrorIsf(t, err, ErrRevisionNotFound, "get error = %v, want ErrRevisionNotFound", err) + assert.ErrorIsf(t, ti.Tombstone([]byte("foo"), Revision{Main: 3}), ErrRevisionNotFound, "tombstone error") } func TestIndexRevision(t *testing.T) { @@ -224,13 +204,9 @@ func TestIndexRevision(t *testing.T) { } for i, tt := range tests { revs, _ := ti.Revisions(tt.key, tt.end, tt.atRev, tt.limit) - if !reflect.DeepEqual(revs, tt.wrevs) { - t.Errorf("#%d limit %d: revs = %+v, want %+v", i, tt.limit, revs, tt.wrevs) - } + assert.Truef(t, reflect.DeepEqual(revs, tt.wrevs), "#%d limit %d: revs = %+v, want %+v", i, tt.limit, revs, tt.wrevs) count := ti.CountRevisions(tt.key, tt.end, tt.atRev) - if count != tt.wcounts { - t.Errorf("#%d: count = %d, want %v", i, count, tt.wcounts) - } + assert.Equalf(t, count, tt.wcounts, "#%d: count = %d, want %v", i, count, tt.wcounts) } } diff --git a/server/storage/mvcc/key_index_test.go b/server/storage/mvcc/key_index_test.go index 643ba11da991..2fff0e8a0c7c 100644 --- a/server/storage/mvcc/key_index_test.go +++ b/server/storage/mvcc/key_index_test.go @@ -15,7 +15,6 @@ package mvcc import ( - "errors" "reflect" "testing" @@ -115,18 +114,10 @@ func TestKeyIndexGet(t *testing.T) { for i, tt := range tests { mod, creat, ver, err := ki.get(zaptest.NewLogger(t), tt.rev) - if !errors.Is(err, tt.werr) { - t.Errorf("#%d: err = %v, want %v", i, err, tt.werr) - } - if mod != tt.wmod { - t.Errorf("#%d: modified = %+v, want %+v", i, mod, tt.wmod) - } - if creat != tt.wcreat { - t.Errorf("#%d: created = %+v, want %+v", i, creat, tt.wcreat) - } - if ver != tt.wver { - t.Errorf("#%d: version = %d, want %d", i, ver, tt.wver) - } + require.ErrorIsf(t, err, tt.werr, "#%d: err = %v, want %v", i, err, tt.werr) + assert.Equalf(t, mod, tt.wmod, "#%d: modified = %+v, want %+v", i, mod, tt.wmod) + assert.Equalf(t, creat, tt.wcreat, "#%d: created = %+v, want %+v", i, creat, tt.wcreat) + assert.Equalf(t, ver, tt.wver, "#%d: version = %d, want %d", i, ver, tt.wver) } } @@ -171,9 +162,7 @@ func TestKeyIndexSince(t *testing.T) { for i, tt := range tests { revs := ki.since(zaptest.NewLogger(t), tt.rev) - if !reflect.DeepEqual(revs, tt.wrevs) { - t.Errorf("#%d: revs = %+v, want %+v", i, revs, tt.wrevs) - } + assert.Truef(t, reflect.DeepEqual(revs, tt.wrevs), "#%d: revs = %+v, want %+v", i, revs, tt.wrevs) } } @@ -186,9 +175,7 @@ func TestKeyIndexPut(t *testing.T) { modified: Revision{Main: 5}, generations: []generation{{created: Revision{Main: 5}, ver: 1, revs: []Revision{{Main: 5}}}}, } - if !reflect.DeepEqual(ki, wki) { - t.Errorf("ki = %+v, want %+v", ki, wki) - } + assert.Truef(t, reflect.DeepEqual(ki, wki), "ki = %+v, want %+v", ki, wki) ki.put(zaptest.NewLogger(t), 7, 0) @@ -197,9 +184,7 @@ func TestKeyIndexPut(t *testing.T) { modified: Revision{Main: 7}, generations: []generation{{created: Revision{Main: 5}, ver: 2, revs: []Revision{{Main: 5}, {Main: 7}}}}, } - if !reflect.DeepEqual(ki, wki) { - t.Errorf("ki = %+v, want %+v", ki, wki) - } + assert.Truef(t, reflect.DeepEqual(ki, wki), "ki = %+v, want %+v", ki, wki) } func TestKeyIndexRestore(t *testing.T) { @@ -211,35 +196,25 @@ func TestKeyIndexRestore(t *testing.T) { modified: Revision{Main: 7}, generations: []generation{{created: Revision{Main: 5}, ver: 2, revs: []Revision{{Main: 7}}}}, } - if !reflect.DeepEqual(ki, wki) { - t.Errorf("ki = %+v, want %+v", ki, wki) - } + assert.Truef(t, reflect.DeepEqual(ki, wki), "ki = %+v, want %+v", ki, wki) } func TestKeyIndexTombstone(t *testing.T) { ki := &keyIndex{key: []byte("foo")} ki.put(zaptest.NewLogger(t), 5, 0) - err := ki.tombstone(zaptest.NewLogger(t), 7, 0) - if err != nil { - t.Errorf("unexpected tombstone error: %v", err) - } + require.NoErrorf(t, ki.tombstone(zaptest.NewLogger(t), 7, 0), "unexpected tombstone error") wki := &keyIndex{ key: []byte("foo"), modified: Revision{Main: 7}, generations: []generation{{created: Revision{Main: 5}, ver: 2, revs: []Revision{{Main: 5}, {Main: 7}}}, {}}, } - if !reflect.DeepEqual(ki, wki) { - t.Errorf("ki = %+v, want %+v", ki, wki) - } + assert.Truef(t, reflect.DeepEqual(ki, wki), "ki = %+v, want %+v", ki, wki) ki.put(zaptest.NewLogger(t), 8, 0) ki.put(zaptest.NewLogger(t), 9, 0) - err = ki.tombstone(zaptest.NewLogger(t), 15, 0) - if err != nil { - t.Errorf("unexpected tombstone error: %v", err) - } + require.NoErrorf(t, ki.tombstone(zaptest.NewLogger(t), 15, 0), "unexpected tombstone error") wki = &keyIndex{ key: []byte("foo"), @@ -250,14 +225,8 @@ func TestKeyIndexTombstone(t *testing.T) { {}, }, } - if !reflect.DeepEqual(ki, wki) { - t.Errorf("ki = %+v, want %+v", ki, wki) - } - - err = ki.tombstone(zaptest.NewLogger(t), 16, 0) - if !errors.Is(err, ErrRevisionNotFound) { - t.Errorf("tombstone error = %v, want %v", err, ErrRevisionNotFound) - } + assert.Truef(t, reflect.DeepEqual(ki, wki), "ki = %+v, want %+v", ki, wki) + assert.ErrorIsf(t, ki.tombstone(zaptest.NewLogger(t), 16, 0), ErrRevisionNotFound, "tombstone error") } func TestKeyIndexCompactAndKeep(t *testing.T) { @@ -535,9 +504,7 @@ func TestKeyIndexCompactAndKeep(t *testing.T) { am := make(map[Revision]struct{}) kiclone := cloneKeyIndex(ki) ki.keep(tt.compact, am) - if !reflect.DeepEqual(ki, kiclone) { - t.Errorf("#%d: ki = %+v, want %+v", i, ki, kiclone) - } + assert.Truef(t, reflect.DeepEqual(ki, kiclone), "#%d: ki = %+v, want %+v", i, ki, kiclone) if isTombstone { assert.Emptyf(t, am, "#%d: ki = %d, keep result wants empty because tombstone", i, ki) @@ -548,12 +515,8 @@ func TestKeyIndexCompactAndKeep(t *testing.T) { am = make(map[Revision]struct{}) ki.compact(zaptest.NewLogger(t), tt.compact, am) - if !reflect.DeepEqual(ki, tt.wki) { - t.Errorf("#%d: ki = %+v, want %+v", i, ki, tt.wki) - } - if !reflect.DeepEqual(am, tt.wam) { - t.Errorf("#%d: am = %+v, want %+v", i, am, tt.wam) - } + assert.Truef(t, reflect.DeepEqual(ki, tt.wki), "#%d: ki = %+v, want %+v", i, ki, tt.wki) + assert.Truef(t, reflect.DeepEqual(am, tt.wam), "#%d: am = %+v, want %+v", i, am, tt.wam) } // Jump Compaction and finding Keep @@ -563,20 +526,12 @@ func TestKeyIndexCompactAndKeep(t *testing.T) { am := make(map[Revision]struct{}) kiclone := cloneKeyIndex(ki) ki.keep(tt.compact, am) - if !reflect.DeepEqual(ki, kiclone) { - t.Errorf("#%d: ki = %+v, want %+v", i, ki, kiclone) - } - if !reflect.DeepEqual(am, tt.wam) { - t.Errorf("#%d: am = %+v, want %+v", i, am, tt.wam) - } + assert.Truef(t, reflect.DeepEqual(ki, kiclone), "#%d: ki = %+v, want %+v", i, ki, kiclone) + assert.Truef(t, reflect.DeepEqual(am, tt.wam), "#%d: am = %+v, want %+v", i, am, tt.wam) am = make(map[Revision]struct{}) ki.compact(zaptest.NewLogger(t), tt.compact, am) - if !reflect.DeepEqual(ki, tt.wki) { - t.Errorf("#%d: ki = %+v, want %+v", i, ki, tt.wki) - } - if !reflect.DeepEqual(am, tt.wam) { - t.Errorf("#%d: am = %+v, want %+v", i, am, tt.wam) - } + assert.Truef(t, reflect.DeepEqual(ki, tt.wki), "#%d: ki = %+v, want %+v", i, ki, tt.wki) + assert.Truef(t, reflect.DeepEqual(am, tt.wam), "#%d: am = %+v, want %+v", i, am, tt.wam) } } @@ -586,9 +541,7 @@ func TestKeyIndexCompactAndKeep(t *testing.T) { ki := newTestKeyIndex(zaptest.NewLogger(t)) am := make(map[Revision]struct{}) ki.keep(tt.compact, am) - if !reflect.DeepEqual(ki, kiClone) { - t.Errorf("#%d: ki = %+v, want %+v", i, ki, kiClone) - } + assert.Truef(t, reflect.DeepEqual(ki, kiClone), "#%d: ki = %+v, want %+v", i, ki, kiClone) if isTombstoneRevFn(ki, tt.compact) { assert.Emptyf(t, am, "#%d: ki = %d, keep result wants empty because tombstone", i, ki) @@ -599,12 +552,8 @@ func TestKeyIndexCompactAndKeep(t *testing.T) { am = make(map[Revision]struct{}) ki.compact(zaptest.NewLogger(t), tt.compact, am) - if !reflect.DeepEqual(ki, tt.wki) { - t.Errorf("#%d: ki = %+v, want %+v", i, ki, tt.wki) - } - if !reflect.DeepEqual(am, tt.wam) { - t.Errorf("#%d: am = %+v, want %+v", i, am, tt.wam) - } + assert.Truef(t, reflect.DeepEqual(ki, tt.wki), "#%d: ki = %+v, want %+v", i, ki, tt.wki) + assert.Truef(t, reflect.DeepEqual(am, tt.wam), "#%d: am = %+v, want %+v", i, am, tt.wam) } } @@ -644,12 +593,8 @@ func TestKeyIndexCompactOnFurtherRev(t *testing.T) { wam := map[Revision]struct{}{ {Main: 2}: {}, } - if !reflect.DeepEqual(ki, wki) { - t.Errorf("ki = %+v, want %+v", ki, wki) - } - if !reflect.DeepEqual(am, wam) { - t.Errorf("am = %+v, want %+v", am, wam) - } + assert.Truef(t, reflect.DeepEqual(ki, wki), "ki = %+v, want %+v", ki, wki) + assert.Truef(t, reflect.DeepEqual(am, wam), "am = %+v, want %+v", am, wam) } func TestKeyIndexIsEmpty(t *testing.T) { @@ -677,9 +622,7 @@ func TestKeyIndexIsEmpty(t *testing.T) { } for i, tt := range tests { g := tt.ki.isEmpty() - if g != tt.w { - t.Errorf("#%d: isEmpty = %v, want %v", i, g, tt.w) - } + assert.Equalf(t, g, tt.w, "#%d: isEmpty = %v, want %v", i, g, tt.w) } } @@ -707,9 +650,7 @@ func TestKeyIndexFindGeneration(t *testing.T) { } for i, tt := range tests { g := ki.findGeneration(tt.rev) - if g != tt.wg { - t.Errorf("#%d: generation = %+v, want %+v", i, g, tt.wg) - } + assert.Samef(t, g, tt.wg, "#%d: generation = %+v, want %+v", i, g, tt.wg) } } @@ -726,9 +667,7 @@ func TestKeyIndexLess(t *testing.T) { } for i, tt := range tests { g := ki.Less(tt.ki) - if g != tt.w { - t.Errorf("#%d: Less = %v, want %v", i, g, tt.w) - } + assert.Equalf(t, g, tt.w, "#%d: Less = %v, want %v", i, g, tt.w) } } @@ -743,9 +682,7 @@ func TestGenerationIsEmpty(t *testing.T) { } for i, tt := range tests { g := tt.g.isEmpty() - if g != tt.w { - t.Errorf("#%d: isEmpty = %v, want %v", i, g, tt.w) - } + assert.Equalf(t, g, tt.w, "#%d: isEmpty = %v, want %v", i, g, tt.w) } } @@ -768,9 +705,7 @@ func TestGenerationWalk(t *testing.T) { } for i, tt := range tests { idx := g.walk(tt.f) - if idx != tt.wi { - t.Errorf("#%d: index = %d, want %d", i, idx, tt.wi) - } + assert.Equalf(t, idx, tt.wi, "#%d: index = %d, want %d", i, idx, tt.wi) } } diff --git a/server/storage/mvcc/kv_test.go b/server/storage/mvcc/kv_test.go index 1b2bf6ae567b..cd945b985637 100644 --- a/server/storage/mvcc/kv_test.go +++ b/server/storage/mvcc/kv_test.go @@ -16,7 +16,6 @@ package mvcc import ( "context" - "errors" "fmt" "os" "reflect" @@ -26,6 +25,7 @@ import ( "github.com/prometheus/client_golang/prometheus" dto "github.com/prometheus/client_model/go" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "go.uber.org/zap/zaptest" "go.etcd.io/etcd/api/v3/mvccpb" @@ -130,15 +130,9 @@ func testKVRange(t *testing.T, f rangeFunc) { for i, tt := range tests { r, err := f(s, tt.key, tt.end, RangeOptions{}) - if err != nil { - t.Fatal(err) - } - if r.Rev != wrev { - t.Errorf("#%d: rev = %d, want %d", i, r.Rev, wrev) - } - if !reflect.DeepEqual(r.KVs, tt.wkvs) { - t.Errorf("#%d: kvs = %+v, want %+v", i, r.KVs, tt.wkvs) - } + require.NoError(t, err) + assert.Equalf(t, r.Rev, wrev, "#%d: rev = %d, want %d", i, r.Rev, wrev) + assert.Truef(t, reflect.DeepEqual(r.KVs, tt.wkvs), "#%d: kvs = %+v, want %+v", i, r.KVs, tt.wkvs) } } @@ -166,15 +160,9 @@ func testKVRangeRev(t *testing.T, f rangeFunc) { for i, tt := range tests { r, err := f(s, []byte("foo"), []byte("foo3"), RangeOptions{Rev: tt.rev}) - if err != nil { - t.Fatal(err) - } - if r.Rev != tt.wrev { - t.Errorf("#%d: rev = %d, want %d", i, r.Rev, tt.wrev) - } - if !reflect.DeepEqual(r.KVs, tt.wkvs) { - t.Errorf("#%d: kvs = %+v, want %+v", i, r.KVs, tt.wkvs) - } + require.NoError(t, err) + assert.Equalf(t, r.Rev, tt.wrev, "#%d: rev = %d, want %d", i, r.Rev, tt.wrev) + assert.Truef(t, reflect.DeepEqual(r.KVs, tt.wkvs), "#%d: kvs = %+v, want %+v", i, r.KVs, tt.wkvs) } } @@ -187,9 +175,8 @@ func testKVRangeBadRev(t *testing.T, f rangeFunc) { defer cleanup(s, b) put3TestKVs(s) - if _, err := s.Compact(traceutil.TODO(), 4); err != nil { - t.Fatalf("compact error (%v)", err) - } + _, err := s.Compact(traceutil.TODO(), 4) + require.NoErrorf(t, err, "compact error (%v)", err) tests := []struct { rev int64 @@ -205,9 +192,7 @@ func testKVRangeBadRev(t *testing.T, f rangeFunc) { } for i, tt := range tests { _, err := f(s, []byte("foo"), []byte("foo3"), RangeOptions{Rev: tt.rev}) - if !errors.Is(err, tt.werr) { - t.Errorf("#%d: error = %v, want %v", i, err, tt.werr) - } + assert.ErrorIsf(t, err, tt.werr, "#%d: error = %v, want %v", i, err, tt.werr) } } @@ -238,19 +223,11 @@ func testKVRangeLimit(t *testing.T, f rangeFunc) { } for i, tt := range tests { r, err := f(s, []byte("foo"), []byte("foo3"), RangeOptions{Limit: tt.limit}) - if err != nil { - t.Fatalf("#%d: range error (%v)", i, err) - } - if !reflect.DeepEqual(r.KVs, tt.wkvs) { - t.Errorf("#%d: kvs = %+v, want %+v", i, r.KVs, tt.wkvs) - } - if r.Rev != wrev { - t.Errorf("#%d: rev = %d, want %d", i, r.Rev, wrev) - } + require.NoErrorf(t, err, "#%d: range error (%v)", i, err) + assert.Truef(t, reflect.DeepEqual(r.KVs, tt.wkvs), "#%d: kvs = %+v, want %+v", i, r.KVs, tt.wkvs) + assert.Equalf(t, r.Rev, wrev, "#%d: rev = %d, want %d", i, r.Rev, wrev) if tt.limit <= 0 || int(tt.limit) > len(kvs) { - if r.Count != len(kvs) { - t.Errorf("#%d: count = %d, want %d", i, r.Count, len(kvs)) - } + assert.Lenf(t, kvs, r.Count, "#%d: count = %d, want %d", i, r.Count, len(kvs)) } else if r.Count != int(tt.wcounts) { t.Errorf("#%d: count = %d, want %d", i, r.Count, tt.limit) } @@ -269,20 +246,14 @@ func testKVPutMultipleTimes(t *testing.T, f putFunc) { base := int64(i + 1) rev := f(s, []byte("foo"), []byte("bar"), lease.LeaseID(base)) - if rev != base+1 { - t.Errorf("#%d: rev = %d, want %d", i, rev, base+1) - } + assert.Equalf(t, rev, base+1, "#%d: rev = %d, want %d", i, rev, base+1) r, err := s.Range(t.Context(), []byte("foo"), nil, RangeOptions{}) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) wkvs := []mvccpb.KeyValue{ {Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 2, ModRevision: base + 1, Version: base, Lease: base}, } - if !reflect.DeepEqual(r.KVs, wkvs) { - t.Errorf("#%d: kvs = %+v, want %+v", i, r.KVs, wkvs) - } + assert.Truef(t, reflect.DeepEqual(r.KVs, wkvs), "#%d: kvs = %+v, want %+v", i, r.KVs, wkvs) } } @@ -373,27 +344,19 @@ func testKVPutWithSameLease(t *testing.T, f putFunc) { // put foo rev := f(s, []byte("foo"), []byte("bar"), lease.LeaseID(leaseID)) - if rev != 2 { - t.Errorf("rev = %d, want %d", 2, rev) - } + assert.Equalf(t, int64(2), rev, "rev = %d, want %d", 2, rev) // put foo with same lease again rev2 := f(s, []byte("foo"), []byte("bar"), lease.LeaseID(leaseID)) - if rev2 != 3 { - t.Errorf("rev = %d, want %d", 3, rev2) - } + assert.Equalf(t, int64(3), rev2, "rev = %d, want %d", 3, rev2) // check leaseID r, err := s.Range(t.Context(), []byte("foo"), nil, RangeOptions{}) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) wkvs := []mvccpb.KeyValue{ {Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 3, Version: 2, Lease: leaseID}, } - if !reflect.DeepEqual(r.KVs, wkvs) { - t.Errorf("kvs = %+v, want %+v", r.KVs, wkvs) - } + assert.Truef(t, reflect.DeepEqual(r.KVs, wkvs), "kvs = %+v, want %+v", r.KVs, wkvs) } // TestKVOperationInSequence tests that range, put, delete on single key in @@ -408,23 +371,15 @@ func TestKVOperationInSequence(t *testing.T) { // put foo rev := s.Put([]byte("foo"), []byte("bar"), lease.NoLease) - if rev != base+1 { - t.Errorf("#%d: put rev = %d, want %d", i, rev, base+1) - } + assert.Equalf(t, rev, base+1, "#%d: put rev = %d, want %d", i, rev, base+1) r, err := s.Range(t.Context(), []byte("foo"), nil, RangeOptions{Rev: base + 1}) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) wkvs := []mvccpb.KeyValue{ {Key: []byte("foo"), Value: []byte("bar"), CreateRevision: base + 1, ModRevision: base + 1, Version: 1, Lease: int64(lease.NoLease)}, } - if !reflect.DeepEqual(r.KVs, wkvs) { - t.Errorf("#%d: kvs = %+v, want %+v", i, r.KVs, wkvs) - } - if r.Rev != base+1 { - t.Errorf("#%d: range rev = %d, want %d", i, rev, base+1) - } + assert.Truef(t, reflect.DeepEqual(r.KVs, wkvs), "#%d: kvs = %+v, want %+v", i, r.KVs, wkvs) + assert.Equalf(t, r.Rev, base+1, "#%d: range rev = %d, want %d", i, rev, base+1) // delete foo n, rev := s.DeleteRange([]byte("foo"), nil) @@ -433,15 +388,9 @@ func TestKVOperationInSequence(t *testing.T) { } r, err = s.Range(t.Context(), []byte("foo"), nil, RangeOptions{Rev: base + 2}) - if err != nil { - t.Fatal(err) - } - if r.KVs != nil { - t.Errorf("#%d: kvs = %+v, want %+v", i, r.KVs, nil) - } - if r.Rev != base+2 { - t.Errorf("#%d: range rev = %d, want %d", i, r.Rev, base+2) - } + require.NoError(t, err) + assert.Nilf(t, r.KVs, "#%d: kvs = %+v, want %+v", i, r.KVs, nil) + assert.Equalf(t, r.Rev, base+2, "#%d: range rev = %d, want %d", i, r.Rev, base+2) } } @@ -512,23 +461,15 @@ func TestKVTxnOperationInSequence(t *testing.T) { // put foo rev := txn.Put([]byte("foo"), []byte("bar"), lease.NoLease) - if rev != base+1 { - t.Errorf("#%d: put rev = %d, want %d", i, rev, base+1) - } + assert.Equalf(t, rev, base+1, "#%d: put rev = %d, want %d", i, rev, base+1) r, err := txn.Range(t.Context(), []byte("foo"), nil, RangeOptions{Rev: base + 1}) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) wkvs := []mvccpb.KeyValue{ {Key: []byte("foo"), Value: []byte("bar"), CreateRevision: base + 1, ModRevision: base + 1, Version: 1, Lease: int64(lease.NoLease)}, } - if !reflect.DeepEqual(r.KVs, wkvs) { - t.Errorf("#%d: kvs = %+v, want %+v", i, r.KVs, wkvs) - } - if r.Rev != base+1 { - t.Errorf("#%d: range rev = %d, want %d", i, r.Rev, base+1) - } + assert.Truef(t, reflect.DeepEqual(r.KVs, wkvs), "#%d: kvs = %+v, want %+v", i, r.KVs, wkvs) + assert.Equalf(t, r.Rev, base+1, "#%d: range rev = %d, want %d", i, r.Rev, base+1) // delete foo n, rev := txn.DeleteRange([]byte("foo"), nil) @@ -537,15 +478,9 @@ func TestKVTxnOperationInSequence(t *testing.T) { } r, err = txn.Range(t.Context(), []byte("foo"), nil, RangeOptions{Rev: base + 1}) - if err != nil { - t.Errorf("#%d: range error (%v)", i, err) - } - if r.KVs != nil { - t.Errorf("#%d: kvs = %+v, want %+v", i, r.KVs, nil) - } - if r.Rev != base+1 { - t.Errorf("#%d: range rev = %d, want %d", i, r.Rev, base+1) - } + require.NoErrorf(t, err, "#%d: range error (%v)", i, err) + assert.Nilf(t, r.KVs, "#%d: kvs = %+v, want %+v", i, r.KVs, nil) + assert.Equalf(t, r.Rev, base+1, "#%d: range rev = %d, want %d", i, r.Rev, base+1) txn.End() } @@ -592,16 +527,10 @@ func TestKVCompactReserveLastValue(t *testing.T) { } for i, tt := range tests { _, err := s.Compact(traceutil.TODO(), tt.rev) - if err != nil { - t.Errorf("#%d: unexpect compact error %v", i, err) - } + require.NoErrorf(t, err, "#%d: unexpect compact error %v", i, err) r, err := s.Range(t.Context(), []byte("foo"), nil, RangeOptions{Rev: tt.rev + 1}) - if err != nil { - t.Errorf("#%d: unexpect range error %v", i, err) - } - if !reflect.DeepEqual(r.KVs, tt.wkvs) { - t.Errorf("#%d: kvs = %+v, want %+v", i, r.KVs, tt.wkvs) - } + require.NoErrorf(t, err, "#%d: unexpect range error %v", i, err) + assert.Truef(t, reflect.DeepEqual(r.KVs, tt.wkvs), "#%d: kvs = %+v, want %+v", i, r.KVs, tt.wkvs) } } @@ -628,9 +557,7 @@ func TestKVCompactBad(t *testing.T) { } for i, tt := range tests { _, err := s.Compact(traceutil.TODO(), tt.rev) - if !errors.Is(err, tt.werr) { - t.Errorf("#%d: compact error = %v, want %v", i, err, tt.werr) - } + assert.ErrorIsf(t, err, tt.werr, "#%d: compact error = %v, want %v", i, err, tt.werr) } } @@ -644,16 +571,12 @@ func TestKVHash(t *testing.T) { kv.Put([]byte("foo0"), []byte("bar0"), lease.NoLease) kv.Put([]byte("foo1"), []byte("bar0"), lease.NoLease) hashes[i], _, err = kv.hash() - if err != nil { - t.Fatalf("failed to get hash: %v", err) - } + require.NoErrorf(t, err, "failed to get hash: %v", err) cleanup(kv, b) } for i := 1; i < len(hashes); i++ { - if hashes[i-1] != hashes[i] { - t.Errorf("hash[%d](%d) != hash[%d](%d)", i-1, hashes[i-1], i, hashes[i]) - } + assert.Equalf(t, hashes[i-1], hashes[i], "hash[%d](%d) != hash[%d](%d)", i-1, hashes[i-1], i, hashes[i]) } } @@ -707,9 +630,8 @@ func TestKVRestore(t *testing.T) { // ns should recover the previous state from backend. ns := NewStore(zaptest.NewLogger(t), b, &lease.FakeLessor{}, StoreConfig{CompactionBatchLimit: compactBatchLimit}) - if keysRestore := readGaugeInt(keysGauge); keysBefore != keysRestore { - t.Errorf("#%d: got %d key count, expected %d", i, keysRestore, keysBefore) - } + keysRestore := readGaugeInt(keysGauge) + assert.Equalf(t, keysBefore, keysRestore, "#%d: got %d key count, expected %d", i, keysRestore, keysBefore) // wait for possible compaction to finish testutil.WaitSchedule() @@ -720,9 +642,7 @@ func TestKVRestore(t *testing.T) { } cleanup(ns, b) - if !reflect.DeepEqual(nkvss, kvss) { - t.Errorf("#%d: kvs history = %+v, want %+v", i, nkvss, kvss) - } + assert.Truef(t, reflect.DeepEqual(nkvss, kvss), "#%d: kvs history = %+v, want %+v", i, nkvss, kvss) } } @@ -744,31 +664,21 @@ func TestKVSnapshot(t *testing.T) { newPath := "new_test" f, err := os.Create(newPath) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) defer os.Remove(newPath) snap := s.b.Snapshot() defer snap.Close() _, err = snap.WriteTo(f) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) f.Close() ns := NewStore(zaptest.NewLogger(t), b, &lease.FakeLessor{}, StoreConfig{}) defer ns.Close() r, err := ns.Range(t.Context(), []byte("a"), []byte("z"), RangeOptions{}) - if err != nil { - t.Errorf("unexpect range error (%v)", err) - } - if !reflect.DeepEqual(r.KVs, wkvs) { - t.Errorf("kvs = %+v, want %+v", r.KVs, wkvs) - } - if r.Rev != 4 { - t.Errorf("rev = %d, want %d", r.Rev, 4) - } + require.NoErrorf(t, err, "unexpect range error (%v)", err) + assert.Truef(t, reflect.DeepEqual(r.KVs, wkvs), "kvs = %+v, want %+v", r.KVs, wkvs) + assert.Equalf(t, int64(4), r.Rev, "rev = %d, want %d", r.Rev, 4) } func TestWatchableKVWatch(t *testing.T) { @@ -820,13 +730,9 @@ func TestWatchableKVWatch(t *testing.T) { s.Put([]byte("foo"), []byte("bar"), 1) select { case resp := <-w.Chan(): - if resp.WatchID != wid { - t.Errorf("resp.WatchID got = %d, want = %d", resp.WatchID, wid) - } + assert.Equalf(t, resp.WatchID, wid, "resp.WatchID got = %d, want = %d", resp.WatchID, wid) ev := resp.Events[0] - if !reflect.DeepEqual(ev, wev[0]) { - t.Errorf("watched event = %+v, want %+v", ev, wev[0]) - } + assert.Truef(t, reflect.DeepEqual(ev, wev[0]), "watched event = %+v, want %+v", ev, wev[0]) case <-time.After(5 * time.Second): // CPU might be too slow, and the routine is not able to switch around testutil.FatalStack(t, "failed to watch the event") @@ -835,13 +741,9 @@ func TestWatchableKVWatch(t *testing.T) { s.Put([]byte("foo1"), []byte("bar1"), 2) select { case resp := <-w.Chan(): - if resp.WatchID != wid { - t.Errorf("resp.WatchID got = %d, want = %d", resp.WatchID, wid) - } + assert.Equalf(t, resp.WatchID, wid, "resp.WatchID got = %d, want = %d", resp.WatchID, wid) ev := resp.Events[0] - if !reflect.DeepEqual(ev, wev[1]) { - t.Errorf("watched event = %+v, want %+v", ev, wev[1]) - } + assert.Truef(t, reflect.DeepEqual(ev, wev[1]), "watched event = %+v, want %+v", ev, wev[1]) case <-time.After(5 * time.Second): testutil.FatalStack(t, "failed to watch the event") } @@ -851,13 +753,9 @@ func TestWatchableKVWatch(t *testing.T) { select { case resp := <-w.Chan(): - if resp.WatchID != wid { - t.Errorf("resp.WatchID got = %d, want = %d", resp.WatchID, wid) - } + assert.Equalf(t, resp.WatchID, wid, "resp.WatchID got = %d, want = %d", resp.WatchID, wid) ev := resp.Events[0] - if !reflect.DeepEqual(ev, wev[1]) { - t.Errorf("watched event = %+v, want %+v", ev, wev[1]) - } + assert.Truef(t, reflect.DeepEqual(ev, wev[1]), "watched event = %+v, want %+v", ev, wev[1]) case <-time.After(5 * time.Second): testutil.FatalStack(t, "failed to watch the event") } @@ -865,13 +763,9 @@ func TestWatchableKVWatch(t *testing.T) { s.Put([]byte("foo1"), []byte("bar11"), 3) select { case resp := <-w.Chan(): - if resp.WatchID != wid { - t.Errorf("resp.WatchID got = %d, want = %d", resp.WatchID, wid) - } + assert.Equalf(t, resp.WatchID, wid, "resp.WatchID got = %d, want = %d", resp.WatchID, wid) ev := resp.Events[0] - if !reflect.DeepEqual(ev, wev[2]) { - t.Errorf("watched event = %+v, want %+v", ev, wev[2]) - } + assert.Truef(t, reflect.DeepEqual(ev, wev[2]), "watched event = %+v, want %+v", ev, wev[2]) case <-time.After(5 * time.Second): testutil.FatalStack(t, "failed to watch the event") } diff --git a/server/storage/mvcc/kvstore_compaction_test.go b/server/storage/mvcc/kvstore_compaction_test.go index 0b28c931ca7c..41e6e307a92e 100644 --- a/server/storage/mvcc/kvstore_compaction_test.go +++ b/server/storage/mvcc/kvstore_compaction_test.go @@ -19,6 +19,8 @@ import ( "testing" "time" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "go.uber.org/zap/zaptest" "go.etcd.io/etcd/pkg/v3/traceutil" @@ -83,23 +85,17 @@ func TestScheduleCompaction(t *testing.T) { tx.Unlock() _, err := s.scheduleCompaction(tt.rev, 0) - if err != nil { - t.Error(err) - } + require.NoError(t, err) tx.Lock() for _, rev := range tt.wrevs { ibytes := NewRevBytes() ibytes = RevToBytes(rev, ibytes) keys, _ := tx.UnsafeRange(schema.Key, ibytes, nil, 0) - if len(keys) != 1 { - t.Errorf("#%d: range on %v = %d, want 1", i, rev, len(keys)) - } + assert.Lenf(t, keys, 1, "#%d: range on %v = %d, want 1", i, rev, len(keys)) } vals, _ := UnsafeReadFinishedCompact(tx) - if !reflect.DeepEqual(vals, tt.rev) { - t.Errorf("#%d: finished compact equal %+v, want %+v", i, vals, tt.rev) - } + assert.Truef(t, reflect.DeepEqual(vals, tt.rev), "#%d: finished compact equal %+v, want %+v", i, vals, tt.rev) tx.Unlock() cleanup(s, b) @@ -119,9 +115,7 @@ func TestCompactAllAndRestore(t *testing.T) { rev := s0.Rev() // compact all keys done, err := s0.Compact(traceutil.TODO(), rev) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) select { case <-done: @@ -129,21 +123,11 @@ func TestCompactAllAndRestore(t *testing.T) { t.Fatal("timeout waiting for compaction to finish") } - err = s0.Close() - if err != nil { - t.Fatal(err) - } + require.NoError(t, s0.Close()) s1 := NewStore(zaptest.NewLogger(t), b, &lease.FakeLessor{}, StoreConfig{}) - if s1.Rev() != rev { - t.Errorf("rev = %v, want %v", s1.Rev(), rev) - } + assert.Equalf(t, s1.Rev(), rev, "rev = %v, want %v", s1.Rev(), rev) _, err = s1.Range(t.Context(), []byte("foo"), nil, RangeOptions{}) - if err != nil { - t.Errorf("unexpect range error %v", err) - } - err = s1.Close() - if err != nil { - t.Fatal(err) - } + require.NoErrorf(t, err, "unexpect range error %v", err) + require.NoError(t, s1.Close()) } diff --git a/server/storage/mvcc/kvstore_test.go b/server/storage/mvcc/kvstore_test.go index c993b0d8ba00..736c6bcec3ce 100644 --- a/server/storage/mvcc/kvstore_test.go +++ b/server/storage/mvcc/kvstore_test.go @@ -18,7 +18,6 @@ import ( "bytes" "crypto/rand" "encoding/binary" - "errors" "fmt" "math" mrand "math/rand" @@ -29,6 +28,8 @@ import ( "testing" "time" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "go.uber.org/zap" "go.uber.org/zap/zaptest" @@ -49,9 +50,8 @@ func TestStoreRev(t *testing.T) { for i := 1; i <= 3; i++ { s.Put([]byte("foo"), []byte("bar"), lease.NoLease) - if r := s.Rev(); r != int64(i+1) { - t.Errorf("#%d: rev = %d, want %d", i, r, i+1) - } + r := s.Rev() + assert.Equalf(t, r, int64(i+1), "#%d: rev = %d, want %d", i, r, i+1) } } @@ -65,9 +65,7 @@ func TestStorePut(t *testing.T) { Version: 1, } kvb, err := kv.Marshal() - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) tests := []struct { rev Revision @@ -145,9 +143,7 @@ func TestStorePut(t *testing.T) { s.Put([]byte("foo"), []byte("bar"), lease.LeaseID(i+1)) data, err := tt.wkv.Marshal() - if err != nil { - t.Errorf("#%d: marshal err = %v, want nil", i, err) - } + require.NoErrorf(t, err, "#%d: marshal err = %v, want nil", i, err) wact := []testutil.Action{ {Name: "seqput", Params: []any{schema.Key, tt.wkey, data}}, @@ -159,19 +155,15 @@ func TestStorePut(t *testing.T) { } } - if g := b.tx.Action(); !reflect.DeepEqual(g, wact) { - t.Errorf("#%d: tx action = %+v, want %+v", i, g, wact) - } + g := b.tx.Action() + assert.Truef(t, reflect.DeepEqual(g, wact), "#%d: tx action = %+v, want %+v", i, g, wact) wact = []testutil.Action{ {Name: "get", Params: []any{[]byte("foo"), tt.wputrev.Main}}, {Name: "put", Params: []any{[]byte("foo"), tt.wputrev}}, } - if g := fi.Action(); !reflect.DeepEqual(g, wact) { - t.Errorf("#%d: index action = %+v, want %+v", i, g, wact) - } - if s.currentRev != tt.wrev.Main { - t.Errorf("#%d: rev = %+v, want %+v", i, s.currentRev, tt.wrev) - } + g = fi.Action() + assert.Truef(t, reflect.DeepEqual(g, wact), "#%d: index action = %+v, want %+v", i, g, wact) + assert.Equalf(t, s.currentRev, tt.wrev.Main, "#%d: rev = %+v, want %+v", i, s.currentRev, tt.wrev) s.Close() } @@ -188,9 +180,7 @@ func TestStoreRange(t *testing.T) { Version: 1, } kvb, err := kv.Marshal() - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) wrev := int64(2) tests := []struct { @@ -218,33 +208,24 @@ func TestStoreRange(t *testing.T) { fi.indexRangeRespc <- tt.idxr ret, err := s.Range(t.Context(), []byte("foo"), []byte("goo"), ro) - if err != nil { - t.Errorf("#%d: err = %v, want nil", i, err) - } - if w := []mvccpb.KeyValue{kv}; !reflect.DeepEqual(ret.KVs, w) { - t.Errorf("#%d: kvs = %+v, want %+v", i, ret.KVs, w) - } - if ret.Rev != wrev { - t.Errorf("#%d: rev = %d, want %d", i, ret.Rev, wrev) - } + require.NoErrorf(t, err, "#%d: err = %v, want nil", i, err) + w := []mvccpb.KeyValue{kv} + assert.Truef(t, reflect.DeepEqual(ret.KVs, w), "#%d: kvs = %+v, want %+v", i, ret.KVs, w) + assert.Equalf(t, ret.Rev, wrev, "#%d: rev = %d, want %d", i, ret.Rev, wrev) wstart := NewRevBytes() wstart = RevToBytes(tt.idxr.revs[0], wstart) wact := []testutil.Action{ {Name: "range", Params: []any{schema.Key, wstart, []byte(nil), int64(0)}}, } - if g := b.tx.Action(); !reflect.DeepEqual(g, wact) { - t.Errorf("#%d: tx action = %+v, want %+v", i, g, wact) - } + g := b.tx.Action() + assert.Truef(t, reflect.DeepEqual(g, wact), "#%d: tx action = %+v, want %+v", i, g, wact) wact = []testutil.Action{ {Name: "range", Params: []any{[]byte("foo"), []byte("goo"), wrev}}, } - if g := fi.Action(); !reflect.DeepEqual(g, wact) { - t.Errorf("#%d: index action = %+v, want %+v", i, g, wact) - } - if s.currentRev != 2 { - t.Errorf("#%d: current rev = %+v, want %+v", i, s.currentRev, 2) - } + g = fi.Action() + assert.Truef(t, reflect.DeepEqual(g, wact), "#%d: index action = %+v, want %+v", i, g, wact) + assert.Equalf(t, int64(2), s.currentRev, "#%d: current rev = %+v, want %+v", i, s.currentRev, 2) s.Close() } @@ -261,9 +242,7 @@ func TestStoreDeleteRange(t *testing.T) { Version: 1, } kvb, err := kv.Marshal() - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) tests := []struct { rev Revision @@ -296,32 +275,24 @@ func TestStoreDeleteRange(t *testing.T) { b.tx.rangeRespc <- tt.rr n, _ := s.DeleteRange([]byte("foo"), []byte("goo")) - if n != 1 { - t.Errorf("#%d: n = %d, want 1", i, n) - } + assert.Equalf(t, int64(1), n, "#%d: n = %d, want 1", i, n) data, err := (&mvccpb.KeyValue{ Key: []byte("foo"), }).Marshal() - if err != nil { - t.Errorf("#%d: marshal err = %v, want nil", i, err) - } + require.NoErrorf(t, err, "#%d: marshal err = %v, want nil", i, err) wact := []testutil.Action{ {Name: "seqput", Params: []any{schema.Key, tt.wkey, data}}, } - if g := b.tx.Action(); !reflect.DeepEqual(g, wact) { - t.Errorf("#%d: tx action = %+v, want %+v", i, g, wact) - } + g := b.tx.Action() + assert.Truef(t, reflect.DeepEqual(g, wact), "#%d: tx action = %+v, want %+v", i, g, wact) wact = []testutil.Action{ {Name: "range", Params: []any{[]byte("foo"), []byte("goo"), tt.wrrev}}, {Name: "tombstone", Params: []any{[]byte("foo"), tt.wdelrev}}, } - if g := fi.Action(); !reflect.DeepEqual(g, wact) { - t.Errorf("#%d: index action = %+v, want %+v", i, g, wact) - } - if s.currentRev != tt.wrev.Main { - t.Errorf("#%d: rev = %+v, want %+v", i, s.currentRev, tt.wrev) - } + g = fi.Action() + assert.Truef(t, reflect.DeepEqual(g, wact), "#%d: index action = %+v, want %+v", i, g, wact) + assert.Equalf(t, s.currentRev, tt.wrev.Main, "#%d: rev = %+v, want %+v", i, s.currentRev, tt.wrev) s.Close() } } @@ -344,9 +315,7 @@ func TestStoreCompact(t *testing.T) { s.Compact(traceutil.TODO(), 3) s.fifoSched.WaitFinish(1) - if s.compactMainRev != 3 { - t.Errorf("compact main rev = %d, want 3", s.compactMainRev) - } + assert.Equalf(t, int64(3), s.compactMainRev, "compact main rev = %d, want 3", s.compactMainRev) end := make([]byte, 8) binary.BigEndian.PutUint64(end, uint64(4)) wact := []testutil.Action{ @@ -357,15 +326,13 @@ func TestStoreCompact(t *testing.T) { {Name: "delete", Params: []any{schema.Key, key2}}, {Name: "put", Params: []any{schema.Meta, schema.FinishedCompactKeyName, newTestRevBytes(Revision{Main: 3})}}, } - if g := b.tx.Action(); !reflect.DeepEqual(g, wact) { - t.Errorf("tx actions = %+v, want %+v", g, wact) - } + g := b.tx.Action() + assert.Truef(t, reflect.DeepEqual(g, wact), "tx actions = %+v, want %+v", g, wact) wact = []testutil.Action{ {Name: "compact", Params: []any{int64(3)}}, } - if g := fi.Action(); !reflect.DeepEqual(g, wact) { - t.Errorf("index action = %+v, want %+v", g, wact) - } + g = fi.Action() + assert.Truef(t, reflect.DeepEqual(g, wact), "index action = %+v, want %+v", g, wact) } func TestStoreRestore(t *testing.T) { @@ -384,17 +351,13 @@ func TestStoreRestore(t *testing.T) { Version: 1, } putkvb, err := putkv.Marshal() - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) delkey := newTestBucketKeyBytes(newBucketKey(5, 0, true)) delkv := mvccpb.KeyValue{ Key: []byte("foo"), } delkvb, err := delkv.Marshal() - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) b.tx.rangeRespc <- rangeResp{[][]byte{schema.FinishedCompactKeyName}, [][]byte{newTestRevBytes(Revision{Main: 3})}} b.tx.rangeRespc <- rangeResp{[][]byte{schema.ScheduledCompactKeyName}, [][]byte{newTestRevBytes(Revision{Main: 3})}} @@ -403,20 +366,15 @@ func TestStoreRestore(t *testing.T) { s.restore() - if s.compactMainRev != 3 { - t.Errorf("compact rev = %d, want 3", s.compactMainRev) - } - if s.currentRev != 5 { - t.Errorf("current rev = %v, want 5", s.currentRev) - } + assert.Equalf(t, int64(3), s.compactMainRev, "compact rev = %d, want 3", s.compactMainRev) + assert.Equalf(t, int64(5), s.currentRev, "current rev = %v, want 5", s.currentRev) wact := []testutil.Action{ {Name: "range", Params: []any{schema.Meta, schema.FinishedCompactKeyName, []byte(nil), int64(0)}}, {Name: "range", Params: []any{schema.Meta, schema.ScheduledCompactKeyName, []byte(nil), int64(0)}}, {Name: "range", Params: []any{schema.Key, newTestRevBytes(Revision{Main: 1}), newTestRevBytes(Revision{Main: math.MaxInt64, Sub: math.MaxInt64}), int64(restoreChunkKeys)}}, } - if g := b.tx.Action(); !reflect.DeepEqual(g, wact) { - t.Errorf("tx actions = %+v, want %+v", g, wact) - } + g := b.tx.Action() + assert.Truef(t, reflect.DeepEqual(g, wact), "tx actions = %+v, want %+v", g, wact) gens := []generation{ {created: Revision{Main: 4}, ver: 2, revs: []Revision{{Main: 3}, {Main: 5}}}, @@ -427,9 +385,8 @@ func TestStoreRestore(t *testing.T) { {Name: "keyIndex", Params: []any{ki}}, {Name: "insert", Params: []any{ki}}, } - if g := fi.Action(); !reflect.DeepEqual(g, wact) { - t.Errorf("index action = %+v, want %+v", g, wact) - } + g = fi.Action() + assert.Truef(t, reflect.DeepEqual(g, wact), "index action = %+v, want %+v", g, wact) } func TestRestoreDelete(t *testing.T) { @@ -469,13 +426,9 @@ func TestRestoreDelete(t *testing.T) { for i := 0; i < 20; i++ { ks := fmt.Sprintf("foo-%d", i) r, err := s.Range(t.Context(), []byte(ks), nil, RangeOptions{}) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) if _, ok := keys[ks]; ok { - if len(r.KVs) == 0 { - t.Errorf("#%d: expected %q, got deleted", i, ks) - } + assert.NotEmptyf(t, r.KVs, "#%d: expected %q, got deleted", i, ks) } else if len(r.KVs) != 0 { t.Errorf("#%d: expected deleted, got %q", i, ks) } @@ -518,9 +471,8 @@ func TestRestoreContinueUnfinishedCompaction(t *testing.T) { // wait for scheduled compaction to be finished time.Sleep(100 * time.Millisecond) - if _, err := s.Range(t.Context(), []byte("foo"), nil, RangeOptions{Rev: 1}); !errors.Is(err, ErrCompacted) { - t.Errorf("range on compacted rev error = %v, want %v", err, ErrCompacted) - } + _, err := s.Range(t.Context(), []byte("foo"), nil, RangeOptions{Rev: 1}) + require.ErrorIsf(t, err, ErrCompacted, "range on compacted rev error = %v, want %v", err, ErrCompacted) // check the key in backend is deleted revbytes := NewRevBytes() revbytes = BucketKeyToBytes(newBucketKey(1, 0, false), revbytes) @@ -571,9 +523,7 @@ func TestHashKVWhenCompacting(t *testing.T) { defer wg.Done() for { hash, _, err := s.HashStorage().HashByRev(int64(rev)) - if err != nil { - t.Error(err) - } + assert.NoError(t, err) select { case <-stopc: return @@ -597,9 +547,7 @@ func TestHashKVWhenCompacting(t *testing.T) { revHash[r.compactRev] = r.hash } - if r.hash != revHash[r.compactRev] { - t.Errorf("Hashes differ (current %v) != (saved %v)", r.hash, revHash[r.compactRev]) - } + assert.Equalf(t, r.hash, revHash[r.compactRev], "Hashes differ (current %v) != (saved %v)", r.hash, revHash[r.compactRev]) case <-stopc: return case <-donec: @@ -624,9 +572,7 @@ func TestHashKVWhenCompacting(t *testing.T) { } _, err := s.Compact(traceutil.TODO(), int64(rev-i)) - if err != nil { - t.Error(err) - } + assert.NoError(t, err) // Wait for the compaction job to finish s.fifoSched.WaitFinish(1) // Leave time for calls to HashByRev to take place after each compaction @@ -659,24 +605,17 @@ func TestHashKVWithCompactedAndFutureRevisions(t *testing.T) { for i := 2; i <= rev; i++ { s.Put([]byte("foo"), []byte(fmt.Sprintf("bar%d", i)), lease.NoLease) } - if _, err := s.Compact(traceutil.TODO(), int64(compactRev)); err != nil { - t.Fatal(err) - } + _, err := s.Compact(traceutil.TODO(), int64(compactRev)) + require.NoError(t, err) _, _, errFutureRev := s.HashStorage().HashByRev(int64(rev + 1)) - if !errors.Is(errFutureRev, ErrFutureRev) { - t.Error(errFutureRev) - } + require.ErrorIs(t, errFutureRev, ErrFutureRev) _, _, errPastRev := s.HashStorage().HashByRev(int64(compactRev - 1)) - if !errors.Is(errPastRev, ErrCompacted) { - t.Error(errPastRev) - } + require.ErrorIs(t, errPastRev, ErrCompacted) _, _, errCompactRev := s.HashStorage().HashByRev(int64(compactRev)) - if errCompactRev != nil { - t.Error(errCompactRev) - } + assert.NoError(t, errCompactRev) } // TestHashKVZeroRevision ensures that "HashByRev(0)" computes @@ -690,22 +629,15 @@ func TestHashKVZeroRevision(t *testing.T) { for i := 2; i <= rev; i++ { s.Put([]byte("foo"), []byte(fmt.Sprintf("bar%d", i)), lease.NoLease) } - if _, err := s.Compact(traceutil.TODO(), int64(rev/2)); err != nil { - t.Fatal(err) - } + _, err := s.Compact(traceutil.TODO(), int64(rev/2)) + require.NoError(t, err) hash1, _, err := s.HashStorage().HashByRev(int64(rev)) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) var hash2 KeyValueHash hash2, _, err = s.HashStorage().HashByRev(0) - if err != nil { - t.Fatal(err) - } - if hash1 != hash2 { - t.Errorf("hash %d (rev %d) != hash %d (rev 0)", hash1, rev, hash2) - } + require.NoError(t, err) + assert.Equalf(t, hash1, hash2, "hash %d (rev %d) != hash %d (rev 0)", hash1, rev, hash2) } func TestTxnPut(t *testing.T) { @@ -722,9 +654,8 @@ func TestTxnPut(t *testing.T) { for i := 0; i < sliceN; i++ { txn := s.Write(traceutil.TODO()) base := int64(i + 2) - if rev := txn.Put(keys[i], vals[i], lease.NoLease); rev != base { - t.Errorf("#%d: rev = %d, want %d", i, rev, base) - } + rev := txn.Put(keys[i], vals[i], lease.NoLease) + assert.Equalf(t, rev, base, "#%d: rev = %d, want %d", i, rev, base) txn.End() } } @@ -757,9 +688,7 @@ func TestConcurrentReadNotBlockingWrite(t *testing.T) { readTx2 := s.Read(ConcurrentReadTxMode, traceutil.TODO()) ro := RangeOptions{Limit: 1, Rev: 0, Count: false} ret, err := readTx2.Range(t.Context(), []byte("foo"), nil, ro) - if err != nil { - t.Fatalf("failed to range: %v", err) - } + require.NoErrorf(t, err, "failed to range: %v", err) // readTx2 should see the result of new write w := mvccpb.KeyValue{ Key: []byte("foo"), @@ -768,15 +697,11 @@ func TestConcurrentReadNotBlockingWrite(t *testing.T) { ModRevision: 3, Version: 2, } - if !reflect.DeepEqual(ret.KVs[0], w) { - t.Fatalf("range result = %+v, want = %+v", ret.KVs[0], w) - } + require.Truef(t, reflect.DeepEqual(ret.KVs[0], w), "range result = %+v, want = %+v", ret.KVs[0], w) readTx2.End() ret, err = readTx1.Range(t.Context(), []byte("foo"), nil, ro) - if err != nil { - t.Fatalf("failed to range: %v", err) - } + require.NoErrorf(t, err, "failed to range: %v", err) // readTx1 should not see the result of new write w = mvccpb.KeyValue{ Key: []byte("foo"), @@ -785,9 +710,7 @@ func TestConcurrentReadNotBlockingWrite(t *testing.T) { ModRevision: 2, Version: 1, } - if !reflect.DeepEqual(ret.KVs[0], w) { - t.Fatalf("range result = %+v, want = %+v", ret.KVs[0], w) - } + require.Truef(t, reflect.DeepEqual(ret.KVs[0], w), "range result = %+v, want = %+v", ret.KVs[0], w) readTx1.End() } @@ -853,9 +776,7 @@ func TestConcurrentReadTxAndWrite(t *testing.T) { for _, keyValue := range ret.KVs { result = append(result, kv{keyValue.Key, keyValue.Value}) } - if !reflect.DeepEqual(wKVs, result) { - t.Errorf("unexpected range result") // too many key value pairs, skip printing them - } + assert.Truef(t, reflect.DeepEqual(wKVs, result), "unexpected range result") // too many key value pairs, skip printing them }() } diff --git a/server/storage/mvcc/store_test.go b/server/storage/mvcc/store_test.go index df7607a54efd..afed0462cb6b 100644 --- a/server/storage/mvcc/store_test.go +++ b/server/storage/mvcc/store_test.go @@ -21,6 +21,7 @@ import ( "time" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "go.uber.org/zap/zaptest" "go.etcd.io/etcd/server/v3/storage/backend" @@ -48,9 +49,7 @@ func TestScheduledCompact(t *testing.T) { lg := zaptest.NewLogger(t) be, tmpPath := betesting.NewTmpBackend(t, time.Microsecond, 10) tx := be.BatchTx() - if tx == nil { - t.Fatal("batch tx is nil") - } + require.NotNilf(t, tx, "batch tx is nil") tx.Lock() tx.UnsafeCreateBucket(schema.Meta) UnsafeSetScheduledCompact(tx, tc.value) @@ -87,9 +86,7 @@ func TestFinishedCompact(t *testing.T) { lg := zaptest.NewLogger(t) be, tmpPath := betesting.NewTmpBackend(t, time.Microsecond, 10) tx := be.BatchTx() - if tx == nil { - t.Fatal("batch tx is nil") - } + require.NotNilf(t, tx, "batch tx is nil") tx.Lock() tx.UnsafeCreateBucket(schema.Meta) UnsafeSetFinishedCompact(tx, tc.value) diff --git a/server/storage/mvcc/watchable_store_test.go b/server/storage/mvcc/watchable_store_test.go index 50de7466ac7f..d04da1d5397d 100644 --- a/server/storage/mvcc/watchable_store_test.go +++ b/server/storage/mvcc/watchable_store_test.go @@ -44,10 +44,8 @@ func TestWatch(t *testing.T) { defer w.Close() w.Watch(0, testKey, nil, 0) - if !s.(*watchableStore).synced.contains(string(testKey)) { - // the key must have had an entry in synced - t.Errorf("existence = false, want true") - } + // the key must have had an entry in synced + assert.Truef(t, s.(*watchableStore).synced.contains(string(testKey)), "existence = false, want true") } func TestNewWatcherCancel(t *testing.T) { @@ -63,14 +61,9 @@ func TestNewWatcherCancel(t *testing.T) { defer w.Close() wt, _ := w.Watch(0, testKey, nil, 0) - if err := w.Cancel(wt); err != nil { - t.Error(err) - } - - if s.(*watchableStore).synced.contains(string(testKey)) { - // the key shoud have been deleted - t.Errorf("existence = true, want false") - } + require.NoError(t, w.Cancel(wt)) + // the key shoud have been deleted + assert.Falsef(t, s.(*watchableStore).synced.contains(string(testKey)), "existence = true, want false") } // TestCancelUnsynced tests if running CancelFunc removes watchers from unsynced. @@ -106,18 +99,14 @@ func TestCancelUnsynced(t *testing.T) { } for _, idx := range watchIDs { - if err := w.Cancel(idx); err != nil { - t.Error(err) - } + require.NoError(t, w.Cancel(idx)) } // After running CancelFunc // // unsynced should be empty // because cancel removes watcher from unsynced - if size := s.unsynced.size(); size != 0 { - t.Errorf("unsynced size = %d, want 0", size) - } + assert.Zero(t, s.unsynced.size()) } // TestSyncWatchers populates unsynced watcher map and tests syncWatchers @@ -283,9 +272,7 @@ func TestWatchCompacted(t *testing.T) { s.Put(testKey, testValue, lease.NoLease) } _, err := s.Compact(traceutil.TODO(), compactRev) - if err != nil { - t.Fatalf("failed to compact kv (%v)", err) - } + require.NoErrorf(t, err, "failed to compact kv (%v)", err) w := s.NewWatchStream() defer w.Close() @@ -293,12 +280,8 @@ func TestWatchCompacted(t *testing.T) { wt, _ := w.Watch(0, testKey, nil, compactRev-1) select { case resp := <-w.Chan(): - if resp.WatchID != wt { - t.Errorf("resp.WatchID = %x, want %x", resp.WatchID, wt) - } - if resp.CompactRevision == 0 { - t.Errorf("resp.Compacted = %v, want %v", resp.CompactRevision, compactRev) - } + assert.Equalf(t, resp.WatchID, wt, "resp.WatchID = %x, want %x", resp.WatchID, wt) + assert.NotEqualf(t, 0, resp.CompactRevision, "resp.Compacted = %v, want %v", resp.CompactRevision, compactRev) case <-time.After(1 * time.Second): t.Fatalf("failed to receive response (timeout)") } @@ -386,15 +369,9 @@ func TestWatchFutureRev(t *testing.T) { select { case resp := <-w.Chan(): - if resp.Revision != wrev { - t.Fatalf("rev = %d, want %d", resp.Revision, wrev) - } - if len(resp.Events) != 1 { - t.Fatalf("failed to get events from the response") - } - if resp.Events[0].Kv.ModRevision != wrev { - t.Fatalf("kv.rev = %d, want %d", resp.Events[0].Kv.ModRevision, wrev) - } + require.Equalf(t, resp.Revision, wrev, "rev = %d, want %d", resp.Revision, wrev) + require.Lenf(t, resp.Events, 1, "failed to get events from the response") + require.Equalf(t, resp.Events[0].Kv.ModRevision, wrev, "kv.rev = %d, want %d", resp.Events[0].Kv.ModRevision, wrev) case <-time.After(time.Second): t.Fatal("failed to receive event in 1 second.") } @@ -418,12 +395,8 @@ func TestWatchRestore(t *testing.T) { s.Restore(b) events := readEventsForSecond(w.Chan()) - if len(events) != 1 { - t.Errorf("Expected only one event, got %d", len(events)) - } - if events[0].Kv.ModRevision != wantRev { - t.Errorf("Expected revision to match, got %d, want %d", events[0].Kv.ModRevision, wantRev) - } + assert.Lenf(t, events, 1, "Expected only one event, got %d", len(events)) + assert.Equalf(t, wantRev, events[0].Kv.ModRevision, "Expected revision to match, got %d, want %d", events[0].Kv.ModRevision, wantRev) } } @@ -473,9 +446,7 @@ func TestWatchRestoreSyncedWatcher(t *testing.T) { s2.Put(testKey, testValue, lease.NoLease) // overwrite storage with higher revisions - if err := s1.Restore(b2); err != nil { - t.Fatal(err) - } + require.NoError(t, s1.Restore(b2)) // wait for next "syncWatchersLoop" iteration // and the unsynced watcher should be chosen @@ -486,15 +457,9 @@ func TestWatchRestoreSyncedWatcher(t *testing.T) { select { case resp := <-w1.Chan(): - if resp.Revision != startRev { - t.Fatalf("resp.Revision expect %d, got %d", startRev, resp.Revision) - } - if len(resp.Events) != 1 { - t.Fatalf("len(resp.Events) expect 1, got %d", len(resp.Events)) - } - if resp.Events[0].Kv.ModRevision != startRev { - t.Fatalf("resp.Events[0].Kv.ModRevision expect %d, got %d", startRev, resp.Events[0].Kv.ModRevision) - } + require.Equalf(t, resp.Revision, startRev, "resp.Revision expect %d, got %d", startRev, resp.Revision) + require.Lenf(t, resp.Events, 1, "len(resp.Events) expect 1, got %d", len(resp.Events)) + require.Equalf(t, resp.Events[0].Kv.ModRevision, startRev, "resp.Events[0].Kv.ModRevision expect %d, got %d", startRev, resp.Events[0].Kv.ModRevision) case <-time.After(time.Second): t.Fatal("failed to receive event in 1 second") } @@ -661,17 +626,11 @@ func TestNewMapwatcherToEventMap(t *testing.T) { } gwe := newWatcherBatch(&wg, tt.evs) - if len(gwe) != len(tt.wwe) { - t.Errorf("#%d: len(gwe) got = %d, want = %d", i, len(gwe), len(tt.wwe)) - } + assert.Lenf(t, tt.wwe, len(gwe), "#%d: len(gwe) got = %d, want = %d", i, len(gwe), len(tt.wwe)) // compare gwe and tt.wwe for w, eb := range gwe { - if len(eb.evs) != len(tt.wwe[w]) { - t.Errorf("#%d: len(eb.evs) got = %d, want = %d", i, len(eb.evs), len(tt.wwe[w])) - } - if !reflect.DeepEqual(eb.evs, tt.wwe[w]) { - t.Errorf("#%d: reflect.DeepEqual events got = %v, want = true", i, false) - } + assert.Lenf(t, tt.wwe[w], len(eb.evs), "#%d: len(eb.evs) got = %d, want = %d", i, len(eb.evs), len(tt.wwe[w])) + assert.Truef(t, reflect.DeepEqual(eb.evs, tt.wwe[w]), "#%d: reflect.DeepEqual events got = %v, want = true", i, false) } } } diff --git a/server/storage/mvcc/watcher_test.go b/server/storage/mvcc/watcher_test.go index e774c70cfac8..a736e9e7d205 100644 --- a/server/storage/mvcc/watcher_test.go +++ b/server/storage/mvcc/watcher_test.go @@ -16,13 +16,14 @@ package mvcc import ( "bytes" - "errors" "fmt" "os" "reflect" "testing" "time" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "go.uber.org/zap/zaptest" "go.etcd.io/etcd/api/v3/mvccpb" @@ -45,21 +46,16 @@ func TestWatcherWatchID(t *testing.T) { for i := 0; i < 10; i++ { id, _ := w.Watch(0, []byte("foo"), nil, 0) - if _, ok := idm[id]; ok { - t.Errorf("#%d: id %d exists", i, id) - } + _, ok := idm[id] + assert.Falsef(t, ok, "#%d: id %d exists", i, id) idm[id] = struct{}{} s.Put([]byte("foo"), []byte("bar"), lease.NoLease) resp := <-w.Chan() - if resp.WatchID != id { - t.Errorf("#%d: watch id in event = %d, want %d", i, resp.WatchID, id) - } + assert.Equalf(t, resp.WatchID, id, "#%d: watch id in event = %d, want %d", i, resp.WatchID, id) - if err := w.Cancel(id); err != nil { - t.Error(err) - } + require.NoError(t, w.Cancel(id)) } s.Put([]byte("foo2"), []byte("bar"), lease.NoLease) @@ -67,19 +63,13 @@ func TestWatcherWatchID(t *testing.T) { // unsynced watchers for i := 10; i < 20; i++ { id, _ := w.Watch(0, []byte("foo2"), nil, 1) - if _, ok := idm[id]; ok { - t.Errorf("#%d: id %d exists", i, id) - } + _, ok := idm[id] + assert.Falsef(t, ok, "#%d: id %d exists", i, id) idm[id] = struct{}{} resp := <-w.Chan() - if resp.WatchID != id { - t.Errorf("#%d: watch id in event = %d, want %d", i, resp.WatchID, id) - } - - if err := w.Cancel(id); err != nil { - t.Error(err) - } + assert.Equalf(t, resp.WatchID, id, "#%d: watch id in event = %d, want %d", i, resp.WatchID, id) + assert.NoError(t, w.Cancel(id)) } } @@ -109,9 +99,7 @@ func TestWatcherRequestsCustomID(t *testing.T) { for i, tcase := range tt { id, err := w.Watch(tcase.givenID, []byte("foo"), nil, 0) if tcase.expectedErr != nil || err != nil { - if !errors.Is(err, tcase.expectedErr) { - t.Errorf("expected get error %q in test case %q, got %q", tcase.expectedErr, i, err) - } + assert.ErrorIsf(t, err, tcase.expectedErr, "expected get error %q in test case %q, got %q", tcase.expectedErr, i, err) } else if tcase.expectedID != id { t.Errorf("expected to create ID %d, got %d in test case %d", tcase.expectedID, id, i) } @@ -135,29 +123,20 @@ func TestWatcherWatchPrefix(t *testing.T) { for i := 0; i < 10; i++ { id, _ := w.Watch(0, keyWatch, keyEnd, 0) - if _, ok := idm[id]; ok { - t.Errorf("#%d: unexpected duplicated id %x", i, id) - } + _, ok := idm[id] + assert.Falsef(t, ok, "#%d: unexpected duplicated id %x", i, id) idm[id] = struct{}{} s.Put(keyPut, val, lease.NoLease) resp := <-w.Chan() - if resp.WatchID != id { - t.Errorf("#%d: watch id in event = %d, want %d", i, resp.WatchID, id) - } + assert.Equalf(t, resp.WatchID, id, "#%d: watch id in event = %d, want %d", i, resp.WatchID, id) - if err := w.Cancel(id); err != nil { - t.Errorf("#%d: unexpected cancel error %v", i, err) - } + require.NoErrorf(t, w.Cancel(id), "#%d: unexpected cancel error", i) - if len(resp.Events) != 1 { - t.Errorf("#%d: len(resp.Events) got = %d, want = 1", i, len(resp.Events)) - } + assert.Lenf(t, resp.Events, 1, "#%d: len(resp.Events) got = %d, want = 1", i, len(resp.Events)) if len(resp.Events) == 1 { - if !bytes.Equal(resp.Events[0].Kv.Key, keyPut) { - t.Errorf("#%d: resp.Events got = %s, want = %s", i, resp.Events[0].Kv.Key, keyPut) - } + assert.Truef(t, bytes.Equal(resp.Events[0].Kv.Key, keyPut), "#%d: resp.Events got = %s, want = %s", i, resp.Events[0].Kv.Key, keyPut) } } @@ -167,27 +146,18 @@ func TestWatcherWatchPrefix(t *testing.T) { // unsynced watchers for i := 10; i < 15; i++ { id, _ := w.Watch(0, keyWatch1, keyEnd1, 1) - if _, ok := idm[id]; ok { - t.Errorf("#%d: id %d exists", i, id) - } + _, ok := idm[id] + assert.Falsef(t, ok, "#%d: id %d exists", i, id) idm[id] = struct{}{} resp := <-w.Chan() - if resp.WatchID != id { - t.Errorf("#%d: watch id in event = %d, want %d", i, resp.WatchID, id) - } + assert.Equalf(t, resp.WatchID, id, "#%d: watch id in event = %d, want %d", i, resp.WatchID, id) - if err := w.Cancel(id); err != nil { - t.Error(err) - } + require.NoError(t, w.Cancel(id)) - if len(resp.Events) != 1 { - t.Errorf("#%d: len(resp.Events) got = %d, want = 1", i, len(resp.Events)) - } + assert.Lenf(t, resp.Events, 1, "#%d: len(resp.Events) got = %d, want = 1", i, len(resp.Events)) if len(resp.Events) == 1 { - if !bytes.Equal(resp.Events[0].Kv.Key, keyPut1) { - t.Errorf("#%d: resp.Events got = %s, want = %s", i, resp.Events[0].Kv.Key, keyPut1) - } + assert.Truef(t, bytes.Equal(resp.Events[0].Kv.Key, keyPut1), "#%d: resp.Events got = %s, want = %s", i, resp.Events[0].Kv.Key, keyPut1) } } } @@ -202,16 +172,13 @@ func TestWatcherWatchWrongRange(t *testing.T) { w := s.NewWatchStream() defer w.Close() - if _, err := w.Watch(0, []byte("foa"), []byte("foa"), 1); !errors.Is(err, ErrEmptyWatcherRange) { - t.Fatalf("key == end range given; expected ErrEmptyWatcherRange, got %+v", err) - } - if _, err := w.Watch(0, []byte("fob"), []byte("foa"), 1); !errors.Is(err, ErrEmptyWatcherRange) { - t.Fatalf("key > end range given; expected ErrEmptyWatcherRange, got %+v", err) - } + _, err := w.Watch(0, []byte("foa"), []byte("foa"), 1) + require.ErrorIsf(t, err, ErrEmptyWatcherRange, "key == end range given; expected ErrEmptyWatcherRange, got %+v", err) + _, err = w.Watch(0, []byte("fob"), []byte("foa"), 1) + require.ErrorIsf(t, err, ErrEmptyWatcherRange, "key > end range given; expected ErrEmptyWatcherRange, got %+v", err) // watch request with 'WithFromKey' has empty-byte range end - if id, _ := w.Watch(0, []byte("foo"), []byte{}, 1); id != 0 { - t.Fatalf("\x00 is range given; id expected 0, got %d", id) - } + id, _ := w.Watch(0, []byte("foo"), []byte{}, 1) + require.Zerof(t, id, "\x00 is range given; id expected 0, got %d", id) } func TestWatchDeleteRange(t *testing.T) { @@ -244,9 +211,7 @@ func TestWatchDeleteRange(t *testing.T) { select { case r := <-w.Chan(): - if !reflect.DeepEqual(r.Events, we) { - t.Errorf("event = %v, want %v", r.Events, we) - } + assert.Truef(t, reflect.DeepEqual(r.Events, we), "event = %v, want %v", r.Events, we) case <-time.After(10 * time.Second): t.Fatal("failed to receive event after 10 seconds!") } @@ -278,15 +243,10 @@ func TestWatchStreamCancelWatcherByID(t *testing.T) { for i, tt := range tests { gerr := w.Cancel(tt.cancelID) - - if !errors.Is(gerr, tt.werr) { - t.Errorf("#%d: err = %v, want %v", i, gerr, tt.werr) - } + require.ErrorIsf(t, gerr, tt.werr, "#%d: err = %v, want %v", i, gerr, tt.werr) } - if l := len(w.(*watchStream).cancels); l != 0 { - t.Errorf("cancels = %d, want 0", l) - } + assert.Empty(t, w.(*watchStream).cancels) } // TestWatcherRequestProgress ensures synced watcher can correctly @@ -326,9 +286,7 @@ func TestWatcherRequestProgress(t *testing.T) { wrs := WatchResponse{WatchID: id, Revision: 2} select { case resp := <-w.Chan(): - if !reflect.DeepEqual(resp, wrs) { - t.Fatalf("got %+v, expect %+v", resp, wrs) - } + require.Truef(t, reflect.DeepEqual(resp, wrs), "got %+v, expect %+v", resp, wrs) case <-time.After(time.Second): t.Fatal("failed to receive progress") } @@ -365,9 +323,7 @@ func TestWatcherRequestProgressAll(t *testing.T) { wrs := WatchResponse{WatchID: clientv3.InvalidWatchID, Revision: 2} select { case resp := <-w.Chan(): - if !reflect.DeepEqual(resp, wrs) { - t.Fatalf("got %+v, expect %+v", resp, wrs) - } + require.Truef(t, reflect.DeepEqual(resp, wrs), "got %+v, expect %+v", resp, wrs) case <-time.After(time.Second): t.Fatal("failed to receive progress") } diff --git a/server/storage/schema/actions_test.go b/server/storage/schema/actions_test.go index a1acb697dec7..69f0401ae7a6 100644 --- a/server/storage/schema/actions_test.go +++ b/server/storage/schema/actions_test.go @@ -15,7 +15,6 @@ package schema import ( - "errors" "fmt" "testing" "time" @@ -80,13 +79,9 @@ func TestActionIsReversible(t *testing.T) { assertBucketState(t, tx, Meta, tc.state) reverse, err := tc.action.unsafeDo(tx) - if err != nil { - t.Errorf("Failed to upgrade, err: %v", err) - } + require.NoErrorf(t, err, "Failed to upgrade, err: %v", err) _, err = reverse.unsafeDo(tx) - if err != nil { - t.Errorf("Failed to downgrade, err: %v", err) - } + require.NoErrorf(t, err, "Failed to downgrade, err: %v", err) assertBucketState(t, tx, Meta, tc.state) }) } @@ -132,10 +127,7 @@ func TestActionListRevert(t *testing.T) { defer tx.Unlock() UnsafeCreateMetaBucket(tx) - err := tc.actions.unsafeExecute(lg, tx) - if !errors.Is(err, tc.expectError) { - t.Errorf("Unexpected error or lack thereof, expected: %v, got: %v", tc.expectError, err) - } + require.ErrorIs(t, tc.actions.unsafeExecute(lg, tx), tc.expectError) assertBucketState(t, tx, Meta, tc.expectState) }) } diff --git a/server/storage/schema/changes_test.go b/server/storage/schema/changes_test.go index 40cca68aae6c..41b59f81effa 100644 --- a/server/storage/schema/changes_test.go +++ b/server/storage/schema/changes_test.go @@ -47,14 +47,10 @@ func TestUpgradeDowngrade(t *testing.T) { UnsafeCreateMetaBucket(tx) _, err := tc.change.upgradeAction().unsafeDo(tx) - if err != nil { - t.Errorf("Failed to upgrade, err: %v", err) - } + require.NoErrorf(t, err, "Failed to upgrade, err: %v", err) assertBucketState(t, tx, Meta, tc.expectStateAfterUpgrade) _, err = tc.change.downgradeAction().unsafeDo(tx) - if err != nil { - t.Errorf("Failed to downgrade, err: %v", err) - } + require.NoErrorf(t, err, "Failed to downgrade, err: %v", err) assertBucketState(t, tx, Meta, tc.expectStateAfterDowngrade) }) } diff --git a/server/storage/schema/migration_test.go b/server/storage/schema/migration_test.go index 2b1d563864de..1d61ecca5505 100644 --- a/server/storage/schema/migration_test.go +++ b/server/storage/schema/migration_test.go @@ -15,7 +15,6 @@ package schema import ( - "errors" "fmt" "testing" "time" @@ -177,12 +176,8 @@ func TestMigrationStepExecute(t *testing.T) { UnsafeSetStorageVersion(tx, &tc.currentVersion) step := newMigrationStep(tc.currentVersion, tc.isUpgrade, tc.changes) - err := step.unsafeExecute(lg, tx) - if !errors.Is(err, tc.expectError) { - t.Errorf("Unexpected error or lack thereof, expected: %v, got: %v", tc.expectError, err) - } - v := UnsafeReadStorageVersion(tx) - assert.Equal(t, tc.expectVersion, v) + require.ErrorIs(t, step.unsafeExecute(lg, tx), tc.expectError) + assert.Equal(t, tc.expectVersion, UnsafeReadStorageVersion(tx)) assert.Equal(t, tc.expectRecordedActions, recorder.actions) }) } diff --git a/server/storage/schema/schema_test.go b/server/storage/schema/schema_test.go index 5f062730f293..15b6cb13727c 100644 --- a/server/storage/schema/schema_test.go +++ b/server/storage/schema/schema_test.go @@ -208,9 +208,7 @@ func TestMigrate(t *testing.T) { w, _ := waltesting.NewTmpWAL(t, tc.walEntries) defer w.Close() walVersion, err := wal.ReadWALVersion(w) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) b := backend.NewDefaultBackend(lg, dataPath) defer b.Close() @@ -264,16 +262,12 @@ func TestMigrateIsReversible(t *testing.T) { assertBucketState(t, tx, Meta, tc.state) w, walPath := waltesting.NewTmpWAL(t, nil) walVersion, err := wal.ReadWALVersion(w) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) // Upgrade to current version ver := localBinaryVersion() err = UnsafeMigrate(lg, tx, walVersion, ver) - if err != nil { - t.Errorf("Migrate(lg, tx, %q) returned error %+v", ver, err) - } + require.NoErrorf(t, err, "Migrate(lg, tx, %q) returned error %+v", ver, err) assert.Equal(t, &ver, UnsafeReadStorageVersion(tx)) // Downgrade back to initial version @@ -281,13 +275,9 @@ func TestMigrateIsReversible(t *testing.T) { w = waltesting.Reopen(t, walPath) defer w.Close() walVersion, err = wal.ReadWALVersion(w) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) err = UnsafeMigrate(lg, tx, walVersion, tc.initialVersion) - if err != nil { - t.Errorf("Migrate(lg, tx, %q) returned error %+v", tc.initialVersion, err) - } + require.NoErrorf(t, err, "Migrate(lg, tx, %q) returned error %+v", tc.initialVersion, err) // Assert that all changes were revered assertBucketState(t, tx, Meta, tc.state) diff --git a/server/storage/schema/version_test.go b/server/storage/schema/version_test.go index fc774c6a2db5..bed0d99da2da 100644 --- a/server/storage/schema/version_test.go +++ b/server/storage/schema/version_test.go @@ -112,18 +112,15 @@ func TestVersionSnapshot(t *testing.T) { be.ForceCommit() be.Close() db, err := bbolt.Open(tmpPath, 0o400, &bbolt.Options{ReadOnly: true}) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) defer db.Close() var ver *semver.Version - if err = db.View(func(tx *bbolt.Tx) error { + err = db.View(func(tx *bbolt.Tx) error { ver = ReadStorageVersionFromSnapshot(tx) return nil - }); err != nil { - t.Fatal(err) - } + }) + require.NoError(t, err) assert.Equal(t, tc.expectVersion, ver.String()) }) diff --git a/server/storage/wal/file_pipeline_test.go b/server/storage/wal/file_pipeline_test.go index bb59270bf3a0..12f4793cedf5 100644 --- a/server/storage/wal/file_pipeline_test.go +++ b/server/storage/wal/file_pipeline_test.go @@ -18,6 +18,7 @@ import ( "math" "testing" + "github.com/stretchr/testify/require" "go.uber.org/zap/zaptest" ) @@ -28,9 +29,7 @@ func TestFilePipeline(t *testing.T) { defer fp.Close() f, ferr := fp.Open() - if ferr != nil { - t.Fatal(ferr) - } + require.NoError(t, ferr) f.Close() } diff --git a/server/storage/wal/record_test.go b/server/storage/wal/record_test.go index 85ceebed9c11..9c3e18a28436 100644 --- a/server/storage/wal/record_test.go +++ b/server/storage/wal/record_test.go @@ -16,13 +16,15 @@ package wal import ( "bytes" - "errors" "hash/crc32" "io" "os" "reflect" "testing" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "go.etcd.io/etcd/client/pkg/v3/fileutil" "go.etcd.io/etcd/server/v3/storage/wal/walpb" ) @@ -54,17 +56,11 @@ func TestReadRecord(t *testing.T) { for i, tt := range tests { buf := bytes.NewBuffer(tt.data) f, err := createFileWithData(t, buf) - if err != nil { - t.Errorf("Unexpected error: %v", err) - } + require.NoErrorf(t, err, "Unexpected error: %v", err) decoder := NewDecoder(fileutil.NewFileReader(f)) e := decoder.Decode(rec) - if !reflect.DeepEqual(rec, tt.wr) { - t.Errorf("#%d: block = %v, want %v", i, rec, tt.wr) - } - if !errors.Is(e, tt.we) { - t.Errorf("#%d: err = %v, want %v", i, e, tt.we) - } + assert.Truef(t, reflect.DeepEqual(rec, tt.wr), "#%d: block = %v, want %v", i, rec, tt.wr) + assert.ErrorIsf(t, e, tt.we, "#%d: err = %v, want %v", i, e, tt.we) rec = &walpb.Record{} } } @@ -78,20 +74,11 @@ func TestWriteRecord(t *testing.T) { e.encode(&walpb.Record{Type: typ, Data: d}) e.flush() f, err := createFileWithData(t, buf) - if err != nil { - t.Errorf("Unexpected error: %v", err) - } + require.NoErrorf(t, err, "Unexpected error: %v", err) decoder := NewDecoder(fileutil.NewFileReader(f)) - err = decoder.Decode(b) - if err != nil { - t.Errorf("err = %v, want nil", err) - } - if b.Type != typ { - t.Errorf("type = %d, want %d", b.Type, typ) - } - if !reflect.DeepEqual(b.Data, d) { - t.Errorf("data = %v, want %v", b.Data, d) - } + require.NoError(t, decoder.Decode(b)) + assert.Equalf(t, b.Type, typ, "type = %d, want %d", b.Type, typ) + assert.Truef(t, reflect.DeepEqual(b.Data, d), "data = %v, want %v", b.Data, d) } func createFileWithData(t *testing.T, bf *bytes.Buffer) (*os.File, error) { diff --git a/server/storage/wal/repair_test.go b/server/storage/wal/repair_test.go index 8f05b197806f..34d6af7d70ff 100644 --- a/server/storage/wal/repair_test.go +++ b/server/storage/wal/repair_test.go @@ -167,9 +167,7 @@ func TestRepairFailDeleteDir(t *testing.T) { p := t.TempDir() w, err := Create(zaptest.NewLogger(t), p, nil) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) oldSegmentSizeBytes := SegmentSizeBytes SegmentSizeBytes = 64 @@ -177,30 +175,20 @@ func TestRepairFailDeleteDir(t *testing.T) { SegmentSizeBytes = oldSegmentSizeBytes }() for _, es := range makeEnts(50) { - if err = w.Save(raftpb.HardState{}, es); err != nil { - t.Fatal(err) - } + require.NoError(t, w.Save(raftpb.HardState{}, es)) } _, serr := w.tail().Seek(0, io.SeekCurrent) - if serr != nil { - t.Fatal(serr) - } + require.NoError(t, serr) w.Close() f, err := openLast(zaptest.NewLogger(t), p) - if err != nil { - t.Fatal(err) - } - if terr := f.Truncate(20); terr != nil { - t.Fatal(err) - } + require.NoError(t, err) + require.NoError(t, f.Truncate(20)) f.Close() w, err = Open(zaptest.NewLogger(t), p, walpb.Snapshot{}) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) _, _, _, err = w.ReadAll() require.ErrorIsf(t, err, io.ErrUnexpectedEOF, "err = %v, want error %v", err, io.ErrUnexpectedEOF) w.Close() diff --git a/server/storage/wal/wal_test.go b/server/storage/wal/wal_test.go index bbc6f5181433..979857114145 100644 --- a/server/storage/wal/wal_test.go +++ b/server/storage/wal/wal_test.go @@ -26,7 +26,6 @@ import ( "path/filepath" "reflect" "regexp" - "strings" "testing" "github.com/stretchr/testify/assert" @@ -49,25 +48,19 @@ func TestNew(t *testing.T) { w, err := Create(zaptest.NewLogger(t), p, []byte("somedata")) require.NoErrorf(t, err, "err = %v, want nil", err) - if g := filepath.Base(w.tail().Name()); g != walName(0, 0) { - t.Errorf("name = %+v, want %+v", g, walName(0, 0)) - } + g := filepath.Base(w.tail().Name()) + assert.Equalf(t, g, walName(0, 0), "name = %+v, want %+v", g, walName(0, 0)) defer w.Close() // file is preallocated to segment size; only read data written by wal off, err := w.tail().Seek(0, io.SeekCurrent) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) gd := make([]byte, off) f, err := os.Open(filepath.Join(p, filepath.Base(w.tail().Name()))) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) defer f.Close() - if _, err = io.ReadFull(f, gd); err != nil { - t.Fatalf("err = %v, want nil", err) - } + _, err = io.ReadFull(f, gd) + require.NoErrorf(t, err, "err = %v, want nil", err) var wb bytes.Buffer e := newEncoder(&wb, 0, 0) @@ -82,9 +75,7 @@ func TestNew(t *testing.T) { err = e.encode(r) require.NoErrorf(t, err, "err = %v, want nil", err) e.flush() - if !bytes.Equal(gd, wb.Bytes()) { - t.Errorf("data = %v, want %v", gd, wb.Bytes()) - } + assert.Truef(t, bytes.Equal(gd, wb.Bytes()), "data = %v, want %v", gd, wb.Bytes()) } func TestCreateNewWALFile(t *testing.T) { @@ -167,9 +158,7 @@ func TestCreateFailFromPollutedDir(t *testing.T) { func TestWalCleanup(t *testing.T) { testRoot := t.TempDir() p, err := os.MkdirTemp(testRoot, "waltest") - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) logger := zaptest.NewLogger(t) w, err := Create(logger, p, []byte("")) @@ -180,9 +169,7 @@ func TestWalCleanup(t *testing.T) { require.Lenf(t, fnames, 1, "expected 1 file under %v, got %v", testRoot, len(fnames)) pattern := fmt.Sprintf(`%s.broken\.[\d]{8}\.[\d]{6}\.[\d]{1,6}?`, filepath.Base(p)) match, _ := regexp.MatchString(pattern, fnames[0]) - if !match { - t.Errorf("match = false, expected true for %v with pattern %v", fnames[0], pattern) - } + assert.Truef(t, match, "match = false, expected true for %v with pattern %v", fnames[0], pattern) } func TestCreateFailFromNoSpaceLeft(t *testing.T) { @@ -202,51 +189,39 @@ func TestNewForInitedDir(t *testing.T) { p := t.TempDir() os.Create(filepath.Join(p, walName(0, 0))) - if _, err := Create(zaptest.NewLogger(t), p, nil); err == nil || !errors.Is(err, os.ErrExist) { - t.Errorf("err = %v, want %v", err, os.ErrExist) - } + _, err := Create(zaptest.NewLogger(t), p, nil) + assert.ErrorIsf(t, err, os.ErrExist, "err = %v, want %v", err, os.ErrExist) } func TestOpenAtIndex(t *testing.T) { dir := t.TempDir() f, err := os.Create(filepath.Join(dir, walName(0, 0))) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) f.Close() w, err := Open(zaptest.NewLogger(t), dir, walpb.Snapshot{}) require.NoErrorf(t, err, "err = %v, want nil", err) - if g := filepath.Base(w.tail().Name()); g != walName(0, 0) { - t.Errorf("name = %+v, want %+v", g, walName(0, 0)) - } - if w.seq() != 0 { - t.Errorf("seq = %d, want %d", w.seq(), 0) - } + g := filepath.Base(w.tail().Name()) + assert.Equalf(t, g, walName(0, 0), "name = %+v, want %+v", g, walName(0, 0)) + assert.Zerof(t, w.seq(), "seq = %d, want %d", w.seq(), 0) w.Close() wname := walName(2, 10) f, err = os.Create(filepath.Join(dir, wname)) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) f.Close() w, err = Open(zaptest.NewLogger(t), dir, walpb.Snapshot{Index: 5}) require.NoErrorf(t, err, "err = %v, want nil", err) - if g := filepath.Base(w.tail().Name()); g != wname { - t.Errorf("name = %+v, want %+v", g, wname) - } - if w.seq() != 2 { - t.Errorf("seq = %d, want %d", w.seq(), 2) - } + g = filepath.Base(w.tail().Name()) + assert.Equalf(t, g, wname, "name = %+v, want %+v", g, wname) + assert.Equalf(t, uint64(2), w.seq(), "seq = %d, want %d", w.seq(), 2) w.Close() emptydir := t.TempDir() - if _, err = Open(zaptest.NewLogger(t), emptydir, walpb.Snapshot{}); !errors.Is(err, ErrFileNotFound) { - t.Errorf("err = %v, want %v", err, ErrFileNotFound) - } + _, err = Open(zaptest.NewLogger(t), emptydir, walpb.Snapshot{}) + assert.ErrorIsf(t, err, ErrFileNotFound, "err = %v, want %v", err, ErrFileNotFound) } // TestVerify tests that Verify throws a non-nil error when the WAL is corrupted. @@ -258,20 +233,14 @@ func TestVerify(t *testing.T) { // create WAL w, err := Create(lg, walDir, nil) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) defer w.Close() // make 5 separate files for i := 0; i < 5; i++ { es := []raftpb.Entry{{Index: uint64(i), Data: []byte(fmt.Sprintf("waldata%d", i+1))}} - if err = w.Save(raftpb.HardState{}, es); err != nil { - t.Fatal(err) - } - if err = w.cut(); err != nil { - t.Fatal(err) - } + require.NoError(t, w.Save(raftpb.HardState{}, es)) + require.NoError(t, w.cut()) } hs := raftpb.HardState{Term: 1, Vote: 3, Commit: 5} @@ -279,26 +248,17 @@ func TestVerify(t *testing.T) { // to verify the WAL is not corrupted at this point hardstate, err := Verify(lg, walDir, walpb.Snapshot{}) - if err != nil { - t.Errorf("expected a nil error, got %v", err) - } + require.NoErrorf(t, err, "expected a nil error, got %v", err) assert.Equal(t, hs, *hardstate) walFiles, err := os.ReadDir(walDir) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) // corrupt the WAL by truncating one of the WAL files completely - err = os.Truncate(path.Join(walDir, walFiles[2].Name()), 0) - if err != nil { - t.Fatal(err) - } + require.NoError(t, os.Truncate(path.Join(walDir, walFiles[2].Name()), 0)) _, err = Verify(lg, walDir, walpb.Snapshot{}) - if err == nil { - t.Error("expected a non-nil error, got nil") - } + assert.Errorf(t, err, "expected a non-nil error, got nil") } // TestCut tests cut @@ -307,72 +267,48 @@ func TestCut(t *testing.T) { p := t.TempDir() w, err := Create(zaptest.NewLogger(t), p, nil) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) defer w.Close() state := raftpb.HardState{Term: 1} - if err = w.Save(state, nil); err != nil { - t.Fatal(err) - } - if err = w.cut(); err != nil { - t.Fatal(err) - } + require.NoError(t, w.Save(state, nil)) + require.NoError(t, w.cut()) wname := walName(1, 1) - if g := filepath.Base(w.tail().Name()); g != wname { - t.Errorf("name = %s, want %s", g, wname) - } + g := filepath.Base(w.tail().Name()) + assert.Equalf(t, g, wname, "name = %s, want %s", g, wname) es := []raftpb.Entry{{Index: 1, Term: 1, Data: []byte{1}}} - if err = w.Save(raftpb.HardState{}, es); err != nil { - t.Fatal(err) - } - if err = w.cut(); err != nil { - t.Fatal(err) - } + require.NoError(t, w.Save(raftpb.HardState{}, es)) + require.NoError(t, w.cut()) snap := walpb.Snapshot{Index: 2, Term: 1, ConfState: &confState} - if err = w.SaveSnapshot(snap); err != nil { - t.Fatal(err) - } + require.NoError(t, w.SaveSnapshot(snap)) wname = walName(2, 2) - if g := filepath.Base(w.tail().Name()); g != wname { - t.Errorf("name = %s, want %s", g, wname) - } + g = filepath.Base(w.tail().Name()) + assert.Equalf(t, g, wname, "name = %s, want %s", g, wname) // check the state in the last WAL // We do check before closing the WAL to ensure that Cut syncs the data // into the disk. f, err := os.Open(filepath.Join(p, wname)) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) defer f.Close() nw := &WAL{ decoder: NewDecoder(fileutil.NewFileReader(f)), start: snap, } _, gst, _, err := nw.ReadAll() - if err != nil { - t.Fatal(err) - } - if !reflect.DeepEqual(gst, state) { - t.Errorf("state = %+v, want %+v", gst, state) - } + require.NoError(t, err) + assert.Truef(t, reflect.DeepEqual(gst, state), "state = %+v, want %+v", gst, state) } func TestSaveWithCut(t *testing.T) { p := t.TempDir() w, err := Create(zaptest.NewLogger(t), p, []byte("metadata")) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) state := raftpb.HardState{Term: 1} - if err = w.Save(state, nil); err != nil { - t.Fatal(err) - } + require.NoError(t, w.Save(state, nil)) bigData := make([]byte, 500) strdata := "Hello World!!" copy(bigData, strdata) @@ -384,9 +320,7 @@ func TestSaveWithCut(t *testing.T) { index := uint64(0) for totalSize := 0; totalSize < int(SegmentSizeBytes); totalSize += EntrySize { ents := []raftpb.Entry{{Index: index, Term: 1, Data: bigData}} - if err = w.Save(state, ents); err != nil { - t.Fatal(err) - } + require.NoError(t, w.Save(state, ents)) index++ } @@ -396,25 +330,16 @@ func TestSaveWithCut(t *testing.T) { require.NoErrorf(t, err, "err = %v, want nil", err) defer neww.Close() wname := walName(1, index) - if g := filepath.Base(neww.tail().Name()); g != wname { - t.Errorf("name = %s, want %s", g, wname) - } + g := filepath.Base(neww.tail().Name()) + assert.Equalf(t, g, wname, "name = %s, want %s", g, wname) _, newhardstate, entries, err := neww.ReadAll() - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) - if !reflect.DeepEqual(newhardstate, state) { - t.Errorf("Hard State = %+v, want %+v", newhardstate, state) - } - if len(entries) != int(SegmentSizeBytes/int64(EntrySize)) { - t.Errorf("Number of entries = %d, expected = %d", len(entries), int(SegmentSizeBytes/int64(EntrySize))) - } + assert.Truef(t, reflect.DeepEqual(newhardstate, state), "Hard State = %+v, want %+v", newhardstate, state) + assert.Equalf(t, len(entries), int(SegmentSizeBytes/int64(EntrySize)), "Number of entries = %d, expected = %d", len(entries), int(SegmentSizeBytes/int64(EntrySize))) for _, oneent := range entries { - if !bytes.Equal(oneent.Data, bigData) { - t.Errorf("the saved data does not match at Index %d : found: %s , want :%s", oneent.Index, oneent.Data, bigData) - } + assert.Truef(t, bytes.Equal(oneent.Data, bigData), "the saved data does not match at Index %d : found: %s , want :%s", oneent.Index, oneent.Data, bigData) } } @@ -442,51 +367,32 @@ func TestRecover(t *testing.T) { p := t.TempDir() w, err := Create(zaptest.NewLogger(t), p, []byte("metadata")) - if err != nil { - t.Fatal(err) - } - if err = w.SaveSnapshot(walpb.Snapshot{}); err != nil { - t.Fatal(err) - } + require.NoError(t, err) + require.NoError(t, w.SaveSnapshot(walpb.Snapshot{})) data := make([]byte, tc.size) n, err := rand.Read(data) assert.Equal(t, tc.size, n) - if err != nil { - t.Errorf("Unexpected error: %v", err) - } + require.NoErrorf(t, err, "Unexpected error: %v", err) ents := []raftpb.Entry{{Index: 1, Term: 1, Data: data}, {Index: 2, Term: 2, Data: data}} - if err = w.Save(raftpb.HardState{}, ents); err != nil { - t.Fatal(err) - } + require.NoError(t, w.Save(raftpb.HardState{}, ents)) sts := []raftpb.HardState{{Term: 1, Vote: 1, Commit: 1}, {Term: 2, Vote: 2, Commit: 2}} for _, s := range sts { - if err = w.Save(s, nil); err != nil { - t.Fatal(err) - } + require.NoError(t, w.Save(s, nil)) } w.Close() - if w, err = Open(zaptest.NewLogger(t), p, walpb.Snapshot{}); err != nil { - t.Fatal(err) - } + w, err = Open(zaptest.NewLogger(t), p, walpb.Snapshot{}) + require.NoError(t, err) metadata, state, entries, err := w.ReadAll() - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) - if !bytes.Equal(metadata, []byte("metadata")) { - t.Errorf("metadata = %s, want %s", metadata, "metadata") - } - if !reflect.DeepEqual(entries, ents) { - t.Errorf("ents = %+v, want %+v", entries, ents) - } + assert.Truef(t, bytes.Equal(metadata, []byte("metadata")), "metadata = %s, want %s", metadata, "metadata") + assert.Truef(t, reflect.DeepEqual(entries, ents), "ents = %+v, want %+v", entries, ents) // only the latest state is recorded s := sts[len(sts)-1] - if !reflect.DeepEqual(state, s) { - t.Errorf("state = %+v, want %+v", state, s) - } + assert.Truef(t, reflect.DeepEqual(state, s), "state = %+v, want %+v", state, s) w.Close() }) } @@ -526,12 +432,8 @@ func TestSearchIndex(t *testing.T) { } for i, tt := range tests { idx, ok := searchIndex(zaptest.NewLogger(t), tt.names, tt.index) - if idx != tt.widx { - t.Errorf("#%d: idx = %d, want %d", i, idx, tt.widx) - } - if ok != tt.wok { - t.Errorf("#%d: ok = %v, want %v", i, ok, tt.wok) - } + assert.Equalf(t, idx, tt.widx, "#%d: idx = %d, want %d", i, idx, tt.widx) + assert.Equalf(t, ok, tt.wok, "#%d: ok = %v, want %v", i, ok, tt.wok) } } @@ -547,15 +449,10 @@ func TestScanWalName(t *testing.T) { } for i, tt := range tests { s, index, err := parseWALName(tt.str) - if g := err == nil; g != tt.wok { - t.Errorf("#%d: ok = %v, want %v", i, g, tt.wok) - } - if s != tt.wseq { - t.Errorf("#%d: seq = %d, want %d", i, s, tt.wseq) - } - if index != tt.windex { - t.Errorf("#%d: index = %d, want %d", i, index, tt.windex) - } + g := err == nil + assert.Equalf(t, g, tt.wok, "#%d: ok = %v, want %v", i, g, tt.wok) + assert.Equalf(t, s, tt.wseq, "#%d: seq = %d, want %d", i, s, tt.wseq) + assert.Equalf(t, index, tt.windex, "#%d: index = %d, want %d", i, index, tt.windex) } } @@ -563,34 +460,22 @@ func TestRecoverAfterCut(t *testing.T) { p := t.TempDir() md, err := Create(zaptest.NewLogger(t), p, []byte("metadata")) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) for i := 0; i < 10; i++ { - if err = md.SaveSnapshot(walpb.Snapshot{Index: uint64(i), Term: 1, ConfState: &confState}); err != nil { - t.Fatal(err) - } + require.NoError(t, md.SaveSnapshot(walpb.Snapshot{Index: uint64(i), Term: 1, ConfState: &confState})) es := []raftpb.Entry{{Index: uint64(i)}} - if err = md.Save(raftpb.HardState{}, es); err != nil { - t.Fatal(err) - } - if err = md.cut(); err != nil { - t.Fatal(err) - } + require.NoError(t, md.Save(raftpb.HardState{}, es)) + require.NoError(t, md.cut()) } md.Close() - if err := os.Remove(filepath.Join(p, walName(4, 4))); err != nil { - t.Fatal(err) - } + require.NoError(t, os.Remove(filepath.Join(p, walName(4, 4)))) for i := 0; i < 10; i++ { w, err := Open(zaptest.NewLogger(t), p, walpb.Snapshot{Index: uint64(i), Term: 1}) if err != nil { if i <= 4 { - if !strings.Contains(err.Error(), "do not increase continuously") { - t.Errorf("#%d: err = %v isn't expected, want: '* do not increase continuously'", i, err) - } + require.ErrorContainsf(t, err, "do not increase continuously", "#%d: err = %v isn't expected, want: '* do not increase continuously'", i, err) } else { t.Errorf("#%d: err = %v, want nil", i, err) } @@ -601,13 +486,9 @@ func TestRecoverAfterCut(t *testing.T) { t.Errorf("#%d: err = %v, want nil", i, err) continue } - if !bytes.Equal(metadata, []byte("metadata")) { - t.Errorf("#%d: metadata = %s, want %s", i, metadata, "metadata") - } + assert.Truef(t, bytes.Equal(metadata, []byte("metadata")), "#%d: metadata = %s, want %s", i, metadata, "metadata") for j, e := range entries { - if e.Index != uint64(j+i+1) { - t.Errorf("#%d: ents[%d].Index = %+v, want %+v", i, j, e.Index, j+i+1) - } + assert.Equalf(t, e.Index, uint64(j+i+1), "#%d: ents[%d].Index = %+v, want %+v", i, j, e.Index, j+i+1) } w.Close() } @@ -617,25 +498,16 @@ func TestOpenAtUncommittedIndex(t *testing.T) { p := t.TempDir() w, err := Create(zaptest.NewLogger(t), p, nil) - if err != nil { - t.Fatal(err) - } - if err = w.SaveSnapshot(walpb.Snapshot{}); err != nil { - t.Fatal(err) - } - if err = w.Save(raftpb.HardState{}, []raftpb.Entry{{Index: 0}}); err != nil { - t.Fatal(err) - } + require.NoError(t, err) + require.NoError(t, w.SaveSnapshot(walpb.Snapshot{})) + require.NoError(t, w.Save(raftpb.HardState{}, []raftpb.Entry{{Index: 0}})) w.Close() w, err = Open(zaptest.NewLogger(t), p, walpb.Snapshot{}) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) // commit up to index 0, try to read index 1 - if _, _, _, err = w.ReadAll(); err != nil { - t.Errorf("err = %v, want nil", err) - } + _, _, _, err = w.ReadAll() + require.NoErrorf(t, err, "err = %v, want nil", err) w.Close() } @@ -647,19 +519,13 @@ func TestOpenForRead(t *testing.T) { p := t.TempDir() // create WAL w, err := Create(zaptest.NewLogger(t), p, nil) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) defer w.Close() // make 10 separate files for i := 0; i < 10; i++ { es := []raftpb.Entry{{Index: uint64(i)}} - if err = w.Save(raftpb.HardState{}, es); err != nil { - t.Fatal(err) - } - if err = w.cut(); err != nil { - t.Fatal(err) - } + require.NoError(t, w.Save(raftpb.HardState{}, es)) + require.NoError(t, w.cut()) } // release the lock to 5 unlockIndex := uint64(5) @@ -667,24 +533,19 @@ func TestOpenForRead(t *testing.T) { // All are available for read w2, err := OpenForRead(zaptest.NewLogger(t), p, walpb.Snapshot{}) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) defer w2.Close() _, _, ents, err := w2.ReadAll() require.NoErrorf(t, err, "err = %v, want nil", err) - if g := ents[len(ents)-1].Index; g != 9 { - t.Errorf("last index read = %d, want %d", g, 9) - } + g := ents[len(ents)-1].Index + assert.Equalf(t, uint64(9), g, "last index read = %d, want %d", g, 9) } func TestOpenWithMaxIndex(t *testing.T) { p := t.TempDir() // create WAL w1, err := Create(zaptest.NewLogger(t), p, nil) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) defer func() { if w1 != nil { w1.Close() @@ -692,16 +553,12 @@ func TestOpenWithMaxIndex(t *testing.T) { }() es := []raftpb.Entry{{Index: uint64(math.MaxInt64)}} - if err = w1.Save(raftpb.HardState{}, es); err != nil { - t.Fatal(err) - } + require.NoError(t, w1.Save(raftpb.HardState{}, es)) w1.Close() w1 = nil w2, err := Open(zaptest.NewLogger(t), p, walpb.Snapshot{}) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) defer w2.Close() _, _, _, err = w2.ReadAll() @@ -714,12 +571,8 @@ func TestSaveEmpty(t *testing.T) { w := WAL{ encoder: newEncoder(&buf, 0, 0), } - if err := w.saveState(&est); err != nil { - t.Errorf("err = %v, want nil", err) - } - if len(buf.Bytes()) != 0 { - t.Errorf("buf.Bytes = %d, want 0", len(buf.Bytes())) - } + require.NoError(t, w.saveState(&est)) + assert.Emptyf(t, buf.Bytes(), "buf.Bytes = %d, want 0", len(buf.Bytes())) } func TestReleaseLockTo(t *testing.T) { @@ -727,48 +580,31 @@ func TestReleaseLockTo(t *testing.T) { // create WAL w, err := Create(zaptest.NewLogger(t), p, nil) defer func() { - if err = w.Close(); err != nil { - t.Fatal(err) - } + err = w.Close() + require.NoError(t, err) }() - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) // release nothing if no files - err = w.ReleaseLockTo(10) - if err != nil { - t.Errorf("err = %v, want nil", err) - } + require.NoError(t, w.ReleaseLockTo(10)) // make 10 separate files for i := 0; i < 10; i++ { es := []raftpb.Entry{{Index: uint64(i)}} - if err = w.Save(raftpb.HardState{}, es); err != nil { - t.Fatal(err) - } - if err = w.cut(); err != nil { - t.Fatal(err) - } + require.NoError(t, w.Save(raftpb.HardState{}, es)) + require.NoError(t, w.cut()) } // release the lock to 5 unlockIndex := uint64(5) w.ReleaseLockTo(unlockIndex) // expected remaining are 4,5,6,7,8,9,10 - if len(w.locks) != 7 { - t.Errorf("len(w.locks) = %d, want %d", len(w.locks), 7) - } + assert.Lenf(t, w.locks, 7, "len(w.locks) = %d, want %d", len(w.locks), 7) for i, l := range w.locks { var lockIndex uint64 _, lockIndex, err = parseWALName(filepath.Base(l.Name())) - if err != nil { - t.Fatal(err) - } - - if lockIndex != uint64(i+4) { - t.Errorf("#%d: lockindex = %d, want %d", i, lockIndex, uint64(i+4)) - } + require.NoError(t, err) + assert.Equalf(t, lockIndex, uint64(i+4), "#%d: lockindex = %d, want %d", i, lockIndex, uint64(i+4)) } // release the lock to 15 @@ -776,17 +612,10 @@ func TestReleaseLockTo(t *testing.T) { w.ReleaseLockTo(unlockIndex) // expected remaining is 10 - if len(w.locks) != 1 { - t.Errorf("len(w.locks) = %d, want %d", len(w.locks), 1) - } + assert.Lenf(t, w.locks, 1, "len(w.locks) = %d, want %d", len(w.locks), 1) _, lockIndex, err := parseWALName(filepath.Base(w.locks[0].Name())) - if err != nil { - t.Fatal(err) - } - - if lockIndex != uint64(10) { - t.Errorf("lockindex = %d, want %d", lockIndex, 10) - } + require.NoError(t, err) + assert.Equalf(t, uint64(10), lockIndex, "lockindex = %d, want %d", lockIndex, 10) } // TestTailWriteNoSlackSpace ensures that tail writes append if there's no preallocated space. @@ -795,57 +624,37 @@ func TestTailWriteNoSlackSpace(t *testing.T) { // create initial WAL w, err := Create(zaptest.NewLogger(t), p, []byte("metadata")) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) // write some entries for i := 1; i <= 5; i++ { es := []raftpb.Entry{{Index: uint64(i), Term: 1, Data: []byte{byte(i)}}} - if err = w.Save(raftpb.HardState{Term: 1}, es); err != nil { - t.Fatal(err) - } + require.NoError(t, w.Save(raftpb.HardState{Term: 1}, es)) } // get rid of slack space by truncating file off, serr := w.tail().Seek(0, io.SeekCurrent) - if serr != nil { - t.Fatal(serr) - } - if terr := w.tail().Truncate(off); terr != nil { - t.Fatal(terr) - } + require.NoError(t, serr) + require.NoError(t, w.tail().Truncate(off)) w.Close() // open, write more w, err = Open(zaptest.NewLogger(t), p, walpb.Snapshot{}) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) _, _, ents, rerr := w.ReadAll() - if rerr != nil { - t.Fatal(rerr) - } + require.NoError(t, rerr) require.Lenf(t, ents, 5, "got entries %+v, expected 5 entries", ents) // write more entries for i := 6; i <= 10; i++ { es := []raftpb.Entry{{Index: uint64(i), Term: 1, Data: []byte{byte(i)}}} - if err = w.Save(raftpb.HardState{Term: 1}, es); err != nil { - t.Fatal(err) - } + require.NoError(t, w.Save(raftpb.HardState{Term: 1}, es)) } w.Close() // confirm all writes w, err = Open(zaptest.NewLogger(t), p, walpb.Snapshot{}) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) _, _, ents, rerr = w.ReadAll() - if rerr != nil { - t.Fatal(rerr) - } - if len(ents) != 10 { - t.Fatalf("got entries %+v, expected 10 entries", ents) - } + require.NoError(t, rerr) + require.Lenf(t, ents, 10, "got entries %+v, expected 10 entries", ents) w.Close() } @@ -856,25 +665,17 @@ func TestRestartCreateWal(t *testing.T) { // make temporary directory so it looks like initialization is interrupted tmpdir := filepath.Clean(p) + ".tmp" - if err = os.Mkdir(tmpdir, fileutil.PrivateDirMode); err != nil { - t.Fatal(err) - } - if _, err = os.OpenFile(filepath.Join(tmpdir, "test"), os.O_WRONLY|os.O_CREATE, fileutil.PrivateFileMode); err != nil { - t.Fatal(err) - } + require.NoError(t, os.Mkdir(tmpdir, fileutil.PrivateDirMode)) + _, err = os.OpenFile(filepath.Join(tmpdir, "test"), os.O_WRONLY|os.O_CREATE, fileutil.PrivateFileMode) + require.NoError(t, err) w, werr := Create(zaptest.NewLogger(t), p, []byte("abc")) - if werr != nil { - t.Fatal(werr) - } + require.NoError(t, werr) w.Close() - if Exist(tmpdir) { - t.Fatalf("got %q exists, expected it to not exist", tmpdir) - } + require.Falsef(t, Exist(tmpdir), "got %q exists, expected it to not exist", tmpdir) - if w, err = OpenForRead(zaptest.NewLogger(t), p, walpb.Snapshot{}); err != nil { - t.Fatal(err) - } + w, err = OpenForRead(zaptest.NewLogger(t), p, walpb.Snapshot{}) + require.NoError(t, err) defer w.Close() if meta, _, _, rerr := w.ReadAll(); rerr != nil || string(meta) != "abc" { @@ -891,24 +692,18 @@ func TestOpenOnTornWrite(t *testing.T) { p := t.TempDir() w, err := Create(zaptest.NewLogger(t), p, nil) defer func() { - if err = w.Close(); err != nil && !errors.Is(err, os.ErrInvalid) { - t.Fatal(err) - } + err = w.Close() + require.ErrorIs(t, err, os.ErrInvalid) }() - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) // get offset of end of each saved entry offsets := make([]int64, maxEntries) for i := range offsets { es := []raftpb.Entry{{Index: uint64(i)}} - if err = w.Save(raftpb.HardState{}, es); err != nil { - t.Fatal(err) - } - if offsets[i], err = w.tail().Seek(0, io.SeekCurrent); err != nil { - t.Fatal(err) - } + require.NoError(t, w.Save(raftpb.HardState{}, es)) + offsets[i], err = w.tail().Seek(0, io.SeekCurrent) + require.NoError(t, err) } fn := filepath.Join(p, filepath.Base(w.tail().Name())) @@ -916,52 +711,36 @@ func TestOpenOnTornWrite(t *testing.T) { // clobber some entry with 0's to simulate a torn write f, ferr := os.OpenFile(fn, os.O_WRONLY, fileutil.PrivateFileMode) - if ferr != nil { - t.Fatal(ferr) - } + require.NoError(t, ferr) defer f.Close() _, err = f.Seek(offsets[clobberIdx], io.SeekStart) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) zeros := make([]byte, offsets[clobberIdx+1]-offsets[clobberIdx]) _, err = f.Write(zeros) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) f.Close() w, err = Open(zaptest.NewLogger(t), p, walpb.Snapshot{}) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) // seek up to clobbered entry _, _, _, err = w.ReadAll() - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) // write a few entries past the clobbered entry for i := 0; i < overwriteEntries; i++ { // Index is different from old, truncated entries es := []raftpb.Entry{{Index: uint64(i + clobberIdx), Data: []byte("new")}} - if err = w.Save(raftpb.HardState{}, es); err != nil { - t.Fatal(err) - } + require.NoError(t, w.Save(raftpb.HardState{}, es)) } w.Close() // read back the entries, confirm number of entries matches expectation w, err = OpenForRead(zaptest.NewLogger(t), p, walpb.Snapshot{}) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) _, _, ents, rerr := w.ReadAll() - if rerr != nil { - // CRC error? the old entries were likely never truncated away - t.Fatal(rerr) - } + // CRC error? the old entries were likely never truncated away + require.NoError(t, rerr) wEntries := (clobberIdx - 1) + overwriteEntries require.Equalf(t, len(ents), wEntries, "expected len(ents) = %d, got %d", wEntries, len(ents)) } @@ -994,9 +773,7 @@ func TestReadAllFail(t *testing.T) { // create initial WAL f, err := Create(zaptest.NewLogger(t), dir, []byte("metadata")) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) f.Close() // try to read without opening the WAL _, _, _, err = f.ReadAll() @@ -1018,39 +795,21 @@ func TestValidSnapshotEntries(t *testing.T) { snap4 := walpb.Snapshot{Index: 4, Term: 2, ConfState: &confState} // will be orphaned since the last committed entry will be snap3 func() { w, err := Create(zaptest.NewLogger(t), p, nil) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) defer w.Close() // snap0 is implicitly created at index 0, term 0 - if err = w.SaveSnapshot(snap1); err != nil { - t.Fatal(err) - } - if err = w.Save(state1, nil); err != nil { - t.Fatal(err) - } - if err = w.SaveSnapshot(snap2); err != nil { - t.Fatal(err) - } - if err = w.SaveSnapshot(snap3); err != nil { - t.Fatal(err) - } - if err = w.Save(state2, nil); err != nil { - t.Fatal(err) - } - if err = w.SaveSnapshot(snap4); err != nil { - t.Fatal(err) - } + require.NoError(t, w.SaveSnapshot(snap1)) + require.NoError(t, w.Save(state1, nil)) + require.NoError(t, w.SaveSnapshot(snap2)) + require.NoError(t, w.SaveSnapshot(snap3)) + require.NoError(t, w.Save(state2, nil)) + require.NoError(t, w.SaveSnapshot(snap4)) }() walSnaps, err := ValidSnapshotEntries(zaptest.NewLogger(t), p) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) expected := []walpb.Snapshot{snap0, snap1, snap2, snap3} - if !reflect.DeepEqual(walSnaps, expected) { - t.Errorf("expected walSnaps %+v, got %+v", expected, walSnaps) - } + assert.Truef(t, reflect.DeepEqual(walSnaps, expected), "expected walSnaps %+v, got %+v", expected, walSnaps) } // TestValidSnapshotEntriesAfterPurgeWal ensure that there are many wal files, and after cleaning the first wal file, @@ -1070,39 +829,23 @@ func TestValidSnapshotEntriesAfterPurgeWal(t *testing.T) { state2 := raftpb.HardState{Commit: 3, Term: 2} func() { w, err := Create(zaptest.NewLogger(t), p, nil) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) defer w.Close() // snap0 is implicitly created at index 0, term 0 - if err = w.SaveSnapshot(snap1); err != nil { - t.Fatal(err) - } - if err = w.Save(state1, nil); err != nil { - t.Fatal(err) - } - if err = w.SaveSnapshot(snap2); err != nil { - t.Fatal(err) - } - if err = w.SaveSnapshot(snap3); err != nil { - t.Fatal(err) - } + require.NoError(t, w.SaveSnapshot(snap1)) + require.NoError(t, w.Save(state1, nil)) + require.NoError(t, w.SaveSnapshot(snap2)) + require.NoError(t, w.SaveSnapshot(snap3)) for i := 0; i < 128; i++ { - if err = w.Save(state2, nil); err != nil { - t.Fatal(err) - } + require.NoError(t, w.Save(state2, nil)) } }() files, _, err := selectWALFiles(nil, p, snap0) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) os.Remove(p + "/" + files[0]) _, err = ValidSnapshotEntries(zaptest.NewLogger(t), p) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err) } func TestLastRecordLengthExceedFileEnd(t *testing.T) { diff --git a/server/storage/wal/walpb/record_test.go b/server/storage/wal/walpb/record_test.go index cdacb3d03f21..90fd85cd1a50 100644 --- a/server/storage/wal/walpb/record_test.go +++ b/server/storage/wal/walpb/record_test.go @@ -18,6 +18,7 @@ import ( "testing" "github.com/golang/protobuf/descriptor" + "github.com/stretchr/testify/assert" "go.etcd.io/raft/v3/raftpb" ) @@ -25,10 +26,8 @@ import ( func TestSnapshotMetadataCompatibility(t *testing.T) { _, snapshotMetadataMd := descriptor.ForMessage(&raftpb.SnapshotMetadata{}) _, snapshotMd := descriptor.ForMessage(&Snapshot{}) - if len(snapshotMetadataMd.GetField()) != len(snapshotMd.GetField()) { - t.Errorf("Different number of fields in raftpb.SnapshotMetadata vs. walpb.Snapshot. " + - "They are supposed to be in sync.") - } + assert.Lenf(t, snapshotMd.GetField(), len(snapshotMetadataMd.GetField()), "Different number of fields in raftpb.SnapshotMetadata vs. walpb.Snapshot. "+ + "They are supposed to be in sync.") } func TestValidateSnapshot(t *testing.T) {