def run_test(self):
    try:
        myFunc()
    except ExceptionType:
        self.fail("myFunc() raised ExceptionType unexpectedly!")

If your function supplies a result, the usual practice is to test that result.

If it doesn't, you don't have to do anything after the call.

If your testing framework forces you to fill in the "then" part of the standard unit test format anyway, well, Python has pass for precisely this situation.

Use TestCase.assertRaises from the unittest module, for example:

import mymod

class MyTestCase(unittest.TestCase):
    def test1(self):
        self.assertRaises(SomeCoolException, mymod.myfunc)

If I understand your question correctly, you could do something like this:

def test_does_not_raise_on_valid_input(self):
    raised = False
    try:
        do_something(42)
    except:
        raised = True
    self.assertFalse(raised, 'Exception raised')

...assuming that you have a corresponding test that the correct Exception gets raised on invalid input, of course:

def test_does_raise_on_invalid_input(self):
    self.assertRaises(OutOfCheese, do_something, 43)

However, as pointed out in the comments, you need to consider what it is that you are actually testing. It's likely that a test like...

def test_what_is_42(self):
    self.assertEquals(do_something(42), 'Meaning of life')

...is better because it tests the desired behaviour of the system and will fail if an exception is raised.

Because the call to self.client.post is not actually raising an InvalidValueException.

The view function raises the exception, which gets caught by an exception handler and returns JSON to the client.

You should not use assertRaises in this case, but instead use the assertEquals on the status code (and maybe check the actual error type in the response JSON).

Think of it like this (a super simple example):

def api_endpoint():
    raise ValueError

def handle_post_api_endpoint():
    try:
        return api_endpoint()
    except ValueError:
        return {'type': 'ValueError'}

When you call self.client.post it's not actually calling api_endpoint. It's calling something else (handle_post_api_endpoint) that handles the error and returns something else.

I think you just need to re-raise the assertion error after printing out log messages:

try:
    self.assertEqual(len(self.verificationErrors), 0)  # no errors
except AssertionError as e:
    for message in self.verificationErrors:
        print(str(message))
    raise  # < HERE

Also, if you want to check for severe console messages after every single test, see if it would make sense to do it in a "tear down" function of your test case.

Or, you may also assert self.verificationErrors is an empty list. In case of failure, you would get to see all the messages on a console:

self.assertEqual(self.verificationErrors, [])