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
142
143
144
|
from contextlib import contextmanager
from functools import wraps
from types import TracebackType
from typing import Callable, TypeAlias, Iterator, Self, ParamSpec, TypeVar, Generic
from testfixtures import diff, compare
from .comparison import split_repr
param_docs = """
:param exception: This can be one of the following:
* `None`, indicating that an exception must be
raised, but the type is unimportant.
* An exception class, indicating that the type
of the exception is important but not the
parameters it is created with.
* An exception instance, indicating that an
exception exactly matching the one supplied
should be raised.
:param unless: Can be passed a boolean that, when ``True`` indicates that
no exception is expected. This is useful when checking
that exceptions are only raised on certain versions of
Python.
"""
class NoException(AssertionError):
"""
A marker class indicating no exception has been raised.
.. currentmodule:: testfixtures
:attr:`ShouldRaise.raised` is set to an instance of this class unless an
exception has otherwise been seen.
"""
def __init__(self) -> None:
super().__init__('No exception raised!')
E = TypeVar("E", bound=BaseException)
class ShouldRaise(Generic[E]):
__doc__ = """
This context manager is used to assert that an exception is raised
within the context it is managing.
""" + param_docs
#: The exception captured by the context manager.
#: Can be used to inspect specific attributes of the exception.
raised: E = NoException() # type: ignore[assignment]
def __init__(self, exception: E | type[E] | None = None, unless: bool | None = False):
self.exception = exception
self.expected = not unless
def __enter__(self) -> Self:
return self
def __exit__(
self,
exc_type: type[BaseException] | None,
actual: BaseException | None,
traceback: TracebackType | None,
) -> bool:
__tracebackhide__ = True
self.raised = actual or NoException() # type: ignore[assignment]
if self.expected:
if self.exception:
actual_: type[BaseException] | BaseException | None = actual
if actual is not None:
if isinstance(self.exception, type):
actual_ = type(actual)
if self.exception is not actual_:
return False
else:
if type(self.exception) is not type(actual):
return False
compare(self.exception,
actual_,
x_label='expected',
y_label='raised')
elif not actual:
raise NoException()
elif actual:
return False
return True
P = ParamSpec("P")
T = TypeVar("T")
class should_raise(Generic[E]):
__doc__ = """
A decorator to assert that the decorated function will raised
an exception. An exception class or exception instance may be
passed to check more specifically exactly what exception will be
raised.
""" + param_docs
def __init__(self, exception: E | type[E] | None = None, unless: bool | None = None):
self.exception = exception
self.unless = unless
def __call__(self, target: Callable[P, T]) -> Callable[P, None]:
@wraps(target)
def _should_raise_wrapper(*args: P.args, **kw: P.kwargs) -> None:
with ShouldRaise(self.exception, self.unless):
target(*args, **kw)
return _should_raise_wrapper
@contextmanager
def ShouldAssert(expected_text: str, show_whitespace: bool = False) -> Iterator[None]:
"""
A context manager to check that an :class:`AssertionError`
is raised and its text is as expected.
:param show_whitespace: If `True`, then whitespace characters in
multi-line strings will be replaced with their
representations.
"""
try:
yield
except AssertionError as e:
actual_text = str(e)
if expected_text != actual_text:
if show_whitespace:
expected_text = split_repr(expected_text)
actual_text = split_repr(actual_text)
raise AssertionError(diff(expected_text, actual_text,
x_label='expected', y_label='actual'))
else:
raise AssertionError('Expected AssertionError(%r), None raised!' %
expected_text)
|
