test: Add some tests and remove dead code in store (#13614)

store/cache/cache_test.go

@@ -9,6 +9,7 @@ import (
 	dbm "github.com/tendermint/tm-db"
 
 	"github.com/cosmos/cosmos-sdk/store/cache"
+	"github.com/cosmos/cosmos-sdk/store/cachekv"
 	iavlstore "github.com/cosmos/cosmos-sdk/store/iavl"
 	"github.com/cosmos/cosmos-sdk/store/types"
 )
@@ -67,3 +68,37 @@ func TestStoreCache(t *testing.T) {
 		require.Nil(t, store.Get(key))
 	}
 }
+
+func TestReset(t *testing.T) {
+	db := dbm.NewMemDB()
+	mngr := cache.NewCommitKVStoreCacheManager(cache.DefaultCommitKVStoreCacheSize)
+
+	sKey := types.NewKVStoreKey("test")
+	tree, err := iavl.NewMutableTree(db, 100, false)
+	require.NoError(t, err)
+	store := iavlstore.UnsafeNewStore(tree)
+	store2 := mngr.GetStoreCache(sKey, store)
+
+	require.NotNil(t, store2)
+	require.Equal(t, store2, mngr.GetStoreCache(sKey, store))
+
+	// reset and check if the cache is gone
+	mngr.Reset()
+	require.Nil(t, mngr.Unwrap(sKey))
+
+	// check if the cache is recreated
+	require.Equal(t, store2, mngr.GetStoreCache(sKey, store))
+}
+
+func TestCacheWrap(t *testing.T) {
+	db := dbm.NewMemDB()
+	mngr := cache.NewCommitKVStoreCacheManager(cache.DefaultCommitKVStoreCacheSize)
+
+	sKey := types.NewKVStoreKey("test")
+	tree, err := iavl.NewMutableTree(db, 100, false)
+	require.NoError(t, err)
+	store := iavlstore.UnsafeNewStore(tree)
+
+	cacheWrapper := mngr.GetStoreCache(sKey, store).CacheWrap()
+	require.IsType(t, &cachekv.Store{}, cacheWrapper)
+}

store/firstlast.go

@@ -1,41 +0,0 @@
-package store
-
-import (
-	"bytes"
-
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	sdkkv "github.com/cosmos/cosmos-sdk/types/kv"
-)
-
-// First gets the first item.
-func First(st KVStore, start, end []byte) (kv sdkkv.Pair, ok bool) {
-	iter := st.Iterator(start, end)
-	if !iter.Valid() {
-		return kv, false
-	}
-	defer iter.Close()
-
-	return sdkkv.Pair{Key: iter.Key(), Value: iter.Value()}, true
-}
-
-// Last gets the last item.  `end` is exclusive.
-func Last(st KVStore, start, end []byte) (kv sdkkv.Pair, ok bool) {
-	iter := st.ReverseIterator(end, start)
-	if !iter.Valid() {
-		if v := st.Get(start); v != nil {
-			return sdkkv.Pair{Key: sdk.CopyBytes(start), Value: sdk.CopyBytes(v)}, true
-		}
-		return kv, false
-	}
-	defer iter.Close()
-
-	if bytes.Equal(iter.Key(), end) {
-		// Skip this one, end is exclusive.
-		iter.Next()
-		if !iter.Valid() {
-			return kv, false
-		}
-	}
-
-	return sdkkv.Pair{Key: iter.Key(), Value: iter.Value()}, true
-}

store/internal/proofs/create_test.go

@@ -26,8 +26,15 @@ func TestCreateMembership(t *testing.T) {
 			data := BuildMap(tc.size)
 			allkeys := SortedKeys(data)
 			key := GetKey(allkeys, tc.loc)
+			nonKey := GetNonKey(allkeys, tc.loc)
+
+			// error if the key does not exist
+			proof, err := CreateMembershipProof(data, []byte(nonKey))
+			assert.EqualError(t, err, "cannot make existence proof if key is not in map")
+			assert.Nil(t, proof)
+
 			val := data[key]
-			proof, err := CreateMembershipProof(data, []byte(key))
+			proof, err = CreateMembershipProof(data, []byte(key))
 			if err != nil {
 				t.Fatalf("Creating Proof: %+v", err)
 			}
@@ -66,9 +73,15 @@ func TestCreateNonMembership(t *testing.T) {
 		t.Run(name, func(t *testing.T) {
 			data := BuildMap(tc.size)
 			allkeys := SortedKeys(data)
-			key := GetNonKey(allkeys, tc.loc)
+			nonKey := GetNonKey(allkeys, tc.loc)
+			key := GetKey(allkeys, tc.loc)
 
+			// error if the key exists
 			proof, err := CreateNonMembershipProof(data, []byte(key))
+			assert.EqualError(t, err, "cannot create non-membership proof if key is in map")
+			assert.Nil(t, proof)
+
+			proof, err = CreateNonMembershipProof(data, []byte(nonKey))
 			if err != nil {
 				t.Fatalf("Creating Proof: %+v", err)
 			}
@@ -77,12 +90,12 @@ func TestCreateNonMembership(t *testing.T) {
 			}
 
 			root := CalcRoot(data)
-			err = proof.GetNonexist().Verify(ics23.TendermintSpec, root, []byte(key))
+			err = proof.GetNonexist().Verify(ics23.TendermintSpec, root, []byte(nonKey))
 			if err != nil {
 				t.Fatalf("Verifying Proof: %+v", err)
 			}
 
-			valid := ics23.VerifyNonMembership(ics23.TendermintSpec, root, proof, []byte(key))
+			valid := ics23.VerifyNonMembership(ics23.TendermintSpec, root, proof, []byte(nonKey))
 			if !valid {
 				t.Fatalf("Non Membership Proof Invalid")
 			}

store/mem/mem_test.go

@@ -4,6 +4,7 @@ import (
 	"testing"
 
 	"github.com/cosmos/cosmos-sdk/store/cachekv"
+	pruningtypes "github.com/cosmos/cosmos-sdk/store/pruning/types"
 
 	"github.com/stretchr/testify/require"
 
@@ -13,10 +14,10 @@ import (
 
 func TestStore(t *testing.T) {
 	db := mem.NewStore()
-	key, value := []byte("key"), []byte("value")
-
 	require.Equal(t, types.StoreTypeMemory, db.GetStoreType())
 
+	key, value := []byte("key"), []byte("value")
+
 	require.Nil(t, db.Get(key))
 	db.Set(key, value)
 	require.Equal(t, value, db.Get(key))
@@ -48,3 +49,9 @@ func TestCommit(t *testing.T) {
 	require.True(t, db.LastCommitID().IsZero())
 	require.Equal(t, value, db.Get(key))
 }
+
+func TestStorePrunningOptions(t *testing.T) {
+	// this is a no-op
+	db := mem.NewStore()
+	require.Equal(t, pruningtypes.NewPruningOptions(pruningtypes.PruningUndefined), db.GetPruning())
+}

store/types/store_test.go

@@ -10,6 +10,9 @@ import (
 
 func TestStoreUpgrades(t *testing.T) {
 	t.Parallel()
+	type toAdd struct {
+		key string
+	}
 	type toDelete struct {
 		key    string
 		delete bool
@@ -21,6 +24,7 @@ func TestStoreUpgrades(t *testing.T) {
 
 	cases := map[string]struct {
 		upgrades     *StoreUpgrades
+		expectAdd    []toAdd
 		expectDelete []toDelete
 		expectRename []toRename
 	}{
@@ -38,9 +42,11 @@ func TestStoreUpgrades(t *testing.T) {
 		},
 		"many data points": {
 			upgrades: &StoreUpgrades{
+				Added:   []string{"foo", "bar", "baz"},
 				Deleted: []string{"one", "two", "three", "four", "five"},
 				Renamed: []StoreRename{{"old", "new"}, {"white", "blue"}, {"black", "orange"}, {"fun", "boring"}},
 			},
+			expectAdd:    []toAdd{{"foo"}, {"bar"}, {"baz"}},
 			expectDelete: []toDelete{{"four", true}, {"six", false}, {"baz", false}},
 			expectRename: []toRename{{"white", ""}, {"blue", "white"}, {"boring", "fun"}, {"missing", ""}},
 		},
@@ -49,6 +55,9 @@ func TestStoreUpgrades(t *testing.T) {
 	for name, tc := range cases {
 		tc := tc
 		t.Run(name, func(t *testing.T) {
+			for _, r := range tc.expectAdd {
+				assert.Equal(t, tc.upgrades.IsAdded(r.key), true)
+			}
 			for _, d := range tc.expectDelete {
 				assert.Equal(t, tc.upgrades.IsDeleted(d.key), d.delete)
 			}
@@ -91,6 +100,14 @@ func TestTransientStoreKey(t *testing.T) {
 	require.Equal(t, fmt.Sprintf("TransientStoreKey{%p, test}", key), key.String())
 }
 
+func TestMemoryStoreKey(t *testing.T) {
+	t.Parallel()
+	key := NewMemoryStoreKey("test")
+	require.Equal(t, "test", key.name)
+	require.Equal(t, key.name, key.Name())
+	require.Equal(t, fmt.Sprintf("MemoryStoreKey{%p, test}", key), key.String())
+}
+
 func TestTraceContext_Clone(t *testing.T) {
 	tests := []struct {
 		name string