Initial upload: gitignore-gen Rust CLI tool with 100+ templates

app/gitignore-gen/tests/unit/template_tests.rs

@@ -0,0 +1,231 @@
+use crate::templates::{Category, Template, TemplateLoader, TemplateSet};
+
+#[cfg(test)]
+mod template_tests {
+    use super::*;
+
+    #[test]
+    fn test_template_creation() {
+        let template = Template::new(
+            "test".to_string(),
+            Category::Language,
+            vec!["*.log".to_string(), "*.tmp".to_string()],
+        );
+
+        assert_eq!(template.name, "test");
+        assert_eq!(template.category, Category::Language);
+        assert_eq!(template.patterns.len(), 2);
+    }
+
+    #[test]
+    fn test_template_patterns_as_string() {
+        let template = Template::new(
+            "test".to_string(),
+            Category::Language,
+            vec!["*.log".to_string(), "*.tmp".to_string()],
+        );
+
+        let result = template.patterns_as_string();
+        assert!(result.contains("*.log"));
+        assert!(result.contains("*.tmp"));
+    }
+
+    #[test]
+    fn test_template_with_description() {
+        let template = Template::new("test".to_string(), Category::Language, vec![])
+            .with_description("A test template".to_string());
+
+        assert_eq!(template.description, Some("A test template".to_string()));
+    }
+
+    #[test]
+    fn test_template_with_version() {
+        let template = Template::new("test".to_string(), Category::Language, vec![])
+            .with_version("1.0.0".to_string());
+
+        assert_eq!(template.version, Some("1.0.0".to_string()));
+    }
+}
+
+#[cfg(test)]
+mod template_set_tests {
+    use super::*;
+
+    #[test]
+    fn test_template_set_add() {
+        let mut set = TemplateSet::new();
+        let template = Template::new("rust".to_string(), Category::Language, vec![]);
+        set.add(template);
+
+        assert_eq!(set.len(), 1);
+        assert!(!set.is_empty());
+    }
+
+    #[test]
+    fn test_template_set_get_by_name() {
+        let mut set = TemplateSet::new();
+        set.add(Template::new(
+            "rust".to_string(),
+            Category::Language,
+            vec!["target/".to_string()],
+        ));
+
+        let found = set.get_by_name("rust");
+        assert!(found.is_some());
+        assert_eq!(found.unwrap().name, "rust");
+    }
+
+    #[test]
+    fn test_template_set_search() {
+        let mut set = TemplateSet::new();
+        set.add(Template::new(
+            "rust".to_string(),
+            Category::Language,
+            vec!["target/".to_string()],
+        ));
+        set.add(Template::new(
+            "python".to_string(),
+            Category::Language,
+            vec!["__pycache__/".to_string()],
+        ));
+
+        let results = set.search("rust");
+        assert_eq!(results.len(), 1);
+        assert_eq!(results[0].name, "rust");
+    }
+
+    #[test]
+    fn test_template_set_get_by_category() {
+        let mut set = TemplateSet::new();
+        set.add(Template::new(
+            "rust".to_string(),
+            Category::Language,
+            vec![],
+        ));
+        set.add(Template::new(
+            "python".to_string(),
+            Category::Language,
+            vec![],
+        ));
+        set.add(Template::new(
+            "vim".to_string(),
+            Category::IDE,
+            vec![],
+        ));
+
+        let results = set.get_by_category(&Category::Language);
+        assert_eq!(results.len(), 2);
+    }
+}
+
+#[cfg(test)]
+mod template_loader_tests {
+    use super::*;
+
+    #[test]
+    fn test_template_loader_new() {
+        let loader = TemplateLoader::new(None);
+        let templates = loader.list_templates();
+        assert!(!templates.is_empty());
+    }
+
+    #[test]
+    fn test_template_loader_get_template() {
+        let loader = TemplateLoader::new(None);
+        let template = loader.get_template("rust");
+        assert!(template.is_some());
+        assert_eq!(template.unwrap().name, "rust");
+    }
+
+    #[test]
+    fn test_template_loader_get_nonexistent_template() {
+        let loader = TemplateLoader::new(None);
+        let template = loader.get_template("nonexistent");
+        assert!(template.is_none());
+    }
+
+    #[test]
+    fn test_template_loader_search() {
+        let loader = TemplateLoader::new(None);
+        let results = loader.search_templates("rust");
+        assert!(!results.is_empty());
+        assert!(results.contains(&"rust"));
+    }
+
+    #[test]
+    fn test_template_loader_search_no_results() {
+        let loader = TemplateLoader::new(None);
+        let results = loader.search_templates("xyznonexistent123");
+        assert!(results.is_empty());
+    }
+
+    #[test]
+    fn test_template_loader_combine_templates() {
+        let loader = TemplateLoader::new(None);
+        let result = loader.combine_templates(&["rust", "python"]);
+        assert!(result.is_ok());
+        let content = result.unwrap();
+        assert!(content.contains("rust"));
+        assert!(content.contains("python"));
+    }
+
+    #[test]
+    fn test_template_loader_combine_single_template() {
+        let loader = TemplateLoader::new(None);
+        let result = loader.combine_templates(&["go"]);
+        assert!(result.is_ok());
+        let content = result.unwrap();
+        assert!(content.contains("go"));
+    }
+
+    #[test]
+    fn test_template_loader_load_all() {
+        let mut loader = TemplateLoader::new(None);
+        let set = loader.load_all();
+        assert!(set.is_ok());
+        let template_set = set.unwrap();
+        assert!(!template_set.is_empty());
+    }
+
+    #[test]
+    fn test_template_loader_filter_by_category() {
+        let loader = TemplateLoader::new(None);
+        let languages = loader.filter_by_category(&Category::Language);
+        assert!(!languages.is_empty());
+        assert!(languages.contains(&"rust"));
+        assert!(languages.contains(&"python"));
+    }
+
+    #[test]
+    fn test_template_categories() {
+        let loader = TemplateLoader::new(None);
+
+        let languages = loader.filter_by_category(&Category::Language);
+        let frameworks = loader.filter_by_category(&Category::Framework);
+        let ides = loader.filter_by_category(&Category::IDE);
+
+        assert!(!languages.is_empty());
+        assert!(!frameworks.is_empty());
+        assert!(!ides.is_empty());
+    }
+}
+
+#[cfg(test)]
+mod category_tests {
+    use super::*;
+
+    #[test]
+    fn test_category_display() {
+        assert_eq!(Category::Language.to_string(), "Language");
+        assert_eq!(Category::Framework.to_string(), "Framework");
+        assert_eq!(Category::IDE.to_string(), "IDE");
+        assert_eq!(Category::OS.to_string(), "Operating System");
+        assert_eq!(Category::Misc.to_string(), "Miscellaneous");
+    }
+
+    #[test]
+    fn test_custom_category() {
+        let category = Category::Custom("Custom Category".to_string());
+        assert_eq!(category.to_string(), "Custom Category");
+    }
+}