Inject state blocks from incremental polls into the room timeline

state/event_table.go

@@ -149,6 +149,8 @@ func (t *EventTable) SelectHighestNID() (highest int64, err error) {
 }
 
 // Insert events into the event table. Returns a map of event ID to NID for new events only.
+// The NIDs assigned to new events will respect the order of the given events, e.g. if
+// we insert new events A and B in that order, then NID(A) < NID(B).
 func (t *EventTable) Insert(txn *sqlx.Tx, events []Event, checkFields bool) (map[string]int, error) {
 	if checkFields {
 		ensureFieldsSet(events)
@@ -211,6 +213,10 @@ func (t *EventTable) SelectByNIDs(txn *sqlx.Tx, verifyAll bool, nids []int64) (e
 	WHERE event_nid = ANY ($1) ORDER BY event_nid ASC;`, pq.Int64Array(nids))
 }
 
+// SelectByIDs fetches all events with the given event IDs from the DB as Event structs.
+// If verifyAll is true, the function will check that each event ID has a matching
+// event row in the database. The returned events are ordered by ascending NID; the
+// order of the event IDs is irrelevant.
 func (t *EventTable) SelectByIDs(txn *sqlx.Tx, verifyAll bool, ids []string) (events []Event, err error) {
 	wanted := 0
 	if verifyAll {

state/event_table_test.go

@@ -920,28 +920,29 @@ func TestEventTableSelectUnknownEventIDs(t *testing.T) {
 	if err != nil {
 		t.Fatalf("failed to select events: %s", err)
 	}
-	if (gotEvents[0].ID == eventID1 && gotEvents[1].ID == eventID2) || (gotEvents[0].ID == eventID2 && gotEvents[1].ID == eventID1) {
+	if gotEvents[0].ID == eventID1 && gotEvents[1].ID == eventID2 {
 		t.Logf("Got expected event IDs after insert. NIDS: %s=%d, %s=%d", gotEvents[0].ID, gotEvents[0].NID, gotEvents[1].ID, gotEvents[1].NID)
 	} else {
 		t.Fatalf("Event ID mismatch: expected $A-SelectUnknownEventIDs and $B-SelectUnknownEventIDs, got %v", gotEvents)
 	}
 
 	// Someone else tells us the state of the room is {A, C}. Query which of those
 	// event IDs are unknown.
-	const unknownEventID = "$C-SelectUnknownEventIDs"
-	stateBlockIDs := []string{eventID1, unknownEventID}
+	shouldBeUnknownIDs := []string{"$C-SelectUnknownEventIDs", "$D-SelectUnknownEventIDs"}
+	stateBlockIDs := append(shouldBeUnknownIDs, eventID1)
 	unknownIDs, err := table.SelectUnknownEventIDs(txn, stateBlockIDs)
 	t.Logf("unknownIDs=%v", unknownIDs)
 	if err != nil {
 		t.Fatalf("failed to select unknown state events: %s", err)
 	}
 
-	// Only event C should be flagged as unknown.
-	if len(unknownIDs) != 1 {
-		t.Fatalf("Expected 1 unknown id, got %v", unknownIDs)
+	// Event C and D should be flagged as unknown.
+	if len(unknownIDs) != len(shouldBeUnknownIDs) {
+		t.Fatalf("Expected %d unknown ids, got %v", len(shouldBeUnknownIDs), unknownIDs)
 	}
-	_, ok := unknownIDs[unknownEventID]
-	if !ok {
-		t.Fatalf("Expected $C-SelectUnknownEventIDs to be unknown to the DB, but it wasn't")
+	for _, unknownEventID := range shouldBeUnknownIDs {
+		if _, ok := unknownIDs[unknownEventID]; !ok {
+			t.Errorf("Expected %s to be unknown to the DB, but it wasn't", unknownEventID)
+		}
 	}
 }

tests-integration/poller_test.go

@@ -205,7 +205,7 @@ func TestPollerUpdatesRoomMemberTrackerOnGappySyncStateBlock(t *testing.T) {
 	v2.addAccount(bob, bobToken)
 	const roomID = "!unimportant"
 
-	t.Log("Alice's poller does an initial sync. It sees that Alice and Bob share a room.")
+	t.Log("Alice and Bob's pollers initial sync. Both see the same state: that Alice and Bob share a room.")
 	initialTimeline := createRoomState(t, alice, time.Now())
 	bobJoin := testutils.NewStateEvent(
 		t,
@@ -221,9 +221,12 @@ func TestPollerUpdatesRoomMemberTrackerOnGappySyncStateBlock(t *testing.T) {
 	v2.queueResponse(aliceToken, sync2.SyncResponse{
 		Rooms: sync2.SyncRoomsResponse{Join: initialJoinBlock},
 	})
+	v2.queueResponse(aliceToken, sync2.SyncResponse{
+		Rooms: sync2.SyncRoomsResponse{Join: initialJoinBlock},
+	})
 
 	t.Log("Alice makes an initial sliding sync request.")
-	aliceRes := v3.mustDoV3Request(t, aliceToken, sync3.Request{
+	syncRequest := sync3.Request{
 		Lists: map[string]sync3.RequestList{
 			"a": {
 				Ranges: [][2]int64{{0, 20}},
@@ -232,7 +235,35 @@ func TestPollerUpdatesRoomMemberTrackerOnGappySyncStateBlock(t *testing.T) {
 				},
 			},
 		},
-	})
+	}
+	aliceRes := v3.mustDoV3Request(t, aliceToken, syncRequest)
+
+	t.Log("Alice sees herself and Bob joined to the room.")
+	m.MatchResponse(
+		t,
+		aliceRes,
+		m.MatchList(
+			"a",
+			m.MatchV3Count(1),
+			m.MatchV3Ops(m.MatchV3SyncOp(0, 0, []string{roomID})),
+		),
+		m.MatchRoomSubscription(roomID, m.MatchRoomTimelineMostRecent(1, []json.RawMessage{bobJoin})),
+	)
+
+	t.Log("Bob makes an initial sliding sync request.")
+	bobRes := v3.mustDoV3Request(t, bobToken, syncRequest)
+
+	t.Log("Bob sees himself and Alice joined to the room.")
+	m.MatchResponse(
+		t,
+		bobRes,
+		m.MatchList(
+			"a",
+			m.MatchV3Count(1),
+			m.MatchV3Ops(m.MatchV3SyncOp(0, 0, []string{roomID})),
+		),
+		m.MatchRoomSubscription(roomID, m.MatchJoinCount(2)),
+	)
 
 	t.Log("Alice's poller receives a gappy incremental sync response. Bob has left in the gap. The timeline includes a message from Alice.")
 	bobLeave := testutils.NewStateEvent(
@@ -260,35 +291,13 @@ func TestPollerUpdatesRoomMemberTrackerOnGappySyncStateBlock(t *testing.T) {
 		},
 	})
 
-	t.Log("Alice makes an incremental sliding sync request.")
-	aliceRes = v3.mustDoV3RequestWithPos(t, aliceToken, aliceRes.Pos, sync3.Request{})
-
-	t.Log("She should see Bob's leave event and her message at the end of the room timeline.")
-	m.MatchResponse(
-		t,
-		aliceRes,
-		m.MatchRoomSubscription(
-			roomID,
-			m.MatchRoomTimelineMostRecent(2, []json.RawMessage{bobLeave, aliceMessage}),
-		),
-	)
-
-	t.Log("Bob makes an initial sliding sync request.")
-	bobRes := v3.mustDoV3Request(t, bobToken, sync3.Request{
-		Lists: map[string]sync3.RequestList{
-			"a": {
-				Ranges: [][2]int64{{0, 20}},
-				RoomSubscription: sync3.RoomSubscription{
-					TimelineLimit: 10,
-				},
-			},
-		},
-	})
-	t.Log("He should not see himself in the room.")
+	t.Log("Bob makes an incremental sliding sync request.")
+	bobRes = v3.mustDoV3RequestWithPos(t, bobToken, bobRes.Pos, sync3.Request{})
+	t.Log("He should see his leave event in the room timeline.")
 	m.MatchResponse(
 		t,
 		bobRes,
-		m.MatchList("a", m.MatchV3Count(0)),
+		m.MatchList("a", m.MatchV3Count(1)),
+		m.MatchRoomSubscription(roomID, m.MatchRoomTimelineMostRecent(1, []json.RawMessage{bobLeave})),
 	)
-
 }