Skipping an exception in all Python tests

I'm using Python's unittest with pytest for integration testing a library against a third-party API.

Some of the API calls are temporarily returning an error which raises a specific exception in my code. This behaviour is fine in the code.

However, rather than having the tests fail, I'd rather skip these temporary errors.

I have over 150 tests. Rather than rewriting each and every test like this:

class TestMyLibrary(unittest.TestCase):

    def test_some_test(self):
        try:
            // run the test as normal
            // assert the normal behaviour
        except SomeException:
            // skip the test

    def test_some_other_test(self):
        try:
            // run the test as normal
            // assert the normal behaviour
        except SomeException:
            // skip the test

Can I rather wrap them all somehow at the class level, or similar?

If you expect this exception why don't you check its raised when it should? You can use :

pytest.raises(Exceptiontype, Foo())

unittest — Unit testing framework — Python 3.8.5 documentation, The command line can also be used for test discovery, for running all of the tests in a The following decorators and exception implement test skipping and� Skipping an exception in all Python tests. Ask Question Asked 4 years, 8 months ago. Active 1 year, 2 months ago. Viewed 1k times 1. I'm using Python

This can be done with a decorator. For example:

def handle_lastfm_exceptions(f):
    def wrapper(*args, **kw):
        try:
            return f(*args, **kw)
        except pylast.WSError as e:
            if (str(e) == "Invalid Method - "
                          "No method with that name in this package"):
                msg = "Ignore broken Last.fm API: " + str(e)
                print(msg)
                pytest.skip(msg)
            else:
                raise(e)
    return wrapper

And then decorate the problematic functions:

class TestMyLibrary(unittest.TestCase):

    @handle_lastfm_exceptions
    def test_some_bad_test(self):
        // run the test as normal
        // assert the normal behaviour

    def test_some_good_test(self):
        // run the test as normal
        // assert the normal behaviour

Python, This article aims to write a unit test that cleanly tests if an exception is raised. To test Code #2 : Test the exception's value with a different approach is needed. If it does, it returns "Email format is ok", otherwise, an exception is raised. Using pytest.raises in a with block as a context manager, we can check that an exception is actually raised if an invalid email is given. Running the tests on the code as it is above should fail:

had the same problem (instable 3rd party library, waiting for fix...). ended up with something like this:

def pytest_runtest_makereport(item, call):
    from _pytest.runner import pytest_runtest_makereport as orig_pytest_runtest_makereport
    tr = orig_pytest_runtest_makereport(item, call)

    if call.excinfo is not None:
        if call.excinfo.type == SomeExceptionFromLibrary:
            tr.outcome = 'skipped'
            tr.wasxfail = "reason: SomeExceptionFromLibrary. shame on them..."

    return tr

works like a charm

Tests are not showing as "Skipped" when a unittest.SkipTest error is , It's silently skipping the entire class instead of verbosely skipping them. It all boiled down to Python treating a SkipTest exception raised� The Python: Debug All Tests and Python: Debug Test Method commands (on both the Command Palette and Status Bar menu) launch the debugger for all tests and a single test method, respectively. You can also use the "bug" icons in Test Explorer to launch the debugger for all tests in a selected scope as well as all discovered tests.

Asserting Exceptions with Pytest - DEV, First time I had someone review my pull requests, she was pretty strict on test Tagged with python, tdd, learning, tutorial. Skipping Tests¶ It is frequently useful to be able to skip a test if some external condition is not met. For example, when writing tests to check behavior of a library under a specific version of Python there is no reason to run those tests under other versions of Python. Test classes and methods can be decorated with skip() to always skip the

Working with Exceptions using PyTest, Skip to content; Skip to breadcrumbs; Skip to header menu; Skip to Have you ever wondering how to test your custom Python Exceptions? PyTest can help you with this. It has method that test for raised exception called pytest.raises. the test is failing in a more specific way than just having any exception� The Python unit testing framework, sometimes referred to as “PyUnit,” is a Python language version of JUnit, by Kent Beck and Erich Gamma. unittest supports test automation, sharing of setup and shutdown code for tests, aggregation of tests into collections, and independence of the tests from the reporting framework.To achieve this

Python Unit Testing — LSST DM Developer Guide u-ktl-vim-python , All LSST products that are built using scons will execute Python tests using pytest so of individual tests and entire classes using decorators or skip exceptions. Skipping tests conditionally¶ skipif, a string option, can be used to skip directives conditionally. This may be useful e.g. when a different set of tests should be run depending on the environment (hardware, network/VPN, optional dependencies or different versions of dependencies). The skipif option is supported by all of the doctest directives.

Comments
  • It's happening for over 50 tests. It's a temporary error in the third-party API for certain calls, which used to work and they should be fixing soon. In the meantime, I'd rather just globally skip than find and edit each test, then have to review later and revert as each is fixed.