regression test and error overhaul

Alexander Weber · Alexander Weber · commit b15f3285d071 · 2023-03-04T13:57:55.000+01:00
diff --git a/.neomake.yaml b/.neomake.yaml
@@ -0,0 +1,13 @@
+version: 0.3
+
+chains:
+  "test:regression":
+    env:
+      config: "./test/.complate/config.yaml"
+    tasks:
+      - script: |
+          set -e
+          export RUST_BACKTRACE=1
+          printf $config
+          bravo="bravo" cargo run -- render -c $config -t static
+          bravo="bravo" cargo run -- -e render -c $config -t override -v c.charlie="charlie"
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -38,3 +38,4 @@ serde_yaml = "^0.8"
 cursive = { version = "^0.16", optional = true }
 dialoguer = { version = "^0.8", optional = true }
 fui = { version = "^2.0", optional = true }
+thiserror = "1.0.38"
diff --git a/src/args/mod.rs b/src/args/mod.rs
@@ -2,6 +2,8 @@ use std::{collections::HashMap, result::Result, str::FromStr};
 
 use clap::{Arg, ArgAction};
 
+use crate::error::Error;
+
 #[derive(Debug)]
 pub struct CallArgs {
     pub privileges: Privilege,
@@ -14,9 +16,7 @@ impl CallArgs {
         match &self.command {
             | Command::Render(args) => {
                 if args.helpers && args.shell_trust != ShellTrust::Ultimate {
-                    return Err(Box::new(crate::error::NoShellTrust::new(
-                        "need ultimate shell trust for helper functions",
-                    )));
+                    return Err(Box::new(Error::NoTrust));
                 }
             },
             | _ => {},
@@ -27,21 +27,15 @@ impl CallArgs {
                 | Command::Render(args) => {
                     match args.backend {
                         #[cfg(feature = "backend+ui")]
-                        | Backend::UI => {
-                            return Err(Box::new(crate::error::NeedExperimentalFlag::new(
-                                "to enable UI backend",
-                            )))
-                        },
+                        | Backend::UI => return Err(Box::new(Error::ExperimentalCommand)),
                         #[cfg(feature = "backend+cli")]
                         | Backend::CLI => {},
                     };
                     if args.value_overrides.len() > 0 {
-                        return Err(Box::new(crate::error::NeedExperimentalFlag::new(
-                            "to enable value overrides",
-                        )));
+                        return Err(Box::new(Error::ExperimentalCommand));
                     }
                     if args.helpers {
-                        return Err(Box::new(crate::error::NeedExperimentalFlag::new("to enable helpers")));
+                        return Err(Box::new(Error::ExperimentalCommand));
                     }
                     #[allow(unreachable_code)]
                     Ok(())
@@ -222,7 +216,7 @@ impl ClapArgumentLoader {
                 | "cli" => Backend::CLI,
                 #[cfg(feature = "backend+ui")]
                 | "ui" => Backend::UI,
-                | _ => return Err(Box::new(crate::error::Failed::new("no backend specified"))),
+                | _ => return Err(Box::new(Error::Argument("no backend specified".into()))),
             };
             let helpers = subc.get_flag("helpers");
 
@@ -239,7 +233,7 @@ impl ClapArgumentLoader {
                 }),
             })
         } else {
-            return Err(Box::new(crate::error::Failed::new("unknown subcommand")));
+            return Err(Box::new(Error::UnknownCommand));
         }
     }
 }
diff --git a/src/error.rs b/src/error.rs
@@ -1,36 +1,25 @@
-macro_rules! make_error {
-    ($name:ident) => {
-        #[derive(Debug, Clone)]
-        /// An error type.
-        pub struct $name {
-            details: String,
-        }
+use thiserror::Error;
 
-        impl $name {
-            pub fn default() -> Self {
-                Self::new("")
-            }
-
-            /// Error type constructor.
-            pub fn new(details: &str) -> Self {
-                Self {
-                    details: details.to_owned(),
-                }
-            }
-        }
-
-        impl std::fmt::Display for $name {
-            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                f.write_str(&self.details)
-            }
-        }
-
-        impl std::error::Error for $name {}
-    };
+#[derive(Debug, Error)]
+pub(crate) enum Error {
+    #[error("std")]
+    Std(#[from] Box<dyn std::error::Error + Sync + Send>),
+    #[error("generic")]
+    Generic(String),
+    // #[error("many")]
+    // Many(Vec<Self>),
+    #[error("argument")]
+    Argument(String),
+    #[error("experimental command")]
+    ExperimentalCommand,
+    #[error("unknown command")]
+    UnknownCommand,
+    #[error("no trust")]
+    NoTrust,
+    #[error("shell command")]
+    ShellCommand(String),
+    #[error("user interact abort")]
+    InteractAbort,
+    #[error("helper")]
+    Helper(String),
 }
-
-make_error!(Failed);
-make_error!(NeedExperimentalFlag);
-make_error!(UnknownCommand);
-make_error!(UserAbort);
-make_error!(NoShellTrust);
diff --git a/src/main.rs b/src/main.rs
@@ -18,13 +18,13 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     match cmd.command {
         | crate::args::Command::Man(path) => {
             let out_path = PathBuf::from(path);
-            std::fs::create_dir_all(&out_path).unwrap();
+            std::fs::create_dir_all(&out_path)?;
             reference::build_manpages(&out_path)?;
             Ok(())
         },
         | crate::args::Command::Autocomplete(path, shell) => {
             let out_path = PathBuf::from(path);
-            std::fs::create_dir_all(&out_path).unwrap();
+            std::fs::create_dir_all(&out_path)?;
             reference::build_shell_completion(&out_path, &shell)?;
             Ok(())
         },
diff --git a/src/render/cli.rs b/src/render/cli.rs
@@ -1,3 +1,5 @@
+use crate::error::Error;
+
 use super::UserInput;
 use async_trait::async_trait;
 use std::{collections::HashMap, result::Result};
@@ -17,7 +19,7 @@ impl<'a> UserInput for CLIBackend<'a> {
     async fn prompt(&self, text: &str) -> Result<String, Box<dyn std::error::Error>> {
         match dialoguer::Input::new().allow_empty(true).with_prompt(text).interact() {
             | Ok(res) => Ok(res),
-            | Err(_) => Err(Box::new(crate::error::Failed::default())),
+            | Err(_) => Err(Box::new(Error::InteractAbort)),
         }
     }
 
@@ -53,8 +55,7 @@ impl<'a> UserInput for CLIBackend<'a> {
         let indices = dialoguer::MultiSelect::new()
             .with_prompt(prompt)
             .items(&display_vals)
-            .interact()
-            .unwrap();
+            .interact()?;
 
         match indices.len() {
             | 0usize => Ok("".to_owned()),
diff --git a/src/render/mod.rs b/src/render/mod.rs
@@ -1,5 +1,6 @@
 use crate::args::{Backend, ShellTrust};
 use crate::config::{Config, Content, Option, OptionValue, Template, VariableDefinition};
+use crate::error::Error;
 use async_trait::async_trait;
 use std::collections::{BTreeMap, HashMap};
 use std::env;
@@ -58,14 +59,24 @@ pub async fn render(
                                _: &mut handlebars::RenderContext,
                                out: &mut dyn handlebars::Output|
                   -> handlebars::HelperResult {
-                let param = h.param(0).unwrap();
+                let param = h
+                    .param(0)
+                    .ok_or_else(|| Error::Helper("no parameter to helper function found".into()))
+                    .unwrap();
                 // dbg!(param);
                 let cmd = helper.1.shell.to_owned();
 
                 let output = std::process::Command::new("sh")
                     .arg("-c")
                     .arg(cmd)
-                    .env("VALUE", param.value().as_str().unwrap())
+                    .env(
+                        "VALUE",
+                        param
+                            .value()
+                            .as_str()
+                            .ok_or_else(|| Error::Helper("parameter is not a string".into()))
+                            .unwrap(),
+                    )
                     .output()?;
                 if output.status.code().unwrap() != 0 {
                     return Err(handlebars::RenderError::new("failed to get command status"));
@@ -78,8 +89,7 @@ pub async fn render(
         }
     }
 
-    let rendered_template = hb.render_template(template, &values_json).unwrap();
-    Ok(rendered_template)
+    Ok(hb.render_template(template, &values_json)?)
 }
 
 #[allow(clippy::needless_lifetimes)]
@@ -105,7 +115,7 @@ pub async fn select_template<'a>(
 
     match config.templates.get(&selection) {
         | Some(x) => Ok(x),
-        | None => Err(Box::new(crate::error::Failed::default())),
+        | None => Err(Box::new(Error::Generic("invalid template selection".into()))),
     }
 }
 
@@ -132,7 +142,10 @@ pub async fn select_and_render(
     let cfg: Config = serde_yaml::from_str(&invoke_options.configuration).unwrap();
 
     let template = match &invoke_options.template {
-        | Some(x) => cfg.templates.get(x).unwrap(),
+        | Some(x) => cfg
+            .templates
+            .get(x)
+            .ok_or_else(|| Error::Generic("template not found".into()))?,
         | None => select_template(&cfg, &invoke_options.backend, &invoke_options.shell_trust).await?,
     };
     let template_str = match &template.content {
@@ -210,7 +223,7 @@ async fn shell(
     shell_trust: &ShellTrust,
 ) -> Result<String, Box<dyn std::error::Error>> {
     match shell_trust {
-        | ShellTrust::None => return Err(Box::new(crate::error::NoShellTrust::default())),
+        | ShellTrust::None => return Err(Box::new(Error::NoTrust)),
         | ShellTrust::Ultimate => {},
     }
 
@@ -220,7 +233,7 @@ async fn shell(
         .envs(env)
         .output()?;
     if output.status.code().unwrap() != 0 {
-        return Err(Box::new(crate::error::Failed::default()));
+        return Err(Box::new(Error::ShellCommand(command.into())));
     }
-    Ok(String::from_utf8(output.stdout).unwrap())
+    Ok(String::from_utf8(output.stdout)?)
 }
diff --git a/src/render/ui.rs b/src/render/ui.rs
@@ -1,3 +1,5 @@
+use crate::error::Error;
+
 use super::UserInput;
 use async_trait::async_trait;
 use cursive::traits::*;
@@ -36,7 +38,7 @@ impl<'a> UserInput for UIBackend<'a> {
 
         match v.take() {
             | Some(x) => Ok(x),
-            | None => Err(Box::new(crate::error::UserAbort::default())),
+            | None => Err(Box::new(Error::InteractAbort)),
         }
     }
 
@@ -136,7 +138,7 @@ impl<'a> UserInput for UIBackend<'a> {
             siv.run();
 
             if !ok_pressed.take() {
-                return Err(Box::new(crate::error::UserAbort::default()));
+                return Err(Box::new(Error::InteractAbort));
             }
             for x in items.try_read().unwrap().iter() {
                 let pos = display_vals.iter().position(|v| x == v).unwrap();
diff --git a/test/.complate/config.yaml b/test/.complate/config.yaml
@@ -0,0 +1,25 @@
+version: 0.12
+templates:
+  static:
+    content:
+      inline: |-
+        {{ a.alpha }}
+        {{ b.bravo }}
+    values:
+      a.alpha:
+        static: "alpha"
+      b.bravo:
+        env: "bravo"
+  override:
+    content:
+      inline: |-
+        {{ a.alpha }}
+        {{ b.bravo }}
+        {{ c.charlie }}
+    values:
+      a.alpha:
+        static: "alpha"
+      b.bravo:
+        env: "bravo"
+      c.charlie:
+        env: "DOES_NOT_EXIST"

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+use crate::error::Error;`
	`2`	`+`
`1`	`3`	`use super::UserInput;`
`2`	`4`	`use async_trait::async_trait;`
`3`	`5`	`use cursive::traits::*;`
`@@ -36,7 +38,7 @@ impl<'a> UserInput for UIBackend<'a> {`
`36`	`38`
`37`	`39`	`match v.take() {`
`38`	`40`	`\| Some(x) => Ok(x),`
`39`		`- \| None => Err(Box::new(crate::error::UserAbort::default())),`
	`41`	`+ \| None => Err(Box::new(Error::InteractAbort)),`
`40`	`42`	`}`
`41`	`43`	`}`
`42`	`44`
`@@ -136,7 +138,7 @@ impl<'a> UserInput for UIBackend<'a> {`
`136`	`138`	`siv.run();`
`137`	`139`
`138`	`140`	`if !ok_pressed.take() {`
`139`		`- return Err(Box::new(crate::error::UserAbort::default()));`
	`141`	`+ return Err(Box::new(Error::InteractAbort));`
`140`	`142`	`}`
`141`	`143`	`for x in items.try_read().unwrap().iter() {`
`142`	`144`	`let pos = display_vals.iter().position(\|v\| x == v).unwrap();`