onsi/ginkgo

Features

• BDD Specification Structuring - Organizes test logic into a hierarchical structure using containers and subjects to describe system behavior.
• BDD Test Hierarchies - Organizes tests into a nested structure of containers and specs to map system behavior to a descriptive hierarchy.
• Behavior Driven Development - Implements a behavior-driven development framework for Go using human-readable specifications and hierarchical containers.
• Nested Data Matchers - Supports building nested matchers to apply individual validation tests to specific fields within large data sets.
• Testing Frameworks - Implements a hierarchical BDD testing framework specifically for the Go ecosystem.
• Test - Runs setup and teardown functions before or after individual test nodes using context wrapping and thread-locking.
• Testing Specifications - Offers a domain-specific language for writing human-readable specifications using containers and subjects.
• Assertion Libraries - Provides a wide range of matchers for both synchronous and asynchronous state verification in Go.
• Assertion Matchers - Provides a comprehensive set of assertion matchers that can be combined using logical operators.
• Asynchronous Logic Validation - Provides specialized tools for validating eventual consistency in asynchronous Go code using polling and timeouts.
• Suite-Level Resource Initialization - Performs expensive setup and teardown exactly once for the entire suite to manage external dependencies.
• Test Lifecycle Hooks - Manages the setup and teardown of resources across nested test containers to ensure environment isolation.
• Go Testing Frameworks - Provides a comprehensive testing environment for Go applications with support for data-driven scenarios and complex assertions.
• Parallel Test Execution - Distributes test specifications across multiple CPU cores to reduce total execution time in Go projects.
• Assertion and Validation Utilities - Provides comprehensive utilities for defining test conditions and assertions with multi-return error handling.
• Custom Matchers - Implements a common matcher interface supporting both synchronous checks and eventual consistency polling.
• Test Execution Runners - Ships a test execution engine featuring parallelization, sharding, and randomized ordering to detect flakiness.
• Global Test Lifecycle Hooks - Provides global hooks to perform one-time setup and teardown for the entire test suite.
• Nested Setup Nodes - Supports hierarchical environment refinement using nested setup nodes to initialize shared state.
• Test Lifecycle Hooks - Manages test setup and teardown by wrapping test nodes in initialization and cleanup functions.
• Focused Test Execution - Enables rapid iteration by isolating a small set of specifications and skipping all non-focused tests.
• Table-Driven Tests - Generates multiple test cases from tables of inputs and expected outputs for repetitive scenarios.
• Stream Buffer Assertions - Captures data in an in-memory buffer to perform ordered assertions against incremental or streaming output.
• Specification Timeouts - Enforces deadlines and grace periods for individual specifications to ensure timely completion.
• Subprocess Assertions - Allows compiling binaries and monitoring external processes to validate exit codes and output streams.
• Test Reporting Pipelines - Streams test results through a pipeline of customizable nodes that aggregate data or generate reports.
• Deferred Cleanup Registration - Ensures resources are released regardless of test outcome by registering cleanup functions adjacent to setup code.
• Goroutine Leak Prevention - Verifies that test executions finish without leaving orphaned or leaked goroutines.
• Test State Cleanup - Executes cleanup code after specifications to restore external systems and prevent state pollution between tests.
• Execution State Streaming - Emits current execution state and source code location in real-time to help debug slow or stuck tests.
• Stuck Process Monitoring - Emits progress reports and stack traces for hanging tests via system signals or polling intervals.
• Description-Based Filtering - Matches regular expressions against the concatenated description of the spec hierarchy to isolate specific tests.
• Execution State Inspection - Pauses execution after a failure but before teardown to enable manual inspection of the system state.
• Test Reporters - Generates machine-readable and formatted test reports with support for custom metadata.
• Flaky Test Analyzers - Identifies non-deterministic failures using randomized execution order and automated retries.
• Programmable Reporting Nodes - Implements programmable reporting nodes that execute before or after specs to aggregate results.
• Test Report Exporters - Produces test results in standardized, machine-readable formats for CI/CD integration.
• Execution Randomizers - Shuffles the execution order of tests using a seed to uncover hidden dependencies and state pollution.
• Conditional Skipping - Skips tests at compile time as pending or bypasses them dynamically at runtime based on conditions.
• Transient Failure Reruns - Automatically reruns failed tests a specified number of times to mitigate flaky or transient failures.
• HTTP Mock Servers - Simulates an HTTP server with a stack of handlers to validate incoming requests and return prefabricated responses.
• Label-Based Filtering - Includes or excludes tests based on textual tags and complex logical queries using set-based operations.
• Parallel Setup Synchronization - Coordinates a single setup process across multiple parallel workers to share expensive external resources.
• Test Case Generators - Creates test cases programmatically using loops or configuration files during the suite construction phase.
• Test Execution Filtering - Provides the ability to isolate and run tests based on their file paths or specific line number ranges.
• Shared Behaviors - Extracts common sets of assertions into reusable functions to avoid duplicating tests across contexts.
• Sequence Controllers - Ensures specific groups of tests run in a fixed sequence when they rely on shared mutating state.
• Test Sharding - Distributes test workloads across multiple processes to utilize multiple CPU cores and reduce runtime.
• Test Suite Filters - Isolates and runs specific subsets of a large test suite using labels and command-line flags.
• Serial Test Execution Modes - Guarantees that specific tests run sequentially on a single process to avoid resource contention.
• Frameworks and Libraries - BDD-style testing framework for Go.
• Frameworks de test - BDD-style testing framework.

Historique des stars