Setup for test case builder CLI

Author: paudrow

src/common/src/types/test_cases_builder.rs

@@ -3,23 +3,61 @@ use std::collections::HashMap;
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct TestCasesBuilder {
+    /// The name of the test case builder.
     pub name: String,
+    /// The description of the test case builder.
     pub description: String,
+    /// The set of steps to build the test cases.
     pub set: Vec<SetSteps>,
+    /// The labels to apply to the test cases.
     pub labels: Option<Vec<String>>,
+    /// The permutations to apply to the test cases.
     pub permutations: HashMap<String, Vec<String>>,
+    /// The pub version of the test cases.
     pub version: u8,
 }
 
+impl TestCasesBuilder {
+    pub fn default() -> Self {
+        let mut permutations = HashMap::new();
+        permutations.insert(
+            "Operating System".to_string(),
+            vec![
+                "Ubuntu 22.04".to_string(),
+                "Windows 11".to_string(),
+                "MacOS 12.0".to_string(),
+            ],
+        );
+
+        TestCasesBuilder {
+            name: "Demo test cases".to_string(),
+            description: "description".to_string(),
+            set: vec![SetSteps::Include(Filter {
+                all_labels: None,
+                any_names: None,
+                negate: false,
+            })],
+            labels: Some(vec!["Demo".to_string()]),
+            permutations,
+            version: 1,
+        }
+    }
+}
+
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub enum SetSteps {
+    /// Include requirements that match the filter
     Include(Filter),
+    /// Exclude requirements that match the filter
     Exclude(Filter),
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct Filter {
+    /// The labels to filter the requirements.
     pub all_labels: Option<Vec<String>>,
+    /// The names to filter the requirements.
     pub any_names: Option<Vec<String>>,
+    /// If the filter should negate the result.
     pub negate: bool,
 }

src/yatm_v2/src/app/cli.rs

@@ -1,20 +1,19 @@
 use crate::app::load_config::load_config;
-use crate::app::requirements_validate::get_requirements_from_files;
+use crate::app::requirements::get_requirements_from_files;
 use crate::app::{
-    init_config::init_config,
-    requirements_validate::{
+    init_workspace::init_workspace,
+    requirements::{
         get_requirements_from_file, validate_requirements_file, validate_requirements_files,
     },
 };
-use crate::types::RequirementsFile;
-use common::types::Requirement;
+use crate::types::{RequirementsFile, TestCasesBuilderFile};
 
 use std::path::PathBuf;
 
 use anyhow::{Context, Ok, Result};
 use clap::{Parser, Subcommand};
 
-use super::requirements_validate::get_requirements_files;
+use super::requirements::get_requirements_files;
 
 // Define the main application
 #[derive(Parser)]
@@ -27,9 +26,9 @@ struct App {
 // Define the top-level subcommands
 #[derive(Subcommand)]
 enum Commands {
-    /// Create a directory to start working from
+    /// Create a new YATM workspace
     Init {
-        /// The path to the project
+        /// The path to the new workspace
         #[clap(short, long)]
         path: PathBuf,
     },
@@ -91,6 +90,14 @@ struct Subcommand1Options {
 
 #[derive(Subcommand)]
 enum TestCasesSubcommands {
+    /// Create a new test case builder
+    New {
+        /// The path to the project
+        #[clap(short, long, default_value = ".")]
+        config_path: PathBuf,
+        #[clap(short, long)]
+        file_name: Option<String>,
+    },
     /// Check the test cases
     Validate,
     /// List the test cases
@@ -113,8 +120,8 @@ pub fn cli() -> Result<()> {
     let app = App::parse();
     match app.command {
         Commands::Init { path } => {
-            init_config(&path)?;
-            println!("Created the project in {:?}", path);
+            init_workspace(&path)?;
+            println!("Created a YATM workspace in {:?}", path);
         }
         Commands::Requirements { subcommand } => match subcommand {
             RequirementsSubcommands::New {
@@ -133,10 +140,7 @@ pub fn cli() -> Result<()> {
                     }
                 };
 
-                if config.requirements_dirs.len() < 1 {
-                    anyhow::bail!("No requirements directories found");
-                }
-                let requirements_file_path = config.requirements_dirs[0].join(file_name);
+                let requirements_file_path = config.new_requirements_dir.join(file_name);
                 if requirements_file_path.exists() {
                     anyhow::bail!(
                         "The requirements file already exists: {:?}",
@@ -187,6 +191,44 @@ pub fn cli() -> Result<()> {
             }
         },
         Commands::TestCases { subcommand } => match subcommand {
+            TestCasesSubcommands::New {
+                config_path,
+                file_name,
+            } => {
+                let config = load_config(&config_path)?;
+
+                let file_name = match file_name {
+                    Some(file_name) => file_name,
+                    None => {
+                        // get datetime string in current timezone
+                        let datetime_string =
+                            chrono::Local::now().format("%Y-%m-%d-%H-%M-%S").to_string();
+                        format!("test_cases_builder-{}.yaml", datetime_string)
+                    }
+                };
+
+                let test_cases_builder_file_path =
+                    config.new_test_cases_builder_dir.join(file_name);
+                if test_cases_builder_file_path.exists() {
+                    anyhow::bail!(
+                        "The test cases builder file already exists: {:?}",
+                        test_cases_builder_file_path
+                    );
+                }
+                let test_cases_builder_file = TestCasesBuilderFile::default();
+                let test_cases_builder_file = serde_yaml::to_string(&test_cases_builder_file)
+                    .context("Failed to turn test cases builder file into a string")?;
+                std::fs::write(&test_cases_builder_file_path, test_cases_builder_file).context(
+                    format!(
+                        "Failed to write the test cases builder file: {:?}",
+                        test_cases_builder_file_path
+                    ),
+                )?;
+                println!(
+                    "Created the test cases builder file: {:?}",
+                    test_cases_builder_file_path
+                );
+            }
             TestCasesSubcommands::Validate => {
                 println!("Running validate");
             }
@@ -220,6 +262,8 @@ mod test_cli {
     use predicates::prelude::predicate;
     use tempfile::tempdir;
 
+    use crate::app::load_config::load_config;
+
     fn get_command() -> Command {
         Command::cargo_bin(env!("CARGO_PKG_NAME")).unwrap()
     }
@@ -249,15 +293,18 @@ mod test_cli {
         cmd.args(&["init", "--path", dir.to_str().unwrap()])
             .assert()
             .success()
-            .stdout(predicate::str::contains("Created the project in"));
+            .stdout(predicate::str::contains("Created a YATM workspace in"));
 
-        // check that files are generated correctly
+        // load the config
         assert!(dir.join("config.yaml").is_file());
-        assert!(dir.join(".generated_files").is_dir());
+        let config = load_config(&dir).unwrap();
+
+        // check that files are generated correctly
+        assert!(config.new_requirements_dir.is_dir());
+        assert!(config.new_test_cases_builder_dir.is_dir());
+        assert!(config.generated_files_dir.is_dir());
         assert!(dir.join(".gitignore").is_file());
-        let requirements_dir = dir.join("requirements");
-        assert!(requirements_dir.is_dir());
-        assert_eq!(get_number_of_files_in_dir(&requirements_dir), 1);
+        assert_eq!(get_number_of_files_in_dir(&config.new_requirements_dir), 1);
 
         // run the requirements new command
         let new_requirements_file_name = "my-test-requirements.yaml";
@@ -272,9 +319,10 @@ mod test_cli {
         ])
         .assert()
         .success();
-        let new_requirements_file_path = requirements_dir.join(new_requirements_file_name);
+        let new_requirements_file_path =
+            config.new_requirements_dir.join(new_requirements_file_name);
         assert!(new_requirements_file_path.is_file());
-        assert_eq!(get_number_of_files_in_dir(&requirements_dir), 2);
+        assert_eq!(get_number_of_files_in_dir(&config.new_requirements_dir), 2);
 
         // run the requirements new command without a file name
         let mut cmd = get_command();
@@ -286,7 +334,7 @@ mod test_cli {
         ])
         .assert()
         .success();
-        assert_eq!(get_number_of_files_in_dir(&requirements_dir), 3);
+        assert_eq!(get_number_of_files_in_dir(&config.new_requirements_dir), 3);
 
         // run the requirements list command
         let mut cmd = get_command();

src/yatm_v2/src/app/init_config.rs renamed to src/yatm_v2/src/app/init_workspace.rs

@@ -1,11 +1,13 @@
-use crate::types::Config;
+use crate::types::{Config, RequirementsFile, TestCasesBuilderFile};
 use anyhow::{Context, Result};
 use serde_yaml;
 use std::path::PathBuf;
 
-pub fn init_config(dir: &PathBuf) -> Result<()> {
+/// Initialize the configuration directory.
+pub fn init_workspace(dir: &PathBuf) -> Result<()> {
     make_sure_empty_dir_exists(dir)?;
 
+    // Create the config file
     let config = Config::default();
     let config_file = dir.join("config.yaml");
     std::fs::write(
@@ -14,24 +16,36 @@ pub fn init_config(dir: &PathBuf) -> Result<()> {
     )
     .context("Failed to write the config file")?;
 
-    if config.requirements_dirs.len() == 1 {
-        let requirements_dir = dir.join(&config.requirements_dirs[0]);
-        make_sure_empty_dir_exists(&requirements_dir)?;
-        let datetime_string = chrono::Utc::now().format("%Y%m%d%H%M%S").to_string();
-        let requirements_file_path =
-            requirements_dir.join(format!("requirements-{}.yaml", datetime_string));
-        let requirements_file = crate::types::RequirementsFile::default();
-        std::fs::write(
-            &requirements_file_path,
-            serde_yaml::to_string(&requirements_file)
-                .context("Failed to serialize the requirements")?,
-        )?;
-    }
+    // Get the current datetime for naming files
+    let datetime_string = chrono::Utc::now().format("%Y-%m-%d-%H-%M-%S").to_string();
+
+    // Create the requirements directory and file
+    let requirements_dir = dir.join(&config.new_requirements_dir);
+    make_sure_empty_dir_exists(&requirements_dir)?;
+    let requirements_file_path =
+        requirements_dir.join(format!("requirements-{}.yaml", datetime_string));
+    let requirements_file = RequirementsFile::default();
+    std::fs::write(
+        &requirements_file_path,
+        serde_yaml::to_string(&requirements_file)
+            .context("Failed to serialize the requirements")?,
+    )?;
+
+    // Create the test cases builder directory and file
+    let test_cases_builder_dir = dir.join(&config.new_test_cases_builder_dir);
+    make_sure_empty_dir_exists(&test_cases_builder_dir)?;
+    let test_cases_builder_file =
+        test_cases_builder_dir.join(format!("test_cases_builder-{}.yaml", datetime_string));
+    std::fs::write(
+        &test_cases_builder_file,
+        serde_yaml::to_string(&TestCasesBuilderFile::default())
+            .context("Failed to serialize the test cases builder")?,
+    )
+    .context("Failed to write the test cases builder file")?;
 
+    // Create the generated files directory and .gitignore file
     let generated_files_dir = dir.join(&config.generated_files_dir);
     make_sure_empty_dir_exists(&generated_files_dir)?;
-
-    // add a .gitignore file with the generated_files_dir
     let gitignore_file = dir.join(".gitignore");
     std::fs::write(
         &gitignore_file,
@@ -44,41 +58,37 @@ pub fn init_config(dir: &PathBuf) -> Result<()> {
 
 #[cfg(test)]
 mod test_init_config {
-    use super::init_config;
+    use crate::app::load_config::load_config;
+
+    use super::init_workspace;
     use std::fs;
     use tempfile::tempdir;
 
     #[test]
     fn init_config_creates_files() {
         let dir = tempdir().unwrap().path().to_path_buf();
-        init_config(&dir).unwrap();
+        init_workspace(&dir).unwrap();
         assert!(dir.join("config.yaml").is_file());
 
-        let requirements_dir = dir.join("requirements");
-        assert!(requirements_dir.is_dir());
-
-        // check the requirements file is created
-        let mut entries = fs::read_dir(&requirements_dir).unwrap();
-        assert!(entries.next().is_some());
-        assert!(entries.next().is_none());
+        let config = load_config(&dir).unwrap();
 
-        assert!(dir.join(".generated_files").is_dir());
-        assert!(dir.join(".gitignore").is_file());
+        assert!(config.new_requirements_dir.is_dir());
+        assert!(config.new_test_cases_builder_dir.is_dir());
     }
 
     #[test]
     fn init_config_exists_not_empty() {
         let dir = tempdir().unwrap().path().to_path_buf();
         fs::create_dir(&dir).unwrap();
         fs::File::create(dir.join("file")).unwrap();
-        assert!(init_config(&dir).is_err());
+        assert!(init_workspace(&dir).is_err());
     }
 
     #[test]
     fn init_config_exists_file() {
         let dir = tempdir().unwrap().path().to_path_buf();
         fs::File::create(&dir).unwrap();
-        assert!(init_config(&dir).is_err());
+        assert!(init_workspace(&dir).is_err());
     }
 }
 

src/yatm_v2/src/app/load_config.rs

@@ -3,6 +3,7 @@ use anyhow::{Context, Result};
 use serde_yaml;
 use std::path::PathBuf;
 
+/// Load the configuration.
 pub fn load_config(path: &PathBuf) -> Result<Config> {
     let mut path = path.clone();
     if path.is_dir() {
@@ -14,15 +15,23 @@ pub fn load_config(path: &PathBuf) -> Result<Config> {
     let mut config = serde_yaml::from_str::<Config>(&config)
         .context(format!("Failed to deserialize the config: {:?}", path))?;
 
+    // Update the paths to be relative to the config file
     let parent_dir = path
         .parent()
         .context(format!("Failed to get the parent directory: {:?}", path))?;
-    config.generated_files_dir = parent_dir.join(config.generated_files_dir);
     config.requirements_dirs = config
         .requirements_dirs
         .iter()
         .map(|dir| parent_dir.join(dir))
         .collect();
+    config.new_requirements_dir = parent_dir.join(config.new_requirements_dir);
+    config.test_cases_builders_dirs = config
+        .test_cases_builders_dirs
+        .iter()
+        .map(|file| parent_dir.join(file))
+        .collect();
+    config.new_test_cases_builder_dir = parent_dir.join(config.new_test_cases_builder_dir);
+    config.generated_files_dir = parent_dir.join(config.generated_files_dir);
 
     Ok(config)
 }

src/yatm_v2/src/app/mod.rs

@@ -1,6 +1,6 @@
 mod cli;
-mod init_config;
+mod init_workspace;
 mod load_config;
-mod requirements_validate;
+mod requirements;
 
 pub use cli::cli;