aliasmgr: add test coverage for alias persistency

Author: GeorgeTsagk

aliasmgr/aliasmgr_test.go

@@ -180,7 +180,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 +267,234 @@ 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.
+	<-updateChan
+
+	// 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.
+	<-updateChan
+
+	// 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)
+}