1use std::io::Write;
2use std::num::NonZeroUsize;
3use std::path::PathBuf;
4
5use anyhow::Context as _;
6use anyhow::Result;
7use anyhow::ensure;
8use bon::Builder;
9use derive_new::new;
10use nonzero_ext::nonzero;
11use protobuf::Message as _;
12use tempfile::NamedTempFile;
13
14use crate::Exclusions;
15use crate::analyzer::options::Options as AnalyzerOptions;
16use crate::backend::RustAnalyzer;
17use crate::cycle_report::file_report;
18use crate::cycle_report::folder_report;
19use crate::cycles::analyze_files;
20use crate::cycles::analyze_folders;
21use crate::diagnostics::emit;
22use crate::export::Format;
23use crate::export::Options as ExportOptions;
24use crate::outgoing_dependencies::Analysis as OutgoingDependencyAnalysis;
25use crate::outgoing_dependencies::Mode as OutgoingDependencyMode;
26use crate::model::FileGraph;
27use crate::output_paths::FileOutput;
28use crate::output_paths::InputFile;
29use crate::output_paths::OutputFiles;
30use crate::scip::backend::file_graph;
31use crate::scip::index::ParsedIndex;
32
33const NO_FILES_AFTER_FILTERING: &str = "No indexed Rust files remain after applying root and file filters";
34
35pub const DEFAULT_CYCLE_LIMIT: NonZeroUsize = nonzero!(10_000_usize);
36
37#[derive(new)]
38pub struct Project {
39 path: PathBuf,
40 rust_analyzer_configuration: Option<PathBuf>,
41}
42
43pub enum Input {
44 Project(Project),
45 ScipFile(PathBuf),
46}
47
48enum PreparedInput {
49 Project(Project),
50 ScipFile { index: ParsedIndex, protected_input: InputFile },
51}
52
53impl TryFrom<Input> for PreparedInput {
54 type Error = anyhow::Error;
55
56 fn try_from(input: Input) -> Result<Self> {
57 match input {
58 Input::Project(project) => Ok(Self::Project(project)),
59 Input::ScipFile(path) => {
60 let mut protected_input = InputFile::open(&path)?;
61 let bytes = protected_input.read()?;
62 let index = ParsedIndex::parse(&bytes).context("Cannot load saved dependency analysis")?;
63 Ok(Self::ScipFile { index, protected_input })
64 }
65 }
66 }
67}
68
69#[derive(Builder)]
70pub struct CycleOptions {
71 #[builder(default)]
72 highlight_cycles: bool,
73 #[builder(default)]
74 fail_on_cycles: bool,
75 cycles_output: Option<PathBuf>,
76 file_cycles_output: Option<PathBuf>,
77 #[builder(default = DEFAULT_CYCLE_LIMIT)]
78 cycle_limit: NonZeroUsize,
79}
80
81#[derive(Builder)]
82pub struct OutgoingDependencyOptions {
83 maximum: usize,
84 #[builder(default = OutgoingDependencyMode::Folders)]
85 mode: OutgoingDependencyMode,
86 output: Option<PathBuf>,
87}
88
89pub struct Request {
90 input: PreparedInput,
91 root: PathBuf,
92 format: Format,
93 output: Option<PathBuf>,
94 depth: Option<usize>,
95 include_self: bool,
96 group_folders: bool,
97 exclude_tests: bool,
98 exclusions: Exclusions,
99 cycles: CycleOptions,
100 outgoing_dependencies: Option<OutgoingDependencyOptions>,
101 save_scip: Option<PathBuf>,
102 protected_inputs: Vec<InputFile>,
103 analyzer: AnalyzerOptions,
104}
105
106#[bon::bon]
107impl Request {
108 #[builder]
109 pub fn new(
110 input: Input,
111 #[builder(default = PathBuf::from("."))] root: PathBuf,
112 #[builder(default = Format::Dot)] format: Format,
113 output: Option<PathBuf>,
114 depth: Option<usize>,
115 #[builder(default)] include_self: bool,
116 #[builder(default)] group_folders: bool,
117 #[builder(default)] exclude_tests: bool,
118 #[builder(default)] exclusions: Exclusions,
119 #[builder(default = CycleOptions::builder().build())] cycles: CycleOptions,
120 outgoing_dependencies: Option<OutgoingDependencyOptions>,
121 save_scip: Option<PathBuf>,
122 #[builder(default)] protected_inputs: Vec<InputFile>,
123 #[builder(default = AnalyzerOptions::new(false))] analyzer: AnalyzerOptions,
124 ) -> Result<Self> {
125 ensure!(!matches!(input, Input::ScipFile(_)) || save_scip.is_none(), "Cannot save analysis when replaying a SCIP file");
126 let input = PreparedInput::try_from(input)?;
127 Ok(Self {
128 input, root, format, output, depth, include_self, group_folders, exclude_tests, exclusions,
129 cycles, outgoing_dependencies, save_scip, protected_inputs, analyzer,
130 })
131 }
132}
133
134pub fn run(request: &Request, diagram_output: &mut dyn Write) -> Result<()> {
135 let mut retained_inputs = Vec::new();
136 let (file_graph, saved_index, replay_input) = match request.input {
137 PreparedInput::ScipFile { ref index, ref protected_input } => (file_graph(index)?, None, Some(protected_input)),
138 PreparedInput::Project(ref project) => {
139 let configuration = if let Some(path) = project.rust_analyzer_configuration.as_deref() {
140 let mut input = InputFile::open(path)?;
141 let snapshot = snapshot_analyzer_configuration(&mut input)?;
142 retained_inputs.push(input);
143 Some(snapshot)
144 } else {
145 None
146 };
147 let configuration_path = configuration.as_ref().map(NamedTempFile::path);
148 let index = RustAnalyzer::new(&project.path, configuration_path, &request.analyzer).index_parsed()?;
149 let graph = file_graph(&index)?;
150 let saved_index = if let Some(path) = request.save_scip.as_deref() {
151 let bytes = index.into_index().write_to_bytes().context("Cannot serialize dependency analysis")?;
152 Some((path, bytes))
153 } else {
154 None
155 };
156 (graph, saved_index, None)
157 }
158 };
159 let protected_inputs: Vec<_> = retained_inputs.iter().chain(&request.protected_inputs).chain(replay_input).collect();
160 let saved_index_output = saved_index.as_ref().map(|&(path, ref bytes)| FileOutput::new(path, bytes));
161 let outputs = write_analysis_outputs().request(request).file_graph(file_graph).protected_inputs(&protected_inputs);
162 outputs.maybe_saved_index(saved_index_output).diagram_output(diagram_output).call()
163}
164
165fn snapshot_analyzer_configuration(input: &mut InputFile) -> Result<NamedTempFile> {
166 let mut snapshot = NamedTempFile::new().context("Cannot create analysis configuration snapshot")?;
167 let bytes = input.read()?;
168 snapshot.write_all(&bytes).context("Cannot write analysis configuration snapshot")?;
169 Ok(snapshot)
170}
171
172enum IndexCheckpoint<'a> {
173 NotRequested,
174 Saved { output_files: OutputFiles<'a> },
175}
176
177fn open_outputs_and_save_index<'a>(
178 request: &'a Request, index_save_file: Option<FileOutput<'a>>, protected_inputs: &[&InputFile],
179) -> Result<IndexCheckpoint<'a>> {
180 let Some(index_save_file) = index_save_file else { return Ok(IndexCheckpoint::NotRequested); };
181 let outgoing_report = request.outgoing_dependencies.as_ref().and_then(|options| options.output.as_deref());
182 let empty_output = |path| FileOutput::new(path, &[]);
183 let outputs = velcro::vec![
184 index_save_file,
185 ..request.cycles.cycles_output.as_deref().map(empty_output),
186 ..request.cycles.file_cycles_output.as_deref().map(empty_output),
187 ..outgoing_report.map(empty_output),
188 ..request.output.as_deref().map(empty_output),
189 ];
190 let mut prepared = OutputFiles::open(&outputs, protected_inputs)?;
191 prepared.write_output(&index_save_file)?;
192 emit(format_args!("Dependency analysis saved to {}", index_save_file.path().display()));
193 Ok(IndexCheckpoint::Saved { output_files: prepared })
194}
195
196#[bon::builder]
197fn write_analysis_outputs(
198 request: &Request,
199 file_graph: FileGraph,
200 saved_index: Option<FileOutput<'_>>,
201 protected_inputs: &[&InputFile],
202 diagram_output: &mut dyn Write,
203) -> Result<()> {
204 let mut checkpoint = open_outputs_and_save_index(request, saved_index, protected_inputs)?;
205 let file_graph = if request.exclude_tests { file_graph.without_test_dependencies() } else { file_graph };
206 let file_graph = file_graph.within_root(&request.root)?.excluding(&request.exclusions);
207 let folder_graph = file_graph.folders(&request.root, request.depth, request.include_self)?;
208 ensure!(!folder_graph.nodes().is_empty(), "{NO_FILES_AFTER_FILTERING}: root {}", request.root.display());
209 let cycles = &request.cycles;
210 let analyze_folder_cycles = cycles.highlight_cycles || cycles.cycles_output.is_some() || cycles.fail_on_cycles;
211 let (highlight_analysis, folder_report_output, folder_cycle_group_count) = if analyze_folder_cycles {
212 let analysis = analyze_folders(&folder_graph)?;
213 let report = if let Some(path) = cycles.cycles_output.as_ref() {
214 Some((path, folder_report(&analysis, cycles.cycle_limit)?))
215 } else {
216 None
217 };
218 let group_count = analysis.group_count();
219 (cycles.highlight_cycles.then_some(analysis), report, group_count)
220 } else {
221 (None, None, 0)
222 };
223 let analyze_file_cycles = cycles.file_cycles_output.is_some() || cycles.fail_on_cycles;
224 let (file_report_output, file_cycle_group_count) = if analyze_file_cycles {
225 let analysis = analyze_files(&file_graph)?;
226 let report = if let Some(path) = cycles.file_cycles_output.as_ref() {
227 Some((path, file_report(&analysis, cycles.cycle_limit)?))
228 } else {
229 None
230 };
231 (report, analysis.group_count())
232 } else {
233 (None, 0)
234 };
235 let (outgoing_analysis, outgoing_report_output) = if let Some(options) = request.outgoing_dependencies.as_ref() {
236 let analysis = match options.mode {
237 OutgoingDependencyMode::Files => OutgoingDependencyAnalysis::files(&file_graph, options.maximum)?,
238 OutgoingDependencyMode::Folders => OutgoingDependencyAnalysis::folders(&folder_graph, options.maximum),
239 };
240 let report = options.output.as_ref().map(|path| (path, analysis.markdown()));
241 (Some(analysis), report)
242 } else {
243 (None, None)
244 };
245 let mut diagram_bytes = Vec::new();
246 let exporter = request.format.exporter();
247 let options = ExportOptions::builder().group_folders(request.group_folders).maybe_cycles(highlight_analysis.as_ref()).build();
248 exporter.write_with_options(&folder_graph, &options, &mut diagram_bytes)?;
249
250 let mut outputs = Vec::new();
251 if let Some((path, ref report)) = folder_report_output {
252 outputs.push(FileOutput::new(path, report.as_bytes()));
253 }
254 if let Some((path, ref report)) = file_report_output {
255 outputs.push(FileOutput::new(path, report.as_bytes()));
256 }
257 if let Some((path, ref report)) = outgoing_report_output {
258 outputs.push(FileOutput::new(path, report.as_bytes()));
259 }
260 if let Some(path) = request.output.as_deref() {
261 outputs.push(FileOutput::new(path, &diagram_bytes));
262 }
263 match checkpoint {
264 IndexCheckpoint::Saved { ref mut output_files } => {
265 for output in &outputs {
266 output_files.write_output(output)?;
267 }
268 }
269 IndexCheckpoint::NotRequested => OutputFiles::open(&outputs, protected_inputs)?.write()?,
270 }
271 if request.output.is_none() {
272 diagram_output.write_all(&diagram_bytes)?;
273 }
274 let mut failures = Vec::new();
275 if cycles.fail_on_cycles && (folder_cycle_group_count != 0 || file_cycle_group_count != 0) {
276 failures.push(format!(
277 "Dependency cycles found: {folder_cycle_group_count} folder cycle group(s), \
278 {file_cycle_group_count} file cycle group(s)"
279 ));
280 }
281 if let Some(analysis) = outgoing_analysis && analysis.has_violations() {
282 failures.push(analysis.diagnostic());
283 }
284 ensure!(failures.is_empty(), "{}", failures.join("\n\n"));
285 Ok(())
286}
287
288#[cfg(test)]
289mod tests {
290 use std::fs;
291 use std::io;
292 use std::num::NonZeroUsize;
293 use std::path::Path;
294 use std::path::PathBuf;
295
296 use anyhow::Error;
297 use anyhow::Result;
298 use assertables::assert_contains;
299 use claims::assert_ok;
300 use claims::assert_some;
301 use derive_new::new;
302 use pretty_assertions::assert_eq;
303 use protobuf::Message as _;
304 use rstest::rstest;
305 use scip::types::Document;
306 use scip::types::Index;
307 use scip::types::Occurrence;
308 use scip::types::SymbolRole;
309 use tempfile::TempDir;
310 use tempfile::tempdir;
311
312 use super::CycleOptions;
313 use super::Input;
314 use super::NO_FILES_AFTER_FILTERING;
315 use super::OutgoingDependencyOptions;
316 use super::Project;
317 use super::Request;
318 use super::run;
319 use super::write_analysis_outputs;
320 use crate::Exclusions;
321 use crate::InputFile;
322 use crate::export::Format;
323 use crate::export::Options;
324 use crate::model::FileGraph;
325 use crate::outgoing_dependencies::Mode;
326 use crate::output_paths::FileOutput;
327 use crate::output_paths::OutputPathConflict;
328 use crate::scip::backend::parse_scip;
329
330 struct ReplayTestFixture {
331 directory: TempDir,
332 index: PathBuf,
333 saved_index: PathBuf,
334 index_bytes: Vec<u8>,
335 diagram: PathBuf,
336 file_report: PathBuf,
337 folder_report: PathBuf,
338 outgoing_report: PathBuf,
339 }
340
341 #[derive(new)]
342 struct ReplayRequestTestFixture {
343 fixture: ReplayTestFixture,
344 request: Request,
345 }
346
347 #[derive(new)]
348 struct AnalyzedProjectTestFixture {
349 fixture: ReplayTestFixture,
350 request: Request,
351 graph: FileGraph,
352 }
353
354 fn replay_bytes_test_fixture(index_bytes: Vec<u8>) -> ReplayTestFixture {
355 let directory = tempdir();
356 let directory = assert_ok!(directory, "Failed to create the replay fixture directory");
357 let fixture = ReplayTestFixture {
358 index: directory.path().join("index.scip"),
359 saved_index: directory.path().join("saved.scip"),
360 diagram: directory.path().join("diagram.dot"),
361 file_report: directory.path().join("files.md"),
362 folder_report: directory.path().join("folders.md"),
363 outgoing_report: directory.path().join("outgoing.md"),
364 directory, index_bytes,
365 };
366 let written = fs::write(&fixture.index, &fixture.index_bytes);
367 assert_ok!(written, "Failed to write the replay fixture index at {}", fixture.index.display());
368 fixture
369 }
370
371 fn replay_test_fixture(index: &Index) -> ReplayRequestTestFixture {
372 let bytes = index.write_to_bytes();
373 let bytes = assert_ok!(bytes, "Failed to serialize the replay fixture index");
374 let fixture = replay_bytes_test_fixture(bytes);
375 let request = Request::builder().input(Input::ScipFile(fixture.index.clone())).root(PathBuf::from("src")).build();
376 let request = assert_ok!(request, "Failed to construct the replay request from its fixture index");
377 ReplayRequestTestFixture::new(fixture, request)
378 }
379
380 #[must_use]
381 fn cycle_reports_test_fixture(file_report: &Path, folder_report: &Path) -> CycleOptions {
382 let options = CycleOptions::builder().file_cycles_output(file_report.to_path_buf());
383 options.cycles_output(folder_report.to_path_buf()).build()
384 }
385
386 #[must_use]
387 fn outgoing_options_test_fixture(output: Option<&Path>, maximum: usize, mode: Option<Mode>) -> OutgoingDependencyOptions {
388 let options = OutgoingDependencyOptions::builder().maximum(maximum).maybe_mode(mode);
389 options.maybe_output(output.map(Path::to_path_buf)).build()
390 }
391
392 fn write_outputs_test_fixture(paths: &[&Path], contents: &str) {
393 for path in paths {
394 let written = fs::write(path, contents);
395 assert_ok!(written, "Failed to initialize the existing output at {}", path.display());
396 }
397 }
398
399 fn read_outputs_test_fixture(paths: &[&Path]) -> Vec<String> {
400 paths.iter().map(|path| {
401 let contents = fs::read_to_string(path);
402 assert_ok!(contents, "Failed to read the output at {}", path.display())
403 }).collect()
404 }
405
406 fn output_alias_test_fixture(path: &Path, alias: bool) -> PathBuf {
407 if alias {
408 let output = path.with_extension("alias");
409 let linked = fs::hard_link(path, &output);
410 assert_ok!(linked, "Failed to create a hard link to {}", path.display());
411 output
412 } else {
413 path.to_path_buf()
414 }
415 }
416
417 #[must_use]
418 fn request_output_test_fixture(mut request: Request, output: PathBuf, outgoing_report: bool) -> Request {
419 if outgoing_report {
420 request.outgoing_dependencies = Some(outgoing_options_test_fixture(Some(&output), usize::MAX, None));
421 } else {
422 request.output = Some(output);
423 }
424 request
425 }
426
427 fn analyzed_project_test_fixture() -> AnalyzedProjectTestFixture {
428 let mut index = two_file_index_fixture(true);
429 let third_symbol = "rust-analyzer cargo fixture 0.0.0 third().";
430 let first = index.documents.first_mut();
431 let first = assert_some!(first, "The analysis fixture contains no source files");
432 let first_symbol = first.occurrences.first();
433 let first_symbol = assert_some!(first_symbol, "The first fixture file contains no symbol occurrences").symbol.clone();
434 first.occurrences.push(Occurrence { range: vec![2, 0, 5], symbol: third_symbol.into(), ..Occurrence::default() });
435 index.documents.push(Document {
436 relative_path: "src/third.rs".into(),
437 occurrences: vec![
438 Occurrence {
439 range: vec![0, 3, 8], symbol: third_symbol.into(),
440 symbol_roles: SymbolRole::Definition as i32, ..Occurrence::default()
441 },
442 Occurrence { range: vec![1, 0, 5], symbol: first_symbol, ..Occurrence::default() },
443 ],
444 ..Document::default()
445 });
446 let bytes = index.write_to_bytes();
447 let bytes = assert_ok!(bytes, "Failed to serialize the completed-analysis fixture");
448 let fixture = replay_bytes_test_fixture(bytes);
449 let graph = parse_scip(&fixture.index_bytes);
450 let graph = assert_ok!(graph, "Failed to parse the completed-analysis fixture into a file graph");
451 let project = Project::new(fixture.directory.path().to_path_buf(), None);
452 let cycles = cycle_reports_test_fixture(&fixture.file_report, &fixture.folder_report);
453 let request = Request::builder().input(Input::Project(project)).root(PathBuf::from("src"));
454 let request = request.save_scip(fixture.saved_index.clone()).output(fixture.diagram.clone()).cycles(cycles).build();
455 let request = assert_ok!(request, "Failed to construct the completed-analysis request");
456 AnalyzedProjectTestFixture::new(fixture, request, graph)
457 }
458
459 fn write_analyzed_outputs_test_fixture(
460 fixture: &ReplayTestFixture, request: &Request, graph: FileGraph, diagram: &mut dyn io::Write,
461 ) -> Result<()> {
462 let protected_inputs: Vec<_> = request.protected_inputs.iter().collect();
463 let outputs = write_analysis_outputs().request(request).file_graph(graph).protected_inputs(&protected_inputs);
464 let saved_index = FileOutput::new(&fixture.saved_index, &fixture.index_bytes);
465 outputs.saved_index(saved_index).diagram_output(diagram).call()
466 }
467
468 fn assert_saved_index_test_fixture(path: &Path, expected: &[u8]) {
469 let saved = fs::read(path);
470 let saved = assert_ok!(saved, "Failed to read the saved analysis at {}", path.display());
471
472 assert_eq!(saved, expected, "Unexpected checkpoint contents at {}", path.display());
473 }
474
475 #[rstest]
476 #[case::filtering(PathBuf::from("missing"), PathBuf::from("folders.md"), true)]
477 #[case::output_open(PathBuf::from("src"), Path::new("missing").join("folders.md"), false)]
478 fn test_analysis_checkpoint_failure_order(
479 #[case] root: PathBuf, #[case] folder_report: PathBuf, #[case] checkpoint_written: bool,
480 ) {
481 const CONTENTS_EXISTING: &str = "previous result";
482 let AnalyzedProjectTestFixture { fixture, mut request, graph } = analyzed_project_test_fixture();
483 request.root = root;
484 request.cycles.cycles_output = Some(fixture.directory.path().join(folder_report));
485 let reports: [&Path; 3] = [&fixture.diagram, &fixture.folder_report, &fixture.file_report];
486 write_outputs_test_fixture(
487 &[&fixture.saved_index, &fixture.diagram, &fixture.folder_report, &fixture.file_report], CONTENTS_EXISTING,
488 );
489 let mut diagram = Vec::new();
490
491 let system_under_test = write_analyzed_outputs_test_fixture(&fixture, &request, graph, &mut diagram);
492 let preserved = read_outputs_test_fixture(&reports);
493
494 let error = assert_some!(system_under_test.err(), "Output generation accepted an invalid path or empty root");
495 let expected_index = if checkpoint_written { &fixture.index_bytes } else { CONTENTS_EXISTING.as_bytes() };
496 if !checkpoint_written {
497 assert_eq!(error.downcast_ref::<io::Error>().map(io::Error::kind), Some(io::ErrorKind::NotFound), "{error:#}");
498 }
499 assert_saved_index_test_fixture(&fixture.saved_index, expected_index);
500 assert_eq!(preserved, [CONTENTS_EXISTING; 3], "Failed output generation changed existing reports");
501 assert!(diagram.is_empty());
502 }
503
504 #[test]
505 fn test_analysis_checkpoint_diagram_write_failure() {
506 let AnalyzedProjectTestFixture { fixture, mut request, graph } = analyzed_project_test_fixture();
507 request.output = None;
508 let mut diagram: &mut [u8] = &mut [];
509
510 let system_under_test = write_analyzed_outputs_test_fixture(&fixture, &request, graph, &mut diagram);
511 let reports = read_outputs_test_fixture(&[&fixture.folder_report, &fixture.file_report]);
512
513 let error = assert_some!(system_under_test.err(), "Writing a diagram to a zero-capacity sink unexpectedly succeeded");
514 assert_eq!(error.downcast_ref::<io::Error>().map(io::Error::kind), Some(io::ErrorKind::WriteZero), "{error:#}");
515 assert_saved_index_test_fixture(&fixture.saved_index, &fixture.index_bytes);
516 assert!(reports.iter().all(|report| !report.is_empty()));
517 }
518
519 #[rstest]
520 fn test_analysis_checkpoint_path_conflicts(
521 #[values("diagram", "folder", "file", "outgoing", "input")] target: &str,
522 #[values(false, true)] hard_link: bool,
523 ) {
524 const CONTENTS_EXISTING: &str = "previous result";
525 let AnalyzedProjectTestFixture { fixture, mut request, graph } = analyzed_project_test_fixture();
526 let outputs: [&Path; 4] = [&fixture.saved_index, &fixture.diagram, &fixture.folder_report, &fixture.file_report];
527 write_outputs_test_fixture(&outputs, CONTENTS_EXISTING);
528 let conflicting_path = output_alias_test_fixture(&fixture.saved_index, hard_link);
529 match target {
530 "input" => {
531 let opened = InputFile::open(&conflicting_path);
532 let input = assert_ok!(opened, "Failed to open the saved-index conflict fixture as a protected input");
533 request.protected_inputs.push(input);
534 }
535 "diagram" => request.output = Some(conflicting_path),
536 "folder" => request.cycles.cycles_output = Some(conflicting_path),
537 "file" => request.cycles.file_cycles_output = Some(conflicting_path),
538 "outgoing" => {
539 request.outgoing_dependencies = Some(outgoing_options_test_fixture(Some(&conflicting_path), 0, None));
540 }
541 _ => unreachable!("Unsupported output kind in the checkpoint fixture: {target}"),
542 }
543 request.root = PathBuf::from("missing");
544 let mut diagram = Vec::new();
545
546 let system_under_test = write_analyzed_outputs_test_fixture(&fixture, &request, graph, &mut diagram);
547 let preserved = read_outputs_test_fixture(&outputs);
548
549 let conflict = system_under_test.as_ref().is_err_and(Error::is::<OutputPathConflict>);
550 assert!(conflict, "Checkpoint path conflict was not reported: {system_under_test:?}");
551 assert_eq!(preserved, [CONTENTS_EXISTING; 4]);
552 assert!(diagram.is_empty());
553 }
554
555 #[test]
556 fn test_analysis_failure_before_checkpoint() {
557 const CONTENTS_EXISTING: &[u8] = b"previous index";
558 let fixture = tempdir();
559 let fixture = assert_ok!(fixture, "Failed to create the project-without-manifest fixture");
560 let saved_path = fixture.path().join("saved.scip");
561 let project = Project::new(fixture.path().to_path_buf(), None);
562 let request = Request::builder().input(Input::Project(project)).save_scip(saved_path.clone()).build();
563 let request = assert_ok!(request, "Request construction rejected a project before analysis");
564 let initialized = fs::write(&saved_path, CONTENTS_EXISTING);
565 assert_ok!(initialized, "Failed to initialize the previous saved index");
566 let mut diagram = Vec::new();
567
568 let system_under_test = run(&request, &mut diagram);
569
570 assert!(system_under_test.is_err(), "Analysis succeeded for a project without a manifest");
571 assert_saved_index_test_fixture(&saved_path, CONTENTS_EXISTING);
572 assert!(diagram.is_empty());
573 }
574
575 #[test]
576 fn test_saved_analysis_replay() {
577 let fixture = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("src").join("fixtures").join("dependency-graph.scip");
578 let index = fs::read(&fixture);
579 let index = assert_ok!(index, "Saved SCIP fixture must be readable: {}", fixture.display());
580 let graph = parse_scip(&index);
581 let graph = assert_ok!(graph, "Saved SCIP fixture must contain a valid dependency graph");
582 let root = PathBuf::from("src");
583 let within_root = graph.within_root(&root);
584 let within_root = assert_ok!(within_root, "Fixture graph must support the selected source root");
585 let folders = within_root.folders(&root, Some(1), false);
586 let folders = assert_ok!(folders, "Fixture graph must support depth-limited folder aggregation");
587 let mut expected = Vec::new();
588 let options = Options::builder().group_folders(true).build();
589 let export = Format::Mermaid.exporter().write_with_options(&folders, &options, &mut expected);
590 assert_ok!(export, "Expected grouped Mermaid diagram must render successfully");
591 let request = Request::builder().input(Input::ScipFile(fixture)).root(root).format(Format::Mermaid);
592 let system_under_test = request.depth(1).group_folders(true).build();
593 let system_under_test = assert_ok!(system_under_test, "Saved analysis must load during request construction");
594 let mut diagram = Vec::new();
595
596 let result = run(&system_under_test, &mut diagram);
597
598 assert_ok!(result, "Replaying saved analysis must produce a dependency diagram");
599 assert_eq!(diagram, expected);
600 assert_ne!(diagram, [] as [u8; 0]);
601 }
602
603 #[must_use]
604 fn two_file_index_fixture(cyclic: bool) -> Index {
605 let first_symbol = "rust-analyzer cargo fixture 0.0.0 first().";
606 let second_symbol = "rust-analyzer cargo fixture 0.0.0 second().";
607 let mut second_occurrences = vec![Occurrence {
608 range: vec![0, 3, 9],
609 symbol: second_symbol.into(),
610 symbol_roles: SymbolRole::Definition as i32,
611 ..Occurrence::default()
612 }];
613 if cyclic {
614 second_occurrences.push(Occurrence { range: vec![1, 0, 5], symbol: first_symbol.into(), ..Occurrence::default() });
615 }
616 Index {
617 documents: vec![
618 Document {
619 relative_path: "src/first.rs".into(),
620 occurrences: vec![
621 Occurrence {
622 range: vec![0, 3, 8],
623 symbol: first_symbol.into(),
624 symbol_roles: SymbolRole::Definition as i32,
625 ..Occurrence::default()
626 },
627 Occurrence { range: vec![1, 0, 6], symbol: second_symbol.into(), ..Occurrence::default() },
628 ],
629 ..Document::default()
630 },
631 Document {
632 relative_path: "src/second.rs".into(),
633 occurrences: second_occurrences,
634 ..Document::default()
635 },
636 ],
637 ..Index::default()
638 }
639 }
640
641 #[must_use]
642 fn outgoing_dependency_index_fixture() -> Index {
643 let targets = [
644 ("src/target/first.rs", "first", 0),
645 ("src/target/second.rs", "second", 0),
646 ("src/target/deep/third.rs", "third", 0),
647 ("src/testonly/test.rs", "test_only", SymbolRole::Test as i32),
648 ("outside/external.rs", "external", 0),
649 ];
650 let mut documents = Vec::new();
651 let mut references = Vec::new();
652 for (relative_path, name, symbol_roles) in targets {
653 let symbol = format!("rust-analyzer cargo fixture 0.0.0 {name}().");
654 references.push(Occurrence { symbol: symbol.clone(), symbol_roles, ..Occurrence::default() });
655 documents.push(Document {
656 relative_path: relative_path.into(),
657 occurrences: vec![Occurrence { symbol, symbol_roles: SymbolRole::Definition as i32, ..Occurrence::default() }],
658 ..Document::default()
659 });
660 }
661 documents.push(Document {
662 relative_path: "outside/entry.rs".into(),
663 occurrences: references.clone(),
664 ..Document::default()
665 });
666 documents.push(Document { relative_path: "src/app/entry.rs".into(), occurrences: references, ..Document::default() });
667 Index { documents, ..Index::default() }
668 }
669
670 #[rstest]
671 #[case::files_all(Mode::Files, ".", false, None, &[("outside/entry.rs", 5), ("src/app/entry.rs", 5)])]
672 #[case::folders_all(Mode::Folders, ".", false, None, &[("outside", 3), ("src/app", 4)])]
673 #[case::files_root(Mode::Files, "src", false, None, &[("src/app/entry.rs", 4)])]
674 #[case::folders_root(Mode::Folders, "src", false, None, &[("app", 3)])]
675 #[case::files_production(Mode::Files, "src", true, None, &[("src/app/entry.rs", 3)])]
676 #[case::folders_production(Mode::Folders, "src", true, None, &[("app", 2)])]
677 #[case::files_folded(Mode::Files, "src", true, Some(1), &[("src/app/entry.rs", 3)])]
678 #[case::folders_folded(Mode::Folders, "src", true, Some(1), &[])]
679 #[case::folders_folded_with_tests(Mode::Folders, "src", false, Some(1), &[("app", 2)])]
680 fn test_outgoing_dependency_graph_selection(
681 #[case] mode: Mode,
682 #[case] root: &str,
683 #[case] exclude_tests: bool,
684 #[case] depth: Option<usize>,
685 #[case] expected: &[(&str, usize)],
686 ) {
687 let fixture = replay_test_fixture(&outgoing_dependency_index_fixture());
688 let ReplayRequestTestFixture { fixture: _fixture, request: mut system_under_test } = fixture;
689 system_under_test.root = PathBuf::from(root);
690 system_under_test.exclude_tests = exclude_tests;
691 system_under_test.depth = depth;
692 system_under_test.outgoing_dependencies = Some(outgoing_options_test_fixture(None, 1, Some(mode)));
693 let expected_failure = !expected.is_empty();
694 let expected_lines: Vec<_> = expected.iter().map(|&(label, count)| {
695 let label = match mode {
696 Mode::Files => PathBuf::from_iter(label.split('/')).to_string_lossy().into_owned(),
697 Mode::Folders => label.to_owned(),
698 };
699 format!("- {label:?}: {count} outgoing dependencies (maximum: 1)")
700 }).collect();
701 let mut diagram = Vec::new();
702
703 let result = run(&system_under_test, &mut diagram);
704 let failed = result.is_err();
705 let diagnostic = result.err().map_or_else(String::new, |error| error.to_string());
706 let actual_lines: Vec<_> = diagnostic.lines().filter(|line| line.starts_with("- ")).collect();
707
708 assert_eq!(failed, expected_failure, "Unexpected graph-selection result: {diagnostic}");
709 assert_eq!(actual_lines, expected_lines, "Violations must reflect the selected graph after filtering and folding");
710 }
711
712 #[rstest]
713 #[case::disabled(false, None, true, 0, false)]
714 #[case::default_folders(true, None, false, 0, false)]
715 #[case::default_folder_self(true, None, true, 0, true)]
716 #[case::files_without_self(true, Some(Mode::Files), false, 0, true)]
717 #[case::files_with_self(true, Some(Mode::Files), true, 0, true)]
718 #[case::folder_equality(true, Some(Mode::Folders), true, 1, false)]
719 #[case::file_equality(true, Some(Mode::Files), false, 1, false)]
720 fn test_outgoing_dependency_gate(
721 #[case] enabled: bool,
722 #[case] mode: Option<Mode>,
723 #[case] include_self: bool,
724 #[case] maximum: usize,
725 #[case] expected_failure: bool,
726 ) {
727 let fixture = replay_test_fixture(&two_file_index_fixture(false));
728 let ReplayRequestTestFixture { fixture: _fixture, request: mut system_under_test } = fixture;
729 system_under_test.include_self = include_self;
730 system_under_test.outgoing_dependencies = enabled.then(|| outgoing_options_test_fixture(None, maximum, mode));
731 let mut diagram = Vec::new();
732
733 let result = run(&system_under_test, &mut diagram);
734 let failed = result.is_err();
735
736 assert_eq!(failed, expected_failure, "Unexpected outgoing threshold result: {result:?}");
737 if let Err(error) = result {
738 let diagnostic = error.to_string();
739 assert_contains!(diagnostic, "Outgoing dependency threshold exceeded", "Unexpected gate failure: {diagnostic}");
740 }
741 }
742
743 #[rstest]
744 #[case::at_limit(1, false)]
745 #[case::above_limit(0, true)]
746 fn test_outgoing_dependency_outputs(#[case] maximum: usize, #[case] expected_failure: bool) {
747 const CONTENTS_EXISTING: &str = "preserved";
748 let fixture = replay_test_fixture(&two_file_index_fixture(false));
749 let ReplayRequestTestFixture { fixture, request: mut system_under_test } = fixture;
750 let outputs: [&Path; 2] = [&fixture.diagram, &fixture.outgoing_report];
751 write_outputs_test_fixture(&outputs, CONTENTS_EXISTING);
752 system_under_test.output = Some(fixture.diagram.clone());
753 let outgoing = outgoing_options_test_fixture(Some(&fixture.outgoing_report), maximum, Some(Mode::Files));
754 system_under_test.outgoing_dependencies = Some(outgoing);
755 let mut diagram = Vec::new();
756
757 let result = run(&system_under_test, &mut diagram);
758 let exported = read_outputs_test_fixture(&outputs);
759 let replaced: Vec<_> = exported.iter().map(|contents| !contents.is_empty() && contents != CONTENTS_EXISTING).collect();
760 let failed = result.is_err();
761
762 assert_eq!(failed, expected_failure, "Unexpected outgoing threshold result: {result:?}");
763 assert_eq!(replaced, [true; 2], "Both outputs must be replaced before gating: {exported:?}");
764 assert_eq!(diagram, [] as [u8; 0], "An output-file request must not also write to the supplied writer");
765 }
766
767 #[rstest]
768 #[case::cyclic_neither(true, false, false, None)]
769 #[case::cyclic_report_only(true, true, false, None)]
770 #[case::cyclic_gate_only(true, false, true, Some(1))]
771 #[case::cyclic_report_and_gate(true, true, true, Some(1))]
772 #[case::acyclic_neither(false, false, false, None)]
773 #[case::acyclic_report_only(false, true, false, None)]
774 #[case::acyclic_gate_only(false, false, true, None)]
775 #[case::acyclic_report_and_gate(false, true, true, None)]
776 fn test_file_cycle_report_and_gate_flags(
777 #[case] cyclic: bool,
778 #[case] report_requested: bool,
779 #[case] fail_on_cycles: bool,
780 #[case] expected_file_cycle_groups: Option<usize>,
781 ) {
782 let fixture = replay_test_fixture(&two_file_index_fixture(cyclic));
783 let ReplayRequestTestFixture { fixture, request: mut system_under_test } = fixture;
784 system_under_test.cycles.fail_on_cycles = fail_on_cycles;
785 system_under_test.cycles.file_cycles_output = report_requested.then(|| fixture.file_report.clone());
786 system_under_test.include_self = false;
788 let expected_error = expected_file_cycle_groups.map(|groups| {
789 format!("Dependency cycles found: 0 folder cycle group(s), {groups} file cycle group(s)")
790 });
791 let mut diagram = Vec::new();
792
793 let result = run(&system_under_test, &mut diagram);
794
795 let actual_error = result.err().map(|error| error.to_string());
796 assert_eq!(actual_error, expected_error);
797 assert!(!diagram.is_empty(), "Cycle gating must happen after diagram output is written");
798 let report_exists = fixture.file_report.try_exists();
799 let report_exists = assert_ok!(report_exists, "File-cycle report path must be inspectable");
800 assert_eq!(report_exists, report_requested, "Only a requested file-cycle report should be written");
801 if report_requested {
802 let report = fs::read_to_string(&fixture.file_report);
803 let report = assert_ok!(report, "Requested file-cycle report must be readable");
804 let cycle_groups = report.lines().filter(|line| line.starts_with("## ")).count();
805 let expected_groups = usize::from(cyclic);
806 assert_eq!(cycle_groups, expected_groups, "Report requests must trigger file-cycle analysis independently of gating");
807 }
808 }
809
810 #[rstest]
811 #[case::report_only(false, 2, [false, false])]
812 #[case::cycles_only(true, 2, [true, false])]
813 #[case::outgoing_only(false, 0, [false, true])]
814 #[case::both(true, 0, [true, true])]
815 fn test_combined_dependency_gates(#[case] fail_on_cycles: bool, #[case] maximum: usize, #[case] expected_reasons: [bool; 2]) {
816 let AnalyzedProjectTestFixture { fixture, request: mut system_under_test, graph } = analyzed_project_test_fixture();
817 system_under_test.output = None;
818 system_under_test.include_self = true;
819 system_under_test.cycles.cycle_limit = NonZeroUsize::MIN;
820 system_under_test.cycles.fail_on_cycles = fail_on_cycles;
821 let outgoing = outgoing_options_test_fixture(Some(&fixture.outgoing_report), maximum, Some(Mode::Files));
822 system_under_test.outgoing_dependencies = Some(outgoing);
823 let mut diagram = Vec::new();
824
825 let result = write_analyzed_outputs_test_fixture(&fixture, &system_under_test, graph, &mut diagram);
826 assert_eq!(result.is_err(), expected_reasons.contains(&true), "Unexpected gate result: {result:?}");
827 let diagnostic = result.err().map_or_else(String::new, |error| error.to_string());
828 let reasons = ["Dependency cycles found:", "Outgoing dependency threshold exceeded"];
829 let actual_reasons = reasons.map(|reason| diagnostic.contains(reason));
830 let reports = read_outputs_test_fixture(&[&fixture.folder_report, &fixture.file_report, &fixture.outgoing_report]);
831 let cycle_listings: Vec<_> = reports.iter().take(2).map(|report| {
832 let chain_count = report.lines().filter(|line| line.starts_with("- ")).count();
833 (chain_count, report.contains("cycle listing truncated"))
834 }).collect();
835
836 assert_eq!(actual_reasons, expected_reasons, "Dependency gate failure reasons differ: {diagnostic}");
837 assert_saved_index_test_fixture(&fixture.saved_index, &fixture.index_bytes);
838 assert_eq!(cycle_listings, [(1, false), (1, true)], "Incorrect folder/file chain counts or truncation markers");
839 assert!(reports.iter().all(|report| !report.is_empty()), "An exported dependency report is empty");
840 assert!(!diagram.is_empty(), "The exported diagram is empty");
841 }
842
843 #[rstest]
844 #[case::matching("src/second.rs", false)]
845 #[case::project_relative("second.rs", true)]
846 fn test_exclusions_and_checks(
847 #[case] pattern: &str,
848 #[case] expected_failure: bool,
849 #[values(Mode::Files, Mode::Folders)] mode: Mode,
850 ) {
851 let fixture = replay_test_fixture(&two_file_index_fixture(true));
852 let ReplayRequestTestFixture { fixture, request: mut system_under_test } = fixture;
853 let exclusions = Exclusions::new(&[pattern.to_owned()]);
854 system_under_test.exclusions = assert_ok!(exclusions, "Replay exclusion patterns must compile");
855 system_under_test.include_self = true;
856 system_under_test.cycles = cycle_reports_test_fixture(&fixture.file_report, &fixture.folder_report);
857 system_under_test.cycles.highlight_cycles = true;
858 system_under_test.cycles.fail_on_cycles = true;
859 let outgoing = outgoing_options_test_fixture(Some(&fixture.outgoing_report), 0, Some(mode));
860 system_under_test.outgoing_dependencies = Some(outgoing);
861 let expected_groups = usize::from(expected_failure);
862 let expected_sources = if expected_failure { match mode { Mode::Files => 2, Mode::Folders => 1 } } else { 0 };
863 let mut diagram = Vec::new();
864
865 let result = run(&system_under_test, &mut diagram);
866 let reports = read_outputs_test_fixture(&[&fixture.file_report, &fixture.folder_report]);
867 let groups: Vec<_> = reports.iter().map(|report| report.lines().filter(|line| line.starts_with("## ")).count()).collect();
868 let outgoing_contents = fs::read_to_string(&fixture.outgoing_report);
869 let outgoing_contents = assert_ok!(outgoing_contents, "Outgoing counts must be written for the filtered replay graph");
870 let violating_sources = outgoing_contents.lines().filter(|line| line.starts_with("- ")).count();
871 let failed = result.is_err();
872
873 assert_eq!(failed, expected_failure, "Exclusions did not affect dependency checks as expected: {result:?}");
874 assert_eq!(groups, [expected_groups; 2], "File and folder cycles must use the filtered graph");
875 assert_eq!(violating_sources, expected_sources, "Outgoing counts must use the filtered graph");
876 }
877
878 #[test]
879 fn test_exclusions_saved_replay() {
880 let fixture = replay_test_fixture(&two_file_index_fixture(true));
881 let ReplayRequestTestFixture { fixture, request: mut system_under_test } = fixture;
882 let exclusions = Exclusions::new(&["src/second.rs".to_owned()]);
883 system_under_test.exclusions = assert_ok!(exclusions, "Replay exclusion patterns must compile");
884 system_under_test.include_self = true;
885 let mut diagram = Vec::new();
886
887 let result = run(&system_under_test, &mut diagram);
888 assert_ok!(result, "Filtered replay must export its remaining graph");
889 system_under_test.exclusions = Exclusions::default();
890 let mut replayed_diagram = Vec::new();
891 let replay = run(&system_under_test, &mut replayed_diagram);
892 assert_ok!(replay, "The same saved index must support replay with different filters");
893 let preserved = fs::read(&fixture.index);
894 let preserved = assert_ok!(preserved, "The saved index must remain readable after changing replay filters");
895
896 assert_ne!(diagram, replayed_diagram, "Clearing exclusions must restore the original graph");
897 assert_eq!(preserved, fixture.index_bytes, "Exclusions must not rewrite the saved index");
898 }
899
900 #[test]
901 fn test_exclusions_all_files() {
902 const CONTENTS_EXISTING: &str = "preserved";
903 let fixture = replay_test_fixture(&two_file_index_fixture(false));
904 let ReplayRequestTestFixture { fixture, request: mut system_under_test } = fixture;
905 let outputs: [&Path; 3] = [&fixture.diagram, &fixture.file_report, &fixture.outgoing_report];
906 write_outputs_test_fixture(&outputs, CONTENTS_EXISTING);
907 let exclusions = Exclusions::new(&["src/**".to_owned()]);
908 system_under_test.exclusions = assert_ok!(exclusions, "A whole-root exclusion must compile");
909 system_under_test.output = Some(fixture.diagram.clone());
910 system_under_test.cycles = cycle_reports_test_fixture(&fixture.file_report, &fixture.folder_report);
911 system_under_test.outgoing_dependencies = Some(outgoing_options_test_fixture(Some(&fixture.outgoing_report), 0, None));
912 let mut diagram = Vec::new();
913
914 let error = run(&system_under_test, &mut diagram).err();
915 let error = assert_some!(error, "Excluding every indexed file must fail before opening outputs");
916 let diagnostic = error.to_string();
917 let preserved = read_outputs_test_fixture(&outputs);
918 let report_exists = fixture.folder_report.try_exists();
919 let report_exists = assert_ok!(report_exists, "The unwritten folder-report path must be inspectable");
920
921 assert!(diagnostic.starts_with(NO_FILES_AFTER_FILTERING), "The error must explain filtering: {diagnostic}");
922 assert_eq!(preserved, [CONTENTS_EXISTING; 3], "An empty filtered graph replaced an existing output");
923 assert!(!report_exists, "An empty filtered graph created a report");
924 assert!(diagram.is_empty(), "An empty filtered graph wrote diagram bytes");
925 }
926
927 #[rstest]
928 #[case::readable_input(false)]
929 #[case::missing_input(true)]
930 fn test_replay_cannot_save_analysis(#[case] missing_input: bool) {
931 let ReplayRequestTestFixture { fixture, request: _request } = replay_test_fixture(&two_file_index_fixture(false));
932 let output = fixture.saved_index;
933 let initialized = fs::write(&output, b"preserved");
934 assert_ok!(initialized, "Existing analysis output must be initialized separately from the replay input");
935 let input = if missing_input { fixture.directory.path().join("missing.scip") } else { fixture.index.clone() };
936 let system_under_test = Request::builder().input(Input::ScipFile(input)).save_scip(output.clone());
937
938 let request = system_under_test.build();
939 let preserved = fs::read(&output);
940 let input_bytes = fs::read(&fixture.index);
941
942 let error = assert_some!(request.err(), "Request construction must reject saving replayed analysis");
943 assert!(!error.is::<std::io::Error>(), "Conflicting options must be rejected before input I/O: {error:#}");
944 let preserved = assert_ok!(preserved, "Rejected replay must leave the existing analysis output readable");
945 let input_bytes = assert_ok!(input_bytes, "Rejected replay must leave the source index readable");
946 assert_eq!(preserved, b"preserved", "Rejected replay must preserve the existing output");
947 assert_eq!(input_bytes, fixture.index_bytes, "Rejected replay must preserve its source index");
948 }
949
950 #[rstest]
951 #[case::missing(false)]
952 #[case::directory(true)]
953 fn test_replay_input_io_at_construction(#[case] directory_input: bool) {
954 let fixture = tempdir();
955 let fixture = assert_ok!(fixture, "The request construction fixture must be created");
956 let path = if directory_input { fixture.path().to_path_buf() } else { fixture.path().join("missing.scip") };
957 let system_under_test = Request::builder().input(Input::ScipFile(path.clone()));
958
959 let error = system_under_test.build().err();
960 let error = assert_some!(error, "An unreadable saved index must fail before execution");
961 let diagnostic = format!("{error:#}");
962
963 assert!(error.is::<std::io::Error>(), "Input failure must preserve its I/O cause: {diagnostic}");
964 assert_contains!(diagnostic, &path.to_string_lossy().into_owned(), "Input failure must identify its path: {diagnostic}");
965 }
966
967 #[rstest]
968 #[case::overwrite_contents(false)]
969 #[case::replace_path(true)]
970 fn test_replay_snapshot_at_construction(#[case] replace_path: bool) {
971 let fixture = replay_test_fixture(&two_file_index_fixture(false));
972 let ReplayRequestTestFixture { fixture, request: system_under_test } = fixture;
973 if replace_path {
974 let renamed = fs::rename(&fixture.index, fixture.directory.path().join("retained.scip"));
975 assert_ok!(renamed, "The loaded index must be renamed before replacing its path");
976 }
977 let changed = fs::write(&fixture.index, b"\xff");
978 assert_ok!(changed, "The index path must contain malformed data before the first run");
979 let mut diagram = Vec::new();
980 let mut repeated_diagram = Vec::new();
981
982 let result = run(&system_under_test, &mut diagram);
983 let repeated = run(&system_under_test, &mut repeated_diagram);
984 let reloaded = Request::builder().input(Input::ScipFile(fixture.index)).build();
985
986 assert_ok!(result, "Execution must use the snapshot captured by build, not the changed file");
987 assert_ok!(repeated, "The same request must support repeated execution without rereading the file");
988 assert!(!diagram.is_empty(), "The parsed snapshot must still produce a diagram");
989 assert_eq!(diagram, repeated_diagram, "Repeated execution must use the same saved analysis");
990 assert!(reloaded.is_err(), "A new request must load the changed file instead of reusing another request's snapshot");
991 }
992
993 #[test]
994 fn test_renamed_replay_input_protection() {
995 let fixture = replay_test_fixture(&two_file_index_fixture(false));
996 let ReplayRequestTestFixture { fixture, request: mut system_under_test } = fixture;
997 let retained = fixture.directory.path().join("retained.scip");
998 let renamed = fs::rename(&fixture.index, &retained);
999 assert_ok!(renamed, "The loaded index must be renamed while its identity is retained");
1000 let replaced = fs::write(&fixture.index, b"replacement");
1001 assert_ok!(replaced, "The original input path must contain a different file before execution");
1002 system_under_test.output = Some(retained.clone());
1003 let mut diagram = Vec::new();
1004
1005 let result = run(&system_under_test, &mut diagram);
1006 let preserved = fs::read(&retained);
1007 let replacement = fs::read(&fixture.index);
1008
1009 assert!(result.as_ref().is_err_and(Error::is::<OutputPathConflict>), "The retained input must be protected: {result:?}");
1010 let preserved = assert_ok!(preserved, "The renamed index must remain readable after rejecting output");
1011 let replacement = assert_ok!(replacement, "The replacement file must remain readable after rejecting output");
1012 assert_eq!(preserved, fixture.index_bytes, "Output protection must follow the original file's identity");
1013 assert_eq!(replacement, b"replacement", "Output protection must not modify the replacement file");
1014 assert!(diagram.is_empty(), "An input conflict must not write a diagram");
1015 }
1016
1017 #[rstest]
1018 #[case::same_path(false)]
1019 #[case::hard_link(true)]
1020 fn test_replay_cannot_overwrite_input(#[case] alias: bool, #[values(false, true)] outgoing_report: bool) {
1021 let ReplayRequestTestFixture { fixture, request } = replay_test_fixture(&two_file_index_fixture(false));
1022 let output = output_alias_test_fixture(&fixture.index, alias);
1023 let system_under_test = request_output_test_fixture(request, output, outgoing_report);
1024 let mut diagram = Vec::new();
1025
1026 let result = run(&system_under_test, &mut diagram);
1027 let preserved = fs::read(&fixture.index);
1028 let preserved = assert_ok!(preserved, "Protected SCIP input must remain readable after replay rejection");
1029 let conflict = result.as_ref().is_err_and(Error::is::<OutputPathConflict>);
1030
1031 assert!(conflict, "Replay must protect input aliases: {result:?}");
1032 assert_eq!(preserved, fixture.index_bytes);
1033 assert_eq!(diagram, [] as [u8; 0]);
1034 }
1035
1036 #[rstest]
1037 #[case::configuration_path(true, false, false)]
1038 #[case::configuration_alias(true, true, false)]
1039 #[case::configuration_renamed(true, false, true)]
1040 #[case::index_path(false, false, false)]
1041 #[case::index_alias(false, true, false)]
1042 fn test_request_protected_inputs(
1043 #[case] configuration_target: bool,
1044 #[case] alias: bool,
1045 #[case] renamed: bool,
1046 #[values(false, true)] outgoing_report: bool,
1047 ) {
1048 const CONTENTS_CONFIGURATION: &[u8] = b"# protected configuration\n";
1049 const CONTENTS_REPLACEMENT: &[u8] = b"# replacement configuration\n";
1050 let ReplayRequestTestFixture { fixture, mut request } = replay_test_fixture(&two_file_index_fixture(false));
1051 let configuration = fixture.directory.path().join("source-mesh.toml");
1052 let retained_configuration = fixture.directory.path().join("retained.toml");
1053 let configuration_write = fs::write(&configuration, CONTENTS_CONFIGURATION);
1054 assert_ok!(configuration_write, "Protected configuration must be written before loading");
1055 let opened_configuration = InputFile::open(&configuration);
1056 let mut opened_configuration = assert_ok!(opened_configuration, "Configuration must open before request construction");
1057 let loaded = opened_configuration.read();
1058 let loaded = assert_ok!(loaded, "Configuration contents must be read from its retained handle");
1059 assert_eq!(CONTENTS_CONFIGURATION, loaded, "The retained handle must identify the loaded configuration");
1060 let configuration_path = if renamed {
1061 let moved = fs::rename(&configuration, &retained_configuration);
1062 assert_ok!(moved, "Loaded configuration must be renamed while its identity is retained");
1063 let replacement_write = fs::write(&configuration, CONTENTS_REPLACEMENT);
1064 assert_ok!(replacement_write, "The original configuration path must be replaced before output validation");
1065 &retained_configuration
1066 } else {
1067 &configuration
1068 };
1069 let protected_path = if configuration_target { configuration_path } else { &fixture.index };
1070 let output = output_alias_test_fixture(protected_path, alias);
1071 request.protected_inputs = vec![opened_configuration];
1072 let system_under_test = request_output_test_fixture(request, output, outgoing_report);
1073 let mut diagram = Vec::new();
1074
1075 let result = run(&system_under_test, &mut diagram);
1076 let preserved_index = fs::read(&fixture.index);
1077 let preserved_index = assert_ok!(preserved_index, "Replay index must remain readable after a protected-input conflict");
1078 let preserved_configuration = fs::read(configuration_path);
1079 let preserved_configuration = assert_ok!(preserved_configuration, "The loaded configuration must remain readable");
1080
1081 let conflict = result.as_ref().is_err_and(Error::is::<OutputPathConflict>);
1082 assert!(conflict, "Output validation must protect both request-owned and locally opened inputs: {result:?}");
1083 assert_eq!(fixture.index_bytes, preserved_index, "Output validation changed the replay index");
1084 assert_eq!(CONTENTS_CONFIGURATION, preserved_configuration, "Output validation changed the loaded configuration");
1085 if renamed {
1086 let replacement = fs::read(configuration);
1087 let replacement = assert_ok!(replacement, "The replacement configuration must remain readable");
1088 assert_eq!(CONTENTS_REPLACEMENT, replacement, "Output validation changed the replacement configuration");
1089 }
1090 assert!(diagram.is_empty(), "An input conflict must be detected before writing diagram bytes");
1091 }
1092
1093 #[rstest]
1094 #[case::empty(b"")]
1095 #[case::malformed(b"\xff")]
1096 #[case::metadata_without_documents(b"\x0a\x00")]
1097 fn test_invalid_index_preserves_outputs(#[case] bytes: &[u8], #[values(false, true)] existing_report: bool) {
1098 const CONTENTS_EXISTING: &str = "preserved";
1099 let fixture = replay_bytes_test_fixture(bytes.to_vec());
1100 let mut existing_outputs = vec![fixture.diagram.as_path()];
1101 if existing_report { existing_outputs.push(&fixture.outgoing_report); }
1102 write_outputs_test_fixture(&existing_outputs, CONTENTS_EXISTING);
1103 let cycles = cycle_reports_test_fixture(&fixture.file_report, &fixture.folder_report);
1104 let outgoing = outgoing_options_test_fixture(Some(&fixture.outgoing_report), 0, None);
1105 let request = Request::builder().input(Input::ScipFile(fixture.index.clone()));
1106 let system_under_test = request.output(fixture.diagram.clone()).cycles(cycles).outgoing_dependencies(outgoing);
1107
1108 let result = system_under_test.build();
1109 let preserved = read_outputs_test_fixture(&existing_outputs);
1110 let expected = vec![CONTENTS_EXISTING; existing_outputs.len()];
1111 let reports = [&fixture.folder_report, &fixture.file_report, &fixture.outgoing_report];
1112 let reports_exist = reports.map(|path| {
1113 let exists = path.try_exists();
1114 assert_ok!(exists, "Report path must be inspectable: {}", path.display())
1115 });
1116
1117 assert!(result.is_err(), "Malformed external analysis must fail during request construction");
1118 assert_eq!(preserved, expected, "Invalid input must not replace an existing output");
1119 assert_eq!(reports_exist, [false, false, existing_report], "Invalid input must not create any report");
1120 }
1121
1122 #[rstest]
1123 #[case::empty("")]
1124 #[case::parent("../outside.rs")]
1125 #[case::absolute("/absolute.rs")]
1126 fn test_invalid_source_path_preserves_outputs(#[case] path: &str) {
1127 let index = Index { documents: vec![Document { relative_path: path.into(), ..Document::default() }], ..Index::default() };
1128 let bytes = index.write_to_bytes();
1129 let bytes = assert_ok!(bytes, "The invalid-source-path index must serialize");
1130 let fixture = replay_bytes_test_fixture(bytes);
1131 let system_under_test = Request::builder().input(Input::ScipFile(fixture.index.clone())).output(fixture.diagram.clone());
1132
1133 let result = system_under_test.build();
1134
1135 assert!(result.is_err(), "Malformed external source paths must fail during request construction");
1136 let output_exists = fixture.diagram.try_exists();
1137 let output_exists = assert_ok!(output_exists, "Diagram output path must be inspectable");
1138 assert!(!output_exists, "Invalid input created a diagram");
1139 }
1140
1141 #[rstest]
1142 #[case::same_path(false)]
1143 #[case::hard_link(true)]
1144 fn test_conflicting_outputs_preserve_files(#[case] alias: bool, #[values(false, true)] outgoing_report: bool) {
1145 const CONTENTS_EXISTING: &str = "preserved";
1146 let fixture = replay_test_fixture(&two_file_index_fixture(false));
1147 let ReplayRequestTestFixture { fixture, request: mut system_under_test } = fixture;
1148 let outputs: [&Path; 2] = [&fixture.diagram, &fixture.file_report];
1149 write_outputs_test_fixture(&outputs, CONTENTS_EXISTING);
1150 let conflicting_report = output_alias_test_fixture(&fixture.diagram, alias);
1151 system_under_test.output = Some(fixture.diagram.clone());
1152 system_under_test.cycles.file_cycles_output = Some(fixture.file_report.clone());
1153 if outgoing_report {
1154 let outgoing = outgoing_options_test_fixture(Some(&conflicting_report), usize::MAX, None);
1155 system_under_test.outgoing_dependencies = Some(outgoing);
1156 } else {
1157 system_under_test.cycles.cycles_output = Some(conflicting_report);
1158 }
1159 let mut diagram = Vec::new();
1160
1161 let result = run(&system_under_test, &mut diagram);
1162 let preserved = read_outputs_test_fixture(&outputs);
1163 let conflict = result.as_ref().is_err_and(Error::is::<OutputPathConflict>);
1164
1165 assert!(conflict, "Replay must reject output aliases: {result:?}");
1166 assert_eq!(preserved, [CONTENTS_EXISTING; 2]);
1167 assert_eq!(diagram, [] as [u8; 0]);
1168 }
1169}