Python unit test mock. ValueError: The truth value of a DataFrame is ambiguous

Question

I am writing a unit test case for one of my python 2.7 methods.

In my test method, there is a method call that takes a dictionary with string key and panadas dataframe as the value for that key.

I want to write an interaction test for this method to check if it calls the method internally with correct dictionary

def MethodUnderTest(self):
    #some code here
    externalMethod(dictionary_of_string_dataframe)
    #some code here

In the unit test, I do write my assert to test this interaction like this

mock_externalClass.externalMethod.assert_called_once_with(dictionary_of_string_dataframe)

I create dictionary_of_string_dataframe exactly the same way it is created in the actual method. In fact, I copied the helper method that does that in the test code just to make sure that both the dictionaries are the same. I even print both the dictionaries while debugging the test method on python console and both look exactly the same.

And I patch the external class using @patch decorator and all that works fine.

The problem is that in the above mentioned assert statement, i get the following error:

 mock_externalClass.externalMethod.assert_called_once_with(dictionary_of_string_dataframe)
  File "C:\Python27\lib\site-packages\mock\mock.py", line 948, in assert_called_once_with
    return self.assert_called_with(*args, **kwargs)
  File "C:\Python27\lib\site-packages\mock\mock.py", line 935, in assert_called_with
    if expected != actual:
  File "C:\Python27\lib\site-packages\mock\mock.py", line 2200, in __ne__
    return not self.__eq__(other)
  File "C:\Python27\lib\site-packages\mock\mock.py", line 2196, in __eq__
    return (other_args, other_kwargs) == (self_args, self_kwargs)
  File "C:\Python27\lib\site-packages\pandas\core\generic.py", line 953, in __nonzero__
    .format(self.__class__.__name__))
ValueError: The truth value of a DataFrame is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().

I did search on the valueError but not much of help. Can someone tell me what's going on here ?

I did check the following question but that didn't help

ValueError: The truth value of a DataFrame is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all()

So just to clarify: You have two dictionaries that map strings to pandas dataframes, and you want to check if they are equal. You are writing the unit test yourself, and even with two dictionaries that are created with the same functions and parameters, you are getting the above error. — victor, Jun 19 '17 at 22:13
when i runt the test case, it hits an external method inside the method under test with a dict of string:dataframe. In the test case itself, i test this interaction using the statement given in my question and i create the dict value in the test method for mock_externalClass.externalMethod.assert_called_once_with using the same helper method which is used in the method under test. However, i get an error. — Hary, Jun 19 '17 at 22:20
IMHO you're taking the wrong approach. You're basically trying to force your code to pass the test instead of making the test enforce the desired outcomes. If the external method's signature is changed your test will not detect the code breaking change but when you fix the code only then will your test fail. I suggest that you decouple the code that derives the input and calls the external method into it's own method and test that method in isolation, separate your concerns. — Dan, Jun 20 '17 at 00:02

sfogle · Answer 1 · 2019-07-10T15:22:16.260

I also ran into this issue while trying to test that a function I wrote is called with a certain preprocessed dataframe, and I solved it using mock's call_args attribute along with pandas's testing.assert_frame_equal.

In my case I wanted to assert the value of the dataframe passed as the second argument to my function below called score_function that is called by the higher-level function run_scoring. So first I retrieved the *args part of the method call to the mock using [0] and then I got my second positional argument (which is the one I wanted to assert the value of) using [1].

Then I could assert the value of this dataframe using pd.testing.assert_frame_equal.

from unittest.mock import Mock
import pandas as pd

import my_code

...

score_function_mocked = Mock()
my_code.score_function = score_function_mocked
my_code.run_scoring()

pd.testing.assert_frame_equal(
    # [0] = *args, [0][1] = second positional arg to my function
    score_function_mocked.call_args[0][1],
    pd.DataFrame({
        'new_york': [1, 0],
        'chicago': [0, 1],
        'austin': [0, 0]
    })

)

ericman · Answer 2 · 2021-09-07T07:58:55.150

5

I solved it by having a SAME_DF class, similar to mock's ANY class

class SAME_DF:
    def __init__(self, df: pd.DataFrame):
        self.df = df

    def __eq__(self, other):
        return isinstance(other, pd.DataFrame) and other.equals(self.df)
 
def test_called_with_df():
    ....
    mock.method.assert_called_once_with(SAME_DF(pd.DataFrame({
        'name': ['Eric', 'Yoav'],
        'age': [28, 34]
    })))

edited Sep 07 '21 at 07:58

answered Sep 01 '21 at 08:23

ericman

153
2
9

This worked well for solving my problem, but adding a repr function will help when the test fails. `def __repr__(self):` `return repr(self.df)` – Jeff Sep 15 '21 at 19:43
Neat solution! Tx. – Pete C Sep 27 '21 at 13:09

victor · Answer 3 · 2017-07-25T21:00:38.927

This happens because unittest.mock compares between input values using == or !=. However, pandas dataframes cannot be similarly compared, and instead, you must use the .equals method of DataFrames.

https://github.com/testing-cabal/mock/blob/master/mock/mock.py

One possible fix is to write your own unit test that iterates through the dictionary and compares between dataframes using the .equals method.

Another is to override the __equals__ method of pandas dataframes so when mock compares between them it will use the correct method.

score 4 · Answer 4 · answered Oct 22 '19 at 18:33

Here is how I would solve it based on the original question. This borrows some of the thinking in sfogle's answer, but it allows you to test called functions generally whether the args are DataFrames or not.

import unittest
from unittest.mock import patch
import pandas as pd

def external_method(df):
    return df

def function_to_test(df):
    external_method(df)
    return df

class MyTest(unittest.TestCase):

    def test_the_function_to_test(self):
        my_test_df = pd.DataFrame({"a": [1, 2, 3, 4]})    
        with patch(__name__ + ".external_method") as mock_external_method:        
            function_to_test(my_test_df)
            mock_external_method.assert_called_once()
            args, kwargs = mock_external_method.call_args
            self.assertTrue(args[0].equals(my_test_df))

Python unit test mock. ValueError: The truth value of a DataFrame is ambiguous

4 Answers4