thomhurst/TUnit

Features

• Test Frameworks - A comprehensive test runner and assertion library that uses source generation for Native AOT compatibility.
• Unit Testing Frameworks - Serves as a comprehensive framework for defining and executing automated unit tests using source generation.
• HTTP Client Tracing - Instruments HTTP clients with tracing and correlation handlers to ensure test identifier propagation.
• Dependency Lifecycle Management - Controls the sharing of injected objects across tests, classes, or assemblies to optimize resource usage.
• Distributed Resource Orchestration - Controls the distributed application startup process via command-line arguments and custom health-check wait behaviors.
• Tracing Context Propagation - Uses activity baggage to propagate test identifiers across network boundaries for log correlation.
• Build-Time Test Discovery - Uses source generators to identify tests during compilation for Native AOT compatibility.
• Testing Utilities - Provides a sophisticated system for injecting classes as parameters into tests with configurable lifecycles.
• Test Data Injections - Uses compile-time source generation to inject test data into properties, ensuring type safety and Native AOT compatibility.
• Object Member Assertions - Performs assertions on specific members and nested properties of an object to verify internal state.
• Null Value Validation - Ships comprehensive assertions to validate whether values are null or not null.
• Application Log Redirection - Redirects log output from application hosts or containers into the test explorer and console.
• Test-to-Log Correlation - Routes server-side logging output and distributed tracing spans to the specific test that triggered the request.
• Execution Tracing - Generates execution spans for test cases and lifecycles, nesting application-level spans for full visibility.
• Cross-Boundary Log Correlation - Propagates test context identifiers via headers to link logs from remote services back to the originating test.
• Distributed Tracing - Injects unique test identifiers into baggage headers to track requests across distributed process boundaries.
• Observability Tracing - Emits activity spans for the test lifecycle and individual cases to enable distributed tracing.
• Test-SUT Trace Integration - Configures instrumentation and trace propagation for integration tests to capture spans from the system under test.
• Trace Linking - Associates trace spans from separate processes with a specific test for a unified view of activity.
• Logging Integrations - Bridges standard logging abstractions to route application logs through the test output pipeline.
• Telemetry Correlation - Links logs, metrics, and traces from the system under test back to the originating test using OTLP receivers.
• Application Lifecycle Management - Automates the lifecycle of distributed application resources, ensuring they are built, started, and disposed of correctly.
• Boolean-Return Assertions - Validates boolean and nullable boolean expressions using expressive assertion methods.
• Boolean Assertions - Provides fundamental assertions to verify whether boolean conditions are true or false.
• Compile-Time Test Validation - Identifies and executes tests using compile-time source generation for safety and AOT support.
• Custom Assertions - Generates specialized, domain-specific assertions from existing logic using source generation for improved test readability.
• Data-Driven Testing - Enables generating multiple test cases using fixed arguments, combinatorial matrices, or custom data sources.
• Fluent Assertion Chaining - Implements a chainable validation syntax that returns the asserted subject to enable subsequent operations on the same value.
• Fluent Assertions - Implements a readable, chainable syntax to validate values, collections, strings, and exceptions.
• Test Lifecycle and Execution Control - Implements a comprehensive system for managing test lifecycles, ensuring cleanup occurs across multiple scope levels.
• Test Lifecycle Hooks - Supports native async setup and teardown hooks for managing test environment lifecycles.
• HTTP Testing Utilities - Provides a utility for intercepting network exchanges, mocking API responses, and verifying outgoing HTTP requests.
• Integration Testing - Executes parallel integration tests with per-test isolation while sharing global infrastructure like containers.
• Mock Behavior Configuration - Allows defining return values, exceptions, and callbacks for mocked methods, including sequential call outcomes.
• Numeric Assertions - Compares numeric values for equality or relative order with precision-based tolerance for floating-point errors.
• Parallel Test Execution - Runs test suites concurrently by default to provide faster feedback and encourage isolated test design.
• Compile-Time Mock Generation - Produces mock implementations during the build process to ensure compatibility with Native AOT and IL trimming.
• Integration Testing Frameworks - Manages distributed application lifecycles, isolates database schemas, and correlates telemetry across processes.
• Partial Mocks - Supports creating test doubles that selectively override specific methods while delegating other calls to the real implementation.
• Test Execution and Orchestration - Utilizes compile-time source generation to discover and execute unit, integration, and acceptance tests at scale.
• Test Case Annotations - Provides the primary mechanism to mark methods as executable test cases and theories.
• Collection Content Validations - Provides specialized assertions to verify the presence, count, and sequential order of elements in collections.
• Asynchronous Assertions - Provides specialized computation expressions for validating asynchronous operations without manual wrapping.
• Exception Assertions - Validates that code throws a specific exception type for both synchronous and asynchronous operations.
• Fluent Assertions - Provides a chainable, type-safe validation syntax restricted to logically valid operations for a specific data type.
• State Expectation Validation - Provides a chainable syntax for verifying that values meet specific expectations including equality, range, and membership.
• Source-Generated Discovery - Identifies and registers tests at compile time using source generation to eliminate runtime reflection and support Native AOT.
• Native AOT Test Suites - Executes tests against ahead-of-time compiled binaries to ensure correctness in Native AOT environments.
• AOT-Compatible Data Sources - Provides test data via static methods and async streams to maintain Native AOT compatibility.
• Test Lifecycle Hooks - Provides native async setup and teardown hooks at session, assembly, class, and test levels.
• Type Assertions - Verifies that values are of a specific type or compatible via inheritance and interfaces.
• Type-Safe Assertions - Ensures logic errors are prevented by limiting assertion methods to those compatible with the specific data type being tested.
• Fluent Assertions - Provides a chainable, readable API for verifying software behavior that mirrors natural language.
• Regex Assertions - Provides powerful regex-based assertions to verify string formats and extract match details.
• Dictionary Construction - Actually, this feature is a duplicate of f0; it provides assertions to verify the presence of specific keys and values in dictionaries.
• Development Schema Isolation - Provides unique, isolated database schemas for individual tests to ensure data independence.
• Test Logging Utilities - Captures diagnostic text and attaches files like screenshots to test runs for failure analysis.
• Parallel Execution - Constrains the number of concurrent operations to prevent resource exhaustion.
• Real-Time Output Streaming - Streams real-time console output to IDE test explorers while tests are actively running.
• Dependency Graph Orchestrators - Calculates the optimal operation sequence for initializing complex chains of test dependencies and lifecycles.
• Resource Disposal - Implements comprehensive setup and teardown hooks to manage the lifecycle of shared and isolated test resources.
• HTTP Status Codes - Provides assertions to verify if HTTP response status codes fall within expected success or error ranges.
• API Response Simulators - Intercepts outgoing requests and returns predefined or dynamic responses to simulate external API behavior.
• Ahead-Of-Time Compilation - Uses ahead-of-time compilation to accelerate the test discovery process and reduce runtime memory usage.
• Return Value Interceptors - Allows defining custom providers to override the default values returned by unconfigured mocked methods.
• Static Analysis Assertions - Detects unawaited asynchronous assertions and improper logical chaining via static analysis to prevent runtime errors.
• Mock Property Definitions - Configures getter and setter behaviors for properties with an automatic tracking mode for value storage.
• Test Dependency Resolution - Resolves a dependency graph of test data sources to ensure correct initialization and disposal order.
• Argument Constraint Matchers - Specifies method call triggers for mock responses using exact values, predicates, or specialized matchers.
• Test Case Combinations - Automatically creates exhaustive sets of parameterized test cases using combinatorial data generation.
• Member-Level Assertions - Allows chaining multiple assertions on specific object properties while maintaining the parent context.
• Dependency Injection Providers - Implements a service provider to resolve dependencies for tests during ahead-of-time execution.
• Exception Verification - Provides detailed verification of exception messages and parameter names for argument-related errors.
• Mock Event Triggering - Triggers events on a mock object with specific arguments to test system responses to notifications.
• Configurable String Equality - Checks if two strings are equal using a variety of configurable comparison options.
• Dependency Injection - Manages the lifecycle of DI scopes and resolves services by type to inject dependencies into test classes.
• Nested Injections - Supports complex object graphs by injecting dependencies into objects that are themselves provided via test data sources.
• Shared Resource Lifecycles - Injects expensive resources into tests with automatic lifecycle management and cross-class sharing.
• Object Structural Assertions - Compares nested objects, anonymous types, and records by their properties and fields rather than by reference.
• Value-Based Equality Checking - Supports comparing data structures by their internal content using standard operators, custom comparers, or floating-point tolerances.
• Test Console Captures - Intercepts console writes and logger calls to correlate them with the specific test that triggered the output.
• Log Streaming - Captures and pipes container logs from specific named resources directly into the test output for debugging.
• External Span Collection - Hosts a receiver to collect tracing data from out-of-process child processes and associate them with specific test runs.
• Cancellation Status Checks - Provides the ability to assert whether an asynchronous task has been cancelled.
• Test Report Visualizations - Renders detailed activity spans and library call timelines directly within HTML test reports for easier failure analysis.
• Trace Waterfall Visualizations - Renders waterfall timelines of nested spans to track durations and dependencies during test execution.
• Assembly-Level Hooks - Provides static methods to prepare or clean up the global environment once per assembly execution.
• Assertion Grouping - Collects and reports multiple failing assertions within a single scope to provide a comprehensive view of failures.
• Asynchronous Task Assertions - Implements assertions to validate whether asynchronous tasks have completed, faulted, or finished successfully.
• Automated Test Data Generation - Produces strongly typed or dynamic test arguments at discovery time to populate test parameters.
• Mock Interaction Recorders - Records values passed to mocked methods during execution for subsequent inspection and validation.
• Interaction Verifiers - Checks if specific methods were called on a mock object, including call counts and arguments.
• CI Integration Testing - Runs test suites across multiple operating systems and versions within automated pipelines to verify cross-platform compatibility.
• Pipeline Report Generators - Produces test results in formats compatible with common CI/CD workflow tools to surface failures.
• Code Coverage Analysis - Tracks executed code paths during tests and exports the results in standardized coverage formats.
• Collection Equivalency Assertions - Verifies if two collections contain the same elements, supporting both order-independent and order-sensitive checks.
• Collection Order Assertions - Confirms that a collection is sorted in ascending or descending order, or ordered by a specific property.
• Collection Size Assertions - Verifies that a collection has an exact count, is not empty, or contains exactly one item.
• Custom Assertion Predicates - Evaluates a value against a user-defined predicate or transforms the value before applying a standard assertion.
• Custom Data Source Integrations - Accepts custom attributes implementing a data source interface to provide tailored input values for tests.
• Testing Framework Extenders - Enables the creation of custom data sources and output formatters to modify test behavior and reporting.
• Delegate Mocks - Generates mock implementations for Action, Func, and custom delegate types to simulate functional dependencies.
• Dictionary Assertions - Provides specialized assertions to verify if dictionaries contain expected keys or values.
• Custom Test Attributes - Provides the ability to create custom attributes for specialized skip conditions and retry behaviors.
• Test Isolation - Prevents state leakage by creating a new instance of the test class for every individual test method.
• Test Metadata - Allows defining and formatting test identities and display names to organize test reporting.
• Test Result Reporters - Generates formatted report files of test execution outcomes and supports custom output directories.
• HTML Dashboard Reports - Produces a visual HTML dashboard of test results including pass rates and failure analysis.
• Assertion Aggregators - Collects multiple failing assertions within a defined scope to report them collectively instead of stopping at the first failure.
• Asynchronous Polling Mechanisms - Repeatedly evaluates a value source until a specified assertion passes or a timeout is reached.
• State Assertions - Implements awaitable assertion objects to verify boolean returns and overall system state.
• Asynchronous Assertions - Provides asynchronous assertions to check expected outcomes with detailed failure messaging.
• Test Assertion Extensions - Automatically generates fluent counterparts for user-defined assertion extensions to provide domain-specific validation logic.
• Test Execution Controls - Provides controls for test repetition, retry logic, timeouts, and skipping.
• Asynchronous Data Initialization - Enables asynchronous setup tasks during test discovery to fetch external data or generate dynamic test cases.
• Conditional Skipping - Marks tests as skipped at runtime when specific conditions prevent their execution.
• Test Skipping Mechanisms - Allows marking specific tests or classes as skipped so they are not executed during standard runs.
• Test Execution Timeouts - Defines global time limits for test execution to prevent hanging processes.
• Timeout Enforcements - Ensures asynchronous tasks complete within a specified time limit or fail the test.
• Test Parameterization - Produces multiple test cases from sets of arguments or cross-product matrices of parameter combinations.
• Test Retry Strategies - Automatically reruns failed tests based on configurable retry strategies to mitigate flakiness.
• Failure Flow Control - Terminates the test run immediately upon the first failure for rapid feedback.
• Mock Parameter Control - Allows setting specific values for out and ref parameters during mocked method calls using strongly-typed methods.
• Mocking Frameworks - Checks if specific members of a mocked object were called using generated extension methods.
• Numeric Range Assertions - Checks if numeric values are positive, negative, or within specified inclusive ranges.
• Concurrency Limiters - Caps the number of tests running simultaneously to prevent system resource exhaustion.
• Property-Based Testing - Generates random test data to verify software invariants across a wide range of inputs.
• Multi-Interface Mocks - Creates a single mock object that implements several interfaces simultaneously to satisfy multiple dependencies.
• Recursive Mock Generation - Automatically generates functional mock objects for interface return types to avoid nulls in deep object graphs.
• Static Abstract Member Mocks - Provides bridge interfaces to enable the mocking of interfaces containing static abstract members.
• Test Case Generators - Supplies test parameters from static or instance methods to automatically generate multiple test cases.
• Collection Membership Assertions - Checks if a collection contains an item, is empty, has a specific count, or contains equivalent items regardless of order.
• Collection Condition Assertions - Tests whether all items or at least one item in a collection satisfy a specific condition.
• Execution Assertions - Executes functions or actions to verify their return values or catch thrown exceptions.
• Exception Chain Assertions - Traverses the exception chain to validate the type and properties of nested inner exceptions.
• Custom Matchers - Allows the definition of custom classes to implement reusable matching logic for complex mock argument conditions.
• Inline Test Case Reproducers - Enables consistent reproduction of failed property tests using stored seeds.
• Parametrized Test Cases - Supplies multiple sets of input values to test methods via inline values, method sources, or fixtures.
• Test Repeaters - Runs tests multiple times at method, class, or assembly levels to detect intermittent failures.
• CLI Test Runners - Runs test suites using command line tools or executables to trigger test discovery and execution.
• Reusable Infrastructure Patterns - Allows creation of shared lifecycle hooks and base classes to standardize test logic across projects.
• Test Runner Integrations - Connects to graphical testing interfaces via a standard protocol to discover and run tests within an editor.
• String Assertions - Provides a comprehensive set of assertions for checking substrings, prefixes, suffixes, and string lengths.
• Temporal Assertions - Validates if a date occurs before, after, or on a specific date.
• Test Boilerplate Reduction - Eliminates the requirement for mandatory base classes or class-level attributes when defining test suites.
• Test Data Isolation - Creates unique database schemas for each test execution to prevent cross-test data contamination.
• Test Data Injection - Provides flexible mechanisms for injecting new or shared data instances into tests.
• Test Execution Filtering - Enables filtering of tests based on values provided by dynamic data sources during compile-time discovery.
• Generic Test Instantiation - Generates explicit type combinations for generic test classes at compile time for AOT compatibility.
• Test Lifecycle Event Listeners - Triggers custom actions at key lifecycle stages such as registration, start, and completion of tests.
• Test Report Attachments - Enables linking of screenshots, logs, and other files to individual tests for inclusion in CI/CD reports.
• HTTP Request Captures - Records outgoing requests and incoming responses during execution to verify network interactions through assertions.
• Test Signature Analysis - Detects incorrect method signatures or missing keywords during compilation to ensure consistent test structures.
• Test Execution Management - Manages the parallelization and concurrency of test execution to optimize resource usage.
• Execution Ordering - Allows defining the sequence of test execution to handle dependent operations.
• Parallel Execution Managers - Controls concurrency and worker process limits within specific test classes to manage resource usage.
• Test Dependency Managers - Enables retrieving result or state data from a preceding dependent test for use in subsequent assertions.
• Lifecycle Hooks - Provides native async setup and teardown hooks to manage expensive resource initialization and cleanup.
• Test Context Sharing - Provides a context object injected into test methods to share metadata and output logging.
• Type-Converting Assertion Chains - Transforms the value being tested into a new type during an assertion sequence for subsequent checks.
• HTTP Interaction Verifiers - Inspects outgoing calls including methods, URIs, and headers to ensure correct interaction with external services.

Star history