Among the many greatest snapshot testing instruments for .NET builders, there are lots of nice choices. However there are two instruments that actually stand out: Confirm and Storm Petrel. Each supply distinctive approaches to managing anticipated baselines in unit and integration checks, however they differ considerably in methodology and implementation.

Confirm focuses on file-based snapshot administration, storing serialized baselines, and leveraging specialised extensions and diff instruments.

Storm Petrel, however, introduces a C# code-based method, utilizing .NET Incremental Turbines to replace baselines instantly throughout the check code. Understanding their variations will help builders select the precise device based mostly on their challenge wants.

What Is Confirm .NET?

Confirm .NET is a group of NuGet packages ,snapshot administration instruments, and extensions designed to simplify snapshot testing in .NET.

It supplies extensions for serialization, comparability, and verification of anticipated baselines for the preferred .NET libraries and frameworks. Confirm helps set up snapshot testing by evaluating and rewriting baseline snapshots saved within the file system.

What Is Storm Petrel .NET?

Storm Petrel .NET is an Incremental Generator device that updates anticipated baselines instantly in C# check code (somewhat than in file snapshots). It helps unit and integration checks for the preferred .NET check frameworks.

File snapshots are a particular use case of baseline administration in Storm Petrel, which might be carried out by way of the extra FileSnapshotInfrastructure NuGet package deal. This package deal partially implements Storm Petrel’s abstraction layer.

Technical Comparability: Confirm vs. Storm Petrel

Right here, we’ll examine Confirm and Storm Petrel that will help you see crucial variations in how they deal with snapshots, check updates, and supported frameworks.

Check Refactoring Necessities

Builders have to refactor conventional assertion checks into snapshot checks utilizing Confirm. Beneath are examples of how one can transition from conventional checks to Confirm-style checks.

Conventional Assertion Check Instance

public void TraditionalTest()
{

    var particular person = ClassBeingTested.FindPerson();
    Assert.Equal(new("ebced679-45d3-4653-8791-3d969c4a986c"), particular person.Id);
    Assert.Equal(Title.Mr, particular person.Title);
    Assert.Equal("John", particular person.GivenNames);
    Assert.Equal("Smith", particular person.FamilyName);
    Assert.Equal("Jill", particular person.Partner);
    Assert.Equal(2, particular person.Kids.Depend);
    Assert.Equal("Sam", particular person.Kids[0]);
    Assert.Equal("Mary", particular person.Kids[1]);
    Assert.Equal("4 Puddle Lane", particular person.Deal with.Avenue);
    Assert.Equal("USA", particular person.Deal with.Nation);
}

Conventional Check Utilizing FluentAssertions

public void TraditionalTestViaAssertionLibrary()
{

    var particular person = ClassBeingTested.FindPerson();
    particular person.Ought to().BeEquivalentTo(new Particular person
    {

        Id = new("ebced679-45d3-4653-8791-3d969c4a986c"),
        Title = Title.Mr,
        GivenNames = "John",
        FamilyName = "Smith",
        Partner = "Jill",
        Kids = new Checklist<string>
        {

            "Sam",
            "Mary"
        },
        Deal with = new Deal with
        {
            Nation = "USA",
            Avenue = "4 Puddle Lane",
        }
    });
}

Snapshot Check Utilizing Confirm

public Activity SnapshotTest()
{

    var particular person = ClassBeingTested.FindPerson();
    return Confirm(particular person);
}

In Confirm, the particular person baseline is serialized and saved in a file to comply with Confirm’s Preliminary Verification and Subsequent Verification flows.

Preliminary Verification

Subsequent Verification

Storm Petrel doesn’t require builders to vary conventional checks. As defined within the “Snapshot Testing with Scand.StormPetrel.Generator with out Serialization” part, conventional checks retain their important advantages over snapshot checks.

For file snapshot checks, Storm Petrel additionally follows the standard method with one pure requirement:

builders should name strategies like

`Scand.StormPetrel.FileSnapshotInfrastructure.SnapshotProvider.ReadAllText()`

or

`SnapshotProvider.ReadAllBytes()`

based mostly on the use instances.

Snapshot Storage & Administration

Confirm helps instruments like ReSharper and Rider check runner Confirm plugins. Storm Petrel .NET, nevertheless, doesn’t require these instruments.

As a substitute, it leverages .NET/IDE infrastructure to run autogenerated checks and replace baselines. After updating the baselines, builders can examine them utilizing any third-party device to confirm if the updates are appropriate.

Confirm provides quite a few extensions (e.g., Confirm.AspNetCore, Confirm.WinForms, Confirm.Xaml) to confirm objects from particular libraries. Storm Petrel eliminates the necessity for such extensions by representing baselines as C# code by way of third-party dumpers or utilizing any serialization/illustration of objects for file snapshots.

Supported Check Frameworks

Confirm helps about six check frameworks, together with xUnit, NUnit, and MSTest. Storm Petrel presently helps solely these three hottest frameworks.

Diff & Replace Mechanisms

Confirm features a diff engine with help for varied instruments. Storm Petrel, however, updates baselines instantly, permitting builders to make use of any diff/merge device of their alternative for comparability.

Professionals and Cons of Each Approaches

Beneath are essentially the most notable professionals and cons of every method (although not an exhaustive record).

Professionals of Confirm

Cons of Confirm

• No Assist for C# Code Baselines: Confirm doesn’t help anticipated baselines saved instantly in C# code, which is a major use case in conventional checks.
• Check Refactoring Required: Important adjustments to conventional checks are wanted to undertake Confirm’s snapshot testing method.
• Complexity: The big variety of interactivity choices and specialised extensions might require further effort to be taught and configure. Some object representations might not be enough out-of-the-box.

Professionals of Storm Petrel

• Conventional Check Strategy: Maintains the standard testing method with out requiring important adjustments. See the configuration for particular default/customized naming conventions of precise/anticipated variables and FAQs for different particulars.
• Flexibility: Helps each “anticipated baselines in C# code” and “anticipated baselines in snapshot recordsdata” situations.
• Simplicity: No want for specialised extensions or embedded interactivity instruments. Any third-party options can be utilized right here.

Cons of Storm Petrel

• No Embedded Interactivity: Builders should use third-party diff instruments to check precise and anticipated baselines after Storm Petrel .NET updates them.
• Restricted Framework Assist: Presently helps solely xUnit, NUnit, and MSTest. No help for much less standard frameworks or F#.

Use Circumstances

On this part, we’ll discover how Confirm and Storm Petrel are utilized in real-world situations. Every device serves particular wants, so we’ll break down when and why you would possibly select one over the opposite.

Preliminary and Subsequent Verification with Confirm

Confirm is just for initiatives the place you wish to handle snapshot testing via exterior recordsdata. You utilize Confirm to each confirm and rewrite anticipated baselines for Confirm-style snapshot checks. That is helpful when you could retailer snapshots outdoors of your check code and simply examine them as your checks evolve.

Instance:
You run a check, and the baseline snapshot doesn’t match the present output. Confirm rewrites the snapshot to replicate the brand new state, making it straightforward to trace adjustments over time.

Visible Support:
Preliminary and Subsequent Verification with Confirm.

Rewriting Baselines with Storm Petrel

Storm Petrel focuses on C# code baselines for snapshot checks. It additionally helps snapshot testing via exterior recordsdata, making it a sensible choice for builders. It provides two major use instances for baseline rewriting:

• Conventional Checks: With Storm Petrel, you may automate the method of updating baselines which can be saved instantly as C# code inside your check strategies. This works effectively while you don’t wish to depend on exterior snapshot recordsdata, preserving all the pieces in your check code.
  Instance:
  Storm Petrel adjusts the baseline in your C# code every time the check outcomes change, preserving it per the most recent state.
  Visible Support: