diff --git a/plan.md b/plan.md index 09e578b..6b7c576 100644 --- a/plan.md +++ b/plan.md @@ -77,7 +77,7 @@ Companion research files (raw per-plugin catalogue produced while researching th - Core looks for a type named `VerifyTests.` plus the assembly name without dots. The match is case-sensitive, and an assembly without that type is skipped silently (`Verify\src\Verify\VerifierSettings_PluginConvention.cs:171-176, 202-208`). - As a result it never initializes **Verify.AngleSharp** (its class is `VerifyAngleSharpDiffing`), **Verify.QuestPDF** (`VerifyQuestPdf`) or **Verify.Blazor** (an internal class in the global namespace). - Plugins are enumerated in file-system order (`:34`), so when two plugins register for the same thing, the winner can differ between operating systems. -- Some `Initialize` methods take parameters that matter: `VerifyDiffPlex.Initialize(OutputType)`, `VerifySqlServer.Initialize(recordCommands)`, `VerifyEntityFramework.Initialize(model, recordCommands)`, `VerifyNServiceBus.Initialize(captureLogs)` (no effect in practice, see 11.2), `VerifyBunit.Initialize(excludeComponent)`, `VerifyImageSharp.Initialize(ssimThreshold)`, `VerifyPDFium.Initialize(dpi)`, `VerifyPlaywright.Initialize(installPlaywright)`, `VerifySerilog.Initialize(custom)`, `VerifyEmailPreviewServices.Initialize(apiKey)`, `VerifyAngleSharpDiffing.Initialize(action)`. +- Some `Initialize` methods take parameters that matter: `VerifySqlServer.Initialize(recordCommands)`, `VerifyEntityFramework.Initialize(model, recordCommands)`, `VerifyNServiceBus.Initialize(captureLogs)` (no effect in practice, see 11.2), `VerifyBunit.Initialize(excludeComponent)`, `VerifyImageSharp.Initialize(ssimThreshold)`, `VerifyPDFium.Initialize(dpi)`, `VerifyPlaywright.Initialize(installPlaywright)`, `VerifySerilog.Initialize(custom)`, `VerifyEmailPreviewServices.Initialize(apiKey)`, `VerifyAngleSharpDiffing.Initialize(action)`. - Several groups are mutually exclusive because they register a converter or comparer for the same file extension (pdf, xlsx, docx, pptx, csv, png/jpg, html, json) or install the same global listener (Activity listeners, 26-char ULID scrub windows). - The documented interaction the requester cited: Verify.EntityFramework and Verify.SqlServer both record every EF command (`ef` and `sql`), and `VerifySqlServer.Initialize(recordCommands: false)` **must** run before `VerifierSettings.InitializePlugins()`. @@ -92,7 +92,7 @@ Numbered so they can be referenced. Each is a choice the requester did not spell - **D3. NuGet versions: baked plus live refresh.** A `package-versions.json` in `Wizard.Core` holds the last known stable version of every package the wizard can emit. A weekly GitHub Actions workflow refreshes it from nuget.org and opens a pull request. At runtime the app also queries nuget.org (same flat-container endpoint SponsorCheck already uses from the browser) and uses the newest **non-prerelease** version when the query succeeds; the baked value is the offline fallback. "Stable" means no `-` prerelease label. If a package has no stable version (none currently), fall back to newest prerelease and say so in the output. - **D4. Explicit `Initialize` calls, then `InitializePlugins`.** The generated `ModuleInitializer` calls each selected plugin's `Initialize` explicitly, in an order computed from the interaction rules, each with a verbose comment, and then calls `VerifierSettings.InitializePlugins()` (which skips already-initialized plugins) with a comment explaining that it picks up plugins added later. Explicit calls are needed anyway for parameters and ordering; making them universal keeps the output predictable and self-documenting. They are also needed for correctness, because `InitializePlugins()` never initializes Verify.AngleSharp, Verify.QuestPDF or Verify.Blazor (1.3). - **D5. Windows-only plugins go in a second test project.** WinForms and Xaml need `net10.0-windows` (`UseWindowsForms`/`UseWPF`), Phash targets `net8.0-windows`. Putting them in the main test project would make the whole solution Windows-only. The zip therefore contains `.Tests` (cross-platform) and, when needed, `.Tests.Windows`. Each project has its own `ModuleInitializer`. -- **D6. Verified files are not included in the zip**, except where the exact output is known: the core sample (`Sample.Test.verified.txt`, from the Verify repository) and any plugin sample that sets `VerifiedOutput`, which today is Verify.DiffPlex's, because it verifies a literal string and DiffPlex is selected by default. A download whose first `dotnet test` fails is a poor way to meet a tool, so the default one passes. Plugin sample outputs depend on package versions and machine state; shipping wrong `.verified.` files is worse than shipping none. The README and AI content explain that the first run produces `.received.` files and how to accept them. +- **D6. Verified files are not included in the zip**, except where the exact output is known: the core sample (`Sample.Test.verified.txt`, from the Verify repository), and no plugin sample's. (Verify.DiffPlex's sample shipped one, through a `VerifiedOutput` field, while DiffPlex was selected by default; it was removed with the plugin, because Verify now shows a text diff in the failure message itself.) A download whose first `dotnet test` fails is a poor way to meet a tool, so the default one passes. Plugin sample outputs depend on package versions and machine state; shipping wrong `.verified.` files is worse than shipping none. The README and AI content explain that the first run produces `.received.` files and how to accept them. - **D7. "Verbose" vs "minimal" is per plugin** and defaults to **verbose**, because the requester asked to bias toward more content that users can delete. Minimal = the enable call plus the one or two most common usages. Verbose = minimal plus every documented API in the catalogue's "Verbose / edge-case APIs" list, each as its own commented test method. - **D8. Sponsor step interprets `One Month From Now`** from the request as "emit a real date". The wizard emits `Verify_SponsorshipStart` = **today (UTC, `yyyy-MM-dd`)** when the user says the sponsorship is new, because the bundled sponsor list is frozen at pack time and a future date fails with SC028. The user can edit the date. The alternative reading (a date one month ahead) is rejected by the verifier, so it is not offered. See section 14. - **D9. Expecto (F#) is supported for the core sample only.** Plugin usage samples are C#; for Expecto the docs show them as C# with a note, the F# test project configures Verify in a `lazy` value in `Tests.fs` that every test forces before verifying, and plugin tests are not generated into the fsproj. A custom `main` is not possible there: with `EnableExpectoTestingPlatformIntegration` the SDK generates the entry point (FS0433), and F# has no module initializers. This is a scoping decision, not a limitation of Verify. The F# initializer is generated from the same ordered call list as the C# one, so a selected plugin is enabled either way; a call needing one of the C# helper methods the generator emits, such as EntityFramework's `GetDbModel()`, is replaced by a comment saying plugin discovery enables that plugin with its defaults instead. @@ -205,7 +205,7 @@ D:\Code\VerifyTests\Wizard\ wwwroot/ index.html, css/app.css, fonts/, js/interop.js, favicon.svg, fixtures/ Wizard.Tests/ - Wizard.Tests.csproj TUnit + Verify.TUnit + Verify.DiffPlex + bunit + Verify.Bunit + Verify.AngleSharp + Microsoft.Playwright + Verify.Playwright + DiffEngine + Wizard.Tests.csproj TUnit + Verify.TUnit + bunit + Verify.Bunit + Verify.AngleSharp + Microsoft.Playwright + Verify.Playwright + DiffEngine Generation/*Tests.cs snapshot tests of every generator Registry/*Tests.cs registry invariants Components/*Tests.cs bunit @@ -242,7 +242,7 @@ Start from `SponsorCheck.Web.csproj` and change: ### 5.2 Directory.Packages.props (this repository) -`ManagePackageVersionsCentrally=true`, `CentralPackageTransitivePinningEnabled=true`. Packages: `Microsoft.AspNetCore.Components.WebAssembly`, `Markdig`, `ProjectDefaults`, `Polyfill`, `TUnit`, `Verify`, `Verify.TUnit`, `Verify.DiffPlex`, `Verify.AngleSharp`, `bunit`, `Verify.Bunit`, `Microsoft.Playwright`, `Verify.Playwright`, `DiffEngine`, `MarkdownSnippets.MsBuild` (for readme generation), `System.Text.Json`. Take initial versions from `SponsorCheck/src/Directory.Packages.props` (all current as of this plan: Verify 33.1.0, Verify.DiffPlex 3.3.1, Verify.AngleSharp 5.1.2, bunit 2.11.3, Verify.Bunit 14.0.0, Microsoft.Playwright 1.62.0, Verify.Playwright 3.1.1, DiffEngine 20.3.1, TUnit 1.68.17, Microsoft.AspNetCore.Components.WebAssembly 10.0.12). +`ManagePackageVersionsCentrally=true`, `CentralPackageTransitivePinningEnabled=true`. Packages: `Microsoft.AspNetCore.Components.WebAssembly`, `Markdig`, `ProjectDefaults`, `Polyfill`, `TUnit`, `Verify`, `Verify.TUnit`, `Verify.AngleSharp`, `bunit`, `Verify.Bunit`, `Microsoft.Playwright`, `Verify.Playwright`, `DiffEngine`, `MarkdownSnippets.MsBuild` (for readme generation), `System.Text.Json`. Take initial versions from `SponsorCheck/src/Directory.Packages.props` (all current as of this plan: Verify 33.1.0, Verify.AngleSharp 5.1.2, bunit 2.11.3, Verify.Bunit 14.0.0, Microsoft.Playwright 1.62.0, Verify.Playwright 3.1.1, DiffEngine 20.3.1, TUnit 1.68.17, Microsoft.AspNetCore.Components.WebAssembly 10.0.12). Note: `DiffEngine` is referenced by the **tests** so a registry test can assert the wizard's static diff-tool list matches `DiffEngine.Definitions.Tools` (section 17.2). Do not reference DiffEngine from `Wizard.Core` (it uses `Process` and is not meant for WASM). @@ -287,7 +287,7 @@ sealed class WizardState HashSet ExistingPlugins // Plugin ids already in the user's project (Add flows) HashSet SelectedPlugins // Plugin ids to add / include Dictionary Depths // per selected plugin; default Verbose - Dictionary Choices // per-plugin or per-rule choices, e.g. "ef-sql-recording" => "keep-ef"; "diffplex-output" => "Compact"; "systemjson-strict" => "false" + Dictionary Choices // per-plugin or per-rule choices, e.g. "ef-sql-recording" => "keep-ef"; "systemjson-strict" => "false" // sponsor SponsorMode SponsorMode string SponsorAccount @@ -321,8 +321,8 @@ Every flow is a linear list of steps; each step is a Razor component bound to `W 4. **Test framework** (xUnit v3, NUnit, TUnit, MSTest, Fixie, Expecto). Names only: the notes that were planned here (MTP, F#, `[UsesVerify]`) added nothing to the choice, and the guide covers each. 5. **Build server** (GitHub Actions, Azure DevOps, AppVeyor, none). 6. **Tech stack** (optional, multi-select chips grouped by category; persisted). Skippable with "I just want the basics". Selecting tech pre-checks plugins on the next step. -7. **Plugins** (multi-select cards grouped by category; suggested ones pre-checked and shown first under "Suggested for your stack", the rest under "Everything else"). Verify.DiffPlex is pre-checked always. Cards show badges: Windows only, licence required, external tool required, needs running service, beta, net10 only. Interaction notices appear inline as soon as two interacting plugins are both checked (section 11). -8. **Options**: always shown. Snapshot storage, Files (default) or Inline (12.8), then per selected plugin, a Minimal/Verbose toggle (default Verbose), plus any rule choices (EF/SqlServer recording owner, DiffPlex output type, SystemJson strict JSON, Bunit exclude component, image comparer tolerance, PDFium dpi, HeadlessBrowsers driver, EF Core vs EF6, Serilog custom configuration stub). One compact form. +7. **Plugins** (multi-select cards grouped by category; suggested ones pre-checked and shown first under "Suggested for your stack", the rest under "Everything else"). Nothing is pre-checked without a tech that suggests it (Verify.DiffPlex used to be, until Verify showed a text diff in the failure message itself). Cards show badges: Windows only, licence required, external tool required, needs running service, beta, net10 only. Interaction notices appear inline as soon as two interacting plugins are both checked (section 11). +8. **Options**: always shown. Snapshot storage, Files (default) or Inline (12.8), then per selected plugin, a Minimal/Verbose toggle (default Verbose), plus any rule choices (EF/SqlServer recording owner, SystemJson strict JSON, Bunit exclude component, image comparer tolerance, PDFium dpi, HeadlessBrowsers driver, EF Core vs EF6, Serilog custom configuration stub). One compact form. 9. **Sponsor** (section 14). 10. **Output** (section 12): rendered docs, three download/copy actions, file list. @@ -330,7 +330,7 @@ Every flow is a linear list of steps; each step is a Razor component bound to `W 1. **Test framework** (needed to generate tests and the correct LocalDb package). 2. **Already using** (optional): multi-select of plugins already in the project. Pre-filled from `localStorage`. Everything checked here is excluded from step 3's pick list (shown greyed as "already in your project") and participates in interaction rules with a "Existing" role so the side effects of adding a new plugin next to an existing one are listed. -3. **Plugins to add** (same card grid as A7, without tech pre-selection; deep-link id pre-checked). Nothing is selected by default: Verify.DiffPlex, pre-checked for a new project, is not assumed for an existing one. An existing plugin's card is shown ticked and locked. When a rule the new selection triggers changes how an existing plugin has to be initialized (EntityFramework added next to an existing SqlServer turns SqlServer's recording off), the generated `ModuleInitializer.cs` carries that existing call too, with a comment saying to replace the project's own; an existing plugin that plugin discovery cannot find (A1) raises an `existing-not-discovered` warning, because a project relying on `InitializePlugins()` alone never enabled it. +3. **Plugins to add** (same card grid as A7, without tech pre-selection; deep-link id pre-checked). Nothing is selected by default, as in a new project. An existing plugin's card is shown ticked and locked. When a rule the new selection triggers changes how an existing plugin has to be initialized (EntityFramework added next to an existing SqlServer turns SqlServer's recording off), the generated `ModuleInitializer.cs` carries that existing call too, with a comment saying to replace the project's own; an existing plugin that plugin discovery cannot find (A1) raises an `existing-not-discovered` warning, because a project relying on `InitializePlugins()` alone never enabled it. 4. **Options** (as A8). 5. **Sponsor**: always shown, with **No change** as the first and default option, because an existing project already declares its status; a remembered declaration pre-fills it. The output has a `Directory.Build.props` fragment only when a mode is chosen, or when an added package brings another owner's fee check (A8), whose block is emitted even when Verify's is left alone. 6. **Output**: docs with "Change to make" sections (PackageVersion/PackageReference lines, ModuleInitializer merge instructions, new test files), a zip of just the new/changed files, and AI markdown that instructs an assistant to perform the merge. @@ -345,7 +345,7 @@ Identical to flow B with a **Tech stack** step inserted before "Plugins to add", `Components/Breadcrumb.razor`, a vertical list rendered in `MainLayout`'s left column (`min-width: 240px`), one row per step in the current flow: -- Completed step: step title in muted text, chosen value(s) in normal text (`Windows`, `Rider`, `xUnit v3`, `GitHub Actions`, `3 techs`, `EntityFramework, SqlServer, DiffPlex`, `Verbose ×3`, `Sponsor: acme`), clickable (navigates to that step; later steps keep their values, which is what makes the URL sharable mid-flow). +- Completed step: step title in muted text, chosen value(s) in normal text (`Windows`, `Rider`, `xUnit v3`, `GitHub Actions`, `3 techs`, `EntityFramework, SqlServer`, `Verbose ×3`, `Sponsor: acme`), clickable (navigates to that step; later steps keep their values, which is what makes the URL sharable mid-flow). - Current step: highlighted, not clickable. - Future step: muted title only, not clickable (gated by validation of the current step, as SponsorCheck's `Stepper`). - Top row: the flow name ("New project", "Add plugins", "Add by tech stack") linking to Home. @@ -380,10 +380,10 @@ Query keys (short, stable, documented in `WizardStateUrl.cs`): | `ci` | `BuildServer` name | `GitHubActions` | | `name` | solution name | `VerifySample` | | `tech` | comma list of tech ids | `efcore,sqlserver,aspnetcore` | -| `have` | comma list of existing plugin ids | `DiffPlex,Http` | -| `ext` | comma list of selected plugin ids, in registry order. Absent means the default selection, `DiffPlex`, so a link made before a plugin existed still means what it meant; the literal `none` means nothing is selected | `EntityFramework,SqlServer` | +| `have` | comma list of existing plugin ids | `SqlServer,Http` | +| `ext` | comma list of selected plugin ids, in registry order. Absent means nothing is selected. The literal `none` is still read as nothing selected, because links wrote it while a new project started with Verify.DiffPlex selected; it is no longer written. Unknown ids, DiffPlex's included, are dropped | `EntityFramework,SqlServer` | | `min` | comma list of plugin ids set to Minimal (absence = Verbose) | `SqlServer` | -| `opt` | comma list of `key:value` choices | `ef-sql-recording:keep-ef,diffplex-output:Compact` | +| `opt` | comma list of `key:value` choices | `ef-sql-recording:keep-ef,ef-sql-format:false` | | `sponsor` | mode | `Sponsor`, `Exempt`, `Private`, `Ignore` | | `account` | GitHub account | `acme` | | `start` | `yyyy-MM-dd` | `2026-09-22` | @@ -430,7 +430,7 @@ sealed record PluginDefinition( IReadOnlyList Tags, // tech ids (section 10) this plugin serves IReadOnlyList Packages, // NuGet packages to reference; may depend on TestFramework (LocalDb) or a choice (EF Core vs Classic) InitializeShape Initialize, // see below - IReadOnlyList Usings, // namespaces the generated tests need (e.g. VerifyTestsAspose, VerifyTests.DiffPlex, VerifyTests.Http) + IReadOnlyList Usings, // namespaces the generated tests need (e.g. VerifyTestsAspose, VerifyTests.Http) IReadOnlyList ProjectRequirements, // csproj properties/items: UseWPF, UseWindowsForms, FrameworkReference Microsoft.AspNetCore.App, Sdk Web, CopyToOutputDirectory fixtures, InternalsVisibleTo IReadOnlyList ExternalRequirements, // Ghostscript, Pandoc, SQL LocalDB, Cosmos emulator, RavenDB embedded, browser install, licence key + env var name, API key Platform Platform, // CrossPlatform | WindowsOnly @@ -451,7 +451,7 @@ sealed record PluginDefinition( - `None` (Terminal: a dotnet tool, not a library), - `NoOp` (Wolverine, ParametersHashing – emitted as a comment only), - `Static(call)` e.g. `VerifyHttp.Initialize()`, -- `StaticWithParameters(template, parameters)` e.g. `VerifyDiffPlex.Initialize(OutputType.{diffplex-output})`, `VerifySqlServer.Initialize(recordCommands: {bool})`, `VerifyEntityFramework.Initialize(GetDbModel(), recordCommands: {bool})` with a preamble (the `GetDbModel()` helper), +- `StaticWithParameters(template, parameters)` e.g. `VerifySqlServer.Initialize(recordCommands: {bool})`, `VerifyEntityFramework.Initialize(GetDbModel(), recordCommands: {bool})` with a preamble (the `GetDbModel()` helper), - `Custom(generator)` for three plugins: - LocalDb: `LocalDbTestBase.Initialize()` after `InitializePlugins`. - Quibble: `VerifierSettings.UseStrictJson()` before `VerifyQuibble.Initialize()`. @@ -488,7 +488,7 @@ Plugin usings go in each test file, never in global usings. The three browser na ### 9.2 Registry invariants (tests) -- Ids unique; every `Tags` entry exists in `Techs.All`; every `ExclusiveGroups` id exists in `InteractionRules.Groups`; every package id has a version in `package-versions.json`; every fixture referenced by a sample exists in `wwwroot/fixtures`; every plugin appears in at least one tech suggestion or is in the explicit `NotSuggestedByTech` list (DiffPlex, Terminal, ParametersHashing, Assertions, Quibble are universal/niche and appear under "Everything else" only). +- Ids unique; every `Tags` entry exists in `Techs.All`; every `ExclusiveGroups` id exists in `InteractionRules.Groups`; every package id has a version in `package-versions.json`; every fixture referenced by a sample exists in `wwwroot/fixtures`; every plugin appears in at least one tech suggestion or is in the explicit `NotSuggestedByTech` list (Terminal, ParametersHashing, Assertions, Quibble are universal/niche and appear under "Everything else" only). - Snapshot of the whole registry as JSON (`Registry.verified.txt`) so any change is reviewed. - `DiscoveredByInitializePlugins` matches core's naming rule (`VerifyTests.` + assembly name without dots, case-sensitive) for the shipped assembly. Every `RetiredBy` names an id from section 22. @@ -548,7 +548,7 @@ Plugin usings go in each test file, never in global usings. The three browser na | Testing | Assertion libraries inside snapshots (`assertions`) | Assertions | | | Testing | Long parameterised test names (`longnames`) | ParametersHashing | | -Universal: `DiffPlex` is always recommended; `Terminal` is recommended when CLI preference is Cli (new flow) and always listed. Windows-only plugins (LocalDb, Xaml, WinForms, Phash) are not suggested when the chosen OS is MacOS or Linux; on the plugin step they are greyed out, cannot be selected, and say why on hover, and the `windows-only` notice is gone with them. +Universal: `Terminal` is listed as related in every new project. Nothing is recommended without a tech (Verify.DiffPlex was, until Verify showed a text diff in the failure message itself). Windows-only plugins (LocalDb, Xaml, WinForms, Phash) are not suggested when the chosen OS is MacOS or Linux; on the plugin step they are greyed out, cannot be selected, and say why on hover, and the `windows-only` notice is gone with them. The tech step renders groups as headed chip sets; the plugin step shows "Suggested for your stack" first (recommended checked, related unchecked but listed with a "related" tag), then "Everything else" grouped by `PluginCategory`. @@ -607,7 +607,6 @@ ImageMagick appears in two groups. | `rendering-needs-comparer` | any of Avalonia, WinForms, Xaml, Playwright, Puppeteer, Selenium, DocNet, PDFium, QuestPDF, Aspose, Syncfusion, OpenXml, ImageMagick, ImageSharp without an `image-comparer` choice (not EmailPreviewServices: its snapshots are `webp`, so `UseSsimForPng` has no effect) | Info | default to `VerifierSettings.UseSsimForPng(threshold)` with per-plugin recommended threshold (DocNet 0.95, SponsorCheck-style 0.7 for browser screenshots, default 0.98) and a comment | | `recording-bus` | two or more of EntityFramework, SqlServer, Http, Diagnostics, OpenTelemetry, MicrosoftLogging, Serilog, ZeroLog, NServiceBus | Info | explain that all land in the same snapshot keyed `ef`/`sql`/`httpCall`/`activity`/`log`, and show `Recording.IgnoreNames(...)`. Serilog, ZeroLog and MicrosoftLogging all use `log`, so `IgnoreNames` cannot separate them. The logging plugins call `Recording.Add`, which throws outside a recording, so samples call `Recording.Start()` before anything logs and the guide warns about logging during host startup (retired by U13) | | `logger-takeover` | Serilog, ZeroLog | Warning | `Initialize` replaces the global logger; let the plugin own it. For ZeroLog, an existing configuration only works with `AppendingStrategy.Synchronous`: the default asynchronous appender loses the recording context and captures nothing (retired by U11, U18) | -| `diffplex-default-comparer` | DiffPlex with AngleSharp, Bunit, Quibble, ImageMagick | Info | DiffPlex is the default string comparer; plugin-specific comparers for html/json/svg take precedence, except that a per-test `UseDiffPlex()` overrides them for that test | | `readable-expressions-priority` | ReadableExpressions + EntityFramework | Info | converter inserted at index 0; expression trees inside EF snapshots render as C# | | `plugin-not-discovered` | AngleSharp, QuestPDF or Blazor listed as existing (Add flows) | Warning | `InitializePlugins()` never initialized these (1.3); the Add output tells users to add the explicit call even though the package is already referenced (retired by C2, U1, U2) | | `settings-method-ambiguity` | two or more of DocNet, PdfPig, QuestPDF, Syncfusion, PDFium, Aspose | Info | each defines `PagesToInclude(int)` and/or `SkipPdfNormalization()` as extension methods (Aspose in `VerifyTestsAspose`, the rest in `VerifyTests`), so the fluent call is a CS0121 compile error even without a runtime conflict (QuestPDF + PdfPig is a suggested pair); samples use the static form, e.g. `PdfPigSettings.PagesToInclude(settings, 2)`, with a comment (retired by C4) | @@ -681,7 +680,7 @@ Every generated code file starts with a comment banner: generated by the Verify Section order mirrors today's terminal page, then adds plugin sections. All the static texts come from Appendix A. Headings use third-person phrasing (Verify's `mdsnippets` content validation forbids "you"; keep the same voice for consistency). 1. Title + "Generated by the Verify wizard" + the choices as a bullet list + the wizard link. -2. **Add NuGet packages** – CLI: `dotnet add package …` lines (test framework + Verify adapter + each plugin package + Verify.DiffPlex); GUI: a `Directory.Packages.props` + `PackageReference` block. Both variants mention CPM. +2. **Add NuGet packages** – CLI: `dotnet add package …` lines (test framework + Verify adapter + each plugin package); GUI: a `Directory.Packages.props` + `PackageReference` block. Both variants mention CPM. 3. **Microsoft.Testing.Platform** (not for Fixie) + test project settings per framework (`OutputType Exe`, `EnableNUnitRunner`, `EnableMSTestRunner`, `EnableExpectoTestingPlatformIntegration`) + `global.json` runner. 4. **Implicit usings**. 5. **Conventions**: source control includes/excludes, text file settings, EditorConfig, conventions check. @@ -704,7 +703,7 @@ Template (C#; Expecto gets an F# equivalent in `main`): ```cs // Generated by the Verify wizard: // Everything in this file runs once when the test assembly loads. Delete what is not needed. -using VerifyTests.DiffPlex; // only the usings the selected plugins need +using VerifyTests.Http; // only the usings the selected plugins need public static class ModuleInitializer { @@ -712,10 +711,6 @@ public static class ModuleInitializer public static void Initialize() { // ---- comparers (must be registered before converters that emit images) ---- - // Verify.DiffPlex: shows an inline diff of text snapshots in the failure message instead of the full received and verified text. - // OutputType.Compact prints only changed lines with one line of context. Alternatives: Full, Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Verify's built in SSIM comparer for png. Rendering differs slightly between operating systems and font stacks; // 0.95 tolerates that while still failing on real layout changes. Remove if png snapshots must be byte exact. VerifierSettings.UseSsimForPng(0.95); @@ -753,7 +748,7 @@ public static class ModuleInitializer } ``` -Rules: every call has a comment; comments quote the readme where the catalogue has a quote; parameters come from `Choices`; verbose depth adds commented-out alternatives (`// VerifyDiffPlex.Initialize(OutputType.Full);`). Licence keys are read from environment variables with a throw-if-missing message copied from the plugin's own tests. For MSTest add `[assembly: UsesVerify]` in a separate `AssemblyInfo.cs`. For Fixie the `TestProject` convention file is emitted (Appendix C). Plugin usings are per test file (9.1). When `settings-method-ambiguity` applies, the affected calls use the static form. +Rules: every call has a comment; comments quote the readme where the catalogue has a quote; parameters come from `Choices`; verbose depth adds commented-out alternatives (`// VerifierSettings.Inline(maxLines: 30);`). Licence keys are read from environment variables with a throw-if-missing message copied from the plugin's own tests. For MSTest add `[assembly: UsesVerify]` in a separate `AssemblyInfo.cs`. For Fixie the `TestProject` convention file is emitted (Appendix C). Plugin usings are per test file (9.1). When `settings-method-ambiguity` applies, the affected calls use the static form. ### 12.5 Zip layout – Add flows @@ -881,7 +876,7 @@ As built (phase 4): the output appears straight away with the baked versions and ### 17.1 Generator snapshot tests (fast, always run) -For a matrix of `WizardState`s (each test framework with core only; each framework with DiffPlex + Http; the EF + SqlServer + LocalDb combination with each `ef-sql-recording` choice; every plugin alone at Minimal and at Verbose; the "everything cross-platform and licence-free" set; the Windows set; each sponsor mode; each build server; Add flow with existing DiffPlex + adding EF; Add flow with existing SqlServer + adding EF), verify: the guide markdown, the AI markdown, the `ModuleInitializer.cs`, the csproj files, `Directory.Packages.props`, the file list of the zip. Use `VerifierSettings.UseStrictJson` off (default), `Verify.DiffPlex`, and `UniqueForRuntime` is not needed. Freeze `today` via an injected `DateOnly`. +For a matrix of `WizardState`s (each test framework with core only; each framework with Http; the EF + SqlServer + LocalDb combination with each `ef-sql-recording` choice; every plugin alone at Minimal and at Verbose; the "everything cross-platform and licence-free" set; the Windows set; each sponsor mode; each build server; Add flow with existing SqlServer + adding EF; Add flow with existing SqlServer + adding EF), verify: the guide markdown, the AI markdown, the `ModuleInitializer.cs`, the csproj files, `Directory.Packages.props`, the file list of the zip. Use `VerifierSettings.UseStrictJson` off (default), `Verify.DiffPlex`, and `UniqueForRuntime` is not needed. Freeze `today` via an injected `DateOnly`. ### 17.2 Registry tests @@ -893,7 +888,7 @@ bunit: each step component (validation gates Next; choices bind), `Breadcrumb` ( ### 17.4 Integration: the zip compiles and the tests run (opt-in, CI) -`Integration/GeneratedSolutionTests.cs`, marked `[Explicit]` and run by `integration.yml` (`--treenode-filter`): for a curated set of states, generate the solution, extract to a temp directory, run `dotnet build` and then the framework's test command with `DiffEngine_Disabled=true`, and assert the build succeeds and the only failures are Verify "New" snapshot failures (the core sample passes because its verified file is shipped). Matrix: ubuntu for the cross-platform set (every framework; plugins: DiffPlex, Http, AspNetCore, SystemJson, NewtonsoftJson, Yaml, NodaTime, Ulid, MailMessage, SendGrid, CsvHelper, Sep, ClosedXml, OpenXml, PdfPig, PDFium, QuestPDF, ImageSharp, ImageHash, AngleSharp, Bunit, Blazor, Moq, NSubstitute, FakeItEasy, Mockly, MassTransit, NServiceBus, Wolverine, Brighter, MicrosoftLogging, Serilog, ZeroLog, OpenTelemetry, Diagnostics, SourceGenerators, ICSharpCodeDecompiler, ReadableExpressions, ParametersHashing, Assertions, Quibble, Flurl, Playwright with browser install); windows for the Windows set (WinForms, Xaml, Phash, LocalDb + EntityFramework + SqlServer with SqlLocalDB available on `windows-latest`). Excluded from CI: Aspose, Syncfusion, EmailPreviewServices (licences), Cosmos (emulator), RavenDB (server download; try it, drop if flaky), ImageMagick pdf (Ghostscript install is possible via choco on Windows: include), Pandoc (choco/apt install is possible: include), Avalonia (needs a display? Avalonia headless works without one: include). This test is the guarantee behind "working bits" and behind the weekly version bump. Per plugin the assertion is that `dotnet build` succeeds: the samples are copied from readmes, which drift, and only the compiler notices. Running them is not asserted per plugin, because most need a database, a browser or a licence; the core solution, which ships its one verified file, is what asserts a passing run. The combination cases (A16) assert the build too, because that is where a wrong ordering or a method two packages both define shows up. These combinations run in addition to the per-plugin set: +`Integration/GeneratedSolutionTests.cs`, marked `[Explicit]` and run by `integration.yml` (`--treenode-filter`): for a curated set of states, generate the solution, extract to a temp directory, run `dotnet build` and then the framework's test command with `DiffEngine_Disabled=true`, and assert the build succeeds and the only failures are Verify "New" snapshot failures (the core sample passes because its verified file is shipped). Matrix: ubuntu for the cross-platform set (every framework; plugins: Http, AspNetCore, SystemJson, NewtonsoftJson, Yaml, NodaTime, Ulid, MailMessage, SendGrid, CsvHelper, Sep, ClosedXml, OpenXml, PdfPig, PDFium, QuestPDF, ImageSharp, ImageHash, AngleSharp, Bunit, Blazor, Moq, NSubstitute, FakeItEasy, Mockly, MassTransit, NServiceBus, Wolverine, Brighter, MicrosoftLogging, Serilog, ZeroLog, OpenTelemetry, Diagnostics, SourceGenerators, ICSharpCodeDecompiler, ReadableExpressions, ParametersHashing, Assertions, Quibble, Flurl, Playwright with browser install); windows for the Windows set (WinForms, Xaml, Phash, LocalDb + EntityFramework + SqlServer with SqlLocalDB available on `windows-latest`). Excluded from CI: Aspose, Syncfusion, EmailPreviewServices (licences), Cosmos (emulator), RavenDB (server download; try it, drop if flaky), ImageMagick pdf (Ghostscript install is possible via choco on Windows: include), Pandoc (choco/apt install is possible: include), Avalonia (needs a display? Avalonia headless works without one: include). This test is the guarantee behind "working bits" and behind the weekly version bump. Per plugin the assertion is that `dotnet build` succeeds: the samples are copied from readmes, which drift, and only the compiler notices. Running them is not asserted per plugin, because most need a database, a browser or a licence; the core solution, which ships its one verified file, is what asserts a passing run. The combination cases (A16) assert the build too, because that is where a wrong ordering or a method two packages both define shows up. These combinations run in addition to the per-plugin set: - Blazor with the core sample in one project, with the order forced so `Sample` runs first (Blazor's `Custom` shape, 9.1). - QuestPDF + PdfPig with verbose samples (`settings-method-ambiguity`). - Pandoc with `Papyrine_*` properties (14). @@ -1189,7 +1184,6 @@ Summary of every selectable plugin. Versions are the repo `Directory.Build.props | Cosmos | Verify.Cosmos | 3.0.0 | `VerifyCosmos.Initialize()` | Data | needs Cosmos emulator; tests skipped by default | A | | CsvHelper | Verify.CsvHelper | 0.2.0 | `VerifyCsvHelper.Initialize()` | Data; csv-scrubber group | `IgnoreCsvColumns`, `ScrubCsvColumns`, `TranslateCsvColumn(s)` | A | | Diagnostics | Verify.Diagnostics | 1.0.0 | `VerifyDiagnostics.Initialize()` | Observability; activity-listener group | `Recording.Start()`; readme's `RecordingActivityListener` does not exist | A | -| DiffPlex | Verify.DiffPlex | 3.3.1 | `VerifyDiffPlex.Initialize(OutputType)` | DeveloperExperience | always suggested; `using VerifyTests.DiffPlex` | A | | DocNet | Verify.DocNet | 3.6.0 | `VerifyDocNet.Initialize()` | Documents; pdf group | native pdfium; `UseSsimForPng(0.95)`; `PagesToInclude`, `SinglePage`, `PageDimensions`, `PreserveTransparency` | A | | EmailPreviewServices | Verify.EmailPreviewServices | 1.0.0 | `VerifyEmailPreviewServices.Initialize(apiKey?)` | Email | paid API key (`EmailPreviewServicesApiKey`); slow; tests explicit; snapshots are webp | A | | EntityFramework | Verify.EntityFramework (+ Microsoft.EntityFrameworkCore.SqlServer for the sample) | 15.4.1 | `VerifyEntityFramework.Initialize(model, recordCommands)` | Data | `EnableRecording()`, `Recording.Start()`, ChangeTracker, queryable → `.sql`, `IgnoreNavigationProperties`, descriptive aliases/parameters, `ReplayRecentMigrations`; EF+SqlServer rule | A | diff --git a/src/Directory.Packages.props b/src/Directory.Packages.props index 83e8ed2..d9d3fc1 100644 --- a/src/Directory.Packages.props +++ b/src/Directory.Packages.props @@ -9,14 +9,13 @@ - - - + + - + \ No newline at end of file diff --git a/src/Wizard.Core/Generation/PluginTestFiles.cs b/src/Wizard.Core/Generation/PluginTestFiles.cs index 7f3467c..0d4ad3a 100644 --- a/src/Wizard.Core/Generation/PluginTestFiles.cs +++ b/src/Wizard.Core/Generation/PluginTestFiles.cs @@ -6,29 +6,14 @@ /// public static class PluginTestFiles { - public static IEnumerable For(Plan plan, bool windows) - { - foreach (var plugin in plan.PluginsIn(windows).Where(_ => _.Samples.Count > 0)) - { - yield return new($"Plugins/{plugin.TestClass}.cs", Build(plan, plugin)); - - // With inline snapshots a known snapshot is a literal in the sample instead. - if (plan.Inline) - { - continue; - } - - // A sample whose snapshot is known ships it, so it passes on the first run. Verified text - // files are UTF-8 with a BOM and no trailing newline. - foreach (var sample in plugin.Samples.Where(_ => _.VerifiedOutput != null)) - { - yield return new( - $"Plugins/{plugin.TestClass}.{sample.Name}.verified.txt", - sample.VerifiedOutput!, - Bom: true); - } - } - } + /// + /// No plugin sample ships a verified file (plan D6): what a plugin writes depends on its version + /// and the machine, so each writes a received file on its first run instead. + /// + public static IEnumerable For(Plan plan, bool windows) => + plan.PluginsIn(windows) + .Where(_ => _.Samples.Count > 0) + .Select(_ => new GeneratedFile($"Plugins/{_.TestClass}.cs", Build(plan, _))); static string Build(Plan plan, ResolvedPlugin plugin) { @@ -73,7 +58,7 @@ static string Build(Plan plan, ResolvedPlugin plugin) } first = false; - AppendSample(builder, framework, sample, plan.Inline); + AppendSample(builder, framework, sample); } foreach (var member in plugin.Samples.SelectMany(_ => _.Members)) @@ -86,7 +71,7 @@ static string Build(Plan plan, ResolvedPlugin plugin) return builder.ToString(); } - static void AppendSample(StringBuilder builder, TestFrameworkInfo framework, Sample sample, bool inline) + static void AppendSample(StringBuilder builder, TestFrameworkInfo framework, Sample sample) { foreach (var line in sample.Comment) { @@ -124,14 +109,7 @@ static void AppendSample(StringBuilder builder, TestFrameworkInfo framework, Sam var signature = sample.Async ? "async Task" : "Task"; builder.Append($" {visibility} {signature} {sample.Name}()\n {{\n"); - var body = sample.Body; - if (inline && - sample.VerifiedOutput is { } verified) - { - body = InlineSnapshots.AddSnapshot(body, verified); - } - - builder.Append(ModuleInitializerGenerator.Indent(body, " ")); + builder.Append(ModuleInitializerGenerator.Indent(sample.Body, " ")); builder.Append(" }\n"); } diff --git a/src/Wizard.Core/Generation/TestFrameworkInfo.cs b/src/Wizard.Core/Generation/TestFrameworkInfo.cs index c95087d..f6762c1 100644 --- a/src/Wizard.Core/Generation/TestFrameworkInfo.cs +++ b/src/Wizard.Core/Generation/TestFrameworkInfo.cs @@ -3,7 +3,7 @@ /// Verify's usages/*NugetUsage projects; sample and VerifyChecks code match the snippets in the Verify /// repo, which the old docs/wiz pages rendered. /// -/// Test project packages, in the order the Verify docs list them. Verify.DiffPlex is added separately. +/// Test project packages, in the order the Verify docs list them. /// Test project properties that switch on Microsoft.Testing.Platform. /// False for Fixie, which has no MTP runner and keeps VSTest (plan D10). /// The name of the core sample's snapshot, which is shipped (plan D6). diff --git a/src/Wizard.Core/Model/WizardState.cs b/src/Wizard.Core/Model/WizardState.cs index d14884e..692620c 100644 --- a/src/Wizard.Core/Model/WizardState.cs +++ b/src/Wizard.Core/Model/WizardState.cs @@ -24,23 +24,11 @@ public sealed record WizardState /// so the url and the generated output do not depend on insertion order. Collections are replaced /// rather than mutated, so with { } copies do not share them. /// - public IReadOnlySet SelectedPlugins { get; set; } = new HashSet(DefaultPlugins(Flow.New), StringComparer.Ordinal); - - /// - /// In a new project Verify.DiffPlex is selected until it is deselected: an inline diff on a failed - /// text snapshot helps in any project, and the wizard has recommended it unconditionally since the - /// old pages. Adding to an existing project starts from nothing, because the project already has - /// whatever it had. - /// - public static IReadOnlyList DefaultPlugins(Flow flow) - { - if (flow == Flow.New) - { - return [Plugins.DiffPlexId]; - } - - return []; - } + /// + /// Starts empty in every flow. A new project used to start with Verify.DiffPlex selected, until + /// Verify showed a text diff in the failure message itself. + /// + public IReadOnlySet SelectedPlugins { get; set; } = new HashSet(StringComparer.Ordinal); /// /// Plugins the project already has (plan 7.2 step 2). They are never generated, but they take diff --git a/src/Wizard.Core/Model/WizardStateUrl.cs b/src/Wizard.Core/Model/WizardStateUrl.cs index c6fe3a3..526854a 100644 --- a/src/Wizard.Core/Model/WizardStateUrl.cs +++ b/src/Wizard.Core/Model/WizardStateUrl.cs @@ -19,7 +19,10 @@ public static class WizardStateUrl public const string ExistingKey = "have"; public const string InlineKey = "inline"; - /// The value meaning "nothing at all", as opposed to "unset". + /// + /// The value older links used for "nothing at all", when an absent key + /// meant a default selection. Only read now: an absent key means nothing. + /// public const string NoPlugins = "none"; public const string SponsorKey = "sponsor"; @@ -85,11 +88,7 @@ void Add(string key, string? value) .Where(_ => state.Has(_.Id)) .Select(_ => _.Id) .ToList(); - if (!selected.SequenceEqual(WizardState.DefaultPlugins(state.Flow), StringComparer.Ordinal)) - { - // A link that selects nothing still has to say so, or it would read as the default. - Add(PluginsKey, selected.Count == 0 ? NoPlugins : string.Join(',', selected)); - } + Add(PluginsKey, string.Join(',', selected)); Add(MinimalKey, string.Join(',', selected.Where(_ => state.DepthOf(_) == Depth.Minimal))); Add(ChoicesKey, string.Join(',', state.Choices.OrderBy(_ => _.Key, StringComparer.Ordinal).Select(_ => $"{_.Key}:{_.Value}"))); @@ -161,7 +160,7 @@ public static WizardState Parse(Flow flow, string? query) BuildServer = ParseEnum(Get(BuildServerKey)), SolutionName = Get(NameKey) ?? WizardState.DefaultSolutionName, InlineSnapshots = Get(InlineKey) == "true", - SelectedPlugins = ParsePlugins(flow, Get(PluginsKey)), + SelectedPlugins = ParsePlugins(Get(PluginsKey)), ExistingPlugins = new HashSet(SplitList(Get(ExistingKey)), StringComparer.Ordinal), Techs = new HashSet(SplitList(Get(TechKey)), StringComparer.Ordinal), Choices = ParseChoices(Get(ChoicesKey)), @@ -227,17 +226,14 @@ static string Escape(string value) => .Replace("%3A", ":"); /// - /// An absent key means the default selection, so a link made before a plugin existed still - /// means what it meant. is how "nothing selected" is written. + /// An absent key means nothing is selected. is still read, because it is + /// how links wrote "nothing selected" while a new project started with Verify.DiffPlex selected, + /// and one of those links should still mean what it meant. /// - static HashSet ParsePlugins(Flow flow, string? value) + static HashSet ParsePlugins(string? value) { - if (value == null) - { - return [with(StringComparer.Ordinal), .. WizardState.DefaultPlugins(flow)]; - } - - if (value == NoPlugins) + if (value == null || + value == NoPlugins) { return [with(StringComparer.Ordinal)]; } diff --git a/src/Wizard.Core/Registry/InteractionRules.Data.cs b/src/Wizard.Core/Registry/InteractionRules.Data.cs index 41e10c8..fd2cb9b 100644 --- a/src/Wizard.Core/Registry/InteractionRules.Data.cs +++ b/src/Wizard.Core/Registry/InteractionRules.Data.cs @@ -292,17 +292,6 @@ public static partial class InteractionRules RetiredBy = "U25" }, new() - { - Id = "diffplex-default-comparer", - Severity = Severity.Info, - All = ["DiffPlex"], - Any = ["AngleSharp", "Bunit", "ImageMagick", "Quibble"], - Message = - "Verify.DiffPlex is the default comparer for text snapshots. The plugins selected here " + - "register comparers for specific plugins (html, json, svg), which take precedence over it.", - Notes = ["A per test `UseDiffPlex()` overrides those comparers again, for that test only."] - }, - new() { Id = "readable-expressions-priority", Severity = Severity.Info, diff --git a/src/Wizard.Core/Registry/PluginDefinition.cs b/src/Wizard.Core/Registry/PluginDefinition.cs index 194b956..524d7a2 100644 --- a/src/Wizard.Core/Registry/PluginDefinition.cs +++ b/src/Wizard.Core/Registry/PluginDefinition.cs @@ -308,13 +308,6 @@ public sealed record Sample(string Name, string Body) /// Extra members the body needs, emitted after the method. public IReadOnlyList Members { get; init; } = []; - - /// - /// The snapshot this sample produces, when it is known exactly and does not depend on the package - /// version or the machine. Shipping it means the sample passes on the first run instead of writing - /// a received file; most samples cannot (plan D6), and the guide explains what to do with those. - /// - public string? VerifiedOutput { get; init; } } /// Relative to the project the file belongs to. diff --git a/src/Wizard.Core/Registry/Plugins.A.cs b/src/Wizard.Core/Registry/Plugins.A.cs index 4d54504..a2fdb33 100644 --- a/src/Wizard.Core/Registry/Plugins.A.cs +++ b/src/Wizard.Core/Registry/Plugins.A.cs @@ -1270,66 +1270,6 @@ static string BuildCsv() => ] }, new() - { - Id = "DiffPlex", - DisplayName = "Verify.DiffPlex", - RepoUrl = "https://github.com/VerifyTests/Verify.DiffPlex", - Description = "Shows an inline diff in the failure message of a text snapshot, instead of both files in full.", - Category = PluginCategory.DeveloperExperience, - Packages = [new("Verify.DiffPlex")], - PluginType = "VerifyDiffPlex", - Phase = InitializePhase.Comparers, - Initialize = - [ - new( - "VerifyDiffPlex.Initialize(OutputType.{diffplex-output});", - "Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline", - "diff instead of the whole received and verified text.", - "OutputType.Compact prints only the changed lines, with a line of context either side.", - "Alternatives: OutputType.Full, OutputType.Minimal.") - ], - InitializeUsings = ["VerifyTests.DiffPlex"], - Usings = ["VerifyTests.DiffPlex"], - Choices = - [ - new( - "diffplex-output", - "Failure message detail", - "How much of the text a failed comparison prints.", - [ - new("Compact", "Compact", "Only changed lines, with one line of context and its line number."), - new("Full", "Full", "The whole received text, with + and - markers on the changed lines."), - new("Minimal", "Minimal", "Only the changed lines.") - ]) - ], - MinimalSamples = - [ - new( - "PerTestOutput", - """ - var target = "The text"; - return Verify(target) - .UseDiffPlex(OutputType.Full); - """) - { - Comment = - [ - "The module initializer sets the mode for every test. UseDiffPlex overrides it for one,", - "which is useful when a single snapshot is easier to read in full." - ], - // Verifying a string writes it verbatim, so the snapshot is known and can ship. - // Verify.DiffPlex is selected by default, and a download whose first test run fails - // is a poor way to meet a tool. - VerifiedOutput = "The text" - } - ], - Notes = - [ - "This changes only the failure message; what is written to a `.verified.` file is unaffected.", - "It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension." - ] - }, - new() { Id = "DocNet", DisplayName = "Verify.DocNet", diff --git a/src/Wizard.Core/Registry/Plugins.C.cs b/src/Wizard.Core/Registry/Plugins.C.cs index f6cd481..6ea6bb1 100644 --- a/src/Wizard.Core/Registry/Plugins.C.cs +++ b/src/Wizard.Core/Registry/Plugins.C.cs @@ -1116,7 +1116,7 @@ static IDocument GenerateDocument() => [ "`VerifierSettings.UseStrictJson()` is mandatory and has to run first. `Initialize()` sets `Initialized` before it throws about strict json, so a failed call cannot be retried.", "Strict json changes every snapshot in the project from Verify's relaxed format to real json, so it is not a drop in for an existing suite.", - "It registers a string comparer for `json`, so it takes precedence over Verify.DiffPlex for json snapshots. A per test `UseDiffPlex()` overrides it again.", + "It registers a string comparer for `json`, so a mismatched json snapshot shows Quibble's message rather than Verify's text diff.", "An empty verified file is treated as `{}`.", "Quibble is an F# library, so `FSharp.Core` arrives transitively.", "There are no settings methods or per test toggles: the only configuration is the `UseStrictJson()` call." diff --git a/src/Wizard.Core/Registry/Plugins.cs b/src/Wizard.Core/Registry/Plugins.cs index 9e0ea5b..8751328 100644 --- a/src/Wizard.Core/Registry/Plugins.cs +++ b/src/Wizard.Core/Registry/Plugins.cs @@ -18,12 +18,6 @@ static IEnumerable Build() => public static bool Contains(string id) => ById.ContainsKey(id); - /// - /// Always pre-checked: an inline diff on a failed text snapshot is useful in every project, and the - /// old wizard's pages recommended it unconditionally. - /// - public const string DiffPlexId = "DiffPlex"; - /// The selected plugins in registry order, ignoring ids the registry does not have. public static IReadOnlyList Selected(WizardState state) => [.. All.Where(_ => state.Has(_.Id))]; diff --git a/src/Wizard.Core/Registry/TechSuggestions.cs b/src/Wizard.Core/Registry/TechSuggestions.cs index a588deb..ddca7ae 100644 --- a/src/Wizard.Core/Registry/TechSuggestions.cs +++ b/src/Wizard.Core/Registry/TechSuggestions.cs @@ -8,7 +8,7 @@ public static class TechSuggestions /// /// The plugins the stack suggests, in registry order. A Windows-only plugin is left out when /// the chosen OS is not Windows, since it cannot be selected there. - /// Verify.DiffPlex is recommended in every new project, and Verify.Terminal is listed alongside it. + /// Verify.Terminal is listed as related in every new project. /// public static IReadOnlyList For(WizardState state) { @@ -40,7 +40,6 @@ static void Note(Dictionary> into, string pluginId, string if (state.Flow == Flow.New) { - Note(recommended, Plugins.DiffPlexId, "every project"); Note(related, "Terminal", "every project"); } diff --git a/src/Wizard.Core/Registry/Techs.cs b/src/Wizard.Core/Registry/Techs.cs index ee40ba4..3be650d 100644 --- a/src/Wizard.Core/Registry/Techs.cs +++ b/src/Wizard.Core/Registry/Techs.cs @@ -92,5 +92,5 @@ public static bool Contains(string id) => /// Plugins no tech suggests: they are useful whatever the stack, so they are listed under /// "Everything else" rather than tied to one (plan 9.2). /// - public static IReadOnlyList NotSuggestedByTech { get; } = [Plugins.DiffPlexId, "Terminal"]; + public static IReadOnlyList NotSuggestedByTech { get; } = ["Terminal"]; } diff --git a/src/Wizard.Core/Versions/package-versions.json b/src/Wizard.Core/Versions/package-versions.json index 7b66ec3..4547f50 100644 --- a/src/Wizard.Core/Versions/package-versions.json +++ b/src/Wizard.Core/Versions/package-versions.json @@ -51,7 +51,7 @@ "Serilog": "4.4.0", "System.Drawing.Common": "10.0.12", "TUnit": "1.69.0", - "Verify": "33.1.1", + "Verify": "33.2.0", "Verify.AngleSharp": "5.1.2", "Verify.AspNetCore": "5.0.0", "Verify.Aspose": "5.28.0", @@ -65,14 +65,13 @@ "Verify.Cosmos": "3.0.0", "Verify.CsvHelper": "0.2.0", "Verify.Diagnostics": "1.0.0", - "Verify.DiffPlex": "3.3.1", "Verify.DocNet": "3.6.0", "Verify.EmailPreviewServices": "1.0.0", "Verify.EntityFramework": "15.5.0", "Verify.EntityFrameworkClassic": "15.5.0", - "Verify.Expecto": "33.1.1", + "Verify.Expecto": "33.2.0", "Verify.FakeItEasy": "2.1.0", - "Verify.Fixie": "33.1.1", + "Verify.Fixie": "33.2.0", "Verify.Flurl": "2.0.0", "Verify.Http": "7.5.1", "Verify.ICSharpCode.Decompiler": "3.4.1", @@ -85,13 +84,13 @@ "Verify.MicrosoftLogging": "5.0.0", "Verify.Mockly": "1.0.1", "Verify.Moq": "2.2.0", - "Verify.MSTest": "33.1.1", + "Verify.MSTest": "33.2.0", "Verify.NewtonsoftJson": "1.1.0", "Verify.NodaTime": "2.3.0", "Verify.NServiceBus": "12.2.0", "Verify.NSubstitute": "2.1.0", "Verify.NUlid": "1.0.1", - "Verify.NUnit": "33.1.1", + "Verify.NUnit": "33.2.0", "Verify.OpenTelemetry": "1.0.0", "Verify.OpenXml": "1.27.0", "Verify.Pandoc": "0.1.1", @@ -115,12 +114,12 @@ "Verify.Syncfusion": "2.7.4", "Verify.SystemJson": "1.4.1", "verify.tool": "0.9.1", - "Verify.TUnit": "33.1.1", + "Verify.TUnit": "33.2.0", "Verify.Ulid": "1.0.1", "Verify.WinForms": "6.0.0", "Verify.Wolverine": "3.2.0", "Verify.Xaml": "5.0.0", - "Verify.XunitV3": "33.1.1", + "Verify.XunitV3": "33.2.0", "Verify.Yaml": "0.1.0", "Verify.ZeroLog": "2.0.0", "WolverineFx": "6.39.1", diff --git a/src/Wizard.Tests/EndToEndTests.cs b/src/Wizard.Tests/EndToEndTests.cs index 9228acd..6d5e0a0 100644 --- a/src/Wizard.Tests/EndToEndTests.cs +++ b/src/Wizard.Tests/EndToEndTests.cs @@ -15,13 +15,13 @@ public async Task NewFlowToZipDownload() await page.ClickAsync("button.primary"); } - // The tech stack is optional, the plugin step starts on the default selection, and the - // options step on the defaults, so all three are passed by moving on. + // The tech stack and the plugins are optional, and the options step starts on the defaults, + // so all three are passed by moving on. await page.WaitForSelectorAsync(".tech-group"); await page.ClickAsync("button.primary"); - await page.WaitForSelectorAsync(".plugin-card[data-id=DiffPlex]"); + await page.WaitForSelectorAsync(".plugin-card[data-id=AngleSharp]"); await page.ClickAsync("button.primary"); - await page.WaitForSelectorAsync(".depth-row[data-id=DiffPlex]"); + await page.WaitForSelectorAsync(".choice[data-choice=inline]"); await page.ClickAsync("button.primary"); await page.ClickAsync("#sponsor-Exempt"); @@ -57,7 +57,7 @@ public async Task SharedLinkOpensTheSameState() await Assert.That(second.Url).IsEqualTo(first.Url); await Assert.That(await second.InputValueAsync("#solutionName")).IsEqualTo("Acme"); var values = await second.Locator(".breadcrumb .step-value").AllTextContentsAsync(); - await Assert.That(string.Join(" | ", values)).IsEqualTo("MacOS | JetBrains Rider | Prefer CLI | Expecto | No build server | None | DiffPlex | Defaults | Private arrangement"); + await Assert.That(string.Join(" | ", values)).IsEqualTo("MacOS | JetBrains Rider | Prefer CLI | Expecto | No build server | None | None | Defaults | Private arrangement"); } /// @@ -84,15 +84,15 @@ public async Task ConflictingPluginsBlockTheStep() public async Task OptionsAreCarriedInTheUrl() { var page = await ScreenSnapshotTests.Open( - "/new?step=options&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=None&ext=DiffPlex", - ".depth-row[data-id=DiffPlex]"); + "/new?step=options&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=None&ext=EntityFramework", + ".depth-row[data-id=EntityFramework]"); - await page.ClickAsync(".depth-row[data-id=DiffPlex] .depth-option:text-is('Minimal')"); - await page.ClickAsync(".choice[data-choice=diffplex-output] label:has-text('Full') input"); + await page.ClickAsync(".depth-row[data-id=EntityFramework] .depth-option:text-is('Minimal')"); + await page.ClickAsync(".choice[data-choice=ef-sql-format] label:has-text('Write it verbatim') input"); // The wizard replaces the history entry rather than navigating, so there is no load to wait for. await page.WaitForFunctionAsync( - "() => location.search.includes('min=DiffPlex') && location.search.includes('opt=diffplex-output:Full')"); + "() => location.search.includes('min=EntityFramework') && location.search.includes('opt=ef-sql-format:false')"); } /// @@ -189,12 +189,12 @@ public async Task BackAndForwardMoveBetweenSteps() [Test] public async Task NextStartsTheNextStepAtTheTop() { - var page = await ScreenSnapshotTests.Open("/new?step=plugins&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions", ".plugin-card[data-id=DiffPlex]"); + var page = await ScreenSnapshotTests.Open("/new?step=plugins&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions", ".plugin-card[data-id=AngleSharp]"); await page.EvaluateAsync("() => window.scrollTo(0, document.body.scrollHeight)"); await Assert.That(await page.EvaluateAsync("() => window.scrollY")).IsGreaterThan(0); await page.ClickAsync("button.primary"); - await page.WaitForSelectorAsync(".depth-row[data-id=DiffPlex]"); + await page.WaitForSelectorAsync(".choice[data-choice=inline]"); await page.WaitForFunctionAsync("() => window.scrollY === 0"); } } diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Addition_name=ByTech.verified.txt b/src/Wizard.Tests/Generation/GeneratorTests.Addition_name=ByTech.verified.txt index fc00f0d..1519c63 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Addition_name=ByTech.verified.txt +++ b/src/Wizard.Tests/Generation/GeneratorTests.Addition_name=ByTech.verified.txt @@ -6,11 +6,11 @@ # Adding Verify plugins -Generated by the [Verify wizard](https://verifytests.github.io/Wizard/add/by-tech?step=output&tf=XunitV3&tech=aspnetcore&have=DiffPlex&ext=AspNetCore,Http) (reopen that link to change any answer). +Generated by the [Verify wizard](https://verifytests.github.io/Wizard/add/by-tech?step=output&tf=XunitV3&tech=aspnetcore&ext=AspNetCore,Http) (reopen that link to change any answer). * Test framework: xUnit v3 * Adding: AspNetCore (verbose), Http (verbose) - * Already in the project: DiffPlex + * Already in the project: none listed * Maintenance fee: No change * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -280,7 +280,7 @@ Set the environment variable `DiffEngine_Disabled=true` when running tests where # Adding Verify plugins: instructions for AI coding assistants -Generated by the [Verify wizard](https://verifytests.github.io/Wizard/add/by-tech?step=output&tf=XunitV3&tech=aspnetcore&have=DiffPlex&ext=AspNetCore,Http). The files next to this one are changes to merge into a project that already uses Verify snapshot testing with xUnit v3. Carry out the steps below in order. +Generated by the [Verify wizard](https://verifytests.github.io/Wizard/add/by-tech?step=output&tf=XunitV3&tech=aspnetcore&ext=AspNetCore,Http). The files next to this one are changes to merge into a project that already uses Verify snapshot testing with xUnit v3. Carry out the steps below in order. ## Steps @@ -434,7 +434,7 @@ await ThrowsTask(() => MethodThatThrows()) ==== ModuleInitializer.cs -// Generated by the Verify wizard: https://verifytests.github.io/Wizard/add/by-tech?step=output&tf=XunitV3&tech=aspnetcore&have=DiffPlex&ext=AspNetCore,Http +// Generated by the Verify wizard: https://verifytests.github.io/Wizard/add/by-tech?step=output&tf=XunitV3&tech=aspnetcore&ext=AspNetCore,Http // Delete whatever is not needed. using System.Runtime.CompilerServices; @@ -461,7 +461,7 @@ public static class ModuleInitializer ==== Plugins/AspNetCoreTests.cs -// Generated by the Verify wizard: https://verifytests.github.io/Wizard/add/by-tech?step=output&tf=XunitV3&tech=aspnetcore&have=DiffPlex&ext=AspNetCore,Http +// Generated by the Verify wizard: https://verifytests.github.io/Wizard/add/by-tech?step=output&tf=XunitV3&tech=aspnetcore&ext=AspNetCore,Http // Delete whatever is not needed. using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Mvc; @@ -508,7 +508,7 @@ public class AspNetCoreTests ==== Plugins/HttpTests.cs -// Generated by the Verify wizard: https://verifytests.github.io/Wizard/add/by-tech?step=output&tf=XunitV3&tech=aspnetcore&have=DiffPlex&ext=AspNetCore,Http +// Generated by the Verify wizard: https://verifytests.github.io/Wizard/add/by-tech?step=output&tf=XunitV3&tech=aspnetcore&ext=AspNetCore,Http // Delete whatever is not needed. using Microsoft.Extensions.DependencyInjection; using VerifyTests.Http; @@ -638,7 +638,7 @@ public class HttpTests ==== src-samples/MyController.cs -// Generated by the Verify wizard: https://verifytests.github.io/Wizard/add/by-tech?step=output&tf=XunitV3&tech=aspnetcore&have=DiffPlex&ext=AspNetCore,Http +// Generated by the Verify wizard: https://verifytests.github.io/Wizard/add/by-tech?step=output&tf=XunitV3&tech=aspnetcore&ext=AspNetCore,Http // Delete whatever is not needed. using Microsoft.AspNetCore.Mvc; diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Addition_name=EfNextToExistingSql.verified.txt b/src/Wizard.Tests/Generation/GeneratorTests.Addition_name=EfNextToExistingSql.verified.txt index 0212d80..c96ef7c 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Addition_name=EfNextToExistingSql.verified.txt +++ b/src/Wizard.Tests/Generation/GeneratorTests.Addition_name=EfNextToExistingSql.verified.txt @@ -7,11 +7,11 @@ Info recording-bus [EntityFramework, SqlServer] # Adding Verify plugins -Generated by the [Verify wizard](https://verifytests.github.io/Wizard/add?step=output&tf=XunitV3&have=DiffPlex,SqlServer&ext=EntityFramework) (reopen that link to change any answer). +Generated by the [Verify wizard](https://verifytests.github.io/Wizard/add?step=output&tf=XunitV3&have=SqlServer&ext=EntityFramework) (reopen that link to change any answer). * Test framework: xUnit v3 * Adding: EntityFramework (verbose) - * Already in the project: DiffPlex, SqlServer + * Already in the project: SqlServer * Maintenance fee: No change * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -270,7 +270,7 @@ Set the environment variable `DiffEngine_Disabled=true` when running tests where # Adding Verify plugins: instructions for AI coding assistants -Generated by the [Verify wizard](https://verifytests.github.io/Wizard/add?step=output&tf=XunitV3&have=DiffPlex,SqlServer&ext=EntityFramework). The files next to this one are changes to merge into a project that already uses Verify snapshot testing with xUnit v3. Carry out the steps below in order. +Generated by the [Verify wizard](https://verifytests.github.io/Wizard/add?step=output&tf=XunitV3&have=SqlServer&ext=EntityFramework). The files next to this one are changes to merge into a project that already uses Verify snapshot testing with xUnit v3. Carry out the steps below in order. ## Steps @@ -420,7 +420,7 @@ await ThrowsTask(() => MethodThatThrows()) ==== ModuleInitializer.cs -// Generated by the Verify wizard: https://verifytests.github.io/Wizard/add?step=output&tf=XunitV3&have=DiffPlex,SqlServer&ext=EntityFramework +// Generated by the Verify wizard: https://verifytests.github.io/Wizard/add?step=output&tf=XunitV3&have=SqlServer&ext=EntityFramework // Delete whatever is not needed. using System.Runtime.CompilerServices; using Microsoft.EntityFrameworkCore; @@ -463,7 +463,7 @@ public static class ModuleInitializer ==== Plugins/EntityFrameworkTests.cs -// Generated by the Verify wizard: https://verifytests.github.io/Wizard/add?step=output&tf=XunitV3&have=DiffPlex,SqlServer&ext=EntityFramework +// Generated by the Verify wizard: https://verifytests.github.io/Wizard/add?step=output&tf=XunitV3&have=SqlServer&ext=EntityFramework // Delete whatever is not needed. using Microsoft.EntityFrameworkCore; @@ -597,7 +597,7 @@ public class EntityFrameworkTests ==== src-samples/SampleDbContext.cs -// Generated by the Verify wizard: https://verifytests.github.io/Wizard/add?step=output&tf=XunitV3&have=DiffPlex,SqlServer&ext=EntityFramework +// Generated by the Verify wizard: https://verifytests.github.io/Wizard/add?step=output&tf=XunitV3&have=SqlServer&ext=EntityFramework // Delete whatever is not needed. using Microsoft.EntityFrameworkCore; diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Ai_framework=Expecto.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.Ai_framework=Expecto.verified.md index 59cff4c..329dae2 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Ai_framework=Expecto.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.Ai_framework=Expecto.verified.md @@ -9,21 +9,10 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Run the tests from the solution directory with `dotnet test`. The test project runs on Microsoft.Testing.Platform (`global.json` sets the runner), so `dotnet run --project` on it also works. * Target framework `net10.0`, SDK pinned by `global.json` (10.0.401). * Packages use Central Package Management: add or change versions in `Directory.Packages.props`, and reference packages without a version. - * Verify packages: Verify.Expecto 1.0.0, Verify.DiffPlex 1.0.0. + * Verify packages: Verify.Expecto 1.0.0. * Verify is configured by the lazy `initialize` value in `Tests.fs`; every test forces it before verifying. * The Open Source Maintenance Fee declaration is in `Directory.Build.props` (Exempt: OpenSource). Do not remove it: without it every build fails with SC021. -## Verify plugins in this project - -### Verify.DiffPlex - - * Shows an inline diff in the failure message of a text snapshot, instead of both files in full. - * Repository: https://github.com/VerifyTests/Verify.DiffPlex - * Enabled in `ModuleInitializer.cs` by `VerifyDiffPlex.Initialize(OutputType.Compact);`. Do not move that call after `VerifierSettings.InitializePlugins()`. - * Needs `using VerifyTests.DiffPlex;` in the test file, not in global usings: plugins define colliding type names. - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Snapshot Testing (Verify) This project uses [Verify](https://github.com/VerifyTests/Verify) for snapshot testing. diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Ai_framework=Fixie.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.Ai_framework=Fixie.verified.md index 1c25590..566c589 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Ai_framework=Fixie.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.Ai_framework=Fixie.verified.md @@ -9,22 +9,10 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Run the tests from the solution directory with `dotnet test`. Fixie runs on VSTest, which is why `global.json` does not select the Microsoft.Testing.Platform runner. * Target framework `net10.0`, SDK pinned by `global.json` (10.0.401). * Packages use Central Package Management: add or change versions in `Directory.Packages.props`, and reference packages without a version. - * Verify packages: Verify.Fixie 1.0.0, Verify.DiffPlex 1.0.0. + * Verify packages: Verify.Fixie 1.0.0. * Verify is configured in `ModuleInitializer.cs` in the test project. Explicit plugin `Initialize` calls go before `VerifierSettings.InitializePlugins()`. * The Open Source Maintenance Fee declaration is in `Directory.Build.props` (Exempt: OpenSource). Do not remove it: without it every build fails with SC021. -## Verify plugins in this project - -### Verify.DiffPlex - - * Shows an inline diff in the failure message of a text snapshot, instead of both files in full. - * Repository: https://github.com/VerifyTests/Verify.DiffPlex - * Enabled in `ModuleInitializer.cs` by `VerifyDiffPlex.Initialize(OutputType.Compact);`. Do not move that call after `VerifierSettings.InitializePlugins()`. - * Samples: `Plugins/DiffPlexTests.cs`, using `PerTestOutput`. - * Needs `using VerifyTests.DiffPlex;` in the test file, not in global usings: plugins define colliding type names. - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Snapshot Testing (Verify) This project uses [Verify](https://github.com/VerifyTests/Verify) for snapshot testing. diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Ai_framework=MSTest.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.Ai_framework=MSTest.verified.md index 6064580..855d834 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Ai_framework=MSTest.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.Ai_framework=MSTest.verified.md @@ -9,22 +9,10 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Run the tests from the solution directory with `dotnet test`. The test project runs on Microsoft.Testing.Platform (`global.json` sets the runner), so `dotnet run --project` on it also works. * Target framework `net10.0`, SDK pinned by `global.json` (10.0.401). * Packages use Central Package Management: add or change versions in `Directory.Packages.props`, and reference packages without a version. - * Verify packages: Verify.MSTest 1.0.0, Verify.DiffPlex 1.0.0. + * Verify packages: Verify.MSTest 1.0.0. * Verify is configured in `ModuleInitializer.cs` in the test project. Explicit plugin `Initialize` calls go before `VerifierSettings.InitializePlugins()`. * The Open Source Maintenance Fee declaration is in `Directory.Build.props` (Exempt: OpenSource). Do not remove it: without it every build fails with SC021. -## Verify plugins in this project - -### Verify.DiffPlex - - * Shows an inline diff in the failure message of a text snapshot, instead of both files in full. - * Repository: https://github.com/VerifyTests/Verify.DiffPlex - * Enabled in `ModuleInitializer.cs` by `VerifyDiffPlex.Initialize(OutputType.Compact);`. Do not move that call after `VerifierSettings.InitializePlugins()`. - * Samples: `Plugins/DiffPlexTests.cs`, using `PerTestOutput`. - * Needs `using VerifyTests.DiffPlex;` in the test file, not in global usings: plugins define colliding type names. - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Snapshot Testing (Verify) This project uses [Verify](https://github.com/VerifyTests/Verify) for snapshot testing. diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Ai_framework=NUnit.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.Ai_framework=NUnit.verified.md index 1d93657..6a16d60 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Ai_framework=NUnit.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.Ai_framework=NUnit.verified.md @@ -9,22 +9,10 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Run the tests from the solution directory with `dotnet test`. The test project runs on Microsoft.Testing.Platform (`global.json` sets the runner), so `dotnet run --project` on it also works. * Target framework `net10.0`, SDK pinned by `global.json` (10.0.401). * Packages use Central Package Management: add or change versions in `Directory.Packages.props`, and reference packages without a version. - * Verify packages: Verify.NUnit 1.0.0, Verify.DiffPlex 1.0.0. + * Verify packages: Verify.NUnit 1.0.0. * Verify is configured in `ModuleInitializer.cs` in the test project. Explicit plugin `Initialize` calls go before `VerifierSettings.InitializePlugins()`. * The Open Source Maintenance Fee declaration is in `Directory.Build.props` (Exempt: OpenSource). Do not remove it: without it every build fails with SC021. -## Verify plugins in this project - -### Verify.DiffPlex - - * Shows an inline diff in the failure message of a text snapshot, instead of both files in full. - * Repository: https://github.com/VerifyTests/Verify.DiffPlex - * Enabled in `ModuleInitializer.cs` by `VerifyDiffPlex.Initialize(OutputType.Compact);`. Do not move that call after `VerifierSettings.InitializePlugins()`. - * Samples: `Plugins/DiffPlexTests.cs`, using `PerTestOutput`. - * Needs `using VerifyTests.DiffPlex;` in the test file, not in global usings: plugins define colliding type names. - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Snapshot Testing (Verify) This project uses [Verify](https://github.com/VerifyTests/Verify) for snapshot testing. diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Ai_framework=TUnit.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.Ai_framework=TUnit.verified.md index 7228cc8..3af11f1 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Ai_framework=TUnit.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.Ai_framework=TUnit.verified.md @@ -9,22 +9,10 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Run the tests from the solution directory with `dotnet test`. The test project runs on Microsoft.Testing.Platform (`global.json` sets the runner), so `dotnet run --project` on it also works. * Target framework `net10.0`, SDK pinned by `global.json` (10.0.401). * Packages use Central Package Management: add or change versions in `Directory.Packages.props`, and reference packages without a version. - * Verify packages: Verify.TUnit 1.0.0, Verify.DiffPlex 1.0.0. + * Verify packages: Verify.TUnit 1.0.0. * Verify is configured in `ModuleInitializer.cs` in the test project. Explicit plugin `Initialize` calls go before `VerifierSettings.InitializePlugins()`. * The Open Source Maintenance Fee declaration is in `Directory.Build.props` (Exempt: OpenSource). Do not remove it: without it every build fails with SC021. -## Verify plugins in this project - -### Verify.DiffPlex - - * Shows an inline diff in the failure message of a text snapshot, instead of both files in full. - * Repository: https://github.com/VerifyTests/Verify.DiffPlex - * Enabled in `ModuleInitializer.cs` by `VerifyDiffPlex.Initialize(OutputType.Compact);`. Do not move that call after `VerifierSettings.InitializePlugins()`. - * Samples: `Plugins/DiffPlexTests.cs`, using `PerTestOutput`. - * Needs `using VerifyTests.DiffPlex;` in the test file, not in global usings: plugins define colliding type names. - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Snapshot Testing (Verify) This project uses [Verify](https://github.com/VerifyTests/Verify) for snapshot testing. diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Ai_framework=XunitV3.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.Ai_framework=XunitV3.verified.md index caffb4e..8788877 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Ai_framework=XunitV3.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.Ai_framework=XunitV3.verified.md @@ -9,22 +9,10 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Run the tests from the solution directory with `dotnet test`. The test project runs on Microsoft.Testing.Platform (`global.json` sets the runner), so `dotnet run --project` on it also works. * Target framework `net10.0`, SDK pinned by `global.json` (10.0.401). * Packages use Central Package Management: add or change versions in `Directory.Packages.props`, and reference packages without a version. - * Verify packages: Verify.XunitV3 1.0.0, Verify.DiffPlex 1.0.0. + * Verify packages: Verify.XunitV3 1.0.0. * Verify is configured in `ModuleInitializer.cs` in the test project. Explicit plugin `Initialize` calls go before `VerifierSettings.InitializePlugins()`. * The Open Source Maintenance Fee declaration is in `Directory.Build.props` (Exempt: OpenSource). Do not remove it: without it every build fails with SC021. -## Verify plugins in this project - -### Verify.DiffPlex - - * Shows an inline diff in the failure message of a text snapshot, instead of both files in full. - * Repository: https://github.com/VerifyTests/Verify.DiffPlex - * Enabled in `ModuleInitializer.cs` by `VerifyDiffPlex.Initialize(OutputType.Compact);`. Do not move that call after `VerifierSettings.InitializePlugins()`. - * Samples: `Plugins/DiffPlexTests.cs`, using `PerTestOutput`. - * Needs `using VerifyTests.DiffPlex;` in the test file, not in global usings: plugins define colliding type names. - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Snapshot Testing (Verify) This project uses [Verify](https://github.com/VerifyTests/Verify) for snapshot testing. diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Combination_combination=BunitAndAngleSharp.verified.txt b/src/Wizard.Tests/Generation/GeneratorTests.Combination_combination=BunitAndAngleSharp.verified.txt index 6cde0e2..5e5727a 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Combination_combination=BunitAndAngleSharp.verified.txt +++ b/src/Wizard.Tests/Generation/GeneratorTests.Combination_combination=BunitAndAngleSharp.verified.txt @@ -2,16 +2,12 @@ AngleSharp Bunit -DiffPlex ==== interactions Warning bunit-anglesharp-comparer [AngleSharp, Bunit] Both register a string comparer for html. Verify.Bunit is initialized first, so Verify.AngleSharp's semantic comparison wins. -Info diffplex-default-comparer [AngleSharp, Bunit, DiffPlex] -Verify.DiffPlex is the default comparer for text snapshots. The plugins selected here register comparers for specific plugins (html, json, svg), which take precedence over it. - Info html-prettyprint [AngleSharp, Bunit] Rendered html is a single long line, which makes snapshot diffs unreadable. `HtmlPrettyPrint.All()` formats every html snapshot, and Verify.AngleSharp compares them semantically rather than as text. @@ -20,11 +16,10 @@ VerifierSettings.InitializePlugins() cannot find AngleSharp: it looks for a type ==== src/VerifySample.Tests/ModuleInitializer.cs -// Generated by the Verify wizard: https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions&ext=AngleSharp,Bunit,DiffPlex&sponsor=Exempt&exempt=OpenSource&until=2027-09 +// Generated by the Verify wizard: https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions&ext=AngleSharp,Bunit&sponsor=Exempt&exempt=OpenSource&until=2027-09 // Delete whatever is not needed. using System.Runtime.CompilerServices; using VerifyTests.AngleSharp; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -32,12 +27,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Verify.Bunit: renders a component through bUnit and writes its markup as an html snapshot. // excludeComponent decides whether the component's own state is written alongside the markup. VerifyBunit.Initialize(excludeComponent: false); @@ -87,6 +76,4 @@ src/VerifySample.Tests/ModuleInitializer.cs src/VerifySample.Tests/Sample.cs src/VerifySample.Tests/VerifyChecksTests.cs src/VerifySample.Tests/Plugins/AngleSharpTests.cs -src/VerifySample.Tests/Plugins/BunitTests.cs -src/VerifySample.Tests/Plugins/DiffPlexTests.cs -src/VerifySample.Tests/Plugins/DiffPlexTests.PerTestOutput.verified.txt \ No newline at end of file +src/VerifySample.Tests/Plugins/BunitTests.cs \ No newline at end of file diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Combination_combination=EfAndSql.verified.txt b/src/Wizard.Tests/Generation/GeneratorTests.Combination_combination=EfAndSql.verified.txt index e9dfb39..816d28a 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Combination_combination=EfAndSql.verified.txt +++ b/src/Wizard.Tests/Generation/GeneratorTests.Combination_combination=EfAndSql.verified.txt @@ -1,6 +1,5 @@ ==== selected -DiffPlex EntityFramework SqlServer @@ -17,12 +16,11 @@ These plugins all append to the same recording, which lands in every snapshot ta ==== src/VerifySample.Tests/ModuleInitializer.cs -// Generated by the Verify wizard: https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions&ext=DiffPlex,EntityFramework,SqlServer&sponsor=Exempt&exempt=OpenSource&until=2027-09 +// Generated by the Verify wizard: https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions&ext=EntityFramework,SqlServer&sponsor=Exempt&exempt=OpenSource&until=2027-09 // Delete whatever is not needed. using System.Runtime.CompilerServices; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.Metadata; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -30,12 +28,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Verify.SqlServer: schema snapshots stay, but recording is off, because // Verify.EntityFramework records the same commands under the name ef, with the command // type and the transaction state. @@ -88,7 +80,5 @@ src/VerifySample.Tests/Sample.Test.verified.txt src/VerifySample.Tests/ModuleInitializer.cs src/VerifySample.Tests/Sample.cs src/VerifySample.Tests/VerifyChecksTests.cs -src/VerifySample.Tests/Plugins/DiffPlexTests.cs -src/VerifySample.Tests/Plugins/DiffPlexTests.PerTestOutput.verified.txt src/VerifySample.Tests/Plugins/EntityFrameworkTests.cs src/VerifySample.Tests/Plugins/SqlServerTests.cs \ No newline at end of file diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Combination_combination=Everything.verified.txt b/src/Wizard.Tests/Generation/GeneratorTests.Combination_combination=Everything.verified.txt index fb95aec..54e22c0 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Combination_combination=Everything.verified.txt +++ b/src/Wizard.Tests/Generation/GeneratorTests.Combination_combination=Everything.verified.txt @@ -13,7 +13,6 @@ CommunityToolkitMvvm Cosmos CsvHelper Diagnostics -DiffPlex DocNet EmailPreviewServices EntityFramework @@ -177,9 +176,6 @@ Morph carries an Open Source Maintenance Fee check of its own, for Papyrine, and Info cosmos-etag [AspNetCore, Cosmos, Http] Verify.Cosmos ignores the member ETag on every type, not only on Cosmos types, so an ETag on an http response or an ASP.NET Core result is left out of the snapshot too. -Info diffplex-default-comparer [AngleSharp, Bunit, DiffPlex, ImageMagick, Quibble] -Verify.DiffPlex is the default comparer for text snapshots. The plugins selected here register comparers for specific plugins (html, json, svg), which take precedence over it. - Info ef-localdb [EntityFramework, LocalDb] LocalDb runs the tests against a real SQL Server LocalDB instance, one database per test, so EF snapshots cover what the database actually returns. The EfLocalDb package for the chosen test framework already depends on Verify.EntityFramework. @@ -206,7 +202,7 @@ LocalDb gives Verify.SqlServer a real database to read a schema from, without ne ==== src/VerifySample.Tests/ModuleInitializer.cs -// Generated by the Verify wizard: https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions&ext=AngleSharp,AspNetCore,Aspose,Assertions,Avalonia,Blazor,Brighter,Bunit,ClosedXml,CommunityToolkitMvvm,Cosmos,CsvHelper,Diagnostics,DiffPlex,DocNet,EmailPreviewServices,EntityFramework,EntityFrameworkClassic,FakeItEasy,Flurl,Http,ICSharpCodeDecompiler,ImageHash,ImageMagick,ImageSharp,ImageSharpCompare,LocalDb,MailMessage,MassTransit,MicrosoftLogging,Mockly,Moq,NServiceBus,NSubstitute,NUlid,NewtonsoftJson,NodaTime,OpenTelemetry,OpenXml,PDFium,Pandoc,ParametersHashing,PdfPig,Phash,Playwright,Puppeteer,QuestPDF,Quibble,RavenDB,ReadableExpressions,Selenium,SendGrid,Sep,Serilog,SourceGenerators,SqlServer,Sylvan,Syncfusion,SystemJson,Terminal,Ulid,WinForms,Wolverine,Xaml,Yaml,ZeroLog&sponsor=Exempt&exempt=OpenSource&until=2027-09 +// Generated by the Verify wizard: https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions&ext=AngleSharp,AspNetCore,Aspose,Assertions,Avalonia,Blazor,Brighter,Bunit,ClosedXml,CommunityToolkitMvvm,Cosmos,CsvHelper,Diagnostics,DocNet,EmailPreviewServices,EntityFramework,EntityFrameworkClassic,FakeItEasy,Flurl,Http,ICSharpCodeDecompiler,ImageHash,ImageMagick,ImageSharp,ImageSharpCompare,LocalDb,MailMessage,MassTransit,MicrosoftLogging,Mockly,Moq,NServiceBus,NSubstitute,NUlid,NewtonsoftJson,NodaTime,OpenTelemetry,OpenXml,PDFium,Pandoc,ParametersHashing,PdfPig,Phash,Playwright,Puppeteer,QuestPDF,Quibble,RavenDB,ReadableExpressions,Selenium,SendGrid,Sep,Serilog,SourceGenerators,SqlServer,Sylvan,Syncfusion,SystemJson,Terminal,Ulid,WinForms,Wolverine,Xaml,Yaml,ZeroLog&sponsor=Exempt&exempt=OpenSource&until=2027-09 // Delete whatever is not needed. using System.Runtime.CompilerServices; using CoenM.ImageHash.HashAlgorithms; @@ -216,7 +212,6 @@ using QuestPDF.Infrastructure; using Syncfusion.Licensing; using VerifyTests.AngleSharp; using VerifyTests.Blazor; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -235,12 +230,6 @@ public static class ModuleInitializer // with strict json still off. VerifyQuibble.Initialize(); - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Verify.ImageHash: png, jpg and bmp snapshots are compared by perceptual hash rather than // byte for byte, so anti-aliasing and font hinting differences no longer fail a test. // Initialize() registers the comparers with the default threshold of 95 and is what marks @@ -386,7 +375,7 @@ public static class ModuleInitializer ==== src/VerifySample.Tests.Windows/ModuleInitializer.cs -// Generated by the Verify wizard: https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions&ext=AngleSharp,AspNetCore,Aspose,Assertions,Avalonia,Blazor,Brighter,Bunit,ClosedXml,CommunityToolkitMvvm,Cosmos,CsvHelper,Diagnostics,DiffPlex,DocNet,EmailPreviewServices,EntityFramework,EntityFrameworkClassic,FakeItEasy,Flurl,Http,ICSharpCodeDecompiler,ImageHash,ImageMagick,ImageSharp,ImageSharpCompare,LocalDb,MailMessage,MassTransit,MicrosoftLogging,Mockly,Moq,NServiceBus,NSubstitute,NUlid,NewtonsoftJson,NodaTime,OpenTelemetry,OpenXml,PDFium,Pandoc,ParametersHashing,PdfPig,Phash,Playwright,Puppeteer,QuestPDF,Quibble,RavenDB,ReadableExpressions,Selenium,SendGrid,Sep,Serilog,SourceGenerators,SqlServer,Sylvan,Syncfusion,SystemJson,Terminal,Ulid,WinForms,Wolverine,Xaml,Yaml,ZeroLog&sponsor=Exempt&exempt=OpenSource&until=2027-09 +// Generated by the Verify wizard: https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions&ext=AngleSharp,AspNetCore,Aspose,Assertions,Avalonia,Blazor,Brighter,Bunit,ClosedXml,CommunityToolkitMvvm,Cosmos,CsvHelper,Diagnostics,DocNet,EmailPreviewServices,EntityFramework,EntityFrameworkClassic,FakeItEasy,Flurl,Http,ICSharpCodeDecompiler,ImageHash,ImageMagick,ImageSharp,ImageSharpCompare,LocalDb,MailMessage,MassTransit,MicrosoftLogging,Mockly,Moq,NServiceBus,NSubstitute,NUlid,NewtonsoftJson,NodaTime,OpenTelemetry,OpenXml,PDFium,Pandoc,ParametersHashing,PdfPig,Phash,Playwright,Puppeteer,QuestPDF,Quibble,RavenDB,ReadableExpressions,Selenium,SendGrid,Sep,Serilog,SourceGenerators,SqlServer,Sylvan,Syncfusion,SystemJson,Terminal,Ulid,WinForms,Wolverine,Xaml,Yaml,ZeroLog&sponsor=Exempt&exempt=OpenSource&until=2027-09 // Delete whatever is not needed. using System.Runtime.CompilerServices; @@ -470,8 +459,6 @@ src/VerifySample.Tests/Plugins/CommunityToolkitMvvmTests.cs src/VerifySample.Tests/Plugins/CosmosTests.cs src/VerifySample.Tests/Plugins/CsvHelperTests.cs src/VerifySample.Tests/Plugins/DiagnosticsTests.cs -src/VerifySample.Tests/Plugins/DiffPlexTests.cs -src/VerifySample.Tests/Plugins/DiffPlexTests.PerTestOutput.verified.txt src/VerifySample.Tests/Plugins/DocNetTests.cs src/VerifySample.Tests/Plugins/EmailPreviewServicesTests.cs src/VerifySample.Tests/Plugins/EntityFrameworkTests.cs diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Combination_combination=Windows.verified.txt b/src/Wizard.Tests/Generation/GeneratorTests.Combination_combination=Windows.verified.txt index 4db53a2..5a55afc 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Combination_combination=Windows.verified.txt +++ b/src/Wizard.Tests/Generation/GeneratorTests.Combination_combination=Windows.verified.txt @@ -1,6 +1,5 @@ ==== selected -DiffPlex WinForms Xaml @@ -11,10 +10,9 @@ Many Avalonia and WPF projects use CommunityToolkit.Mvvm. Verify.CommunityToolki ==== src/VerifySample.Tests/ModuleInitializer.cs -// Generated by the Verify wizard: https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions&ext=DiffPlex,WinForms,Xaml&sponsor=Exempt&exempt=OpenSource&until=2027-09 +// Generated by the Verify wizard: https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions&ext=WinForms,Xaml&sponsor=Exempt&exempt=OpenSource&until=2027-09 // Delete whatever is not needed. using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -22,12 +20,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); @@ -36,7 +28,7 @@ public static class ModuleInitializer ==== src/VerifySample.Tests.Windows/ModuleInitializer.cs -// Generated by the Verify wizard: https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions&ext=DiffPlex,WinForms,Xaml&sponsor=Exempt&exempt=OpenSource&until=2027-09 +// Generated by the Verify wizard: https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions&ext=WinForms,Xaml&sponsor=Exempt&exempt=OpenSource&until=2027-09 // Delete whatever is not needed. using System.Runtime.CompilerServices; @@ -77,8 +69,6 @@ src/VerifySample.Tests/Sample.Test.verified.txt src/VerifySample.Tests/ModuleInitializer.cs src/VerifySample.Tests/Sample.cs src/VerifySample.Tests/VerifyChecksTests.cs -src/VerifySample.Tests/Plugins/DiffPlexTests.cs -src/VerifySample.Tests/Plugins/DiffPlexTests.PerTestOutput.verified.txt src/VerifySample.Tests.Windows/VerifySample.Tests.Windows.csproj src/VerifySample.Tests.Windows/ModuleInitializer.cs src/VerifySample.Tests.Windows/Plugins/WinFormsTests.cs diff --git a/src/Wizard.Tests/Generation/GeneratorTests.GuideEnvironment_os=Linux_ide=Other_cli=Gui.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.GuideEnvironment_os=Linux_ide=Other_cli=Gui.verified.md index 2bac340..096c6f8 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.GuideEnvironment_os=Linux_ide=Other_cli=Gui.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.GuideEnvironment_os=Linux_ide=Other_cli=Gui.verified.md @@ -7,7 +7,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer GUI * Test framework: xUnit v3 * Build server: GitHub Actions - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -24,7 +24,6 @@ In `Directory.Packages.props`: - ``` @@ -34,7 +33,6 @@ In the test project: - ``` @@ -200,44 +198,12 @@ public class VerifyChecksTests When a snapshot does not match, Verify writes a `.received.` file next to the `.verified.` one and opens a diff tool. The following tools help review and accept those changes. -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before any test runs, in a [module initializer](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general#moduleinitializer-attribute). The solution's `ModuleInitializer.cs`: ```cs using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -245,12 +211,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); diff --git a/src/Wizard.Tests/Generation/GeneratorTests.GuideEnvironment_os=Linux_ide=VsCode_cli=Cli.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.GuideEnvironment_os=Linux_ide=VsCode_cli=Cli.verified.md index ec59db2..311a823 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.GuideEnvironment_os=Linux_ide=VsCode_cli=Cli.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.GuideEnvironment_os=Linux_ide=VsCode_cli=Cli.verified.md @@ -7,7 +7,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: xUnit v3 * Build server: GitHub Actions - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -21,7 +21,6 @@ Add the following packages to the test project. The solution uses [Central Packa ``` dotnet add package Verify.XunitV3 dotnet add package xunit.v3 -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -198,44 +197,12 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before any test runs, in a [module initializer](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general#moduleinitializer-attribute). The solution's `ModuleInitializer.cs`: ```cs using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -243,12 +210,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); diff --git a/src/Wizard.Tests/Generation/GeneratorTests.GuideEnvironment_os=MacOS_ide=Rider_cli=Gui.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.GuideEnvironment_os=MacOS_ide=Rider_cli=Gui.verified.md index 8babd48..400adec 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.GuideEnvironment_os=MacOS_ide=Rider_cli=Gui.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.GuideEnvironment_os=MacOS_ide=Rider_cli=Gui.verified.md @@ -7,7 +7,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer GUI * Test framework: xUnit v3 * Build server: GitHub Actions - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -24,7 +24,6 @@ In `Directory.Packages.props`: - ``` @@ -34,7 +33,6 @@ In the test project: - ``` @@ -263,44 +261,12 @@ resharper_return_value_of_pure_method_is_not_used_highlighting = error The solution's `.editorconfig` already includes this setting. -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before any test runs, in a [module initializer](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general#moduleinitializer-attribute). The solution's `ModuleInitializer.cs`: ```cs using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -308,12 +274,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); diff --git a/src/Wizard.Tests/Generation/GeneratorTests.GuideEnvironment_os=Windows_ide=VisualStudioWithReSharper_cli=Cli.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.GuideEnvironment_os=Windows_ide=VisualStudioWithReSharper_cli=Cli.verified.md index 38e9d4d..cfafb7c 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.GuideEnvironment_os=Windows_ide=VisualStudioWithReSharper_cli=Cli.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.GuideEnvironment_os=Windows_ide=VisualStudioWithReSharper_cli=Cli.verified.md @@ -7,7 +7,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: xUnit v3 * Build server: GitHub Actions - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -21,7 +21,6 @@ Add the following packages to the test project. The solution uses [Central Packa ``` dotnet add package Verify.XunitV3 dotnet add package xunit.v3 -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -273,44 +272,12 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before any test runs, in a [module initializer](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general#moduleinitializer-attribute). The solution's `ModuleInitializer.cs`: ```cs using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -318,12 +285,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); diff --git a/src/Wizard.Tests/Generation/GeneratorTests.GuideEnvironment_os=Windows_ide=VisualStudio_cli=Gui.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.GuideEnvironment_os=Windows_ide=VisualStudio_cli=Gui.verified.md index 7c04e56..85209a3 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.GuideEnvironment_os=Windows_ide=VisualStudio_cli=Gui.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.GuideEnvironment_os=Windows_ide=VisualStudio_cli=Gui.verified.md @@ -7,7 +7,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer GUI * Test framework: xUnit v3 * Build server: GitHub Actions - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -24,7 +24,6 @@ In `Directory.Packages.props`: - ``` @@ -34,7 +33,6 @@ In the test project: - ``` @@ -212,44 +210,12 @@ dotnet tool install -g DiffEngineTray This is optional, but recommended. Also consider enabling [Run at startup](https://github.com/VerifyTests/DiffEngine/blob/main/docs/tray.md#run-at-startup). -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before any test runs, in a [module initializer](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general#moduleinitializer-attribute). The solution's `ModuleInitializer.cs`: ```cs using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -257,12 +223,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Expecto_buildServer=AppVeyor.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Expecto_buildServer=AppVeyor.verified.md index 2d9a9ed..7a67e40 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Expecto_buildServer=AppVeyor.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Expecto_buildServer=AppVeyor.verified.md @@ -7,7 +7,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: Expecto * Build server: AppVeyor - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -23,7 +23,6 @@ dotnet add package YoloDev.Expecto.TestSdk dotnet add package Expecto dotnet add package FSharp.Core dotnet add package Verify.Expecto -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -276,27 +275,6 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before the first verification. F# has no module initializers, so `Tests.fs` holds a lazy value that each test forces first: @@ -304,12 +282,6 @@ Verify is configured once, before the first verification. F# has no module initi ```fs let initialize = lazy ( - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact) - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins()) diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Expecto_buildServer=AzureDevOps.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Expecto_buildServer=AzureDevOps.verified.md index 7d09b0b..5e0c5df 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Expecto_buildServer=AzureDevOps.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Expecto_buildServer=AzureDevOps.verified.md @@ -7,7 +7,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: Expecto * Build server: Azure DevOps - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -23,7 +23,6 @@ dotnet add package YoloDev.Expecto.TestSdk dotnet add package Expecto dotnet add package FSharp.Core dotnet add package Verify.Expecto -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -276,27 +275,6 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before the first verification. F# has no module initializers, so `Tests.fs` holds a lazy value that each test forces first: @@ -304,12 +282,6 @@ Verify is configured once, before the first verification. F# has no module initi ```fs let initialize = lazy ( - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact) - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins()) diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Expecto_buildServer=GitHubActions.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Expecto_buildServer=GitHubActions.verified.md index 9c15e96..7932606 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Expecto_buildServer=GitHubActions.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Expecto_buildServer=GitHubActions.verified.md @@ -7,7 +7,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: Expecto * Build server: GitHub Actions - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -23,7 +23,6 @@ dotnet add package YoloDev.Expecto.TestSdk dotnet add package Expecto dotnet add package FSharp.Core dotnet add package Verify.Expecto -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -276,27 +275,6 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before the first verification. F# has no module initializers, so `Tests.fs` holds a lazy value that each test forces first: @@ -304,12 +282,6 @@ Verify is configured once, before the first verification. F# has no module initi ```fs let initialize = lazy ( - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact) - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins()) diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Expecto_buildServer=None.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Expecto_buildServer=None.verified.md index df46bfb..949e904 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Expecto_buildServer=None.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Expecto_buildServer=None.verified.md @@ -7,7 +7,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: Expecto * Build server: No build server - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -23,7 +23,6 @@ dotnet add package YoloDev.Expecto.TestSdk dotnet add package Expecto dotnet add package FSharp.Core dotnet add package Verify.Expecto -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -276,27 +275,6 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before the first verification. F# has no module initializers, so `Tests.fs` holds a lazy value that each test forces first: @@ -304,12 +282,6 @@ Verify is configured once, before the first verification. F# has no module initi ```fs let initialize = lazy ( - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact) - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins()) diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Fixie_buildServer=AppVeyor.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Fixie_buildServer=AppVeyor.verified.md index ee8d66e..2685555 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Fixie_buildServer=AppVeyor.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Fixie_buildServer=AppVeyor.verified.md @@ -7,7 +7,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: Fixie * Build server: AppVeyor - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -22,7 +22,6 @@ Add the following packages to the test project. The solution uses [Central Packa dotnet add package Fixie.TestAdapter dotnet add package Microsoft.NET.Test.Sdk dotnet add package Verify.Fixie -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -251,44 +250,12 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before any test runs, in a [module initializer](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general#moduleinitializer-attribute). The solution's `ModuleInitializer.cs`: ```cs using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -296,12 +263,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Fixie_buildServer=AzureDevOps.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Fixie_buildServer=AzureDevOps.verified.md index 51b1776..b654beb 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Fixie_buildServer=AzureDevOps.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Fixie_buildServer=AzureDevOps.verified.md @@ -7,7 +7,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: Fixie * Build server: Azure DevOps - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -22,7 +22,6 @@ Add the following packages to the test project. The solution uses [Central Packa dotnet add package Fixie.TestAdapter dotnet add package Microsoft.NET.Test.Sdk dotnet add package Verify.Fixie -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -251,44 +250,12 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before any test runs, in a [module initializer](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general#moduleinitializer-attribute). The solution's `ModuleInitializer.cs`: ```cs using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -296,12 +263,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Fixie_buildServer=GitHubActions.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Fixie_buildServer=GitHubActions.verified.md index 95740ea..be69f79 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Fixie_buildServer=GitHubActions.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Fixie_buildServer=GitHubActions.verified.md @@ -7,7 +7,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: Fixie * Build server: GitHub Actions - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -22,7 +22,6 @@ Add the following packages to the test project. The solution uses [Central Packa dotnet add package Fixie.TestAdapter dotnet add package Microsoft.NET.Test.Sdk dotnet add package Verify.Fixie -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -251,44 +250,12 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before any test runs, in a [module initializer](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general#moduleinitializer-attribute). The solution's `ModuleInitializer.cs`: ```cs using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -296,12 +263,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Fixie_buildServer=None.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Fixie_buildServer=None.verified.md index f07451f..fe87278 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Fixie_buildServer=None.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=Fixie_buildServer=None.verified.md @@ -7,7 +7,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: Fixie * Build server: No build server - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -22,7 +22,6 @@ Add the following packages to the test project. The solution uses [Central Packa dotnet add package Fixie.TestAdapter dotnet add package Microsoft.NET.Test.Sdk dotnet add package Verify.Fixie -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -251,44 +250,12 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before any test runs, in a [module initializer](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general#moduleinitializer-attribute). The solution's `ModuleInitializer.cs`: ```cs using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -296,12 +263,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=MSTest_buildServer=AppVeyor.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=MSTest_buildServer=AppVeyor.verified.md index 49f56ee..1982c94 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=MSTest_buildServer=AppVeyor.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=MSTest_buildServer=AppVeyor.verified.md @@ -7,7 +7,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: MSTest * Build server: AppVeyor - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -22,7 +22,6 @@ Add the following packages to the test project. The solution uses [Central Packa dotnet add package MSTest.TestAdapter dotnet add package MSTest.TestFramework dotnet add package Verify.MSTest -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -276,44 +275,12 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before any test runs, in a [module initializer](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general#moduleinitializer-attribute). The solution's `ModuleInitializer.cs`: ```cs using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -321,12 +288,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=MSTest_buildServer=AzureDevOps.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=MSTest_buildServer=AzureDevOps.verified.md index 0823f3a..d776e0d 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=MSTest_buildServer=AzureDevOps.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=MSTest_buildServer=AzureDevOps.verified.md @@ -7,7 +7,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: MSTest * Build server: Azure DevOps - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -22,7 +22,6 @@ Add the following packages to the test project. The solution uses [Central Packa dotnet add package MSTest.TestAdapter dotnet add package MSTest.TestFramework dotnet add package Verify.MSTest -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -276,44 +275,12 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before any test runs, in a [module initializer](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general#moduleinitializer-attribute). The solution's `ModuleInitializer.cs`: ```cs using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -321,12 +288,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=MSTest_buildServer=GitHubActions.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=MSTest_buildServer=GitHubActions.verified.md index cd0bd09..9c34e18 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=MSTest_buildServer=GitHubActions.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=MSTest_buildServer=GitHubActions.verified.md @@ -7,7 +7,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: MSTest * Build server: GitHub Actions - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -22,7 +22,6 @@ Add the following packages to the test project. The solution uses [Central Packa dotnet add package MSTest.TestAdapter dotnet add package MSTest.TestFramework dotnet add package Verify.MSTest -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -276,44 +275,12 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before any test runs, in a [module initializer](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general#moduleinitializer-attribute). The solution's `ModuleInitializer.cs`: ```cs using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -321,12 +288,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=MSTest_buildServer=None.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=MSTest_buildServer=None.verified.md index afc1f23..37b43d3 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=MSTest_buildServer=None.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=MSTest_buildServer=None.verified.md @@ -7,7 +7,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: MSTest * Build server: No build server - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -22,7 +22,6 @@ Add the following packages to the test project. The solution uses [Central Packa dotnet add package MSTest.TestAdapter dotnet add package MSTest.TestFramework dotnet add package Verify.MSTest -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -276,44 +275,12 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before any test runs, in a [module initializer](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general#moduleinitializer-attribute). The solution's `ModuleInitializer.cs`: ```cs using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -321,12 +288,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=NUnit_buildServer=AppVeyor.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=NUnit_buildServer=AppVeyor.verified.md index 3196f50..ff65627 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=NUnit_buildServer=AppVeyor.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=NUnit_buildServer=AppVeyor.verified.md @@ -7,7 +7,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: NUnit * Build server: AppVeyor - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -22,7 +22,6 @@ Add the following packages to the test project. The solution uses [Central Packa dotnet add package NUnit dotnet add package NUnit3TestAdapter dotnet add package Verify.NUnit -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -276,44 +275,12 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before any test runs, in a [module initializer](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general#moduleinitializer-attribute). The solution's `ModuleInitializer.cs`: ```cs using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -321,12 +288,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=NUnit_buildServer=AzureDevOps.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=NUnit_buildServer=AzureDevOps.verified.md index f6e6f17..60917c1 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=NUnit_buildServer=AzureDevOps.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=NUnit_buildServer=AzureDevOps.verified.md @@ -7,7 +7,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: NUnit * Build server: Azure DevOps - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -22,7 +22,6 @@ Add the following packages to the test project. The solution uses [Central Packa dotnet add package NUnit dotnet add package NUnit3TestAdapter dotnet add package Verify.NUnit -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -276,44 +275,12 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before any test runs, in a [module initializer](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general#moduleinitializer-attribute). The solution's `ModuleInitializer.cs`: ```cs using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -321,12 +288,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=NUnit_buildServer=GitHubActions.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=NUnit_buildServer=GitHubActions.verified.md index 2c2b1f9..d3d6720 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=NUnit_buildServer=GitHubActions.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=NUnit_buildServer=GitHubActions.verified.md @@ -7,7 +7,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: NUnit * Build server: GitHub Actions - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -22,7 +22,6 @@ Add the following packages to the test project. The solution uses [Central Packa dotnet add package NUnit dotnet add package NUnit3TestAdapter dotnet add package Verify.NUnit -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -276,44 +275,12 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before any test runs, in a [module initializer](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general#moduleinitializer-attribute). The solution's `ModuleInitializer.cs`: ```cs using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -321,12 +288,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=NUnit_buildServer=None.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=NUnit_buildServer=None.verified.md index 107c6d6..79415c9 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=NUnit_buildServer=None.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=NUnit_buildServer=None.verified.md @@ -7,7 +7,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: NUnit * Build server: No build server - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -22,7 +22,6 @@ Add the following packages to the test project. The solution uses [Central Packa dotnet add package NUnit dotnet add package NUnit3TestAdapter dotnet add package Verify.NUnit -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -276,44 +275,12 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before any test runs, in a [module initializer](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general#moduleinitializer-attribute). The solution's `ModuleInitializer.cs`: ```cs using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -321,12 +288,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=TUnit_buildServer=AppVeyor.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=TUnit_buildServer=AppVeyor.verified.md index 71cf70b..afed8c5 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=TUnit_buildServer=AppVeyor.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=TUnit_buildServer=AppVeyor.verified.md @@ -7,7 +7,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: TUnit * Build server: AppVeyor - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -21,7 +21,6 @@ Add the following packages to the test project. The solution uses [Central Packa ``` dotnet add package TUnit dotnet add package Verify.TUnit -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -265,44 +264,12 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before any test runs, in a [module initializer](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general#moduleinitializer-attribute). The solution's `ModuleInitializer.cs`: ```cs using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -310,12 +277,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=TUnit_buildServer=AzureDevOps.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=TUnit_buildServer=AzureDevOps.verified.md index f79f205..7433e4b 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=TUnit_buildServer=AzureDevOps.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=TUnit_buildServer=AzureDevOps.verified.md @@ -7,7 +7,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: TUnit * Build server: Azure DevOps - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -21,7 +21,6 @@ Add the following packages to the test project. The solution uses [Central Packa ``` dotnet add package TUnit dotnet add package Verify.TUnit -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -265,44 +264,12 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before any test runs, in a [module initializer](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general#moduleinitializer-attribute). The solution's `ModuleInitializer.cs`: ```cs using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -310,12 +277,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=TUnit_buildServer=GitHubActions.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=TUnit_buildServer=GitHubActions.verified.md index 03fbd5e..80bd160 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=TUnit_buildServer=GitHubActions.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=TUnit_buildServer=GitHubActions.verified.md @@ -7,7 +7,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: TUnit * Build server: GitHub Actions - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -21,7 +21,6 @@ Add the following packages to the test project. The solution uses [Central Packa ``` dotnet add package TUnit dotnet add package Verify.TUnit -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -265,44 +264,12 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before any test runs, in a [module initializer](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general#moduleinitializer-attribute). The solution's `ModuleInitializer.cs`: ```cs using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -310,12 +277,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=TUnit_buildServer=None.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=TUnit_buildServer=None.verified.md index aadb2ed..813e34c 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=TUnit_buildServer=None.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=TUnit_buildServer=None.verified.md @@ -7,7 +7,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: TUnit * Build server: No build server - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -21,7 +21,6 @@ Add the following packages to the test project. The solution uses [Central Packa ``` dotnet add package TUnit dotnet add package Verify.TUnit -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -265,44 +264,12 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before any test runs, in a [module initializer](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general#moduleinitializer-attribute). The solution's `ModuleInitializer.cs`: ```cs using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -310,12 +277,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=XunitV3_buildServer=AppVeyor.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=XunitV3_buildServer=AppVeyor.verified.md index 72f9b58..e99bc00 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=XunitV3_buildServer=AppVeyor.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=XunitV3_buildServer=AppVeyor.verified.md @@ -7,7 +7,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: xUnit v3 * Build server: AppVeyor - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -21,7 +21,6 @@ Add the following packages to the test project. The solution uses [Central Packa ``` dotnet add package Verify.XunitV3 dotnet add package xunit.v3 -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -273,44 +272,12 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before any test runs, in a [module initializer](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general#moduleinitializer-attribute). The solution's `ModuleInitializer.cs`: ```cs using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -318,12 +285,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=XunitV3_buildServer=AzureDevOps.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=XunitV3_buildServer=AzureDevOps.verified.md index 2ced1a4..9903b31 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=XunitV3_buildServer=AzureDevOps.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=XunitV3_buildServer=AzureDevOps.verified.md @@ -7,7 +7,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: xUnit v3 * Build server: Azure DevOps - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -21,7 +21,6 @@ Add the following packages to the test project. The solution uses [Central Packa ``` dotnet add package Verify.XunitV3 dotnet add package xunit.v3 -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -273,44 +272,12 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before any test runs, in a [module initializer](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general#moduleinitializer-attribute). The solution's `ModuleInitializer.cs`: ```cs using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -318,12 +285,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=XunitV3_buildServer=GitHubActions.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=XunitV3_buildServer=GitHubActions.verified.md index faeafb9..05812c3 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=XunitV3_buildServer=GitHubActions.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=XunitV3_buildServer=GitHubActions.verified.md @@ -7,7 +7,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: xUnit v3 * Build server: GitHub Actions - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -21,7 +21,6 @@ Add the following packages to the test project. The solution uses [Central Packa ``` dotnet add package Verify.XunitV3 dotnet add package xunit.v3 -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -273,44 +272,12 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before any test runs, in a [module initializer](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general#moduleinitializer-attribute). The solution's `ModuleInitializer.cs`: ```cs using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -318,12 +285,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=XunitV3_buildServer=None.verified.md b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=XunitV3_buildServer=None.verified.md index 8bde67c..b6444dd 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=XunitV3_buildServer=None.verified.md +++ b/src/Wizard.Tests/Generation/GeneratorTests.Guide_framework=XunitV3_buildServer=None.verified.md @@ -7,7 +7,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: xUnit v3 * Build server: No build server - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -21,7 +21,6 @@ Add the following packages to the test project. The solution uses [Central Packa ``` dotnet add package Verify.XunitV3 dotnet add package xunit.v3 -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -273,44 +272,12 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before any test runs, in a [module initializer](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general#moduleinitializer-attribute). The solution's `ModuleInitializer.cs`: ```cs using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -318,12 +285,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); diff --git a/src/Wizard.Tests/Generation/GeneratorTests.InlineAddition.verified.txt b/src/Wizard.Tests/Generation/GeneratorTests.InlineAddition.verified.txt deleted file mode 100644 index 4514e7c..0000000 --- a/src/Wizard.Tests/Generation/GeneratorTests.InlineAddition.verified.txt +++ /dev/null @@ -1,368 +0,0 @@ -==== readme.md - -# Adding Verify plugins - -Generated by the [Verify wizard](https://verifytests.github.io/Wizard/add?step=output&tf=XunitV3&ext=DiffPlex&inline=true) (reopen that link to change any answer). - - * Test framework: xUnit v3 - * Adding: DiffPlex (verbose) - * Already in the project: none listed - * Maintenance fee: No change - * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated - -The download holds the changes below as files to merge, each named for where it goes. `CLAUDE.md` has the same steps written for an AI assistant to carry out. - -## 1. Add the packages - -With Central Package Management, merge `Directory.Packages.props.fragment.xml` into `Directory.Packages.props`, and the `PackageReference` items in `TestProject.csproj.fragment.xml` into the test project: - -```xml - - - - -``` - -Without it, reference each package with its version instead: - -```xml - -``` - -Or from the command line, in the test project's directory: - -``` -dotnet add package Verify.DiffPlex -``` - -## 2. Update the test project - -`TestProject.csproj.fragment.xml` has everything the test project gains: - -```xml - - - - -``` - -## 3. Update the module initializer - -`ModuleInitializer.cs` is a complete initializer for the plugins being added. To merge it into the project's own: explicit `Initialize` calls go above `VerifierSettings.InitializePlugins()`, because a plugin can only be initialized once and a call with parameters has to get in before discovery does. Calls after `InitializePlugins()` stay after it. - -```cs -using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; - -// Everything here runs once, when the test assembly loads, before any test. -public static class ModuleInitializer -{ - [ModuleInitializer] - public static void Initialize() - { - // Keeps each text snapshot in the test source, as a .Snapshot(...) literal, instead of a .verified. file. - // A verification that cannot be inlined, such as an image or a parameterised test, still uses a file. - VerifierSettings.Inline(); - // VerifierSettings.Inline(maxLines: 30); - - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - - // Initializes every Verify.* plugin the project references and has not initialized above. - // Explicit calls come first so their parameters apply: a plugin can only be initialized once. - VerifierSettings.InitializePlugins(); - } -} -``` - -### Inline snapshots - -[Inline snapshots](https://github.com/VerifyTests/Verify/blob/main/docs/inline-snapshots.md) are on: `VerifierSettings.Inline()` in the module initializer keeps each text snapshot in the test source, as the literal passed to `.Snapshot(...)`, instead of in a `.verified.` file. A verification that cannot be inlined, such as an image, a document, or a parameterised test whose parameters reach the verified name, still uses a file. `.NotInline()` keeps a single test on files. - -A pending inline snapshot is reviewed in DiffEngineViewer, which ships with Verify and opens on a failed run, in DiffEngineTray 20.1.2 or later, or with Verify.Terminal 0.9.1 or later (`dotnet verify review`). Accepting one rewrites the literal in the test file. The Rider and ReSharper plugins do not handle inline snapshots yet. - -The switch applies to the snapshots the project already has. On the next run each existing text snapshot fails as a new inline snapshot, and its `.verified.` file is reported as stale. Accepting both moves the snapshot into the test source; commit the source edits and the deleted files together. - -## 4. Add the tests - -Copy `Plugins/` into the test project. Each file shows one plugin, with a comment above every test saying what it demonstrates. - -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - -## Running the tests - -A new test has no snapshot yet, so its first run fails. For an inline snapshot, review the received text in DiffEngineViewer or DiffEngineTray, or with `dotnet verify review`, and accept it there: accepting writes the `.Snapshot(...)` literal into the test. A verification that cannot be inlined writes a `.received.` file instead; accept it by renaming it to `.verified.`, accepting it in the diff tool, DiffEngineTray or IDE plugin, or running `dotnet verify accept`. - -Set the environment variable `DiffEngine_Disabled=true` when running tests where a diff tool should not open, such as a build server or an AI assistant's terminal. Verify detects the common build servers itself. - -## Further reading - - * [Verify readme](https://github.com/VerifyTests/Verify#readme) - * [Serializer settings](https://github.com/VerifyTests/Verify/blob/main/docs/serializer-settings.md) - * [Scrubbers](https://github.com/VerifyTests/Verify/blob/main/docs/scrubbers.md) - * [File naming](https://github.com/VerifyTests/Verify/blob/main/docs/naming.md) - * [Parameterised tests](https://github.com/VerifyTests/Verify/blob/main/docs/parameterised.md) - * [Plugins](https://github.com/VerifyTests/Verify/blob/main/docs/plugins.md) - * [Using Verify with AI assistants](https://github.com/VerifyTests/Verify/blob/main/docs/ai-usage.md) - -==== CLAUDE.md - -# Adding Verify plugins: instructions for AI coding assistants - -Generated by the [Verify wizard](https://verifytests.github.io/Wizard/add?step=output&tf=XunitV3&ext=DiffPlex&inline=true). The files next to this one are changes to merge into a project that already uses Verify snapshot testing with xUnit v3. Carry out the steps below in order. - -## Steps - -1. If the solution uses Central Package Management (a `Directory.Packages.props` with `ManagePackageVersionsCentrally`), merge the `PackageVersion` items from `Directory.Packages.props.fragment.xml` into it. Otherwise give each `PackageReference` in the next step the version listed in that file. -2. Merge `TestProject.csproj.fragment.xml` into the test project: the `PackageReference` items, and any properties and items it has. -3. Merge `ModuleInitializer.cs` into the test project's existing module initializer. Explicit `Initialize` calls go above `VerifierSettings.InitializePlugins()`, in the order given: a plugin can only be initialized once, so a call with parameters has to come before discovery. Calls after `InitializePlugins()` stay after it. If the project has no module initializer, add the file as it is. -4. Copy `Plugins/` into the test project. -5. `VerifierSettings.Inline()` moves every existing text snapshot inline. On the next run each of those tests fails as `InlineNew` and its `.verified.` file is listed under `Delete:`. Tell the user before running the tests; once they agree, write each received text into the `.Snapshot(...)` literal at its `Source:` location and delete the listed files. -6. Build, then run the tests with `DiffEngine_Disabled=true`. The new tests fail on their first run because they have no `.verified.` files yet. Show the user each `.received.` file; accept one only once the user agrees it is right. - -## Verify plugins in this project - -### Verify.DiffPlex - - * Shows an inline diff in the failure message of a text snapshot, instead of both files in full. - * Repository: https://github.com/VerifyTests/Verify.DiffPlex - * Enabled in `ModuleInitializer.cs` by `VerifyDiffPlex.Initialize(OutputType.Compact);`. Do not move that call after `VerifierSettings.InitializePlugins()`. - * Samples: `Plugins/DiffPlexTests.cs`, using `PerTestOutput`. - * Needs `using VerifyTests.DiffPlex;` in the test file, not in global usings: plugins define colliding type names. - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - -## Snapshot Testing (Verify) - -This project uses [Verify](https://github.com/VerifyTests/Verify) for snapshot testing. - -### Key concepts - -- **`.verified.*` files** are the approved snapshots. They are committed to source control. -- **`.received.*` files** are the actual output from the latest test run. They are generated when a test fails (actual != expected) and are git-ignored. -- When a test fails, compare the `.received.*` file to the `.verified.*` file to understand the difference. -- **Inline snapshots** store the approved text in the test source file as a raw string literal passed to `.Snapshot(...)`, instead of in a `.verified.` file. - -### Handling test failures - -When a snapshot test fails: - -1. Run the failing test and read the `.received.*` file that was generated. -2. Compare it to the corresponding `.verified.*` file. -3. Determine if the difference is expected (due to an intentional code change) or a bug. - - **If expected**: copy the `.received.*` file to the `Verified:` path listed in the exception message to accept the new snapshot. - - **If a bug**: fix the code, not the snapshot. -4. Never hand-edit `.verified.*` files to make tests pass. Always let Verify generate the correct output by running the test. -5. Never derive the verified name from the received name. The two are not always identical. Multi-targeted projects add a runtime and version suffix to the received file, and ignored parameters are kept in the received name but dropped from the verified name. Always take the destination from the `Verified:` line of the exception message. -6. Delete every `.verified.` file listed in the `Delete:` section. Those files are no longer produced by any test, usually because a test was renamed or removed. - -If a snapshot differs between runs or between machines, add a scrubber to the test (`ScrubLinesContaining(...)`, `ScrubLines(...)`, `AddScrubber(...)`) rather than accepting the new output each time. - -### Handling inline snapshot failures - -An inline failure is reported in the `InlineNew:` or `InlineNotEqual:` section, which carries a `Source:` line with the source file path and line number instead of a file pair: - -```csharp -await Verify(input) - .Snapshot( - """ - line1 - line2 - """); -``` - -1. Read the received and expected text from the `FileContent:` section of the exception message, or from the staged `Received:` and `Expected:` paths under `obj/VerifyInline/` when present. -2. If the difference is expected, replace the raw string literal at the `Source:` location with the received text verbatim. If it is a bug, fix the code instead. -3. `InlineNew` means the `.Snapshot(...)` call has no expected value yet, so the received text becomes the literal. -4. Never invent the expected text and never edit a literal other than the one at the reported `Source:` location. - -Only the first target of a verification is inlined, so one exception message can carry both inline sections and file sections. - -### Scrubbed values - -Verify replaces non-deterministic values in snapshots with stable placeholders: - -- GUIDs become `Guid_1`, `Guid_2`, etc. -- DateTimes become `DateTime_1`, `DateTime_2`, etc. -- File paths are replaced with tokens like `{SolutionDirectory}`, `{ProjectDirectory}`, `{TempPath}`. -- Custom scrubbers may replace other values. - -These placeholders are intentional and ensure snapshots are deterministic across machines and runs. - -### Exception message format - -When a test fails, the exception message is machine-parsable with the following structure: - -``` -Directory: /path/to/test/project -New: - - Received: TestClass.Method.received.txt - Verified: TestClass.Method.verified.txt -NotEqual: - - Received: TestClass.Method.received.txt - Verified: TestClass.Method.verified.txt - -FileContent: - -New: - -Received: TestClass.Method.received.txt - - -NotEqual: - -Received: TestClass.Method.received.txt - -Verified: TestClass.Method.verified.txt - -``` - - * The `Directory:` line gives the base path for all relative file references. - * `New` means no `.verified.` file exists yet (first run or new test). - * `NotEqual` means the `.received.` and `.verified.` files differ. - * `Delete` means a `.verified.` file is no longer produced by any test. - * `InlineNew` and `InlineNotEqual` are the inline snapshot equivalents of `New` and `NotEqual`. They list a `Source:` line (`path:line`) rather than a received/verified pair, optionally followed by staged `Received:`, `Expected:` and `Patch:` paths. - * The `FileContent:` section contains the actual text content for quick comparison without needing to read files separately. - -See [Exception Message Format](https://github.com/VerifyTests/Verify/blob/main/docs/exception-message-format.md) for full details. - -### Verified file conventions - -- Encoding: UTF-8 with BOM -- Line endings: LF (not CRLF) -- No trailing newline - -### Common patterns - -```csharp -// Verify an object (serialized to JSON) -await Verify(myObject); - -// Verify a string -await Verify("some text output"); - -// Verify with inline settings -await Verify(myObject) - .ScrubLines(line => line.Contains("volatile")) - .DontScrubDateTimes(); - -// Verify throws -await ThrowsTask(() => MethodThatThrows()) - .IgnoreStackTrace(); - -// Verify with an inline snapshot instead of a .verified. file -await Verify(myObject) - .Snapshot( - """ - expected text - """); -``` - -==== Directory.Packages.props.fragment.xml - - - - - - -==== TestProject.csproj.fragment.xml - - - - - - -==== ModuleInitializer.cs - -// Generated by the Verify wizard: https://verifytests.github.io/Wizard/add?step=output&tf=XunitV3&ext=DiffPlex&inline=true -// Delete whatever is not needed. -using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; - -// Everything here runs once, when the test assembly loads, before any test. -public static class ModuleInitializer -{ - [ModuleInitializer] - public static void Initialize() - { - // Keeps each text snapshot in the test source, as a .Snapshot(...) literal, instead of a .verified. file. - // A verification that cannot be inlined, such as an image or a parameterised test, still uses a file. - VerifierSettings.Inline(); - // VerifierSettings.Inline(maxLines: 30); - - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - - // Initializes every Verify.* plugin the project references and has not initialized above. - // Explicit calls come first so their parameters apply: a plugin can only be initialized once. - VerifierSettings.InitializePlugins(); - } -} - -==== Plugins/DiffPlexTests.cs - -// Generated by the Verify wizard: https://verifytests.github.io/Wizard/add?step=output&tf=XunitV3&ext=DiffPlex&inline=true -// Delete whatever is not needed. -using VerifyTests.DiffPlex; - -// Verify.DiffPlex: Shows an inline diff in the failure message of a text snapshot, instead of both files in full. -// https://github.com/VerifyTests/Verify.DiffPlex -// Note: This changes only the failure message; what is written to a .verified. file is unaffected. -// Note: It is the default comparer for text. A plugin that registers a comparer for a specific -// file extension, such as html or json, takes precedence for that extension. -public class DiffPlexTests -{ - // The module initializer sets the mode for every test. UseDiffPlex overrides it for one, - // which is useful when a single snapshot is easier to read in full. - [Fact] - public Task PerTestOutput() - { - var target = "The text"; - return Verify(target) - .UseDiffPlex(OutputType.Full) - .Snapshot( - """ - The text - """); - } -} - diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Inline_framework=Expecto.verified.txt b/src/Wizard.Tests/Generation/GeneratorTests.Inline_framework=Expecto.verified.txt index e1fd870..5bc4cc7 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Inline_framework=Expecto.verified.txt +++ b/src/Wizard.Tests/Generation/GeneratorTests.Inline_framework=Expecto.verified.txt @@ -9,7 +9,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: Expecto * Build server: GitHub Actions - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -25,7 +25,6 @@ dotnet add package YoloDev.Expecto.TestSdk dotnet add package Expecto dotnet add package FSharp.Core dotnet add package Verify.Expecto -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -284,27 +283,6 @@ dotnet tool install -g verify.tool A pending inline snapshot is reviewed in DiffEngineViewer, which ships with Verify and opens on a failed run, in DiffEngineTray 20.1.2 or later, or with Verify.Terminal 0.9.1 or later (`dotnet verify review`). Accepting one rewrites the literal in the test file. The Rider and ReSharper plugins do not handle inline snapshots yet. -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before the first verification. F# has no module initializers, so `Tests.fs` holds a lazy value that each test forces first: @@ -315,13 +293,6 @@ let initialize = // Keeps each text snapshot in the test source, as a .Snapshot(...) literal, instead of a .verified. file. // A verification that cannot be inlined, such as an image or a parameterised test, still uses a file. VerifierSettings.Inline() - // VerifierSettings.Inline(maxLines: 30) - - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact) // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. @@ -459,22 +430,11 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Run the tests from the solution directory with `dotnet test`. The test project runs on Microsoft.Testing.Platform (`global.json` sets the runner), so `dotnet run --project` on it also works. * Target framework `net10.0`, SDK pinned by `global.json` (10.0.401). * Packages use Central Package Management: add or change versions in `Directory.Packages.props`, and reference packages without a version. - * Verify packages: Verify.Expecto 1.0.0, Verify.DiffPlex 1.0.0. + * Verify packages: Verify.Expecto 1.0.0. * Verify is configured by the lazy `initialize` value in `Tests.fs`; every test forces it before verifying. * Inline snapshots are on (`VerifierSettings.Inline()` in the module initializer): a text snapshot is the `.Snapshot(...)` literal in the test source. A verification that cannot be inlined, such as an image, a document or a test whose parameters reach the verified name, uses a `.verified.` file. * The Open Source Maintenance Fee declaration is in `Directory.Build.props` (Exempt: OpenSource). Do not remove it: without it every build fails with SC021. -## Verify plugins in this project - -### Verify.DiffPlex - - * Shows an inline diff in the failure message of a text snapshot, instead of both files in full. - * Repository: https://github.com/VerifyTests/Verify.DiffPlex - * Enabled in `ModuleInitializer.cs` by `VerifyDiffPlex.Initialize(OutputType.Compact);`. Do not move that call after `VerifierSettings.InitializePlugins()`. - * Needs `using VerifyTests.DiffPlex;` in the test file, not in global usings: plugins define colliding type names. - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Snapshot Testing (Verify) This project uses [Verify](https://github.com/VerifyTests/Verify) for snapshot testing. @@ -676,7 +636,7 @@ module Tests open System.Reflection open Expecto open VerifyTests -open VerifyTests.DiffPlex + open VerifyExpecto // F# has no module initializers, so each test forces this before verifying. It runs once. @@ -686,13 +646,6 @@ let initialize = // Keeps each text snapshot in the test source, as a .Snapshot(...) literal, instead of a .verified. file. // A verification that cannot be inlined, such as an image or a parameterised test, still uses a file. VerifierSettings.Inline() - // VerifierSettings.Inline(maxLines: 30) - - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact) // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Inline_framework=XunitV3.verified.txt b/src/Wizard.Tests/Generation/GeneratorTests.Inline_framework=XunitV3.verified.txt index b132583..69a173c 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Inline_framework=XunitV3.verified.txt +++ b/src/Wizard.Tests/Generation/GeneratorTests.Inline_framework=XunitV3.verified.txt @@ -9,7 +9,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: xUnit v3 * Build server: GitHub Actions - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -23,7 +23,6 @@ Add the following packages to the test project. The solution uses [Central Packa ``` dotnet add package Verify.XunitV3 dotnet add package xunit.v3 -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -281,44 +280,12 @@ dotnet tool install -g verify.tool A pending inline snapshot is reviewed in DiffEngineViewer, which ships with Verify and opens on a failed run, in DiffEngineTray 20.1.2 or later, or with Verify.Terminal 0.9.1 or later (`dotnet verify review`). Accepting one rewrites the literal in the test file. The Rider and ReSharper plugins do not handle inline snapshots yet. -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before any test runs, in a [module initializer](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general#moduleinitializer-attribute). The solution's `ModuleInitializer.cs`: ```cs using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -329,13 +296,6 @@ public static class ModuleInitializer // Keeps each text snapshot in the test source, as a .Snapshot(...) literal, instead of a .verified. file. // A verification that cannot be inlined, such as an image or a parameterised test, still uses a file. VerifierSettings.Inline(); - // VerifierSettings.Inline(maxLines: 30); - - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. @@ -477,23 +437,11 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Run the tests from the solution directory with `dotnet test`. The test project runs on Microsoft.Testing.Platform (`global.json` sets the runner), so `dotnet run --project` on it also works. * Target framework `net10.0`, SDK pinned by `global.json` (10.0.401). * Packages use Central Package Management: add or change versions in `Directory.Packages.props`, and reference packages without a version. - * Verify packages: Verify.XunitV3 1.0.0, Verify.DiffPlex 1.0.0. + * Verify packages: Verify.XunitV3 1.0.0. * Verify is configured in `ModuleInitializer.cs` in the test project. Explicit plugin `Initialize` calls go before `VerifierSettings.InitializePlugins()`. * Inline snapshots are on (`VerifierSettings.Inline()` in the module initializer): a text snapshot is the `.Snapshot(...)` literal in the test source. A verification that cannot be inlined, such as an image, a document or a test whose parameters reach the verified name, uses a `.verified.` file. * The Open Source Maintenance Fee declaration is in `Directory.Build.props` (Exempt: OpenSource). Do not remove it: without it every build fails with SC021. -## Verify plugins in this project - -### Verify.DiffPlex - - * Shows an inline diff in the failure message of a text snapshot, instead of both files in full. - * Repository: https://github.com/VerifyTests/Verify.DiffPlex - * Enabled in `ModuleInitializer.cs` by `VerifyDiffPlex.Initialize(OutputType.Compact);`. Do not move that call after `VerifierSettings.InitializePlugins()`. - * Samples: `Plugins/DiffPlexTests.cs`, using `PerTestOutput`. - * Needs `using VerifyTests.DiffPlex;` in the test file, not in global usings: plugins define colliding type names. - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Snapshot Testing (Verify) This project uses [Verify](https://github.com/VerifyTests/Verify) for snapshot testing. @@ -691,7 +639,6 @@ public enum Title // Generated by the Verify wizard: https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions&inline=true&sponsor=Exempt&exempt=OpenSource&until=2027-09 // Delete whatever is not needed. using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -702,13 +649,6 @@ public static class ModuleInitializer // Keeps each text snapshot in the test source, as a .Snapshot(...) literal, instead of a .verified. file. // A verification that cannot be inlined, such as an image or a parameterised test, still uses a file. VerifierSettings.Inline(); - // VerifierSettings.Inline(maxLines: 30); - - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. @@ -763,31 +703,3 @@ public class VerifyChecksTests VerifyChecks.Run(); } -==== src/VerifySample.Tests/Plugins/DiffPlexTests.cs - -// Generated by the Verify wizard: https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions&inline=true&sponsor=Exempt&exempt=OpenSource&until=2027-09 -// Delete whatever is not needed. -using VerifyTests.DiffPlex; - -// Verify.DiffPlex: Shows an inline diff in the failure message of a text snapshot, instead of both files in full. -// https://github.com/VerifyTests/Verify.DiffPlex -// Note: This changes only the failure message; what is written to a .verified. file is unaffected. -// Note: It is the default comparer for text. A plugin that registers a comparer for a specific -// file extension, such as html or json, takes precedence for that extension. -public class DiffPlexTests -{ - // The module initializer sets the mode for every test. UseDiffPlex overrides it for one, - // which is useful when a single snapshot is easier to read in full. - [Fact] - public Task PerTestOutput() - { - var target = "The text"; - return Verify(target) - .UseDiffPlex(OutputType.Full) - .Snapshot( - """ - The text - """); - } -} - diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Plugin_plugin=DiffPlex-Minimal.verified.txt b/src/Wizard.Tests/Generation/GeneratorTests.Plugin_plugin=DiffPlex-Minimal.verified.txt deleted file mode 100644 index b916b9d..0000000 --- a/src/Wizard.Tests/Generation/GeneratorTests.Plugin_plugin=DiffPlex-Minimal.verified.txt +++ /dev/null @@ -1,62 +0,0 @@ -==== src/VerifySample.Tests/ModuleInitializer.cs - -// Generated by the Verify wizard: https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions&min=DiffPlex&sponsor=Exempt&exempt=OpenSource&until=2027-09 -// Delete whatever is not needed. -using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; - -// Everything here runs once, when the test assembly loads, before any test. -public static class ModuleInitializer -{ - [ModuleInitializer] - public static void Initialize() - { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - - // Initializes every Verify.* plugin the project references and has not initialized above. - // Explicit calls come first so their parameters apply: a plugin can only be initialized once. - VerifierSettings.InitializePlugins(); - } -} - -==== src/VerifySample.Tests/Plugins/DiffPlexTests.cs - -// Generated by the Verify wizard: https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions&min=DiffPlex&sponsor=Exempt&exempt=OpenSource&until=2027-09 -// Delete whatever is not needed. -using VerifyTests.DiffPlex; - -// Verify.DiffPlex: Shows an inline diff in the failure message of a text snapshot, instead of both files in full. -// https://github.com/VerifyTests/Verify.DiffPlex -// Note: This changes only the failure message; what is written to a .verified. file is unaffected. -// Note: It is the default comparer for text. A plugin that registers a comparer for a specific -// file extension, such as html or json, takes precedence for that extension. -public class DiffPlexTests -{ - // The module initializer sets the mode for every test. UseDiffPlex overrides it for one, - // which is useful when a single snapshot is easier to read in full. - [Fact] - public Task PerTestOutput() - { - var target = "The text"; - return Verify(target) - .UseDiffPlex(OutputType.Full); - } -} - -==== src/VerifySample.Tests/Plugins/DiffPlexTests.PerTestOutput.verified.txt (UTF-8 with BOM) - -The text - - -==== packages - -Verify.XunitV3 -xunit.v3 -Verify.DiffPlex - -==== interactions - diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Plugin_plugin=DiffPlex-Verbose.verified.txt b/src/Wizard.Tests/Generation/GeneratorTests.Plugin_plugin=DiffPlex-Verbose.verified.txt deleted file mode 100644 index d61e10a..0000000 --- a/src/Wizard.Tests/Generation/GeneratorTests.Plugin_plugin=DiffPlex-Verbose.verified.txt +++ /dev/null @@ -1,62 +0,0 @@ -==== src/VerifySample.Tests/ModuleInitializer.cs - -// Generated by the Verify wizard: https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions&sponsor=Exempt&exempt=OpenSource&until=2027-09 -// Delete whatever is not needed. -using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; - -// Everything here runs once, when the test assembly loads, before any test. -public static class ModuleInitializer -{ - [ModuleInitializer] - public static void Initialize() - { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - - // Initializes every Verify.* plugin the project references and has not initialized above. - // Explicit calls come first so their parameters apply: a plugin can only be initialized once. - VerifierSettings.InitializePlugins(); - } -} - -==== src/VerifySample.Tests/Plugins/DiffPlexTests.cs - -// Generated by the Verify wizard: https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions&sponsor=Exempt&exempt=OpenSource&until=2027-09 -// Delete whatever is not needed. -using VerifyTests.DiffPlex; - -// Verify.DiffPlex: Shows an inline diff in the failure message of a text snapshot, instead of both files in full. -// https://github.com/VerifyTests/Verify.DiffPlex -// Note: This changes only the failure message; what is written to a .verified. file is unaffected. -// Note: It is the default comparer for text. A plugin that registers a comparer for a specific -// file extension, such as html or json, takes precedence for that extension. -public class DiffPlexTests -{ - // The module initializer sets the mode for every test. UseDiffPlex overrides it for one, - // which is useful when a single snapshot is easier to read in full. - [Fact] - public Task PerTestOutput() - { - var target = "The text"; - return Verify(target) - .UseDiffPlex(OutputType.Full); - } -} - -==== src/VerifySample.Tests/Plugins/DiffPlexTests.PerTestOutput.verified.txt (UTF-8 with BOM) - -The text - - -==== packages - -Verify.XunitV3 -xunit.v3 -Verify.DiffPlex - -==== interactions - diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Plugin_plugin=Quibble-Minimal.verified.txt b/src/Wizard.Tests/Generation/GeneratorTests.Plugin_plugin=Quibble-Minimal.verified.txt index aabbb3f..7ec4e8b 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Plugin_plugin=Quibble-Minimal.verified.txt +++ b/src/Wizard.Tests/Generation/GeneratorTests.Plugin_plugin=Quibble-Minimal.verified.txt @@ -37,8 +37,8 @@ public static class ModuleInitializer // Initialized before it throws about strict json, so a failed call cannot be retried. // Note: Strict json changes every snapshot in the project from Verify's relaxed format to real // json, so it is not a drop in for an existing suite. -// Note: It registers a string comparer for json, so it takes precedence over Verify.DiffPlex for -// json snapshots. A per test UseDiffPlex() overrides it again. +// Note: It registers a string comparer for json, so a mismatched json snapshot shows Quibble's +// message rather than Verify's text diff. // Note: An empty verified file is treated as {}. // Note: Quibble is an F# library, so FSharp.Core arrives transitively. // Note: There are no settings methods or per test toggles: the only configuration is the diff --git a/src/Wizard.Tests/Generation/GeneratorTests.Plugin_plugin=Quibble-Verbose.verified.txt b/src/Wizard.Tests/Generation/GeneratorTests.Plugin_plugin=Quibble-Verbose.verified.txt index 782be28..7cc7549 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.Plugin_plugin=Quibble-Verbose.verified.txt +++ b/src/Wizard.Tests/Generation/GeneratorTests.Plugin_plugin=Quibble-Verbose.verified.txt @@ -37,8 +37,8 @@ public static class ModuleInitializer // Initialized before it throws about strict json, so a failed call cannot be retried. // Note: Strict json changes every snapshot in the project from Verify's relaxed format to real // json, so it is not a drop in for an existing suite. -// Note: It registers a string comparer for json, so it takes precedence over Verify.DiffPlex for -// json snapshots. A per test UseDiffPlex() overrides it again. +// Note: It registers a string comparer for json, so a mismatched json snapshot shows Quibble's +// message rather than Verify's text diff. // Note: An empty verified file is treated as {}. // Note: Quibble is an F# library, so FSharp.Core arrives transitively. // Note: There are no settings methods or per test toggles: the only configuration is the diff --git a/src/Wizard.Tests/Generation/GeneratorTests.SolutionFileListMinimal.verified.txt b/src/Wizard.Tests/Generation/GeneratorTests.SolutionFileListMinimal.verified.txt index bc76571..dcf4e36 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.SolutionFileListMinimal.verified.txt +++ b/src/Wizard.Tests/Generation/GeneratorTests.SolutionFileListMinimal.verified.txt @@ -18,7 +18,5 @@ src/VerifySample.Tests/Sample.Test.verified.txt, src/VerifySample.Tests/ModuleInitializer.cs, src/VerifySample.Tests/Sample.cs, - src/VerifySample.Tests/VerifyChecksTests.cs, - src/VerifySample.Tests/Plugins/DiffPlexTests.cs, - src/VerifySample.Tests/Plugins/DiffPlexTests.PerTestOutput.verified.txt + src/VerifySample.Tests/VerifyChecksTests.cs ] \ No newline at end of file diff --git a/src/Wizard.Tests/Generation/GeneratorTests.SolutionFiles_framework=Expecto.verified.txt b/src/Wizard.Tests/Generation/GeneratorTests.SolutionFiles_framework=Expecto.verified.txt index 66bef4e..67cc38f 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.SolutionFiles_framework=Expecto.verified.txt +++ b/src/Wizard.Tests/Generation/GeneratorTests.SolutionFiles_framework=Expecto.verified.txt @@ -50,10 +50,6 @@ - - - - ==== nuget.config @@ -191,7 +187,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: Expecto * Build server: GitHub Actions - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -207,7 +203,6 @@ dotnet add package YoloDev.Expecto.TestSdk dotnet add package Expecto dotnet add package FSharp.Core dotnet add package Verify.Expecto -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -460,27 +455,6 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before the first verification. F# has no module initializers, so `Tests.fs` holds a lazy value that each test forces first: @@ -488,12 +462,6 @@ Verify is configured once, before the first verification. F# has no module initi ```fs let initialize = lazy ( - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact) - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins()) @@ -632,21 +600,10 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Run the tests from the solution directory with `dotnet test`. The test project runs on Microsoft.Testing.Platform (`global.json` sets the runner), so `dotnet run --project` on it also works. * Target framework `net10.0`, SDK pinned by `global.json` (10.0.401). * Packages use Central Package Management: add or change versions in `Directory.Packages.props`, and reference packages without a version. - * Verify packages: Verify.Expecto 1.0.0, Verify.DiffPlex 1.0.0. + * Verify packages: Verify.Expecto 1.0.0. * Verify is configured by the lazy `initialize` value in `Tests.fs`; every test forces it before verifying. * The Open Source Maintenance Fee declaration is in `Directory.Build.props` (Exempt: OpenSource). Do not remove it: without it every build fails with SC021. -## Verify plugins in this project - -### Verify.DiffPlex - - * Shows an inline diff in the failure message of a text snapshot, instead of both files in full. - * Repository: https://github.com/VerifyTests/Verify.DiffPlex - * Enabled in `ModuleInitializer.cs` by `VerifyDiffPlex.Initialize(OutputType.Compact);`. Do not move that call after `VerifierSettings.InitializePlugins()`. - * Needs `using VerifyTests.DiffPlex;` in the test file, not in global usings: plugins define colliding type names. - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Snapshot Testing (Verify) This project uses [Verify](https://github.com/VerifyTests/Verify) for snapshot testing. @@ -763,21 +720,10 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Run the tests from the solution directory with `dotnet test`. The test project runs on Microsoft.Testing.Platform (`global.json` sets the runner), so `dotnet run --project` on it also works. * Target framework `net10.0`, SDK pinned by `global.json` (10.0.401). * Packages use Central Package Management: add or change versions in `Directory.Packages.props`, and reference packages without a version. - * Verify packages: Verify.Expecto 1.0.0, Verify.DiffPlex 1.0.0. + * Verify packages: Verify.Expecto 1.0.0. * Verify is configured by the lazy `initialize` value in `Tests.fs`; every test forces it before verifying. * The Open Source Maintenance Fee declaration is in `Directory.Build.props` (Exempt: OpenSource). Do not remove it: without it every build fails with SC021. -## Verify plugins in this project - -### Verify.DiffPlex - - * Shows an inline diff in the failure message of a text snapshot, instead of both files in full. - * Repository: https://github.com/VerifyTests/Verify.DiffPlex - * Enabled in `ModuleInitializer.cs` by `VerifyDiffPlex.Initialize(OutputType.Compact);`. Do not move that call after `VerifierSettings.InitializePlugins()`. - * Needs `using VerifyTests.DiffPlex;` in the test file, not in global usings: plugins define colliding type names. - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Snapshot Testing (Verify) This project uses [Verify](https://github.com/VerifyTests/Verify) for snapshot testing. @@ -1007,7 +953,6 @@ public enum Title - @@ -1040,19 +985,13 @@ module Tests open System.Reflection open Expecto open VerifyTests -open VerifyTests.DiffPlex + open VerifyExpecto // F# has no module initializers, so each test forces this before verifying. It runs once. // Plugin samples are C# only (plan D9), but every selected plugin is still enabled here. let initialize = lazy ( - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact) - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins()) diff --git a/src/Wizard.Tests/Generation/GeneratorTests.SolutionFiles_framework=Fixie.verified.txt b/src/Wizard.Tests/Generation/GeneratorTests.SolutionFiles_framework=Fixie.verified.txt index d007203..f1340fa 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.SolutionFiles_framework=Fixie.verified.txt +++ b/src/Wizard.Tests/Generation/GeneratorTests.SolutionFiles_framework=Fixie.verified.txt @@ -46,10 +46,6 @@ - - - - ==== nuget.config @@ -187,7 +183,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: Fixie * Build server: GitHub Actions - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -202,7 +198,6 @@ Add the following packages to the test project. The solution uses [Central Packa dotnet add package Fixie.TestAdapter dotnet add package Microsoft.NET.Test.Sdk dotnet add package Verify.Fixie -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -431,44 +426,12 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before any test runs, in a [module initializer](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general#moduleinitializer-attribute). The solution's `ModuleInitializer.cs`: ```cs using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -476,12 +439,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); @@ -676,22 +633,10 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Run the tests from the solution directory with `dotnet test`. Fixie runs on VSTest, which is why `global.json` does not select the Microsoft.Testing.Platform runner. * Target framework `net10.0`, SDK pinned by `global.json` (10.0.401). * Packages use Central Package Management: add or change versions in `Directory.Packages.props`, and reference packages without a version. - * Verify packages: Verify.Fixie 1.0.0, Verify.DiffPlex 1.0.0. + * Verify packages: Verify.Fixie 1.0.0. * Verify is configured in `ModuleInitializer.cs` in the test project. Explicit plugin `Initialize` calls go before `VerifierSettings.InitializePlugins()`. * The Open Source Maintenance Fee declaration is in `Directory.Build.props` (Exempt: OpenSource). Do not remove it: without it every build fails with SC021. -## Verify plugins in this project - -### Verify.DiffPlex - - * Shows an inline diff in the failure message of a text snapshot, instead of both files in full. - * Repository: https://github.com/VerifyTests/Verify.DiffPlex - * Enabled in `ModuleInitializer.cs` by `VerifyDiffPlex.Initialize(OutputType.Compact);`. Do not move that call after `VerifierSettings.InitializePlugins()`. - * Samples: `Plugins/DiffPlexTests.cs`, using `PerTestOutput`. - * Needs `using VerifyTests.DiffPlex;` in the test file, not in global usings: plugins define colliding type names. - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Snapshot Testing (Verify) This project uses [Verify](https://github.com/VerifyTests/Verify) for snapshot testing. @@ -808,22 +753,10 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Run the tests from the solution directory with `dotnet test`. Fixie runs on VSTest, which is why `global.json` does not select the Microsoft.Testing.Platform runner. * Target framework `net10.0`, SDK pinned by `global.json` (10.0.401). * Packages use Central Package Management: add or change versions in `Directory.Packages.props`, and reference packages without a version. - * Verify packages: Verify.Fixie 1.0.0, Verify.DiffPlex 1.0.0. + * Verify packages: Verify.Fixie 1.0.0. * Verify is configured in `ModuleInitializer.cs` in the test project. Explicit plugin `Initialize` calls go before `VerifierSettings.InitializePlugins()`. * The Open Source Maintenance Fee declaration is in `Directory.Build.props` (Exempt: OpenSource). Do not remove it: without it every build fails with SC021. -## Verify plugins in this project - -### Verify.DiffPlex - - * Shows an inline diff in the failure message of a text snapshot, instead of both files in full. - * Repository: https://github.com/VerifyTests/Verify.DiffPlex - * Enabled in `ModuleInitializer.cs` by `VerifyDiffPlex.Initialize(OutputType.Compact);`. Do not move that call after `VerifierSettings.InitializePlugins()`. - * Samples: `Plugins/DiffPlexTests.cs`, using `PerTestOutput`. - * Needs `using VerifyTests.DiffPlex;` in the test file, not in global usings: plugins define colliding type names. - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Snapshot Testing (Verify) This project uses [Verify](https://github.com/VerifyTests/Verify) for snapshot testing. @@ -1044,7 +977,6 @@ public enum Title - @@ -1073,7 +1005,6 @@ public enum Title // Generated by the Verify wizard: https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=Fixie&ci=GitHubActions&sponsor=Exempt&exempt=OpenSource&until=2027-09 // Delete whatever is not needed. using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -1081,12 +1012,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); @@ -1176,30 +1101,3 @@ public sealed class TestCase(params object[] parameters) : public object[] Parameters { get; } = parameters; } -==== src/VerifySample.Tests/Plugins/DiffPlexTests.cs - -// Generated by the Verify wizard: https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=Fixie&ci=GitHubActions&sponsor=Exempt&exempt=OpenSource&until=2027-09 -// Delete whatever is not needed. -using VerifyTests.DiffPlex; - -// Verify.DiffPlex: Shows an inline diff in the failure message of a text snapshot, instead of both files in full. -// https://github.com/VerifyTests/Verify.DiffPlex -// Note: This changes only the failure message; what is written to a .verified. file is unaffected. -// Note: It is the default comparer for text. A plugin that registers a comparer for a specific -// file extension, such as html or json, takes precedence for that extension. -public class DiffPlexTests -{ - // The module initializer sets the mode for every test. UseDiffPlex overrides it for one, - // which is useful when a single snapshot is easier to read in full. - public Task PerTestOutput() - { - var target = "The text"; - return Verify(target) - .UseDiffPlex(OutputType.Full); - } -} - -==== src/VerifySample.Tests/Plugins/DiffPlexTests.PerTestOutput.verified.txt (UTF-8 with BOM) - -The text - diff --git a/src/Wizard.Tests/Generation/GeneratorTests.SolutionFiles_framework=MSTest.verified.txt b/src/Wizard.Tests/Generation/GeneratorTests.SolutionFiles_framework=MSTest.verified.txt index 55de003..89ee3d5 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.SolutionFiles_framework=MSTest.verified.txt +++ b/src/Wizard.Tests/Generation/GeneratorTests.SolutionFiles_framework=MSTest.verified.txt @@ -49,10 +49,6 @@ - - - - ==== nuget.config @@ -190,7 +186,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: MSTest * Build server: GitHub Actions - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -205,7 +201,6 @@ Add the following packages to the test project. The solution uses [Central Packa dotnet add package MSTest.TestAdapter dotnet add package MSTest.TestFramework dotnet add package Verify.MSTest -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -459,44 +454,12 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before any test runs, in a [module initializer](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general#moduleinitializer-attribute). The solution's `ModuleInitializer.cs`: ```cs using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -504,12 +467,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); @@ -686,22 +643,10 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Run the tests from the solution directory with `dotnet test`. The test project runs on Microsoft.Testing.Platform (`global.json` sets the runner), so `dotnet run --project` on it also works. * Target framework `net10.0`, SDK pinned by `global.json` (10.0.401). * Packages use Central Package Management: add or change versions in `Directory.Packages.props`, and reference packages without a version. - * Verify packages: Verify.MSTest 1.0.0, Verify.DiffPlex 1.0.0. + * Verify packages: Verify.MSTest 1.0.0. * Verify is configured in `ModuleInitializer.cs` in the test project. Explicit plugin `Initialize` calls go before `VerifierSettings.InitializePlugins()`. * The Open Source Maintenance Fee declaration is in `Directory.Build.props` (Exempt: OpenSource). Do not remove it: without it every build fails with SC021. -## Verify plugins in this project - -### Verify.DiffPlex - - * Shows an inline diff in the failure message of a text snapshot, instead of both files in full. - * Repository: https://github.com/VerifyTests/Verify.DiffPlex - * Enabled in `ModuleInitializer.cs` by `VerifyDiffPlex.Initialize(OutputType.Compact);`. Do not move that call after `VerifierSettings.InitializePlugins()`. - * Samples: `Plugins/DiffPlexTests.cs`, using `PerTestOutput`. - * Needs `using VerifyTests.DiffPlex;` in the test file, not in global usings: plugins define colliding type names. - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Snapshot Testing (Verify) This project uses [Verify](https://github.com/VerifyTests/Verify) for snapshot testing. @@ -818,22 +763,10 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Run the tests from the solution directory with `dotnet test`. The test project runs on Microsoft.Testing.Platform (`global.json` sets the runner), so `dotnet run --project` on it also works. * Target framework `net10.0`, SDK pinned by `global.json` (10.0.401). * Packages use Central Package Management: add or change versions in `Directory.Packages.props`, and reference packages without a version. - * Verify packages: Verify.MSTest 1.0.0, Verify.DiffPlex 1.0.0. + * Verify packages: Verify.MSTest 1.0.0. * Verify is configured in `ModuleInitializer.cs` in the test project. Explicit plugin `Initialize` calls go before `VerifierSettings.InitializePlugins()`. * The Open Source Maintenance Fee declaration is in `Directory.Build.props` (Exempt: OpenSource). Do not remove it: without it every build fails with SC021. -## Verify plugins in this project - -### Verify.DiffPlex - - * Shows an inline diff in the failure message of a text snapshot, instead of both files in full. - * Repository: https://github.com/VerifyTests/Verify.DiffPlex - * Enabled in `ModuleInitializer.cs` by `VerifyDiffPlex.Initialize(OutputType.Compact);`. Do not move that call after `VerifierSettings.InitializePlugins()`. - * Samples: `Plugins/DiffPlexTests.cs`, using `PerTestOutput`. - * Needs `using VerifyTests.DiffPlex;` in the test file, not in global usings: plugins define colliding type names. - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Snapshot Testing (Verify) This project uses [Verify](https://github.com/VerifyTests/Verify) for snapshot testing. @@ -1057,7 +990,6 @@ public enum Title - @@ -1086,7 +1018,6 @@ public enum Title // Generated by the Verify wizard: https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=MSTest&ci=GitHubActions&sponsor=Exempt&exempt=OpenSource&until=2027-09 // Delete whatever is not needed. using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -1094,12 +1025,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); @@ -1146,32 +1071,3 @@ public partial class VerifyChecksTests // every test class in the assembly; test classes must be partial. [assembly: UsesVerify] -==== src/VerifySample.Tests/Plugins/DiffPlexTests.cs - -// Generated by the Verify wizard: https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=MSTest&ci=GitHubActions&sponsor=Exempt&exempt=OpenSource&until=2027-09 -// Delete whatever is not needed. -using VerifyTests.DiffPlex; - -// Verify.DiffPlex: Shows an inline diff in the failure message of a text snapshot, instead of both files in full. -// https://github.com/VerifyTests/Verify.DiffPlex -// Note: This changes only the failure message; what is written to a .verified. file is unaffected. -// Note: It is the default comparer for text. A plugin that registers a comparer for a specific -// file extension, such as html or json, takes precedence for that extension. -[TestClass] -public partial class DiffPlexTests -{ - // The module initializer sets the mode for every test. UseDiffPlex overrides it for one, - // which is useful when a single snapshot is easier to read in full. - [TestMethod] - public Task PerTestOutput() - { - var target = "The text"; - return Verify(target) - .UseDiffPlex(OutputType.Full); - } -} - -==== src/VerifySample.Tests/Plugins/DiffPlexTests.PerTestOutput.verified.txt (UTF-8 with BOM) - -The text - diff --git a/src/Wizard.Tests/Generation/GeneratorTests.SolutionFiles_framework=NUnit.verified.txt b/src/Wizard.Tests/Generation/GeneratorTests.SolutionFiles_framework=NUnit.verified.txt index 5b439a9..1089734 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.SolutionFiles_framework=NUnit.verified.txt +++ b/src/Wizard.Tests/Generation/GeneratorTests.SolutionFiles_framework=NUnit.verified.txt @@ -49,10 +49,6 @@ - - - - ==== nuget.config @@ -190,7 +186,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: NUnit * Build server: GitHub Actions - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -205,7 +201,6 @@ Add the following packages to the test project. The solution uses [Central Packa dotnet add package NUnit dotnet add package NUnit3TestAdapter dotnet add package Verify.NUnit -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -459,44 +454,12 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before any test runs, in a [module initializer](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general#moduleinitializer-attribute). The solution's `ModuleInitializer.cs`: ```cs using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -504,12 +467,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); @@ -651,22 +608,10 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Run the tests from the solution directory with `dotnet test`. The test project runs on Microsoft.Testing.Platform (`global.json` sets the runner), so `dotnet run --project` on it also works. * Target framework `net10.0`, SDK pinned by `global.json` (10.0.401). * Packages use Central Package Management: add or change versions in `Directory.Packages.props`, and reference packages without a version. - * Verify packages: Verify.NUnit 1.0.0, Verify.DiffPlex 1.0.0. + * Verify packages: Verify.NUnit 1.0.0. * Verify is configured in `ModuleInitializer.cs` in the test project. Explicit plugin `Initialize` calls go before `VerifierSettings.InitializePlugins()`. * The Open Source Maintenance Fee declaration is in `Directory.Build.props` (Exempt: OpenSource). Do not remove it: without it every build fails with SC021. -## Verify plugins in this project - -### Verify.DiffPlex - - * Shows an inline diff in the failure message of a text snapshot, instead of both files in full. - * Repository: https://github.com/VerifyTests/Verify.DiffPlex - * Enabled in `ModuleInitializer.cs` by `VerifyDiffPlex.Initialize(OutputType.Compact);`. Do not move that call after `VerifierSettings.InitializePlugins()`. - * Samples: `Plugins/DiffPlexTests.cs`, using `PerTestOutput`. - * Needs `using VerifyTests.DiffPlex;` in the test file, not in global usings: plugins define colliding type names. - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Snapshot Testing (Verify) This project uses [Verify](https://github.com/VerifyTests/Verify) for snapshot testing. @@ -783,22 +728,10 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Run the tests from the solution directory with `dotnet test`. The test project runs on Microsoft.Testing.Platform (`global.json` sets the runner), so `dotnet run --project` on it also works. * Target framework `net10.0`, SDK pinned by `global.json` (10.0.401). * Packages use Central Package Management: add or change versions in `Directory.Packages.props`, and reference packages without a version. - * Verify packages: Verify.NUnit 1.0.0, Verify.DiffPlex 1.0.0. + * Verify packages: Verify.NUnit 1.0.0. * Verify is configured in `ModuleInitializer.cs` in the test project. Explicit plugin `Initialize` calls go before `VerifierSettings.InitializePlugins()`. * The Open Source Maintenance Fee declaration is in `Directory.Build.props` (Exempt: OpenSource). Do not remove it: without it every build fails with SC021. -## Verify plugins in this project - -### Verify.DiffPlex - - * Shows an inline diff in the failure message of a text snapshot, instead of both files in full. - * Repository: https://github.com/VerifyTests/Verify.DiffPlex - * Enabled in `ModuleInitializer.cs` by `VerifyDiffPlex.Initialize(OutputType.Compact);`. Do not move that call after `VerifierSettings.InitializePlugins()`. - * Samples: `Plugins/DiffPlexTests.cs`, using `PerTestOutput`. - * Needs `using VerifyTests.DiffPlex;` in the test file, not in global usings: plugins define colliding type names. - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Snapshot Testing (Verify) This project uses [Verify](https://github.com/VerifyTests/Verify) for snapshot testing. @@ -1022,7 +955,6 @@ public enum Title - @@ -1051,7 +983,6 @@ public enum Title // Generated by the Verify wizard: https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=NUnit&ci=GitHubActions&sponsor=Exempt&exempt=OpenSource&until=2027-09 // Delete whatever is not needed. using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -1059,12 +990,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); @@ -1103,32 +1028,3 @@ public class VerifyChecksTests VerifyChecks.Run(); } -==== src/VerifySample.Tests/Plugins/DiffPlexTests.cs - -// Generated by the Verify wizard: https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=NUnit&ci=GitHubActions&sponsor=Exempt&exempt=OpenSource&until=2027-09 -// Delete whatever is not needed. -using VerifyTests.DiffPlex; - -// Verify.DiffPlex: Shows an inline diff in the failure message of a text snapshot, instead of both files in full. -// https://github.com/VerifyTests/Verify.DiffPlex -// Note: This changes only the failure message; what is written to a .verified. file is unaffected. -// Note: It is the default comparer for text. A plugin that registers a comparer for a specific -// file extension, such as html or json, takes precedence for that extension. -[TestFixture] -public class DiffPlexTests -{ - // The module initializer sets the mode for every test. UseDiffPlex overrides it for one, - // which is useful when a single snapshot is easier to read in full. - [Test] - public Task PerTestOutput() - { - var target = "The text"; - return Verify(target) - .UseDiffPlex(OutputType.Full); - } -} - -==== src/VerifySample.Tests/Plugins/DiffPlexTests.PerTestOutput.verified.txt (UTF-8 with BOM) - -The text - diff --git a/src/Wizard.Tests/Generation/GeneratorTests.SolutionFiles_framework=TUnit.verified.txt b/src/Wizard.Tests/Generation/GeneratorTests.SolutionFiles_framework=TUnit.verified.txt index 688142b..e86d4f7 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.SolutionFiles_framework=TUnit.verified.txt +++ b/src/Wizard.Tests/Generation/GeneratorTests.SolutionFiles_framework=TUnit.verified.txt @@ -48,10 +48,6 @@ - - - - ==== nuget.config @@ -189,7 +185,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: TUnit * Build server: GitHub Actions - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -203,7 +199,6 @@ Add the following packages to the test project. The solution uses [Central Packa ``` dotnet add package TUnit dotnet add package Verify.TUnit -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -447,44 +442,12 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before any test runs, in a [module initializer](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general#moduleinitializer-attribute). The solution's `ModuleInitializer.cs`: ```cs using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -492,12 +455,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); @@ -638,22 +595,10 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Run the tests from the solution directory with `dotnet test`. The test project runs on Microsoft.Testing.Platform (`global.json` sets the runner), so `dotnet run --project` on it also works. * Target framework `net10.0`, SDK pinned by `global.json` (10.0.401). * Packages use Central Package Management: add or change versions in `Directory.Packages.props`, and reference packages without a version. - * Verify packages: Verify.TUnit 1.0.0, Verify.DiffPlex 1.0.0. + * Verify packages: Verify.TUnit 1.0.0. * Verify is configured in `ModuleInitializer.cs` in the test project. Explicit plugin `Initialize` calls go before `VerifierSettings.InitializePlugins()`. * The Open Source Maintenance Fee declaration is in `Directory.Build.props` (Exempt: OpenSource). Do not remove it: without it every build fails with SC021. -## Verify plugins in this project - -### Verify.DiffPlex - - * Shows an inline diff in the failure message of a text snapshot, instead of both files in full. - * Repository: https://github.com/VerifyTests/Verify.DiffPlex - * Enabled in `ModuleInitializer.cs` by `VerifyDiffPlex.Initialize(OutputType.Compact);`. Do not move that call after `VerifierSettings.InitializePlugins()`. - * Samples: `Plugins/DiffPlexTests.cs`, using `PerTestOutput`. - * Needs `using VerifyTests.DiffPlex;` in the test file, not in global usings: plugins define colliding type names. - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Snapshot Testing (Verify) This project uses [Verify](https://github.com/VerifyTests/Verify) for snapshot testing. @@ -770,22 +715,10 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Run the tests from the solution directory with `dotnet test`. The test project runs on Microsoft.Testing.Platform (`global.json` sets the runner), so `dotnet run --project` on it also works. * Target framework `net10.0`, SDK pinned by `global.json` (10.0.401). * Packages use Central Package Management: add or change versions in `Directory.Packages.props`, and reference packages without a version. - * Verify packages: Verify.TUnit 1.0.0, Verify.DiffPlex 1.0.0. + * Verify packages: Verify.TUnit 1.0.0. * Verify is configured in `ModuleInitializer.cs` in the test project. Explicit plugin `Initialize` calls go before `VerifierSettings.InitializePlugins()`. * The Open Source Maintenance Fee declaration is in `Directory.Build.props` (Exempt: OpenSource). Do not remove it: without it every build fails with SC021. -## Verify plugins in this project - -### Verify.DiffPlex - - * Shows an inline diff in the failure message of a text snapshot, instead of both files in full. - * Repository: https://github.com/VerifyTests/Verify.DiffPlex - * Enabled in `ModuleInitializer.cs` by `VerifyDiffPlex.Initialize(OutputType.Compact);`. Do not move that call after `VerifierSettings.InitializePlugins()`. - * Samples: `Plugins/DiffPlexTests.cs`, using `PerTestOutput`. - * Needs `using VerifyTests.DiffPlex;` in the test file, not in global usings: plugins define colliding type names. - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Snapshot Testing (Verify) This project uses [Verify](https://github.com/VerifyTests/Verify) for snapshot testing. @@ -1005,7 +938,6 @@ public enum Title - @@ -1034,7 +966,6 @@ public enum Title // Generated by the Verify wizard: https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=TUnit&ci=GitHubActions&sponsor=Exempt&exempt=OpenSource&until=2027-09 // Delete whatever is not needed. using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -1042,12 +973,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); @@ -1084,31 +1009,3 @@ public class VerifyChecksTests VerifyChecks.Run(); } -==== src/VerifySample.Tests/Plugins/DiffPlexTests.cs - -// Generated by the Verify wizard: https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=TUnit&ci=GitHubActions&sponsor=Exempt&exempt=OpenSource&until=2027-09 -// Delete whatever is not needed. -using VerifyTests.DiffPlex; - -// Verify.DiffPlex: Shows an inline diff in the failure message of a text snapshot, instead of both files in full. -// https://github.com/VerifyTests/Verify.DiffPlex -// Note: This changes only the failure message; what is written to a .verified. file is unaffected. -// Note: It is the default comparer for text. A plugin that registers a comparer for a specific -// file extension, such as html or json, takes precedence for that extension. -public class DiffPlexTests -{ - // The module initializer sets the mode for every test. UseDiffPlex overrides it for one, - // which is useful when a single snapshot is easier to read in full. - [Test] - public Task PerTestOutput() - { - var target = "The text"; - return Verify(target) - .UseDiffPlex(OutputType.Full); - } -} - -==== src/VerifySample.Tests/Plugins/DiffPlexTests.PerTestOutput.verified.txt (UTF-8 with BOM) - -The text - diff --git a/src/Wizard.Tests/Generation/GeneratorTests.SolutionFiles_framework=XunitV3.verified.txt b/src/Wizard.Tests/Generation/GeneratorTests.SolutionFiles_framework=XunitV3.verified.txt index 0d6d8ad..ce587bf 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.SolutionFiles_framework=XunitV3.verified.txt +++ b/src/Wizard.Tests/Generation/GeneratorTests.SolutionFiles_framework=XunitV3.verified.txt @@ -48,10 +48,6 @@ - - - - ==== nuget.config @@ -189,7 +185,7 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Package management: Prefer CLI * Test framework: xUnit v3 * Build server: GitHub Actions - * Plugins: DiffPlex (verbose) + * Plugins: none * Maintenance fee: Exempt: OpenSource * .NET: net10.0 (SDK 10.0.401) * Package versions: the newest stable releases as of 2026-09-22; nuget.org was not checked when this was generated @@ -203,7 +199,6 @@ Add the following packages to the test project. The solution uses [Central Packa ``` dotnet add package Verify.XunitV3 dotnet add package xunit.v3 -dotnet add package Verify.DiffPlex ``` With Central Package Management enabled, `dotnet add package` writes the version to `Directory.Packages.props`. @@ -455,44 +450,12 @@ The solution installs it as a local tool in `.config/dotnet-tools.json`, so `dot dotnet tool install -g verify.tool ``` -## Plugins - -Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else. - -### Verify.DiffPlex - -Shows an inline diff in the failure message of a text snapshot, instead of both files in full. ([repository](https://github.com/VerifyTests/Verify.DiffPlex)) - -Package: `Verify.DiffPlex` 1.0.0. - -Enabled by: - -```cs -VerifyDiffPlex.Initialize(OutputType.Compact); -``` - -`Plugins/DiffPlexTests.cs` in the download shows every documented API: - -**PerTestOutput** — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full. - -```cs -var target = "The text"; -return Verify(target) - .UseDiffPlex(OutputType.Full); -``` - -Notes: - - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Initialization Verify is configured once, before any test runs, in a [module initializer](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general#moduleinitializer-attribute). The solution's `ModuleInitializer.cs`: ```cs using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -500,12 +463,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); @@ -646,22 +603,10 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Run the tests from the solution directory with `dotnet test`. The test project runs on Microsoft.Testing.Platform (`global.json` sets the runner), so `dotnet run --project` on it also works. * Target framework `net10.0`, SDK pinned by `global.json` (10.0.401). * Packages use Central Package Management: add or change versions in `Directory.Packages.props`, and reference packages without a version. - * Verify packages: Verify.XunitV3 1.0.0, Verify.DiffPlex 1.0.0. + * Verify packages: Verify.XunitV3 1.0.0. * Verify is configured in `ModuleInitializer.cs` in the test project. Explicit plugin `Initialize` calls go before `VerifierSettings.InitializePlugins()`. * The Open Source Maintenance Fee declaration is in `Directory.Build.props` (Exempt: OpenSource). Do not remove it: without it every build fails with SC021. -## Verify plugins in this project - -### Verify.DiffPlex - - * Shows an inline diff in the failure message of a text snapshot, instead of both files in full. - * Repository: https://github.com/VerifyTests/Verify.DiffPlex - * Enabled in `ModuleInitializer.cs` by `VerifyDiffPlex.Initialize(OutputType.Compact);`. Do not move that call after `VerifierSettings.InitializePlugins()`. - * Samples: `Plugins/DiffPlexTests.cs`, using `PerTestOutput`. - * Needs `using VerifyTests.DiffPlex;` in the test file, not in global usings: plugins define colliding type names. - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Snapshot Testing (Verify) This project uses [Verify](https://github.com/VerifyTests/Verify) for snapshot testing. @@ -778,22 +723,10 @@ Generated by the [Verify wizard](https://verifytests.github.io/Wizard/new?step=o * Run the tests from the solution directory with `dotnet test`. The test project runs on Microsoft.Testing.Platform (`global.json` sets the runner), so `dotnet run --project` on it also works. * Target framework `net10.0`, SDK pinned by `global.json` (10.0.401). * Packages use Central Package Management: add or change versions in `Directory.Packages.props`, and reference packages without a version. - * Verify packages: Verify.XunitV3 1.0.0, Verify.DiffPlex 1.0.0. + * Verify packages: Verify.XunitV3 1.0.0. * Verify is configured in `ModuleInitializer.cs` in the test project. Explicit plugin `Initialize` calls go before `VerifierSettings.InitializePlugins()`. * The Open Source Maintenance Fee declaration is in `Directory.Build.props` (Exempt: OpenSource). Do not remove it: without it every build fails with SC021. -## Verify plugins in this project - -### Verify.DiffPlex - - * Shows an inline diff in the failure message of a text snapshot, instead of both files in full. - * Repository: https://github.com/VerifyTests/Verify.DiffPlex - * Enabled in `ModuleInitializer.cs` by `VerifyDiffPlex.Initialize(OutputType.Compact);`. Do not move that call after `VerifierSettings.InitializePlugins()`. - * Samples: `Plugins/DiffPlexTests.cs`, using `PerTestOutput`. - * Needs `using VerifyTests.DiffPlex;` in the test file, not in global usings: plugins define colliding type names. - * This changes only the failure message; what is written to a `.verified.` file is unaffected. - * It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension. - ## Snapshot Testing (Verify) This project uses [Verify](https://github.com/VerifyTests/Verify) for snapshot testing. @@ -1011,16 +944,10 @@ public enum Title VerifySample.Tests Exe - - - - - $(NoWarn);xUnit1051 - @@ -1049,7 +976,6 @@ public enum Title // Generated by the Verify wizard: https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions&sponsor=Exempt&exempt=OpenSource&until=2027-09 // Delete whatever is not needed. using System.Runtime.CompilerServices; -using VerifyTests.DiffPlex; // Everything here runs once, when the test assembly loads, before any test. public static class ModuleInitializer @@ -1057,12 +983,6 @@ public static class ModuleInitializer [ModuleInitializer] public static void Initialize() { - // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline - // diff instead of the whole received and verified text. - // OutputType.Compact prints only the changed lines, with a line of context either side. - // Alternatives: OutputType.Full, OutputType.Minimal. - VerifyDiffPlex.Initialize(OutputType.Compact); - // Initializes every Verify.* plugin the project references and has not initialized above. // Explicit calls come first so their parameters apply: a plugin can only be initialized once. VerifierSettings.InitializePlugins(); @@ -1099,31 +1019,3 @@ public class VerifyChecksTests VerifyChecks.Run(); } -==== src/VerifySample.Tests/Plugins/DiffPlexTests.cs - -// Generated by the Verify wizard: https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions&sponsor=Exempt&exempt=OpenSource&until=2027-09 -// Delete whatever is not needed. -using VerifyTests.DiffPlex; - -// Verify.DiffPlex: Shows an inline diff in the failure message of a text snapshot, instead of both files in full. -// https://github.com/VerifyTests/Verify.DiffPlex -// Note: This changes only the failure message; what is written to a .verified. file is unaffected. -// Note: It is the default comparer for text. A plugin that registers a comparer for a specific -// file extension, such as html or json, takes precedence for that extension. -public class DiffPlexTests -{ - // The module initializer sets the mode for every test. UseDiffPlex overrides it for one, - // which is useful when a single snapshot is easier to read in full. - [Fact] - public Task PerTestOutput() - { - var target = "The text"; - return Verify(target) - .UseDiffPlex(OutputType.Full); - } -} - -==== src/VerifySample.Tests/Plugins/DiffPlexTests.PerTestOutput.verified.txt (UTF-8 with BOM) - -The text - diff --git a/src/Wizard.Tests/Generation/GeneratorTests.cs b/src/Wizard.Tests/Generation/GeneratorTests.cs index ff0d084..11571f1 100644 --- a/src/Wizard.Tests/Generation/GeneratorTests.cs +++ b/src/Wizard.Tests/Generation/GeneratorTests.cs @@ -91,8 +91,8 @@ public Task Ai(TestFramework framework) => .UseParameters(framework); /// - /// Inline snapshots (plan 12.8): the initializer switch, the core and DiffPlex samples carrying - /// their snapshots as literals, no verified files, and the guide and AI text that go with them. + /// Inline snapshots (plan 12.8): the initializer switch, the core sample carrying its snapshot as + /// a literal, no verified files, and the guide and AI text that go with them. /// [Test] [Arguments(TestFramework.XunitV3)] @@ -113,10 +113,6 @@ public Task Inline(TestFramework framework) .UseParameters(framework); } - [Test] - public Task InlineAddition() => - Verify(Render(SolutionGenerator.Build(PlanFor(Addition(Flow.Add, [], ["DiffPlex"]) with {InlineSnapshots = true})))); - /// Visual Studio without ReSharper, and no build server, drop the JetBrains settings and the build definition. [Test] public Task SolutionFileListMinimal() => @@ -239,10 +235,10 @@ public Task Plugin((string Id, Depth Depth) plugin) /// The combinations the interaction rules exist for (plan 17.1). public static IEnumerable> Combinations() { - yield return () => ("EfAndSql", ["DiffPlex", "EntityFramework", "SqlServer"]); - yield return () => ("BunitAndAngleSharp", ["AngleSharp", "Bunit", "DiffPlex"]); + yield return () => ("EfAndSql", ["EntityFramework", "SqlServer"]); + yield return () => ("BunitAndAngleSharp", ["AngleSharp", "Bunit"]); yield return () => ("Recording", ["EntityFramework", "Http", "MicrosoftLogging", "SqlServer"]); - yield return () => ("Windows", ["DiffPlex", "WinForms", "Xaml"]); + yield return () => ("Windows", ["WinForms", "Xaml"]); yield return () => ("Everything", [.. Plugins.All.Select(_ => _.Id)]); } @@ -290,7 +286,7 @@ public async Task ConflictingSelectionStillGenerates() { // The case the interaction rules were written for: EF Core added next to an existing SqlServer, // whose recording the project's own initializer now has to turn off. - ["EfNextToExistingSql"] = () => Addition(Flow.Add, ["DiffPlex", "SqlServer"], ["EntityFramework"]), + ["EfNextToExistingSql"] = () => Addition(Flow.Add, ["SqlServer"], ["EntityFramework"]), // An existing plugin plugin discovery never found, which the project may never have enabled. ["ExistingUndiscovered"] = () => Addition(Flow.Add, ["AngleSharp"], ["Bunit"]), // A package with a maintenance fee check of its own, into a project whose Verify declaration @@ -306,7 +302,7 @@ public async Task ConflictingSelectionStillGenerates() ["Expecto"] = () => Addition(Flow.Add, [], ["Http", "EntityFramework"], TestFramework.Expecto), ["ByTech"] = () => { - var state = Addition(Flow.AddByTech, ["DiffPlex"], []); + var state = Addition(Flow.AddByTech, [], []); TechSuggestions.Choose(state, "aspnetcore", true); return state; } diff --git a/src/Wizard.Tests/Integration/GeneratedSolutionTests.cs b/src/Wizard.Tests/Integration/GeneratedSolutionTests.cs index 392872a..78f5ada 100644 --- a/src/Wizard.Tests/Integration/GeneratedSolutionTests.cs +++ b/src/Wizard.Tests/Integration/GeneratedSolutionTests.cs @@ -24,16 +24,10 @@ public async Task CoreSolutionBuildsAndPasses(TestFramework framework, bool inli var received = Directory.EnumerateFiles(directory, "*.received.*", SearchOption.AllDirectories).ToList(); await Assert.That(received).IsEmpty(); - // An undiscovered test is not a failure, so count them: the core sample, the conventions check, - // and every plugin sample that ships its snapshot. The default selection is Verify.DiffPlex, - // whose sample verifies a literal string, so a first run of the download is green. With - // inline snapshots the same samples pass, carrying their snapshots as literals. - var expected = 2 + Plan - .Build(state, PackageVersions.Baked, Date.FromDateTime(DateTime.UtcNow)) - .Plugins - .SelectMany(_ => _.Samples) - .Count(_ => _.VerifiedOutput != null); - await Assert.That(PassedCount(output)).IsEqualTo(expected).Because(output); + // An undiscovered test is not a failure, so count them: the core sample, whose snapshot ships + // (plan D6), and the conventions check. With inline snapshots the core sample passes too, + // carrying its snapshot as a literal. + await Assert.That(PassedCount(output)).IsEqualTo(2).Because(output); } /// @@ -81,12 +75,12 @@ public async Task CombinationBuilds((string Name, string[] Ids) combination) public static IEnumerable> Combinations() { - yield return () => ("EfAndSql", ["DiffPlex", "EntityFramework", "SqlServer"]); - yield return () => ("BunitAndAngleSharp", ["AngleSharp", "Bunit", "DiffPlex"]); + yield return () => ("EfAndSql", ["EntityFramework", "SqlServer"]); + yield return () => ("BunitAndAngleSharp", ["AngleSharp", "Bunit"]); // Blazor's Render initializes the plugin from its static constructor, which throws once any // verification has run, so the core sample and a Blazor test in one assembly is the case to // prove (plan A2). - yield return () => ("BlazorAndCore", ["AngleSharp", "Blazor", "DiffPlex"]); + yield return () => ("BlazorAndCore", ["AngleSharp", "Blazor"]); // Both define PagesToInclude and SkipPdfNormalization in the VerifyTests namespace (plan A6). yield return () => ("QuestPdfAndPdfPig", ["PdfPig", "QuestPDF"]); // Verify.Flurl is built against an older Verify.Http than the one pinned here (plan A11). diff --git a/src/Wizard.Tests/Model/BrowserMemoryTests.cs b/src/Wizard.Tests/Model/BrowserMemoryTests.cs index c4c5b3d..ac2473f 100644 --- a/src/Wizard.Tests/Model/BrowserMemoryTests.cs +++ b/src/Wizard.Tests/Model/BrowserMemoryTests.cs @@ -23,14 +23,14 @@ public async Task RememberedAnswersFillInWhatTheUrlLeavesOut() [Test] public async Task TheUrlWins() { - const string query = "tf=XunitV3&tech=stj&have=DiffPlex&sponsor=Ignore"; + const string query = "tf=XunitV3&tech=stj&have=AngleSharp&sponsor=Ignore"; var state = WizardStateUrl.Parse(Flow.AddByTech, query); var restored = BrowserMemory.Seed(state, query, everything); await Assert.That(restored.Any).IsFalse(); await Assert.That(state.Techs).IsEquivalentTo(["stj"]); - await Assert.That(state.ExistingPlugins).IsEquivalentTo(["DiffPlex"]); + await Assert.That(state.ExistingPlugins).IsEquivalentTo(["AngleSharp"]); await Assert.That(state.SponsorMode).IsEqualTo(SponsorMode.Ignore); } diff --git a/src/Wizard.Tests/Model/WizardStateUrlTests.Urls.verified.txt b/src/Wizard.Tests/Model/WizardStateUrlTests.Urls.verified.txt index 1dc8777..c915af9 100644 --- a/src/Wizard.Tests/Model/WizardStateUrlTests.Urls.verified.txt +++ b/src/Wizard.Tests/Model/WizardStateUrlTests.Urls.verified.txt @@ -5,10 +5,10 @@ https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions&sponsor=Sponsor&account=acme&start=2026-09-01&private=2027-01, https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions&sponsor=Private&until=2027-06, https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions&sponsor=Ignore, - https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions&ext=none&sponsor=Exempt&exempt=OpenSource&until=2027-09, + https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions&sponsor=Exempt&exempt=OpenSource&until=2027-09, https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions&ext=EntityFramework,SqlServer&sponsor=Exempt&exempt=OpenSource&until=2027-09, - https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions&ext=AngleSharp,DiffPlex&min=AngleSharp&opt=diffplex-output:Full&sponsor=Exempt&exempt=OpenSource&until=2027-09, + https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions&ext=AngleSharp,EntityFramework&min=AngleSharp&opt=ef-sql-format:false&sponsor=Exempt&exempt=OpenSource&until=2027-09, https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions&inline=true&sponsor=Exempt&exempt=OpenSource&until=2027-09, https://verifytests.github.io/Wizard/add?step=output&tf=XunitV3&have=SqlServer&ext=EntityFramework, - https://verifytests.github.io/Wizard/add/by-tech?step=output&tf=XunitV3&tech=aspnetcore,http&have=DiffPlex&ext=Http + https://verifytests.github.io/Wizard/add/by-tech?step=output&tf=XunitV3&tech=aspnetcore,http&have=AngleSharp&ext=Http ] \ No newline at end of file diff --git a/src/Wizard.Tests/Model/WizardStateUrlTests.cs b/src/Wizard.Tests/Model/WizardStateUrlTests.cs index cb12cfa..57839e2 100644 --- a/src/Wizard.Tests/Model/WizardStateUrlTests.cs +++ b/src/Wizard.Tests/Model/WizardStateUrlTests.cs @@ -35,9 +35,9 @@ public static IEnumerable> States() yield return () => GeneratorTests.WithPlugins(GeneratorTests.State(), "EntityFramework", "SqlServer"); yield return () => { - var state = GeneratorTests.WithPlugins(GeneratorTests.State(), "AngleSharp", "DiffPlex"); + var state = GeneratorTests.WithPlugins(GeneratorTests.State(), "AngleSharp", "EntityFramework"); state.SetDepth("AngleSharp", Depth.Minimal); - state.SetChoice("diffplex-output", "Full"); + state.SetChoice("ef-sql-format", "false"); return state; }; yield return () => GeneratorTests.State() with @@ -47,13 +47,13 @@ public static IEnumerable> States() yield return () => GeneratorTests.Addition(Flow.Add, ["SqlServer"], ["EntityFramework"]); yield return () => { - var state = GeneratorTests.Addition(Flow.AddByTech, ["DiffPlex"], ["Http"]); + var state = GeneratorTests.Addition(Flow.AddByTech, ["AngleSharp"], ["Http"]); state.Techs = new HashSet(["http", "aspnetcore"], StringComparer.Ordinal); return state; }; } - /// The add flows start from nothing, rather than from Verify.DiffPlex (plan 7.2). + /// The add flows start from nothing (plan 7.2). [Test] public async Task AddFlowsStartWithNothingSelected() { @@ -77,29 +77,48 @@ public async Task QuestionsAFlowDoesNotAskAreDropped() await Assert.That(created.ExistingPlugins).IsEmpty(); } - /// - /// An absent ext key means the default selection, not an empty one, so a link made before the - /// plugin step existed still generates what it used to. - /// + /// A new project starts from nothing too, and a link that selects nothing has no ext key. [Test] - public async Task AbsentPluginsMeansTheDefault() + public async Task NewProjectStartsWithNothingSelected() { var state = WizardStateUrl.Parse(Flow.New, "os=Windows"); - await Assert.That(state.SelectedPlugins).IsEquivalentTo(WizardState.DefaultPlugins(Flow.New)); + await Assert.That(state.SelectedPlugins).IsEmpty(); + await Assert.That(WizardStateUrl.ToQuery(state)).DoesNotContain("ext="); } + /// + /// Links wrote ext=none while a new project started with Verify.DiffPlex selected. It still reads + /// as nothing selected, and is not written any more. + /// [Test] public async Task NoneMeansNothingSelected() { var state = WizardStateUrl.Parse(Flow.New, $"os=Windows&ext={WizardStateUrl.NoPlugins}"); await Assert.That(state.SelectedPlugins).IsEmpty(); + await Assert.That(WizardStateUrl.ToQuery(state)).DoesNotContain("ext="); + } + + /// + /// DiffPlex was a plugin until Verify showed a text diff itself, so older links carry it in ext, + /// min, opt and have. All of it is dropped, and the rest of the link still applies. + /// + [Test] + public async Task RemovedDiffPlexIsDropped() + { + var state = WizardStateUrl.Parse(Flow.New, "ext=DiffPlex,Http&min=DiffPlex&opt=diffplex-output:Full"); + await Assert.That(state.SelectedPlugins).IsEquivalentTo(["Http"]); + await Assert.That(state.Depths).IsEmpty(); + await Assert.That(state.Choices).IsEmpty(); + + var added = WizardStateUrl.Parse(Flow.Add, "have=DiffPlex,SqlServer"); + await Assert.That(added.ExistingPlugins).IsEquivalentTo(["SqlServer"]); } [Test] public async Task UnknownPluginsAndStaleOptionsAreDropped() { - var state = WizardStateUrl.Parse(Flow.New, "ext=DiffPlex,NotAPlugin&min=NotAPlugin&opt=nope:1"); - await Assert.That(state.SelectedPlugins).IsEquivalentTo(["DiffPlex"]); + var state = WizardStateUrl.Parse(Flow.New, "ext=Http,NotAPlugin&min=NotAPlugin&opt=nope:1"); + await Assert.That(state.SelectedPlugins).IsEquivalentTo(["Http"]); await Assert.That(state.Depths).IsEmpty(); await Assert.That(state.Choices).IsEmpty(); } @@ -108,8 +127,8 @@ public async Task UnknownPluginsAndStaleOptionsAreDropped() [Test] public async Task PluginOrderIsTheRegistryOrder() { - var one = WizardStateUrl.Parse(Flow.New, "ext=SqlServer,DiffPlex"); - var other = WizardStateUrl.Parse(Flow.New, "ext=DiffPlex,SqlServer"); + var one = WizardStateUrl.Parse(Flow.New, "ext=SqlServer,Http"); + var other = WizardStateUrl.Parse(Flow.New, "ext=Http,SqlServer"); await Assert.That(WizardStateUrl.ToQuery(one)).IsEqualTo(WizardStateUrl.ToQuery(other)); } diff --git a/src/Wizard.Tests/ModuleInitializer.cs b/src/Wizard.Tests/ModuleInitializer.cs index 42aed75..227153e 100644 --- a/src/Wizard.Tests/ModuleInitializer.cs +++ b/src/Wizard.Tests/ModuleInitializer.cs @@ -1,12 +1,9 @@ -using VerifyTests.DiffPlex; - static class ModuleInitializer { [ModuleInitializer] public static void Init() { VerifyPlaywright.Initialize(); - VerifyDiffPlex.Initialize(OutputType.Compact); VerifierSettings.InitializePlugins(); // Playwright hands back the page markup as one long line, which makes a snapshot diff diff --git a/src/Wizard.Tests/Pages/AddTests.cs b/src/Wizard.Tests/Pages/AddTests.cs index 5366d16..dde3d17 100644 --- a/src/Wizard.Tests/Pages/AddTests.cs +++ b/src/Wizard.Tests/Pages/AddTests.cs @@ -101,10 +101,10 @@ public async Task ChoosingATechSelectsItsRecommendations() [Test] public async Task RememberedAnswersAreRestored() { - Remember(BrowserMemory.ExistingKey, "SqlServer,DiffPlex"); + Remember(BrowserMemory.ExistingKey, "SqlServer,AngleSharp"); var page = OpenAdd("add?step=have&tf=XunitV3"); - await Assert.That(CurrentUrl).IsEqualTo("add?step=have&tf=XunitV3&have=DiffPlex,SqlServer"); + await Assert.That(CurrentUrl).IsEqualTo("add?step=have&tf=XunitV3&have=AngleSharp,SqlServer"); await Assert.That(page.Find(".restored").TextContent).IsEqualTo("Restored from this browser."); } diff --git a/src/Wizard.Tests/Pages/NewTests.cs b/src/Wizard.Tests/Pages/NewTests.cs index 92f0b91..4dbfffd 100644 --- a/src/Wizard.Tests/Pages/NewTests.cs +++ b/src/Wizard.Tests/Pages/NewTests.cs @@ -103,32 +103,21 @@ await page.Find(".plugin-card[data-id=AngleSharp] input") { Value = true }); - await Assert.That(CurrentUrl).Contains("&ext=AngleSharp,DiffPlex"); + await Assert.That(CurrentUrl).Contains("&ext=AngleSharp"); - await page.Find(".plugin-card[data-id=DiffPlex] input") + // Nothing selected is the default, so the url drops the key rather than saying so. + await page.Find(".plugin-card[data-id=AngleSharp] input") .ChangeAsync( new() {Value = false}); - await Assert.That(CurrentUrl).Contains("&ext=AngleSharp"); - } - - /// Nothing selected is a real answer, and the url has to say so, not read as the default. - [Test] - public async Task DeselectingEverythingIsCarriedInTheUrl() - { - var page = Open("new?step=plugins&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=None"); - await page.Find(".plugin-card[data-id=DiffPlex] input") - .ChangeAsync( - new() - {Value = false}); - await Assert.That(CurrentUrl).Contains("&ext=none"); + await Assert.That(CurrentUrl).DoesNotContain("ext="); } /// A Windows-only plugin is greyed out on another OS, says why, and is dropped from the url. [Test] public async Task WindowsOnlyPluginsAreUnavailableOffWindows() { - var page = Open("new?step=plugins&os=Linux&ide=Rider&cli=Cli&tf=XunitV3&ci=None&ext=DiffPlex,WinForms"); + var page = Open("new?step=plugins&os=Linux&ide=Rider&cli=Cli&tf=XunitV3&ci=None&ext=Http,WinForms"); await Assert.That(CurrentUrl).DoesNotContain("WinForms"); var card = page.Find(".plugin-card[data-id=WinForms]"); @@ -141,7 +130,7 @@ public async Task WindowsOnlyPluginsAreUnavailableOffWindows() [Test] public async Task PluginsTheFrameworkCannotRunAreUnavailable() { - var page = Open("new?step=plugins&os=Windows&ide=Rider&cli=Cli&tf=TUnit&ci=None&ext=DiffPlex,Avalonia"); + var page = Open("new?step=plugins&os=Windows&ide=Rider&cli=Cli&tf=TUnit&ci=None&ext=Http,Avalonia"); await Assert.That(CurrentUrl).DoesNotContain("Avalonia"); var card = page.Find(".plugin-card[data-id=Avalonia]"); diff --git a/src/Wizard.Tests/Registry/RegistryTests.Registry.verified.txt b/src/Wizard.Tests/Registry/RegistryTests.Registry.verified.txt index 4df08df..196cc70 100644 --- a/src/Wizard.Tests/Registry/RegistryTests.Registry.verified.txt +++ b/src/Wizard.Tests/Registry/RegistryTests.Registry.verified.txt @@ -327,28 +327,6 @@ StopRecording ] }, - { - Id: DiffPlex, - DisplayName: Verify.DiffPlex, - Platform: CrossPlatform, - Packages: [ - Verify.DiffPlex - ], - PluginType: VerifyDiffPlex, - DiscoveredByInitializePlugins: true, - Initialize: [ - VerifyDiffPlex.Initialize(OutputType.{diffplex-output}); - ], - Usings: [ - VerifyTests.DiffPlex - ], - Choices: [ - diffplex-output - ], - Minimal: [ - PerTestOutput - ] - }, { Id: DocNet, DisplayName: Verify.DocNet, diff --git a/src/Wizard.Tests/Registry/RegistryTests.Rules.verified.txt b/src/Wizard.Tests/Registry/RegistryTests.Rules.verified.txt index 197d732..b37a2e4 100644 --- a/src/Wizard.Tests/Registry/RegistryTests.Rules.verified.txt +++ b/src/Wizard.Tests/Registry/RegistryTests.Rules.verified.txt @@ -240,19 +240,6 @@ AnyCount: 2, RetiredBy: U25 }, - { - Id: diffplex-default-comparer, - All: [ - DiffPlex - ], - Any: [ - AngleSharp, - Bunit, - ImageMagick, - Quibble - ], - AnyCount: 1 - }, { Id: readable-expressions-priority, All: [ diff --git a/src/Wizard.Tests/Registry/RegistryTests.cs b/src/Wizard.Tests/Registry/RegistryTests.cs index 87560b0..1fe4087 100644 --- a/src/Wizard.Tests/Registry/RegistryTests.cs +++ b/src/Wizard.Tests/Registry/RegistryTests.cs @@ -224,20 +224,6 @@ await Assert.That(choice) } } - /// - /// Shipping a snapshot for a test that never runs would leave a file nothing can ever confirm, and - /// Verify's conventions check reports a verified file with no test behind it. - /// - [Test] - public async Task ShippedSnapshotsBelongToSamplesThatRun() - { - var contradictions = Plugins.All - .SelectMany(_ => _.SamplesFor(Depth.Verbose).Select(sample => (_.Id, sample))) - .Where(_ => _.sample.VerifiedOutput != null && _.sample.SkipReason != null) - .Select(_ => $"{_.Id}.{_.sample.Name}"); - await Assert.That(contradictions).IsEmpty(); - } - /// A package that carries another owner's fee gate has to name it, or the build fails SC021. [Test] public async Task SponsorOwnersAreComplete() diff --git a/src/Wizard.Tests/Registry/TechTests.Suggestions.verified.txt b/src/Wizard.Tests/Registry/TechTests.Suggestions.verified.txt index f7b6383..ce5261b 100644 --- a/src/Wizard.Tests/Registry/TechTests.Suggestions.verified.txt +++ b/src/Wizard.Tests/Registry/TechTests.Suggestions.verified.txt @@ -1,7 +1,6 @@ [ AngleSharp: related by ASP.NET Core, AspNetCore: recommended by ASP.NET Core, - DiffPlex: recommended by every project, EntityFramework: recommended by Entity Framework Core, Http: recommended by ASP.NET Core, LocalDb: recommended by Entity Framework Core, diff --git a/src/Wizard.Tests/ScreenSnapshotTests.AddByTechPlugins.verified.html b/src/Wizard.Tests/ScreenSnapshotTests.AddByTechPlugins.verified.html index 0722c83..5072a7f 100644 --- a/src/Wizard.Tests/ScreenSnapshotTests.AddByTechPlugins.verified.html +++ b/src/Wizard.Tests/ScreenSnapshotTests.AddByTechPlugins.verified.html @@ -72,7 +72,7 @@

Plugins

- Plugins teach Verify about one kind of value each. Nothing here is required, and anything chosen can be deleted from what is generated later. 66 are available. + Plugins teach Verify about one kind of value each. Nothing here is required, and anything chosen can be deleted from what is generated later. 65 are available.

@@ -153,18 +153,6 @@

Suggested for this stack

-
-

Developer experience

-
- -
-

Data

diff --git a/src/Wizard.Tests/ScreenSnapshotTests.AddByTechPlugins.verified.png b/src/Wizard.Tests/ScreenSnapshotTests.AddByTechPlugins.verified.png index 4a94f3e..5dd85c4 100644 Binary files a/src/Wizard.Tests/ScreenSnapshotTests.AddByTechPlugins.verified.png and b/src/Wizard.Tests/ScreenSnapshotTests.AddByTechPlugins.verified.png differ diff --git a/src/Wizard.Tests/ScreenSnapshotTests.AddExisting.verified.html b/src/Wizard.Tests/ScreenSnapshotTests.AddExisting.verified.html index c3d857f..e24cf48 100644 --- a/src/Wizard.Tests/ScreenSnapshotTests.AddExisting.verified.html +++ b/src/Wizard.Tests/ScreenSnapshotTests.AddExisting.verified.html @@ -73,15 +73,6 @@

Already using

2 ticked
-
-

Developer experience

-
- -
-

Data

@@ -122,7 +113,7 @@

Data

Web

-
@@ -196,7 +190,6 @@

Result

// Generated by the Verify wizard: https://verifytests.github.io/Wizard/new?step=output&os=Windows&ide=Rider&cli=Cli&tf=XunitV3&ci=GitHubActions&sponsor=Exempt&exempt=OpenSource&until=2027-09
 // Delete whatever is not needed.
 using System.Runtime.CompilerServices;
-using VerifyTests.DiffPlex;
 
 // Everything here runs once, when the test assembly loads, before any test.
 public static class ModuleInitializer
@@ -204,12 +197,6 @@ 
Result

     [ModuleInitializer]
     public static void Initialize()
     {
-        // Verify.DiffPlex: when a text snapshot does not match, the failure message shows an inline
-        // diff instead of the whole received and verified text.
-        // OutputType.Compact prints only the changed lines, with a line of context either side.
-        // Alternatives: OutputType.Full, OutputType.Minimal.
-        VerifyDiffPlex.Initialize(OutputType.Compact);
-
         // Initializes every Verify.* plugin the project references and has not initialized above.
         // Explicit calls come first so their parameters apply: a plugin can only be initialized once.
         VerifierSettings.InitializePlugins();
diff --git a/src/Wizard.Tests/ScreenSnapshotTests.NewOutputFiles.verified.png b/src/Wizard.Tests/ScreenSnapshotTests.NewOutputFiles.verified.png
index 87da80a..bc733f5 100644
Binary files a/src/Wizard.Tests/ScreenSnapshotTests.NewOutputFiles.verified.png and b/src/Wizard.Tests/ScreenSnapshotTests.NewOutputFiles.verified.png differ
diff --git a/src/Wizard.Tests/ScreenSnapshotTests.NewOutputGuide.verified.html b/src/Wizard.Tests/ScreenSnapshotTests.NewOutputGuide.verified.html
index 29ce5de..5a92bed 100644
--- a/src/Wizard.Tests/ScreenSnapshotTests.NewOutputGuide.verified.html
+++ b/src/Wizard.Tests/ScreenSnapshotTests.NewOutputGuide.verified.html
@@ -68,7 +68,7 @@ 

               
  • 
                 
               
    • 
               
  • 
@@ -121,7 +121,7 @@ 
    Getting started with Verify: V
                   
  • Package management: Prefer CLI
    • 
                   
  • Test framework: xUnit v3
    • 
                   
  • Build server: GitHub Actions
    • 
-                  
  • Plugins: DiffPlex (verbose)
    • 
+                  
  • Plugins: none
    • 
                   
  • Maintenance fee: Exempt: OpenSource
    • 
                   
  • .NET: net10.0 (SDK 10.0.401)
    • 
                   
  • Package versions: the newest stable release of each on nuget.org when this was generated
    • 
@@ -133,7 +133,6 @@ 
    Add NuGet packages
    
                   Directory.Packages.props, and project files reference packages without a version.
    
                 
    dotnet add package Verify.XunitV3
 dotnet add package xunit.v3
-dotnet add package Verify.DiffPlex
 
    
                 
    With Central Package Management enabled,
                   dotnet add package
@@ -407,39 +406,6 @@ 
    Verify.Terminal
    
   }
 }
     4
    • -

    Plugins

    -

    Each plugin below teaches Verify about one kind of value: how to serialize it, how to compare two of them, or how to turn it into something readable. They are independent; removing one changes nothing else.

    -

    Verify.DiffPlex

    -

    Shows an inline diff in the failure message of a text snapshot, instead of both files in full. (repository)

    -

    Package: - Verify.DiffPlex - 1.1.0.

    -

    Enabled by:

    - 
    {
-  "test": {
-    "runner": "Microsoft.Testing.Platform"
-  }
-}
-5
    -

    - Plugins/DiffPlexTests.cs - in the download shows every documented API:

    -

    - PerTestOutput - — The module initializer sets the mode for every test. UseDiffPlex overrides it for one, which is useful when a single snapshot is easier to read in full.

    - 
    {
-  "test": {
-    "runner": "Microsoft.Testing.Platform"
-  }
-}
-6
    -

    Notes:

    -
      -
    • This changes only the failure message; what is written to a - .verified. - file is unaffected.
      • -
    • It is the default comparer for text. A plugin that registers a comparer for a specific file extension, such as html or json, takes precedence for that extension.
      • -

    Initialization

    Verify is configured once, before any test runs, in a module initializer. The solution's @@ -449,14 +415,14 @@

    Initialization

    "runner": "Microsoft.Testing.Platform" } } -7 +5

    Sample Test

    {
   "test": {
     "runner": "Microsoft.Testing.Platform"
   }
 }
-8
    +6

    ClassBeingTested.FindPerson() lives in the @@ -468,7 +434,7 @@

    Sample Test

    "runner": "Microsoft.Testing.Platform" } } -9 +7

    Diff Tool

    Verify supports many Diff Tools @@ -536,10 +502,12 @@

    Getting .received in outpu condition to upload any *.received.* files if the build fails.

    - 
    <PropertyGroup>
-  <OutputType>Exe</OutputType>
-</PropertyGroup>
-0
    + 
    {
+  "test": {
+    "runner": "Microsoft.Testing.Platform"
+  }
+}
+8

    The solution's .github/workflows/build.yml builds, runs the tests, and includes this step.

    @@ -550,10 +518,12 @@

    Open Source Maintenance Fee

    at the tier matching their size. Individuals, non-revenue open source projects and small organizations are exempt.

    Every Verify package checks at build time that the build declares its status, with a property in Directory.Build.props. The solution's declaration:

    - 
    <PropertyGroup>
-  <OutputType>Exe</OutputType>
-</PropertyGroup>
-1
    + 
    {
+  "test": {
+    "runner": "Microsoft.Testing.Platform"
+  }
+}
+9

    Expected build outcome: The build passes and logs the exemption's criteria as an SC031 message, not a warning, so builds with warnings as errors pass too. It passes through the end of 2027-09 (UTC); after that it fails with SC049 until the claim is renewed.

    The SponsorCheck setup wizard for Verify @@ -563,7 +533,7 @@

    Running the tests

    <PropertyGroup>
   <OutputType>Exe</OutputType>
 </PropertyGroup>
-2
    +0

    The test project is also an executable, so dotnet run --project src/VerifySample.Tests runs the tests directly.

    diff --git a/src/Wizard.Tests/ScreenSnapshotTests.NewOutputGuide.verified.png b/src/Wizard.Tests/ScreenSnapshotTests.NewOutputGuide.verified.png index 76c9d4e..f35d80d 100644 Binary files a/src/Wizard.Tests/ScreenSnapshotTests.NewOutputGuide.verified.png and b/src/Wizard.Tests/ScreenSnapshotTests.NewOutputGuide.verified.png differ diff --git a/src/Wizard.Tests/ScreenSnapshotTests.NewPlugins.verified.html b/src/Wizard.Tests/ScreenSnapshotTests.NewPlugins.verified.html index af5a12c..dd80fb0 100644 --- a/src/Wizard.Tests/ScreenSnapshotTests.NewPlugins.verified.html +++ b/src/Wizard.Tests/ScreenSnapshotTests.NewPlugins.verified.html @@ -90,24 +90,16 @@

    Plugins

    - Plugins teach Verify about one kind of value each. Nothing here is required, and anything chosen can be deleted from what is generated later. 66 are available. + Plugins teach Verify about one kind of value each. Nothing here is required, and anything chosen can be deleted from what is generated later. 65 are available.

    - 1 selected + 0 selected

    Suggested

    -