rust: add testing method for ouput writers

Author: rizsotto

rust/bear/src/output/clang/mod.rs

@@ -174,34 +174,170 @@ impl<T: IteratorWriter<Entry>> IteratorWriter<Entry> for AtomicClangOutputWriter
 /// Responsible for writing a JSON compilation database file from the given entries.
 ///
 /// # Features
-/// - Writes the entries to a file.
 /// - Filters duplicates based on the provided configuration.
-pub(super) struct ClangOutputWriter {
-    output: io::BufWriter<fs::File>,
+pub(super) struct UniqueOutputWriter<T: IteratorWriter<Entry>> {
+    writer: T,
     filter: filter_duplicates::DuplicateFilter,
 }
 
-impl TryFrom<(&path::Path, &config::DuplicateFilter)> for ClangOutputWriter {
-    type Error = anyhow::Error;
+impl<T: IteratorWriter<Entry>> UniqueOutputWriter<T> {
+    pub(super) fn create(writer: T, config: &config::DuplicateFilter) -> anyhow::Result<Self> {
+        let filter = filter_duplicates::DuplicateFilter::try_from(config.clone())
+            .with_context(|| format!("Failed to create duplicate filter: {:?}", config))?;
+
+        Ok(Self { writer, filter })
+    }
+}
+
+impl<T: IteratorWriter<Entry>> IteratorWriter<Entry> for UniqueOutputWriter<T> {
+    fn write(self, entries: impl Iterator<Item = Entry>) -> anyhow::Result<()> {
+        let mut filter = self.filter.clone();
+        let filtered_entries = entries.filter(move |entry| filter.unique(entry));
+
+        self.writer.write(filtered_entries)
+    }
+}
 
-    fn try_from(value: (&path::Path, &config::DuplicateFilter)) -> Result<Self, Self::Error> {
-        let (file_name, config) = value;
+/// Responsible for writing a JSON compilation database file from the given entries.
+///
+/// # Features
+/// - Writes the entries to a file.
+pub(super) struct ClangOutputWriter {
+    output: io::BufWriter<fs::File>,
+}
 
+impl ClangOutputWriter {
+    pub(super) fn create(file_name: &path::Path) -> anyhow::Result<Self> {
         let output = fs::File::create(file_name)
             .map(io::BufWriter::new)
             .with_context(|| format!("Failed to open file: {:?}", file_name))?;
 
-        let filter = filter_duplicates::DuplicateFilter::try_from(config.clone())?;
-
-        Ok(Self { output, filter })
+        Ok(Self { output })
     }
 }
 
 impl IteratorWriter<Entry> for ClangOutputWriter {
     fn write(self, entries: impl Iterator<Item = Entry>) -> anyhow::Result<()> {
-        let mut filter = self.filter.clone();
-        let filtered_entries = entries.filter(move |entry| filter.unique(entry));
-        JsonCompilationDatabase::write(self.output, filtered_entries)?;
+        JsonCompilationDatabase::write(self.output, entries)?;
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs::{self};
+    use tempfile::tempdir;
+
+    struct MockWriter;
+
+    impl IteratorWriter<Entry> for MockWriter {
+        fn write(self, _: impl Iterator<Item = Entry>) -> anyhow::Result<()> {
+            Ok(())
+        }
+    }
+
+    #[test]
+    fn test_atomic_clang_output_writer_success() {
+        let dir = tempdir().unwrap();
+        let temp_file_path = dir.path().join("temp_file.json");
+        let final_file_path = dir.path().join("final_file.json");
+
+        // Create the temp file
+        fs::File::create(&temp_file_path).unwrap();
+
+        let sut = AtomicClangOutputWriter::new(MockWriter, &temp_file_path, &final_file_path);
+        sut.write(std::iter::empty()).unwrap();
+
+        // Verify the final file exists
+        assert!(final_file_path.exists());
+        assert!(!temp_file_path.exists());
+    }
+
+    #[test]
+    fn test_atomic_clang_output_writer_temp_file_missing() {
+        let dir = tempdir().unwrap();
+        let temp_file_path = dir.path().join("temp_file.json");
+        let final_file_path = dir.path().join("final_file.json");
+
+        let sut = AtomicClangOutputWriter::new(MockWriter, &temp_file_path, &final_file_path);
+        let result = sut.write(std::iter::empty());
+
+        // Verify the operation fails
+        assert!(result.is_err());
+        assert!(!final_file_path.exists());
+    }
+
+    #[test]
+    fn test_atomic_clang_output_writer_final_file_exists() {
+        let dir = tempdir().unwrap();
+        let temp_file_path = dir.path().join("temp_file.json");
+        let final_file_path = dir.path().join("final_file.json");
+
+        // Create the temp file and final file
+        fs::File::create(&temp_file_path).unwrap();
+        fs::File::create(&final_file_path).unwrap();
+
+        let sut = AtomicClangOutputWriter::new(MockWriter, &temp_file_path, &final_file_path);
+        let result = sut.write(std::iter::empty());
+
+        // Verify the operation fails
+        assert!(result.is_ok());
+        assert!(final_file_path.exists());
+        assert!(!temp_file_path.exists());
+    }
+
+    #[test]
+    fn test_append_clang_output_writer_no_original_file() {
+        let dir = tempdir().unwrap();
+        let file_to_append = dir.path().join("file_to_append.json");
+        let result_file = dir.path().join("result_file.json");
+
+        let entries_to_write = vec![
+            entry("file1.cpp", vec!["clang", "-c"], "/path/to/dir", None),
+            entry("file2.cpp", vec!["clang", "-c"], "/path/to/dir", None),
+        ];
+
+        let writer = ClangOutputWriter::create(&result_file).unwrap();
+        let sut = AppendClangOutputWriter::new(writer, false, &file_to_append);
+        sut.write(entries_to_write.into_iter()).unwrap();
+
+        // Verify the result file contains the written entries
+        assert!(result_file.exists());
+        let content = fs::read_to_string(&result_file).unwrap();
+        assert!(content.contains("file1.cpp"));
+        assert!(content.contains("file2.cpp"));
+    }
+
+    #[test]
+    fn test_append_clang_output_writer_with_original_file() {
+        let dir = tempdir().unwrap();
+        let file_to_append = dir.path().join("file_to_append.json");
+        let result_file = dir.path().join("result_file.json");
+
+        // Create the original file with some entries
+        let original_entries = vec![
+            entry("file3.cpp", vec!["clang", "-c"], "/path/to/dir", None),
+            entry("file4.cpp", vec!["clang", "-c"], "/path/to/dir", None),
+        ];
+        let writer = ClangOutputWriter::create(&file_to_append).unwrap();
+        writer.write(original_entries.into_iter()).unwrap();
+
+        let new_entries = vec![
+            entry("file1.cpp", vec!["clang", "-c"], "/path/to/dir", None),
+            entry("file2.cpp", vec!["clang", "-c"], "/path/to/dir", None),
+        ];
+
+        let writer = ClangOutputWriter::create(&result_file).unwrap();
+        let sut = AppendClangOutputWriter::new(writer, false, &file_to_append);
+        sut.write(new_entries.into_iter()).unwrap();
+
+        // Verify the result file contains both original and new entries
+        assert!(result_file.exists());
+        let content = fs::read_to_string(&result_file).unwrap();
+        assert!(content.contains("file1.cpp"));
+        assert!(content.contains("file2.cpp"));
+        assert!(content.contains("file3.cpp"));
+        assert!(content.contains("file4.cpp"));
+    }
+}

rust/bear/src/output/mod.rs

@@ -7,7 +7,8 @@ mod json;
 use crate::{args, config, semantic};
 use anyhow::Context;
 use clang::{
-    AppendClangOutputWriter, AtomicClangOutputWriter, ClangOutputWriter, FormattedClangOutputWriter,
+    AppendClangOutputWriter, AtomicClangOutputWriter, ClangOutputWriter,
+    FormattedClangOutputWriter, UniqueOutputWriter,
 };
 use formats::{FileFormat, JsonSemanticDatabase};
 use std::{fs, io, path};
@@ -23,7 +24,7 @@ pub enum OutputWriter {
     #[allow(private_interfaces)]
     Clang(
         FormattedClangOutputWriter<
-            AppendClangOutputWriter<AtomicClangOutputWriter<ClangOutputWriter>>,
+            AppendClangOutputWriter<AtomicClangOutputWriter<UniqueOutputWriter<ClangOutputWriter>>>,
         >,
     ),
     #[allow(private_interfaces)]
@@ -40,10 +41,10 @@ impl TryFrom<(&args::BuildSemantic, &config::Output)> for OutputWriter {
                 let final_file_name = path::Path::new(&args.file_name);
                 let temp_file_name = final_file_name.with_extension("tmp");
 
-                let base_writer =
-                    ClangOutputWriter::try_from((temp_file_name.as_path(), duplicates))?;
+                let base_writer = ClangOutputWriter::create(&temp_file_name)?;
+                let unique_writer = UniqueOutputWriter::create(base_writer, duplicates)?;
                 let atomic_writer =
-                    AtomicClangOutputWriter::new(base_writer, &temp_file_name, final_file_name);
+                    AtomicClangOutputWriter::new(unique_writer, &temp_file_name, final_file_name);
                 let append_writer =
                     AppendClangOutputWriter::new(atomic_writer, args.append, final_file_name);
                 let formatted_writer = FormattedClangOutputWriter::new(append_writer);