Structural Snapshot tests for .NET

Browser journeys

Click through a running site with Nullean.Cdp: a text file of agent-browser commands, run in Chrome with no Node and no daemon. Every read lands in one transcript per journey, compared as a tree, so a failure names the node that moved.

# Search, add a lamp, look at the basket.
open index.html
find label Search fill lamp
find role button click --name Search --exact
snapshot -c -s "#results"
find role button click --name "Add red lamp"
get text #count
click "a[href='basket.html']"
get title
snapshot -c -s main

[Test]
[JourneyFiles("journeys")]   // a test case per file
public Task Run(SnapshotFile journey) =>
    JourneyTest.RunAsync(journey,
        new() { BaseUrl = server.Url });

Add a11y, links, network requests --failed or Web Vitals budgets and they snapshot too; screenshots and HAR files land next to the received transcript. Browser journeys →

HTTP APIs

Run the .http files you already keep for Visual Studio, Rider or the REST Client against any HttpClient, WebApplicationFactory's included. Each response is snapshotted: status, the headers you choose, and JSON bodies compared as trees.

### login
POST {{host}}/api/login
Content-Type: application/json

{"user": "ada"}

###
GET {{host}}/api/orders
Authorization: Bearer {{login.response.body.$.token}}

###
GET {{host}}/api/missing

[Test]
[HttpFiles("http")]
public Task Run(SnapshotFile file) =>
    HttpFileTest.RunAsync(file,
        new() { Client = factory.CreateClient() });

[Test]
public async Task Orders() =>
    await (await client.GetAsync("/api/orders"))
        .Should().MatchHttpSnapshot();

Secrets from user secrets, configuration or environment variables are redacted from everything written, even when a server echoes them back. snap http run runs the same files against a live host. HTTP →

Inline snapshots, accepted by snap

Keep a short expected value in the test, as a string literal, for text, HTML, JSON and YAML. When the output changes, snap accept rewrites that literal in your source itself: a plain string for one line, a raw """ literal for several.

No agent edits, no tokens spent. It is a deterministic edit by the CLI, and there are no expected strings to retype by hand.

[Test]
public void RendersTheBasket() =>
    basket.Render().Should().MatchInlineSnapshot("""
        2 × beats
        1 × lamp
        """);

[Test]
public void Serializes() =>
    // no value yet: snap accept writes it
    json.Should().MatchInlineJsonSnapshot();

snap review shows each change as a diff and snap accept --all takes the lot, or SNAPSHOT_ACCEPT=1 dotnet test does it without the CLI. Nothing is edited until you accept, and never in CI. If the test file changed since the run, or the expected value is not a plain literal, accepting says why and edits nothing. Inline snapshots →

Review, then accept

snap walks through what changed, one snapshot at a time. Accept it, reject it, or skip it for later. Keys can be given in full, as a unique suffix, or as a glob.

dotnet tool install --global Nullean.Snapshots.Cli
# or, without installing:
dnx Nullean.Snapshots.Cli status