Namespace ProtoTest.Core
Classes
- ApplicationAttribute
Selects the application under test for a test or class and, optionally, which registered client each protocol uses. Bindings use
Protocol:Client(for exampleRest:BillingorWeb:Admin); unlisted protocols use the application's first registered client of that protocol.
- Proto
Provides a static gateway to the active ProtoExecutionContext.
- ProtoApplication
Resolves the named application that a client or web session targets: a system under test with a base address and protocol descriptors. Reads values from its
ProtoTest:Applications:{app}section. A scope selects an application with its ownApplicationsetting, defaulting to the scope's own name, so a REST client, GraphQL client, and browser session can share one application.
- ProtoApplicationClient
A client of a protocol registered under an application.
- ProtoApplicationClients
The ordered clients registered for one application, per protocol.
- ProtoApplicationRegistry
Resolves the clients registered for each application. Integrations use it to pick a protocol's default client (the first registered) when a test does not name one explicitly.
- ProtoApplicationResolution
Resolves which client a protocol accessor should use for the current application.
- ProtoApplicationState
The application selected for the current test and any per-protocol client bindings.
- ProtoApplicationTransport
The in-process transport (an ASP.NET Core server client) backing an application. An application's HTTP clients with no configured base address reuse this transport instead of opening a socket.
- ProtoAssertion
Runner-independent semantics shared by integrations whose assertions run in a positive or a negated form. A negated assertion is satisfied when the underlying check does not hold, and its expectation reads with a leading "not".
- ProtoAssertionException
Base type for runner-independent assertion failures produced by ProtoTest integrations.
- ProtoAttachmentCapture
Adds a captured payload as an attachment without ever failing the operation: a failure is traced as a failed event with the operation as its parent, the rule gRPC, messaging and web diagnostics share.
- ProtoAttachmentFailure
Names the failure event one integration writes when an attachment cannot be added.
- ProtoAttribute
Base attribute for defining test-level or class-level lifecycle execution hooks.
- ProtoAttributeOrder
Named order bands for setup attributes, so an attribute sits relative to the built-ins without spelling out their raw values. Lower orders run earlier; two attributes with the same order run in the order the runner reports them, so a suite sequences its own attributes with Order.
- ProtoAttributeResolver
Resolves the ProtoTest lifecycle attributes that apply to a test method, expanding the composite attributes among them.
- ProtoAuthenticatorFactory
Constructs a protocol authenticator so its constructor can request ProtoExecutionContext directly, in addition to any services resolvable from DI and explicit constructor arguments.
- ProtoCapabilityDescriptor
Describes one thing the host is composed of: a capability or an adapter behind it. Descriptors are metadata, not lifecycle - they record what an application is made of for the run overview, the trace and the report. Register one with AddCapability(IProtoHostBuilder, ProtoCapabilityDescriptor).
- ProtoCapabilityExtensions
Registers capability descriptors from the host builder or from an application builder.
- ProtoCapabilityKinds
The capability kinds ProtoTest itself registers; an integration may use its own.
- ProtoCleanupException
The failure a runner reports when cleanup failed and Fail is in effect. A body that passed produces a message that says so and names the first cleanup failure; further failures are counted. A body that failed stays the primary error: its message leads, it is the InnerException, and CleanupFailures carries the cleanup.
- ProtoCleanupExtensions
Selects what a failing cleanup does to the test the runner reports.
- ProtoCleanupOptions
How the run treats a cleanup failure. The section
ProtoTestbinds over code values when the host is built, soProtoTest:CleanupFailuresselects Fail or Report.
- ProtoClientResolution
The name resolution every protocol accessor shares: the client name the call asked for, the application-qualified name a registered client uses, and the lookup that lets a host-registered client stay reachable from inside an
[Application].
- ProtoClientTrace
The client entity a traced operation belongs to. Every protocol records its client under the same id and name, so the viewer places a REST, GraphQL, gRPC or web operation on that client's timeline together.
- ProtoClientTraceState
The client state every initializer records once, so a client's configuration reads the same in the trace whichever protocol created it: name, protocol, concrete type, where the endpoint came from, and the protocol's own details.
- ProtoClock
The clock a suite controls: a TimeProvider whose UTC time only moves when the test moves it. The run owns one instance (seeding each test's clock), and every test gets its own, so advancing time in one test never leaks into another. Only GetUtcNow() is virtual: timers created from this provider still run on real time.
- ProtoClockExtensions
Configures the run's clock.
- ProtoClockRegistry
The clocks of the tests one host is currently running, keyed by test id. One registry belongs to one host, so two hosts that share a test id each resolve their own clock, and disposing the host clears it. An in-process hosting integration links a request the test caused back to the test's clock through the owning host's registry: the registry is a host service, so resolving it from the test's provider yields exactly the host that started the application, and Find(string) is the public lookup an in-process transport or middleware uses.
- ProtoCompositeAttribute
An attribute that declares the attributes it groups, so one declaration a test carries stands for several. The framework expands a composite wherever attributes are resolved: the composed attributes run like declarations the test made itself - at their own Order - and the composite's own lifecycle behavior runs at its order too. A composite may compose another composite; a cycle is rejected when the attributes are resolved.
- ProtoCoreDiagnostics
The names ProtoTest.Core records under.
- ProtoCoverageCollector
Thread-safe base for collectors that aggregate observations as coverage items.
- ProtoCoverageSummary
Aggregated coverage for one target and category, as seen by a Run gate.
- ProtoDocumentSource
Loads a text document from inline content, a local file, or an HTTP(S) URL.
- ProtoExecutionContext
Provides the public per-test facade for metadata, services, state, clients, attachments, and observations.
- ProtoFlow
A named, traced sequence of steps: each step is one operation whose outcome is derived, and the flow either stops at the first failure or collects every failure. This is the shared sequence primitive for lifecycle phases and teardown chains, so a release chain reads as a list of steps instead of a loop, an exception list and a tracing helper.
- ProtoFlowResult
The failures a flow collected, in step order.
- ProtoHookOrder
Named positions for Order and Order, so a hook can sit relative to the built-ins without spelling out their raw values. Lower orders run earlier on the way in and later on the way out; two orders of the same value run in registration order.
- ProtoHost
Owns the ProtoTest service provider and exposes the public run and test lifecycle API. The run state machine lives in ProtoTest.Core.Internal.ProtoRunStateMachine; hook sequencing and the test lifecycle are delegated to focused internal components.
- ProtoHostBuilder
Implements the builder pattern for configuring and constructing a ProtoHost instance.
- ProtoInfrastructureContext
The run's collected state, handed to infrastructure as it starts: the settings earlier infrastructure provided, the suite's own configuration, and the clock in effect (the active test's, or the run's on a background flow).
- ProtoInfrastructureSettings
The configuration values started infrastructure provided, keyed as the application reads them.
- ProtoObservation
A protocol-agnostic fact observed during a test execution.
- ProtoOptionsRegistration
Registers a single instance of an options type and applies every configuration callback in registration order before binding the type's known configuration section over the result, so repeated registration composes instead of replacing earlier callbacks.
- ProtoPolling
Shared bounded polling: repeatedly probes until the observation satisfies the predicate or the timeout elapses, returning the last observation and whether it was satisfied. The caller decides what a timeout means, so the same loop serves assertions, synchronization waits and readiness probes without owning their failure semantics.
- ProtoProtocol
What makes one protocol itself: the key its options are registered under, the name capabilities and coverage use, the trace source its operations declare, and the observation kind coverage collects. One descriptor per integration, so the builder that produces an observation and the collector that consumes it cannot disagree about its kind. CoverageCategory is null for a protocol that ships no collector (Messaging): it owns no coverage vocabulary, so it declares none.
- ProtoProviderConditionContext
The resolved environment a provider condition is evaluated against.
- ProtoProviderConditions
The canonical provider conditions: Configured for a target the environment already provides, Selected(string) for an integration-owned selection key, Available(string, Func<bool>) for a runtime probe, and Always for the fallback a chain ends with.
- ProtoReadiness
The readiness checks and the wait loop the host, containers and applications share.
- ProtoReadinessExtensions
Registers readiness probes the host awaits before the first test.
- ProtoReadinessOptions
How long the host waits for a readiness probe and how often it asks. One instance governs every probe of the host and every container the run starts; a probe registered with its own timeout uses that instead. The section
ProtoTest:Readinessbinds over code values when the host is built.
- ProtoReadinessResult
What a readiness wait observed, for the trace evidence and failure messages.
- ProtoRedactionDefaults
The names redacted by default wherever ProtoTest writes JSON diagnostics: attachment bodies, observation data and traced state values all read this one list, so no axis can hide more than another.
- ProtoRedactionExtensions
Registers a suite's additional sensitive names for the run.
- ProtoRedactionOptions
Names a suite redacts on top of the defaults: every additional name is treated like the entries of SensitivePropertyNames wherever the run redacts state values and finding metadata, while attachment and diagnostic JSON keeps each protocol's
SensitiveJsonPropertieslist. The sectionProtoTest:Redactionbinds over code values when the host is built.
- ProtoRegistrationGuard
The public facade for the one internal once-only rule (
ProtoRegistration): first registration wins, later calls are no-ops. The guard reads through that helper for a service collection, a marker with the caller's own identity rule, and a builder that keeps its marker out of DI, so an integration's idempotency cannot drift from Core's.
- ProtoReportItem
A normalized item that can be rendered by any report sink. Kind is an open string so integrations can define their own; ProtoReportItemKinds names the values Core itself uses.
- ProtoReportItemExtensions
Traversal and coverage arithmetic shared by every consumer of ProtoReportItem trees - the report summary, the HTML renderer and Run gate coverage - so the three cannot disagree.
- ProtoReportItemKinds
The report item kinds Core produces. A kind is an open string, so an integration can add its own; sinks group unknown kinds under their own section instead of dropping them.
- ProtoRequestClock
The clock in effect for the current request or flow. A hosting integration that runs an application in-process pushes the test's clock while it handles a request the test caused, so application code that resolves TimeProvider sees the test's time; background flows see the run's.
- ProtoResolvedTarget
How one target resolved: the winning provider and the capabilities it declared. A dependent chain reads it from ProtoProviderConditionContext to follow the target it belongs to.
- ProtoResource
A resource described by a release callback, for cases that do not warrant a type of their own.
- ProtoResourceReleaseContext
Provides everything a resource needs while it is being released.
- ProtoResourceSnapshot
An immutable view of one resource owned by a test.
- ProtoRunApplicationClient
A client the run opened for an application, and what was started only for it.
- ProtoRunGate
A Run gate defined by a delegate.
- ProtoRunGateContext
The evidence a Run gate evaluates: everything the run's collectors and report sources produced, whatever kind. Coverage, findings, metrics and observations all arrive as ProtoReportItem.
- ProtoRunGateCoverageExtensions
Coverage helpers for Run gates. Coverage is one kind of collected evidence among several, so its arithmetic lives here rather than on ProtoRunGateContext.
- ProtoRunGateException
Thrown when one or more Run gates failed, failing the run.
- ProtoRunGateFailure
One failed Run gate, as reported when the run ends.
- ProtoRunGateResult
The verdict of one Run gate.
- ProtoRunSetupContext
The run's collected state a run setup step reads: the settings started infrastructure published before the step's registration position, the suite's configuration it can fall back to, and the run's start cancellation token. Read Settings first and Configuration second - the precedence every address reader follows - so a container the environment replaced with a configured address is skipped and the configuration value still reaches the step.
- ProtoSpecIdentity
The identity a contract collector records for the document it loaded: the configured source and the SHA-256 hash of the loaded content. The report item that carries it has no coverage verdict, so the report arithmetic ignores it; a cross-run comparison can still tell a changed specification from the same one.
- ProtoStepDescriptor
One step of a flow: the operation the step records and the entity that operation belongs to. Declaring the operation is what lets a teardown chain keep its semantic entry - a resource release stays
resource.release, an attribute teardown staysattribute.after- instead of collapsing into a generic step. A step declared by name alone records asflow.step.
- ProtoTargetProvider
A provider described by its parts: a name, the piece that serves the target, the condition, the capabilities it serves and the services the winner contributes. Use it when the provider has no behavior beyond those parts; implement IProtoTargetProvider when it does.
- ProtoTargetResolutionException
Thrown when a target's provider chain cannot serve it - no provider is registered, or no provider's condition holds. The message names the target and every provider's unmet condition, so a suite fixes its composition instead of failing at first use.
- ProtoTargetTrace
The trace vocabulary a target's resolution records.
- ProtoTestAdapter
The preparation every runner adapter shares: resolve the attributes that apply to a test method, ask the run's skip conditions, then start the lifecycle. Keeping it in one place is what makes the five adapters behave the same - including skipping before the lifecycle starts, so the trace stays honest: nothing ran, nothing failed.
- ProtoTestAssemblyHost<TSelf>
The assembly-level host every test-framework adapter manages: one ProtoHost per test assembly, started once from the framework's assembly hook and stopped from its teardown. The lifetime is a static of the closed generic type, so two adapter assemblies loaded in one process each own their host instead of sharing one.
- ProtoTestAsync
The one bridge for frameworks whose lifecycle hooks are synchronous. It blocks the calling thread until the async lifecycle completes; the adapters only use it on runner hooks that do not install a single-threaded synchronization context, where a blocking wait cannot deadlock.
- ProtoTestAttachment
A file or in-memory artifact associated with one test execution.
- ProtoTestAttachmentPublisher
Materializes an attachment to a file and hands the path to the framework. Every adapter shares this shape, so a publisher declares only what its framework does with the file.
- ProtoTestDiagnostics
Diagnostic source information used by OpenTelemetry and other Activity listeners.
- ProtoTestHostLifetime
Owns the single root ProtoHost for a test assembly and enforces one-time initialization. Shared by every test-framework adapter so host lifetime, guards, and shutdown ordering stay identical across frameworks.
- ProtoTestIdOptions
Options for the numeric test IDs the host generates: the run's prefix and the sequence width.
- ProtoTestName
Builds the stable, fully qualified test name recorded for a test method, shared by the adapters so traces and reports use the same naming across frameworks.
- ProtoTestPreparation
A test method resolved once for execution: the attributes the host orders hooks from, the name the trace records, and the reason the test must skip, if any of the run's skip conditions apply.
- ProtoTestResult
The final result reported by a test-framework adapter.
- ProtoTestScope
One test's lifecycle as a scope: start it from a prepared test, run the framework's body, then let the scope complete the lifecycle. Teardown failures are recorded as findings by the lifecycle. By default the scope then fails the test: a body that passed is reported as failed, and a body that failed keeps that failure with the cleanup attached. A skipped or unknown body also fails when cleanup fails. Report records the finding and leaves the reported result alone, so every adapter shares one policy.
- ProtoTestSkip
Evaluates the skip conditions of a resolved attribute set.
- ProtoTestTrace
One test's slice of the run: its outcome, its entries and the artifacts it captured.
- ProtoTraceArtifact
A file the run captured as evidence: an attachment, or an artifact an integration wrote.
- ProtoTraceAttachmentRecord
An artifact the test attached; the file itself lives in the bundle's artifacts.
- ProtoTraceContent
Caps long payloads before they become trace sections, so a trace stays a trace and not a dump. JSON is pretty-printed before it is capped; anything else is capped as written.
- ProtoTraceEntity
The current state of one thing the run composed: a client, context, resource, server or capability. Entities are state, not history: an entity appears once in the artifact with its latest state and its versions, and entries refer to it by EntityId.
- ProtoTraceEntityKinds
The entity kinds ProtoTest itself records; an integration may define its own.
- ProtoTraceEntry
One row of the trace: a timed operation or an event, with its attributes and outcome.
- ProtoTraceError
A failure recorded on a trace entry, however the runner reported it.
- ProtoTraceFindingRecord
Evidence worth reporting that is deliberately not a failure.
- ProtoTraceItemKeys
Builds the identity segments ProtoTrace uses for tracked values. A tracked value is the item kind
valuewith the id{type}:{identity}, where{type}is the CLR type name in snake_case: anInvoiceLinebecomesinvoice_line:42. An application that emits its own identity attribute (invoice_line.number) uses the same segment, so both sides describe one value.
- ProtoTraceObservationRecord
A semantic fact the test emitted on purpose.
- ProtoTraceOperation
A timed operation in a ProtoTest execution trace.
- ProtoTraceOptions
Options for the automatic execution trace: whether it is collected, where it is written and what travels with it. Code values are the only source;
ConfigureTracingsupplies them.
- ProtoTraceRecord
Deliberate evidence: what the test observed, attached, found and proved. The record axis is separate from the timeline and the world; items reference the operation (and often the value) they belong to, and never duplicate what those axes already carry.
- ProtoTraceRun
The whole run as a
.prototracereads it: every test, plus the run-level entries, entities and values. FormatVersion tells a reader how to interpret the rest.
- ProtoTraceSection
A labelled block inside an operation. Integrations attach sections where the data is known; the viewer renders them under the operation, and the inspector reads the same sections deeper.
- ProtoTraceSectionItem
One item of a fields, checks or diff section. Fields use Value; checks use Value and Detail with a Tone; diff uses Label as the property path with expected in Value and actual in Detail.
- ProtoTraceValue
A domain object the run touched - a tenant, project, invoice, message. Values are the data side of the trace: identity plus versions, so a reader can follow how a value changed, not just that it appeared.
- ProtoTraceValueFormatter
Serializes a value into compact, cycle-safe, redacted JSON for trace attributes. Shared so every integration renders diagnostic values the same way.
- ProtoTraceVersion
One state of a world item, and what produced it. Shared by values and entities.
- ProtoTraceVisibility
What a run could see, recorded so a gap is explained rather than implied: visibility is integration depth, not hosting mode.
- ProtoTraceWriterExtensions
Reduces the start/await/succeed-or-fail boilerplate repeated across ProtoTest integrations.
- ProtoUriSanitizer
Text-level redaction for the addresses integrations trace: URI user-info (credentials) is removed unconditionally, and the values of well-known sensitive query parameters are replaced. Shared by HTTP, gRPC, messaging and web so one policy cannot drift between packages.
- RequiresApplicationAttribute
Skips the test unless the suite declares the named application through
AddApplication, so an application-specific test reads as skipped when the suite was composed without it instead of failing at the first accessor.
- RequiresCapabilityAttribute
Skips the test unless the host is composed with a capability of the given kind - for example a test-side domain that only exists when the suite owns the store. The kind is open, like capability kinds themselves; ProtoCapabilityKinds lists the built-in ones.
- RequiresInProcessAttribute
Skips the test unless the application runs in-process: in-process services, transactional isolation and a test-side composition of the application's own code only exist in that hosting mode.
- RequiresServerAttribute
Skips the test unless the host is composed with the named ASP.NET Core server, for example the instance registered by
AddAspNetCoreServer<TProgram>(name). The check addresses the capability's Instance - the server name - so a configured address that drops one named server does not satisfy a gate for another.
- RequiresTestClockAttribute
Skips the test unless the run's clock is authoritative for the application under test: the winning in-process application server and a hosted worker bridge the test clock into the process they serve. A test that advances the clock against an application running in its own process - published, container, AppHost or loopback - must carry the gate instead of asserting a time the application never saw.
- RequiresWorkerAttribute<TProgram>
Skips the test unless the run hosts the worker program
TProgramwithAddWorkerHost<TProgram>(). The check is the worker capability that registration declares, keyed by the program assembly's name, so a typo in a string cannot turn a missing worker into a plausible skip.
Structs
- ProtoCoverageTotals
Coverage units counted across a set of report items: covered, uncovered and the rounded percentage.
- ProtoCoverageUnitPath
A coverage unit and the path that names it in its report.
- ProtoPollResult<T>
The outcome of a PollAsync<T>(Func<CancellationToken, ValueTask<T>>, Func<T, bool>, TimeSpan, TimeSpan, CancellationToken) call.
- ProtoTestId
Numeric identifier for one test execution. Its string representation preserves the configured width.
- ProtoTraceScope
A lightweight fluent descriptor for a traced operation. Create one with Operation(IProtoTraceWriter, string, string, string), refine it with During(ProtoTracePhase), Parent(string?) and With(string, string?), then either run traced work through RunAsync(Func<ValueTask>) or open a handle with Begin().
Interfaces
- IProtoApplicationBuilder
Configures one named application under test. Integrations extend it, for example with
app.AddRest(rest => rest.AddClient("Orders")), to expose the protocols and clients the application supports. The first client registered for a protocol becomes that protocol's default.
- IProtoApplicationSkipCondition
A skip condition whose answer depends on the application the test selected with ApplicationAttribute. The runner resolves that selection from the same attribute set it is about to run and passes the application name here, so a condition that targets an application can skip honestly in a run where another application is live. A condition that ignores the selection implements IProtoSkipCondition only.
- IProtoBinaryContent
A named binary payload a test produced - a downloaded report, an exported document. Integrations that consume files accept this instead of a response type, so REST, GraphQL or an attachment can feed them without any of them knowing about each other.
- IProtoClientCompletion
A client that must finish work before attachments are published. Core calls CompleteAsync() after the test's teardown hooks, in reverse registration order, and lets the client registry dispose it afterwards; a failure fails the test.
- IProtoClientInitializer
Defines a contract for initializing and registering client instances (e.g., HttpClient, GrpcChannel) into the active ProtoExecutionContext.
- IProtoClientInitializer<TClient>
Defines a client initializer for a specific client type.
- IProtoCollector
Consumes observations during test execution. Reporting is optional and exposed separately through IProtoReportSource.
- IProtoConfigurableOptions
An options (or sink) type whose properties can be layered with values from a fixed "ProtoTest:..." configuration section after code-based defaults are applied.
- IProtoConfiguredInfrastructure
Infrastructure that needs the run's collected state while it starts - settings earlier pieces provided and the suite's configuration, which are complete only once those pieces have started. The host prefers this overload over StartAsync(CancellationToken) when a piece implements it, so an in-process worker can read the database or broker a container just started, and a readiness probe can read the address a settings piece published.
- IProtoConnectionInfrastructure
Infrastructure that hands the application under test a connection string.
- IProtoContext
Marker interface for custom contextual data stored in a ProtoExecutionContext.
- IProtoHostBuilder
Defines the builder contract for constructing and configuring a ProtoHost.
- IProtoInfrastructure
Something the run provides for itself - a database, a broker, a storage emulator. The host starts every registered piece after the run hooks, records it as a run entity, and releases it with the run, so a test suite declares what it needs instead of starting things by hand.
- IProtoProviderChainBuilder
Builds one target's provider chain. Providers are added in priority order: the first whose condition holds serves the target, and every later provider is recorded skipped with the reason.
- IProtoProviderCondition
When one provider can serve its target. Conditions are evaluated in chain order against the resolved configuration; the first that holds wins, so the provider order is the priority of the environments the chain describes.
- IProtoReportSource
Produces a snapshot of normalized items for end-of-run reporting.
- IProtoResource
Something the current test owns. Resources are released in reverse registration order during teardown, after test hooks and attributes have run; the test's clients are part of the same ordered release, so a resource registered after a client releases before it.
- IProtoRunApplicationTransport
Serves an application that has no address to the run itself, before any test: an in-process server implements it. ApplicationClientAsync(string) uses it when the application has no configured or published address.
- IProtoRunGate
Evaluates the evidence a run collected and can fail the run. Gates run once the suite has finished, before reports are written, so a failed gate still produces its report.
- IProtoRunHook
Defines lifecycle hooks that run once per test suite execution (before all tests start and after all tests finish).
- IProtoSettingsInfrastructure
Infrastructure that fills configuration keys with values only it can know after starting, for example the address of a standalone application a browser should visit.
- IProtoSink
Defines a contract for exporting normalized report data.
- IProtoSinkArtifactSource
Exposes files produced by a sink so tracing can bundle them as run-level artifacts.
- IProtoSkipCondition
A condition that can stop a test before its lifecycle starts, with a reason the runner can report. Adapters evaluate these before starting the test; a runner that does not evaluate them runs the test, so the contract stays opt-in.
- IProtoStartupEvidence
Infrastructure that can report what happened while it started - attempts, the wait it spent, the last error it saw. The host merges the evidence into the run entity it records for the piece, so a readiness wait is visible in the trace without an integration of its own.
- IProtoTargetBuilder
Configures observation collection for a named target.
- IProtoTargetProvider
A run piece that can serve a target - an application's address, a store, a broker or a worker. A target registers its providers in priority order; the first provider whose condition holds serves it, so only that provider's piece starts and only that provider's capabilities are declared.
- IProtoTestAssemblyHost<TSelf>
The contract an adapter's assembly class implements so the host base can show that adapter's own "not initialized" guidance. Adapters implement it explicitly, keeping it off their public surface.
- IProtoTestAttachmentPublisher
Publishes Core attachments to a test framework or another artifact destination.
- IProtoTestHook
Defines a lifecycle hook executed before and after each test.
- IProtoTraceSource
Provides immutable snapshots of the automatic ProtoTest execution trace.
- IProtoTraceWriter
Records automatic execution operations and events. This API primarily exists for ProtoTest integrations.
Enums
- ProtoCleanupFailureMode
What a failing cleanup does to the test the runner reports. Cleanup is the work after the body: after-test hooks and attributes, publishing attachments, releasing resources and disposing clients.
- ProtoClientOwnership
Who disposes a client registered for a test.
- ProtoFlowFailureMode
How a flow treats a failing step.
- ProtoResourceScope
How long an owned resource lives.
- ProtoResourceState
Describes what happened to an owned resource.
- ProtoRunGateOutcome
How a Run gate evaluated.
- ProtoTraceEntryKind
Whether an entry is a timed operation or a point-in-time event.
- ProtoTraceOutcome
How an entry ended. The vocabulary the reports and gates read, so adapters share it.
- ProtoTracePhase
The phase of the run an entry belongs to.
- ProtoTraceSectionKind
The closed vocabulary of operation sections. A viewer renders these four kinds and nothing else, so an integration describes what happened in data, never in markup or styling.
- ProtoTraceValueSource
Where a value version came from, so a reader can tell "not visible" from "did not happen".