Add tests for generators

8 files changed, 688 insertions, 4 deletions

diff --git a/src/archiver/gemini.rs b/src/archiver/gemini.rs
index aa3ac29..7839ff2 100644
--- a/src/archiver/gemini.rs
+++ b/src/archiver/gemini.rs
@@ -71,7 +71,7 @@ mod tests {
     fn test_fails_if_output_folder_is_not_writable() {
         let test_dir = setup_test_dir();
         let template_dir = test_dir.join("template");
-        let output_dir = test_dir.join("/unwritable/folder/please");
+        let output_dir = test_dir.join("unwritable/folder/please");
         create_dir_all(&template_dir).expect("Could not create template test directory");
 
         create_test_file(&template_dir.join("index.gmi"), "Simple {{= test }}");
diff --git a/src/archiver/raw.rs b/src/archiver/raw.rs
index 8641177..5cac709 100644
--- a/src/archiver/raw.rs
+++ b/src/archiver/raw.rs
@@ -16,7 +16,6 @@ mod tests {
     use std::fs::create_dir_all;
 
     use super::*;
-    use crate::template::Value;
 
     use test_utilities::*;
 
diff --git a/src/generator/html.rs b/src/generator/html.rs
index 70cc320..7895a83 100644
--- a/src/generator/html.rs
+++ b/src/generator/html.rs
@@ -20,3 +20,159 @@ pub fn generate(
     }
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+    use std::fs::create_dir_all;
+
+    use super::*;
+
+    use crate::template::Value;
+
+    use test_utilities::*;
+
+    #[test]
+    fn test_generates_html_with_default_layout() {
+        let test_dir = setup_test_dir();
+        let static_dir = test_dir.join("static");
+        let template_dir = test_dir.join("templates");
+        let output_dir = test_dir.join("output");
+
+        create_dir_all(&static_dir).expect("Could not create static directory");
+        create_dir_all(&template_dir).expect("Could not create template directory");
+        create_dir_all(&output_dir).expect("Could not create output directory");
+
+        let context = HashMap::from([
+            ("has_posts".to_string(), Value::Bool(true)),
+            (
+                "posts".to_string(),
+                Value::Collection(vec![
+                    HashMap::from([
+                        ("index".to_string(), Value::Unsigned(2828)),
+                        (
+                            "html".to_string(),
+                            Value::String("<p>Contextualization</p>".to_string()),
+                        ),
+                    ]),
+                    HashMap::from([
+                        ("index".to_string(), Value::Unsigned(2828)),
+                        (
+                            "html".to_string(),
+                            Value::String("<p>Contexternalization</p>".to_string()),
+                        ),
+                    ]),
+                ]),
+            ),
+        ]);
+
+        generate(&static_dir, &template_dir, &output_dir, &context).expect("Generate failed");
+
+        assert_file_contains(&output_dir.join("index.html"), "<p>Contextualization</p>");
+        assert_file_contains(&output_dir.join("index.html"), "<p>Contexternalization</p>");
+    }
+
+    #[test]
+    fn test_uses_custom_layout_if_available() {
+        let test_dir = setup_test_dir();
+        let static_dir = test_dir.join("static");
+        let template_dir = test_dir.join("templates");
+        let output_dir = test_dir.join("output");
+
+        create_dir_all(&static_dir).expect("Could not create static directory");
+        create_dir_all(&template_dir).expect("Could not create template directory");
+        create_dir_all(&output_dir).expect("Could not create output directory");
+        create_test_file(
+            &template_dir.join("index.html"),
+            "\
+{{~ posts:post }}
+    {{= post.html }}
+{{~}}
+",
+        );
+        let context = HashMap::from([(
+            "posts".to_string(),
+            Value::Collection(vec![
+                HashMap::from([(
+                    "html".to_string(),
+                    Value::String("<p>Recontextualization</p>".to_string()),
+                )]),
+                HashMap::from([(
+                    "html".to_string(),
+                    Value::String("<p>Recontexternalization</p>".to_string()),
+                )]),
+            ]),
+        )]);
+
+        generate(&static_dir, &template_dir, &output_dir, &context).expect("Generate failed");
+
+        assert_file_contents(
+            &output_dir.join("index.html"),
+            "\
+<p>Recontextualization</p>
+
+    <p>Recontexternalization</p>
+",
+        );
+    }
+
+    #[test]
+    fn test_fails_if_html_is_malformed() {
+        let test_dir = setup_test_dir();
+        let static_dir = test_dir.join("static");
+        let template_dir = test_dir.join("templates");
+        let output_dir = test_dir.join("output");
+
+        create_dir_all(&static_dir).expect("Could not create static directory");
+        create_dir_all(&template_dir).expect("Could not create template directory");
+        create_dir_all(&output_dir).expect("Could not create output directory");
+        create_test_file(
+            &template_dir.join("index.html"),
+            "\
+{{~ posts:post }}
+    {{ post.html }}
+{{~}}
+",
+        );
+        let context = HashMap::new();
+
+        let result = generate(&static_dir, &template_dir, &output_dir, &context);
+
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_fails_if_output_is_not_writable() {
+        let test_dir = setup_test_dir();
+        let static_dir = test_dir.join("static");
+        let template_dir = test_dir.join("templates");
+        let output_dir = test_dir.join("output");
+
+        create_dir_all(&template_dir).expect("Could not create template directory");
+        create_test_file(
+            &template_dir.join("index.html"),
+            "\
+{{~ posts:post }}
+    {{= post.html }}
+{{~}}
+",
+        );
+        let context = HashMap::from([(
+            "posts".to_string(),
+            Value::Collection(vec![
+                HashMap::from([(
+                    "html".to_string(),
+                    Value::String("<p>Recontextualization</p>".to_string()),
+                )]),
+                HashMap::from([(
+                    "html".to_string(),
+                    Value::String("<p>Recontexternalization</p>".to_string()),
+                )]),
+            ]),
+        )]);
+
+        let result = generate(&static_dir, &template_dir, &output_dir, &context);
+
+        assert!(result.is_err());
+    }
+}
diff --git a/src/generator/mod.rs b/src/generator/mod.rs
index dbe1c2e..55946af 100644
--- a/src/generator/mod.rs
+++ b/src/generator/mod.rs
@@ -38,3 +38,150 @@ fn available_generators() -> Vec<Generator> {
         txt::generate,
     ]
 }
+
+#[cfg(test)]
+mod tests {
+    use std::fs::create_dir_all;
+
+    use super::*;
+
+    use crate::metadata::Metadata;
+    use crate::post::Post;
+
+    use test_utilities::*;
+
+    #[test]
+    fn test_generates() {
+        let test_dir = setup_test_dir();
+        let static_dir = test_dir.join("static");
+        let template_dir = test_dir.join("templates");
+        let output_dir = test_dir.join("output");
+
+        create_dir_all(&static_dir).expect("Could not create static directory");
+        create_dir_all(&template_dir).expect("Could not create template directory");
+        create_dir_all(&output_dir).expect("Could not create output directory");
+        create_test_file(&static_dir.join("file.txt"), "wow");
+        create_test_file(
+            &template_dir.join("index.html"),
+            "\
+{{~ posts:post }}
+    {{= post.html }}
+{{~}}
+",
+        );
+        create_test_file(
+            &template_dir.join("feed.xml"),
+            "\
+{{~ posts:post }}
+    {{= post.id }}
+{{~}}
+",
+        );
+        create_test_file(
+            &template_dir.join("index.txt"),
+            "\
+{{~ posts:post }}
+    {{= post.raw }}
+{{~}}
+",
+        );
+        let posts = vec![
+            Post {
+                metadata: Metadata {
+                    id: "1736035200000".to_string(),
+                    created_on: 1_736_035_200_000,
+                },
+                index: 9,
+                html: "<p>Generatorial</p>".to_string(),
+                raw: "electricity generator".to_string(),
+            },
+            Post {
+                metadata: Metadata {
+                    id: "1736045200000".to_string(),
+                    created_on: 1_736_045_200_000,
+                },
+                index: 10,
+                html: "<p>Generation</p>".to_string(),
+                raw: "kero kero".to_string(),
+            },
+        ];
+
+        generate(&static_dir, &template_dir, &output_dir, &posts).expect("Generate failed");
+
+        assert_file_contents(&output_dir.join("file.txt"), "wow");
+        assert_file_contents(
+            &output_dir.join("index.html"),
+            "\
+<p>Generatorial</p>
+
+    <p>Generation</p>
+",
+        );
+        assert_file_contents(
+            &output_dir.join("feed.xml"),
+            "\
+1736035200000
+
+    1736045200000
+",
+        );
+    }
+
+    #[test]
+    fn test_fails_if_directories_do_not_exist() {
+        let test_dir = setup_test_dir();
+        let static_dir = test_dir.join("static");
+        let template_dir = test_dir.join("templates");
+        let output_dir = test_dir.join("output");
+        let posts = vec![];
+
+        let result = generate(&static_dir, &template_dir, &output_dir, &posts);
+
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_fails_if_a_generator_fails() {
+        let test_dir = setup_test_dir();
+        let static_dir = test_dir.join("static");
+        let template_dir = test_dir.join("templates");
+        let output_dir = test_dir.join("output");
+
+        create_dir_all(&static_dir).expect("Could not create static directory");
+        create_dir_all(&template_dir).expect("Could not create template directory");
+        create_dir_all(&output_dir).expect("Could not create output directory");
+        create_test_file(&static_dir.join("file.txt"), "wow");
+        create_test_file(
+            &template_dir.join("index.html"),
+            "\
+{{~ posts:post }}
+    {{ post.html }}
+{{~}}
+",
+        );
+        let posts = vec![
+            Post {
+                metadata: Metadata {
+                    id: "1736035200000".to_string(),
+                    created_on: 1_736_035_200_000,
+                },
+                index: 9,
+                html: "<p>Generatorial</p>".to_string(),
+                raw: "electricity generator".to_string(),
+            },
+            Post {
+                metadata: Metadata {
+                    id: "1736045200000".to_string(),
+                    created_on: 1_736_045_200_000,
+                },
+                index: 10,
+                html: "<p>Generation</p>".to_string(),
+                raw: "kero kero".to_string(),
+            },
+        ];
+
+        let result = generate(&static_dir, &template_dir, &output_dir, &posts);
+
+        assert!(result.is_err());
+    }
+}
diff --git a/src/generator/rss.rs b/src/generator/rss.rs
index e79694e..c4b8bdb 100644
--- a/src/generator/rss.rs
+++ b/src/generator/rss.rs
@@ -20,3 +20,175 @@ pub fn generate(
     }
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+    use std::fs::create_dir_all;
+
+    use super::*;
+
+    use crate::template::Value;
+
+    use test_utilities::*;
+
+    #[test]
+    fn test_generates_rss_with_default_layout() {
+        let test_dir = setup_test_dir();
+        let static_dir = test_dir.join("static");
+        let template_dir = test_dir.join("templates");
+        let output_dir = test_dir.join("output");
+
+        create_dir_all(&static_dir).expect("Could not create static directory");
+        create_dir_all(&template_dir).expect("Could not create template directory");
+        create_dir_all(&output_dir).expect("Could not create output directory");
+
+        let context = HashMap::from([
+            ("has_posts".to_string(), Value::Bool(true)),
+            (
+                "posts".to_string(),
+                Value::Collection(vec![
+                    HashMap::from([
+                        ("id".to_string(), Value::String("123".to_string())),
+                        (
+                            "created_on_utc".to_string(),
+                            Value::String("Last Saturday".to_string()),
+                        ),
+                        (
+                            "title".to_string(),
+                            Value::String("Big words I know.".to_string()),
+                        ),
+                        (
+                            "escaped_html".to_string(),
+                            Value::String("<p>Contextualization</p>".to_string()),
+                        ),
+                    ]),
+                    HashMap::from([
+                        ("id".to_string(), Value::String("456".to_string())),
+                        (
+                            "created_on_utc".to_string(),
+                            Value::String("This Saturday".to_string()),
+                        ),
+                        (
+                            "title".to_string(),
+                            Value::String("Big words I don't know.".to_string()),
+                        ),
+                        (
+                            "escaped_html".to_string(),
+                            Value::String("<p>Contexternalization</p>".to_string()),
+                        ),
+                    ]),
+                ]),
+            ),
+        ]);
+
+        generate(&static_dir, &template_dir, &output_dir, &context).expect("Generate failed");
+
+        assert_file_contains(&output_dir.join("feed.xml"), "<p>Contextualization</p>");
+        assert_file_contains(&output_dir.join("feed.xml"), "<p>Contexternalization</p>");
+    }
+
+    #[test]
+    fn test_uses_custom_layout_if_available() {
+        let test_dir = setup_test_dir();
+        let static_dir = test_dir.join("static");
+        let template_dir = test_dir.join("templates");
+        let output_dir = test_dir.join("output");
+
+        create_dir_all(&static_dir).expect("Could not create static directory");
+        create_dir_all(&template_dir).expect("Could not create template directory");
+        create_dir_all(&output_dir).expect("Could not create output directory");
+        create_test_file(
+            &template_dir.join("feed.xml"),
+            "\
+{{~ posts:post }}
+    {{= post.html }}
+{{~}}
+",
+        );
+        let context = HashMap::from([(
+            "posts".to_string(),
+            Value::Collection(vec![
+                HashMap::from([(
+                    "html".to_string(),
+                    Value::String("<p>Recontextualization</p>".to_string()),
+                )]),
+                HashMap::from([(
+                    "html".to_string(),
+                    Value::String("<p>Recontexternalization</p>".to_string()),
+                )]),
+            ]),
+        )]);
+
+        generate(&static_dir, &template_dir, &output_dir, &context).expect("Generate failed");
+
+        assert_file_contents(
+            &output_dir.join("feed.xml"),
+            "\
+<p>Recontextualization</p>
+
+    <p>Recontexternalization</p>
+",
+        );
+    }
+
+    #[test]
+    fn test_fails_if_rss_is_malformed() {
+        let test_dir = setup_test_dir();
+        let static_dir = test_dir.join("static");
+        let template_dir = test_dir.join("templates");
+        let output_dir = test_dir.join("output");
+
+        create_dir_all(&static_dir).expect("Could not create static directory");
+        create_dir_all(&template_dir).expect("Could not create template directory");
+        create_dir_all(&output_dir).expect("Could not create output directory");
+        create_test_file(
+            &template_dir.join("feed.xml"),
+            "\
+{{~ posts:post }}
+    {{ post.html }}
+{{~}}
+",
+        );
+        let context = HashMap::new();
+
+        let result = generate(&static_dir, &template_dir, &output_dir, &context);
+
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_fails_if_output_is_not_writable() {
+        let test_dir = setup_test_dir();
+        let static_dir = test_dir.join("static");
+        let template_dir = test_dir.join("templates");
+        let output_dir = test_dir.join("output");
+
+        create_dir_all(&template_dir).expect("Could not create template directory");
+        create_test_file(
+            &template_dir.join("feed.xml"),
+            "\
+{{~ posts:post }}
+    {{= post.html }}
+{{~}}
+",
+        );
+        let context = HashMap::from([(
+            "posts".to_string(),
+            Value::Collection(vec![
+                HashMap::from([(
+                    "html".to_string(),
+                    Value::String("<p>Recontextualization</p>".to_string()),
+                )]),
+                HashMap::from([(
+                    "html".to_string(),
+                    Value::String("<p>Recontexternalization</p>".to_string()),
+                )]),
+            ]),
+        )]);
+
+        let result = generate(&static_dir, &template_dir, &output_dir, &context);
+
+        assert!(result.is_err());
+    }
+}
diff --git a/src/generator/static_files.rs b/src/generator/static_files.rs
index b4ec9fd..449dcc4 100644
--- a/src/generator/static_files.rs
+++ b/src/generator/static_files.rs
@@ -9,3 +9,63 @@ pub fn generate(source: &Path, _: &Path, target: &Path, _: &Context) -> Result<(
     }
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+    use std::fs::create_dir_all;
+
+    use super::*;
+
+    use test_utilities::*;
+
+    #[test]
+    fn test_copies_files() {
+        let test_dir = setup_test_dir();
+        let static_dir = test_dir.join("static");
+        let template_dir = test_dir.join("templates");
+        let output_dir = test_dir.join("output");
+
+        create_dir_all(&static_dir).expect("Could not create static directory");
+        create_dir_all(&output_dir).expect("Could not create output directory");
+        create_test_file(&static_dir.join("test.jpg"), "Cool hat");
+
+        let context = HashMap::new();
+
+        generate(&static_dir, &template_dir, &output_dir, &context).expect("Generate failed");
+
+        assert_file_contents(&output_dir.join("test.jpg"), "Cool hat");
+    }
+
+    #[test]
+    fn test_creates_directories_if_they_do_not_exist() {
+        let test_dir = setup_test_dir();
+        let static_dir = test_dir.join("static");
+        let template_dir = test_dir.join("templates");
+        let output_dir = test_dir.join("output");
+
+        create_dir_all(&static_dir).expect("Could not create static directory");
+        create_dir_all(&static_dir.join("nested")).expect("Could not create output directory");
+        create_test_file(&static_dir.join("nested/test.mov"), "Cool hats, multiple.");
+
+        let context = HashMap::new();
+
+        generate(&static_dir, &template_dir, &output_dir, &context).expect("Generate failed");
+
+        assert_file_contents(&output_dir.join("nested/test.mov"), "Cool hats, multiple.");
+    }
+
+    #[test]
+    fn test_it_does_not_fail_if_source_directory_does_not_exist() {
+        let test_dir = setup_test_dir();
+        let static_dir = test_dir.join("static");
+        let template_dir = test_dir.join("templates");
+        let output_dir = test_dir.join("output");
+
+        let context = HashMap::new();
+
+        let result = generate(&static_dir, &template_dir, &output_dir, &context);
+
+        assert!(result.is_ok());
+    }
+}
diff --git a/src/generator/txt.rs b/src/generator/txt.rs
index 0a53655..ef48c03 100644
--- a/src/generator/txt.rs
+++ b/src/generator/txt.rs
@@ -20,3 +20,153 @@ pub fn generate(
     }
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+    use std::fs::create_dir_all;
+
+    use super::*;
+
+    use crate::template::Value;
+
+    use test_utilities::*;
+
+    #[test]
+    fn test_generates_txt_with_default_layout() {
+        let test_dir = setup_test_dir();
+        let static_dir = test_dir.join("static");
+        let template_dir = test_dir.join("templates");
+        let output_dir = test_dir.join("output");
+
+        create_dir_all(&static_dir).expect("Could not create static directory");
+        create_dir_all(&template_dir).expect("Could not create template directory");
+        create_dir_all(&output_dir).expect("Could not create output directory");
+
+        let context = HashMap::from([
+            ("has_posts".to_string(), Value::Bool(true)),
+            (
+                "posts".to_string(),
+                Value::Collection(vec![
+                    HashMap::from([(
+                        "raw".to_string(),
+                        Value::String("Contextualization".to_string()),
+                    )]),
+                    HashMap::from([(
+                        "raw".to_string(),
+                        Value::String("Contexternalization".to_string()),
+                    )]),
+                ]),
+            ),
+        ]);
+
+        generate(&static_dir, &template_dir, &output_dir, &context).expect("Generate failed");
+
+        assert_file_contains(&output_dir.join("index.txt"), "Contextualization");
+        assert_file_contains(&output_dir.join("index.txt"), "Contexternalization");
+    }
+
+    #[test]
+    fn test_uses_custom_layout_if_available() {
+        let test_dir = setup_test_dir();
+        let static_dir = test_dir.join("static");
+        let template_dir = test_dir.join("templates");
+        let output_dir = test_dir.join("output");
+
+        create_dir_all(&static_dir).expect("Could not create static directory");
+        create_dir_all(&template_dir).expect("Could not create template directory");
+        create_dir_all(&output_dir).expect("Could not create output directory");
+        create_test_file(
+            &template_dir.join("index.txt"),
+            "\
+{{~ posts:post }}
+    {{= post.raw }}
+{{~}}
+",
+        );
+        let context = HashMap::from([(
+            "posts".to_string(),
+            Value::Collection(vec![
+                HashMap::from([(
+                    "raw".to_string(),
+                    Value::String("Recontextualization".to_string()),
+                )]),
+                HashMap::from([(
+                    "raw".to_string(),
+                    Value::String("Recontexternalization".to_string()),
+                )]),
+            ]),
+        )]);
+
+        generate(&static_dir, &template_dir, &output_dir, &context).expect("Generate failed");
+
+        assert_file_contents(
+            &output_dir.join("index.txt"),
+            "\
+Recontextualization
+
+    Recontexternalization
+",
+        );
+    }
+
+    #[test]
+    fn test_fails_if_txt_is_malformed() {
+        let test_dir = setup_test_dir();
+        let static_dir = test_dir.join("static");
+        let template_dir = test_dir.join("templates");
+        let output_dir = test_dir.join("output");
+
+        create_dir_all(&static_dir).expect("Could not create static directory");
+        create_dir_all(&template_dir).expect("Could not create template directory");
+        create_dir_all(&output_dir).expect("Could not create output directory");
+        create_test_file(
+            &template_dir.join("index.txt"),
+            "\
+{{~ posts:post }}
+    {{ post.raw }}
+{{~}}
+",
+        );
+        let context = HashMap::new();
+
+        let result = generate(&static_dir, &template_dir, &output_dir, &context);
+
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_fails_if_output_is_not_writable() {
+        let test_dir = setup_test_dir();
+        let static_dir = test_dir.join("static");
+        let template_dir = test_dir.join("templates");
+        let output_dir = test_dir.join("output");
+
+        create_dir_all(&template_dir).expect("Could not create template directory");
+        create_test_file(
+            &template_dir.join("index.txt"),
+            "\
+{{~ posts:post }}
+    {{= post.raw }}
+{{~}}
+",
+        );
+        let context = HashMap::from([(
+            "posts".to_string(),
+            Value::Collection(vec![
+                HashMap::from([(
+                    "raw".to_string(),
+                    Value::String("Recontextualization".to_string()),
+                )]),
+                HashMap::from([(
+                    "raw".to_string(),
+                    Value::String("Recontexternalization".to_string()),
+                )]),
+            ]),
+        )]);
+
+        let result = generate(&static_dir, &template_dir, &output_dir, &context);
+
+        assert!(result.is_err());
+    }
+}
diff --git a/src/template.rs b/src/template.rs
index 3708efb..aef3440 100644
--- a/src/template.rs
+++ b/src/template.rs
@@ -292,7 +292,7 @@ fn find_default(filename: &str) -> Option<String> {
         "index.txt" => Some(TXT_TEMPLATE.to_string()),
         "index.html" => Some(HTML_TEMPLATE.to_string()),
         "index.gmi" => Some(GMI_TEMPLATE.to_string()),
-        "index.rss" => Some(RSS_TEMPLATE.to_string()),
+        "feed.xml" => Some(RSS_TEMPLATE.to_string()),
         &_ => None,
     }
 }
@@ -707,7 +707,7 @@ One last OK
     fn test_finds_default_rss_templalte() {
         let template = find(
             &PathBuf::from("/norealpath/ifthisfails/then/wow"),
-            "index.rss",
+            "feed.xml",
         );
         assert!(template.is_some());
     }