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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
|
import inspect
from unittest.mock import MagicMock
import pytest
from chango.concrete import BackwardCompatibleChanGo, BackwardCompatibleVersionScanner
from chango.error import ChanGoError
class TestBackwardCompatibleChanGo:
@staticmethod
def build_mocks(
*,
chango: tuple[str, list[object]] | None = None,
scanner: tuple[str, list[object]] | None = None,
) -> tuple[MagicMock, list[MagicMock]]:
if not chango and not scanner:
raise ValueError("At least one of 'chango' or 'scanner' must be provided.")
if chango and scanner and len(chango[1]) != len(scanner[1]):
raise ValueError(
"The number of chango instances must match the number of scanner instances."
)
if (effective_length := len(chango[1] if chango else scanner[1])) < 2: # noqa PLR2004
raise ValueError("At least two instances must be provided.")
def setup_mock(mock, method_name, result_):
method = getattr(mock, method_name)
if isinstance(result_, Exception) or (
inspect.isclass(result_) and issubclass(result_, Exception)
):
method.side_effect = result_
else:
method.return_value = result_
instances = [MagicMock() for _ in range(effective_length)]
if chango:
for instance, result in zip(instances, chango[1], strict=False):
setup_mock(instance, chango[0], result)
if scanner:
for instance, result in zip(instances, scanner[1], strict=False):
setup_mock(instance.scanner, scanner[0], result)
return instances[0], instances[1:]
def test_scanner(self):
chango = BackwardCompatibleChanGo(MagicMock(), [MagicMock(), MagicMock()])
assert isinstance(chango.scanner, BackwardCompatibleVersionScanner)
def test_build_template_change_note(self):
expected_template = object()
main_instance, legacy_instances = self.build_mocks(
chango=("build_template_change_note", [expected_template, RuntimeError, RuntimeError]),
scanner=None,
)
chango = BackwardCompatibleChanGo(main_instance, legacy_instances)
assert chango.build_template_change_note("slug") is expected_template
main_instance.build_template_change_note.assert_called_once_with("slug", None)
for legacy_instance in legacy_instances:
assert not legacy_instance.build_template_change_note.called
assert chango.build_template_change_note("slug", "uid") is expected_template
main_instance.build_template_change_note.assert_called_with("slug", "uid")
for legacy_instance in legacy_instances:
assert not legacy_instance.build_template_change_note.called
@pytest.mark.parametrize(
("is_available", "version_note", "expected"),
[
(
[True, False, False],
["main-version-note", ChanGoError, ChanGoError],
"main-version-note",
),
(
[False, True, False],
[ChanGoError, "legacy-version-note-1", ChanGoError],
"legacy-version-note-1",
),
(
[False, False, True],
[ChanGoError, ChanGoError, "legacy-version-note-2"],
"legacy-version-note-2",
),
],
)
@pytest.mark.parametrize("version", ["version", None])
def test_build_version_note(self, is_available, version_note, version, expected):
main_instance, legacy_instances = self.build_mocks(
chango=("build_version_note", version_note), scanner=("is_available", is_available)
)
chango = BackwardCompatibleChanGo(main_instance, legacy_instances)
assert chango.build_version_note(version) == expected
has_returned = False
for instance, was_available in zip(
[main_instance, *legacy_instances], is_available, strict=False
):
if not has_returned:
instance.scanner.is_available.assert_called_once_with(version)
if was_available:
instance.build_version_note.assert_called_once_with(version)
else:
assert not instance.build_version_note.called
has_returned = has_returned or was_available
else:
assert not instance.scanner.is_available.called
assert not instance.build_version_note.called
def test_build_version_note_not_found(self):
main_instance, legacy_instances = self.build_mocks(
chango=("build_version_note", [ChanGoError, ChanGoError, ChanGoError]),
scanner=("is_available", [False, False, False]),
)
chango = BackwardCompatibleChanGo(main_instance, legacy_instances)
with pytest.raises(ChanGoError):
chango.build_version_note("version")
for instance in [main_instance, *legacy_instances]:
instance.scanner.is_available.assert_called_once_with("version")
instance.build_version_note.assert_not_called()
def test_build_version_history(self):
expected_history = object()
main_instance, legacy_instances = self.build_mocks(
chango=("build_version_history", [expected_history, RuntimeError, RuntimeError]),
scanner=None,
)
chango = BackwardCompatibleChanGo(main_instance, legacy_instances)
assert chango.build_version_history() is expected_history
main_instance.build_version_history.assert_called_once_with()
for legacy_instance in legacy_instances:
assert not legacy_instance.build_version_history.called
@pytest.mark.parametrize(
("results", "expected"),
[
(["main-change-note", ChanGoError, ChanGoError], "main-change-note"),
([ChanGoError, "legacy-change-note-1", ChanGoError], "legacy-change-note-1"),
([ChanGoError, ChanGoError, "legacy-change-note-2"], "legacy-change-note-2"),
],
)
def test_load_change_note(self, results, expected):
main_instance, legacy_instances = self.build_mocks(
chango=("load_change_note", [expected, ChanGoError, ChanGoError]), scanner=None
)
chango = BackwardCompatibleChanGo(main_instance, legacy_instances)
assert chango.load_change_note("uid") == expected
has_returned = False
for instance, result in zip([main_instance, *legacy_instances], results, strict=False):
if not has_returned:
instance.load_change_note.assert_called_once_with("uid")
has_returned = has_returned or not isinstance(result, ChanGoError)
else:
assert not instance.load_change_note.called
def test_load_change_note_not_found(self):
main_instance, legacy_instances = self.build_mocks(
chango=("load_change_note", [ChanGoError, ChanGoError, ChanGoError]), scanner=None
)
chango = BackwardCompatibleChanGo(main_instance, legacy_instances)
with pytest.raises(ChanGoError):
chango.load_change_note("uid")
for instance in [main_instance, *legacy_instances]:
instance.load_change_note.assert_called_once_with("uid")
def test_get_write_directory(self):
expected_directory = object()
main_instance, legacy_instances = self.build_mocks(
chango=("get_write_directory", [expected_directory, RuntimeError, RuntimeError]),
scanner=None,
)
chango = BackwardCompatibleChanGo(main_instance, legacy_instances)
assert chango.get_write_directory("change_note", "version") is expected_directory
main_instance.get_write_directory.assert_called_once_with("change_note", "version")
for legacy_instance in legacy_instances:
assert not legacy_instance.get_write_directory.called
def test_build_github_event_change_note(self):
expected = object()
main_instance, legacy_instances = self.build_mocks(
chango=("build_github_event_change_note", [expected, RuntimeError, RuntimeError]),
scanner=None,
)
chango = BackwardCompatibleChanGo(main_instance, legacy_instances)
call_args = [[("event", "data"), ("event", "data")], [("event",), ("event", None)]]
for args, expected_args in call_args:
assert chango.build_github_event_change_note(*args) is expected
main_instance.build_github_event_change_note.assert_called_with(*expected_args)
for legacy_instance in legacy_instances:
assert not legacy_instance.build_github_event_change_note.called
|
