Seite 3: Bedingte Kompilierung für automatisierte Tests

#[derive(Debug, PartialEq, Eq)]
pub enum RecipeType { Traditional, Vegetarian, Vegan, }

pub mod caesar_salad {
  use super::*;

  // Get ingredients for a Caesar salad
  pub fn get_ingredients(recipe_type: RecipeType) 
    -> Vec<&'static str> 
  {
    let mut ingredients = vec![
      "Romaine lettuce", "Croutons", "Lemon juice",
      "Olive oil", "Salt", "Black pepper",
    ];

    ingredients.push(match recipe_type {
      RecipeType::Traditional | 
      RecipeType::Vegetarian => "Parmesan cheese",
      _ => "Vegan Parmesan cheese substitute",
    });

    ingredients.extend_from_slice(match recipe_type {
      RecipeType::Traditional 
        => &["Anchovies", "Egg yolks"],
      RecipeType::Vegetarian 
        => &["Capers", "Egg yolks"],
      _ => &["Capers", "Vegan mayonnaise"],
    });

    ingredients
  }
}

// The code for automated tests must only be
// compiled when the test suite is run (cargo test).
#[cfg(test)]
mod tests {
  use super::*;

  #[test]
  fn no_anchovies_in_vegetarian() {
    let ingredients = 
      caesar_salad::get_ingredients(RecipeType::Vegetarian);
    // Make sure there are no anchovies in a 
    //vegetarian salad
    assert!(!ingredients.contains(&"Anchovies"));
  }

  // Add additional tests here
}

toml
[package]
name = "recipe_reader"
version = "0.1.0"
edition = "2021"

[features]
default = ["json"]
all = ["json", "yaml"]
json = ["dep:serde_json"]
yaml = ["dep:serde_yaml"]

[dependencies]
serde = { version = "1", features = ["derive"] }
serde_json = { version = "1", optional = true }
serde_yaml = { version = "0", optional = true }
anyhow = "1"

[dev-dependencies]
mockall = "0"

#[cfg(any(feature = "json", feature = "yaml"))]
use std::{fs::File, io::Read};

use anyhow::Result;
use serde::Deserialize;

// We only reference automock when testing
#[cfg(test)]
use mockall::automock;

#[derive(Debug, Deserialize)]
pub struct Recipe {
  pub title: String,
  pub ingredients: Option<Vec<String>>,
  pub steps: Option<Vec<String>>,
}

// We add the automock attribute to the trait
// ONLY when testing. This is where cfg_attr
// comes in handy.
#[cfg_attr(test, automock)]
pub trait RecipeReader {
  fn read_from_file(&self, path: &str) -> Result<Recipe>;
}

// The json module with the JsonRecipeReader is
// only compiled when the json feature is enabled.
#[cfg(feature = "json")]
pub mod json
{
  use super::*;

  pub struct JsonRecipeReader();

  impl RecipeReader for JsonRecipeReader {
     fn read_from_file(&self, path: &str) 
       -> Result<Recipe> {
       let mut contents = String::new();
       File::open(path)?.read_to_string(&mut contents)?;
       Ok(serde_json::from_str(&contents)?)
     }
  }
}

// The yaml module with the YamlRecipeReader is
// only compiled when the yaml feature is enabled.
#[cfg(feature = "yaml")]
pub mod yaml
{
  use super::*;
    
  pub struct YamlRecipeReader();

  impl RecipeReader for YamlRecipeReader {
    fn read_from_file(&self, path: &str) 
      -> Result<Recipe> 
    {
      let mut contents = String::new();
      File::open(path)?.read_to_string(&mut contents)?;
      Ok(serde_yaml::from_str(&contents)?)
    }
  }
}

pub struct RecipeMarkdownFactory();

impl RecipeMarkdownFactory {
  pub fn file_to_markdown(&self, 
                          path: &str, 
                          reader: impl RecipeReader) 
    -> Result<String> 
  {
    // Read recipe from file using a reader
    let recipe = reader.read_from_file(path)?;

    // Convert recipe into markdown
    let mut markdown = String::new();
    markdown.push_str(&format!("# {}\n\n", 
                      recipe.title));
    if let Some(i) = recipe.ingredients {
      markdown.push_str("## Ingredients\n\n");
      for ingredient in i {
        markdown.push_str(&format!("* {ingredient}\n"));
      }
      markdown.push('\n');
    }

    if let Some(s) = recipe.steps{
      markdown.push_str("## Steps\n\n");
      for (i, step) in s.iter().enumerate() {
        markdown.push_str(&format!("{}. {step}\n",
                          i + 1));
      }
    }

    Ok(markdown)
  }
}

// The code for automated tests must only be 
// compiled when the test suite is run (cargo test).
#[cfg(test)]
mod tests {
  use mockall::predicate::eq;

  use super::*;

  // Parts of the tests are only compiled when the 
  // corresponding feature is enabled.
  #[cfg(feature = "json")]
  use super::json::*;
  #[cfg(feature = "yaml")]
  use super::yaml::*;

  #[cfg(any(feature = "json", feature = "yaml"))]
  fn get_expected_markdown() -> String {
    let mut markdown = String::new();
    File::open("caesar_expected.md")
      .unwrap().read_to_string(&mut markdown).unwrap();
    markdown
  }

  #[cfg(feature = "json")]
  #[test]
  fn json_caesar_salad_to_markdown() {
    let reader = JsonRecipeReader();
    let markdown_factory = RecipeMarkdownFactory();
    let markdown = 
    markdown_factory
     .file_to_markdown("caesar_salad.json", 
                       reader).unwrap();

    assert_eq!(markdown, get_expected_markdown());
  }

  #[cfg(feature = "yaml")]
  #[test]
  fn yaml_caesar_salad_to_markdown() {
    let reader = YamlRecipeReader();
    let markdown_factory = RecipeMarkdownFactory();
    let markdown = 
      markdown_factory
        .file_to_markdown("caesar_salad.yaml", 
                          reader).unwrap();

    assert_eq!(markdown, get_expected_markdown());
  }

  #[test]
  fn no_ingredients() {
    // Here we use the mockall crate to create a mock
    // of the RecipeReader trait. We can then use this
    // mock to test the RecipeMarkdownFactory without
    // having to read from a file.
    let mut reader_mock = MockRecipeReader::new();
    reader_mock
      .expect_read_from_file()
      .with(eq("no_ingredients.json"))
      .returning(|_| {
        Ok(Recipe {
          title: "No Ingredients".to_string(),
          ingredients: None,
          steps: Some(vec!["Step 1".to_string(), 
                           "Step 2".to_string()]),
        })
    });
        
    let markdown_factory = RecipeMarkdownFactory();
    let markdown = markdown_factory
     .file_to_markdown("no_ingredients.json", 
                       reader_mock).unwrap();

    assert!(!markdown.contains("## Ingredients"));
  }
}