aliasmgr: add test coverage for alias persistency

Author: GeorgeTsagk

aliasmgr/aliasmgr_test.go

@@ -4,12 +4,15 @@ import (
 	"math/rand"
 	"path/filepath"
 	"testing"
+	"time"
 
 	"github.com/lightningnetwork/lnd/kvdb"
 	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/stretchr/testify/require"
 )
 
+const channelReadTimeout = time.Second * 10
+
 // TestAliasStorePeerAlias tests that putting and retrieving a peer's alias
 // works properly.
 func TestAliasStorePeerAlias(t *testing.T) {
@@ -116,7 +119,7 @@ func TestAliasLifecycle(t *testing.T) {
 	require.NoError(t, err)
 
 	// The link updater should be called.
-	<-updateChan
+	require.True(t, readOrTimeout(updateChan, channelReadTimeout))
 
 	// Query the aliases and verify the results.
 	aliasList := aliasStore.GetAliases(baseScid)
@@ -128,7 +131,7 @@ func TestAliasLifecycle(t *testing.T) {
 	require.NoError(t, err)
 
 	// The link updater should be called.
-	<-updateChan
+	require.True(t, readOrTimeout(updateChan, channelReadTimeout))
 
 	// Query the aliases and verify the results.
 	aliasList = aliasStore.GetAliases(baseScid)
@@ -141,7 +144,7 @@ func TestAliasLifecycle(t *testing.T) {
 	require.NoError(t, err)
 
 	// The link updater should be called.
-	<-updateChan
+	require.True(t, readOrTimeout(updateChan, channelReadTimeout))
 
 	// We expect to get an error if we attempt to delete the same alias
 	// again.
@@ -166,7 +169,7 @@ func TestAliasLifecycle(t *testing.T) {
 	require.NoError(t, err)
 
 	// The link updater should be called.
-	<-updateChan
+	require.True(t, readOrTimeout(updateChan, channelReadTimeout))
 
 	// Query the aliases and verify that none exists.
 	aliasList = aliasStore.GetAliases(baseScid)
@@ -180,7 +183,8 @@ func TestAliasLifecycle(t *testing.T) {
 
 	// We now manually add the next alias from the range as a custom alias.
 	// This time we also use the base lookup option, in order to be able to
-	// go from alias back to the base scid.
+	// go from alias back to the base scid. The WithBaseLookup option also
+	// marks this alias as persistent.
 	secondAlias := getNextScid(firstRequested)
 	err = aliasStore.AddLocalAlias(
 		secondAlias, baseScid, false, true, WithBaseLookup(),
@@ -266,3 +270,246 @@ func TestGetNextScid(t *testing.T) {
 		})
 	}
 }
+
+// TestPersistentAlias tests that aliases marked as persistent remain in the
+// aliasToBase map even after the base SCID is confirmed.
+func TestPersistentAlias(t *testing.T) {
+	t.Parallel()
+
+	// Create the backend database and use this to create the aliasStore.
+	dbPath := filepath.Join(t.TempDir(), "testdb")
+	db, err := kvdb.Create(
+		kvdb.BoltBackendName, dbPath, true, kvdb.DefaultDBTimeout,
+		false,
+	)
+	require.NoError(t, err)
+	defer db.Close()
+
+	linkUpdater := func(shortID lnwire.ShortChannelID) error {
+		return nil
+	}
+
+	aliasStore, err := NewManager(db, linkUpdater)
+	require.NoError(t, err)
+
+	const (
+		base               = uint64(123123123)
+		nonPersistentAlias = uint64(456456456)
+		persistentAlias    = uint64(789789789)
+	)
+
+	baseScid := lnwire.NewShortChanIDFromInt(base)
+	nonPersistentScid := lnwire.NewShortChanIDFromInt(nonPersistentAlias)
+	persistentScid := lnwire.NewShortChanIDFromInt(persistentAlias)
+
+	// Add a non-persistent alias (without WithBaseLookup option).
+	err = aliasStore.AddLocalAlias(
+		nonPersistentScid, baseScid, true, false,
+	)
+	require.NoError(t, err)
+
+	// Add a persistent alias (with WithBaseLookup option).
+	err = aliasStore.AddLocalAlias(
+		persistentScid, baseScid, true, false, WithBaseLookup(),
+	)
+	require.NoError(t, err)
+
+	// Both aliases should be in aliasToBase before confirmation.
+	_, err = aliasStore.FindBaseSCID(nonPersistentScid)
+	require.NoError(t, err)
+
+	_, err = aliasStore.FindBaseSCID(persistentScid)
+	require.NoError(t, err)
+
+	// Mark the base as confirmed (simulating 6 confirmations).
+	err = aliasStore.DeleteSixConfs(baseScid)
+	require.NoError(t, err)
+
+	// Non-persistent alias should no longer be findable.
+	_, err = aliasStore.FindBaseSCID(nonPersistentScid)
+	require.Error(t, err)
+
+	// Persistent alias should still be findable.
+	foundBase, err := aliasStore.FindBaseSCID(persistentScid)
+	require.NoError(t, err)
+	require.Equal(t, baseScid, foundBase)
+
+	// Restart: create a new manager with the same database.
+	aliasStore2, err := NewManager(db, linkUpdater)
+	require.NoError(t, err)
+
+	// After restart, non-persistent alias should still not be findable.
+	_, err = aliasStore2.FindBaseSCID(nonPersistentScid)
+	require.Error(t, err)
+
+	// Persistent alias should still be findable after restart.
+	foundBase, err = aliasStore2.FindBaseSCID(persistentScid)
+	require.NoError(t, err)
+	require.Equal(t, baseScid, foundBase)
+
+	// Both aliases should still be in baseToSet.
+	aliases := aliasStore2.GetAliases(baseScid)
+	require.Len(t, aliases, 2)
+	require.Contains(t, aliases, nonPersistentScid)
+	require.Contains(t, aliases, persistentScid)
+}
+
+// TestBackwardCompatibility tests that old aliases (without flags) are still
+// loaded correctly.
+func TestBackwardCompatibility(t *testing.T) {
+	t.Parallel()
+
+	// Create the backend database and use this to create the aliasStore.
+	dbPath := filepath.Join(t.TempDir(), "testdb")
+	db, err := kvdb.Create(
+		kvdb.BoltBackendName, dbPath, true, kvdb.DefaultDBTimeout,
+		false,
+	)
+	require.NoError(t, err)
+	defer db.Close()
+
+	linkUpdater := func(shortID lnwire.ShortChannelID) error {
+		return nil
+	}
+
+	// Manually write an old-format alias (8 bytes, no flags).
+	const (
+		base  = uint64(111111111)
+		alias = uint64(222222222)
+	)
+
+	err = kvdb.Update(db, func(tx kvdb.RwTx) error {
+		bucket, err := tx.CreateTopLevelBucket(aliasBucket)
+		if err != nil {
+			return err
+		}
+
+		var aliasBytes [8]byte
+		var baseBytes [8]byte
+		byteOrder.PutUint64(aliasBytes[:], alias)
+		byteOrder.PutUint64(baseBytes[:], base)
+
+		// Write only 8 bytes (old format, no flags).
+		return bucket.Put(aliasBytes[:], baseBytes[:])
+	}, func() {})
+	require.NoError(t, err)
+
+	// Create the manager - it should load the old entry.
+	aliasStore, err := NewManager(db, linkUpdater)
+	require.NoError(t, err)
+
+	baseScid := lnwire.NewShortChanIDFromInt(base)
+	aliasScid := lnwire.NewShortChanIDFromInt(alias)
+
+	// The alias should be in baseToSet.
+	aliases := aliasStore.GetAliases(baseScid)
+	require.Len(t, aliases, 1)
+	require.Contains(t, aliases, aliasScid)
+
+	// The alias should be findable (since it's not confirmed).
+	foundBase, err := aliasStore.FindBaseSCID(aliasScid)
+	require.NoError(t, err)
+	require.Equal(t, baseScid, foundBase)
+
+	// Mark as confirmed - old aliases should not persist.
+	err = aliasStore.DeleteSixConfs(baseScid)
+	require.NoError(t, err)
+
+	// Should no longer be findable after confirmation.
+	_, err = aliasStore.FindBaseSCID(aliasScid)
+	require.Error(t, err)
+}
+
+// TestDeletePersistentAlias tests that persistent aliases can be manually
+// deleted via DeleteLocalAlias.
+func TestDeletePersistentAlias(t *testing.T) {
+	t.Parallel()
+
+	// Create the backend database and use this to create the aliasStore.
+	dbPath := filepath.Join(t.TempDir(), "testdb")
+	db, err := kvdb.Create(
+		kvdb.BoltBackendName, dbPath, true, kvdb.DefaultDBTimeout,
+		false,
+	)
+	require.NoError(t, err)
+	defer db.Close()
+
+	updateChan := make(chan struct{}, 1)
+	linkUpdater := func(shortID lnwire.ShortChannelID) error {
+		updateChan <- struct{}{}
+		return nil
+	}
+
+	aliasStore, err := NewManager(db, linkUpdater)
+	require.NoError(t, err)
+
+	const (
+		base            = uint64(123123123)
+		persistentAlias = uint64(789789789)
+	)
+
+	baseScid := lnwire.NewShortChanIDFromInt(base)
+	persistentScid := lnwire.NewShortChanIDFromInt(persistentAlias)
+
+	// Add a persistent alias (with WithBaseLookup option).
+	err = aliasStore.AddLocalAlias(
+		persistentScid, baseScid, true, true, WithBaseLookup(),
+	)
+	require.NoError(t, err)
+
+	// Link updater should be called.
+	require.True(t, readOrTimeout(updateChan, channelReadTimeout))
+
+	// Alias should be findable.
+	foundBase, err := aliasStore.FindBaseSCID(persistentScid)
+	require.NoError(t, err)
+	require.Equal(t, baseScid, foundBase)
+
+	// Mark as confirmed - persistent alias should survive.
+	err = aliasStore.DeleteSixConfs(baseScid)
+	require.NoError(t, err)
+
+	// Persistent alias should still be findable after confirmation.
+	foundBase, err = aliasStore.FindBaseSCID(persistentScid)
+	require.NoError(t, err)
+	require.Equal(t, baseScid, foundBase)
+
+	// Now manually delete the persistent alias.
+	err = aliasStore.DeleteLocalAlias(persistentScid, baseScid)
+	require.NoError(t, err)
+
+	// Link updater should be called.
+	require.True(t, readOrTimeout(updateChan, channelReadTimeout))
+
+	// Alias should no longer be findable.
+	_, err = aliasStore.FindBaseSCID(persistentScid)
+	require.Error(t, err)
+
+	// Alias should not be in baseToSet.
+	aliases := aliasStore.GetAliases(baseScid)
+	require.Len(t, aliases, 0)
+
+	// Verify it's deleted from database by restarting.
+	aliasStore2, err := NewManager(db, linkUpdater)
+	require.NoError(t, err)
+
+	// Should still not be findable after restart.
+	_, err = aliasStore2.FindBaseSCID(persistentScid)
+	require.Error(t, err)
+
+	// Should not be in baseToSet after restart.
+	aliases = aliasStore2.GetAliases(baseScid)
+	require.Len(t, aliases, 0)
+}
+
+// readOrTimeout attempts to read an element from the given channel of type T.
+// If the item is read successfully then true is returned. If the timeout is
+// reached then it returns false.
+func readOrTimeout[T any](ch <-chan T, timeout time.Duration) bool {
+	select {
+	case <-ch:
+		return true
+	case <-time.After(timeout):
+		return false
+	}
+}