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
|
# Tests that ensure compare and Comparison work correctly in strictly type checked environments
from dataclasses import dataclass
from testfixtures import compare, Comparison
from testfixtures.comparison import like, sequence, contains, unordered
@dataclass
class SampleClass:
x: int
y: str
class OtherClass:
pass
@dataclass
class ListCollection:
items: list[SampleClass]
@dataclass
class TupleCollection:
items: tuple[SampleClass, ...]
def test_simple_compare() -> None:
compare(SampleClass(1, '2'), expected=SampleClass(1, '2'))
def test_comparison_bad_typing_in_list() -> None:
expected: list[SampleClass] = [
Comparison(SampleClass, x=1, partial=True) # type: ignore[list-item]
]
compare(expected, actual=[SampleClass(1, '2')])
def test_comparison_via_like_in_list() -> None:
expected: list[SampleClass] = [like(SampleClass, x=1)]
compare(expected, actual=[SampleClass(1, '2')])
def test_comparison_via_like_in_assert() -> None:
expected: SampleClass = like(SampleClass)
assert expected == SampleClass(1, '2')
assert expected == SampleClass(3, '4')
assert expected != SampleClass
assert expected != OtherClass()
class TestSequence:
def test_minimal(self) -> None:
actual = ListCollection([SampleClass(1, '2')])
compare(actual, expected=ListCollection(sequence()([SampleClass(1, '2')])))
def test_maximal(self) -> None:
actual = ListCollection(
[SampleClass(1, 'x'), SampleClass(2, 'x'), SampleClass(3, 'x')]
)
compare(
actual,
expected=ListCollection(
sequence(partial=True, ordered=False, recursive=False)(
[
SampleClass(3, 'x'),
SampleClass(2, 'x'),
],
)
),
)
def test_minimal_type_override(self) -> None:
actual = TupleCollection((SampleClass(1, '2'),))
compare(
actual,
expected=TupleCollection(
sequence(returns=tuple[SampleClass, ...])([SampleClass(1, '2')])
),
)
def test_maximal_type_override(self) -> None:
actual = TupleCollection(
(
SampleClass(1, 'x'),
SampleClass(2, 'x'),
SampleClass(3, 'x'),
)
)
compare(
actual,
expected=TupleCollection(
sequence(
partial=True,
ordered=False,
recursive=False,
returns=tuple[SampleClass, ...],
)(
[
SampleClass(3, 'x'),
SampleClass(2, 'x'),
]
)
),
)
class TestContains:
def test_it(self) -> None:
actual = ListCollection([SampleClass(1, "2"), SampleClass(3, "4")])
compare(actual, expected=ListCollection(contains([SampleClass(1, "2")])))
def test_type_override(self) -> None:
actual = TupleCollection((SampleClass(1, "2"), SampleClass(3, "4")))
compare(
actual,
expected=TupleCollection(
contains([SampleClass(1, "2")], returns=tuple[SampleClass, ...])
),
)
class TestUnordered:
def test_it(self) -> None:
actual = ListCollection([SampleClass(2, "x"), SampleClass(1, "x")])
compare(
actual,
expected=ListCollection(
unordered([SampleClass(1, "x"), SampleClass(2, "x")])
),
)
def test_type_override(self) -> None:
actual = TupleCollection((SampleClass(2, "x"), SampleClass(1, "x")))
compare(
actual,
expected=TupleCollection(
unordered(
[SampleClass(1, "x"), SampleClass(2, "x")],
returns=tuple[SampleClass, ...],
)
),
)
|
