Add pseudo-integration tests for modules with all options disabled

data/generated/minimal-assembly.adoc

@@ -0,0 +1,22 @@
+ifdef::context[:parent-context-of-minimal-assembly: {context}]
+
+ifndef::context[]
+[id="minimal-assembly"]
+endif::[]
+ifdef::context[]
+[id="minimal-assembly_{context}"]
+endif::[]
+= Minimal assembly
+
+:context: minimal-assembly
+
+[role="_abstract"]
+
+== Prerequisites
+
+[role="_additional-resources"]
+== Additional resources (or Next steps)
+
+ifdef::parent-context-of-minimal-assembly[:context: {parent-context-of-minimal-assembly}]
+ifndef::parent-context-of-minimal-assembly[:!context:]
+

data/generated/minimal-concept.adoc

@@ -0,0 +1,9 @@
+[id="minimal-concept_{context}"]
+= Minimal concept
+
+[role="_abstract"]
+
+[role="_additional-resources"]
+.Additional resources
+
+

data/generated/minimal-procedure.adoc

@@ -0,0 +1,15 @@
+[id="minimal-procedure_{context}"]
+= Minimal procedure
+
+[role="_abstract"]
+
+.Prerequisites
+
+.Procedure
+
+.Verification
+
+[role="_additional-resources"]
+.Additional resources
+
+

data/generated/minimal-reference.adoc

@@ -0,0 +1,9 @@
+[id="minimal-reference_{context}"]
+= Minimal reference
+
+[role="_abstract"]
+
+[role="_additional-resources"]
+.Additional resources
+
+

src/main.rs

@@ -129,13 +129,14 @@ mod tests {
     use crate::module::ModuleType;
     use crate::Options;
 
+    // These values represent the default newdoc options.
     fn basic_options() -> Options {
         Options {
             comments: true,
             prefixes: true,
             examples: true,
             target_dir: ".".to_string(),
-            detect_directory: false,
+            detect_directory: true,
         }
     }
 
@@ -192,4 +193,69 @@ mod tests {
 
         assert_eq!(reference.text, pre_generated);
     }
+
+    // These values strip down the modules to the bare minimum.
+    fn minimal_options() -> Options {
+        Options {
+            comments: false,
+            prefixes: false,
+            examples: false,
+            target_dir: ".".to_string(),
+            detect_directory: true,
+        }
+    }
+
+    /// Test that we generate the assembly that we expect.
+    #[test]
+    fn test_minimal_assembly() {
+        let mod_type = &ModuleType::Assembly;
+        let mod_title = "Minimal assembly";
+        let options = minimal_options();
+        let assembly = Module::new(mod_type, mod_title, &options);
+
+        let pre_generated =
+            include_str!("../data/generated/minimal-assembly.adoc");
+
+        assert_eq!(assembly.text, pre_generated);
+    }
+
+    /// Test that we generate the concept module that we expect.
+    #[test]
+    fn test_minimal_concept() {
+        let mod_type = &ModuleType::Concept;
+        let mod_title = "Minimal concept";
+        let options = minimal_options();
+        let concept = Module::new(mod_type, mod_title, &options);
+
+        let pre_generated = include_str!("../data/generated/minimal-concept.adoc");
+
+        assert_eq!(concept.text, pre_generated);
+    }
+
+    /// Test that we generate the procedure module that we expect.
+    #[test]
+    fn test_minimal_procedure() {
+        let mod_type = &ModuleType::Procedure;
+        let mod_title = "Minimal procedure";
+        let options = minimal_options();
+        let procedure = Module::new(mod_type, mod_title, &options);
+
+        let pre_generated = include_str!("../data/generated/minimal-procedure.adoc");
+
+        assert_eq!(procedure.text, pre_generated);
+    }
+
+    /// Test that we generate the reference module that we expect.
+    #[test]
+    fn test_minimal_reference() {
+        let mod_type = &ModuleType::Reference;
+        let mod_title = "Minimal reference";
+        let options = minimal_options();
+        let reference = Module::new(mod_type, mod_title, &options);
+
+        let pre_generated =
+            include_str!("../data/generated/minimal-reference.adoc");
+
+        assert_eq!(reference.text, pre_generated);
+    }
 }