add extra test

database/tbcd/level/level.go

@@ -2045,13 +2045,17 @@ func (l *ldb) KeystonesByHeight(ctx context.Context, height uint32, depth int) (
 		deks := decodeKeystone(eks)
 		kssList = append(kssList, deks)
 	}
+	if i.Error() != nil {
+		return nil, fmt.Errorf("keystones iterator: %w", i.Error())
+	}
+
 	if len(kssList) == 0 {
 		return nil, database.NotFoundError(fmt.Sprintf("no first occurrence "+
 			"keystones range: %v < %v",
 			min(start, end), max(start, end)))
 	}
 
-	return kssList, i.Error()
+	return kssList, nil
 }
 
 func (l *ldb) BlockKeystoneUpdate(ctx context.Context, direction int, keystones map[chainhash.Hash]tbcd.Keystone, keystoneIndexHash chainhash.Hash) error {

database/tbcd/level/level_test.go

@@ -19,6 +19,7 @@ import (
 	"github.com/go-test/deep"
 
 	"github.com/hemilabs/heminetwork/database"
+	"github.com/hemilabs/heminetwork/database/level"
 	"github.com/hemilabs/heminetwork/database/tbcd"
 	"github.com/hemilabs/heminetwork/hemi"
 	"github.com/hemilabs/heminetwork/testutil"
@@ -720,3 +721,120 @@ func TestHeightHashEncoding(t *testing.T) {
 		t.Fatalf("decoded hash != kss hash (%v != %v)", uhash, hash)
 	}
 }
+
+func TestDbUpgradeV4Errors(t *testing.T) {
+	type testTableItem struct {
+		name  string
+		key   []byte
+		value []byte
+		pass  bool
+	}
+
+	ks := hemi.L2Keystone{
+		Version:            1,
+		ParentEPHash:       testutil.FillBytes("v1parentephash", 32),
+		PrevKeystoneEPHash: testutil.FillBytes("v1prevkeystoneephash", 32),
+		StateRoot:          testutil.FillBytes("v1stateroot", 32),
+		EPHash:             testutil.FillBytes("v1ephash", 32),
+	}
+	abrevKss := hemi.L2KeystoneAbbreviate(ks)
+
+	fakeHash, err := chainhash.NewHashFromStr("1000000050ff3053ada24e6ad581fa0295297f20a2747d034997ffc899aa931e")
+	if err != nil {
+		t.Fatal(err)
+	}
+	realHash, err := chainhash.NewHashFromStr("000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	invalidBlockKss := tbcd.Keystone{
+		BlockHash:           *fakeHash,
+		BlockHeight:         10,
+		AbbreviatedKeystone: abrevKss.Serialize(),
+	}
+	validKss := tbcd.Keystone{
+		BlockHash:           *realHash,
+		BlockHeight:         10,
+		AbbreviatedKeystone: abrevKss.Serialize(),
+	}
+
+	testTable := []testTableItem{
+		{
+			name:  "invalid blockheader",
+			key:   fakeHash[:],
+			value: encodeKeystoneToSliceV1(invalidBlockKss),
+		},
+		{
+			name:  "invalid keystone hash",
+			key:   realHash[:15],
+			value: encodeKeystoneToSliceV1(validKss),
+		},
+		{
+			name: "no errors",
+			pass: true,
+		},
+	}
+
+	for _, tti := range testTable {
+		t.Run(tti.name, func(t *testing.T) {
+			home := t.TempDir()
+			network := "upgradetest"
+			t.Logf("temp: %v", home)
+
+			ctx, cancel := context.WithCancel(t.Context())
+			defer func() {
+				cancel()
+			}()
+
+			cfg, err := NewConfig(network, home, "0mb", "0mb")
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			cfg.SetUpgradeOpen(true)
+			dbTemp, err := New(ctx, cfg)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			if err := dbTemp.insertTable(level.KeystonesDB, tti.key, tti.value); err != nil {
+				panic(err)
+			}
+
+			// Write new version
+			v := make([]byte, 8)
+			binary.BigEndian.PutUint64(v, 1)
+			if err := dbTemp.MetadataPut(ctx, versionKey, v); err != nil {
+				t.Fatal(err)
+			}
+
+			if err := dbTemp.Close(); err != nil {
+				t.Fatal(err)
+			}
+
+			cfg.SetUpgradeOpen(false)
+			// upgrade
+			_, err = New(ctx, cfg)
+			if !tti.pass && err == nil {
+				t.Fatal("expected error")
+			}
+			if tti.pass && err != nil {
+				t.Fatal(err)
+			}
+
+			t.Log(err)
+		})
+	}
+}
+
+func encodeKeystoneV1(ks tbcd.Keystone) (eks [chainhash.HashSize + hemi.L2KeystoneAbrevSize]byte) {
+	copy(eks[0:32], ks.BlockHash[:])
+	copy(eks[32:], ks.AbbreviatedKeystone[:])
+	return
+}
+
+func encodeKeystoneToSliceV1(ks tbcd.Keystone) []byte {
+	eks := encodeKeystoneV1(ks)
+	return eks[:]
+}

database/tbcd/level/upgrade.go

@@ -555,14 +555,13 @@ func (l *ldb) v3(ctx context.Context) error {
 // v4 upgrade the database from v3 to v4.
 // Changes:
 // Add heighthash (L2 height - Keystone Hash) to keystone database.
-// XXX antonio add test
 func (l *ldb) v4(ctx context.Context) error {
 	log.Tracef("v4")
 	defer log.Tracef("v4 exit")
 
 	log.Infof("Upgrading database from v3 to v4")
 
-	// Index all keystones to M[height][hash] format.
+	// Index all keystones to H[height][hash] format.
 	bhs := l.pool[level.BlockHeadersDB]
 	ksdb := l.pool[level.KeystonesDB]
 	i := ksdb.NewIterator(&util.Range{Start: nil, Limit: nil}, nil)