How can I mock patch a class used in an isinstance test?

Question

I want to test the function `is_myclass`. Please help me understand how to write a successful test. ``` def is_myclass(obj): """This absurd stub is a simplified version of the production code.""" isinstance(obj, MyClass) MyClass() ``` Docs The Python Docs for unittest.mock illustrate three ways of addressing the `isinstance` problem: - Set the `spec` parameter to the real class. - Assign the real class to the `__class__` attribute. - Use `spec` in the patch of the real class. `__class__` Normally the `__class__` attribute of an object will return its type. For a mock object with a spec, `__class__` returns the spec class instead. This allows mock objects to pass isinstance() tests for the object they are replacing / masquerading as: ``` >>> mock = Mock(spec=3) >>> isinstance(mock, int) True ``` `__class__` is assignable to, this allows a mock to pass an `isinstance()` check without forcing you to use a spec: ``` >>> mock = Mock() >>> mock.__class__ = dict >>> isinstance(mock, dict) Tr…

Accepted Answer

You can't mock the second argument of `isinstance()`, no. The documentation you found concerns making a mock as the first argument pass the test. If you want to produce something that is acceptable as the second argument to `isinstance()`, you actually have to have a type, not an instance (and mocks are always instances).

You could use a subclass instead of `MyClass` instead, that'll definitely pass, and giving it a `__new__` method lets you alter what is returned when you try to call it to create an instance:

```
class MockedSubClass(MyClass):
    def __new__(cls, *args, **kwargs):
        return mock.Mock(spec=cls)  # produce a mocked instance when called
```

and patch that in:

```
mock.patch('temp2.MyClass', new=MockedSubClass)
```

and use an instance of that class as the mock:

```
instance = mock.Mock(spec=MockedSubClass)
```

Or, and this is much simpler, just use `Mock` as the class, and have `obj` be an `Mock` instance:

```
with mock.patch('temp2.MyClass', new=mock.Mock) as mocked_class:
    is_myclass(mocked_class())
```

Either way, your test then passes:

```
>>> with mock.patch('temp2.MyClass', new=MockedSubClass) as mocked_class:
...     instance = mock.Mock(spec=MockedSubClass)
...     assert isinstance(instance, mocked_class)
...     is_myclass(instance)
...
>>> # no exceptions raised!
...
>>> with mock.patch('temp2.MyClass', new=mock.Mock) as mocked_class:
...     is_myclass(mocked_class())
...
>>> # no exceptions raised!
...
```

For your specific tests, here is why they fail:

- You never mocked `MyClass`, it still references the original class. The first line of `is_myclass()` succeeds, but the second line uses the original `MyClass` and it is booby trapped.

- `MyClass` is replaced with a `mock.Mock` instance, not an actual type, so `isinstance()` raises a `TypeError: isinstance() arg 2 must be a type or tuple of types` exception.

- Fails exactly the same way 1 failed, `MyClass` is left in-tact and is booby trapped.

- Fails the same way as 2 does. `__class__` is an attribute only useful on instances. A class object doesn't use the `__class__` attribute, you still have an instance instead of a class and `isinstance()` raises a type error.

- is essentially exactly the same as 4, only you started the patcher manually instead of having the context manager take care of it, and you used `isinstance(obj, Original)` to check the instance, so you never got the type error there. The type error is instead triggered in `is_myclass()`.

How can I mock patch a class used in an isinstance test?

Solution

Problem

Related problems