github.com/Finschia/finschia-sdk@v0.49.1/store/tracekv/store_test.go (about)

     1  package tracekv_test
     2  
     3  import (
     4  	"bytes"
     5  	"fmt"
     6  	"io"
     7  	"testing"
     8  
     9  	"github.com/stretchr/testify/require"
    10  	dbm "github.com/tendermint/tm-db"
    11  
    12  	"github.com/Finschia/finschia-sdk/store/dbadapter"
    13  	"github.com/Finschia/finschia-sdk/store/prefix"
    14  	"github.com/Finschia/finschia-sdk/store/tracekv"
    15  	"github.com/Finschia/finschia-sdk/store/types"
    16  )
    17  
    18  func bz(s string) []byte { return []byte(s) }
    19  
    20  func keyFmt(i int) []byte { return bz(fmt.Sprintf("key%0.8d", i)) }
    21  func valFmt(i int) []byte { return bz(fmt.Sprintf("value%0.8d", i)) }
    22  
    23  var kvPairs = []types.KVPair{
    24  	{Key: keyFmt(1), Value: valFmt(1)},
    25  	{Key: keyFmt(2), Value: valFmt(2)},
    26  	{Key: keyFmt(3), Value: valFmt(3)},
    27  }
    28  
    29  func newTraceKVStore(w io.Writer) *tracekv.Store {
    30  	store := newEmptyTraceKVStore(w)
    31  
    32  	for _, kvPair := range kvPairs {
    33  		store.Set(kvPair.Key, kvPair.Value)
    34  	}
    35  
    36  	return store
    37  }
    38  
    39  func newEmptyTraceKVStore(w io.Writer) *tracekv.Store {
    40  	dbm := dbadapter.Store{DB: dbm.NewMemDB()}
    41  	tc := types.TraceContext(map[string]interface{}{"blockHeight": 64})
    42  
    43  	return tracekv.NewStore(dbm, w, tc)
    44  }
    45  
    46  func TestTraceKVStoreGet(t *testing.T) {
    47  	testCases := []struct {
    48  		key           []byte
    49  		expectedValue []byte
    50  		expectedOut   string
    51  	}{
    52  		{
    53  			key:           kvPairs[0].Key,
    54  			expectedValue: kvPairs[0].Value,
    55  			expectedOut:   "{\"operation\":\"read\",\"key\":\"a2V5MDAwMDAwMDE=\",\"value\":\"dmFsdWUwMDAwMDAwMQ==\",\"metadata\":{\"blockHeight\":64}}\n",
    56  		},
    57  		{
    58  			key:           []byte("does-not-exist"),
    59  			expectedValue: nil,
    60  			expectedOut:   "{\"operation\":\"read\",\"key\":\"ZG9lcy1ub3QtZXhpc3Q=\",\"value\":\"\",\"metadata\":{\"blockHeight\":64}}\n",
    61  		},
    62  	}
    63  
    64  	for _, tc := range testCases {
    65  		var buf bytes.Buffer
    66  
    67  		store := newTraceKVStore(&buf)
    68  		buf.Reset()
    69  		value := store.Get(tc.key)
    70  
    71  		require.Equal(t, tc.expectedValue, value)
    72  		require.Equal(t, tc.expectedOut, buf.String())
    73  	}
    74  }
    75  
    76  func TestTraceKVStoreSet(t *testing.T) {
    77  	testCases := []struct {
    78  		key         []byte
    79  		value       []byte
    80  		expectedOut string
    81  	}{
    82  		{
    83  			key:         kvPairs[0].Key,
    84  			value:       kvPairs[0].Value,
    85  			expectedOut: "{\"operation\":\"write\",\"key\":\"a2V5MDAwMDAwMDE=\",\"value\":\"dmFsdWUwMDAwMDAwMQ==\",\"metadata\":{\"blockHeight\":64}}\n",
    86  		},
    87  		{
    88  			key:         kvPairs[1].Key,
    89  			value:       kvPairs[1].Value,
    90  			expectedOut: "{\"operation\":\"write\",\"key\":\"a2V5MDAwMDAwMDI=\",\"value\":\"dmFsdWUwMDAwMDAwMg==\",\"metadata\":{\"blockHeight\":64}}\n",
    91  		},
    92  		{
    93  			key:         kvPairs[2].Key,
    94  			value:       kvPairs[2].Value,
    95  			expectedOut: "{\"operation\":\"write\",\"key\":\"a2V5MDAwMDAwMDM=\",\"value\":\"dmFsdWUwMDAwMDAwMw==\",\"metadata\":{\"blockHeight\":64}}\n",
    96  		},
    97  	}
    98  
    99  	for _, tc := range testCases {
   100  		var buf bytes.Buffer
   101  
   102  		store := newEmptyTraceKVStore(&buf)
   103  		buf.Reset()
   104  		store.Set(tc.key, tc.value)
   105  
   106  		require.Equal(t, tc.expectedOut, buf.String())
   107  	}
   108  
   109  	var buf bytes.Buffer
   110  	store := newEmptyTraceKVStore(&buf)
   111  	require.Panics(t, func() { store.Set([]byte(""), []byte("value")) }, "setting an empty key should panic")
   112  	require.Panics(t, func() { store.Set(nil, []byte("value")) }, "setting a nil key should panic")
   113  }
   114  
   115  func TestTraceKVStoreDelete(t *testing.T) {
   116  	testCases := []struct {
   117  		key         []byte
   118  		expectedOut string
   119  	}{
   120  		{
   121  			key:         kvPairs[0].Key,
   122  			expectedOut: "{\"operation\":\"delete\",\"key\":\"a2V5MDAwMDAwMDE=\",\"value\":\"\",\"metadata\":{\"blockHeight\":64}}\n",
   123  		},
   124  	}
   125  
   126  	for _, tc := range testCases {
   127  		var buf bytes.Buffer
   128  
   129  		store := newTraceKVStore(&buf)
   130  		buf.Reset()
   131  		store.Delete(tc.key)
   132  
   133  		require.Equal(t, tc.expectedOut, buf.String())
   134  	}
   135  }
   136  
   137  func TestTraceKVStoreHas(t *testing.T) {
   138  	testCases := []struct {
   139  		key      []byte
   140  		expected bool
   141  	}{
   142  		{
   143  			key:      kvPairs[0].Key,
   144  			expected: true,
   145  		},
   146  	}
   147  
   148  	for _, tc := range testCases {
   149  		var buf bytes.Buffer
   150  
   151  		store := newTraceKVStore(&buf)
   152  		buf.Reset()
   153  		ok := store.Has(tc.key)
   154  
   155  		require.Equal(t, tc.expected, ok)
   156  	}
   157  }
   158  
   159  func TestTestTraceKVStoreIterator(t *testing.T) {
   160  	var buf bytes.Buffer
   161  
   162  	store := newTraceKVStore(&buf)
   163  	iterator := store.Iterator(nil, nil)
   164  
   165  	s, e := iterator.Domain()
   166  	require.Equal(t, []byte(nil), s)
   167  	require.Equal(t, []byte(nil), e)
   168  
   169  	testCases := []struct {
   170  		expectedKey      []byte
   171  		expectedValue    []byte
   172  		expectedKeyOut   string
   173  		expectedvalueOut string
   174  	}{
   175  		{
   176  			expectedKey:      kvPairs[0].Key,
   177  			expectedValue:    kvPairs[0].Value,
   178  			expectedKeyOut:   "{\"operation\":\"iterKey\",\"key\":\"a2V5MDAwMDAwMDE=\",\"value\":\"\",\"metadata\":{\"blockHeight\":64}}\n",
   179  			expectedvalueOut: "{\"operation\":\"iterValue\",\"key\":\"\",\"value\":\"dmFsdWUwMDAwMDAwMQ==\",\"metadata\":{\"blockHeight\":64}}\n",
   180  		},
   181  		{
   182  			expectedKey:      kvPairs[1].Key,
   183  			expectedValue:    kvPairs[1].Value,
   184  			expectedKeyOut:   "{\"operation\":\"iterKey\",\"key\":\"a2V5MDAwMDAwMDI=\",\"value\":\"\",\"metadata\":{\"blockHeight\":64}}\n",
   185  			expectedvalueOut: "{\"operation\":\"iterValue\",\"key\":\"\",\"value\":\"dmFsdWUwMDAwMDAwMg==\",\"metadata\":{\"blockHeight\":64}}\n",
   186  		},
   187  		{
   188  			expectedKey:      kvPairs[2].Key,
   189  			expectedValue:    kvPairs[2].Value,
   190  			expectedKeyOut:   "{\"operation\":\"iterKey\",\"key\":\"a2V5MDAwMDAwMDM=\",\"value\":\"\",\"metadata\":{\"blockHeight\":64}}\n",
   191  			expectedvalueOut: "{\"operation\":\"iterValue\",\"key\":\"\",\"value\":\"dmFsdWUwMDAwMDAwMw==\",\"metadata\":{\"blockHeight\":64}}\n",
   192  		},
   193  	}
   194  
   195  	for _, tc := range testCases {
   196  		buf.Reset()
   197  		ka := iterator.Key()
   198  		require.Equal(t, tc.expectedKeyOut, buf.String())
   199  
   200  		buf.Reset()
   201  		va := iterator.Value()
   202  		require.Equal(t, tc.expectedvalueOut, buf.String())
   203  
   204  		require.Equal(t, tc.expectedKey, ka)
   205  		require.Equal(t, tc.expectedValue, va)
   206  
   207  		iterator.Next()
   208  	}
   209  
   210  	require.False(t, iterator.Valid())
   211  	require.Panics(t, iterator.Next)
   212  	require.NoError(t, iterator.Close())
   213  }
   214  
   215  func TestTestTraceKVStoreReverseIterator(t *testing.T) {
   216  	var buf bytes.Buffer
   217  
   218  	store := newTraceKVStore(&buf)
   219  	iterator := store.ReverseIterator(nil, nil)
   220  
   221  	s, e := iterator.Domain()
   222  	require.Equal(t, []byte(nil), s)
   223  	require.Equal(t, []byte(nil), e)
   224  
   225  	testCases := []struct {
   226  		expectedKey      []byte
   227  		expectedValue    []byte
   228  		expectedKeyOut   string
   229  		expectedvalueOut string
   230  	}{
   231  		{
   232  			expectedKey:      kvPairs[2].Key,
   233  			expectedValue:    kvPairs[2].Value,
   234  			expectedKeyOut:   "{\"operation\":\"iterKey\",\"key\":\"a2V5MDAwMDAwMDM=\",\"value\":\"\",\"metadata\":{\"blockHeight\":64}}\n",
   235  			expectedvalueOut: "{\"operation\":\"iterValue\",\"key\":\"\",\"value\":\"dmFsdWUwMDAwMDAwMw==\",\"metadata\":{\"blockHeight\":64}}\n",
   236  		},
   237  		{
   238  			expectedKey:      kvPairs[1].Key,
   239  			expectedValue:    kvPairs[1].Value,
   240  			expectedKeyOut:   "{\"operation\":\"iterKey\",\"key\":\"a2V5MDAwMDAwMDI=\",\"value\":\"\",\"metadata\":{\"blockHeight\":64}}\n",
   241  			expectedvalueOut: "{\"operation\":\"iterValue\",\"key\":\"\",\"value\":\"dmFsdWUwMDAwMDAwMg==\",\"metadata\":{\"blockHeight\":64}}\n",
   242  		},
   243  		{
   244  			expectedKey:      kvPairs[0].Key,
   245  			expectedValue:    kvPairs[0].Value,
   246  			expectedKeyOut:   "{\"operation\":\"iterKey\",\"key\":\"a2V5MDAwMDAwMDE=\",\"value\":\"\",\"metadata\":{\"blockHeight\":64}}\n",
   247  			expectedvalueOut: "{\"operation\":\"iterValue\",\"key\":\"\",\"value\":\"dmFsdWUwMDAwMDAwMQ==\",\"metadata\":{\"blockHeight\":64}}\n",
   248  		},
   249  	}
   250  
   251  	for _, tc := range testCases {
   252  		buf.Reset()
   253  		ka := iterator.Key()
   254  		require.Equal(t, tc.expectedKeyOut, buf.String())
   255  
   256  		buf.Reset()
   257  		va := iterator.Value()
   258  		require.Equal(t, tc.expectedvalueOut, buf.String())
   259  
   260  		require.Equal(t, tc.expectedKey, ka)
   261  		require.Equal(t, tc.expectedValue, va)
   262  
   263  		iterator.Next()
   264  	}
   265  
   266  	require.False(t, iterator.Valid())
   267  	require.Panics(t, iterator.Next)
   268  	require.NoError(t, iterator.Close())
   269  }
   270  
   271  func TestTraceKVStorePrefix(t *testing.T) {
   272  	store := newEmptyTraceKVStore(nil)
   273  	pStore := prefix.NewStore(store, []byte("trace_prefix"))
   274  	require.IsType(t, prefix.Store{}, pStore)
   275  }
   276  
   277  func TestTraceKVStoreGetStoreType(t *testing.T) {
   278  	dbm := dbadapter.Store{DB: dbm.NewMemDB()}
   279  	store := newEmptyTraceKVStore(nil)
   280  	require.Equal(t, dbm.GetStoreType(), store.GetStoreType())
   281  }
   282  
   283  func TestTraceKVStoreCacheWrap(t *testing.T) {
   284  	store := newEmptyTraceKVStore(nil)
   285  	require.Panics(t, func() { store.CacheWrap() })
   286  }
   287  
   288  func TestTraceKVStoreCacheWrapWithTrace(t *testing.T) {
   289  	store := newEmptyTraceKVStore(nil)
   290  	require.Panics(t, func() { store.CacheWrapWithTrace(nil, nil) })
   291  }
   292  
   293  func TestTraceKVStoreCacheWrapWithListeners(t *testing.T) {
   294  	store := newEmptyTraceKVStore(nil)
   295  	require.Panics(t, func() { store.CacheWrapWithListeners(nil, nil) })
   296  }