Proper way to mock classes and assert on calls to methods

Question

I am trying to write unit tests for Bar that makes calls to Foo's method read(). I have added the patch command in setUp() because other tests will use this patch as well.

Question

How can I check that the read() function was called with the arguments that I am expecting?

Code

foo.py

class Foo(object):
    def __init__(self):
        self.table = {'foo': 1}

    def read(self, name):
        return self.table[name]

bar.py

import foo

class Bar(object):
    def act(self):
        a = foo.Foo()
        return a.read('foo')

test_bar.py

import bar
import unittest
from mock import patch

class TestBar(unittest.TestCase):
    def setUp(self):
        self.foo_mock = patch('bar.foo.Foo', autospec=True).start()
        self.addCleanup(patch.stopall)

    def test_can_call_foo_with_correct_arguments(self):
        a = bar.Bar()
        a.act()
        self.foo_mock.read.assert_called_once_with('foo')

Output

python -m unittest discover

F
======================================================================
FAIL: test_can_call_foo_with_correct_arguments (test_bar.TestBar)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/test_dir/test_bar.py", line 12, in test_can_call_foo_with_correct_arguments
    self.foo_mock.read.assert_called_once_with('foo')
  File "/usr/local/lib/python2.7/dist-packages/mock.py", line 845, in assert_called_once_with
    raise AssertionError(msg)
AssertionError: Expected to be called once. Called 0 times.

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

FAILED (failures=1)

Answer 1

read is a method on instances of Foo. You want to check for the mock return_value to access the instance. After all, you create the instance by calling foo.Foo():

foo_instance = self.foo_mock.return_value
foo_instance.read.assert_called_once_with('foo')

Note that you are patching foo.Foo; using bar.foo.Foo is the same object, but a round-about way of specifying it.