File: test_utils.py

package info (click to toggle)
superqt 0.7.7-1
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid
  • size: 1,320 kB
  • sloc: python: 9,108; makefile: 16; sh: 12
file content (141 lines) | stat: -rw-r--r-- 3,382 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
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
66
67
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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
import os
import sys
from unittest.mock import Mock

import pytest
import qtpy
from qtpy.QtCore import QObject, QTimer, Signal
from qtpy.QtWidgets import QApplication, QErrorMessage, QMessageBox

from superqt.utils import exceptions_as_dialog, signals_blocked
from superqt.utils._util import get_max_args


def test_signal_blocker(qtbot):
    """make sure context manager signal blocker works"""

    class Emitter(QObject):
        sig = Signal()

    obj = Emitter()
    receiver = Mock()
    obj.sig.connect(receiver)

    # make sure signal works
    with qtbot.waitSignal(obj.sig):
        obj.sig.emit()

    receiver.assert_called_once()
    receiver.reset_mock()

    with signals_blocked(obj):
        obj.sig.emit()
        qtbot.wait(10)

    receiver.assert_not_called()


def test_get_max_args_simple():
    def fun1():
        pass

    assert get_max_args(fun1) == 0

    def fun2(a):
        pass

    assert get_max_args(fun2) == 1

    def fun3(a, b=1):
        pass

    assert get_max_args(fun3) == 2

    def fun4(a, *, b=2):
        pass

    assert get_max_args(fun4) == 1

    def fun5(a, *b):
        pass

    assert get_max_args(fun5) is None

    assert get_max_args(print) is None


def test_get_max_args_wrapped():
    from functools import partial, wraps

    def fun1(a, b):
        pass

    assert get_max_args(partial(fun1, 1)) == 1

    def dec(fun):
        @wraps(fun)
        def wrapper(*args, **kwargs):
            return fun(*args, **kwargs)

        return wrapper

    assert get_max_args(dec(fun1)) == 2


def test_get_max_args_methods():
    class A:
        def fun1(self):
            pass

        def fun2(self, a):
            pass

        def __call__(self, a, b=1):
            pass

    assert get_max_args(A().fun1) == 0
    assert get_max_args(A().fun2) == 1
    assert get_max_args(A()) == 2


MAC_CI_PYSIDE6 = bool(
    sys.platform == "darwin" and os.getenv("CI") and qtpy.API_NAME == "PySide6"
)


@pytest.mark.skipif(MAC_CI_PYSIDE6, reason="still hangs on mac ci with pyside6")
def test_exception_context(qtbot, qapp: QApplication) -> None:
    def accept():
        for wdg in qapp.topLevelWidgets():
            if isinstance(wdg, QMessageBox):
                wdg.button(QMessageBox.StandardButton.Ok).click()

    with exceptions_as_dialog():
        QTimer.singleShot(0, accept)
        raise Exception("This will be caught and shown in a QMessageBox")

    with pytest.raises(ZeroDivisionError), exceptions_as_dialog(ValueError):
        1 / 0  # noqa

    with exceptions_as_dialog(msg_template="Error: {exc_value}"):
        QTimer.singleShot(0, accept)
        raise Exception("This message will be used as 'exc_value'")

    err = QErrorMessage()
    with exceptions_as_dialog(use_error_message=err):
        QTimer.singleShot(0, err.accept)
        raise AssertionError("Uncheck the checkbox to ignore this in the future")

    # tb formatting smoke test, and return value checking
    exc = ValueError("Bad Val")
    with exceptions_as_dialog(
        msg_template="{tb}",
        buttons=QMessageBox.StandardButton.Ok | QMessageBox.StandardButton.Cancel,
    ) as ctx:
        qtbot.addWidget(ctx.dialog)
        QTimer.singleShot(100, accept)
        raise exc

    assert isinstance(ctx.dialog, QMessageBox)
    assert ctx.dialog.result() == QMessageBox.StandardButton.Ok
    assert ctx.exception is exc