vitest-dev/vitest

Features

• Test Runners - Provides a high-performance testing framework for JavaScript and TypeScript with built-in mocking and coverage.
• Browser-Based Execution Environments - Provides a browser-native execution environment for validating UI components and web APIs against real browser engines.
• TypeScript Execution - Compiles and executes TypeScript test files automatically without requiring separate build steps.
• Assertion Libraries - Verifies code behavior by defining test cases and checking expected outcomes using built-in assertion functions.
• Browser Automation Testing - Executes test suites within real browser environments to validate web application behavior and UI component interactions.
• Test Isolation - Resets state before each execution to ensure tests remain independent and can run in any order.
• Snapshot Testing - Captures and compares serialized application state or UI component output against stored reference files to detect regressions.
• Incremental Test Runners - Monitors source files and automatically re-runs only affected tests to provide immediate feedback during development.
• Incremental Execution - Monitors source code changes and automatically re-runs only the affected tests to provide rapid feedback during development.
• State Snapshots - Serializes complex objects or UI structures into persistent files to detect unintended regressions by comparing current output against baselines.
• Code Coverage Tools - Tracks and reports which parts of the codebase are exercised by tests to identify untested logic.
• Component Testing - Provides built-in support for mounting and verifying UI components from various frameworks in an isolated test environment.
• Dependency Mocking - Intercepts module imports to replace their implementations with fakes or spies for controlled dependency testing.
• Mocking Frameworks - Creates mock functions to substitute original logic with custom behavior or return values during test execution.
• Snapshot Testing Utilities - Compares serialized values against stored reference files or inline strings to detect unintended changes in application state or output.
• Visual Regression Testing - Captures UI component screenshots and compares them against baseline images to detect unintended styling or layout changes.
• Test Spying Utilities - Vitest tracks calls to class methods, getters, and setters to verify interactions or override specific behaviors during the execution of a test suite.
• Test Execution Management - Runs multiple test files simultaneously across isolated worker processes to reduce total execution time.
• Test Setup Orchestrators - Manages the lifecycle of shared resources by executing initialization and teardown logic across the main process and worker threads.
• Worker Process Management - Executes individual test files in separate worker processes to ensure state isolation and prevent side effects between suites.
• Developer Tools - Unit testing framework optimized for modern build tools.
• Testing Frameworks - Vite-native unit and integration testing framework.
• Performance Benchmarking - Executes benchmark tests to compare performance of specific code paths.
• CI/CD Pipeline Integrations - Generates workflow annotations and job summaries for test results directly within continuous integration platforms.
• Deterministic Value Injection - Forces consistent outputs for time, random numbers, and unique identifiers to ensure deterministic test results.
• Test Fixture Management - Controls the lifetime of shared test resources by scoping them to individual tests, files, or worker processes.
• Test Lifecycle Hooks - Runs initialization and cleanup code automatically before or after tests to manage shared state and external resources.
• Test Parameterization - Runs the same test logic against multiple data inputs to reduce code duplication and improve test coverage.
• Timer Mocks - Vitest replaces native timer functions with controlled versions to execute delayed code immediately during testing without waiting for real-world time to pass.
• Test Case Generators - Executes functions against randomly generated inputs to identify edge cases and counterexamples.
• DOM Matchers - Validates the state of rendered elements using a comprehensive set of built-in matchers designed for web application testing.
• Test Execution Runners - Supports attaching external debuggers to pause execution and inspect state.
• Test Sharding - Splits a large collection of test files into smaller groups to be executed across multiple machines or processes simultaneously.
• Test Suite Filters - Executes only the subset of tests matching specific labels via command-line arguments or programmatic filters.
• Global Test Lifecycle Hooks - Executes initialization and cleanup code in the main process before and after test suites to manage global state and external resources.
• On-Demand Source Serving - Compiles source code and dependencies on the fly using a native bundler to provide rapid feedback during development.
• In-Memory File Systems - Redirects disk operations to a virtualized memory store to isolate tests from the host environment and improve execution speed.
• Asymmetric Matchers - Validates that data matches a specific shape, type, or partial structure without requiring an exact value match for every field.
• Editor-Integrated Test Execution - Displays test results and execution status directly within the development environment to provide immediate feedback.
• Transformation Caching - Stores processed code files on the local disk to speed up repeated test runs by skipping redundant re-parsing.
• Network Interception Tools - Intercepts network traffic during testing to simulate backend responses without requiring a live server connection.
• User Interaction Simulation - Simulates user actions like clicking and typing using browser-native protocols to ensure tests reflect real user behavior.
• Error Handling - Confirms that specific functions throw expected errors by wrapping calls in a controlled execution environment.
• Test Metadata - Lists or filters tests based on custom tags and logical expressions to execute specific subsets.
• Test Reporters - Supports custom interfaces for processing and formatting test results.
• Soft Assertions - Allows multiple independent assertions to be evaluated in a single test run without stopping on the first failure.
• Test Assertion Extensions - Creates domain-specific assertion logic by extending the testing interface with reusable validation functions.
• Time Manipulation - Overrides the system clock to return specific dates or times for verifying time-sensitive logic.
• Test Sanitizers - Identifies and reports uncaught promise rejections as test failures to surface silent bugs and forgotten asynchronous operations.
• Test Execution Timeouts - Sets maximum duration limits for tests to prevent the suite from hanging indefinitely when operations fail to complete.
• Promise Assertions - Unwraps promises directly within assertions to verify resolved values or rejected errors without manually storing results in variables.
• Test Execution Strategies - Splits test suites across multiple nodes to reduce total execution time in large-scale environments.
• Test Dashboards - Provides a browser-based dashboard to monitor test status and view output.
• Build Configurations - Uses existing application configuration, plugins, and resolvers to ensure tests run in the same environment as the production build.
• Trace Inspection Tools - Captures detailed logs and traces of browser interactions for debugging test failures.
• Test Suites - Structures related test cases into logical blocks to improve output readability and clarify verified functions.
• Virtual Module Resolvers - Intercepts import requests at the module resolution layer to inject fake implementations without modifying physical files.
• Configuration Cascade Resolutions - Calculates final test environment settings by merging custom parameters with project defaults and environment variables.
• Tracking Wrappers - Vitest wraps module exports with tracking utilities to monitor function calls and arguments without altering original code behavior.
• Property Matchers - Uses property matchers to validate the structure of an object while excluding volatile fields like timestamps or unique identifiers from the comparison.
• Runtime Execution Environments - Creates custom runtime environments by defining specific global properties or behaviors to support unique application requirements.
• Global Stubbing - Injects or replaces global objects and environment variables to simulate different runtime configurations.
• Environment Setup Scripts - Executes setup scripts before each test file to configure local state or dependencies within the worker process.
• Error Message Snapshots - Captures and verifies the content of thrown errors against a stored snapshot to ensure consistent and descriptive error reporting.
• Method Call Verification - Creates a spy on an existing object method to record call history and arguments without altering original function behavior.
• Execution Tracing - Generates execution spans for test workers to monitor performance.
• Snapshot Matcher Extensions - Creates custom assertion logic that transforms values before snapshotting while maintaining full lifecycle support for creation and automatic updates.
• Programmatic Interfaces - Runs test suites via an API with support for custom filters, configuration overrides, and automatic lifecycle management.
• Test Execution Controls - Detects at runtime whether active test filters include specific tags to avoid expensive initialization for tests not currently running.
• In-Source Testing - Executes tests defined directly within implementation files to access private state and keep documentation close to the code.
• Execution Profilers - Generates CPU and heap profiles to identify performance bottlenecks during test runs.
• Code Coverage Reportings - Allows customization of coverage data collection and reporting providers.
• Accessibility Validation Utilities - Checks components for keyboard navigation, focus management, and compliance to ensure the interface remains usable for all users.
• Inline Snapshot Management - Stores expected output directly within the test file as a string argument, allowing for easier visibility and maintenance of smaller test values.
• CLI Test Runners - Converts raw string inputs or argument arrays into structured configuration objects compatible with the test runner.
• Project Configurations - Runs distinct test suites with unique settings, plugins, or environments within a single process.
• Test Labeling Systems - Assigns custom labels to test suites or individual tests to group them for selective execution.
• Execution Ordering - Groups test files into parallel or sequential execution sets to optimize resource usage.
• Visual State Stabilizers - Retries screenshot capture until UI states settle to ensure consistent comparisons.

Star history