Skip to content

mode.utils.mocks

Mocking and testing utilities.

IN

Class used to check for multiple alternatives.

assert foo.value IN(a, b)
Source code in mode/utils/mocks.py 
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
class IN:
    """Class used to check for multiple alternatives.

    ```python
    assert foo.value IN(a, b)
    ```
    """

    def __init__(self, *alternatives: Any) -> None:
        self.alternatives = alternatives

    def __eq__(self, other: Any) -> bool:
        return other in self.alternatives

    def __ne__(self, other: Any) -> bool:
        return other not in self.alternatives

    def __repr__(self) -> str:
        sep = " | "
        return f"<IN: {sep.join(map(str, self.alternatives))}>"

mask_module(*modnames)

Ban some modules from being importable inside the context.

For example:

>>> with mask_module('sys'):
...     try:
...         import sys
...     except ImportError:
...         print('sys not found')
sys not found

>>> import sys  # noqa
>>> sys.version
(2, 5, 2, 'final', 0)

Taken from http://bitbucket.org/runeh/snippets/src/tip/missing_modules.py

Source code in mode/utils/mocks.py 
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
@contextmanager
def mask_module(*modnames: str) -> Iterator:
    """Ban some modules from being importable inside the context.

    For example:

    ```sh
    >>> with mask_module('sys'):
    ...     try:
    ...         import sys
    ...     except ImportError:
    ...         print('sys not found')
    sys not found

    >>> import sys  # noqa
    >>> sys.version
    (2, 5, 2, 'final', 0)
    ```

    Taken from
    http://bitbucket.org/runeh/snippets/src/tip/missing_modules.py

    """
    realimport = builtins.__import__

    def myimp(name: str, *args: Any, **kwargs: Any) -> ModuleType:
        if name in modnames:
            raise ImportError(f"No module named {name}")
        else:
            return cast(ModuleType, realimport(name, *args, **kwargs))

    builtins.__import__ = myimp
    try:
        yield
    finally:
        builtins.__import__ = realimport

patch_module(*names, new_callable=MagicMock)

Mock one or modules such that every attribute is a Mock.

Source code in mode/utils/mocks.py 
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
@contextmanager
def patch_module(*names: str, new_callable: Any = MagicMock) -> Iterator:
    """Mock one or modules such that every attribute is a `Mock`."""
    prev = {}

    class MockModule(types.ModuleType):
        def __getattr__(self, attr: str) -> Any:
            setattr(self, attr, new_callable())
            return types.ModuleType.__getattribute__(self, attr)

    mods = []
    for name in names:
        try:
            prev[name] = sys.modules[name]
        except KeyError:
            pass
        mod = sys.modules[name] = MockModule(name)
        mods.append(mod)
    try:
        yield mods
    finally:
        for name in names:
            try:
                sys.modules[name] = prev[name]
            except KeyError:
                try:
                    del sys.modules[name]
                except KeyError:
                    pass