Changelog

Features​

Agent workflows​

• The pull request comment points to ProtoTrace beside the trace link, and the viewer opens the downloaded trace artifact as it is, without unpacking it, for a private repository too: the file is read in the browser. PROTOTEST_FEEDBACK_VIEWER_URL names another viewer or off leaves the pointer out. ProtoTrace

Features​

Core​

• IProtoRunHook.AfterInfrastructureAsync runs once every infrastructure piece started and before the first test. Its ProtoRunSetupContext now carries the run's Services and ApplicationClientAsync(name): a client for an application at its configured or published address, or on its in-process server, released when the phase ends. A collector that is a run hook takes part. Hooks

OpenAPI​

• A specification source that is a path the application serves (/openapi/v1.json), with no BaseUrl to resolve it against, loads from the application before the first test, so an in-process application documents its own coverage without a committed copy. OpenAPI

GraphQL​

• WithSchemaCoverage("/graphql?sdl") loads the schema the application serves before the first test, in process too. Schema coverage

ASP.NET Core​

• The in-process server serves the run before its first test: a per-run server starts then and the tests reuse it, a per-test lifetime starts a server only for that read. Hooks

Features​

Agent workflows​

• The pull request comment leads with what changed: a summary card, one headline, a table of the failing tests with the first mismatch and a linked source line, a caution when failures share a cause, a coverage table against the base branch, and the full record per test folded under Failure details. A skipped test is no longer listed. CI
• ProtoFeedbackComment.Body(digest, target) renders the comment the post sends; ProtoFeedbackTarget.SummaryCardUrl and SourceBaseUrl add the card and the source links. The CLI sets both, and PROTOTEST_FEEDBACK_CARD_URL=off leaves the card out. CLI

Features​

New packages​

• ProtoTest.Analyzers: compile-time rules for what the framework cannot catch at run time.
• ProtoTest.Aspire: runs an Aspire AppHost with the suite and publishes its resources as targets.
• ProtoTest.Cli: the prototest command that summarizes, indexes, compares, proves, reviews and verifies traces.
• ProtoTest.Devices: typed devices, one per test, with every exchange in the trace.
• ProtoTest.Devices.WebSocket and ProtoTest.Devices.WebSocket.AspNetCore: devices over WebSocket, or in-process without a socket.
• ProtoTest.Devices.Mqtt and ProtoTest.Devices.Mqtt.Testcontainers: devices over MQTT, with a Mosquitto broker for the run.
• ProtoTest.Devices.Tcp and ProtoTest.Devices.Serial: devices over TCP and serial lines, with stream framing.
• ProtoTest.Diagnosis: names a failure's cause from the recorded evidence.
• ProtoTest.Feedback: posts a run's digest to a pull request, check annotations or a webhook.
• ProtoTest.Hosting: hosts background workers in the test process.
• ProtoTest.Mcp: an MCP server that lets a coding agent read runs, with the tools and prompts that judge its fixes and tests.
• ProtoTest.Messaging.MassTransit: uses the application's MassTransit test harness as the broker.
• ProtoTest.Traces: reads .prototrace archives for the CLI, MCP and tools.
• ProtoTest.Verification: compares a run with a baseline, by report and by trace.
• ProtoTest.Web.Pages: the page model and coverage, shared by the web backends and ASP.NET Core.
• ProtoTest.WireMock: WireMock.Net fakes owned by a test or the run.

Core​

• Readiness probes replace setup sleeps (AddReadinessProbe, ProtoReadiness.Tcp/.Http). Infrastructure
• One readiness policy (ProtoTest:Readiness) tunes host probes and containers. Infrastructure
• A per-test clock replaces sleeping (ConfigureClock, Proto.Context.Clock, Advance/SetUtcNow). Time
• Targets resolve through ordered provider chains; losers record named skip reasons. Environment resolution
• Applications, workers and containers declare one chain (UseConfigured, UseInProcess). Environment resolution
• [RequiresTestClock] skips tests that need the test clock without a provider that bridges it. Skip conditions
• IProtoTargetProvider.ConfigureServices and ResolveAfter are public. Environment resolution
• Infrastructure with every declared key configured is skipped, unless AddInfrastructureAlways. Infrastructure
  • The old AddInfrastructure(piece, keys) skip rule is deprecated; the provider chain replaces it. Migrating from 1.0
• IProtoConfiguredInfrastructure hands infrastructure the run's settings as it starts. Infrastructure
• AddRunSetup(name, delegate) adds a run-scoped step after the pieces registered before it. Infrastructure
• Composite attributes expand recursively where attributes resolve, with cycles throwing the chain. Attributes
• ProtoCapabilityDescriptor.Instance names the instance a capability describes. Skip conditions
• AddCapabilityWhenProvided/AddCapabilityUnlessConfigured gate capabilities on keys. Skip conditions
• One application-address precedence: a published address wins over configuration. Environment resolution
• Proto.Context.UniqueName("tenant") derives a persistent-store-safe name from the test id. Execution context
• Proto.Context.Sql() is the primary accessor; Messaging(name) accepts a name. Execution context
• Typed skip gates ([RequiresWorker<T>], [RequiresServer], [RequiresApplication]). Skip conditions
• AddCapabilityReason states a skip reason once for the suite, a kind or a name. Skip conditions
• ProtoHost.HasApplication(name) and HasCapability(kind, name, instance) answer the typed skip gates. Skip conditions
• ProtoResourceState.Releasing reports a resource while its release callback runs. Lifecycle
• StartTestAsync accepts a cancellation token on ProtoExecutionContext. Execution context
• ProtoTest.Json hosts the shared JSON read, failure diagnostics and observation capture. Extending
• IProtoConfigurableOptions.FallbackConfigurationSectionName keeps an old section working. Configuration
• ProtoOptionsRegistration.ConfigureKeyed registers keyed per-client options. Configuration
• The extension points a third-party integration needs are public. Extending
• A bare client name resolves across applications; an ambiguous name names both candidates. Clients
• Clients use protocol-scoped names and one registration path per integration. Clients
• One Should assertion surface across protocols; request, message and reply assertions return their subject and chain, while Web element assertions are async. Assertions
• Shape matching lives under Should.MatchShape; old spellings stay as shims. Shape matching
• Exhaustive shape mode (exact: true) works on every shape surface through one matcher walk. Shape matching
• OpenAPI and GraphQL collectors record the specification identity (spec.source, spec.hash). Coverage
• ProtoProtocol.CoverageCategory is optional and falls back to the protocol name. Coverage
• ConfigureTracing captures CI facts with RunMetadata and RunMetadataEnvironmentVariables. ProtoTrace
• ProtoApplication.ResolveSetting publishes the settings-over-configuration precedence. Environment resolution
• ProtoAttributeOrder names the setup order bands (Application, SessionDeclaration, Default). Hooks
• Suites name their own sensitive values (ConfigureRedaction, ProtoTest:Redaction); state and findings redact them like the defaults. ProtoTrace

Hosting​

• AddWorkerHost<TProgram>() runs a background worker or generic host in-process with the suite. Hosting

ASP.NET Core​

• ProtoTestHost.For<TProgram>(builder) composes an in-process application in one line. ASP.NET Core
• AddAspNetCoreServer steps aside when BaseUrl is configured. ASP.NET Core
• AddLoopbackApplication hosts a hand-built WebApplication on loopback. ASP.NET Core
• Per-test service substitution (Override, [ReplaceService]) builds a dedicated server. ASP.NET Core
• [SignedInAs] signs a test in; AddTestUserAuthentication() reads it app-side. Authentication
• ProtoTestContextPropagation applies the trace context and test id to raw requests. ASP.NET Core

REST and HTTP​

• Read one value by JSON path (ReadAsJson<T>("$.id")), with the protocol's failure evidence. Responses
• ReadRequired<T> returns T and fails naming the subject or path when the body is empty or null. Responses
• Should/ShouldNot assert content type, headers, cookies and redirect location. Responses
• PostAsync(...).ExpectAsync(shape) asserts the response shape where the call is made. Responses
• RestTrafficCoverageCollector reports the fields no shape assertion mentioned. Coverage
• Protocol builders adopt the public authenticator, base-address and options resolvers. Extending

GraphQL​

• ReadDataAs<T>(jsonPath) and ReadRequired<T> read data or fail naming the operation. Responses

gRPC​

• Client options bind ProtoTest:Grpc:Client; the legacy ProtoTest:Grpc section still binds as a fallback. gRPC
• ProtoGrpcBuilder.ProtocolName names the protocol key. gRPC

Messaging​

• ProtoMessage.MatchesShape(shape) picks a message in an AwaitAsync predicate with the shared shape matcher: true or false, nothing recorded, false for an empty or non-JSON payload. Messaging
• ProtoDestination.Queue(name) awaits a named queue; adapters without queues refuse it by name. Messaging
• Declare(...) or ProtoTest:Messaging:DeclaredDestinations declares suite-owned destinations. Messaging
• Taps gain a code API (AddMessaging(m => m.Tap(...))) that pre-binds destinations during setup. Messaging
• Messages carry a routing key, and PublishAsync/AwaitAsync accept one. Messaging
• ProtoMessage reads are typed (ReadAsJson<T>, ReadRequired<T>). Messaging
• UseBroker(factory, addressKeys) gates the Broker capability on an address key. Messaging
• UseMassTransit<Program>() publishes and awaits over the app's MassTransit harness. MassTransit
• MassTransitEnvelope.Wrap/Unwrap build and read the wire envelope, addresses included. MassTransit
• ProtoMessageConsumerBase exposes the one await contract to adapters. Messaging
• RabbitMQ taps prepare and release in parallel, cutting per-test setup and teardown. Messaging

Devices​

• ProtoTest.Devices talks to simulators and hardware from the test context and trace. Devices
• AddInProcessWebSocketDevices routes device clients through the in-process server. Devices
• Clients carry per-client transport settings (WithSetting) filled into DeviceEndpoint.Settings. Devices
• ProtoTest.Devices.Mqtt speaks MQTT 5; AddMqttClient declares the topics. Devices
• ProtoTest.Devices.Mqtt.Testcontainers owns a Mosquitto broker for the run. Devices
• ProtoDeviceConnect and its timeout live in ProtoTest.Devices, shared by every transport. Devices
• IProtoDeviceTransport.ConnectAsync gains a default context overload for custom transports. Devices
• ProtoTest.Devices.Tcp connects devices out (AddTcpClient) or listens for the system under test (AddTcpListener, ListenAsync). Devices
• ProtoTest.Devices.Serial opens serial:// lines; a client without an address reads ProtoTest:Devices:Serial:Ports:{client}. Devices
• Stream framing (IDeviceFramer, DeviceFramers, WithFramer) and StreamDeviceConnection serve any byte-stream transport. Devices
• DeviceMessage writes and reads device data strings as records, with SendMessageAsync/ExpectMessageAsync. Devices
• [DeviceChecksum<T>] and [DeviceFormat<T>] add checksums and field formatters (DeviceFormatters: scaled, hex, Unix time, BCD). Devices
• [DeviceBinaryMessage] writes and reads fixed-layout binary messages, with Crc16Modbus, Xor8Checksum and Sum8Checksum. Devices
• DeviceMessageProtocol and AddProtocol(instance) report the message types no test expected. Devices

Web​

• WebPageInventory.VisitedObservationKind/VerifiedObservationKind name the page observation kinds. Web
• The backend building blocks are public (WebBackendOptions, WebBackendErrors, WebBackendDefaults). Web
• PlaywrightWebOptions.MaxTraceBytes caps a browser trace; 0 turns the cap off. Web
• Sessions are created when requested and complete through the shared client lifecycle. Web
• Sessions key by name and application, and Web() without an application finds the one session with that name, such as one [WebSession(Application = ...)] opened. Web
• WebDownload implements IProtoBinaryContent, so a download feeds ProtoSheets.Open in one line. Web

Sheets​

• model.Should.MatchHeaders() asserts the header row against the model in declaration order. Sheets
• Key-value sheets declare labels with [Label] and read through Workbook.KeyValueModel<T>(). Sheets

SQL and Data​

• ProtoDataValueContext.Clock gives defaults the test clock, so a default stamp follows Proto.Context.Clock. Defaults
• SqlOptions.AddressKeys declares the connection keys and gates the SQL and EF Core capabilities. SQL
• SqlAddressRule publishes the declared-keys lookup for a sibling SQL provider. SQL
• Generated member defaults are deterministic per test. Defaults

Testcontainers​

• UseContainer and DockerProbe.IsAvailable() skip without a Docker runtime. Infrastructure
• ApplicationContainer runs an application under test in its own image. Infrastructure

Aspire​

• A DCP that cannot start (its container-runtime check or its API server times out, as on a constrained CI runner) fails the start with ProtoAspireUnavailableException, like missing orchestration binaries, so a suite skips with the reason. Aspire
• AddAspireAppHost<TEntryPoint>() runs an AppHost when selected and publishes its resources' addresses. Aspire
• UseAspireResource serves an endpoint or connection string through the provider chain. Aspire
• The AppHost receives the suite's configuration and the run's settings as arguments. Aspire

WireMock​

• AddWireMock(name) fakes HTTP dependencies per test, with stubs as coverage gaps until hit. WireMock

OpenAPI​

• Coverage reads specifications with Microsoft.OpenApi 3.x (JSON and YAML, including 3.1). OpenAPI

Runners and analyzers​

• Opt-in low-ceremony mode ([assembly: ProtoTestAutoWrap]) wraps plain tests in the lifecycle. Runners
• One outcome classifier (ProtoTestResult) and row-name helper (ProtoTestName.ForRow). Runners
• XUnit v3 and TUnit pass their per-test cancellation token into the lifecycle; MSTest's 4.0.2 floor exposes none. Execution context
• dotnet new prototest --runner <name> (nunit, xunit, xunit3, tunit or mstest) writes a suite per runner. Overview
• ProtoTest.Analyzers reports PT0001 and PT0002 for intent the runtime cannot check. Analyzers
• PT0003 flags a fixed wait and PT0004 a hand-made HttpClient in a ProtoTest test. Analyzers

Agent workflows​

• prototest summary prints the diagnosis document. CLI
• prototest index <folder> writes a static index and digest for a folder of runs. CLI
• prototest feedback and prototest verify post the channels and print a verdict. CLI
• prototest-mcp reads .prototrace files over stdio (list_runs, get_failure, get_coverage). Setup
• get_diagnosis returns the run digest or one failing test's context package. Diagnosis
• get_suite_map lists what a new test reuses: clients, provisioners, attributes, pages, examples and gaps. Setup
• The prototest-write-test skill teaches writing a test on top of the suite and proving it. Coding agents
• dotnet new prototest starts agent-ready: AGENTS.md, .mcp.json, both skills, a tool manifest and the analyzers. Coding agents
• The demo endpoint (samples/ProtoTest.Mcp.DemoEndpoint) serves the same tools over the demo trace. Coding agents
• ProtoDiagnosis.Read builds a deterministic digest; ReadContext adds one test's context. Diagnosis
• ProtoTest.Verification compares a baseline and a candidate report. Verification
• prototest compare and the compare_runs tool compare two runs test by test and name the operation where each broken, fixed or still-failing test left the baseline; a skipped test is not a failure, and steps pair across runs although their names carry ports or ids. CLI
• prototest prove and the check_fix tool return a fix receipt: proven only when the baseline failed, every rerun passes, nothing broke and the reports verify, with a named reason for each unmet condition. CLI
• prototest review and the review_tests tool say what each test proves: a body with no check, a call no check looked at, or an untraced gap, each with the next step. Diagnosis
• get_coverage suggests where to cover each uncovered endpoint or page: extend the test that already calls or opens it, or write a new test shaped like the closest recorded call or browser journey (ProtoDiagnosis.SuggestCoverage). Setup
• The MCP server offers three job prompts, fix_failure, cover_change and improve_tests, each ending with the tool that judges it; the skills and the starter's AGENTS.md point at them. Setup
• ProtoReport.ReadJson(Stream) reads a report from a stream, such as the one a trace embeds. Verification
• ProtoTest.Feedback posts a failing run's digest to a PR comment, annotations or a webhook. Loop
• The ProtoTest Evidence action (MSeys/prototest-action) compares a pull request's run with the base branch's last green run, posts what broke, what was fixed and the coverage that moved, runs the verdict over the embedded reports (optionally failing on new uncovered units) and keeps the trace. CI
• prototest feedback --baseline <trace> adds the comparison and the coverage that moved to the comment (each new uncovered unit with the test to start from, each unit no longer covered), and updates the pull request's one ProtoTest comment instead of adding another. A pull request from a fork skips the comment with the reason (its token cannot comment), and a refused post names the missing pull-requests: write. prototest verify reads the reports two traces embedded (ProtoVerificationRun.FromTrace), and --strict fails a unit added without a test. CLI

Traces and reporting​

• A suite built deterministically (ContinuousIntegrationBuild, which maps sources to /_/) still records repository-relative locations and embeds its sources when it runs inside its repository. ProtoTrace
• A check that runs after an await inside ProtoTest, such as ExpectAsync on a REST or GraphQL call, records the line of the test step it checks instead of no line. ProtoTrace
• The HTML report reads like the viewer's run view: a headline that names what needs attention, a strip of every entry, a Needs attention list across all kinds and one tab per kind. Coverage is one tab with its own figure, not the page's headline. Reporting
• The report summary counts every kind in Kinds, written to the JSON report next to the existing totals. Reporting
• Run and test artifacts are declared and readable (ProtoTraceArchive.Artifacts, ReadArtifact). ProtoTrace
• ProtoTest.Traces reads the whole 2.0 archive and selects the viewer's failure. ProtoTrace
• ProtoReport.ReadJson reads the JSON report a sink wrote. Reporting
• The HTML report ends with a quiet pointer to the viewer, naming the .prototrace to drop there. Reporting

Viewer​

• One ViewerMock component draws every viewer picture in the docs (the walkthrough's six views, the home's failing check and the coverage page's run header) from one file of the demo run's values, taken from the viewer itself; Timeline, State and Evidence now show the viewer's own rows, counts and positions. ProtoTrace
• The walkthrough, ProtoTrace guide and viewer README describe Steps, Timeline, State and Evidence, diagnosis rules, untraced gaps and run selections, with updated demo excerpts. ProtoTrace
• State uses the same test clock and phase marks as Timeline, shades the selected operation's time across the lifelines, and highlights the items and changes it touched. The ruler stays visible on phones. ProtoTrace
• The run names attention with the diagnosis rules, marks untraced gaps on its timeline, lists every environment value and the run id, and opens run operations and tracked items in the inspector. ProtoTrace
• Evidence brings observations, files, findings and moments into time order with the operation that recorded each; details show their metadata and sections, a section index jumps through an operation, and binary bodies are marked instead of drawn as broken text (#/test/<id>/files links still open). ProtoTrace
• One test list on every screen, led by the run, with one filter for every list and a path from the run to the open operation; each test is a link. ProtoTrace
• A test's Steps open on the test body: setup and teardown fold into one line that says what they did, time with no recorded operation gets its own row, and the verdict names the failure with the rule prototest summary uses (#/test/<id>/story links still open). ProtoTrace
• The Timeline replaces Spans: every operation on the test's clock, zoomed per phase, with framework machinery dimmed or hidden, moments and evidence marked on their bars, and untraced time drawn through the rows (#/test/<id>/spans links still open). ProtoTrace
• The viewer stays responsive on a 1,000-test run; the benchmark page states the open and search times. Benchmarks
• A skipped test reads as planned in the run strip, keyboard focus and touch targets work across the viewer, and the run header's outcome pill moves under the title on narrow screens. Trace viewer
• Each screen answers its question in order: failing rows name their reason, the failure names where in the test it started, step rows read stated observations inline, and an empty evidence list separates no files from no match. Trace viewer
• The run splits into Overview, Timeline, Operations, Details and Files instead of stacking every panel. ProtoTrace
• A Framework switch shows, dims or hides framework operations in Steps and Timeline, and the machinery in State. ProtoTrace
• The viewer works on a phone and with a keyboard: one tablist with arrow keys, readable rows on narrow screens, and text that meets WCAG AA. ProtoTrace

Docs and samples​

• The site has a blog for articles on the problems ProtoTest solves, with RSS and Atom feeds. Blog
• A copy-in skill (skills/prototest-evidence-loop) teaches agents the evidence loop and the CLI. Coding agents
• The xUnit pages cover converting an existing suite and the Microsoft.Testing.Platform opt-in on SDK 10. Runners
• The integrations overview lists every ProtoTest.Devices* package with a one-line purpose. Overview
• The 46 packages are tiered into supported and preview sets, with the stability promise and the graduation path stated. Installation
• The web pages make the backend choice explicit (Playwright or Selenium), and the conversion order covers NUnit, MSTest and TUnit suites. Web
• The agent workflows document the feedback webhook payload, the configuration page lists every section's keys, and the template page shows what the scaffold creates. CLI
• The reference pages gain the recorded trace walks, the decision figures and the triage tables; the longest pages split into child pages (web page coverage, messaging adapters, gRPC calls, the ProtoTrace archive, the CI providers). Docs
• The home opens on the blueprint hero with the journey as test, composition and trace, then proves three claims with real artefacts: the plumbing each fixture stops writing, the failing check as the viewer shows it, and one model across integrations; the starter includes the working directory and runner options; the integration pages open with a shown test and keep reference detail below the tasks. Docs
• Tab strips in code and the viewer walkthrough scroll with a plain mouse wheel, fade only where there is more, and keep the selected tab in view. Docs
• Tabbed code keeps its copy button beside the tabs on a phone and fades the tab strip where it scrolls, and every figure in running text keeps a paragraph's distance to the text after it. Docs
• Tables read on a phone: every docs table labels its cells with the column heading at build time, and below 700px a row becomes a short card with the first cell as its title; the Level 5 modes comparison does the same, and the failure tour labels its questions quietly and says what opening a card shows. Docs
• The package builder reads its choices from the integrations catalog, so it offers every shipped integration (Selenium, RabbitMQ, SQL and its containers, workers, Aspire, WireMock, devices, analyzers) grouped like the map, and a docs test keeps the catalog equal to the shipped packages. Integrations
• Trace figures speak the viewer's language: the layer-by-layer trace marks each phase in its colour with quiet operation rows, and a pointer to a recorded test reads as a viewer test row with an Open in the viewer button; wrapped code keeps its first token beside the line number. ProtoTrace
• Every Learn lesson is rewritten to one shape (the problem, do it, what happened, check yourself, remember) in plain Markdown with a lesson banner, and Across boundaries adds five lessons built on the sample's own tests: call an API, read back over GraphQL, check the database, drive the browser and follow a message. Learn
• Learn is regrouped into seven tracks (Start, Write good integration tests, Across boundaries, Reliable tests, Understand failures, Real systems, Extend ProtoTest), shown as cards read from the sidebar; every old lesson address redirects, and lessons get a Markdown-first shape with a small lesson banner. Learn
• The Vocabulary page explains every ProtoTest word in one plain sentence and links the lesson that teaches it and the page with the details; lessons explain a word again at its first use. Vocabulary
• The API docs of UniqueName, SignedInAsAttribute.Claims, IProtoMessageConsumer and the readiness probe say what they guarantee: unique within a host (a rerun matches only with an id generator that derives from the test), claim types only in auth:user, isolation per exchange tap. Test context
• Getting started reads plainly: each page says what it is for, introduces its terms in plain words, says what you should see after each step, and folds what only some readers need; the troubleshooting page no longer presents the CI examples' PROTOTEST_RESULTS variable as a ProtoTest setting. Getting started
• Start here opens with one paragraph and four starting points (try it, learn it, weigh it, use it) in two columns, and the sidebar narrows between tablet and wide screens so the text keeps its measure. Docs
• The READMEs follow one shape per kind, from the root to the package pages. Docs
• Northstar with the Learning demo suite is the in-repo sample. Learn
• The coding agents page, the evidence loop lesson and the README describe ProtoTest as the judge above a coding agent: three jobs, each ending with the tool that decides it is done. Coding agents
• A message-to-fix table in troubleshooting, a where-your-evidence-goes map and a which-runner chooser. Troubleshooting

Packaging​

• 46 packages pack in one version, 18 more than 1.0; the installation page lists the supported and preview tiers. Installation

Added​

• Preview .xlsx artifacts directly in the ProtoTrace viewer, with worksheet tabs, dimensions, sticky row and column headers, typed cell values and bounded rendering for large workbooks.
• Add focused, shareable recipe traces for REST-to-GraphQL, REST-to-database and workbook journeys.
• Publish a generated .NET API reference alongside the task-oriented documentation, with one command producing the complete uploadable site.
• Add documentation quality, link and API-reference workflows; contributor, support, security and code-of-conduct guidance; richer CI guidance; and interactive stack and trace examples.

Added​

Host and lifecycle

• One ProtoHost per test process and one ProtoExecutionContext per test, with run hooks and gates, test hooks, attributes, typed state, clients, attachments, findings and owned resources.
• Skip conditions ([RequiresCapability], [RequiresInProcess], [RequiresPlaywrightBrowser]) that stop a test before its lifecycle starts when the host cannot run it.

Integrations

• REST (ProtoTest.Rest): HTTP clients, [Auth<T>], status and shape assertions, REST coverage.
• GraphQL (ProtoTest.GraphQL): queries, mutations, WebSocket/SSE subscriptions, uploads, schema coverage.
• gRPC (ProtoTest.Grpc): unary and streaming clients, metadata auth, method coverage.
• Messaging (ProtoTest.Messaging, ProtoTest.Messaging.RabbitMq): publish and await messages on an in-memory default broker or RabbitMQ.
• SQL and EF Core (ProtoTest.Sql, ProtoTest.Sql.EntityFrameworkCore): one database connection per test, optional transaction isolation, and a DbContext over the same connection.
• Data (ProtoTest.Data): deterministic builders, member defaults, provisioners and the Ref<T> identity map.
• ASP.NET Core in-process (ProtoTest.AspNetCore): host the application inside the test process, with server DI access.
• Browser sessions (ProtoTest.Web with Playwright and Selenium backends): sessions, page objects, flows, login and page coverage.
• Spreadsheets (ProtoTest.Sheets): cell, column, range, table and typed-model assertions for .xlsx files.
• OpenAPI (ProtoTest.OpenApi): contract coverage over REST response and shape observations.
• Containers (ProtoTest.Sql.Testcontainers, ProtoTest.Messaging.RabbitMq.Testcontainers, ProtoTest.Testcontainers): run-scoped PostgreSQL and RabbitMQ, or your own ProtoContainerResource<TContainer>.

Observability

• Coverage of REST endpoints, OpenAPI documents, GraphQL schemas, gRPC services, web pages and spreadsheet ranges.
• ProtoTrace format 2.0: a portable .prototrace bundle (spans.json, state.json) recording what ran and what existed and changed, read in the viewer.
• Reports (ProtoTest.Reporting): JSON and HTML report sinks.
• OpenTelemetry bridge (ProtoTest.OpenTelemetry): export ProtoTest operations as OpenTelemetry spans.

Runners and templates

• Adapters for NUnit, xUnit v2, xUnit v3, MSTest and TUnit, sharing one lifecycle and one set of outcomes.
• ProtoTest.Templates: dotnet new prototest creates an API and a suite for it, already composed, traced and reported.

Welcome to 1.0. Install a package, compose the capabilities your system actually has, and run the same suite in-process, in containers, or against a published environment. The trace will tell you the rest.