nrt-unittest-soft-asserts

Unittest soft asserts.

Supported asserts:

Assert	Description	Example	Return
soft_assert_true(condition, message=None)	Verify that condition is True.	self.soft_assert_true(a == b)	True if assertion passes, False if assertion fails.
soft_assert_false(condition, message=None)	Verify that condition is False.	self.soft_assert_false(a == b)	True if assertion passes, False if assertion fails.
soft_assert_equal(first, second, message=None)	Verify that first is equal to second.	self.soft_assert_equal(a, b)	True if assertion passes, False if assertion fails.
soft_assert_not_equal(first, second, message=None)	Verify that first is not equal to second.	self.soft_assert_not_equal(a, b)	True if assertion passes, False if assertion fails.
soft_assert_is(first, second, message=None)	Verify that first and second are the same object.	self.soft_assert_is(a, b)	True if assertion passes, False if assertion fails.
soft_assert_is_not(first, second, message=None)	Verify that first and second are not the same object.	self.soft_assert_is_not(a, b)	True if assertion passes, False if assertion fails.
soft_assert_is_none(obj, message=None)	Verify that obj is None.	self.soft_assert_is_none(a)	True if assertion passes, False if assertion fails.
soft_assert_is_not_none(obj, message=None)	Verify that obj is not None.	self.soft_assert_is_not_none(a)	True if assertion passes, False if assertion fails.
soft_assert_in(obj, container, message=None)	Verify that obj is in container.	self.soft_assert_in(a, [a, b, c])	True if assertion passes, False if assertion fails.
soft_assert_not_in(obj, container, message=None)	Verify that obj is not in container.	self.soft_assert_not_in(a, [b, c])	True if assertion passes, False if assertion fails.
soft_assert_is_instance(obj, cls, message=None)	Verify that obj is instance of cls.	self.soft_assert_is_instance(a, A)	True if assertion passes, False if assertion fails.
soft_assert_is_not_instance(obj, cls, message=None)	Verify that obj is not instance of cls.	self.soft_assert_is_not_instance(a, B)	True if assertion passes, False if assertion fails.
soft_assert_almost_equal(first, second, delta, message=None)	Verify that first is almost equal to second. and the different is equal or less to delta.	self.soft_assert_almost_equal(1.001, 1.002, 0.1)	True if assertion passes, False if assertion fails.
soft_assert_not_almost_equal(first, second, delta, message=None)	Verify that first is not almost equal to second and the different is more than delta.	self.soft_assert_not_almost_equal(1.001, 1.002, 0.0001)	True if assertion passes, False if assertion fails.
soft_assert_raises(exception, method: Callable, *args, **kwargs)	Verify that method execution raise exception.	self.soft_assert_raises(TypeError, sum, 'a', 2)	True if assertion passes, False if assertion fails.
soft_assert_raises_with(exception, message=None)	Verify that execution in 'with' block raise exception.	with self.soft_assert_raised_with(ValueError):     raise ValueError(ERROR_MESSAGE_1)

In the end of each test, the soft asserts will be verified and the test will be marked as failed if any of the asserts failed.
To verify the soft asserts in the middle of the test, call self.soft_assert_all().

soft_assert_all() will raise AssertionError if any of the asserts failed.

Steps

Each testing section can be divided to steps. The meaning of this is that if one of the asserts in a step failed,
then the step will be entered to list of failure steps and next test can be skipped if it is depended on the failed step.

Example:

To make test be skipped if step failed, a custom decorator should be created.

This is an example of such custom decorator, but user can create its own custom decorator.

import functools
from nrt_unittest_soft_asserts.soft_asserts import SoftAsserts

# Custom decorator to skip test if one of the steps failed.
def skip_steps(skip_steps_list: list[str]):
    def decorator(test_method):
        @functools.wraps(test_method)
        def wrapper(self, *args, **kwargs):
            for step in skip_steps_list:
                if self.is_step_in_failure_steps(step):
                    self.skipTest(f'Skipped because step [{step}] failed.')
            return test_method(self, *args, **kwargs)

        return wrapper

    return decorator


class SoftAssertsExamplesTests(SoftAsserts):
    STEP_1 = 'step 1'
    STEP_2 = 'step 2'
    STEP_3 = 'step 3'
    
    def test_01_assert_with_steps_test_will_fail(self):
        self.set_step(self.STEP_1)
        # result is False
        result = self.soft_assert_true(False)

        self.set_step(self.STEP_2)
        self.soft_assert_true(False)

        # From this code section steps will not be attached to failure asserts
        self.unset_step()
        self.soft_assert_true(False)

        self.soft_assert_all()

    @skip_steps([STEP_1])
    def test_02_skip_if_step_1_fail(self):
        self.soft_assert_true(False)
        self.soft_assert_all()

    @skip_steps([STEP_2])
    def test_03_skip_if_step_2_fail(self):
        self.soft_assert_true(False)
        self.soft_assert_all()

    @skip_steps([STEP_1, STEP_2])
    def test_04_skip_if_step_1_or_step2_fail(self):
        self.soft_assert_true(False)
        self.soft_assert_all()

    @skip_steps([STEP_3])
    def test_05_skip_if_step_3_fail_will_not_be_skipped(self):
        """
        Test should not be skipped because {STEP_3} is not in failure steps.
        """
        # result is True
        result = self.soft_assert_true(True)
        self.soft_assert_all()

Print error on each failed assert

Each assert failure can be printed.
This can be done by adding logger or by adding a print method.

• In case a logger will be added, then logger.error(message) will be used.
• In case a print method will be added, then print_method(message) will be used.
• logger and print method cannot be added together.

Error format

message [file_path: line_number] code_line

logger example:

import logging
from nrt_unittest_soft_asserts.soft_asserts import SoftAsserts


class SoftAssertsWithLoggerTests(SoftAsserts):
    logger = logging.getLogger('test')

    @classmethod
    def setUpClass(cls):
        super().setUpClass()
        cls.set_logger(cls.logger)
        
    def test_assert_true_fail(self):
        i = 1
        j = 2
        # logger.error() will print messages to console for each assert that fails
        self.soft_assert_true(i + j == 5)
        self.soft_assert_equal(i, j, f'{i} is different from {j}')
        self.soft_assert_all()

print method example:

from nrt_unittest_soft_asserts.soft_asserts import SoftAsserts

class SoftAssertsWithPrintMethodTests(SoftAsserts):
    
    def setUp(self):
        super().setUp()
        self.set_print_method(self.__print_message)

    def test_assert_true_fail(self):
        i = 1
        j = 2
        # self.__print_message() will print messages 
        # to console for each assert that fails
        self.soft_assert_true(i + j == 5)
        self.soft_assert_equal(i, j, f'{i} is different from {j}')
        self.soft_assert_all()
        
    def __print_message(self, msg):
            print()

Wiki: https://github.com/etuzon/python-nrt-unittest-soft-asserts/wiki