[management] use peer.Status.LastSeen field to detect stale peer.Status.Connected values (#7268)

management/server/store/sql_store_activity_test.go

@@ -109,6 +109,88 @@ func TestRefreshPeerLastSeenLeavesSessionStateAlone(t *testing.T) {
 	assert.Equal(t, int64(1234567890), peer.Status.SessionStartedAt, "session token must survive an activity write")
 }
 
+// TestPeerReadsAsDisconnectedWhenStale covers a management instance that stopped
+// without marking its peers disconnected: the stored flag stays set, so reads must
+// fall back to LastSeen, both when loading the peer and when filtering on it.
+func TestPeerReadsAsDisconnectedWhenStale(t *testing.T) {
+	ctx := context.Background()
+
+	tests := []struct {
+		name          string
+		lastSeen      time.Time
+		wantConnected bool
+	}{
+		{name: "seen within StaleAfter", lastSeen: time.Now().UTC().Add(-time.Minute), wantConnected: true},
+		{name: "not seen for longer than StaleAfter", lastSeen: time.Now().UTC().Add(-nbpeer.StaleAfter - time.Minute)},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			store := newActivityTestStore(t)
+			stored := activityPeer(tt.lastSeen)
+			stored.Status.Connected = true
+			require.NoError(t, store.AddPeerToAccount(ctx, stored))
+
+			peer, err := store.GetPeerByID(ctx, LockingStrengthNone, activityAccountID, "activityPeer")
+			require.NoError(t, err)
+			assert.Equal(t, tt.wantConnected, peer.Status.Connected)
+
+			for _, connected := range []bool{true, false} {
+				peers, _, err := store.GetAccountPeersPaginated(ctx, LockingStrengthNone, activityAccountID, PaginationState{}, PeerFilters{Connected: &connected}, PeerSorting{})
+				require.NoError(t, err)
+				if connected == tt.wantConnected {
+					assert.Len(t, peers, 1, "filter connected=%t", connected)
+				} else {
+					assert.Empty(t, peers, "filter connected=%t", connected)
+				}
+			}
+		})
+	}
+}
+
+func TestHeartbeatPeerSession(t *testing.T) {
+	ctx := context.Background()
+	const session = int64(1234567890)
+	stale := time.Now().UTC().Add(-time.Hour)
+
+	tests := []struct {
+		name          string
+		storedSession int64
+		loginExpired  bool
+		session       int64
+		wantUpdated   bool
+	}{
+		{name: "stream that owns the session", storedSession: session, session: session, wantUpdated: true},
+		{name: "login expired while the stream stayed open", storedSession: session, loginExpired: true, session: session},
+		{name: "session replaced by a newer stream", storedSession: session + 1, session: session},
+		{name: "session already ended", session: session},
+		{name: "zero token never matches", session: 0},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			store := newActivityTestStore(t)
+			stored := activityPeer(stale)
+			stored.Status.SessionStartedAt = tt.storedSession
+			stored.Status.LoginExpired = tt.loginExpired
+			require.NoError(t, store.AddPeerToAccount(ctx, stored))
+
+			updated, err := store.HeartbeatPeerSession(ctx, activityAccountID, "activityPeer", tt.session)
+			require.NoError(t, err)
+			assert.Equal(t, tt.wantUpdated, updated)
+
+			peer, err := store.GetPeerByID(ctx, LockingStrengthNone, activityAccountID, "activityPeer")
+			require.NoError(t, err)
+			assert.Equal(t, tt.storedSession, peer.Status.SessionStartedAt, "the session token must never change")
+			if tt.wantUpdated {
+				assert.True(t, peer.Status.Connected, "a heartbeat must undo a connected flag that was saved back as false")
+				assert.WithinDuration(t, time.Now().UTC(), peer.Status.LastSeen.UTC(), time.Minute)
+				return
+			}
+			assert.False(t, peer.Status.Connected)
+			assert.WithinDuration(t, stale, peer.Status.LastSeen.UTC(), time.Second)
+		})
+	}
+}
+
 func activityPeer(lastSeen time.Time) *nbpeer.Peer {
 	return &nbpeer.Peer{
 		ID:        "activityPeer",