Delayed/Soft Assertions for Python

0.4.2 · active · verified Thu Apr 16

delayed-assert is a Python library that provides delayed or soft assertions, allowing test execution to continue even after an `expect()` call fails. All accumulated failures are then reported at a designated point using `assert_expectations()` or implicitly with a decorator/context manager. It is framework-agnostic and currently at version 0.4.2, with a moderate release cadence focusing on usability and feature enhancements like improved test case identification and output control.

Common errors

```
ImportError: No module named 'delayed_assert'
```
cause The `delayed-assert` package is either not installed, or there's an issue with the Python environment's path, or an incorrect import statement (e.g., `import delayed_assert.delayed_assert`).

fix Ensure the package is installed using `pip install delayed-assert`. Verify the import statement is `from delayed_assert import expect, assert_expectations` (or other specific symbols).
```
AssertionError: Some expectations failed.
```
cause This error is the intended behavior of `assert_expectations()` (or `@assert_all()`) when one or more `expect()` calls have evaluated to `False`.

fix Review the details printed with the `AssertionError` to identify which `expect()` calls failed. These details will include the expression, message, and location of the failure. This indicates a test failure, not a library issue.
```
SyntaxError: invalid syntax (cannot use 'assert' statement inside a lambda)
```
cause Attempting to use Python's `assert` statement directly within a lambda function passed to `expect()`.

fix Reformulate the condition as a boolean expression (e.g., `expect(x == y)`) or, if integrating with `unittest` assertions, pass the `unittest` assertion method directly to the lambda (e.g., `expect(lambda: self.assertEqual(x, y))`).
```
Error: expect() must be called from a method named 'test_*' or marked with '@test_case' if caller verification is enabled.
```
cause This occurs when `expect()` is called from a function whose name does not start with `test_`, and caller verification (default enabled in >=0.4.1) is active.

fix Rename your function to start with `test_`, apply the `@test_case` decorator to the function, or disable caller verification as described in the warnings section (e.g., `DELAYED_ASSERT_CHECK_CALLER=0` or `set_check_caller(False)`).

Warnings

gotcha By default, `expect()` verifies that it is called from a method named `test_something`. If you use `expect()` in helper methods or functions not prefixed with `test_`, it might raise an error.
Fix: Use the `@test_case` decorator on your test function, or disable caller verification globally by setting the environment variable `DELAYED_ASSERT_CHECK_CALLER=0`, or programmatically with `set_check_caller(False)`.
gotcha When using `expect()` with lambda expressions, `assert` statements are not valid within a lambda. For example, `expect(lambda: assert 1 == 1)` will result in a `SyntaxError`.
Fix: Pass an expression directly (e.g., `expect(1 == 1)`) or, if integrating with `unittest` assertions, pass the assertion call as a lambda expression without the `assert` keyword, e.g., `expect(lambda: self.assertEqual(3, 4))`.
gotcha If you are not using the `@assert_all()` decorator or `with assert_all():` context manager, you must explicitly call `assert_expectations()` at the end of your test case to report any collected failures.
Fix: Ensure `assert_expectations()` is called at the logical end of your test method where you want failures to be aggregated and reported. Alternatively, wrap your test method with `@assert_all()` or its contents in a `with assert_all():` block.
gotcha Colorized output for failure reports is enabled by default. This might introduce unwanted ANSI escape codes into logs or environments that don't support color output (e.g., some CI/CD pipelines).
Fix: Disable color output by setting the environment variable `DELAYED_ASSERT_ENABLE_COLOR=0` or programmatically using `set_color_enabled(False)`.

Install

pip install delayed-assert Install latest stable version

Imports

expect
```
from delayed_assert import expect
```
Evaluates an expression and records failures without stopping execution.
assert_expectations
```
from delayed_assert import assert_expectations
```
Raises an AssertionError if any 'expect()' calls failed in the current scope. Must be called explicitly if not using @assert_all or with assert_all().
test_case
```
from delayed_assert import test_case
```
Decorator to explicitly mark a function as a test case, allowing 'expect()' to work correctly even if the function name doesn't start with 'test_'.
assert_all
```
from delayed_assert import assert_all
```
Decorator or context manager that automatically calls 'assert_expectations()' at the end of the decorated function or 'with' block.
set_check_caller
```
from delayed_assert import set_check_caller
```
Programmatically enables/disables the caller stack verification for 'expect()'.
set_color_enabled
```
from delayed_assert import set_color_enabled
```
Programmatically enables/disables colorized output for failure reports.

Quickstart

This quickstart demonstrates the core functionality of delayed-assert. The `my_test_scenario` function shows explicit use of `expect()` and `assert_expectations()`. The `another_test_case` function demonstrates the `@assert_all()` decorator, which automatically collects and asserts all expectations at the end of the function. Failed expectations do not halt execution immediately, but `assert_expectations()` (or `@assert_all()`) will raise an `AssertionError` at the end if any `expect()` calls failed.

from delayed_assert import expect, assert_expectations, test_case, assert_all

@test_case
def my_test_scenario():
    print("\n--- Running my_test_scenario ---")
    expect(1 == 1, "Assertion 1 (should pass)")
    expect(1 == 2, "Assertion 2 (should fail)")
    expect(3 > 2, "Assertion 3 (should pass)")
    expect("hello" == "world", "Assertion 4 (should fail)")
    print("Continuing after failed expectations...")
    assert_expectations()

@assert_all()
def another_test_case():
    print("\n--- Running another_test_case (with decorator) ---")
    expect(True, "True is True")
    expect(False, "False is not True")
    # No need to call assert_expectations() explicitly here

if __name__ == "__main__":
    try:
        my_test_scenario()
    except AssertionError as e:
        print(f"Caught expected AssertionError for my_test_scenario:\n{e}")

    try:
        another_test_case()
    except AssertionError as e:
        print(f"Caught expected AssertionError for another_test_case:\n{e}")

view raw JSON →