Cleanup database tests (#2654)

dhrubabasu · web-flow · commit 0b344bd66b0f · 2024-01-23T17:16:49.000-05:00
diff --git a/database/corruptabledb/db_test.go b/database/corruptabledb/db_test.go
@@ -18,19 +18,19 @@ import (
 
 var errTest = errors.New("non-nil error")
 
-func TestInterface(t *testing.T) {
-	for _, test := range database.Tests {
-		baseDB := memdb.New()
-		db := New(baseDB)
-		test(t, db)
-	}
-}
-
 func newDB() *Database {
 	baseDB := memdb.New()
 	return New(baseDB)
 }
 
+func TestInterface(t *testing.T) {
+	for name, test := range database.Tests {
+		t.Run(name, func(t *testing.T) {
+			test(t, newDB())
+		})
+	}
+}
+
 func FuzzKeyValue(f *testing.F) {
 	database.FuzzKeyValue(f, newDB())
 }
diff --git a/database/encdb/db_test.go b/database/encdb/db_test.go
@@ -16,12 +16,14 @@ import (
 const testPassword = "lol totally a secure password" //nolint:gosec
 
 func TestInterface(t *testing.T) {
-	for _, test := range database.Tests {
-		unencryptedDB := memdb.New()
-		db, err := New([]byte(testPassword), unencryptedDB)
-		require.NoError(t, err)
-
-		test(t, db)
+	for name, test := range database.Tests {
+		t.Run(name, func(t *testing.T) {
+			unencryptedDB := memdb.New()
+			db, err := New([]byte(testPassword), unencryptedDB)
+			require.NoError(t, err)
+
+			test(t, db)
+		})
 	}
 }
 
diff --git a/database/leveldb/db_test.go b/database/leveldb/db_test.go
@@ -16,14 +16,16 @@ import (
 )
 
 func TestInterface(t *testing.T) {
-	for _, test := range database.Tests {
-		folder := t.TempDir()
-		db, err := New(folder, nil, logging.NoLog{}, "", prometheus.NewRegistry())
-		require.NoError(t, err)
+	for name, test := range database.Tests {
+		t.Run(name, func(t *testing.T) {
+			folder := t.TempDir()
+			db, err := New(folder, nil, logging.NoLog{}, "", prometheus.NewRegistry())
+			require.NoError(t, err)
 
-		test(t, db)
+			test(t, db)
 
-		_ = db.Close()
+			_ = db.Close()
+		})
 	}
 }
 
diff --git a/database/memdb/db_test.go b/database/memdb/db_test.go
@@ -11,8 +11,10 @@ import (
 )
 
 func TestInterface(t *testing.T) {
-	for _, test := range database.Tests {
-		test(t, New())
+	for name, test := range database.Tests {
+		t.Run(name, func(t *testing.T) {
+			test(t, New())
+		})
 	}
 }
 
diff --git a/database/meterdb/db_test.go b/database/meterdb/db_test.go
@@ -16,12 +16,14 @@ import (
 )
 
 func TestInterface(t *testing.T) {
-	for _, test := range database.Tests {
-		baseDB := memdb.New()
-		db, err := New("", prometheus.NewRegistry(), baseDB)
-		require.NoError(t, err)
-
-		test(t, db)
+	for name, test := range database.Tests {
+		t.Run(name, func(t *testing.T) {
+			baseDB := memdb.New()
+			db, err := New("", prometheus.NewRegistry(), baseDB)
+			require.NoError(t, err)
+
+			test(t, db)
+		})
 	}
 }
 
diff --git a/database/pebble/db_test.go b/database/pebble/db_test.go
@@ -23,10 +23,12 @@ func newDB(t testing.TB) *Database {
 }
 
 func TestInterface(t *testing.T) {
-	for _, test := range database.Tests {
-		db := newDB(t)
-		test(t, db)
-		_ = db.Close()
+	for name, test := range database.Tests {
+		t.Run(name, func(t *testing.T) {
+			db := newDB(t)
+			test(t, db)
+			_ = db.Close()
+		})
 	}
 }
 
diff --git a/database/prefixdb/db_test.go b/database/prefixdb/db_test.go
@@ -12,14 +12,16 @@ import (
 )
 
 func TestInterface(t *testing.T) {
-	for _, test := range database.Tests {
-		db := memdb.New()
-		test(t, New([]byte("hello"), db))
-		test(t, New([]byte("world"), db))
-		test(t, New([]byte("wor"), New([]byte("ld"), db)))
-		test(t, New([]byte("ld"), New([]byte("wor"), db)))
-		test(t, NewNested([]byte("wor"), New([]byte("ld"), db)))
-		test(t, NewNested([]byte("ld"), New([]byte("wor"), db)))
+	for name, test := range database.Tests {
+		t.Run(name, func(t *testing.T) {
+			db := memdb.New()
+			test(t, New([]byte("hello"), db))
+			test(t, New([]byte("world"), db))
+			test(t, New([]byte("wor"), New([]byte("ld"), db)))
+			test(t, New([]byte("ld"), New([]byte("wor"), db)))
+			test(t, NewNested([]byte("wor"), New([]byte("ld"), db)))
+			test(t, NewNested([]byte("ld"), New([]byte("wor"), db)))
+		})
 	}
 }
 
diff --git a/database/rpcdb/db_test.go b/database/rpcdb/db_test.go
@@ -54,11 +54,13 @@ func setupDB(t testing.TB) *testDatabase {
 }
 
 func TestInterface(t *testing.T) {
-	for _, test := range database.Tests {
-		db := setupDB(t)
-		test(t, db.client)
+	for name, test := range database.Tests {
+		t.Run(name, func(t *testing.T) {
+			db := setupDB(t)
+			test(t, db.client)
 
-		db.closeFn()
+			db.closeFn()
+		})
 	}
 }
 
diff --git a/database/test_database.go b/database/test_database.go
@@ -24,44 +24,44 @@ import (
 )
 
 // Tests is a list of all database tests
-var Tests = []func(t *testing.T, db Database){
-	TestSimpleKeyValue,
-	TestOverwriteKeyValue,
-	TestEmptyKey,
-	TestKeyEmptyValue,
-	TestSimpleKeyValueClosed,
-	TestNewBatchClosed,
-	TestBatchPut,
-	TestBatchDelete,
-	TestBatchReset,
-	TestBatchReuse,
-	TestBatchRewrite,
-	TestBatchReplay,
-	TestBatchReplayPropagateError,
-	TestBatchInner,
-	TestBatchLargeSize,
-	TestIteratorSnapshot,
-	TestIterator,
-	TestIteratorStart,
-	TestIteratorPrefix,
-	TestIteratorStartPrefix,
-	TestIteratorMemorySafety,
-	TestIteratorClosed,
-	TestIteratorError,
-	TestIteratorErrorAfterRelease,
-	TestCompactNoPanic,
-	TestMemorySafetyDatabase,
-	TestMemorySafetyBatch,
-	TestAtomicClear,
-	TestClear,
-	TestAtomicClearPrefix,
-	TestClearPrefix,
-	TestModifyValueAfterPut,
-	TestModifyValueAfterBatchPut,
-	TestModifyValueAfterBatchPutReplay,
-	TestConcurrentBatches,
-	TestManySmallConcurrentKVPairBatches,
-	TestPutGetEmpty,
+var Tests = map[string]func(t *testing.T, db Database){
+	"SimpleKeyValue":                   TestSimpleKeyValue,
+	"OverwriteKeyValue":                TestOverwriteKeyValue,
+	"EmptyKey":                         TestEmptyKey,
+	"KeyEmptyValue":                    TestKeyEmptyValue,
+	"SimpleKeyValueClosed":             TestSimpleKeyValueClosed,
+	"NewBatchClosed":                   TestNewBatchClosed,
+	"BatchPut":                         TestBatchPut,
+	"BatchDelete":                      TestBatchDelete,
+	"BatchReset":                       TestBatchReset,
+	"BatchReuse":                       TestBatchReuse,
+	"BatchRewrite":                     TestBatchRewrite,
+	"BatchReplay":                      TestBatchReplay,
+	"BatchReplayPropagateError":        TestBatchReplayPropagateError,
+	"BatchInner":                       TestBatchInner,
+	"BatchLargeSize":                   TestBatchLargeSize,
+	"IteratorSnapshot":                 TestIteratorSnapshot,
+	"Iterator":                         TestIterator,
+	"IteratorStart":                    TestIteratorStart,
+	"IteratorPrefix":                   TestIteratorPrefix,
+	"IteratorStartPrefix":              TestIteratorStartPrefix,
+	"IteratorMemorySafety":             TestIteratorMemorySafety,
+	"IteratorClosed":                   TestIteratorClosed,
+	"IteratorError":                    TestIteratorError,
+	"IteratorErrorAfterRelease":        TestIteratorErrorAfterRelease,
+	"CompactNoPanic":                   TestCompactNoPanic,
+	"MemorySafetyDatabase":             TestMemorySafetyDatabase,
+	"MemorySafetyBatch":                TestMemorySafetyBatch,
+	"AtomicClear":                      TestAtomicClear,
+	"Clear":                            TestClear,
+	"AtomicClearPrefix":                TestAtomicClearPrefix,
+	"ClearPrefix":                      TestClearPrefix,
+	"ModifyValueAfterPut":              TestModifyValueAfterPut,
+	"ModifyValueAfterBatchPut":         TestModifyValueAfterBatchPut,
+	"ModifyValueAfterBatchPutReplay":   TestModifyValueAfterBatchPutReplay,
+	"ConcurrentBatches":                TestConcurrentBatches,
+	"ManySmallConcurrentKVPairBatches": TestManySmallConcurrentKVPairBatches,
+	"PutGetEmpty":                      TestPutGetEmpty,
 }
 
 // TestSimpleKeyValue tests to make sure that simple Put + Get + Delete + Has
diff --git a/database/versiondb/db_test.go b/database/versiondb/db_test.go
@@ -14,9 +14,11 @@ import (
 )
 
 func TestInterface(t *testing.T) {
-	for _, test := range database.Tests {
-		baseDB := memdb.New()
-		test(t, New(baseDB))
+	for name, test := range database.Tests {
+		t.Run(name, func(t *testing.T) {
+			baseDB := memdb.New()
+			test(t, New(baseDB))
+		})
 	}
 }
 
diff --git a/x/merkledb/db_test.go b/x/merkledb/db_test.go
@@ -99,10 +99,12 @@ func Test_MerkleDB_GetValues_Safety(t *testing.T) {
 
 func Test_MerkleDB_DB_Interface(t *testing.T) {
 	for _, bf := range validBranchFactors {
-		for _, test := range database.Tests {
-			db, err := getBasicDBWithBranchFactor(bf)
-			require.NoError(t, err)
-			test(t, db)
+		for name, test := range database.Tests {
+			t.Run(fmt.Sprintf("%s_%d", name, bf), func(t *testing.T) {
+				db, err := getBasicDBWithBranchFactor(bf)
+				require.NoError(t, err)
+				test(t, db)
+			})
 		}
 	}
 }

Original file line number	Diff line number	Diff line change
`@@ -16,14 +16,16 @@ import (`
`16`	`16`	`)`
`17`	`17`
`18`	`18`	`func TestInterface(t *testing.T) {`
`19`		`- for _, test := range database.Tests {`
`20`		`- folder := t.TempDir()`
`21`		`- db, err := New(folder, nil, logging.NoLog{}, "", prometheus.NewRegistry())`
`22`		`- require.NoError(t, err)`
	`19`	`+ for name, test := range database.Tests {`
	`20`	`+ t.Run(name, func(t *testing.T) {`
	`21`	`+ folder := t.TempDir()`
	`22`	`+ db, err := New(folder, nil, logging.NoLog{}, "", prometheus.NewRegistry())`
	`23`	`+ require.NoError(t, err)`
`23`	`24`
`24`		`- test(t, db)`
	`25`	`+ test(t, db)`
`25`	`26`
`26`		`- _ = db.Close()`
	`27`	`+ _ = db.Close()`
	`28`	`+ })`
`27`	`29`	`}`
`28`	`30`	`}`
`29`	`31`
Original file line number	Diff line number	Diff line change
`@@ -11,8 +11,10 @@ import (`
`11`	`11`	`)`
`12`	`12`
`13`	`13`	`func TestInterface(t *testing.T) {`
`14`		`- for _, test := range database.Tests {`
`15`		`- test(t, New())`
	`14`	`+ for name, test := range database.Tests {`
	`15`	`+ t.Run(name, func(t *testing.T) {`
	`16`	`+ test(t, New())`
	`17`	`+ })`
`16`	`18`	`}`
`17`	`19`	`}`
`18`	`20`
Original file line number	Diff line number	Diff line change
`@@ -16,12 +16,14 @@ import (`
`16`	`16`	`)`
`17`	`17`
`18`	`18`	`func TestInterface(t *testing.T) {`
`19`		`- for _, test := range database.Tests {`
`20`		`- baseDB := memdb.New()`
`21`		`- db, err := New("", prometheus.NewRegistry(), baseDB)`
`22`		`- require.NoError(t, err)`
`23`		`-`
`24`		`- test(t, db)`
	`19`	`+ for name, test := range database.Tests {`
	`20`	`+ t.Run(name, func(t *testing.T) {`
	`21`	`+ baseDB := memdb.New()`
	`22`	`+ db, err := New("", prometheus.NewRegistry(), baseDB)`
	`23`	`+ require.NoError(t, err)`
	`24`	`+`
	`25`	`+ test(t, db)`
	`26`	`+ })`
`25`	`27`	`}`
`26`	`28`	`}`
`27`	`29`
Original file line number	Diff line number	Diff line change
`@@ -23,10 +23,12 @@ func newDB(t testing.TB) *Database {`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`func TestInterface(t *testing.T) {`
`26`		`- for _, test := range database.Tests {`
`27`		`- db := newDB(t)`
`28`		`- test(t, db)`
`29`		`- _ = db.Close()`
	`26`	`+ for name, test := range database.Tests {`
	`27`	`+ t.Run(name, func(t *testing.T) {`
	`28`	`+ db := newDB(t)`
	`29`	`+ test(t, db)`
	`30`	`+ _ = db.Close()`
	`31`	`+ })`
`30`	`32`	`}`
`31`	`33`	`}`
`32`	`34`
Original file line number	Diff line number	Diff line change
`@@ -54,11 +54,13 @@ func setupDB(t testing.TB) *testDatabase {`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`func TestInterface(t *testing.T) {`
`57`		`- for _, test := range database.Tests {`
`58`		`- db := setupDB(t)`
`59`		`- test(t, db.client)`
	`57`	`+ for name, test := range database.Tests {`
	`58`	`+ t.Run(name, func(t *testing.T) {`
	`59`	`+ db := setupDB(t)`
	`60`	`+ test(t, db.client)`
`60`	`61`
`61`		`- db.closeFn()`
	`62`	`+ db.closeFn()`
	`63`	`+ })`
`62`	`64`	`}`
`63`	`65`	`}`
`64`	`66`
Original file line number	Diff line number	Diff line change
`@@ -14,9 +14,11 @@ import (`
`14`	`14`	`)`
`15`	`15`
`16`	`16`	`func TestInterface(t *testing.T) {`
`17`		`- for _, test := range database.Tests {`
`18`		`- baseDB := memdb.New()`
`19`		`- test(t, New(baseDB))`
	`17`	`+ for name, test := range database.Tests {`
	`18`	`+ t.Run(name, func(t *testing.T) {`
	`19`	`+ baseDB := memdb.New()`
	`20`	`+ test(t, New(baseDB))`
	`21`	`+ })`
`20`	`22`	`}`
`21`	`23`	`}`
`22`	`24`