github.com/vescale/zgraph@v0.0.0-20230410094002-959c02d50f95/storage/snapshot_iterator_test.go (about)

     1  // Copyright 2022 zGraph Authors. All rights reserved.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package storage
    16  
    17  import (
    18  	"reflect"
    19  	"testing"
    20  
    21  	"github.com/cockroachdb/pebble"
    22  	"github.com/stretchr/testify/assert"
    23  	"github.com/vescale/zgraph/storage/kv"
    24  	"github.com/vescale/zgraph/storage/mvcc"
    25  )
    26  
    27  func TestIterator_Basic(t *testing.T) {
    28  	s, err := Open(t.TempDir())
    29  	assert.Nil(t, err)
    30  	assert.NotNil(t, s)
    31  
    32  	db := s.(*mvccStorage).db
    33  	writes := db.NewBatch()
    34  
    35  	// Mock data
    36  	data := []struct {
    37  		key []byte
    38  		val []byte
    39  		ver kv.Version
    40  	}{
    41  		{key: []byte("test"), val: []byte("test1"), ver: 100},
    42  		{key: []byte("test"), val: []byte("test3"), ver: 300},
    43  		{key: []byte("test1"), val: []byte("test5"), ver: 500},
    44  		{key: []byte("test1"), val: []byte("test7"), ver: 700},
    45  		{key: []byte("test2"), val: []byte("test9"), ver: 900},
    46  	}
    47  	wo := &pebble.WriteOptions{}
    48  	for _, d := range data {
    49  		v := mvcc.Value{
    50  			Type:      mvcc.ValueTypePut,
    51  			StartVer:  d.ver,
    52  			CommitVer: d.ver + 10,
    53  			Value:     d.val,
    54  		}
    55  		val, err := v.MarshalBinary()
    56  		assert.Nil(t, err)
    57  		assert.NotNil(t, val)
    58  		err = writes.Set(mvcc.Encode(d.key, d.ver+1), val, wo)
    59  		assert.Nil(t, err)
    60  	}
    61  
    62  	err = db.Apply(writes, wo)
    63  	assert.Nil(t, err)
    64  
    65  	type pair struct {
    66  		k string
    67  		v string
    68  	}
    69  	expected := []struct {
    70  		ver     uint64
    71  		results []pair
    72  	}{
    73  		{
    74  			ver: 200,
    75  			results: []pair{
    76  				{"test", "test1"},
    77  			},
    78  		},
    79  		{
    80  			ver: 320,
    81  			results: []pair{
    82  				{"test", "test3"},
    83  			},
    84  		},
    85  		{
    86  			ver: 1000,
    87  			results: []pair{
    88  				{"test", "test3"},
    89  				{"test1", "test7"},
    90  				{"test2", "test9"},
    91  			},
    92  		},
    93  	}
    94  	for _, e := range expected {
    95  		snapshot, err := s.Snapshot(kv.Version(e.ver))
    96  		assert.Nil(t, err)
    97  		iter, err := snapshot.Iter([]byte("t"), []byte("u"))
    98  		assert.Nil(t, err)
    99  		var results []pair
   100  
   101  		for iter.Valid() {
   102  			key := iter.Key()
   103  			val := iter.Value()
   104  			results = append(results, pair{string(key), string(val)})
   105  			err = iter.Next()
   106  			assert.Nil(t, err)
   107  		}
   108  		assert.True(t, reflect.DeepEqual(results, e.results), "expected: %v, got: %v (ver:%d)",
   109  			e.results, results, e.ver)
   110  
   111  		iter.Close()
   112  	}
   113  }
   114  
   115  func TestReverseIterator(t *testing.T) {
   116  	s, err := Open(t.TempDir())
   117  	assert.Nil(t, err)
   118  	assert.NotNil(t, s)
   119  
   120  	db := s.(*mvccStorage).db
   121  	writes := db.NewBatch()
   122  
   123  	// Mock data
   124  	data := []struct {
   125  		key []byte
   126  		val []byte
   127  		ver kv.Version
   128  	}{
   129  		{key: []byte("test"), val: []byte("test1"), ver: 100},
   130  		{key: []byte("test"), val: []byte("test3"), ver: 300},
   131  		{key: []byte("test1"), val: []byte("test5"), ver: 500},
   132  		{key: []byte("test1"), val: []byte("test7"), ver: 700},
   133  		{key: []byte("test2"), val: []byte("test9"), ver: 900},
   134  	}
   135  	wo := &pebble.WriteOptions{}
   136  	for _, d := range data {
   137  		v := mvcc.Value{
   138  			Type:      mvcc.ValueTypePut,
   139  			StartVer:  d.ver,
   140  			CommitVer: d.ver + 10,
   141  			Value:     d.val,
   142  		}
   143  		val, err := v.MarshalBinary()
   144  		assert.Nil(t, err)
   145  		assert.NotNil(t, val)
   146  		err = writes.Set(mvcc.Encode(d.key, d.ver+1), val, wo)
   147  		assert.Nil(t, err)
   148  	}
   149  
   150  	err = db.Apply(writes, wo)
   151  	assert.Nil(t, err)
   152  
   153  	type pair struct {
   154  		k string
   155  		v string
   156  	}
   157  	expected := []struct {
   158  		ver     uint64
   159  		results []pair
   160  	}{
   161  		{
   162  			ver: 200,
   163  			results: []pair{
   164  				{"test", "test1"},
   165  			},
   166  		},
   167  		{
   168  			ver: 320,
   169  			results: []pair{
   170  				{"test", "test3"},
   171  			},
   172  		},
   173  		{
   174  			ver: 1000,
   175  			results: []pair{
   176  				{"test2", "test9"},
   177  				{"test1", "test7"},
   178  				{"test", "test3"},
   179  			},
   180  		},
   181  	}
   182  	for _, e := range expected {
   183  		snapshot, err := s.Snapshot(kv.Version(e.ver))
   184  		assert.Nil(t, err)
   185  		iter, err := snapshot.IterReverse([]byte("t"), []byte("u"))
   186  		assert.Nil(t, err)
   187  		var results []pair
   188  
   189  		for iter.Valid() {
   190  			key := iter.Key()
   191  			val := iter.Value()
   192  			results = append(results, pair{string(key), string(val)})
   193  			err = iter.Next()
   194  			assert.Nil(t, err)
   195  		}
   196  		assert.True(t, reflect.DeepEqual(results, e.results), "expected: %v, got: %v (ver:%d)",
   197  			e.results, results, e.ver)
   198  
   199  		iter.Close()
   200  	}
   201  }