Skip to main content

source_mesh_core/
application.rs

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        /* Same-folder files and disabled self-edges keep the folder gate from masking skipped file analysis. */
787        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}