How to test if another class method is called within a method in python?

Question

I have the following structure:

ClassB():
 def foo():
Class A():
 def __init__(self, B):
 #some initialisations
 def method1():
 #complex logic
 B.foo()

I am trying to write a unit test method1 and would like to test if foo is called once or not. How I can achieve this? What should I mock?

Answer 1

Edited

Based on the further information provided by OP, a rework on the answer was done.

Code

The code below has been tested locally with Python3.8.3 on CentOS 8. Run python3 -m unittest to see the test result.

Functional code(sub.py):

class B(): 
 def foo(self): 
 pass 
 
 
class A(): 
 def __init__(self, B): 
 self.b = B 
 
 def method1(self): 
 self.b.foo()

Test code(test.py):

from unittest import TestCase 
from unittest.mock import patch 
 
from sub import A, B 
 
 
class Test(TestCase): 
 def test_A(self): 
 with patch('sub.B.foo') as mock_foo: 
 a = A(B) 
 a.method1() 
 mock_foo.assert_called_once()

Basically the test code tries to mock the B.foo method and checks if the method has been called EXACTLY ONCE when A.method1 is invoked.

Test Explanation

1. a = A(B) line does not call B.foo
2. a.method1() line calls B.foo

In total, B.foo is called exactly once so mock_foo.assert_called_once() will pass. If any of the arguments above turns out to be invalid, the assertion will fail. In case you just need to check that B.foo has been called at least once, use mock_foo.assert_called() instead.

For details of the mock system, I suggest to read the official docs.

• MrBean Bremen: Are you sure it's called twice inside the patch block? assert_called_once indeed checks for exactly one call.
• Panduranga Rao Sadhu: @xiao, I cant just call A(), I should be passing B to it as A(B), should I be passing a mock of B?
• MrBean Bremen: Ok. As to your question - you can construct an instance of B and pass it as parameter to A(). If that is not possible, you can indeed mock ClassB instead of ClassB.foo, and use classb_mock.return_value.foo.assert_called... instead.

Answer 2

You should create a Mock for B, pass it to the constructor of A and check if the function was called once.

You can write the Mock by yourself. E.g.:

class B_Mock():
 def __init__(self):
 self.foo_calls = 0
 def foo(self):
 self.foo_calls += 1

And than check the attr foo_calls of your B_Mock instance with assert