delayed-assert 0.4.2

Delayed/soft assertions for python

Python-Delayed-Assert

Delayed aka. Soft asserts for python

Few features:

- No Dependenices on any other framework/library.
- Should work with any testing framework.
- Can be use as decorator or context manager.

Installation

Install via pip

    pip install delayed-assert

Install from master

    pip install git+https://github.com/pr4bh4sh/delayed-assert

Uses

See example_unittest.py for usage.

Using assertion library with lambda

Pass the assertion call as

    expect(lambda: self.assertListEqual([4,5,6,2,5],[7,8]))

While I've tested only with unittest asserttion,It should be able to use any assertion library.

Keep in mind that, Python does not support statement inside lambda, so

    expect(lambda: assert 1 == 1)

won't work as it is not a valid lambda expression in python

Current possible uses

    def testSomething(self):
        delayed_assert.expect(1 == 1) # will succeed
        delayed_assert.expect(1 == 2) # will fail but won't stop execution
        delayed_assert.expect(3 == 2, "Value don't match") # will fail but won't stop execution
        delayed_assert.expect(3 == 3) # will succeed
        # will stop execution and show the stack trace of 2nd assertion
        delayed_assert.assert_expectations()

    def testLambdas(self):
        expect(lambda: self.assertEqual(3,4)) # will fail but won't stop execution
        expect(lambda: self.assertListEqual([4,5,6,2,5],[7,8])) # will fail but won't stop execution
        assert_expectations()

    @delayed_assert.assert_all()
    def testDecorator(self):
        expect('five' == 'Six', 'String do not match')
        expect([5,2] == [3,4], 'List item do not match')
        expect([3,4] == [3,4], 'This message wont be printed')
        # No need to call delayed_assert.assert_expectations() when decorator is used
    
    def testContextManeger(self):
        with delayed_assert.assert_all():
            expect('four' == 'Six', 'String do not match')
            expect([5,2] == [3,4], 'List item do not match')
            expect([3,4] == [3,4], 'This message wont be printed')
            # No need to call delayed_assert.assert_expectations() when using context maneger is used

---

Color Output Control

The library supports toggling colorized output on/off via environment variable or programmatically.

Disable Colors via Environment Variable

# Disable colors
DELAYED_ASSERT_ENABLE_COLOR=0 python -m unittest example_unittest.py

# Enable colors (default)
DELAYED_ASSERT_ENABLE_COLOR=1 python -m unittest example_unittest.py

Values that disable colors: 0, false, no, off (case-insensitive)

Disable Colors Programmatically

from delayed_assert.delayed_assert import set_color_enabled, get_color_enabled

# Disable colors
set_color_enabled(False)

# Check status
if get_color_enabled():
    print("Colors are enabled")

This is useful for:

• CI/CD environments where ANSI color codes may not be supported
• Log files where color codes create noise
• Environments with accessibility requirements

Caller Stack Verification

By default, the library verifies that expect() is called from a method named test*. You can disable this check if you need to use expect() in helper methods or custom test runners.

Disable via Environment Variable:

DELAYED_ASSERT_CHECK_CALLER=0 python -m unittest example_unittest.py

Disable Programmatically:

from delayed_assert.delayed_assert import set_check_caller

set_check_caller(False)

Using the @test_case Decorator:

Alternatively, you can mark any function as a test case using the @test_case decorator. This allows expect() to identify the function correctly without disabling verificaton globally.

from delayed_assert import expect, assert_expectations, test_case

@test_case
def verify_custom_scenario():
    expect(1 == 1, "Should pass")

def test_runner():
    verify_custom_scenario()
    assert_expectations()

---

Credit : http://pythontesting.net/strategy/delayed-assert/