https://github.com/pr4bh4sh/delayed-assert
Delayed aka. Soft assert for python
https://github.com/pr4bh4sh/delayed-assert
assertion-library delayed-assert pip python python-library python-package python3 soft-assert testing
Last synced: 14 days ago
JSON representation
Delayed aka. Soft assert for python
- Host: GitHub
- URL: https://github.com/pr4bh4sh/delayed-assert
- Owner: pr4bh4sh
- License: unlicense
- Created: 2016-10-07T11:25:25.000Z (about 9 years ago)
- Default Branch: master
- Last Pushed: 2021-09-17T17:47:40.000Z (over 4 years ago)
- Last Synced: 2025-03-19T17:43:41.715Z (9 months ago)
- Topics: assertion-library, delayed-assert, pip, python, python-library, python-package, python3, soft-assert, testing
- Language: Python
- Homepage: https://pr4bh4sh.github.io/delayed-assert/
- Size: 543 KB
- Stars: 30
- Watchers: 5
- Forks: 6
- Open Issues: 7
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
[](https://github.com/pr4bh4sh/delayed-assert/actions/workflows/tests.yml)
[](https://badge.fury.io/py/delayed-assert)
[](https://pepy.tech/project/delayed-assert)
[](https://pepy.tech/project/delayed-assert)
# 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
```bash
pip install delayed-assert
```
### Install from master
```bash
pip install git+https://github.com/pr4bh4sh/delayed-assert
```
## Uses
See `tests/example_unittest.py` for usage.
### Using assertion library with lambda
Pass the assertion call as
```python
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
```python
expect(lambda: assert 1 == 1)
```
won't work as it is not a valid lambda expression in python
### Current possible uses
```python
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
# Use @test_case to identify helper methods or non-standard test names
@delayed_assert.test_case
def verify_something_helper(self):
expect(1 == 1)
```
---------------
## Color Output Control
The library supports toggling colorized output on/off via environment variable or programmatically.
### Disable Colors via Environment Variable
```bash
# 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
```python
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:**
```bash
DELAYED_ASSERT_CHECK_CALLER=0 python -m unittest example_unittest.py
```
**Disable Programmatically:**
```python
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.
```python
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 :