mockery/mockery
Mockery
Mockery is a PHP framework designed for creating test doubles, stubs, and spies to facilitate isolated unit testing. It serves as a utility for simulating class behavior, intercepting method calls, and validating arguments, allowing developers to replace real dependencies with mock objects to verify that code components interact as intended.
The framework distinguishes itself through advanced capabilities for handling complex testing scenarios, such as bypassing constructors, mocking protected methods, and intercepting static calls or internal object instantiations. It provides a fluent interface for defining intricate expectations, including call frequency constraints, execution order control, and custom argument validation. Additionally, it supports partial mocking, which allows test doubles to selectively execute original class logic while overriding specific methods to isolate units of code within legacy systems.
Beyond core mocking, the library offers comprehensive tools for interaction verification, enabling the recording of method invocations for post-execution inspection. It integrates directly with standard test runners to automate the lifecycle management of mock objects, including setup, teardown, and the verification of expectations. Global configuration settings allow for standardized error reporting and behavior across entire test suites.
Features
- Dependency Mocking - Provides a comprehensive framework for replacing class dependencies with mock objects to isolate units of code during testing.
- Mocking Frameworks - Provides a framework for defining expectations, return values, and interaction patterns for test doubles.
- Interaction Verification Utilities - Records and asserts method calls, argument patterns, and execution sequences to ensure components interact correctly.
- Unit Testing Frameworks - Creates simulated objects to replace real dependencies, allowing developers to test individual classes in isolation.
- Static and Instantiation Interceptors - Replaces hard-coded object creation and static calls with mock instances to control internal dependencies.
- Test Suite Integrations - Connects mock lifecycles with testing frameworks to automate setup, teardown, and validation of expectations.
- Interaction Spies - Captures method invocation history on mock objects to enable post-execution verification of behavior.
- Testing and Quality - Mock object library for testing.
- Mock Expectation Definitions - Configures mock objects to anticipate specific method calls and return sequences.
- Fluent Interfaces - Provides a chainable interface for defining complex method constraints, return values, and call counts during test setup.
- Mock Interaction Recorders - Captures method calls made to a mock object to enable post-execution inspection.
- Legacy Code Isolation Tools - Isolates specific logic by creating partial mocks or intercepting hard-coded dependencies to test complex systems.
- Test Lifecycle Integrations - Hooks into standard test runner teardown phases to automatically verify expectations and clean up mock object state.
- Partial Mocks - Allows test doubles to selectively execute original class logic while overriding specific methods to isolate units of code.
- Protected Method Mocks - Allows defining expectations on protected class methods to handle scenarios where public interfaces are insufficient for isolation.
- Partial Mocking Utilities - Configures test doubles to execute real code for some methods while stubbing others to isolate specific logic.
- Mocking Observability Tools - Reports specific errors and provides detailed exception objects when expectations are violated during test execution.
- Method Return Values - Specifies the output of mocked methods by defining static values or sequential return sequences.
- Argument Constraint Matchers - Evaluates method parameters against custom logic or type patterns to validate interaction data during execution.
- Method Call Verification - Records method calls to test doubles for verification after the code under test has finished executing.
- Method Call Frequency Constraints - Enforces constraints on method invocation counts to ensure correct interaction patterns.
- Constructor Bypassing - Provides mechanisms to instantiate objects without executing constructors to avoid side effects during test setup.
- Lifecycle Management - Ensures mock containers are properly closed and expectations are verified automatically during the test teardown phase.
- Method Stubbing Utilities - Sets baseline expectations for mock objects that remain active unless selectively overridden.
- Reflection-Based Proxies - Generates mock objects at runtime by inspecting class signatures and creating dynamic proxies that intercept method calls.
- Global Mocking Settings - Provides global settings to adjust default object creation, verification strictness, and error handling.
- Dynamic - Enables the creation of test doubles that implement specific traits on the fly to satisfy interface requirements during unit testing.
- Magic Method Interceptors - Simulates magic method behavior by intercepting calls to virtual methods and properties during testing.
- Exception Simulation Utilities - Configures mock objects to throw specific exceptions to verify failure handling.
- Static Method Aliases - Replaces class names with mock aliases at runtime to intercept static calls and object instantiations.
- Test Argument Validators - Provides mechanisms to validate arguments passed to mock objects during test execution.
- Interaction Sequence Orderers - Allows specification of required method call sequences to ensure correct interaction order.
