codeplain 0.3.13.dev49__py3-none-any.whl → 0.3.14.dev50__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- change_detection.py +65 -94
- cli_output/dry_run.py +7 -3
- {codeplain-0.3.13.dev49.dist-info → codeplain-0.3.14.dev50.dist-info}/METADATA +1 -1
- {codeplain-0.3.13.dev49.dist-info → codeplain-0.3.14.dev50.dist-info}/RECORD +49 -43
- codeplain_REST_api.py +9 -14
- docs/generate_cli.py +3 -2
- partial_rendering.py +32 -2
- plain2code.py +42 -14
- plain2code_arguments.py +69 -12
- plain2code_telemetry.py +2 -1
- plain2code_utils.py +14 -0
- plain_modules.py +73 -14
- render_machine/actions/analyze_specification_ambiguity.py +5 -3
- render_machine/actions/distill_conformance_test_memory.py +3 -1
- render_machine/actions/fix_conformance_test.py +4 -4
- render_machine/actions/fix_unit_tests.py +3 -1
- render_machine/actions/refactor_code.py +6 -1
- render_machine/actions/render_conformance_tests.py +52 -20
- render_machine/actions/render_functional_requirement.py +5 -2
- render_machine/actions/run_conformance_tests.py +3 -2
- render_machine/actions/summarize_conformance_tests.py +3 -1
- render_machine/render_context.py +59 -20
- render_machine/render_types.py +6 -15
- standard_template_library/typescript-react-app-boilerplate.plain +2 -1
- tests/test_acceptance_scenario_rendered_once.py +169 -0
- tests/test_acceptance_scenarios_after_a_code_fix.py +110 -0
- tests/test_change_detection.py +138 -127
- tests/test_conformance_fix_journal.py +46 -46
- tests/test_dry_run_link_validation.py +2 -1
- tests/test_fix_unit_tests_action.py +1 -1
- tests/test_frid_arguments.py +40 -0
- tests/test_functionality_without_scenarios.py +88 -0
- tests/test_git_utils.py +13 -13
- tests/test_partial_rendering.py +82 -47
- tests/test_plain2code.py +39 -41
- tests/test_plain2code_utils.py +12 -1
- tests/test_plain_modules.py +50 -44
- tests/test_render_finished_report.py +2 -0
- tests/test_render_range.py +18 -9
- tests/test_render_stop_reason.py +5 -5
- tests/test_telemetry.py +2 -2
- tests/test_terminal_attachment.py +2 -1
- tests/test_tests_folders.py +91 -0
- tests/test_traceability_warnings.py +69 -0
- tui/plain_module_render_choice_tui.py +4 -6
- tui/state_handlers.py +19 -28
- {codeplain-0.3.13.dev49.dist-info → codeplain-0.3.14.dev50.dist-info}/WHEEL +0 -0
- {codeplain-0.3.13.dev49.dist-info → codeplain-0.3.14.dev50.dist-info}/entry_points.txt +0 -0
- {codeplain-0.3.13.dev49.dist-info → codeplain-0.3.14.dev50.dist-info}/licenses/LICENSE +0 -0
tests/test_change_detection.py
CHANGED
|
@@ -8,12 +8,21 @@ without filesystem or real PlainModule dependencies.
|
|
|
8
8
|
from change_detection import FunctionalityChange, _detect_module_changes, determine_partial_render_start
|
|
9
9
|
|
|
10
10
|
|
|
11
|
+
def _frs(*items) -> list[dict[str, str]]:
|
|
12
|
+
"""Functionalities from a func-id, or from a `(func-id, text)` pair when the text matters."""
|
|
13
|
+
functionalities = []
|
|
14
|
+
for item in items:
|
|
15
|
+
frid, markdown = item if isinstance(item, tuple) else (item, f"The {item} functionality.")
|
|
16
|
+
functionalities.append({"id": frid, "markdown": markdown})
|
|
17
|
+
return functionalities
|
|
18
|
+
|
|
19
|
+
|
|
11
20
|
class FakeModule:
|
|
12
21
|
def __init__(
|
|
13
22
|
self,
|
|
14
23
|
module_name: str,
|
|
15
|
-
current_frs: list[str],
|
|
16
|
-
stored_frs: list[str] | None = None,
|
|
24
|
+
current_frs: list[dict[str, str]],
|
|
25
|
+
stored_frs: list[dict[str, str]] | None = None,
|
|
17
26
|
current_non_fr_hash: str = "match",
|
|
18
27
|
stored_non_fr_hash: str | None = "match",
|
|
19
28
|
):
|
|
@@ -40,7 +49,7 @@ class FakeModule:
|
|
|
40
49
|
metadata["non_functional_source_hash"] = self._stored_non_fr_hash
|
|
41
50
|
return metadata
|
|
42
51
|
|
|
43
|
-
def _get_module_functional_requirements(self) -> list[str]:
|
|
52
|
+
def _get_module_functional_requirements(self) -> list[dict[str, str]]:
|
|
44
53
|
return self._current_frs
|
|
45
54
|
|
|
46
55
|
def get_module_non_functional_source_hash(self) -> str:
|
|
@@ -51,7 +60,7 @@ class FakeModule:
|
|
|
51
60
|
|
|
52
61
|
|
|
53
62
|
def test_identical_specs_no_changes():
|
|
54
|
-
module = FakeModule("mod",
|
|
63
|
+
module = FakeModule("mod", _frs("fr-a", "fr-b", "fr-c"), _frs("fr-a", "fr-b", "fr-c"))
|
|
55
64
|
changes = _detect_module_changes(module)
|
|
56
65
|
assert changes == []
|
|
57
66
|
|
|
@@ -66,16 +75,16 @@ def test_empty_both_no_changes():
|
|
|
66
75
|
|
|
67
76
|
|
|
68
77
|
def test_no_metadata_all_added():
|
|
69
|
-
module = FakeModule("mod",
|
|
78
|
+
module = FakeModule("mod", _frs("fr-a", "fr-b"), stored_frs=None)
|
|
70
79
|
changes = _detect_module_changes(module)
|
|
71
|
-
assert
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
80
|
+
assert changes == [
|
|
81
|
+
FunctionalityChange(module="mod", frid="fr-a", change_type="added"),
|
|
82
|
+
FunctionalityChange(module="mod", frid="fr-b", change_type="added"),
|
|
83
|
+
]
|
|
75
84
|
|
|
76
85
|
|
|
77
86
|
def test_empty_stored_all_added():
|
|
78
|
-
module = FakeModule("mod",
|
|
87
|
+
module = FakeModule("mod", _frs("fr-a", "fr-b"), stored_frs=[])
|
|
79
88
|
changes = _detect_module_changes(module)
|
|
80
89
|
assert len(changes) == 2
|
|
81
90
|
assert all(c.change_type == "added" for c in changes)
|
|
@@ -85,66 +94,85 @@ def test_empty_stored_all_added():
|
|
|
85
94
|
|
|
86
95
|
|
|
87
96
|
def test_no_current_frs_all_removed():
|
|
88
|
-
module = FakeModule("mod", [], stored_frs=
|
|
97
|
+
module = FakeModule("mod", [], stored_frs=_frs("fr-a", "fr-b", "fr-c"))
|
|
89
98
|
changes = _detect_module_changes(module)
|
|
90
|
-
assert len(changes) == 3
|
|
91
99
|
assert all(c.change_type == "removed" for c in changes)
|
|
92
|
-
assert
|
|
93
|
-
assert changes[1].frid == "2"
|
|
94
|
-
assert changes[2].frid == "3"
|
|
100
|
+
assert [c.frid for c in changes] == ["fr-a", "fr-b", "fr-c"]
|
|
95
101
|
|
|
96
102
|
|
|
97
103
|
# --- Edits ---
|
|
98
104
|
|
|
99
105
|
|
|
100
106
|
def test_single_edit():
|
|
101
|
-
module = FakeModule("mod",
|
|
107
|
+
module = FakeModule("mod", _frs(("fr-a", "new text"), "fr-b"), stored_frs=_frs("fr-a", "fr-b"))
|
|
102
108
|
changes = _detect_module_changes(module)
|
|
103
|
-
assert
|
|
104
|
-
assert changes[0] == FunctionalityChange(module="mod", frid="1", change_type="edited")
|
|
109
|
+
assert changes == [FunctionalityChange(module="mod", frid="fr-a", change_type="edited")]
|
|
105
110
|
|
|
106
111
|
|
|
107
112
|
def test_multiple_edits():
|
|
108
|
-
module = FakeModule(
|
|
113
|
+
module = FakeModule(
|
|
114
|
+
"mod",
|
|
115
|
+
_frs(("fr-a", "new a"), ("fr-b", "new b"), ("fr-c", "new c")),
|
|
116
|
+
stored_frs=_frs("fr-a", "fr-b", "fr-c"),
|
|
117
|
+
)
|
|
109
118
|
changes = _detect_module_changes(module)
|
|
110
119
|
assert len(changes) == 3
|
|
111
120
|
assert all(c.change_type == "edited" for c in changes)
|
|
112
121
|
|
|
113
122
|
|
|
123
|
+
def test_two_functionalities_with_the_same_text_are_told_apart_by_id():
|
|
124
|
+
same_text = "The same text."
|
|
125
|
+
module = FakeModule(
|
|
126
|
+
"mod",
|
|
127
|
+
_frs(("fr-a", same_text), ("fr-b", "new b")),
|
|
128
|
+
stored_frs=_frs(("fr-a", same_text), ("fr-b", same_text)),
|
|
129
|
+
)
|
|
130
|
+
changes = _detect_module_changes(module)
|
|
131
|
+
assert changes == [FunctionalityChange(module="mod", frid="fr-b", change_type="edited")]
|
|
132
|
+
|
|
133
|
+
|
|
114
134
|
# --- Additions ---
|
|
115
135
|
|
|
116
136
|
|
|
117
137
|
def test_addition_at_end():
|
|
118
|
-
module = FakeModule("mod",
|
|
138
|
+
module = FakeModule("mod", _frs("fr-a", "fr-b", "fr-c"), stored_frs=_frs("fr-a", "fr-b"))
|
|
119
139
|
changes = _detect_module_changes(module)
|
|
120
|
-
assert
|
|
121
|
-
|
|
140
|
+
assert changes == [FunctionalityChange(module="mod", frid="fr-c", change_type="added")]
|
|
141
|
+
|
|
142
|
+
|
|
143
|
+
def test_addition_in_the_middle_moves_nobody():
|
|
144
|
+
module = FakeModule("mod", _frs("fr-a", "fr-x", "fr-b"), stored_frs=_frs("fr-a", "fr-b"))
|
|
145
|
+
changes = _detect_module_changes(module)
|
|
146
|
+
assert changes == [FunctionalityChange(module="mod", frid="fr-x", change_type="added")]
|
|
122
147
|
|
|
123
148
|
|
|
124
149
|
# --- Removals ---
|
|
125
150
|
|
|
126
151
|
|
|
127
152
|
def test_removal_at_end():
|
|
128
|
-
module = FakeModule("mod",
|
|
153
|
+
module = FakeModule("mod", _frs("fr-a", "fr-b"), stored_frs=_frs("fr-a", "fr-b", "fr-c"))
|
|
129
154
|
changes = _detect_module_changes(module)
|
|
130
|
-
assert
|
|
131
|
-
|
|
155
|
+
assert changes == [FunctionalityChange(module="mod", frid="fr-c", change_type="removed")]
|
|
156
|
+
|
|
157
|
+
|
|
158
|
+
def test_removal_in_the_middle_moves_nobody():
|
|
159
|
+
module = FakeModule("mod", _frs("fr-a", "fr-c"), stored_frs=_frs("fr-a", "fr-b", "fr-c"))
|
|
160
|
+
changes = _detect_module_changes(module)
|
|
161
|
+
assert changes == [FunctionalityChange(module="mod", frid="fr-b", change_type="removed")]
|
|
132
162
|
|
|
133
163
|
|
|
134
164
|
# --- Moves ---
|
|
135
165
|
|
|
136
166
|
|
|
137
167
|
def test_swap_detected_as_moves():
|
|
138
|
-
module = FakeModule("mod",
|
|
168
|
+
module = FakeModule("mod", _frs("fr-b", "fr-a"), stored_frs=_frs("fr-a", "fr-b"))
|
|
139
169
|
changes = _detect_module_changes(module)
|
|
140
170
|
moves = [c for c in changes if c.change_type == "moved"]
|
|
141
|
-
assert
|
|
142
|
-
assert FunctionalityChange(module="mod", frid="1", change_type="moved", detail="2") in moves
|
|
143
|
-
assert FunctionalityChange(module="mod", frid="2", change_type="moved", detail="1") in moves
|
|
171
|
+
assert [c.frid for c in moves] == ["fr-b", "fr-a"]
|
|
144
172
|
|
|
145
173
|
|
|
146
174
|
def test_move_to_later_position():
|
|
147
|
-
module = FakeModule("mod",
|
|
175
|
+
module = FakeModule("mod", _frs("fr-b", "fr-c", "fr-a"), stored_frs=_frs("fr-a", "fr-b", "fr-c"))
|
|
148
176
|
changes = _detect_module_changes(module)
|
|
149
177
|
moves = [c for c in changes if c.change_type == "moved"]
|
|
150
178
|
assert len(moves) == 3
|
|
@@ -154,241 +182,224 @@ def test_move_to_later_position():
|
|
|
154
182
|
|
|
155
183
|
|
|
156
184
|
def test_edit_and_addition():
|
|
157
|
-
module = FakeModule(
|
|
185
|
+
module = FakeModule(
|
|
186
|
+
"mod",
|
|
187
|
+
_frs(("fr-a", "new a"), "fr-b", "fr-c"),
|
|
188
|
+
stored_frs=_frs("fr-a", "fr-b"),
|
|
189
|
+
)
|
|
158
190
|
changes = _detect_module_changes(module)
|
|
159
191
|
edits = [c for c in changes if c.change_type == "edited"]
|
|
160
192
|
added = [c for c in changes if c.change_type == "added"]
|
|
161
|
-
assert
|
|
162
|
-
assert
|
|
163
|
-
assert len(added) == 1
|
|
164
|
-
assert added[0].frid == "3"
|
|
193
|
+
assert [c.frid for c in edits] == ["fr-a"]
|
|
194
|
+
assert [c.frid for c in added] == ["fr-c"]
|
|
165
195
|
|
|
166
196
|
|
|
167
197
|
def test_edit_and_removal():
|
|
168
|
-
module = FakeModule("mod",
|
|
198
|
+
module = FakeModule("mod", _frs(("fr-a", "new a")), stored_frs=_frs("fr-a", "fr-b"))
|
|
169
199
|
changes = _detect_module_changes(module)
|
|
170
200
|
edits = [c for c in changes if c.change_type == "edited"]
|
|
171
201
|
removed = [c for c in changes if c.change_type == "removed"]
|
|
172
|
-
assert
|
|
173
|
-
assert
|
|
174
|
-
assert len(removed) == 1
|
|
175
|
-
assert removed[0].frid == "2"
|
|
202
|
+
assert [c.frid for c in edits] == ["fr-a"]
|
|
203
|
+
assert [c.frid for c in removed] == ["fr-b"]
|
|
176
204
|
|
|
177
205
|
|
|
178
206
|
def test_move_and_addition():
|
|
179
|
-
# Old: [
|
|
180
|
-
module = FakeModule("mod",
|
|
207
|
+
# Old: [a, b], New: [b, a, c] -> a and b swapped, c added
|
|
208
|
+
module = FakeModule("mod", _frs("fr-b", "fr-a", "fr-c"), stored_frs=_frs("fr-a", "fr-b"))
|
|
181
209
|
changes = _detect_module_changes(module)
|
|
182
210
|
moves = [c for c in changes if c.change_type == "moved"]
|
|
183
211
|
added = [c for c in changes if c.change_type == "added"]
|
|
184
212
|
assert len(moves) == 2
|
|
185
|
-
assert
|
|
186
|
-
assert added[0].frid == "3"
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
# --- Duplicate FR texts ---
|
|
190
|
-
|
|
191
|
-
|
|
192
|
-
def test_duplicate_texts_matched_by_position():
|
|
193
|
-
module = FakeModule("mod", ["A", "A", "B"], stored_frs=["A", "A", "B"])
|
|
194
|
-
changes = _detect_module_changes(module)
|
|
195
|
-
assert changes == []
|
|
196
|
-
|
|
197
|
-
|
|
198
|
-
def test_duplicate_texts_with_edit():
|
|
199
|
-
module = FakeModule("mod", ["A", "X", "B"], stored_frs=["A", "A", "B"])
|
|
200
|
-
changes = _detect_module_changes(module)
|
|
201
|
-
assert len(changes) == 1
|
|
202
|
-
assert changes[0] == FunctionalityChange(module="mod", frid="2", change_type="edited")
|
|
213
|
+
assert [c.frid for c in added] == ["fr-c"]
|
|
203
214
|
|
|
204
215
|
|
|
205
216
|
# --- determine_partial_render_start ---
|
|
206
217
|
|
|
207
218
|
|
|
208
219
|
def test_partial_render_start_no_changes():
|
|
209
|
-
module = FakeModule("mod",
|
|
210
|
-
|
|
211
|
-
assert result is None
|
|
220
|
+
module = FakeModule("mod", _frs("fr-a", "fr-b", "fr-c"), _frs("fr-a", "fr-b", "fr-c"))
|
|
221
|
+
assert determine_partial_render_start(module) is None
|
|
212
222
|
|
|
213
223
|
|
|
214
|
-
def
|
|
215
|
-
module = FakeModule(
|
|
224
|
+
def test_partial_render_start_edit():
|
|
225
|
+
module = FakeModule(
|
|
226
|
+
"mod",
|
|
227
|
+
_frs("fr-a", "fr-b", ("fr-c", "new c"), "fr-d", "fr-e"),
|
|
228
|
+
stored_frs=_frs("fr-a", "fr-b", "fr-c", "fr-d", "fr-e"),
|
|
229
|
+
)
|
|
216
230
|
result = determine_partial_render_start(module)
|
|
217
231
|
assert result is not None
|
|
218
232
|
assert result.module.module_name == "mod"
|
|
219
|
-
assert result.frid == "
|
|
233
|
+
assert result.frid == "fr-c"
|
|
220
234
|
|
|
221
235
|
|
|
222
|
-
def
|
|
223
|
-
module = FakeModule(
|
|
236
|
+
def test_partial_render_start_removal_starts_at_what_took_its_place():
|
|
237
|
+
module = FakeModule(
|
|
238
|
+
"mod",
|
|
239
|
+
_frs("fr-a", "fr-b", "fr-d", "fr-e"),
|
|
240
|
+
stored_frs=_frs("fr-a", "fr-b", "fr-c", "fr-d", "fr-e"),
|
|
241
|
+
)
|
|
224
242
|
result = determine_partial_render_start(module)
|
|
225
243
|
assert result is not None
|
|
226
|
-
assert result.
|
|
227
|
-
assert result.frid == "3"
|
|
244
|
+
assert result.frid == "fr-d"
|
|
228
245
|
|
|
229
246
|
|
|
230
247
|
def test_partial_render_start_addition_at_end():
|
|
231
|
-
module = FakeModule("mod",
|
|
248
|
+
module = FakeModule("mod", _frs("fr-a", "fr-b", "fr-c", "fr-d"), stored_frs=_frs("fr-a", "fr-b", "fr-c"))
|
|
232
249
|
result = determine_partial_render_start(module)
|
|
233
250
|
assert result is not None
|
|
234
|
-
assert result.
|
|
235
|
-
assert result.frid == "4"
|
|
251
|
+
assert result.frid == "fr-d"
|
|
236
252
|
|
|
237
253
|
|
|
238
254
|
def test_partial_render_start_swap_returns_earliest_position():
|
|
239
|
-
"""
|
|
240
|
-
module = FakeModule("mod", ["B", "A", "C"], stored_frs=["A", "B", "C"])
|
|
255
|
+
module = FakeModule("mod", _frs("fr-b", "fr-a", "fr-c"), stored_frs=_frs("fr-a", "fr-b", "fr-c"))
|
|
241
256
|
result = determine_partial_render_start(module)
|
|
242
257
|
assert result is not None
|
|
243
|
-
assert result.frid == "
|
|
258
|
+
assert result.frid == "fr-b"
|
|
244
259
|
|
|
245
260
|
|
|
246
261
|
def test_partial_render_start_mid_module_swap_returns_earliest_position():
|
|
247
|
-
|
|
248
|
-
|
|
262
|
+
module = FakeModule(
|
|
263
|
+
"mod",
|
|
264
|
+
_frs("fr-a", "fr-b", "fr-d", "fr-c", "fr-e"),
|
|
265
|
+
stored_frs=_frs("fr-a", "fr-b", "fr-c", "fr-d", "fr-e"),
|
|
266
|
+
)
|
|
249
267
|
result = determine_partial_render_start(module)
|
|
250
268
|
assert result is not None
|
|
251
|
-
assert result.frid == "
|
|
269
|
+
assert result.frid == "fr-d"
|
|
252
270
|
|
|
253
271
|
|
|
254
272
|
def test_partial_render_start_cyclic_move_returns_earliest_position():
|
|
255
|
-
"""
|
|
256
|
-
module = FakeModule("mod", ["B", "C", "A"], stored_frs=["A", "B", "C"])
|
|
273
|
+
module = FakeModule("mod", _frs("fr-b", "fr-c", "fr-a"), stored_frs=_frs("fr-a", "fr-b", "fr-c"))
|
|
257
274
|
result = determine_partial_render_start(module)
|
|
258
275
|
assert result is not None
|
|
259
|
-
assert result.frid == "
|
|
276
|
+
assert result.frid == "fr-b"
|
|
260
277
|
|
|
261
278
|
|
|
262
279
|
def test_partial_render_start_multi_module_change_in_required():
|
|
263
|
-
req_module = FakeModule(
|
|
264
|
-
|
|
280
|
+
req_module = FakeModule(
|
|
281
|
+
"req", _frs("req-a", ("req-b", "new b"), "req-c"), stored_frs=_frs("req-a", "req-b", "req-c")
|
|
282
|
+
)
|
|
283
|
+
top_module = FakeModule("top", _frs("top-a", "top-b"), stored_frs=_frs("top-a", "top-b"))
|
|
265
284
|
top_module.required_modules = [req_module]
|
|
266
285
|
|
|
267
286
|
result = determine_partial_render_start(top_module)
|
|
268
287
|
assert result is not None
|
|
269
288
|
assert result.module.module_name == "req"
|
|
270
|
-
assert result.frid == "
|
|
289
|
+
assert result.frid == "req-b"
|
|
271
290
|
|
|
272
291
|
|
|
273
292
|
def test_partial_render_start_multi_module_no_change_in_required():
|
|
274
|
-
req_module = FakeModule("req",
|
|
275
|
-
top_module = FakeModule("top",
|
|
293
|
+
req_module = FakeModule("req", _frs("req-a", "req-b"), stored_frs=_frs("req-a", "req-b"))
|
|
294
|
+
top_module = FakeModule("top", _frs(("top-a", "new a"), "top-b"), stored_frs=_frs("top-a", "top-b"))
|
|
276
295
|
top_module.required_modules = [req_module]
|
|
277
296
|
|
|
278
297
|
result = determine_partial_render_start(top_module)
|
|
279
298
|
assert result is not None
|
|
280
299
|
assert result.module.module_name == "top"
|
|
281
|
-
assert result.frid == "
|
|
300
|
+
assert result.frid == "top-a"
|
|
282
301
|
|
|
283
302
|
|
|
284
303
|
def test_partial_render_start_multi_module_no_changes_returns_none():
|
|
285
|
-
req_module = FakeModule("req",
|
|
286
|
-
top_module = FakeModule("top",
|
|
304
|
+
req_module = FakeModule("req", _frs("req-a", "req-b"), stored_frs=_frs("req-a", "req-b"))
|
|
305
|
+
top_module = FakeModule("top", _frs("top-a"), stored_frs=_frs("top-a"))
|
|
287
306
|
top_module.required_modules = [req_module]
|
|
288
307
|
|
|
289
|
-
|
|
290
|
-
assert result is None
|
|
308
|
+
assert determine_partial_render_start(top_module) is None
|
|
291
309
|
|
|
292
310
|
|
|
293
311
|
def test_partial_render_start_changes_in_multiple_modules_returns_earliest():
|
|
294
312
|
"""When both a required module and the top module changed, the earliest module in the
|
|
295
313
|
chain (the required one) determines the start point."""
|
|
296
|
-
req_module = FakeModule("req",
|
|
297
|
-
top_module = FakeModule("top",
|
|
314
|
+
req_module = FakeModule("req", _frs("req-a", "req-b"), stored_frs=_frs("req-a"))
|
|
315
|
+
top_module = FakeModule("top", _frs(("top-a", "new a")), stored_frs=_frs("top-a"))
|
|
298
316
|
top_module.required_modules = [req_module]
|
|
299
317
|
|
|
300
318
|
result = determine_partial_render_start(top_module)
|
|
301
319
|
assert result is not None
|
|
302
320
|
assert result.module.module_name == "req"
|
|
303
|
-
assert result.frid == "
|
|
321
|
+
assert result.frid == "req-b"
|
|
304
322
|
|
|
305
323
|
|
|
306
324
|
def test_partial_render_start_deep_chain_change_in_middle():
|
|
307
|
-
mod_a = FakeModule("a",
|
|
308
|
-
mod_b = FakeModule("b",
|
|
325
|
+
mod_a = FakeModule("a", _frs("a-one"), stored_frs=_frs("a-one"))
|
|
326
|
+
mod_b = FakeModule("b", _frs("b-one", "b-two"), stored_frs=_frs("b-one"))
|
|
309
327
|
mod_b.required_modules = [mod_a]
|
|
310
|
-
mod_c = FakeModule("c",
|
|
328
|
+
mod_c = FakeModule("c", _frs("c-one"), stored_frs=_frs("c-one"))
|
|
311
329
|
mod_c.required_modules = [mod_b]
|
|
312
330
|
|
|
313
331
|
result = determine_partial_render_start(mod_c)
|
|
314
332
|
assert result is not None
|
|
315
333
|
assert result.module.module_name == "b"
|
|
316
|
-
assert result.frid == "
|
|
334
|
+
assert result.frid == "b-two"
|
|
317
335
|
|
|
318
336
|
|
|
319
337
|
def test_partial_render_start_never_rendered():
|
|
320
|
-
module = FakeModule("mod",
|
|
338
|
+
module = FakeModule("mod", _frs("fr-a", "fr-b"), stored_frs=None)
|
|
321
339
|
result = determine_partial_render_start(module)
|
|
322
340
|
assert result is not None
|
|
323
|
-
assert result.frid == "
|
|
341
|
+
assert result.frid == "fr-a"
|
|
324
342
|
|
|
325
343
|
|
|
326
344
|
def test_partial_render_start_trailing_removal_returns_none():
|
|
327
|
-
"""Removing the last
|
|
328
|
-
module = FakeModule("mod",
|
|
329
|
-
|
|
330
|
-
assert result is None
|
|
345
|
+
"""Removing the last functionality doesn't require rendering any remaining one."""
|
|
346
|
+
module = FakeModule("mod", _frs("fr-a", "fr-b"), stored_frs=_frs("fr-a", "fr-b", "fr-c"))
|
|
347
|
+
assert determine_partial_render_start(module) is None
|
|
331
348
|
|
|
332
349
|
|
|
333
350
|
def test_partial_render_start_trailing_removal_with_earlier_edit():
|
|
334
|
-
"""
|
|
335
|
-
module = FakeModule("mod", ["A modified", "B"], stored_frs=["A", "B", "C"])
|
|
351
|
+
module = FakeModule("mod", _frs(("fr-a", "new a"), "fr-b"), stored_frs=_frs("fr-a", "fr-b", "fr-c"))
|
|
336
352
|
result = determine_partial_render_start(module)
|
|
337
353
|
assert result is not None
|
|
338
|
-
assert result.frid == "
|
|
354
|
+
assert result.frid == "fr-a"
|
|
339
355
|
|
|
340
356
|
|
|
341
357
|
# --- Non-functional content changes ---
|
|
342
358
|
|
|
343
359
|
|
|
344
360
|
def test_partial_render_start_blocked_by_non_fr_change():
|
|
345
|
-
"""An
|
|
361
|
+
"""An edit alongside a non-FR change (e.g. new definition) must block partial render."""
|
|
346
362
|
module = FakeModule(
|
|
347
363
|
"mod",
|
|
348
|
-
|
|
349
|
-
stored_frs=
|
|
364
|
+
_frs(("fr-a", "new a"), "fr-b"),
|
|
365
|
+
stored_frs=_frs("fr-a", "fr-b"),
|
|
350
366
|
current_non_fr_hash="v2",
|
|
351
367
|
stored_non_fr_hash="v1",
|
|
352
368
|
)
|
|
353
|
-
|
|
354
|
-
assert result is None
|
|
369
|
+
assert determine_partial_render_start(module) is None
|
|
355
370
|
|
|
356
371
|
|
|
357
372
|
def test_partial_render_start_non_fr_only_change_returns_none():
|
|
358
|
-
"""A non-FR-only change (FRs identical) blocks partial render."""
|
|
359
373
|
module = FakeModule(
|
|
360
374
|
"mod",
|
|
361
|
-
|
|
362
|
-
stored_frs=
|
|
375
|
+
_frs("fr-a", "fr-b"),
|
|
376
|
+
stored_frs=_frs("fr-a", "fr-b"),
|
|
363
377
|
current_non_fr_hash="v2",
|
|
364
378
|
stored_non_fr_hash="v1",
|
|
365
379
|
)
|
|
366
|
-
|
|
367
|
-
assert result is None
|
|
380
|
+
assert determine_partial_render_start(module) is None
|
|
368
381
|
|
|
369
382
|
|
|
370
383
|
def test_partial_render_start_missing_stored_non_fr_hash_blocks():
|
|
371
384
|
"""Older metadata without the non-FR hash must be treated as 'changed' (safe default)."""
|
|
372
385
|
module = FakeModule(
|
|
373
386
|
"mod",
|
|
374
|
-
|
|
375
|
-
stored_frs=
|
|
387
|
+
_frs(("fr-a", "new a"), "fr-b"),
|
|
388
|
+
stored_frs=_frs("fr-a", "fr-b"),
|
|
376
389
|
stored_non_fr_hash=None,
|
|
377
390
|
)
|
|
378
|
-
|
|
379
|
-
assert result is None
|
|
391
|
+
assert determine_partial_render_start(module) is None
|
|
380
392
|
|
|
381
393
|
|
|
382
394
|
def test_partial_render_start_non_fr_change_in_required_module_blocks():
|
|
383
395
|
req_module = FakeModule(
|
|
384
396
|
"req",
|
|
385
|
-
|
|
386
|
-
stored_frs=
|
|
397
|
+
_frs(("req-a", "new a")),
|
|
398
|
+
stored_frs=_frs("req-a"),
|
|
387
399
|
current_non_fr_hash="v2",
|
|
388
400
|
stored_non_fr_hash="v1",
|
|
389
401
|
)
|
|
390
|
-
top_module = FakeModule("top",
|
|
402
|
+
top_module = FakeModule("top", _frs("top-a"), stored_frs=_frs("top-a"))
|
|
391
403
|
top_module.required_modules = [req_module]
|
|
392
404
|
|
|
393
|
-
|
|
394
|
-
assert result is None
|
|
405
|
+
assert determine_partial_render_start(top_module) is None
|