I&#39;m working on a python (2.7) program that produce a lot of different matplotlib figure (the data are not random). I&#39;m willing to implement some test (using unittest) to be sure that the generated figures are correct. For instance, I store the expected figure (data or image) in some place, I run my function and compare the result with the reference. Is there a way to do this ?

How can I write unit tests against code that uses matplotlib?

How do I persist changes made within the same object inheriting from `TestCase` in unitttest?

    from unittest import TestCase, main as unittest_main
    
    
    class TestSimpleFoo(TestCase):
        foo = &#39;bar&#39;
    
        def setUp(self):
            pass
    
        def test_a(self):
            self.assertEqual(self.foo, &#39;bar&#39;)
            self.foo = &#39;can&#39;
    
        def test_f(self):
            self.assertEqual(self.foo, &#39;can&#39;)
    
    
    if __name__ == &#39;__main__&#39;:
        unittest_main()

I.e.: I want those two tests above to pass

Persist variable changes between tests in unittest?

I have just started writing some unit tests for a python project I have using `unittest` and `coverage`. I&#39;m only currently testing a small proportion, but I am trying to work out the code coverage

I run my tests and get the coverage using the following

    python -m unittest discover -s tests/
    coverage run -m unittest discover -s tests/
    coverage report -m

The problem I&#39;m having is that `coverage` is telling I have 44% code coverage and is only counting the files that:

1. were tested in the unit tests (i.e., all the files that were not tested are missing and not in the overall coverage)
 
2. were in the libraries in the virtual environment and code coverage of the actual tests too. Surely it should not be including the actual tests in the results?

Furthermore, it says the files that are actually tested in these unit tests only have the first few lines tested (which are in most cases the import statements)

How do I get a more realistic code coverage or is this how it is meant to be?

How do I make coverage include not tested files?

Is there a way to automatically start the debugger at the point at which a unittest fails?

Right now I am just using pdb.set_trace() manually, but this is very tedious as I need to add it each time and take it out at the end.

For Example:

    import unittest

    class tests(unittest.TestCase):

        def setUp(self):
            pass

        def test_trigger_pdb(self):
            #this is the way I do it now
            try:
                assert 1==0
            except AssertionError:
                import pdb
                pdb.set_trace()

        def test_no_trigger(self):
            #this is the way I would like to do it:
            a=1
            b=2
            assert a==b
            #magically, pdb would start here
            #so that I could inspect the values of a and b

    if __name__==&#39;__main__&#39;:
        #In the documentation the unittest.TestCase has a debug() method
        #but I don&#39;t understand how to use it
        #A=tests()
        #A.debug(A)

        unittest.main()



Python Unit Testing: Automatically Running the Debugger when a test fails

Is there a way in python for a pyunit test to output the test it&#39;s currently running.  Example:

    def setUp(self):
        log.debug(&quot;Test %s Started&quot; % (testname))

    def test_example(self):
        #do stuff

    def test_example2(self):
        #do other stuff

    def tearDown(self):
        log.debug(&quot;Test %s Finished&quot; % (testname))



A way to output pyunit test name in setup()

I want to understand how to `@patch` a function from an imported module.

This is where I am so far.

**app/mocking.py:**

    from app.my_module import get_user_name
    
    def test_method():
      return get_user_name()
    
    if __name__ == &quot;__main__&quot;:
      print &quot;Starting Program...&quot;
      test_method()

**app/my_module/__init__.py:**

    def get_user_name():
      return &quot;Unmocked User&quot;

**test/mock-test.py:**

    import unittest
    from app.mocking import test_method 
    
    def mock_get_user():
      return &quot;Mocked This Silly&quot;
    
    @patch(&#39;app.my_module.get_user_name&#39;)
    class MockingTestTestCase(unittest.TestCase):
    
      def test_mock_stubs(self, mock_method):
        mock_method.return_value = &#39;Mocked This Silly&#39;)
        ret = test_method()
        self.assertEqual(ret, &#39;Mocked This Silly&#39;)
    
    if __name__ == &#39;__main__&#39;:
      unittest.main()

This does **not** work as I would expect. The &quot;patched&quot; module simply returns the unmocked value of `get_user_name`. How do I mock methods from other packages that I am importing into a namespace under test?

Python Mocking a function from an imported module

How can individual unit tests be temporarily disabled when using the `unittest` module in Python?

Disable individual Python unit tests temporarily

What is the difference between `setUp()` and `setUpClass()` in the Python `unittest` framework? Why would setup be handled in one method over the other?

I want to understand what part of setup is done in the `setUp()` and `setUpClass()` functions, as well as with `tearDown()` and `tearDownClass()`.

What is the difference between setUp() and setUpClass() in Python unittest?

I have a python file `a.py` which contains two classes `A` and `B`.

    class A(object):
        def method_a(self):
            return &quot;Class A method a&quot;

    class B(object):
        def method_b(self):
            a = A()
            print a.method_a()

 
I would like to unittest `method_b` in class `B` by mocking `A`. Here is the content of the file `testa.py` for this purpose:

    import unittest
    import mock
    import a


    class TestB(unittest.TestCase):

        @mock.patch(&#39;a.A&#39;)
        def test_method_b(self, mock_a):
            mock_a.method_a.return_value = &#39;Mocked A&#39;
            b = a.B()
            b.method_b()


    if __name__ == &#39;__main__&#39;:
        unittest.main()

I expect to get `Mocked A` in the output. But what I get is:

    &lt;MagicMock name=&#39;A().method_a()&#39; id=&#39;4326621392&#39;&gt;

Where am I doing wrong?

Python returns MagicMock object instead of return_value

Can anyone explain the use of Python&#39;s `setUp` and `tearDown` methods while writing test cases apart from that `setUp` is called immediately before calling the test method and `tearDown` is called immediately after it has been called?

Explain the &quot;setUp&quot; and &quot;tearDown&quot; Python methods used in test cases

I have code within a Flask application that uses JSONs in the request, and I can get the JSON object like so:

    Request = request.get_json()

This has been working fine, however I am trying to create unit tests using Python&#39;s unittest module and I&#39;m having difficulty finding a way to send a JSON with the request.

    response=self.app.post(&#39;/test_function&#39;, 
                           data=json.dumps(dict(foo = &#39;bar&#39;)))

This gives me:

    &gt;&gt;&gt; request.get_data()
    &#39;{&quot;foo&quot;: &quot;bar&quot;}&#39;
    &gt;&gt;&gt; request.get_json()
    None

 Flask seems to have a JSON argument where you can set json=dict(foo=&#39;bar&#39;) within the post request, but I don&#39;t know how to do that with the unittest module.

How to send requests with JSON in unit tests

I&#39;m running this command:

    python manage.py test project.apps.app1.tests

and it causes this error:

&gt; AttributeError: &#39;module&#39; object has no attribute &#39;tests&#39;

Below is my directory structure. I&#39;ve also added app1 to my installed apps config.

    Traceback (most recent call last):
        File &quot;manage.py&quot;, line 10, in &lt;module&gt; execute_from_command_line(sys.argv)
        File &quot;/home/username/local/dev/local/lib/python2.7/site-packages/django/core/management/__init__.py&quot;, line 385, in execute_from_command_line
        utility.execute()
        File &quot;/home/username/local/dev/local/lib/python2.7/site-packages/django/core/management/__init__.py&quot;, line 377, in execute
        self.fetch_command(subcommand).run_from_argv(self.argv)
        File &quot;/home/username/local/dev/local/lib/python2.7/site-packages/django/core/management/commands/test.py&quot;, line 50, in run_from_argv
        super(Command, self).run_from_argv(argv)
        File &quot;/home/username/local/dev/local/lib/python2.7/site-packages/django/core/management/base.py&quot;, line 288, in run_from_argv
        self.execute(*args, **options.__dict__)
        File &quot;/home/username/local/dev/local/lib/python2.7/site-packages/django/core/management/commands/test.py&quot;, line 71, in execute
        super(Command, self).execute(*args, **options)
        File &quot;/home/username/local/dev/local/lib/python2.7/site-packages/django/core/management/base.py&quot;, line 338, in execute
        output = self.handle(*args, **options)
        File &quot;/home/username/local/dev/local/lib/python2.7/site-packages/django/core/management/commands/test.py&quot;, line 88, in handle
        failures = test_runner.run_tests(test_labels)
        File &quot;/home/username/local/dev/local/lib/python2.7/site-packages/django/test/runner.py&quot;, line 146, in run_tests
        suite = self.build_suite(test_labels, extra_tests)
        File &quot;/home/username/local/dev/local/lib/python2.7/site-packages/django/test/runner.py&quot;, line 66, in build_suite
        tests = self.test_loader.loadTestsFromName(label)
        File &quot;/usr/lib/python2.7/unittest/loader.py&quot;, line 100, in loadTestsFromName
        parent, obj = obj, getattr(obj, part)
        AttributeError: &#39;module&#39; object has no attribute &#39;tests&#39;

Directory structure:

![enter image description here][1]


  [1]: http://i.stack.imgur.com/DpRCx.png

AttributeError: &#39;module&#39; object has no attribute &#39;tests&#39;

What&#39;s the best way to write unit tests for code using the Python 3.4 `asyncio` library? Assume I want to test a TCP client (`SocketConnection`):

    import asyncio
    import unittest

    class TestSocketConnection(unittest.TestCase):
        def setUp(self):
            self.mock_server = MockServer(&quot;localhost&quot;, 1337)
            self.socket_connection = SocketConnection(&quot;localhost&quot;, 1337)

        @asyncio.coroutine
        def test_sends_handshake_after_connect(self):
            yield from self.socket_connection.connect()
            self.assertTrue(self.mock_server.received_handshake())

When running this test case with the default test runner, the test will always succeed as the method executes only up until the first `yield from` instruction, after which it returns before executing any assertions. This causes tests to always succeed.

Is there a prebuilt test runner that is able to handle asynchronous code like this?

How to test Python 3.4 asyncio code?

I have a test file that contains tests taking quite a lot of time (they send calculations to a cluster and wait for the result). All of these are in specific TestCase class.

Since they take time and furthermore are not likely to break, I&#39;d want to be able to choose whether this subset of tests does or doesn&#39;t run (the best way would be with a command-line argument, ie &quot;`./tests.py --offline`&quot; or something like that), so I could run most of the tests often and quickly and the whole set once in a while, when I have time.

For now, I just use `unittest.main()` to start the tests.





Python unittest: how to run only part of a test file?

I have a directory that contains my Python unit tests. Each unit test module is of the form **test_*.py**. I am attempting to make a file called **all_test.py** that will, you guessed it, run all files in the aforementioned test form and return the result. I have tried two methods so far; both have failed. I will show the two methods, and I hope someone out there knows how to actually do this correctly.

For my first valiant attempt, I thought &quot;If I just import all my testing modules in the file, and then call this `unittest.main()` doodad, it will work, right?&quot; Well, turns out I was wrong.

    import glob
    import unittest

    testSuite = unittest.TestSuite()
    test_file_strings = glob.glob(&#39;test_*.py&#39;)
    module_strings = [str[0:len(str)-3] for str in test_file_strings]

    if __name__ == &quot;__main__&quot;:
         unittest.main()

This did not work, the result I got was:

    $ python all_test.py 

    ----------------------------------------------------------------------
    Ran 0 tests in 0.000s

    OK

For my second try, I though, ok, maybe I will try to do this whole testing thing in a more &quot;manual&quot; fashion. So I attempted to do that below:

    import glob
    import unittest

    testSuite = unittest.TestSuite()
    test_file_strings = glob.glob(&#39;test_*.py&#39;)
    module_strings = [str[0:len(str)-3] for str in test_file_strings]
    [__import__(str) for str in module_strings]
    suites = [unittest.TestLoader().loadTestsFromName(str) for str in module_strings]
    [testSuite.addTest(suite) for suite in suites]
    print testSuite 

    result = unittest.TestResult()
    testSuite.run(result)
    print result

    #Ok, at this point I have a result
    #How do I display it as the normal unit test command line output?
    if __name__ == &quot;__main__&quot;:
        unittest.main()

This also did not work, but it seems so close!

    $ python all_test.py 
    &lt;unittest.TestSuite tests=[&lt;unittest.TestSuite tests=[&lt;unittest.TestSuite tests=[&lt;test_main.TestMain testMethod=test_respondes_to_get&gt;]&gt;]&gt;]&gt;
    &lt;unittest.TestResult run=1 errors=0 failures=0&gt;

    ----------------------------------------------------------------------
    Ran 0 tests in 0.000s

    OK

I seem to have a suite of some sort, and I can execute the result. I am a little concerned about the fact that it says I have only `run=1`, seems like that should be `run=2`, but it is progress. But how do I pass and display the result to main? Or how do I basically get it working so I can just run this file, and in doing so, run all the unit tests in this directory?

How do I run all Python unit tests in a directory?

After submitting queries to a service, I get a dictionary or a list back and I want to make sure it&#39;s not empty. I using Python 2.7.

I am surprised of not having any `assertEmpty` method for the `unittest.TestCase` class instance.

The existing alternatives just don&#39;t look right: 

    self.assertTrue(bool(d))
    self.assertNotEqual(d,{})
    self.assertGreater(len(d),0)


Is this kind of a missing method  in the Python unittest framework? If yes, what would be the most *pythonic* way to assert that an iterable is not empty?

How to assert that an iterable is not empty on Unittest?

Function `foo` prints to console. I want to test the console print. How can I achieve this in python?

Need to test this function, has NO return statement : 

    def foo(inStr):
       print &quot;hi&quot;+inStr

My test : 
    
    def test_foo():
        cmdProcess = subprocess.Popen(foo(&quot;test&quot;), stdout=subprocess.PIPE)
        cmdOut = cmdProcess.communicate()[0]
        self.assertEquals(&quot;hitest&quot;, cmdOut)




Python: Write unittest for console print

I&#39;m having some trouble dealing with the nested tuple which `Mock.call_args_list` returns.

    def test_foo(self):
        def foo(fn):
            fn(&#39;PASS and some other stuff&#39;)

        f = Mock()
        foo(f)
        foo(f)
        foo(f)

        for call in f.call_args_list:
            for args in call:
                for arg in args:
                    self.assertTrue(arg.startswith(&#39;PASS&#39;))

I would like to know if there is a better way to unpack that call_args_list on the mock object in order to make my assertion. This loop works, but it feels like there must be a more straight forward way.

Python mock call_args_list unpacking tuples for assertion on arguments

In our team, we define most test cases like this:

One &quot;framework&quot; class `ourtcfw.py`:

    import unittest

    class OurTcFw(unittest.TestCase):
        def setUp:
            # Something

        # Other stuff that we want to use everywhere

And a lot of test cases like testMyCase.py:

    import localweather

    class MyCase(OurTcFw):

        def testItIsSunny(self):
            self.assertTrue(localweather.sunny)

        def testItIsHot(self):
            self.assertTrue(localweather.temperature &gt; 20)

    if __name__ == &quot;__main__&quot;:
        unittest.main()

When I&#39;m writing new test code and want to run it often, and save time, I do put &quot;__&quot; in front of all other tests. But it&#39;s cumbersome, distracts me from the code I&#39;m writing, and the commit noise this creates is plain annoying.

So, for example, when making changes to `testItIsHot()`, I want to be able to do this:

&lt;!-- language: none --&gt;

    $ python testMyCase.py testItIsHot

and have `unittest` run *only* `testItIsHot()`

How can I achieve that?

I tried to rewrite the `if __name__ == &quot;__main__&quot;:` part, but since I&#39;m new to Python, I&#39;m feeling lost and keep bashing into everything else than the methods.





Running a single test from unittest.TestCase via the command line

I&#39;m modifying some code to be compatible between `Python 2` and `Python 3`, but have observed a warning in unit test output.

    /Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/unittest/case.py:601:
        ResourceWarning: unclosed socket.socket fd=4,
        family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=6,
        laddr=(&#39;1.1.2.3&#39;, 65087), raddr=(&#39;5.8.13.21&#39;, 8080)

A little research determined this was also happening from popular libraries like [requests][1] and [boto3][2].

I could ignore the warning or [filter it][3] completely.  If was my service, I could set the `connection: close` header in my response ([link][3]).

Here&#39;s an example that exhibits the warning in `Python 3.6.1`:

**app.py**

    import requests
    
    class Service(object):
        def __init__(self):
            self.session = requests.Session()
    
        def get_info(self):
            uri = &#39;http://api.stackexchange.com/2.2/info?site=stackoverflow&#39;
            response = self.session.get(uri)
            if response.status_code == 200:
                return response.json()
            else:
                response.raise_for_status()

        def __del__(self):
            self.session.close()
    
    if __name__ == &#39;__main__&#39;:
        service = Service()
        print(service.get_info())

**test.py**

    import unittest
    
    class TestService(unittest.TestCase):
        def test_growing(self):
            import app
            service = app.Service()
            res = service.get_info()
            self.assertTrue(res[&#39;items&#39;][0][&#39;new_active_users&#39;] &gt; 1)
    
    
    if __name__ == &#39;__main__&#39;:
        unittest.main()


Is there a better / correct way to manage the session so that it gets explicitly closed and not rely on `__del__()` to result in this sort of warning.

Thanks for any help.

  [1]: https://github.com/requests/requests/issues/3912
  [2]: https://github.com/boto/boto3/issues/454
  [3]: https://stackoverflow.com/questions/14938716/socket-resourcewarning-using-urllib-in-python-3

ResourceWarning unclosed socket in Python 3 Unit Test

**The Problem**  
Using `mock.patch` with `autospec=True` to patch a class is not preserving attributes of instances of that class.

**The Details**  
I am trying to test a class `Bar` that instantiates an instance of class `Foo` as a `Bar` object attribute called `foo`. The `Bar` method under test is called `bar`; it calls method `foo` of the `Foo` instance belonging to `Bar`. In testing this, I am mocking `Foo`, as I only want to test that `Bar` is accessing the correct `Foo` member:

    import unittest
    from mock import patch
    
    class Foo(object):
        def __init__(self):
            self.foo = &#39;foo&#39;
    
    class Bar(object):
        def __init__(self):
            self.foo = Foo()
    
        def bar(self):
            return self.foo.foo
    
    class TestBar(unittest.TestCase):
        @patch(&#39;foo.Foo&#39;, autospec=True)
        def test_patched(self, mock_Foo):
            Bar().bar()
    
        def test_unpatched(self):
            assert Bar().bar() == &#39;foo&#39;

The classes and methods work just fine (`test_unpatched` passes), but when I try to Foo in a test case (tested using both nosetests and pytest) using ```autospec=True```, I encounter &quot;AttributeError: Mock object has no attribute &#39;foo&#39;&quot;

    19:39 $ nosetests -sv foo.py
    test_patched (foo.TestBar) ... ERROR
    test_unpatched (foo.TestBar) ... ok
    
    ======================================================================
    ERROR: test_patched (foo.TestBar)
    ----------------------------------------------------------------------
    Traceback (most recent call last):
      File &quot;/usr/local/lib/python2.7/dist-packages/mock.py&quot;, line 1201, in patched
        return func(*args, **keywargs)
      File &quot;/home/vagrant/dev/constellation/test/foo.py&quot;, line 19, in test_patched
        Bar().bar()
      File &quot;/home/vagrant/dev/constellation/test/foo.py&quot;, line 14, in bar
        return self.foo.foo
      File &quot;/usr/local/lib/python2.7/dist-packages/mock.py&quot;, line 658, in __getattr__
        raise AttributeError(&quot;Mock object has no attribute %r&quot; % name)
    AttributeError: Mock object has no attribute &#39;foo&#39;

Indeed, when I print out `mock_Foo.return_value.__dict__`, I can see that `foo` is not in the list of children or methods:

    {&#39;_mock_call_args&#39;: None,
     &#39;_mock_call_args_list&#39;: [],
     &#39;_mock_call_count&#39;: 0,
     &#39;_mock_called&#39;: False,
     &#39;_mock_children&#39;: {},
     &#39;_mock_delegate&#39;: None,
     &#39;_mock_methods&#39;: [&#39;__class__&#39;,
                       &#39;__delattr__&#39;,
                       &#39;__dict__&#39;,
                       &#39;__doc__&#39;,
                       &#39;__format__&#39;,
                       &#39;__getattribute__&#39;,
                       &#39;__hash__&#39;,
                       &#39;__init__&#39;,
                       &#39;__module__&#39;,
                       &#39;__new__&#39;,
                       &#39;__reduce__&#39;,
                       &#39;__reduce_ex__&#39;,
                       &#39;__repr__&#39;,
                       &#39;__setattr__&#39;,
                       &#39;__sizeof__&#39;,
                       &#39;__str__&#39;,
                       &#39;__subclasshook__&#39;,
                       &#39;__weakref__&#39;],
     &#39;_mock_mock_calls&#39;: [],
     &#39;_mock_name&#39;: &#39;()&#39;,
     &#39;_mock_new_name&#39;: &#39;()&#39;,
     &#39;_mock_new_parent&#39;: &lt;MagicMock name=&#39;Foo&#39; spec=&#39;Foo&#39; id=&#39;38485392&#39;&gt;,
     &#39;_mock_parent&#39;: &lt;MagicMock name=&#39;Foo&#39; spec=&#39;Foo&#39; id=&#39;38485392&#39;&gt;,
     &#39;_mock_wraps&#39;: None,
     &#39;_spec_class&#39;: &lt;class &#39;foo.Foo&#39;&gt;,
     &#39;_spec_set&#39;: None,
     &#39;method_calls&#39;: []}

My understanding of autospec is that, if True, the patch specs should apply recursively. Since foo is indeed an attribute of Foo instances, should it not be patched? If not, how do I get the Foo mock to preserve the attributes of Foo instances?

**NOTE:**  
This is a trivial example that shows the basic problem. In reality, I am mocking a third party module.Class -- `consul.Consul` -- whose client I instantiate in a Consul wrapper class that I have. As I don&#39;t maintain the consul module, I can&#39;t modify the source to suit my tests (I wouldn&#39;t really want to do that anyway). For what it&#39;s worth, `consul.Consul()` returns a consul client, which has an attribute `kv` -- an instance of `consul.Consul.KV`. `kv` has a method `get`, which I am wrapping in an instance method `get_key` in my Consul class. After patching `consul.Consul`, the call to get fails because of AttributeError: Mock object has no attribute kv.

**Resources Already Checked:**  

http://mock.readthedocs.org/en/latest/helpers.html#autospeccing
http://mock.readthedocs.org/en/latest/patch.html

All Python Unittest Solutions on Gang of Coders

Total of 21 Python Unittest Solutions