49

I am trying to get mock.patch to work on the following piece of sample code:

from mock import patch
from collections import defaultdict

with patch('collections.defaultdict'):
  d = defaultdict()
  print 'd:', d

This outputs the following:

d: defaultdict(None, {})

Which means that defaultdict was not patched.

If I replace the from/import statement with a straight import statement it works:

from mock import patch
import collections

with patch('collections.defaultdict'):
 d = collections.defaultdict()
 print 'd:', d

Output is:

d: <MagicMock name='defaultdict()' id='139953944084176'>

Is there any way to patch a call using from/import?

Thank you

oneself
  • 38,641
  • 34
  • 96
  • 120

3 Answers3

69

If you're patching something in the same module, you can use __main__:

from mock import patch
from collections import defaultdict

with patch('__main__.defaultdict'):
    d = defaultdict()
    print 'd:', d

If you're mocking something for an imported module, however, you'll want to use that module's name so the correct reference (or name) is patched:

# foo.py

from collections import defaultdict

def bar():
    return defaultdict()


# foo_test.py    

from mock import patch
from foo import bar

with patch('foo.defaultdict'):
    print bar()

The point here is that patch wants the full path to the thing it is patching. This just looks a little weird when patching something in the current module, since folks don't often use __main__ (or have to refer to the current module, for that matter).

Adam Wagner
  • 15,469
  • 7
  • 52
  • 66
16

patch works by patching names. You can't achieve anything by patching the name collections.defaultdict if you are using the name defaultdict (in the local namespace) to access the object. See the documentation at https://docs.python.org/3/library/unittest.mock.html#where-to-patch

guettli
  • 25,042
  • 81
  • 346
  • 663
BrenBarn
  • 242,874
  • 37
  • 412
  • 384
  • 13
    Doesn't this mean that your unit tests will silently start behaving very, very differently if you change the implementation detail of whether you use `from X import Y` or `import X.Y`? – detly Dec 22 '13 at 13:34
  • 1
    @detly: I believe that is true, although I'm not super familiar with mock so I can't say from experience. – BrenBarn Dec 22 '13 at 17:50
  • Please see below. I believe you are perhaps correct on the specific case and mistaken on the more general. I have an example below based on something which works for me. – Peter Kahn Feb 12 '19 at 17:25
3

The names can be very confusing in this case. We always want to mock a class definition in a namespace. The namespace is the module in which the import takes place. The class definition is the name used in that namespace.

Let's take a concrete example:

  • myproj.utilities module contains Actor class
  • myproj.application imports this as from myproj.utilities import Actor
  • my test should execute my.proj.application and mock our Actor

myproj.utilities.py

class Actor:
    def __init__(name):
        self.name = name

myproj.application.py

from myproj.utilities import Actor

class App:
    def __init__(name):
        self.actor = Actor(name)

test code

from mock import patch
from myproj.application import App

test:
  # format: patch('<namespace>.<Class>')
  # the namespace in which we with to mock
  # the class definition we wish to mock
  with patch('myproj.application.Actor'):
      app = App('Someone')
      print( type(app.actor) ) # expect a MagicMock

I tried several other approaches and this one works well for me. I have not tests the code above but instead generalized it from my own specific case. So, it might be a little off.

Peter Kahn
  • 12,364
  • 20
  • 77
  • 135