codeplain 0.3.13.dev48__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.
Files changed (49) hide show
  1. change_detection.py +65 -94
  2. cli_output/dry_run.py +7 -3
  3. {codeplain-0.3.13.dev48.dist-info → codeplain-0.3.14.dev50.dist-info}/METADATA +1 -1
  4. {codeplain-0.3.13.dev48.dist-info → codeplain-0.3.14.dev50.dist-info}/RECORD +49 -43
  5. codeplain_REST_api.py +9 -14
  6. docs/generate_cli.py +3 -2
  7. partial_rendering.py +32 -2
  8. plain2code.py +42 -14
  9. plain2code_arguments.py +69 -12
  10. plain2code_telemetry.py +2 -1
  11. plain2code_utils.py +14 -0
  12. plain_modules.py +73 -14
  13. render_machine/actions/analyze_specification_ambiguity.py +5 -3
  14. render_machine/actions/distill_conformance_test_memory.py +3 -1
  15. render_machine/actions/fix_conformance_test.py +4 -4
  16. render_machine/actions/fix_unit_tests.py +3 -1
  17. render_machine/actions/refactor_code.py +6 -1
  18. render_machine/actions/render_conformance_tests.py +52 -20
  19. render_machine/actions/render_functional_requirement.py +5 -2
  20. render_machine/actions/run_conformance_tests.py +3 -2
  21. render_machine/actions/summarize_conformance_tests.py +3 -1
  22. render_machine/render_context.py +59 -20
  23. render_machine/render_types.py +6 -15
  24. standard_template_library/typescript-react-app-boilerplate.plain +2 -1
  25. tests/test_acceptance_scenario_rendered_once.py +169 -0
  26. tests/test_acceptance_scenarios_after_a_code_fix.py +110 -0
  27. tests/test_change_detection.py +138 -127
  28. tests/test_conformance_fix_journal.py +46 -46
  29. tests/test_dry_run_link_validation.py +2 -1
  30. tests/test_fix_unit_tests_action.py +1 -1
  31. tests/test_frid_arguments.py +40 -0
  32. tests/test_functionality_without_scenarios.py +88 -0
  33. tests/test_git_utils.py +13 -13
  34. tests/test_partial_rendering.py +82 -47
  35. tests/test_plain2code.py +39 -41
  36. tests/test_plain2code_utils.py +12 -1
  37. tests/test_plain_modules.py +50 -44
  38. tests/test_render_finished_report.py +2 -0
  39. tests/test_render_range.py +18 -9
  40. tests/test_render_stop_reason.py +5 -5
  41. tests/test_telemetry.py +2 -2
  42. tests/test_terminal_attachment.py +2 -1
  43. tests/test_tests_folders.py +91 -0
  44. tests/test_traceability_warnings.py +69 -0
  45. tui/plain_module_render_choice_tui.py +4 -6
  46. tui/state_handlers.py +19 -28
  47. {codeplain-0.3.13.dev48.dist-info → codeplain-0.3.14.dev50.dist-info}/WHEEL +0 -0
  48. {codeplain-0.3.13.dev48.dist-info → codeplain-0.3.14.dev50.dist-info}/entry_points.txt +0 -0
  49. {codeplain-0.3.13.dev48.dist-info → codeplain-0.3.14.dev50.dist-info}/licenses/LICENSE +0 -0
@@ -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", ["A", "B", "C"], ["A", "B", "C"])
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", ["A", "B"], stored_frs=None)
78
+ module = FakeModule("mod", _frs("fr-a", "fr-b"), stored_frs=None)
70
79
  changes = _detect_module_changes(module)
71
- assert len(changes) == 2
72
- assert all(c.change_type == "added" for c in changes)
73
- assert changes[0] == FunctionalityChange(module="mod", frid="1", change_type="added")
74
- assert changes[1] == FunctionalityChange(module="mod", frid="2", change_type="added")
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", ["A", "B"], stored_frs=[])
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=["A", "B", "C"])
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 changes[0].frid == "1"
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", ["A modified", "B"], stored_frs=["A", "B"])
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 len(changes) == 1
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("mod", ["X", "Y", "Z"], stored_frs=["A", "B", "C"])
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", ["A", "B", "C"], stored_frs=["A", "B"])
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 len(changes) == 1
121
- assert changes[0] == FunctionalityChange(module="mod", frid="3", change_type="added")
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", ["A", "B"], stored_frs=["A", "B", "C"])
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 len(changes) == 1
131
- assert changes[0] == FunctionalityChange(module="mod", frid="3", change_type="removed")
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", ["B", "A"], stored_frs=["A", "B"])
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 len(moves) == 2
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", ["B", "C", "A"], stored_frs=["A", "B", "C"])
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("mod", ["X", "B", "C"], stored_frs=["A", "B"])
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 len(edits) == 1
162
- assert edits[0].frid == "1"
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", ["X"], stored_frs=["A", "B"])
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 len(edits) == 1
173
- assert edits[0].frid == "1"
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: [A, B], New: [B, A, C] → A moved 1→2, B moved 2→1, C added
180
- module = FakeModule("mod", ["B", "A", "C"], stored_frs=["A", "B"])
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 len(added) == 1
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", ["A", "B", "C"], stored_frs=["A", "B", "C"])
210
- result = determine_partial_render_start(module)
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 test_partial_render_start_edit_at_fr3():
215
- module = FakeModule("mod", ["A", "B", "C modified", "D", "E"], stored_frs=["A", "B", "C", "D", "E"])
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 == "3"
233
+ assert result.frid == "fr-c"
220
234
 
221
235
 
222
- def test_partial_render_start_removal_at_fr3():
223
- module = FakeModule("mod", ["A", "B", "D", "E"], stored_frs=["A", "B", "C", "D", "E"])
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.module.module_name == "mod"
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", ["A", "B", "C", "D"], stored_frs=["A", "B", "C"])
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.module.module_name == "mod"
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
- """A swap of FRs 1 and 2 should start partial render from FRID 1."""
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 == "1"
258
+ assert result.frid == "fr-b"
244
259
 
245
260
 
246
261
  def test_partial_render_start_mid_module_swap_returns_earliest_position():
247
- """A swap of FRs 3 and 4 in the middle of a module should start from FRID 3."""
248
- module = FakeModule("mod", ["A", "B", "D", "C", "E"], stored_frs=["A", "B", "C", "D", "E"])
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 == "3"
269
+ assert result.frid == "fr-d"
252
270
 
253
271
 
254
272
  def test_partial_render_start_cyclic_move_returns_earliest_position():
255
- """A 3-cycle move should start from the lowest position in the cycle."""
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 == "1"
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("req", ["R1", "R2 modified", "R3"], stored_frs=["R1", "R2", "R3"])
264
- top_module = FakeModule("top", ["T1", "T2"], stored_frs=["T1", "T2"])
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 == "2"
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", ["R1", "R2"], stored_frs=["R1", "R2"])
275
- top_module = FakeModule("top", ["T1 modified", "T2"], stored_frs=["T1", "T2"])
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 == "1"
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", ["R1", "R2"], stored_frs=["R1", "R2"])
286
- top_module = FakeModule("top", ["T1"], stored_frs=["T1"])
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
- result = determine_partial_render_start(top_module)
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", ["R1", "R2"], stored_frs=["R1"]) # R2 added
297
- top_module = FakeModule("top", ["T1 modified"], stored_frs=["T1"]) # T1 edited
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 == "2"
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", ["A1"], stored_frs=["A1"])
308
- mod_b = FakeModule("b", ["B1", "B2"], stored_frs=["B1"])
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", ["C1"], stored_frs=["C1"])
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 == "2"
334
+ assert result.frid == "b-two"
317
335
 
318
336
 
319
337
  def test_partial_render_start_never_rendered():
320
- module = FakeModule("mod", ["A", "B"], stored_frs=None)
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 == "1"
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 FR doesn't require rendering any remaining FRs."""
328
- module = FakeModule("mod", ["A", "B"], stored_frs=["A", "B", "C"])
329
- result = determine_partial_render_start(module)
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
- """Trailing removal combined with an earlier edit should still detect the edit."""
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 == "1"
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 FR edit alongside a non-FR change (e.g. new definition) must block partial render."""
361
+ """An edit alongside a non-FR change (e.g. new definition) must block partial render."""
346
362
  module = FakeModule(
347
363
  "mod",
348
- ["A modified", "B"],
349
- stored_frs=["A", "B"],
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
- result = determine_partial_render_start(module)
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
- ["A", "B"],
362
- stored_frs=["A", "B"],
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
- result = determine_partial_render_start(module)
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
- ["A modified", "B"],
375
- stored_frs=["A", "B"],
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
- result = determine_partial_render_start(module)
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
- ["R1 modified"],
386
- stored_frs=["R1"],
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", ["T1"], stored_frs=["T1"])
402
+ top_module = FakeModule("top", _frs("top-a"), stored_frs=_frs("top-a"))
391
403
  top_module.required_modules = [req_module]
392
404
 
393
- result = determine_partial_render_start(top_module)
394
- assert result is None
405
+ assert determine_partial_render_start(top_module) is None