Created regression tests for the table of contents

Author: Michael-F-Bryan

Cargo.toml

@@ -43,6 +43,11 @@ ws = { version = "0.7", optional = true}
 [build-dependencies]
 error-chain = "0.11"
 
+[dev-dependencies]
+select = "0.4"
+pretty_assertions = "*"
+walkdir = "1.0"
+
 [features]
 default = ["output", "watch", "serve"]
 debug = []

tests/dummy/mod.rs

@@ -2,14 +2,21 @@
 //! dummy contents from the `tests/dummy-book/` directory.
 
 // Not all features are used in all test crates, so...
-#![allow(dead_code, unused_extern_crates)]
-
+#![allow(dead_code, unused_variables, unused_imports, unused_extern_crates)]
+extern crate mdbook;
 extern crate tempdir;
+extern crate walkdir;
 
-use std::fs::{create_dir_all, File};
-use std::io::Write;
+use std::path::Path;
+use std::fs::{self, File};
+use std::io::{Read, Write};
+use std::error::Error;
 
-use tempdir::TempDir;
+// The funny `self::` here is because we've got an `extern crate ...` and are
+// in a submodule
+use self::tempdir::TempDir;
+use self::walkdir::WalkDir;
+use self::mdbook::MDBook;
 
 
 const SUMMARY_MD: &'static str = include_str!("book/SUMMARY.md");
@@ -55,10 +62,10 @@ impl DummyBook {
         let temp = TempDir::new("dummy_book").unwrap();
 
         let src = temp.path().join("src");
-        create_dir_all(&src).unwrap();
+        fs::create_dir_all(&src).unwrap();
 
         let first = src.join("first");
-        create_dir_all(&first).unwrap();
+        fs::create_dir_all(&first).unwrap();
 
         let to_substitute = if self.passing_test { "true" } else { "false" };
         let nested_text = NESTED.replace("$TEST_STATUS", to_substitute);
@@ -85,3 +92,64 @@ impl Default for DummyBook {
         DummyBook { passing_test: true }
     }
 }
+
+
+/// Read the contents of the provided file into memory and then iterate through
+/// the list of strings asserting that the file contains all of them.
+pub fn assert_contains_strings<P: AsRef<Path>>(filename: P, strings: &[&str]) {
+    let filename = filename.as_ref();
+
+    let mut content = String::new();
+    File::open(&filename)
+        .expect("Couldn't open the provided file")
+        .read_to_string(&mut content)
+        .expect("Couldn't read the file's contents");
+
+    for s in strings {
+        assert!(content.contains(s), "Searching for {:?} in {}\n\n{}", s, filename.display(), content);
+    }
+}
+
+
+/// Copy the example book to a temporary directory and build it.
+pub fn build_example_book() -> TempDir {
+    let temp = TempDir::new("mdbook").expect("Couldn't create a temporary directory");
+    let book_root = Path::new(env!("CARGO_MANIFEST_DIR")).join("book-example");
+
+    recursive_copy(&book_root, temp.path()).expect("Couldn't copy the book example to a temporary directory");
+
+    let book = MDBook::new(temp.path()).build().expect("Building failed");
+    temp
+}
+
+
+/// Recursively copy an entire directory tree to somewhere else (a la `cp -r`).
+fn recursive_copy<A: AsRef<Path>, B: AsRef<Path>>(from: A, to: B) -> Result<(), Box<Error>> {
+    let from = from.as_ref();
+    let to = to.as_ref();
+
+    for entry in WalkDir::new(&from) {
+        let entry = entry?;
+
+        let original_location = entry.path();
+        let relative = original_location.strip_prefix(&from)?;
+        let new_location = to.join(relative);
+
+        if original_location.is_file() {
+            if let Some(parent) = new_location.parent() {
+                fs::create_dir_all(parent)?;
+            }
+
+            fs::copy(&original_location, &new_location)?;
+        }
+    }
+
+    Ok(())
+}
+
+pub fn read_file<P: AsRef<Path>>(filename: P) -> Result<String, Box<Error>> {
+    let mut contents = String::new();
+    File::open(filename)?.read_to_string(&mut contents)?;
+
+    Ok(contents)
+}

tests/regression.rs

@@ -0,0 +1,151 @@
+//! High-level regression testing which will build the example book and *try*
+//! to make sure key elements don't get accidentally broken.
+//!
+//! # Warning
+//!
+//! These tests will need to be updated every time the example book changes.
+//! Hopefully Travis will let you know when that happens.
+
+#![feature(conservative_impl_trait)]
+
+extern crate mdbook;
+#[macro_use]
+extern crate pretty_assertions;
+extern crate select;
+extern crate tempdir;
+extern crate walkdir;
+
+mod helpers;
+
+use std::path::Path;
+use walkdir::{WalkDir, WalkDirIterator};
+use select::document::Document;
+use select::predicate::{Class, Descendant, Name, Predicate};
+
+
+const BOOK_ROOT: &'static str = concat!(env!("CARGO_MANIFEST_DIR"), "/book-example");
+const TOC_TOP_LEVEL: &[&'static str] = &[
+    "1. mdBook",
+    "2. Command Line Tool",
+    "3. Format",
+    "4. Rust Library",
+    "Contributors",
+];
+const TOC_SECOND_LEVEL: &[&'static str] = &[
+    "2.1. init",
+    "2.2. build",
+    "2.3. watch",
+    "2.4. serve",
+    "2.5. test",
+    "3.1. SUMMARY.md",
+    "3.2. Configuration",
+    "3.3. Theme",
+    "3.4. MathJax Support",
+    "3.5. Rust code specific features",
+];
+const TOC_THIRD_LEVEL: &[&'static str] = &["3.3.1. index.hbs", "3.3.2. Syntax highlighting"];
+
+/// Apply a series of predicates to some root predicate, where each
+/// successive predicate is the descendant of the last one.
+macro_rules! descendants {
+    ($root:expr, $($child:expr),*) => {
+        $root
+        $(
+            .descendant($child)
+        )*
+    };
+}
+
+
+/// Make sure that all `*.md` files (excluding `SUMMARY.md`) were rendered
+/// and placed in the `book` directory with their extensions set to `*.html`.
+#[test]
+fn chapter_files_were_rendered_to_html() {
+    let temp = helpers::build_example_book();
+    let src = Path::new(BOOK_ROOT).join("src");
+
+    let chapter_files = WalkDir::new(&src)
+        .into_iter()
+        .filter_entry(|entry| entry.file_name().to_string_lossy().ends_with(".md"))
+        .filter_map(|entry| entry.ok())
+        .map(|entry| entry.path().to_path_buf())
+        .filter(|path| path.file_name().unwrap() != "SUMMARY");
+
+    for chapter in chapter_files {
+        let rendered_location = temp.path()
+            .join(chapter.strip_prefix(&src).unwrap())
+            .with_extension("html");
+        assert!(rendered_location.exists(), "{} doesn't exits", rendered_location.display());
+    }
+}
+
+fn root_index_html() -> Document {
+    let temp = helpers::build_example_book();
+
+    let index_page = temp.path().join("book").join("index.html");
+    let html = helpers::read_file(&index_page).unwrap();
+    Document::from(html.as_str())
+}
+
+#[test]
+fn check_third_toc_level() {
+    let doc = root_index_html();
+    let should_be = TOC_THIRD_LEVEL;
+
+    let children_of_children_of_children: Vec<String> = doc.find(
+        Class("chapter")
+            .descendant(Name("li"))
+            .descendant(Name("li"))
+            .descendant(Name("li"))
+            .descendant(Name("a")),
+    ).map(|elem| elem.text().trim().to_string())
+        .collect();
+    assert_eq!(children_of_children_of_children, should_be);
+}
+
+#[test]
+fn check_second_toc_level() {
+    let doc = root_index_html();
+    let mut should_be = Vec::from(TOC_SECOND_LEVEL);
+
+    should_be.extend(TOC_THIRD_LEVEL);
+    should_be.sort();
+
+    let pred = descendants!(Class("chapter"), Name("li"), Name("li"), Name("a"));
+
+    let mut children_of_children: Vec<String> = doc.find(pred)
+        .map(|elem| elem.text().trim().to_string())
+        .collect();
+    children_of_children.sort();
+
+    assert_eq!(children_of_children, should_be);
+}
+
+#[test]
+fn check_first_toc_level() {
+    let doc = root_index_html();
+    let mut should_be = Vec::from(TOC_TOP_LEVEL);
+
+    should_be.extend(TOC_SECOND_LEVEL);
+    should_be.extend(TOC_THIRD_LEVEL);
+    should_be.sort();
+
+    let pred = descendants!(Class("chapter"), Name("li"), Name("a"));
+
+    let mut children: Vec<String> = doc.find(pred)
+        .map(|elem| elem.text().trim().to_string())
+        .collect();
+    children.sort();
+
+    assert_eq!(children, should_be);
+}
+
+#[test]
+fn check_spacers() {
+    let doc = root_index_html();
+    let should_be = 1;
+
+    let num_spacers = doc.find(Class("chapter").descendant(Name("li").and(Class("spacer"))))
+        .count();
+    assert_eq!(num_spacers, should_be);
+}