Write a regression test for a cursor-paginated endpoint that previously skipped rows sharing a timestamp.

Seed more equal-timestamp records than fit on one page in an isolated store. Follow nextCursor until null and compare all returned ids with the seeded set. Insert a newer record after page one and verify it does not shift forward traversal.

Twelve records share one timestamp with page size five. Three pages return all twelve ids exactly once.

• Treat cursors as opaque strings in the client test.
• Verify ids, not just page sizes.
• Bound the page-walking loop.
• Use deterministic isolated seed data.

I test the API as a consumer would: request a page, retain ids, follow the returned cursor, and stop at null. A set comparison catches missing rows while a duplicate assertion catches unstable tie handling.

[Fact]
public async Task Forward_cursor_is_stable_when_a_newer_row_arrives()
{
    await using var factory = await ApiTestFactory.WithTiedEventsAsync(count: 12);
    var client = factory.CreateAuthenticatedClient("user-1", "events.read");
    var seededIds = factory.SeededEventIds.ToHashSet();
    var seen = new List<Guid>();

    var page = await ReadPageAsync(client, cursor: null);
    seen.AddRange(page.Items.Select(item => item.Id));

    var newerId = await factory.InsertEventAsync(
        factory.SeededTimestamp.AddMinutes(1));

    var cursor = page.NextCursor;
    for (var pageNumber = 1; cursor is not null && pageNumber < 10; pageNumber++)
    {
        page = await ReadPageAsync(client, cursor);
        seen.AddRange(page.Items.Select(item => item.Id));
        cursor = page.NextCursor;
    }

    Assert.Null(cursor);
    Assert.Equal(seededIds.Count, seen.Count);
    Assert.Equal(seededIds.Order(), seen.Order());
    Assert.Equal(seen.Count, seen.Distinct().Count());
    Assert.DoesNotContain(newerId, seen);
}

private static async Task<EventPage> ReadPageAsync(
    HttpClient client,
    string? cursor)
{
    var url = QueryHelpers.AddQueryString(
        "/api/events",
        new Dictionary<string, string?>
        {
            ["pageSize"] = "5",
            ["cursor"] = cursor
        });

    return (await client.GetFromJsonAsync<EventPage>(url))!;
}

This test is cheap with deterministic isolated data. If provider translation determines cursor behavior, use a disposable relational database rather than the in-memory provider.

• All records share one timestamp.
• The final page is partially filled.
• A new record arrives after page one.
• The cursor is malformed or paired with changed filters.

• Seed ties larger than one page.
• Assert the loop terminates.
• Compare concatenated pages to a known snapshot.

• Asserting only that each page has at most five rows.
• Sorting by timestamp without id.
• Decoding and rebuilding opaque cursors in the test.
• Using unbounded page walking.