github.com/cosmos/cosmos-sdk@v0.50.10/x/group/internal/orm/auto_uint64_test.go (about)

     1  package orm
     2  
     3  import (
     4  	"math"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/assert"
     8  	"github.com/stretchr/testify/require"
     9  
    10  	errorsmod "cosmossdk.io/errors"
    11  	storetypes "cosmossdk.io/store/types"
    12  
    13  	"github.com/cosmos/cosmos-sdk/codec"
    14  	"github.com/cosmos/cosmos-sdk/codec/types"
    15  	"github.com/cosmos/cosmos-sdk/testutil/testdata"
    16  	"github.com/cosmos/cosmos-sdk/x/group/errors"
    17  )
    18  
    19  func TestAutoUInt64PrefixScan(t *testing.T) {
    20  	interfaceRegistry := types.NewInterfaceRegistry()
    21  	cdc := codec.NewProtoCodec(interfaceRegistry)
    22  
    23  	tb, err := NewAutoUInt64Table(AutoUInt64TablePrefix, AutoUInt64TableSeqPrefix, &testdata.TableModel{}, cdc)
    24  	require.NoError(t, err)
    25  
    26  	ctx := NewMockContext()
    27  	store := ctx.KVStore(storetypes.NewKVStoreKey("test"))
    28  
    29  	metadata := []byte("metadata")
    30  	t1 := testdata.TableModel{
    31  		Id:       1,
    32  		Name:     "my test 1",
    33  		Metadata: metadata,
    34  	}
    35  	t2 := testdata.TableModel{
    36  		Id:       2,
    37  		Name:     "my test 2",
    38  		Metadata: metadata,
    39  	}
    40  	t3 := testdata.TableModel{
    41  		Id:       3,
    42  		Name:     "my test 3",
    43  		Metadata: metadata,
    44  	}
    45  	for _, g := range []testdata.TableModel{t1, t2, t3} {
    46  		g := g
    47  		_, err := tb.Create(store, &g)
    48  		require.NoError(t, err)
    49  	}
    50  
    51  	specs := map[string]struct {
    52  		start, end uint64
    53  		expResult  []testdata.TableModel
    54  		expRowIDs  []RowID
    55  		expError   *errorsmod.Error
    56  		method     func(store storetypes.KVStore, start, end uint64) (Iterator, error)
    57  	}{
    58  		"first element": {
    59  			start:     1,
    60  			end:       2,
    61  			method:    tb.PrefixScan,
    62  			expResult: []testdata.TableModel{t1},
    63  			expRowIDs: []RowID{EncodeSequence(1)},
    64  		},
    65  		"first 2 elements": {
    66  			start:     1,
    67  			end:       3,
    68  			method:    tb.PrefixScan,
    69  			expResult: []testdata.TableModel{t1, t2},
    70  			expRowIDs: []RowID{EncodeSequence(1), EncodeSequence(2)},
    71  		},
    72  		"first 3 elements": {
    73  			start:     1,
    74  			end:       4,
    75  			method:    tb.PrefixScan,
    76  			expResult: []testdata.TableModel{t1, t2, t3},
    77  			expRowIDs: []RowID{EncodeSequence(1), EncodeSequence(2), EncodeSequence(3)},
    78  		},
    79  		"search with max end": {
    80  			start:     1,
    81  			end:       math.MaxUint64,
    82  			method:    tb.PrefixScan,
    83  			expResult: []testdata.TableModel{t1, t2, t3},
    84  			expRowIDs: []RowID{EncodeSequence(1), EncodeSequence(2), EncodeSequence(3)},
    85  		},
    86  		"2 to end": {
    87  			start:     2,
    88  			end:       5,
    89  			method:    tb.PrefixScan,
    90  			expResult: []testdata.TableModel{t2, t3},
    91  			expRowIDs: []RowID{EncodeSequence(2), EncodeSequence(3)},
    92  		},
    93  		"start after end should fail": {
    94  			start:    2,
    95  			end:      1,
    96  			method:   tb.PrefixScan,
    97  			expError: errors.ErrORMInvalidArgument,
    98  		},
    99  		"start equals end should fail": {
   100  			start:    1,
   101  			end:      1,
   102  			method:   tb.PrefixScan,
   103  			expError: errors.ErrORMInvalidArgument,
   104  		},
   105  		"reverse first element": {
   106  			start:     1,
   107  			end:       2,
   108  			method:    tb.ReversePrefixScan,
   109  			expResult: []testdata.TableModel{t1},
   110  			expRowIDs: []RowID{EncodeSequence(1)},
   111  		},
   112  		"reverse first 2 elements": {
   113  			start:     1,
   114  			end:       3,
   115  			method:    tb.ReversePrefixScan,
   116  			expResult: []testdata.TableModel{t2, t1},
   117  			expRowIDs: []RowID{EncodeSequence(2), EncodeSequence(1)},
   118  		},
   119  		"reverse first 3 elements": {
   120  			start:     1,
   121  			end:       4,
   122  			method:    tb.ReversePrefixScan,
   123  			expResult: []testdata.TableModel{t3, t2, t1},
   124  			expRowIDs: []RowID{EncodeSequence(3), EncodeSequence(2), EncodeSequence(1)},
   125  		},
   126  		"reverse search with max end": {
   127  			start:     1,
   128  			end:       math.MaxUint64,
   129  			method:    tb.ReversePrefixScan,
   130  			expResult: []testdata.TableModel{t3, t2, t1},
   131  			expRowIDs: []RowID{EncodeSequence(3), EncodeSequence(2), EncodeSequence(1)},
   132  		},
   133  		"reverse 2 to end": {
   134  			start:     2,
   135  			end:       5,
   136  			method:    tb.ReversePrefixScan,
   137  			expResult: []testdata.TableModel{t3, t2},
   138  			expRowIDs: []RowID{EncodeSequence(3), EncodeSequence(2)},
   139  		},
   140  		"reverse start after end should fail": {
   141  			start:    2,
   142  			end:      1,
   143  			method:   tb.ReversePrefixScan,
   144  			expError: errors.ErrORMInvalidArgument,
   145  		},
   146  		"reverse start equals end should fail": {
   147  			start:    1,
   148  			end:      1,
   149  			method:   tb.ReversePrefixScan,
   150  			expError: errors.ErrORMInvalidArgument,
   151  		},
   152  	}
   153  	for msg, spec := range specs {
   154  		t.Run(msg, func(t *testing.T) {
   155  			it, err := spec.method(store, spec.start, spec.end)
   156  			require.True(t, spec.expError.Is(err), "expected #+v but got #+v", spec.expError, err)
   157  			if spec.expError != nil {
   158  				return
   159  			}
   160  			var loaded []testdata.TableModel
   161  			rowIDs, err := ReadAll(it, &loaded)
   162  			require.NoError(t, err)
   163  			assert.Equal(t, spec.expResult, loaded)
   164  			assert.Equal(t, spec.expRowIDs, rowIDs)
   165  		})
   166  	}
   167  }