Qunit

QUnit is a JavaScript unit testing framework designed to verify code behavior using assertions and lifecycle hooks across browsers and server runtimes. It functions as a browser-based test runner with an HTML interface for reporting results, an asynchronous test orchestrator for coordinating callbacks, and a utility for isolating and verifying document object model changes.

The framework distinguishes itself through specialized DOM testing capabilities, allowing for the isolation and resetting of the document object model between tests to ensure atomicity. It also features a system for detecting global state leaks by monitoring the window object and provides the ability to execute test suites in headless environments for background automation.

The project covers a broad range of testing capabilities, including asynchronous workflow validation, cross-runtime compatibility testing, and the creation of custom assertions. It supports test organization through modules, the execution of setup and teardown lifecycle hooks, and the generation of code coverage and standardized test reports.

Users can execute tests via a browser interface or a command-line terminal with support for file watching and programmatic test filtering.

Features

Unit Testing Frameworks - Provides a full framework for defining and executing automated unit tests to verify code logic and correctness.
Asynchronous Logic Validation - Provides an orchestrator to verify the execution order and completion of asynchronous callbacks and promises.
Asynchronous Test Execution - Manages the execution flow of tests that rely on promises or callbacks, delaying completion until a trigger occurs.
Behavioral Assertions - Check for specific outcomes like partial object matches or expected exceptions to validate internal logic.
DOM Testing Utilities - Includes utilities for isolating and verifying document object model changes during unit testing.
Test Isolation - Ensures test execution environments remain independent by resetting internal state between individual test cases.
Test Result Reporters - Displays test outcomes via a browser-based HTML interface including assertion diffs and status.
HTML Dashboard Reports - Renders test outcomes and assertion failures through an interactive visual HTML dashboard.
Element State Assertions - Provides high-level assertions to verify the state and properties of HTML elements.
Test Grouping Utilities - Organizes collections of tests into modules to manage shared setup and maintain logical separation.
Test Lifecycle Hooks - Provides mechanisms for executing setup and teardown logic before or after the execution of tests and modules.
JavaScript Testing Frameworks - Provides a dedicated framework for writing and running assertion-based tests within JavaScript environments.
Browser and UI Testing - Offers specialized tools for verifying HTML element rendering and behavior by isolating the DOM.
Test Suite Runners - Ships a browser-based runner with an HTML interface for reporting results and debugging failures.
Test Lifecycle Hooks - Implements setup and teardown hooks to maintain a consistent environment for every test.
Command-Line Test Runners - Provides a terminal-based interface for executing test suites with filtering capabilities.
Test Callback Controllers - Provides mechanisms to control the execution of asynchronous tests using completion callbacks.
Test Environment Preloading - Allows loading of external scripts and configuration hooks to bootstrap the test environment.
Async Sequence Validation - Validates the execution order of asynchronous callbacks or event listeners to ensure events occur in the correct sequence.
Error Stack Filtering - Filters internal framework call frames from error traces to isolate the actual failure point.
Internal Frame Filtering - Provides cleaned-up stack traces that hide internal framework frames to highlight the exact location of test failures.
Headless Browser Test Suites - Supports integration into CI pipelines through headless browser execution and standardized reporting.
Code Coverage Analysis - Integrates tools to track and measure which parts of the codebase are exercised by the test suite.
Cross-Environment Test Execution - Allows the same test suite to be executed across different runtimes, including browsers and server environments.
Assertion Registries - Provides a pluggable registry allowing developers to define and use custom validation functions.
Custom Assertions - Allows developers to define new validation functions that push results directly into the active test context.
Custom Test Reporters - Provides pluggable interfaces to integrate external scripts that format or deliver test results.
Testing Framework Extenders - Offers flexible APIs to extend the framework with custom assertions, runners, and reporters.
Exception Assertions - Checks that specific functions throw or reject with expected errors and captures the resulting values.
Test Report Exporters - Exports test results into standardized formats like JUnit XML or LCOV for CI/CD integration.
Global State Leak Detection - Monitors the window object to identify if a test creates or removes global variables during execution.
Headless Test Runners - Enables execution of test suites in a headless browser for background automation.
Exception Assertions - Includes assertions to verify that code throws expected exceptions, validatable via regular expressions or objects.
Specialized Matchers - Supports extended assertion logic for numerical tolerances, canvas pixels, and CSS classes.
Browser Automation Testing - Facilitates test execution across local, headless, and cloud browser environments.
Cross-Runtime Execution - Ensures consistent behavior by running test suites across multiple browsers, worker threads, and server runtimes.
Test Execution Filtering - Allows specifying which tests to run using a configuration filter to include or exclude specific cases.
Global State Leak Detection - Monitors the global window object to identify variables that leak across test cases.
Test Suite Filters - Allows users to selectively include or exclude specific test suites based on name patterns.
Test Execution Optimizers - Prioritizes previously failing tests and filters passing results to accelerate the developer feedback loop.
Testing Frameworks - Easy-to-use unit testing framework.

thomhurst/TUnit

3,744View on GitHub

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 AP

jasmine/jasmine

15,824View on GitHub

Jasmine is a JavaScript testing framework and test runner designed for behavior-driven development. It provides a comprehensive toolset for writing and executing descriptive test suites that verify code behavior in both web browsers and Node.js environments. The framework is distinguished by its integrated mocking library, which allows for dependency isolation through spies and stubs, as well as the ability to simulate time and timing functions to test asynchronous logic synchronously. It also includes a mechanism to enforce test uniqueness, preventing duplicate names for tests and suites. I

avajs/ava

20,849View on GitHub

Ava is a test runner for JavaScript and TypeScript designed to execute test suites with a focus on concurrency and isolation. It serves as a concurrent test executor that runs test files in parallel across multiple processes to reduce total runtime and prevent state leakage between suites. The project features a built-in snapshot testing framework that saves large data structures to disk and compares subsequent executions to detect regressions via diffs. It is also compatible with the Test Anything Protocol, allowing it to export results for use with external reporting tools. Its capability

substack/tape

5,800View on GitHub

Tape is a JavaScript testing framework and assertion library that serves as a test runner for Node.js and browser environments. It implements the Test Anything Protocol to provide a standardized, machine-readable format for test results. The project functions as a cross-environment test harness, allowing the same test suites to be executed across both server-side and client-side environments while maintaining a consistent output protocol. Its capabilities include validating value equality and truthiness, verifying exception handling, and coordinating asynchronous workflows. The framework als

jqueryqunit

Features