ProtoTest 1.1.0

[1.1.0] - 2026-10-02

ProtoTest 1.1 adds the agent evidence layer (the MCP server, diagnosis, verification, feedback and the
CLI, with compare, prove and review judging what a coding agent changed), the devices family (WebSocket, MQTT, TCP and serial), the topology integrations (Aspire, WireMock,
Testcontainers), the extended runner surface, and a rewritten documentation site with the Learn track.
It ships 46 packages: 19 new, listed first below, and ProtoTest.OpenTelemetry removed. The breaking changes are listed at the end.
See Migrating from 1.0 for the renames
and the deprecated surface; the docs cover the rest.

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

Fixes

Core

• assertion messages across GraphQL, gRPC, messaging, REST and Sheets use a plain hyphen separator. Assertions
• ambient-context errors name the fix (FindTraceWriter, SetContext, the runner setup). Lifecycle
• trace snapshots can be read while other tests record observations, attachments and findings. ProtoTrace
• diagnostic request URLs keep a root-relative path on Linux and macOS instead of turning it into a file:// address. ProtoTrace
• Build() is terminal; every public registration after it throws the single-build message. Lifecycle
• shape mismatches with value constraints record every mismatch, not an internal type name. Shape matching
• ProtoPolling waits out a deadline less than a millisecond away instead of probing in a tight loop until it passes. Time
• malformed JSON bodies and report metadata are redacted with the same policy as the trace. Attachments
• a failed run start unwinds completed run hooks in reverse and keeps the trace silent. Lifecycle
• a scope disposed off its async flow records a Lifecycle finding and throws. Lifecycle
• a throwing run gate keeps its exception and stack in the trace and report metadata. Hooks
• telemetry capture failures record one coalesced telemetry.capture_failed event. ProtoTrace
• [Application] runs before every other setup attribute. Attributes
• a sink added directly to the service collection is exported once, like one added with AddSink. Reporting
• gRPC and messaging share one failure record and the {protocol}.diagnostics.failed event. ProtoTrace
• ResolveState returns only the state the [Application] attribute set during the lifecycle. ASP.NET Core
• container starts and device connects are bounded on release and recorded as abandoned. Lifecycle
• an off-flow dispose releases the orphaned test's context before it throws. Lifecycle

ASP.NET Core

• an application that fails to start reports its own exception, also when WebApplicationFactory reaches its host after the application disposed it. ASP.NET Core
• the in-process HTTP client is owned by its test, fixing a teardown crash. ASP.NET Core
• a repeated AddAspNetCoreServer name with another program throws naming both. ASP.NET Core

REST and HTTP

• a client bound to a configured or published address gets its own handler and cookie jar per test. Clients
• response and attachment defaults bind ProtoTest:Http:Responses; attachments stay opt-in. Attachments
• binary request and response bodies are traced as bytes with their media type. A binary response records its media type and length; it stores no decoded body, no JSON body block and no decoded text in a status assertion. Responses

GraphQL

• a null GraphQL execution result is tolerated, and subscription events are disposed as they advance. Subscriptions
• a rejected subscription names the server's errors. Subscriptions
• a fluent upload argument fails when the document is built instead of rendering as a literal. GraphQL

gRPC

• a transport with no base address fails naming AddClient and the application's keys. gRPC
• client options are per named client; the shared section binds over each callback. gRPC
• a call that misses its deadline in-process reports DeadlineExceeded, as over a socket, instead of the transport's abort. gRPC

Messaging

• awaiting two destinations no longer misses the second destination's first delivery. Messaging
• awaits serialize and an unmatched delivery is kept for a later await, across brokers. Messaging
• UseRabbitMq declares the Broker capability only when a connection string is available. Messaging
• AddMessaging declares Broker with UseBrokerWhenInProcess, replacing UseBrokerUnlessConfigured, and MassTransit's Broker follows its application's chain. MassTransit
• a missing or non-amqp RabbitMQ connection string fails naming the configuration key. Messaging
• UseRabbitMq runs its options callback once per registration. Messaging
• RabbitMQ uses RabbitMQ.Client 7.x end to end (async connect, channel, publish, consume). Messaging
• a tap with a missing exchange fails only the tests that await it, with the named error. Messaging
• publishing to a released broker throws instead of reopening, and a repeated release is a no-op. Messaging

Web

• a failed backend creation is no longer cached, so a session retries from a clean slate. Web
• only the backend that wins the first-wins registration declares the browser capability. Web
• Selenium Check/SelectOption verify the resulting state or fail within the action timeout. Interactions
• assertions poll at IWebBackend.PollInterval; over-cap traces and stuck pumps are recorded. Diagnostics

Sheets

• int/long reads accept only finite, integral, in-range values and fail naming the cell. Sheets
• record models construct through their mapped primary constructor. Sheets
• a repeated AddSheets composes its options callbacks instead of keeping the first. Sheets

SQL and Data

• building a value with a DateTime, DateTimeOffset, decimal or Guid member no longer overflows the stack while tracing it. Defaults
• optional constructor-parameter defaults win over generated values. Defaults
• a run whose declared keys are unprovided keeps the hooks inert and names the required gate. SQL

Testcontainers

• container readiness honors the run's readiness policy. Infrastructure
• a released container can be started again, and its connection string is cleared. Infrastructure

Runners and analyzers

• an NUnit test body that throws is recorded failed with its exception and source location. NUnit
• a body OperationCanceledException records Cancelled under xUnit v2 as under the other adapters. Runners
• TUnit parameterized rows record their arguments in the trace name. TUnit
• the MSTest floor accepts the standard template's version, and every runner page states its framework minimum. Runners

Breaking changes

These are the 1.0 to 1.1 migration changes; from 1.1 onward the 1.x surface stays additive.

Core

• AddClientFrom is removed from the REST and GraphQL builders.
  • Register clients under an application and configure its base URL or endpoints, or use an AddClient resolver (Clients).
• registration, observation and runner implementation types are internal; use the public APIs.
• ProtoHost can no longer be constructed from a service provider; use ProtoHostBuilder (Lifecycle).
• IProtoClientInitializer.TryInitializeAsync no longer takes a cancellation token.
  • Pass one to StartTestAsync, or use a run hook as the cancellable extension point (Lifecycle).
• ProtoExecutionContext.RegisterClient<T> takes ProtoClientOwnership instead of a bool.
  • ProtoClientOwnership.Context is a client the test owns; ProtoClientOwnership.Caller is one the caller owns (Clients).
• ProtoDocumentSource.LoadText is one method with optional parameters; the explicit overload is gone (Extending).
• shape mismatches throw the protocol's assertion exception, with JsonShapeMismatchException as the inner.
  • Code that caught JsonShapeMismatchException catches ProtoAssertionException (Migrating from 1.0).
• ProtoTest.OpenTelemetry is retired.
  • Subscribe to the ProtoTest source with .AddSource("ProtoTest") (OpenTelemetry).

ASP.NET Core

• the package now depends on ProtoTest.Web.Pages instead of the full ProtoTest.Web.

REST and HTTP

• ProtoHttpAuthLifecycleHook is sealed and takes a ProtoProtocol instead of a string.
  • ProtoHttpClientResolution is a positional record with SourceName, SourceClientName and Deconstruct gone, and ProtoHttpClientResolver.Resolve takes the client name as an optional third argument (Extending).
• object request bodies serialize camelCase by default, matching GraphQL variables.
  • Pass explicit JsonSerializerOptions to keep another naming policy (Migrating from 1.0).

gRPC

• GrpcAttachmentOptions no longer derives from the HTTP attachment options, so SensitiveHeaders and SensitiveQueryParameters are gone.
  • Metadata redaction uses the gRPC client's SensitiveMetadataKeys (gRPC).
• ProtoGrpcClient.ServerStreaming and DuplexStreaming moved to the blocking facade, client.Blocking (gRPC).

Messaging

• a publish records the messaging.published observation; the operation stays messaging.publish.
  • Update a collector that filtered the old observation kind (Migrating from 1.0).
• RabbitMqOptions.PollInterval is removed; awaits are event-driven and MessagingOptions.DefaultTimeout bounds them (Messaging).

Web

• ProtoTest:Web:Sessions:{name} settings no longer configure sessions.
  • Put addresses under ProtoTest:Applications:{application} and select with [WebSession] or Web() (Web).
• the reshape removed IWebBackend.CurrentAddress, the old Web() overload and Selenium's download surface.
  • The web pages describe the replacements; CompatibilitySuppressions.xml records the removals.
• PlaywrightWebOptions.Context is removed; configure the browser context with ConfigureContext (Web).
• RequiresPlaywrightBrowserAttribute.Session is removed; the condition probes the configured browser or channel (Skip conditions).
• WebOperationContext.Result is no longer public (Web).