graphdb: test querying chans without a policy

In this commit we add TestChanUpdatesInHorizonWithNoPolicies to
test that we can query channels with no policy attached to it.
We also test that we can query channels with policies alongside
those without.

Author: Abdulkbk

graph/db/graph_test.go

@@ -3693,6 +3693,140 @@ func TestChannelEdgePruningUpdateIndexDeletion(t *testing.T) {
 	checkIndexTimestamps()
 }
 
+// TestChanUpdatesInHorizonWithNoPolicies tests that we're able to properly
+// retrieve channels with no policies within the time range.
+func TestChanUpdatesInHorizonWithNoPolicies(t *testing.T) {
+	t.Parallel()
+	ctx := t.Context()
+
+	graph := MakeTestGraph(t)
+
+	//  This test is only valid for the SQL graph DB. So we skip it for
+	// kvdb.
+	sqlStore, ok := graph.V1Store.(*SQLStore)
+	if !ok {
+		t.Skip("skipping test that is aimed at a SQL graph DB")
+	}
+
+	// We'll start by creating two nodes which will seed our test graph.
+	node1 := createTestVertex(t)
+	require.NoError(t, sqlStore.AddNode(ctx, node1))
+
+	node2 := createTestVertex(t)
+	require.NoError(t, sqlStore.AddNode(ctx, node2))
+
+	// Note: startTime and  endTime only works if the channels have
+	// policies. If not, the channels are included irrespective of the
+	// time range.
+	startTime := time.Unix(1234, 0)
+	endTime := startTime
+	edges := make([]ChannelEdge, 0, 10)
+
+	// We'll now create 10 channels between the two nodes, with no policies.
+	const numChans = 10
+	for i := range numChans {
+		channel, chanID := createEdge(
+			uint32(i*10), 0, 0, 0, node1, node2,
+		)
+		require.NoError(t, sqlStore.AddChannelEdge(ctx, &channel))
+
+		// The first 5 channels will have no policies.
+		if i < numChans/2 {
+			edges = append(edges, ChannelEdge{
+				Info: &channel,
+			})
+
+			continue
+		}
+
+		edge1UpdateTime := endTime
+		edge2UpdateTime := edge1UpdateTime.Add(time.Second)
+		endTime = endTime.Add(time.Second * 10)
+
+		edge1 := newEdgePolicy(
+			chanID.ToUint64(), edge1UpdateTime.Unix(),
+		)
+		edge1.ChannelFlags = 0
+		edge1.ToNode = node2.PubKeyBytes
+		edge1.SigBytes = testSig.Serialize()
+		require.NoError(t, graph.UpdateEdgePolicy(ctx, edge1))
+
+		edge2 := newEdgePolicy(
+			chanID.ToUint64(), edge2UpdateTime.Unix(),
+		)
+		edge2.ChannelFlags = 1
+		edge2.ToNode = node1.PubKeyBytes
+		edge2.SigBytes = testSig.Serialize()
+		require.NoError(t, graph.UpdateEdgePolicy(ctx, edge2))
+
+		edges = append(edges, ChannelEdge{
+			Info:    &channel,
+			Policy1: edge1,
+			Policy2: edge2,
+		})
+	}
+
+	// With our channels loaded, we'll now start our series of queries.
+	queryCases := []struct {
+		start time.Time
+		end   time.Time
+		resp  []ChannelEdge
+	}{
+		// If we query for a time range that's strictly below our set
+		// of updates, then we'll get only the 5 channels with no
+		// policies.
+		{
+			start: time.Unix(100, 0),
+			end:   time.Unix(200, 0),
+			resp:  edges[:5],
+		},
+
+		// If we query for a time range that's well beyond our set of
+		// updates, we should get only the 5 channels with no
+		// policies.
+		{
+			start: time.Unix(99999, 0),
+			end:   time.Unix(999999, 0),
+			resp:  edges[:5],
+		},
+
+		// If we query for the start time, and 10 seconds directly
+		// after it, we should only get the 5 channels with no
+		// policies and one channel with a policy.
+		{
+			start: time.Unix(1234, 0),
+			end:   startTime.Add(time.Second * 10),
+			resp:  edges[:6],
+		},
+
+		// If we use the start and end time as is, we should get the
+		// entire range.
+		{
+			start: startTime,
+			end:   endTime,
+
+			resp: edges[:10],
+		},
+	}
+
+	for _, queryCase := range queryCases {
+		respIter := sqlStore.ChanUpdatesInHorizon(
+			queryCase.start, queryCase.end,
+		)
+
+		resp, err := fn.CollectErr(respIter)
+		require.NoError(t, err)
+		require.Equal(t, len(resp), len(queryCase.resp))
+
+		for i := range len(resp) {
+			chanExp := queryCase.resp[i]
+			chanRet := resp[i]
+
+			require.Equal(t, chanExp.Info, chanRet.Info)
+		}
+	}
+}
+
 // TestPruneGraphNodes tests that unconnected vertexes are pruned via the
 // PruneSyncState method.
 func TestPruneGraphNodes(t *testing.T) {

graph/db/sql_store.go

@@ -1098,6 +1098,11 @@ func (s *SQLStore) updateChanCacheBatch(edgesToCache map[uint64]ChannelEdge) {
 // 5. Update cache after successful batch
 // 6. Repeat with updated pagination cursor until no more results
 //
+// Note: Ideally each channel should have at least one policy. However, if a
+// channel is created and never updated, it will not have any policies.
+// In this case, we'll return the channel with no policies at all regardless of
+// the time range. This helps us prune zombie channels with no policies.
+//
 // NOTE: This is part of the V1Store interface.
 func (s *SQLStore) ChanUpdatesInHorizon(startTime, endTime time.Time,
 	opts ...IteratorOption) iter.Seq2[ChannelEdge, error] {