CODEWITHSUNDEEP
pythonpython-unittest
Jacobian
Jacobian

Reputation: 10802

Unable to pass assertRaises test in Python

So, I have the most trivial in the world example. This is my class to be tested:

# My_Class.py
class My_Class(object):    
    @staticmethod     
    def doit(name, params):
        try:
            raise Exception("This is my error message")
        except Exception:
            print("Exception: I raised Exception")

And this is the tester itself:

# test.py
import unittest
from My_Class import My_Class

class Test_MyClass(unittest.TestCase):

    def setUp(self):
        self.my_class = My_Class()   

    def test_my_class(self):
        name = "Abrakadabra"
        params = {}
        self.assertRaises(Exception, self.my_class.doit, name, params)

And this is what I see in the console, when I'm running my test.py:

$ nosetests test.py
F
======================================================================
FAIL: test_my_class (test.Test_MyClass)
----------------------------------------------------------------------
Traceback (most recent call last):
  File ....
nose.proxy.AssertionError: Exception not raised by doit
-------------------- >> begin captured stdout << ---------------------
Exception: I raised Exception

--------------------- >> end captured stdout << ----------------------

----------------------------------------------------------------------
Ran 1 test in 0.001s

FAILED (failures=1)

It is reaaly iteresting, because it is controversial. On the one hand the test says that "Exception not raised by doit", but one line below it clearly prints out a message from the Exception block. So, what I'm doing wrong here??? Thanks!

Upvotes: 1

Views: 1435

Answers (3)

idjaw
idjaw

Reputation: 26578

To directly answer your question, the reason why you are getting that message is because with this assertion: 

self.assertRaises(Exception, self.my_class.doit, name, params)

You are testing to make sure an exception was raised. But your try/except suppresses this. If you actually remove your try/except your test will in fact pass, because now your method will raise.

Since you do not want to do this, what you should be doing instead is testing the behaviour of your method when an exception is raised. Ultimately, you want to make sure that your print method is called in your except. I have put together an example below to help understand this.

Keeping in mind what @user2357112 mentioned, which is very important to keep in mind when unittesting, here is an example to help expand on that to provide a practical use for what you are trying to do:

Let us just put together some method:

def some_method():
    pass

We will now put this in to your staticmethod you defined as such:

# My_Class.py
class My_Class(object):    
    @staticmethod     
    def doit(name, params):
        try:
            some_method()
        except Exception:
            print("Exception: I raised Exception")

So now, when it comes to your unittesting, you want to test the behaviour of your method doit. With that in mind, what you will do in this case, is test that some_method will raise an exception and you will validate how your doit method behaves to that exception being raised.

At this point, I suggest taking a look at the documentation behind unittest and mock to get more familiar with what you can do with your testing, but here is an example using mock patching to test the behaviour of your code if an exception is being raised: 

@patch('builtins.print')
@patch('__main__.some_method')
def test_my_class(self, m_some_method, m_print):
    name = "Abrakadabra"
    params = {}
    # have the side_effect raise the exception when some_method is called in doit
    m_some_method.side_effect = Exception()

    self.my_class.doit(name, params)

    # check to make sure you caught the exception by checking print was called
    self.assertEqual(m_print.call_count, 1)

When you put it all together, the following is functional code that I ran on my end that you can play around with to understand what is happening: 

def some_method():
    pass

# My_Class.py
class My_Class(object):    
    @staticmethod     
    def doit(name, params):
        try:
            some_method()
        except Exception:
            print("Exception: I raised Exception")


# test.py
import unittest
from mock import patch

class Test_MyClass(unittest.TestCase):

    def setUp(self):
        self.my_class = My_Class()

@patch('builtins.print')
@patch('__main__.some_method')
def test_my_class(self, m_some_method, m_print):
    name = "Abrakadabra"
    params = {}
    m_some_method.side_effect = Exception()
    self.my_class.doit(name, params)
    self.assertEqual(m_print.call_count, 1)


if __name__ == '__main__':
    unittest.main()

Upvotes: 3

alecxe
alecxe

Reputation: 473853

assertRaises failed since there was actually no exception raised. Well, it was raised but handled with except inside the doit() method. The problem is here:

try:
    raise Exception("This is my error message")
except Exception:
    print("Exception: I raised Exception")

You are raising an exception and then catching it without re-raising. From a caller (assertRaises is the caller in your case) perspective, no errors were thrown during the function call. Re-raising an exception allows a caller to handle an exception as well. Put a raise after the print:

try:
    raise Exception("This is my error message")
except Exception:
    print("Exception: I raised Exception")
    raise  # re-raising

Also see Handling Exceptions.

Upvotes: 1

user2357112
user2357112

Reputation: 280485

assertRaises is an assertion about the function's visible behavior, not its internals. It asserts that the stated exception passes out of the function. Any exceptions that are handled inside the function are not assertRaises's concern.

Upvotes: 1

Related Questions