mirror of
https://github.com/lightningnetwork/lnd.git
synced 2026-08-13 12:32:48 +02:00
8047149c6a
Migrate all btcd dependencies to the new per-package v2 modules (wire/v2, txscript/v2, chaincfg/v2, chainhash/v2, btcutil/v2, psbt/v2, btcec/v2) introduced by btcd v0.26.0, and pin the tagged ecosystem versions: btcwallet v0.17.0, neutrino v0.18.0 and lightning-onion v1.4.0. The bulk of the import rewrite was produced by the scripted diff from https://github.com/btcsuite/btcd/pull/2547 (followed by 'make rpc'). The address symbols that moved out of btcutil into the new address package are imported as btcaddr where a local "address" variable would otherwise shadow them. The go.mod/go.sum updates and the remaining manual compilation fixes are folded into this single commit so it builds on its own (the migration was previously split into a reproducible scripted-diff plus follow-ups, intended to be squashed on merge).
110 lines
3.2 KiB
Go
110 lines
3.2 KiB
Go
package graphdb
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/btcsuite/btcd/chainhash/v2"
|
|
"github.com/lightningnetwork/lnd/graph/db/models"
|
|
"github.com/lightningnetwork/lnd/lnwire"
|
|
"github.com/lightningnetwork/lnd/routing/route"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
// TestChannelCache checks the behavior of the channelCache with respect to
|
|
// insertion, eviction, and removal of cache entries.
|
|
func TestChannelCache(t *testing.T) {
|
|
const cacheSize = 100
|
|
|
|
v := lnwire.GossipVersion1
|
|
|
|
// Create a new channel cache with the configured max size.
|
|
c := newChannelCache(cacheSize)
|
|
|
|
// As a sanity check, assert that querying the empty cache does not
|
|
// return an entry.
|
|
_, ok := c.get(v, 0)
|
|
require.False(t, ok)
|
|
|
|
// Now, fill up the cache entirely.
|
|
for i := uint64(0); i < cacheSize; i++ {
|
|
c.insert(v, i, channelForInt(i))
|
|
}
|
|
|
|
// Assert that the cache has all of the entries just inserted, since no
|
|
// eviction should occur until we try to surpass the max size.
|
|
assertHasChanEntries(t, c, v, 0, cacheSize)
|
|
|
|
// Now, insert a new element that causes the cache to evict an element.
|
|
c.insert(v, cacheSize, channelForInt(cacheSize))
|
|
|
|
// Assert that the cache has this last entry, as the cache should evict
|
|
// some prior element and not the newly inserted one.
|
|
assertHasChanEntries(t, c, v, cacheSize, cacheSize)
|
|
|
|
// Iterate over all inserted elements and construct a set of the evicted
|
|
// elements.
|
|
evicted := make(map[uint64]struct{})
|
|
for i := uint64(0); i < cacheSize+1; i++ {
|
|
_, ok := c.get(v, i)
|
|
if !ok {
|
|
evicted[i] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// Assert that exactly one element has been evicted.
|
|
numEvicted := len(evicted)
|
|
require.Equal(t, 1, numEvicted)
|
|
|
|
// Remove the highest item which initially caused the eviction and
|
|
// reinsert the element that was evicted prior.
|
|
c.remove(v, cacheSize)
|
|
for i := range evicted {
|
|
c.insert(v, i, channelForInt(i))
|
|
}
|
|
|
|
// Since the removal created an extra slot, the last insertion should
|
|
// not have caused an eviction and the entries for all channels in the
|
|
// original set that filled the cache should be present.
|
|
assertHasChanEntries(t, c, v, 0, cacheSize)
|
|
|
|
// Finally, reinsert the existing set back into the cache and test that
|
|
// the cache still has all the entries. If the randomized eviction were
|
|
// happening on inserts for existing cache items, we expect this to fail
|
|
// with high probability.
|
|
for i := uint64(0); i < cacheSize; i++ {
|
|
c.insert(v, i, channelForInt(i))
|
|
}
|
|
assertHasChanEntries(t, c, v, 0, cacheSize)
|
|
|
|
}
|
|
|
|
// assertHasEntries queries the edge cache for all channels in the range [start,
|
|
// end), asserting that they exist and their value matches the entry produced by
|
|
// entryForInt.
|
|
func assertHasChanEntries(t *testing.T, c *channelCache,
|
|
v lnwire.GossipVersion, start, end uint64) {
|
|
|
|
t.Helper()
|
|
|
|
for i := start; i < end; i++ {
|
|
entry, ok := c.get(v, i)
|
|
require.True(t, ok)
|
|
|
|
expEntry := channelForInt(i)
|
|
require.Equal(t, expEntry, entry)
|
|
}
|
|
}
|
|
|
|
// channelForInt generates a unique ChannelEdge given an integer.
|
|
func channelForInt(i uint64) ChannelEdge {
|
|
info, err := models.NewV1Channel(
|
|
i, chainhash.Hash{}, route.Vertex{}, route.Vertex{},
|
|
&models.ChannelV1Fields{},
|
|
)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return ChannelEdge{
|
|
Info: info,
|
|
}
|
|
}
|