How to make assertions about captured exceptions?

[1Mark]

How to make assertions about captured exceptions?

[bjoluc]

Then you'll want to use reraise.reset():

    # I want it to fail here.
    assert type(reraise.reset()) is AssertionError

[1Mark]

I also tried catching the exception so that it doesn't get raised in the main thread but that didn't work either

import pytest
from threading import Thread
def test_assert(reraise):
    def run():
        with reraise(catch=True):
            raise ValueError
    t = Thread(target=run)
    t.start()
    t.join()
    # Return the captured exception:
    assert type(reraise.exception) == 5

[bjoluc]

The following example from the README isn't very useful since once the AssertionError is raised in run(), the rest isn't executed.

I'm not sure if I fully get the problem here: In the example, the full test case should be executed and the captured exception should only be raised at the end.

but you cannot easily check what type it is without using @pytest.mark.xfail(strict=True, raises=ValueError)

Have you tried reraise.reset() to return the exception and not raise it at the end?

[bjoluc]

I also tried catching the exception so that it doesn't get raised in the main thread but that didn't work either

The point about catching exceptions is that the run function thread is not terminated after an exception has been captured by a context manager in it. The catch=True in your example doesn't make any difference since raise ValueError is the last line of your run() function.

Let me know if you think there's anything in the readme that could be improved :)

[1Mark]

I want to be able to access the exception from the main thread, but without raising it again. That way I can check what kind of exception was raised?

def test_assert(reraise):

    def run():
        with reraise:
            assert False # instead of it failing here.

    t = Thread(target=run)
    t.start()
    t.join()

    # I want it to fail here.
    assert type(reraise.exception) is AssertionError

[1Mark]

This code is assertion oriented, I want to ensure my assertion controls the test not the exception.

def test_assert(reraise):

    def run():
        with reraise:
            assert False

    t = Thread(target=run)
    t.start()
    t.join()

    assert type(reraise.reset()) is AssertionError

However, the following code below is Exception oriented and when the exception is raised then you can consider everything under t.join() as "dead code". The reason why I dislike this is because I'm testing a scenario where the thread should raise an exception.

import pytest
from threading import Thread


def test_assert(reraise):

    def run():
        with reraise:
            assert False

    t = Thread(target=run)
    t.start()
    t.join()

    # This won't be evaluated 
    assert type(reraise.exception) is ValueError

[1Mark]

I updated the code snippet.

[1Mark]

Also this means you can't really use reraise.exception without reraise.reset()

[bjoluc]

However, the following code below is Exception oriented and when the exception is raised then you can consider everything under t.join() as "dead code".

Right, although the code is technically executed, just that if it raises an exception, that exception is masked by the captured one – see Exception Priority.

Also this means you can't really use reraise.exception without reraise.reset()

Correct, if by "use" you mean writing an assert statement with it. One might also use reraise.exception for other things like if statements or assigning exceptions. Anyway, reraise.exception is just an implementation detail that I decided to expose in case someone needs it – no guarantees that it's useful to anyone, but it doesn't do any harm either 😛