Enhancements and a bug fix for our test helpers

[SebastiaanZ]

I have made several changes to our test helpers defined in tests/helpers.py. These changes will make it easier to work with the mock objects as well as fixing a bug. All changes are backwards compatible with all the current tests we have and should be compatible with the tests that are currently being written as well.

Better way of controlling child mock types

We previously used an override of the __new__ method to prevent our custom mock types from instantiating their children with their own type instead of a general mock type like MagicMock or Mock.

As it turns out, the Python documentation suggests another way of doing this that does not involve overriding __new__. This commit implements this new method to make sure we're using the idiomatic way of handling this.

The suggested method is overriding the _get_child_mock method in the subclass. I've added this override to a mixin that we can apply to all of the custom mock types we define. If you want to use this mixin, please make sure that it comes before the general mock type in the MRO.

AsyncMock's call now returns the right mock type

Since mocks normally instantiate children with their own type, our AsyncMock type returned a new AsyncMock after it had been awaited. By using the mixin described in the previous section, it now returns a regular MagicMock.

Automatically create AsyncMock attributes using inspect

Normally, attributes accessed on a mock are automatically created with an instance of either Mock or MagicMock. However, since those only support synchronous calls, this is not desirable for coroutine function methods. That's why our __init__ methods previously had a long list of all the coroutines defined for a class to properly mock it with an AsyncMock. However, hard-coding such a list is prone to human error and not resilient to changes introduced by version upgrades.

Instead, I have now created a helper method in our CustomMockMixin (formerly GetChildMockMixin) that automatically inspects the spec instance we've passed for coroutine functions using the inspect module. It then automatically sets the according attributes with instances of the AsyncMock class.

There is one caveat: discord.py very rarely defines regular methods that return a coroutine object. Since the returned coroutine should still be awaited, these regular methods should also be mocked with an AsyncMock. However, since they are regular methods, inspect does not detect them and they have to be added manually. (The only case of this I've found so far is Client.wait_for.)

Better handling of passed keyword arguments

Normally, a Mock type respects the keyword arguments passed and automatically sets them as attributes of the mock instance. However, some of custom Mock types set custom attributes, making this impossible:

class MockMessage(unittest.mock.MagicMock):
    def __init__(self, **kwargs):
        super().__init__(spec=message_instance, **kwargs)
        self.author = MockMember()

guido = MockMember(name="Guido")
mocked_message = MockMessage(author=guido)

In this snippet, we attempt to set the author attribute to a mock instance with name="Guido", but since __init__ sets this attribute after the super().__init__, this will be lost. To solve this, I've made sure that we only instantiate a new mock if the attribute name was not present in kwargs by leveraging the default value of .get:

class MockMessage(unittest.mock.MagicMock):
    def __init__(self, **kwargs):
        super().__init__(spec=message_instance, **kwargs)
        self.author = kwargs.get('author', MockMember())

Added MockEmoji, MockPartialEmoji, MockReaction

I have added three new custom mock types, MockEmoij, MockPartialEmoji, and MockReaction after a request from @lemonsaurus.

[lemonsaurus]

this is smart as hell. nice work.