Can a python constructor be mocked without mocking other properties of the object?

Question

Is it possible to mock a python constructor while continuing to use the production version other fields/functions on the same name? For example, given the production code:

class MyClass:
    class SubClass:
        def __init__(self) -> None:
            print("\nreal sub init called")

        class SubSubClass:
            def __init__(self) -> None:
                print("\nreal sub sub init called")

and the following test code:

class FakeSubClass:
    def __init__(self) -> None:
        print("\nfake init called")


def test():
    MyClass.SubClass()
    MyClass.SubClass.SubSubClass()

    MyClass.SubClass = Mock(side_effect=FakeSubClass)

    MyClass.SubClass()
    MyClass.SubClass.SubSubClass()

we get the following output:

real sub init called

real sub sub init called

fake init called

Note that the last line MyClass.SubClass.SubSubClass() did not create a real SubSubClass because at this point it is an automatically created property of the SubClass mock.

My desired output is the following:

real sub init called

real sub sub init called

fake init called

real sub sub init called

In other words I want to mock ONLY the SubClass, but not SubSubClass. Things I have tried in place of the mocking line above (both of which do not work):

MyClass.SubClass.__init__ = Mock(side_effect=FakeSubClass.__init__)

MyClass.SubClass.__new__ = Mock(side_effect=FakeSubClass.__new__)

Note that I am aware of several ways the code could be refactored to avoid this issue but sadly the code cannot be refactored.

Those are not subclasses, not in the normal meaning of the term in the context of an object-oriented programming language; all you have are classes that are attributes of other classes. You’d normally want to avoid this. Why do you nest the classes here? — Martijn Pieters, Jul 07 '18 at 18:22
Next, when creating a unit test you generally would never mock only the `__init__`. You’d mock *everything that’s not the unit under test*. If the class you think you want to mock the `__init__` method of that unit, mock out things the `__init__` method calls, not the method itself. — Martijn Pieters, Jul 07 '18 at 18:27

score 5 · Accepted Answer · answered Jul 05 '18 at 10:10

You can also fake the class, the thing MyClass.SubClass.SubSubClass() wont work in your case is that MyClass.SubClass is a Mock dont have SubSubClass definition. Simply let FakeSubClass inherit it from MyClass.SubClass will solve the issue.

And you can easily patch MyClass to FakeClass, and you will have the right test object rather than real object.

from unittest.mock import Mock


class MyClass:
    class SubClass:
        def __init__(self) -> None:
            print("\nreal sub init called")

        class SubSubClass:
            def __init__(self) -> None:
                print("\nreal sub sub init called")


class FakeSubClass(MyClass.SubClass, Mock):
    def __init__(self) -> None:
        print("\nfake init called")


class FakeClass:
    class SubClass(FakeSubClass):
        pass


def test():
    MyClass.SubClass()
    MyClass.SubClass.SubSubClass()

    MyClass.SubClass = Mock(side_effect=FakeSubClass)

    FakeClass.SubClass()
    FakeClass.SubClass.SubSubClass()

score 1 · Answer 2 · answered Jul 09 '18 at 14:03

I agree that ZhouQuan has a very good answer, as it will work for any method or variable on MyClass.Subclass. That said, here are some variations that may or may not be useful.

If for whatever reason the FakeSubClass can not be direct edited, or you only want to inherit SubSubClass() but nothing else, it can be changed in test() like this.

def test():
    MyClass.SubClass()
    MyClass.SubClass.SubSubClass()

    FakeSubClass.SubSubClass = MyClass.SubClass.SubSubClass()

    MyClass.SubClass = Mock(side_effect=FakeSubClass)

    MyClass.SubClass()
    MyClass.SubClass.SubSubClass()

I think it may be worth noting that Mock does accept a wraps argument, which could be used to get similar behavior, though it is not exactly what you asked for. Here is an example.

from unittest.mock import Mock

class MyClass:
    class SubClass:
        def __init__(self) -> None:
            print("\nreal sub init called")

        class SubSubClass:
            def __init__(self) -> None:
                print("\nreal sub sub init called")


class FakeSubClass:
    def __init__(self) -> None:
        print("\nfake init called")

def test():
    MyClass.SubClass()
    MyClass.SubClass.SubSubClass()

    MyClass.SubClass = Mock(side_effect=FakeSubClass, wraps=MyClass.SubClass)

    MyClass.SubClass()
    MyClass.SubClass.SubSubClass()

This gives a different output.

real sub init called

real sub sub init called

fake init called # A call to MyClass.SubClass() causes both real and fake inits.

real sub init called # Same MyClass.SubClass() call.

real sub sub init called # But now the SubSubClass() does resolve correctly.

Can a python constructor be mocked without mocking other properties of the object?

2 Answers2