Add first tests

[rbdr/page] / src / file_handler / mod.rs

mod file_strategies;

use file_strategies::file::Strategy as FileStrategy;
use file_strategies::gemini::Strategy as GeminiStrategy;
use file_strategies::layout::Strategy as LayoutStrategy;

use std::path::PathBuf;
use std::fs::read_to_string;

pub struct FileHandler {
   pub strategies: Vec<Box<dyn FileHandlerStrategy>>,
   pub layout: Option<String>
}

impl Default for FileHandler {
    fn default() -> FileHandler {
        FileHandler {
            strategies: vec![
                Box::new(GeminiStrategy{}),
                Box::new(LayoutStrategy{}),
                Box::new(FileStrategy{}),
            ],
            layout: None
        }
    }
}

impl FileHandler {
    pub fn identify(&self, path: &PathBuf) -> FileType {
        for strategy in self.strategies.iter() {
            if strategy.is(&path) {
                return strategy.identify();
            }
        }
        FileType::Unknown
    }

    pub fn get_layout_or_panic(&mut self, files: &[File]) -> Result<(), &str> {
        for file in files {
            match file.file_type {
                FileType::Layout => {
                    let layout_text = read_to_string(&file.path).unwrap();
                    self.layout = Some(layout_text);
                    return Ok(());
                },
                _ => {}
            }
        }
        Err("No layout found. Please ensure there's a _layout.html file at the root")
    }

    pub fn handle_all(&self, source: &PathBuf, html_destination: &PathBuf, gemini_destination: &PathBuf, files: &[File]) {
        files.iter().for_each(|file| {
            self.handle(source, html_destination, gemini_destination, file);
        });
    }

    pub fn handle(&self, source: &PathBuf, html_destination: &PathBuf, gemini_destination: &PathBuf, file: &File) {
        if let Some(strategy) = self.strategies
            .iter()
            .find(|s| s.can_handle(&file.file_type)) 
        {
                let layout = self.layout.as_ref()
                    .expect("Layout should be initialized before handling files");
                strategy.handle_html(source, html_destination, file, layout);
                strategy.handle_gemini(source, gemini_destination, file);
                return;
        }
    }
}

pub trait FileHandlerStrategy {
    fn is(&self, path: &PathBuf) -> bool;
    fn identify(&self) -> FileType;
    fn can_handle(&self, file_type: &FileType) -> bool;
    fn handle_html(&self, source: &PathBuf, destination: &PathBuf, file: &File, layout: &str);
    fn handle_gemini(&self, source: &PathBuf, destination: &PathBuf, file: &File);
}

#[derive(Debug, Clone, PartialEq)]
pub enum FileType {
    Gemini,
    File,
    Layout,
    Unknown,
}

#[derive(PartialEq, Debug)]
pub struct File {
    pub path: PathBuf,
    pub file_type: FileType,
}


#[cfg(test)]
mod tests {
    use super::*;
    use std::path::PathBuf;

    fn create_test_file(path: &str, file_type: FileType) -> File {
        File {
            path: PathBuf::from(path),
            file_type,
        }
    }

    #[test]
    fn test_identify_gemini_file() {
        let handler = FileHandler::default();
        let path = PathBuf::from("test.gmi");
        assert!(matches!(handler.identify(&path), FileType::Gemini));
    }

    #[test]
    fn test_identify_layout_file() {
        let handler = FileHandler::default();
        let path = PathBuf::from("_layout.html");
        assert!(matches!(handler.identify(&path), FileType::Layout));
    }

    #[test]
    fn test_identify_regular_file() {
        let handler = FileHandler::default();
        let path = PathBuf::from("regular.html");
        assert!(matches!(handler.identify(&path), FileType::File));
    }

    #[test]
    fn test_identify_unknown_file() {
        let handler = FileHandler::default();
        let path = PathBuf::from("tests/fixtures");
        assert!(matches!(handler.identify(&path), FileType::Unknown));
    }

    #[test]
    fn test_get_layout_success() {
        let mut handler = FileHandler::default();
        let files = vec![
            create_test_file("test.gmi", FileType::Gemini),
            create_test_file("tests/fixtures/_layout.html", FileType::Layout),
            create_test_file("regular.html", FileType::File),
        ];

        assert!(handler.get_layout_or_panic(&files).is_ok());
    }

    #[test]
    fn test_get_layout_failure() {
        let mut handler = FileHandler::default();
        let files = vec![
            create_test_file("test.gmi", FileType::Gemini),
            create_test_file("regular.html", FileType::File),
        ];

        assert!(handler.get_layout_or_panic(&files).is_err());
    }

    // Mock strategy for testing
    struct MockStrategy {
        is_match: bool,
        file_type: FileType,
    }

    impl FileHandlerStrategy for MockStrategy {
        fn is(&self, _path: &PathBuf) -> bool {
            self.is_match
        }

        fn identify(&self) -> FileType {
            self.file_type.clone()
        }

        fn can_handle(&self, file_type: &FileType) -> bool {
            &self.file_type == file_type
        }

        fn handle_html(&self, _source: &PathBuf, _destination: &PathBuf, _file: &File, _layout: &str) {}
        fn handle_gemini(&self, _source: &PathBuf, _destination: &PathBuf, _file: &File) {}
    }

    #[test]
    fn test_custom_strategy() {
        let mock_strategy = MockStrategy {
            is_match: true,
            file_type: FileType::Gemini,
        };

        let handler = FileHandler {
            strategies: vec![Box::new(mock_strategy)],
            layout: None,
        };

        let path = PathBuf::from("test.whatever");
        assert!(matches!(handler.identify(&path), FileType::Gemini));
    }

    #[test]
    fn test_handle_all_empty_files() {
        let handler = FileHandler::default();
        let files: Vec<File> = vec![];

        // Should not panic with empty vector
        handler.handle_all(
            &PathBuf::from("source"),
            &PathBuf::from("tests/fixtures/output"),
            &PathBuf::from("tests/fixtures/output"),
            &files
        );
    }

    #[test]
    fn test_handle_with_layout() {
        let mut handler = FileHandler::default();
        handler.layout = Some("test layout".to_string());

        let file = create_test_file("tests/fixtures/test1.gmi", FileType::Gemini);

        // Should not panic with valid layout
        handler.handle(
            &PathBuf::from(""),
            &PathBuf::from("tests/fixtures/output"),
            &PathBuf::from("tests/fixtures/output"),
            &file
        );
    }

    #[test]
    #[should_panic(expected = "Layout should be initialized before handling files")]
    fn test_handle_without_layout() {
        let handler = FileHandler::default();
        let file = create_test_file("test.gmi", FileType::Gemini);

        handler.handle(
            &PathBuf::from("source"),
            &PathBuf::from("tests/fixtures/output"),
            &PathBuf::from("tests/fixtures/output"),
            &file
        );
    }

    #[test]
    fn test_slice_handling() {
        let mut handler = FileHandler::default();
        let files = vec![
            create_test_file("tests/fixtures/test1.gmi", FileType::Gemini),
            create_test_file("tests/fixtures/_layout.html", FileType::Layout),
            create_test_file("tests/fixtures/test2.gmi", FileType::Gemini),
            create_test_file("tests/fixtures/test3.gmi", FileType::Gemini),
        ];

        let _ = handler.get_layout_or_panic(&files[1..]);

        // Test with slice
        handler.handle_all(
            &PathBuf::from(""),
            &PathBuf::from("tests/fixtures/output"),
            &PathBuf::from("tests/fixtures/output"),
            &files[1..] // Test with slice of last three elements
        );
    }
}