# thomhurst/tunit

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/thomhurst-tunit).**

3,744 stars · 112 forks · C# · mit

## Links

- GitHub: https://github.com/thomhurst/TUnit
- Homepage: https://tunit.dev/
- awesome-repositories: https://awesome-repositories.com/repository/thomhurst-tunit.md

## Topics

`csharp` `dotnet` `test` `testing`

## Description

TUnit is a comprehensive C# testing framework, mocking library, and fluent assertion tool. It utilizes source generation for test discovery and mock creation, ensuring compatibility with Native AOT and IL trimming by eliminating the need for runtime reflection and proxies.

The framework provides specialized capabilities for integration testing, including the management of distributed application lifecycles, isolated database schemas, and the correlation of telemetry and logs across process boundaries via OTLP. It also includes an HTTP testing utility to intercept network exchanges and mock API responses.

Broad capability areas cover data-driven testing with combinatorial generation, a type-safe fluent assertion library for validating complex states, and a sophisticated dependency injection system for managing shared test resources. The toolset also includes observability features such as distributed trace visualization and detailed HTML reporting.

The project provides a command-line interface and integrates with standard IDE test runners and CI/CD pipelines.

## Tags

### Testing & Quality Assurance

- [Test Frameworks](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/testing-frameworks/test-frameworks.md) — A comprehensive test runner and assertion library that uses source generation for Native AOT compatibility.
- [Unit Testing Frameworks](https://awesome-repositories.com/f/testing-quality-assurance/unit-testing-frameworks.md) — Serves as a comprehensive framework for defining and executing automated unit tests using source generation. ([source](https://tunit.dev/docs/getting-started/writing-your-first-test.md))
- [Application Lifecycle Management](https://awesome-repositories.com/f/testing-quality-assurance/application-lifecycle-management.md) — Automates the lifecycle of distributed application resources, ensuring they are built, started, and disposed of correctly. ([source](https://tunit.dev/docs/examples/aspire.md))
- [Boolean-Return Assertions](https://awesome-repositories.com/f/testing-quality-assurance/assertion-macros/boolean-return-assertions.md) — Validates boolean and nullable boolean expressions using expressive assertion methods. ([source](https://tunit.dev/docs/assertions/boolean.md))
- [Boolean Assertions](https://awesome-repositories.com/f/testing-quality-assurance/boolean-assertions.md) — Provides fundamental assertions to verify whether boolean conditions are true or false. ([source](https://tunit.dev/docs/assertions/library.md))
- [Compile-Time Test Validation](https://awesome-repositories.com/f/testing-quality-assurance/compile-time-test-validation.md) — Identifies and executes tests using compile-time source generation for safety and AOT support. ([source](https://tunit.dev/docs/execution/engine-modes.md))
- [Custom Assertions](https://awesome-repositories.com/f/testing-quality-assurance/custom-assertions.md) — Generates specialized, domain-specific assertions from existing logic using source generation for improved test readability. ([source](https://tunit.dev/docs/assertions/extensibility/custom-assertions.md))
- [Data-Driven Testing](https://awesome-repositories.com/f/testing-quality-assurance/data-driven-testing.md) — Enables generating multiple test cases using fixed arguments, combinatorial matrices, or custom data sources. ([source](https://cdn.jsdelivr.net/gh/thomhurst/tunit@main/README.md))
- [Fluent Assertion Chaining](https://awesome-repositories.com/f/testing-quality-assurance/fluent-assertion-chaining.md) — Implements a chainable validation syntax that returns the asserted subject to enable subsequent operations on the same value. ([source](https://tunit.dev/docs/assertions/awaiting.md))
- [Fluent Assertions](https://awesome-repositories.com/f/testing-quality-assurance/fluent-assertions.md) — Implements a readable, chainable syntax to validate values, collections, strings, and exceptions. ([source](https://tunit.dev/docs/intro.md))
- [Test Lifecycle and Execution Control](https://awesome-repositories.com/f/testing-quality-assurance/general-testing-utilities/test-utilities-assertions/test-lifecycle-execution-control.md) — Implements a comprehensive system for managing test lifecycles, ensuring cleanup occurs across multiple scope levels. ([source](https://tunit.dev/docs/comparison/attributes.md))
- [Test Lifecycle Hooks](https://awesome-repositories.com/f/testing-quality-assurance/general-testing-utilities/test-utilities-assertions/test-lifecycle-execution-control/test-lifecycle-hooks.md) — Supports native async setup and teardown hooks for managing test environment lifecycles. ([source](https://tunit.dev/docs/migration/xunit))
- [HTTP Testing Utilities](https://awesome-repositories.com/f/testing-quality-assurance/http-testing-utilities.md) — Provides a utility for intercepting network exchanges, mocking API responses, and verifying outgoing HTTP requests.
- [Integration Testing](https://awesome-repositories.com/f/testing-quality-assurance/integration-testing.md) — Executes parallel integration tests with per-test isolation while sharing global infrastructure like containers. ([source](https://tunit.dev/docs/examples/aspnet.md))
- [Mock Behavior Configuration](https://awesome-repositories.com/f/testing-quality-assurance/mock-behavior-configuration.md) — Allows defining return values, exceptions, and callbacks for mocked methods, including sequential call outcomes. ([source](https://tunit.dev/docs/writing-tests/mocking/setup.md))
- [Numeric Assertions](https://awesome-repositories.com/f/testing-quality-assurance/numeric-assertions.md) — Compares numeric values for equality or relative order with precision-based tolerance for floating-point errors. ([source](https://tunit.dev/docs/assertions/numeric.md))
- [Parallel Test Execution](https://awesome-repositories.com/f/testing-quality-assurance/parallel-test-execution.md) — Runs test suites concurrently by default to provide faster feedback and encourage isolated test design. ([source](https://tunit.dev/docs/guides/philosophy.md))
- [Compile-Time Mock Generation](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/dependency-mocking/automated-mock-generation/compile-time-mock-generation.md) — Produces mock implementations during the build process to ensure compatibility with Native AOT and IL trimming.
- [Integration Testing Frameworks](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/e2e-integration-testing/integration-testing-frameworks.md) — Manages distributed application lifecycles, isolates database schemas, and correlates telemetry across processes.
- [Partial Mocks](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/mocking-frameworks/partial-mocks.md) — Supports creating test doubles that selectively override specific methods while delegating other calls to the real implementation. ([source](https://tunit.dev/docs/writing-tests/mocking/setup.md))
- [Test Execution and Orchestration](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/test-execution-orchestration.md) — Utilizes compile-time source generation to discover and execute unit, integration, and acceptance tests at scale. ([source](https://tunit.dev/docs/intro.md))
- [Test Case Annotations](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/test-execution-orchestration/test-case-generators/test-case-deduplication/test-case-annotations.md) — Provides the primary mechanism to mark methods as executable test cases and theories. ([source](https://tunit.dev/docs/comparison/attributes.md))
- [Collection Content Validations](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/testing-frameworks/test-frameworks/assertions-and-validation/assertion-validation-utilities/assertion-libraries/collection-membership-assertions/collection-content-validations.md) — Provides specialized assertions to verify the presence, count, and sequential order of elements in collections. ([source](https://tunit.dev/docs/assertions/getting-started.md))
- [Asynchronous Assertions](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/testing-frameworks/test-frameworks/assertions-and-validation/assertion-validation-utilities/assertion-libraries/execution-assertions/assertion-failure-handlers/value-property-assertions/asynchronous-assertions.md) — Provides specialized computation expressions for validating asynchronous operations without manual wrapping. ([source](https://tunit.dev/docs/assertions/fsharp.md))
- [Exception Assertions](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/testing-frameworks/test-frameworks/assertions-and-validation/assertion-validation-utilities/assertion-libraries/execution-assertions/exception-assertions.md) — Validates that code throws a specific exception type for both synchronous and asynchronous operations. ([source](https://tunit.dev/docs/assertions/exceptions.md))
- [Fluent Assertions](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/testing-frameworks/test-frameworks/assertions-and-validation/assertion-validation-utilities/fluent-assertions.md) — Provides a chainable, type-safe validation syntax restricted to logically valid operations for a specific data type.
- [State Expectation Validation](https://awesome-repositories.com/f/testing-quality-assurance/state-expectation-validation.md) — Provides a chainable syntax for verifying that values meet specific expectations including equality, range, and membership. ([source](https://tunit.dev/docs/assertions/getting-started.md))
- [Source-Generated Discovery](https://awesome-repositories.com/f/testing-quality-assurance/test-discovery-mechanisms/source-generated-discovery.md) — Identifies and registers tests at compile time using source generation to eliminate runtime reflection and support Native AOT.
- [Native AOT Test Suites](https://awesome-repositories.com/f/testing-quality-assurance/test-suite-execution/native-aot-test-suites.md) — Executes tests against ahead-of-time compiled binaries to ensure correctness in Native AOT environments. ([source](https://tunit.dev/docs/examples/tunit-ci-pipeline.md))
- [AOT-Compatible Data Sources](https://awesome-repositories.com/f/testing-quality-assurance/test-suite-execution/native-aot-test-suites/aot-compatible-data-sources.md) — Provides test data via static methods and async streams to maintain Native AOT compatibility. ([source](https://tunit.dev/docs/writing-tests/aot.md))
- [Test Lifecycle Hooks](https://awesome-repositories.com/f/testing-quality-assurance/testing-infrastructure-management/test-orchestration/test-setup-orchestrators/test-lifecycle-hooks.md) — Provides native async setup and teardown hooks at session, assembly, class, and test levels. ([source](https://cdn.jsdelivr.net/gh/thomhurst/tunit@main/README.md))
- [Type Assertions](https://awesome-repositories.com/f/testing-quality-assurance/type-assertions.md) — Verifies that values are of a specific type or compatible via inheritance and interfaces. ([source](https://tunit.dev/docs/assertions/types.md))
- [Type-Safe Assertions](https://awesome-repositories.com/f/testing-quality-assurance/type-safe-assertions.md) — Ensures logic errors are prevented by limiting assertion methods to those compatible with the specific data type being tested. ([source](https://tunit.dev/docs/guides/philosophy.md))
- [Fluent Assertions](https://awesome-repositories.com/f/testing-quality-assurance/unit-testing-frameworks/fluent-assertions.md) — Provides a chainable, readable API for verifying software behavior that mirrors natural language. ([source](https://tunit.dev/docs/assertions/should-syntax.md))
- [Assembly-Level Hooks](https://awesome-repositories.com/f/testing-quality-assurance/assembly-level-hooks.md) — Provides static methods to prepare or clean up the global environment once per assembly execution. ([source](https://tunit.dev/docs/migration/nunit))
- [Assertion Grouping](https://awesome-repositories.com/f/testing-quality-assurance/assertion-grouping.md) — Collects and reports multiple failing assertions within a single scope to provide a comprehensive view of failures. ([source](https://tunit.dev/docs/assertions/getting-started.md))
- [Asynchronous Task Assertions](https://awesome-repositories.com/f/testing-quality-assurance/asynchronous-task-assertions.md) — Implements assertions to validate whether asynchronous tasks have completed, faulted, or finished successfully. ([source](https://tunit.dev/docs/assertions/tasks-and-async.md))
- [Automated Test Data Generation](https://awesome-repositories.com/f/testing-quality-assurance/automated-test-data-generation.md) — Produces strongly typed or dynamic test arguments at discovery time to populate test parameters. ([source](https://tunit.dev/docs/extending/data-source-generators.md))
- [Mock Interaction Recorders](https://awesome-repositories.com/f/testing-quality-assurance/automation-interaction-tools/test-automation-tools/test-recording-tools/mock-interaction-recorders.md) — Records values passed to mocked methods during execution for subsequent inspection and validation. ([source](https://tunit.dev/docs/writing-tests/mocking/argument-matchers.md))
- [Interaction Verifiers](https://awesome-repositories.com/f/testing-quality-assurance/automation-interaction-tools/test-automation-tools/test-recording-tools/mock-interaction-recorders/interaction-verifiers.md) — Checks if specific methods were called on a mock object, including call counts and arguments. ([source](https://tunit.dev/docs/writing-tests/mocking/verification.md))
- [CI Integration Testing](https://awesome-repositories.com/f/testing-quality-assurance/ci-integration-testing.md) — Runs test suites across multiple operating systems and versions within automated pipelines to verify cross-platform compatibility. ([source](https://tunit.dev/docs/examples/tunit-ci-pipeline.md))
- [Pipeline Report Generators](https://awesome-repositories.com/f/testing-quality-assurance/ci-integration-testing/pipeline-report-generators.md) — Produces test results in formats compatible with common CI/CD workflow tools to surface failures. ([source](https://tunit.dev/docs/execution/ci-cd-reporting.md))
- [Code Coverage Analysis](https://awesome-repositories.com/f/testing-quality-assurance/code-coverage-analysis.md) — Tracks executed code paths during tests and exports the results in standardized coverage formats. ([source](https://tunit.dev/docs/reference/command-line-flags.md))
- [Collection Equivalency Assertions](https://awesome-repositories.com/f/testing-quality-assurance/collection-equivalency-assertions.md) — Verifies if two collections contain the same elements, supporting both order-independent and order-sensitive checks. ([source](https://tunit.dev/docs/assertions/collections.md))
- [Collection Order Assertions](https://awesome-repositories.com/f/testing-quality-assurance/collection-order-assertions.md) — Confirms that a collection is sorted in ascending or descending order, or ordered by a specific property. ([source](https://tunit.dev/docs/assertions/collections.md))
- [Collection Size Assertions](https://awesome-repositories.com/f/testing-quality-assurance/collection-size-assertions.md) — Verifies that a collection has an exact count, is not empty, or contains exactly one item. ([source](https://tunit.dev/docs/assertions/collections.md))
- [Custom Assertion Predicates](https://awesome-repositories.com/f/testing-quality-assurance/custom-assertion-predicates.md) — Evaluates a value against a user-defined predicate or transforms the value before applying a standard assertion. ([source](https://tunit.dev/docs/assertions/getting-started.md))
- [Custom Data Source Integrations](https://awesome-repositories.com/f/testing-quality-assurance/custom-data-source-integrations.md) — Accepts custom attributes implementing a data source interface to provide tailored input values for tests. ([source](https://tunit.dev/docs/writing-tests/combined-data-source.md))
- [Testing Framework Extenders](https://awesome-repositories.com/f/testing-quality-assurance/custom-test-reporters/testing-framework-extenders.md) — Enables the creation of custom data sources and output formatters to modify test behavior and reporting. ([source](https://tunit.dev/docs/intro.md))
- [Delegate Mocks](https://awesome-repositories.com/f/testing-quality-assurance/dependency-mocking/delegate-mocks.md) — Generates mock implementations for Action, Func, and custom delegate types to simulate functional dependencies. ([source](https://tunit.dev/docs/writing-tests/mocking/setup.md))
- [Dictionary Assertions](https://awesome-repositories.com/f/testing-quality-assurance/dictionary-assertions.md) — Provides specialized assertions to verify if dictionaries contain expected keys or values. ([source](https://tunit.dev/docs/assertions/library.md))
- [Custom Test Attributes](https://awesome-repositories.com/f/testing-quality-assurance/general-testing-utilities/test-configuration/test-execution-overrides/test-logic-overrides/custom-test-attributes.md) — Provides the ability to create custom attributes for specialized skip conditions and retry behaviors. ([source](https://cdn.jsdelivr.net/gh/thomhurst/tunit@main/README.md))
- [Test Isolation](https://awesome-repositories.com/f/testing-quality-assurance/general-testing-utilities/test-isolation.md) — Prevents state leakage by creating a new instance of the test class for every individual test method. ([source](https://tunit.dev/docs/guides/philosophy.md))
- [Test Metadata](https://awesome-repositories.com/f/testing-quality-assurance/general-testing-utilities/test-metadata.md) — Allows defining and formatting test identities and display names to organize test reporting. ([source](https://tunit.dev/docs/migration/testcontext-interface-organization.md))
- [Test Result Reporters](https://awesome-repositories.com/f/testing-quality-assurance/general-testing-utilities/test-reporters/test-result-reporters.md) — Generates formatted report files of test execution outcomes and supports custom output directories. ([source](https://tunit.dev/docs/reference/command-line-flags.md))
- [HTML Dashboard Reports](https://awesome-repositories.com/f/testing-quality-assurance/general-testing-utilities/test-reporters/test-result-reporters/html-dashboard-reports.md) — Produces a visual HTML dashboard of test results including pass rates and failure analysis. ([source](https://tunit.dev/docs/guides/html-report.md))
- [Assertion Aggregators](https://awesome-repositories.com/f/testing-quality-assurance/general-testing-utilities/test-utilities-assertions/assertion-aggregators.md) — Collects multiple failing assertions within a defined scope to report them collectively instead of stopping at the first failure. ([source](https://tunit.dev/docs/assertions/combining-assertions.md))
- [Asynchronous Polling Mechanisms](https://awesome-repositories.com/f/testing-quality-assurance/general-testing-utilities/test-utilities-assertions/assertion-extensions-modes/asynchronous-interaction-utilities/asynchronous-polling-mechanisms.md) — Repeatedly evaluates a value source until a specified assertion passes or a timeout is reached. ([source](https://tunit.dev/docs/assertions/tasks-and-async.md))
- [State Assertions](https://awesome-repositories.com/f/testing-quality-assurance/general-testing-utilities/test-utilities-assertions/assertion-extensions-modes/asynchronous-interaction-utilities/element-state-assertions/state-assertions.md) — Implements awaitable assertion objects to verify boolean returns and overall system state. ([source](https://tunit.dev/docs/getting-started/writing-your-first-test.md))
- [Asynchronous Assertions](https://awesome-repositories.com/f/testing-quality-assurance/general-testing-utilities/test-utilities-assertions/assertion-extensions-modes/asynchronous-interaction-utilities/element-state-assertions/state-assertions/asynchronous-assertions.md) — Provides asynchronous assertions to check expected outcomes with detailed failure messaging. ([source](https://cdn.jsdelivr.net/gh/thomhurst/tunit@main/README.md))
- [Test Assertion Extensions](https://awesome-repositories.com/f/testing-quality-assurance/general-testing-utilities/test-utilities-assertions/assertion-extensions-modes/test-assertion-extensions.md) — Automatically generates fluent counterparts for user-defined assertion extensions to provide domain-specific validation logic. ([source](https://tunit.dev/docs/assertions/should-syntax.md))
- [Test Execution Controls](https://awesome-repositories.com/f/testing-quality-assurance/general-testing-utilities/test-utilities-assertions/test-lifecycle-execution-control/test-execution-controls.md) — Provides controls for test repetition, retry logic, timeouts, and skipping. ([source](https://tunit.dev/docs/comparison/attributes.md))
- [Asynchronous Data Initialization](https://awesome-repositories.com/f/testing-quality-assurance/general-testing-utilities/test-utilities-assertions/test-lifecycle-execution-control/test-execution-controls/asynchronous-test-handling/asynchronous-data-initialization.md) — Enables asynchronous setup tasks during test discovery to fetch external data or generate dynamic test cases. ([source](https://tunit.dev/docs/extending/extension-points.md))
- [Conditional Skipping](https://awesome-repositories.com/f/testing-quality-assurance/general-testing-utilities/test-utilities-assertions/test-lifecycle-execution-control/test-execution-controls/conditional-skipping.md) — Marks tests as skipped at runtime when specific conditions prevent their execution. ([source](https://tunit.dev/docs/extending/exception-handling.md))
- [Test Skipping Mechanisms](https://awesome-repositories.com/f/testing-quality-assurance/general-testing-utilities/test-utilities-assertions/test-lifecycle-execution-control/test-execution-controls/test-skipping-mechanisms.md) — Allows marking specific tests or classes as skipped so they are not executed during standard runs. ([source](https://tunit.dev/docs/writing-tests/explicit.md))
- [Test Execution Timeouts](https://awesome-repositories.com/f/testing-quality-assurance/general-testing-utilities/test-utilities-assertions/test-lifecycle-execution-control/test-execution-timeouts.md) — Defines global time limits for test execution to prevent hanging processes. ([source](https://tunit.dev/docs/reference/command-line-flags.md))
- [Timeout Enforcements](https://awesome-repositories.com/f/testing-quality-assurance/general-testing-utilities/test-utilities-assertions/test-lifecycle-execution-control/test-execution-timeouts/timeout-enforcements.md) — Ensures asynchronous tasks complete within a specified time limit or fail the test. ([source](https://tunit.dev/docs/assertions/tasks-and-async.md))
- [Test Parameterization](https://awesome-repositories.com/f/testing-quality-assurance/general-testing-utilities/test-utilities-assertions/test-lifecycle-execution-control/test-parameterization.md) — Produces multiple test cases from sets of arguments or cross-product matrices of parameter combinations. ([source](https://tunit.dev/docs/guides/performance.md))
- [Test Retry Strategies](https://awesome-repositories.com/f/testing-quality-assurance/general-testing-utilities/test-utilities-assertions/test-lifecycle-execution-control/test-retry-strategies.md) — Automatically reruns failed tests based on configurable retry strategies to mitigate flakiness. ([source](https://tunit.dev/docs/execution/retrying.md))
- [Failure Flow Control](https://awesome-repositories.com/f/testing-quality-assurance/general-testing-utilities/test-utilities-assertions/test-lifecycle-execution-control/transient-failure-reruns/failure-flow-control.md) — Terminates the test run immediately upon the first failure for rapid feedback. ([source](https://tunit.dev/docs/examples/tunit-ci-pipeline.md))
- [Mock Parameter Control](https://awesome-repositories.com/f/testing-quality-assurance/mock-parameter-control.md) — Allows setting specific values for out and ref parameters during mocked method calls using strongly-typed methods. ([source](https://tunit.dev/docs/writing-tests/mocking/setup.md))
- [Mocking Frameworks](https://awesome-repositories.com/f/testing-quality-assurance/mocking-frameworks.md) — Checks if specific members of a mocked object were called using generated extension methods. ([source](https://tunit.dev/docs/writing-tests/mocking.md))
- [Numeric Range Assertions](https://awesome-repositories.com/f/testing-quality-assurance/numeric-range-assertions.md) — Checks if numeric values are positive, negative, or within specified inclusive ranges. ([source](https://tunit.dev/docs/assertions/equality-and-comparison.md))
- [Concurrency Limiters](https://awesome-repositories.com/f/testing-quality-assurance/parallel-test-execution/concurrency-limiters.md) — Caps the number of tests running simultaneously to prevent system resource exhaustion. ([source](https://tunit.dev/docs/comparison/framework-differences.md))
- [Property-Based Testing](https://awesome-repositories.com/f/testing-quality-assurance/property-based-testing.md) — Generates random test data to verify software invariants across a wide range of inputs. ([source](https://tunit.dev/docs/examples/fscheck.md))
- [Multi-Interface Mocks](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/dependency-mocking/automated-mock-generation/dynamic-mock-objects/multi-interface-mocks.md) — Creates a single mock object that implements several interfaces simultaneously to satisfy multiple dependencies. ([source](https://tunit.dev/docs/writing-tests/mocking/setup.md))
- [Recursive Mock Generation](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/dependency-mocking/automated-mock-generation/dynamic-mock-objects/recursive-mock-generation.md) — Automatically generates functional mock objects for interface return types to avoid nulls in deep object graphs. ([source](https://tunit.dev/docs/writing-tests/mocking/advanced.md))
- [Static Abstract Member Mocks](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/mocking-frameworks/protected-method-mocks/final-member-mocks/static-abstract-member-mocks.md) — Provides bridge interfaces to enable the mocking of interfaces containing static abstract members. ([source](https://tunit.dev/docs/writing-tests/mocking/setup.md))
- [Test Case Generators](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/test-execution-orchestration/test-case-generators.md) — Supplies test parameters from static or instance methods to automatically generate multiple test cases. ([source](https://tunit.dev/docs/writing-tests/method-data-source.md))
- [Collection Membership Assertions](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/testing-frameworks/test-frameworks/assertions-and-validation/assertion-validation-utilities/assertion-libraries/collection-membership-assertions.md) — Checks if a collection contains an item, is empty, has a specific count, or contains equivalent items regardless of order. ([source](https://tunit.dev/docs/assertions/library.md))
- [Collection Condition Assertions](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/testing-frameworks/test-frameworks/assertions-and-validation/assertion-validation-utilities/assertion-libraries/collection-membership-assertions/collection-condition-assertions.md) — Tests whether all items or at least one item in a collection satisfy a specific condition. ([source](https://tunit.dev/docs/assertions/collections.md))
- [Execution Assertions](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/testing-frameworks/test-frameworks/assertions-and-validation/assertion-validation-utilities/assertion-libraries/execution-assertions.md) — Executes functions or actions to verify their return values or catch thrown exceptions. ([source](https://tunit.dev/docs/assertions/delegates.md))
- [Exception Chain Assertions](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/testing-frameworks/test-frameworks/assertions-and-validation/assertion-validation-utilities/assertion-libraries/execution-assertions/exception-assertions/exception-chain-assertions.md) — Traverses the exception chain to validate the type and properties of nested inner exceptions. ([source](https://tunit.dev/docs/assertions/exceptions.md))
- [Custom Matchers](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/testing-frameworks/test-frameworks/assertions-and-validation/assertion-validation-utilities/snapshot-testing-utilities/custom-matcher-pipelines/custom-matchers.md) — Allows the definition of custom classes to implement reusable matching logic for complex mock argument conditions. ([source](https://tunit.dev/docs/writing-tests/mocking/argument-matchers.md))
- [Inline Test Case Reproducers](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/testing-frameworks/test-frameworks/assertions-and-validation/test-case-definitions/bug-validation-tests/inline-test-case-reproducers.md) — Enables consistent reproduction of failed property tests using stored seeds. ([source](https://tunit.dev/docs/examples/fscheck.md))
- [Parametrized Test Cases](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/testing-frameworks/test-frameworks/assertions-and-validation/test-case-definitions/parametrized-test-cases.md) — Supplies multiple sets of input values to test methods via inline values, method sources, or fixtures. ([source](https://tunit.dev/docs/writing-tests/data-driven-overview.md))
- [Test Repeaters](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/testing-frameworks/test-frameworks/assertions-and-validation/test-case-definitions/test-repeaters.md) — Runs tests multiple times at method, class, or assembly levels to detect intermittent failures. ([source](https://tunit.dev/docs/execution/repeating.md))
- [CLI Test Runners](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/testing-frameworks/test-frameworks/execution-and-infrastructure/test-execution-runners/cli-test-runners.md) — Runs test suites using command line tools or executables to trigger test discovery and execution. ([source](https://tunit.dev/docs/getting-started/running-your-tests.md))
- [Reusable Infrastructure Patterns](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/testing-frameworks/test-frameworks/execution-and-infrastructure/test-infrastructure-configuration/reusable-infrastructure-patterns.md) — Allows creation of shared lifecycle hooks and base classes to standardize test logic across projects. ([source](https://tunit.dev/docs/extending/libraries.md))
- [Test Runner Integrations](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/testing-frameworks/test-frameworks/test-runner-integrations.md) — Connects to graphical testing interfaces via a standard protocol to discover and run tests within an editor. ([source](https://tunit.dev/docs/getting-started/running-your-tests.md))
- [String Assertions](https://awesome-repositories.com/f/testing-quality-assurance/string-assertions.md) — Provides a comprehensive set of assertions for checking substrings, prefixes, suffixes, and string lengths. ([source](https://tunit.dev/docs/assertions/library.md))
- [Temporal Assertions](https://awesome-repositories.com/f/testing-quality-assurance/temporal-assertions.md) — Validates if a date occurs before, after, or on a specific date. ([source](https://tunit.dev/docs/assertions/library.md))
- [Test Boilerplate Reduction](https://awesome-repositories.com/f/testing-quality-assurance/test-boilerplate-reduction.md) — Eliminates the requirement for mandatory base classes or class-level attributes when defining test suites. ([source](https://tunit.dev/docs/guides/philosophy.md))
- [Test Data Isolation](https://awesome-repositories.com/f/testing-quality-assurance/test-data-isolation.md) — Creates unique database schemas for each test execution to prevent cross-test data contamination. ([source](https://tunit.dev/docs/examples/aspnet.md))
- [Test Data Injection](https://awesome-repositories.com/f/testing-quality-assurance/test-data-management/test-data-templating/test-data-injection.md) — Provides flexible mechanisms for injecting new or shared data instances into tests. ([source](https://tunit.dev/docs/comparison/attributes.md))
- [Test Execution Filtering](https://awesome-repositories.com/f/testing-quality-assurance/test-execution-filtering.md) — Enables filtering of tests based on values provided by dynamic data sources during compile-time discovery. ([source](https://tunit.dev/docs/comparison/framework-differences.md))
- [Generic Test Instantiation](https://awesome-repositories.com/f/testing-quality-assurance/test-instantiation-strategies/generic-test-instantiation.md) — Generates explicit type combinations for generic test classes at compile time for AOT compatibility. ([source](https://tunit.dev/docs/writing-tests/aot.md))
- [Test Lifecycle Event Listeners](https://awesome-repositories.com/f/testing-quality-assurance/test-lifecycle-event-listeners.md) — Triggers custom actions at key lifecycle stages such as registration, start, and completion of tests. ([source](https://tunit.dev/docs/migration/testcontext-interface-organization.md))
- [Test Report Attachments](https://awesome-repositories.com/f/testing-quality-assurance/test-report-attachments.md) — Enables linking of screenshots, logs, and other files to individual tests for inclusion in CI/CD reports. ([source](https://tunit.dev/docs/writing-tests/artifacts.md))
- [HTTP Request Captures](https://awesome-repositories.com/f/testing-quality-assurance/test-report-attachments/http-request-captures.md) — Records outgoing requests and incoming responses during execution to verify network interactions through assertions. ([source](https://tunit.dev/docs/examples/aspnet.md))
- [Test Signature Analysis](https://awesome-repositories.com/f/testing-quality-assurance/test-signature-analysis.md) — Detects incorrect method signatures or missing keywords during compilation to ensure consistent test structures. ([source](https://cdn.jsdelivr.net/gh/thomhurst/tunit@main/README.md))
- [Test Execution Management](https://awesome-repositories.com/f/testing-quality-assurance/testing-infrastructure-management/test-execution-management.md) — Manages the parallelization and concurrency of test execution to optimize resource usage. ([source](https://tunit.dev/docs/migration/testcontext-interface-organization.md))
- [Execution Ordering](https://awesome-repositories.com/f/testing-quality-assurance/testing-infrastructure-management/test-execution-management/execution-ordering.md) — Allows defining the sequence of test execution to handle dependent operations. ([source](https://tunit.dev/docs/writing-tests/things-to-know.md))
- [Parallel Execution Managers](https://awesome-repositories.com/f/testing-quality-assurance/testing-infrastructure-management/test-execution-management/parallel-execution-managers.md) — Controls concurrency and worker process limits within specific test classes to manage resource usage. ([source](https://tunit.dev/docs/examples/playwright.md))
- [Test Dependency Managers](https://awesome-repositories.com/f/testing-quality-assurance/testing-infrastructure-management/test-orchestration/test-dependency-managers.md) — Enables retrieving result or state data from a preceding dependent test for use in subsequent assertions. ([source](https://tunit.dev/docs/writing-tests/ordering.md))
- [Lifecycle Hooks](https://awesome-repositories.com/f/testing-quality-assurance/testing-infrastructure-management/test-orchestration/test-setup-orchestrators/lifecycle-hooks.md) — Provides native async setup and teardown hooks to manage expensive resource initialization and cleanup.
- [Test Context Sharing](https://awesome-repositories.com/f/testing-quality-assurance/testing-infrastructure-management/test-orchestration/test-setup-orchestrators/test-lifecycle-hooks/test-context-sharing.md) — Provides a context object injected into test methods to share metadata and output logging. ([source](https://tunit.dev/docs/migration/xunit))
- [Type-Converting Assertion Chains](https://awesome-repositories.com/f/testing-quality-assurance/type-assertions/type-converting-assertion-chains.md) — Transforms the value being tested into a new type during an assertion sequence for subsequent checks. ([source](https://tunit.dev/docs/assertions/extensibility/extensibility-chaining-and-converting.md))

### Part of an Awesome List

- [HTTP Client Tracing](https://awesome-repositories.com/f/awesome-lists/devops/monitoring-and-tracing/http-client-tracing.md) — Instruments HTTP clients with tracing and correlation handlers to ensure test identifier propagation. ([source](https://tunit.dev/docs/guides/distributed-tracing.md))
- [Regex Assertions](https://awesome-repositories.com/f/awesome-lists/devtools/regex-and-pattern-matching/regex-pattern-matching/regex-assertions.md) — Provides powerful regex-based assertions to verify string formats and extract match details. ([source](https://tunit.dev/docs/assertions/regex-assertions.md))

### Data & Databases

- [Dependency Lifecycle Management](https://awesome-repositories.com/f/data-databases/resource-management/resource-lifecycle-managers/dependency-lifecycle-management.md) — Controls the sharing of injected objects across tests, classes, or assemblies to optimize resource usage. ([source](https://tunit.dev/docs/writing-tests/class-data-source.md))
- [Dictionary Construction](https://awesome-repositories.com/f/data-databases/multi-value-dictionaries/dictionary-construction.md) — Actually, this feature is a duplicate of f0; it provides assertions to verify the presence of specific keys and values in dictionaries. ([source](https://tunit.dev/docs/assertions/dictionaries.md))
- [Development Schema Isolation](https://awesome-repositories.com/f/data-databases/schema-extensions/development-schema-isolation.md) — Provides unique, isolated database schemas for individual tests to ensure data independence. ([source](https://tunit.dev/docs/examples/complex-test-infrastructure.md))

### Development Tools & Productivity

- [Distributed Resource Orchestration](https://awesome-repositories.com/f/development-tools-productivity/application-startup-configurations/distributed-resource-orchestration.md) — Controls the distributed application startup process via command-line arguments and custom health-check wait behaviors. ([source](https://tunit.dev/docs/examples/aspire.md))
- [Test Logging Utilities](https://awesome-repositories.com/f/development-tools-productivity/debugging-profiling-testing/test-execution-management/test-logging-utilities.md) — Captures diagnostic text and attaches files like screenshots to test runs for failure analysis. ([source](https://tunit.dev/docs/writing-tests/test-context.md))
- [Parallel Execution](https://awesome-repositories.com/f/development-tools-productivity/parallel-execution.md) — Constrains the number of concurrent operations to prevent resource exhaustion. ([source](https://tunit.dev/docs/extending/extension-points.md))
- [Real-Time Output Streaming](https://awesome-repositories.com/f/development-tools-productivity/real-time-output-streaming.md) — Streams real-time console output to IDE test explorers while tests are actively running. ([source](https://tunit.dev/docs/reference/environment-variables.md))

### Networking & Communication

- [Tracing Context Propagation](https://awesome-repositories.com/f/networking-communication/tracing-context-propagation.md) — Uses activity baggage to propagate test identifiers across network boundaries for log correlation. ([source](https://tunit.dev/docs/examples/opentelemetry.md))
- [HTTP Status Codes](https://awesome-repositories.com/f/networking-communication/http-clients/http-status-codes.md) — Provides assertions to verify if HTTP response status codes fall within expected success or error ranges. ([source](https://tunit.dev/docs/assertions/specialized-types.md))
- [API Response Simulators](https://awesome-repositories.com/f/networking-communication/network-traffic-processors/api-response-simulators.md) — Intercepts outgoing requests and returns predefined or dynamic responses to simulate external API behavior. ([source](https://tunit.dev/docs/writing-tests/mocking/http.md))

### Programming Languages & Runtimes

- [Build-Time Test Discovery](https://awesome-repositories.com/f/programming-languages-runtimes/source-code-generators/build-time-test-discovery.md) — Uses source generators to identify tests during compilation for Native AOT compatibility. ([source](https://cdn.jsdelivr.net/gh/thomhurst/tunit@main/README.md))
- [Ahead-Of-Time Compilation](https://awesome-repositories.com/f/programming-languages-runtimes/ahead-of-time-compilation.md) — Uses ahead-of-time compilation to accelerate the test discovery process and reduce runtime memory usage. ([source](https://tunit.dev/docs/guides/performance.md))
- [Return Value Interceptors](https://awesome-repositories.com/f/programming-languages-runtimes/block-value-returns/method-return-values/return-value-interceptors.md) — Allows defining custom providers to override the default values returned by unconfigured mocked methods. ([source](https://tunit.dev/docs/writing-tests/mocking/advanced.md))
- [Static Analysis Assertions](https://awesome-repositories.com/f/programming-languages-runtimes/compile-time-expressions/compile-time-conditional-branching/compile-time-assertions/static-analysis-assertions.md) — Detects unawaited asynchronous assertions and improper logical chaining via static analysis to prevent runtime errors. ([source](https://tunit.dev/docs/assertions/should-syntax.md))
- [Mock Property Definitions](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-safety/component-property-definitions/mock-property-definitions.md) — Configures getter and setter behaviors for properties with an automatic tracking mode for value storage. ([source](https://tunit.dev/docs/writing-tests/mocking/setup.md))
- [Test Dependency Resolution](https://awesome-repositories.com/f/programming-languages-runtimes/module-state-initializers/dependency-ordered-initializers/test-dependency-resolution.md) — Resolves a dependency graph of test data sources to ensure correct initialization and disposal order. ([source](https://tunit.dev/docs/writing-tests/nested-data-sources.md))
- [Argument Constraint Matchers](https://awesome-repositories.com/f/programming-languages-runtimes/programming-utilities/function-utilities/argument-collectors/splat-argument-validations/argument-constraint-matchers.md) — Specifies method call triggers for mock responses using exact values, predicates, or specialized matchers. ([source](https://tunit.dev/docs/writing-tests/mocking/argument-matchers.md))

### Software Engineering & Architecture

- [Testing Utilities](https://awesome-repositories.com/f/software-engineering-architecture/integration-extensibility/dependency-injection/testing-utilities.md) — Provides a sophisticated system for injecting classes as parameters into tests with configurable lifecycles. ([source](https://tunit.dev/docs/writing-tests/class-data-source.md))
- [Test Data Injections](https://awesome-repositories.com/f/software-engineering-architecture/integration-extensibility/dependency-injection/type-safe-context-injections/test-data-injections.md) — Uses compile-time source generation to inject test data into properties, ensuring type safety and Native AOT compatibility. ([source](https://tunit.dev/docs/writing-tests/property-injection.md))
- [Object Member Assertions](https://awesome-repositories.com/f/software-engineering-architecture/object-property-inspectors/property-extraction-validation/object-member-assertions.md) — Performs assertions on specific members and nested properties of an object to verify internal state. ([source](https://tunit.dev/docs/assertions/getting-started.md))
- [Null Value Validation](https://awesome-repositories.com/f/software-engineering-architecture/runtime-value-validation/null-value-validation.md) — Ships comprehensive assertions to validate whether values are null or not null. ([source](https://tunit.dev/docs/assertions/library.md))
- [Member-Level Assertions](https://awesome-repositories.com/f/software-engineering-architecture/data-schema-validation/data-type-validation/nested-object-validation/member-level-assertions.md) — Allows chaining multiple assertions on specific object properties while maintaining the parent context. ([source](https://tunit.dev/docs/assertions/member-assertions.md))
- [Dependency Injection Providers](https://awesome-repositories.com/f/software-engineering-architecture/dependency-injection-providers.md) — Implements a service provider to resolve dependencies for tests during ahead-of-time execution. ([source](https://tunit.dev/docs/writing-tests/aot.md))
- [Exception Verification](https://awesome-repositories.com/f/software-engineering-architecture/error-handling/exception-logic-structures/exception-handling-strategies/exception-verification.md) — Provides detailed verification of exception messages and parameter names for argument-related errors. ([source](https://tunit.dev/docs/assertions/exceptions.md))
- [Mock Event Triggering](https://awesome-repositories.com/f/software-engineering-architecture/event-buses/event-bus-mocks/mock-event-triggering.md) — Triggers events on a mock object with specific arguments to test system responses to notifications. ([source](https://tunit.dev/docs/writing-tests/mocking/setup.md))
- [Configurable String Equality](https://awesome-repositories.com/f/software-engineering-architecture/execution-control/equality-validators/equality-operators/strict-equality-assertions/configurable-string-equality.md) — Checks if two strings are equal using a variety of configurable comparison options. ([source](https://tunit.dev/docs/assertions/string.md))
- [Dependency Injection](https://awesome-repositories.com/f/software-engineering-architecture/integration-extensibility/dependency-injection.md) — Manages the lifecycle of DI scopes and resolves services by type to inject dependencies into test classes. ([source](https://tunit.dev/docs/writing-tests/dependency-injection.md))
- [Nested Injections](https://awesome-repositories.com/f/software-engineering-architecture/integration-extensibility/dependency-injection/type-safe-context-injections/test-data-injections/nested-injections.md) — Supports complex object graphs by injecting dependencies into objects that are themselves provided via test data sources. ([source](https://tunit.dev/docs/writing-tests/property-injection.md))
- [Shared Resource Lifecycles](https://awesome-repositories.com/f/software-engineering-architecture/rpc-cancellation/asynchronous-operation-cancellation/context-aware-cancellation/resource-lifecycle-managers/shared-resource-lifecycles.md) — Injects expensive resources into tests with automatic lifecycle management and cross-class sharing. ([source](https://tunit.dev/docs/examples/complex-test-infrastructure.md))
- [Object Structural Assertions](https://awesome-repositories.com/f/software-engineering-architecture/structural-comparison-tools/object-structural-assertions.md) — Compares nested objects, anonymous types, and records by their properties and fields rather than by reference. ([source](https://tunit.dev/docs/assertions/collections.md))
- [Value-Based Equality Checking](https://awesome-repositories.com/f/software-engineering-architecture/value-based-equality-checking.md) — Supports comparing data structures by their internal content using standard operators, custom comparers, or floating-point tolerances. ([source](https://tunit.dev/docs/assertions/equality-and-comparison.md))

### System Administration & Monitoring

- [Application Log Redirection](https://awesome-repositories.com/f/system-administration-monitoring/container-observability-tools/log-routing/application-log-redirection.md) — Redirects log output from application hosts or containers into the test explorer and console. ([source](https://tunit.dev/docs/examples/aspnet.md))
- [Test-to-Log Correlation](https://awesome-repositories.com/f/system-administration-monitoring/container-observability-tools/log-routing/application-log-redirection/application-log-routing/test-to-log-correlation.md) — Routes server-side logging output and distributed tracing spans to the specific test that triggered the request. ([source](https://tunit.dev/docs/examples/aspnet.md))
- [Execution Tracing](https://awesome-repositories.com/f/system-administration-monitoring/execution-tracing.md) — Generates execution spans for test cases and lifecycles, nesting application-level spans for full visibility. ([source](https://tunit.dev/docs/guides/distributed-tracing.md))
- [Cross-Boundary Log Correlation](https://awesome-repositories.com/f/system-administration-monitoring/front-to-back-trace-correlation/cross-boundary-log-correlation.md) — Propagates test context identifiers via headers to link logs from remote services back to the originating test. ([source](https://tunit.dev/docs/extending/logging.md))
- [Distributed Tracing](https://awesome-repositories.com/f/system-administration-monitoring/monitoring-and-observability/observability-platforms/distributed-tracing-execution-analysis/distributed-tracing.md) — Injects unique test identifiers into baggage headers to track requests across distributed process boundaries. ([source](https://tunit.dev/docs/guides/distributed-tracing.md))
- [Observability Tracing](https://awesome-repositories.com/f/system-administration-monitoring/observability-tracing.md) — Emits activity spans for the test lifecycle and individual cases to enable distributed tracing. ([source](https://tunit.dev/docs/examples/opentelemetry.md))
- [Test-SUT Trace Integration](https://awesome-repositories.com/f/system-administration-monitoring/observability-tracing/test-sut-trace-integration.md) — Configures instrumentation and trace propagation for integration tests to capture spans from the system under test. ([source](https://tunit.dev/docs/examples/opentelemetry.md))
- [Trace Linking](https://awesome-repositories.com/f/system-administration-monitoring/observability-tracing/trace-linking.md) — Associates trace spans from separate processes with a specific test for a unified view of activity. ([source](https://tunit.dev/docs/guides/html-report.md))
- [Logging Integrations](https://awesome-repositories.com/f/system-administration-monitoring/system-logging/logging-frameworks/logging-integrations.md) — Bridges standard logging abstractions to route application logs through the test output pipeline. ([source](https://tunit.dev/docs/extending/logging.md))
- [Telemetry Correlation](https://awesome-repositories.com/f/system-administration-monitoring/telemetry-correlation.md) — Links logs, metrics, and traces from the system under test back to the originating test using OTLP receivers. ([source](https://tunit.dev/docs/examples/aspire.md))
- [Test Console Captures](https://awesome-repositories.com/f/system-administration-monitoring/diagnostic-tools/diagnostics/telemetry-and-log-collectors/output-capture-utilities/test-console-captures.md) — Intercepts console writes and logger calls to correlate them with the specific test that triggered the output. ([source](https://tunit.dev/docs/extending/logging.md))
- [Log Streaming](https://awesome-repositories.com/f/system-administration-monitoring/log-streaming.md) — Captures and pipes container logs from specific named resources directly into the test output for debugging. ([source](https://tunit.dev/docs/examples/aspire.md))
- [External Span Collection](https://awesome-repositories.com/f/system-administration-monitoring/observability-tracing/custom-span-timing/external-span-collection.md) — Hosts a receiver to collect tracing data from out-of-process child processes and associate them with specific test runs. ([source](https://tunit.dev/docs/guides/distributed-tracing.md))
- [Cancellation Status Checks](https://awesome-repositories.com/f/system-administration-monitoring/system-activity-monitoring/session-activity-monitors/workflow-cancellation-handlers/remote-task-cancellation/cancellation-handlers/cancellation-status-checks.md) — Provides the ability to assert whether an asynchronous task has been cancelled. ([source](https://tunit.dev/docs/assertions/library.md))
- [Test Report Visualizations](https://awesome-repositories.com/f/system-administration-monitoring/trace-visualization/test-report-visualizations.md) — Renders detailed activity spans and library call timelines directly within HTML test reports for easier failure analysis. ([source](https://tunit.dev/docs/examples/opentelemetry.md))
- [Trace Waterfall Visualizations](https://awesome-repositories.com/f/system-administration-monitoring/trace-waterfall-visualizations.md) — Renders waterfall timelines of nested spans to track durations and dependencies during test execution. ([source](https://tunit.dev/docs/guides/html-report.md))

### DevOps & Infrastructure

- [Dependency Graph Orchestrators](https://awesome-repositories.com/f/devops-infrastructure/dependency-graph-orchestrators.md) — Calculates the optimal operation sequence for initializing complex chains of test dependencies and lifecycles.
- [Resource Disposal](https://awesome-repositories.com/f/devops-infrastructure/resource-definitions/namespaced/test-resource-namespacing/resource-disposal.md) — Implements comprehensive setup and teardown hooks to manage the lifecycle of shared and isolated test resources. ([source](https://tunit.dev/docs/writing-tests/lifecycle.md))

### Scientific & Mathematical Computing

- [Test Case Combinations](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/arithmetic-number-types/multiplication-algorithms/number-theory-algorithms/permutation-order-calculations/combinatorial-generators/test-case-combinations.md) — Automatically creates exhaustive sets of parameterized test cases using combinatorial data generation.

### Web Development

- [HTTP Interaction Verifiers](https://awesome-repositories.com/f/web-development/backend-development/request-response-handling/http-utilities/http-header-manipulators/http-request-header-inspectors/http-interaction-verifiers.md) — Inspects outgoing calls including methods, URIs, and headers to ensure correct interaction with external services. ([source](https://tunit.dev/docs/writing-tests/mocking/http.md))