code.vegaprotocol.io/vega@v0.79.0/datanode/networkhistory/store/index_test.go (about)

     1  // Copyright (C) 2023 Gobalsky Labs Limited
     2  //
     3  // This program is free software: you can redistribute it and/or modify
     4  // it under the terms of the GNU Affero General Public License as
     5  // published by the Free Software Foundation, either version 3 of the
     6  // License, or (at your option) any later version.
     7  //
     8  // This program is distributed in the hope that it will be useful,
     9  // but WITHOUT ANY WARRANTY; without even the implied warranty of
    10  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    11  // GNU Affero General Public License for more details.
    12  //
    13  // You should have received a copy of the GNU Affero General Public License
    14  // along with this program.  If not, see <http://www.gnu.org/licenses/>.
    15  
    16  package store_test
    17  
    18  import (
    19  	"sort"
    20  	"testing"
    21  
    22  	"code.vegaprotocol.io/vega/datanode/networkhistory/segment"
    23  	"code.vegaprotocol.io/vega/datanode/networkhistory/store"
    24  	"code.vegaprotocol.io/vega/logging"
    25  
    26  	"github.com/stretchr/testify/assert"
    27  	"github.com/stretchr/testify/require"
    28  )
    29  
    30  func makeSegment(heightFrom, heightTo int64) segment.Full {
    31  	return segment.Full{
    32  		MetaData: segment.MetaData{
    33  			Base: segment.Base{
    34  				HeightFrom: heightFrom,
    35  				HeightTo:   heightTo,
    36  			},
    37  		},
    38  	}
    39  }
    40  
    41  func TestOrderingOfEntriesOldestFirst(t *testing.T) {
    42  	index, err := store.NewIndex(t.TempDir(), logging.NewTestLogger())
    43  	require.NoError(t, err)
    44  	defer func() { _ = index.Close() }()
    45  
    46  	allEntries, err := index.ListAllEntriesOldestFirst()
    47  	assert.Equal(t, 0, len(allEntries))
    48  	require.NoError(t, err)
    49  
    50  	var addedEntries []segment.Full
    51  
    52  	numEntries := int64(100)
    53  	for i := int64(0); i < (numEntries/2)-2; i++ {
    54  		entry := makeSegment((i*1000)+1, (i+1)*1000)
    55  		index.Add(entry)
    56  		addedEntries = append(addedEntries, entry)
    57  
    58  		entry = makeSegment((numEntries-i-1)*1000+1, (numEntries-i)*1000)
    59  		index.Add(entry)
    60  		addedEntries = append(addedEntries, entry)
    61  	}
    62  
    63  	allEntries, err = index.ListAllEntriesOldestFirst()
    64  
    65  	require.NoError(t, err)
    66  
    67  	// Sort oldest first
    68  	sort.Slice(addedEntries, func(i, j int) bool {
    69  		return addedEntries[i].HeightFrom < addedEntries[j].HeightFrom
    70  	})
    71  
    72  	assert.Equal(t, len(addedEntries), len(allEntries))
    73  	assert.Equal(t, addedEntries, []segment.Full(allEntries))
    74  }
    75  
    76  func TestOrderingOfEntriesMostRecentFirst(t *testing.T) {
    77  	index, err := store.NewIndex(t.TempDir(), logging.NewTestLogger())
    78  	require.NoError(t, err)
    79  	defer func() { _ = index.Close() }()
    80  
    81  	allEntries, err := index.ListAllEntriesOldestFirst()
    82  	assert.Equal(t, 0, len(allEntries))
    83  	require.NoError(t, err)
    84  
    85  	var addedEntries []segment.Full
    86  
    87  	numEntries := int64(100)
    88  	for i := int64(0); i < (numEntries/2)-2; i++ {
    89  		entry := makeSegment((i*1000)+1, (i+1)*1000)
    90  		index.Add(entry)
    91  		addedEntries = append(addedEntries, entry)
    92  
    93  		entry = makeSegment((numEntries-i-1)*1000+1, (numEntries-i)*1000)
    94  		index.Add(entry)
    95  		addedEntries = append(addedEntries, entry)
    96  	}
    97  
    98  	allEntries, err = index.ListAllEntriesMostRecentFirst()
    99  
   100  	require.NoError(t, err)
   101  
   102  	// Sort most recent first
   103  	sort.Slice(addedEntries, func(i, j int) bool {
   104  		return addedEntries[i].HeightFrom > addedEntries[j].HeightFrom
   105  	})
   106  
   107  	assert.Equal(t, len(addedEntries), len(allEntries))
   108  	assert.Equal(t, addedEntries, []segment.Full(allEntries))
   109  }
   110  
   111  func TestGetHighestHeightEntry(t *testing.T) {
   112  	index, err := store.NewIndex(t.TempDir(), logging.NewTestLogger())
   113  	require.NoError(t, err)
   114  	defer func() { _ = index.Close() }()
   115  
   116  	entry, err := index.GetHighestBlockHeightEntry()
   117  	require.Error(t, store.ErrIndexEntryNotFound, err)
   118  	assert.Equal(t, int64(0), entry.HeightTo)
   119  	assert.Equal(t, int64(0), entry.HeightFrom)
   120  
   121  	index.Add(makeSegment(2001, 3000))
   122  	index.Add(makeSegment(1, 1000))
   123  	index.Add(makeSegment(1001, 2000))
   124  
   125  	entry, err = index.GetHighestBlockHeightEntry()
   126  	require.NoError(t, err)
   127  	assert.Equal(t, int64(3000), entry.HeightTo)
   128  }
   129  
   130  func TestGetEntryByHeight(t *testing.T) {
   131  	index, err := store.NewIndex(t.TempDir(), logging.NewTestLogger())
   132  	require.NoError(t, err)
   133  	defer func() { _ = index.Close() }()
   134  
   135  	index.Add(makeSegment(2001, 3000))
   136  	index.Add(makeSegment(1, 1000))
   137  	index.Add(makeSegment(1001, 2000))
   138  
   139  	entry, err := index.Get(3000)
   140  	require.NoError(t, err)
   141  	assert.Equal(t, int64(3000), entry.HeightTo)
   142  
   143  	entry, err = index.Get(4300)
   144  	require.Error(t, store.ErrIndexEntryNotFound, err)
   145  	assert.Equal(t, int64(0), entry.HeightTo)
   146  	assert.Equal(t, int64(0), entry.HeightFrom)
   147  }