test: use assert2 for assertions

Cargo.toml

@@ -6,6 +6,7 @@ edition = "2021"
 [dependencies]
 
 [dev-dependencies]
+assert2 = "0.3.15"
 tempfile = "3.3.0"
 
 [profile.release]

src/command_runner_test.rs

@@ -1,6 +1,6 @@
+use assert2::{check, let_assert};
 use crate::command_runner::CommandError::NoCommandToExecute;
 use crate::command_runner::{parse_command_line, Process};
-use crate::{assert_err, assert_ok};
 
 macro_rules! svec {
     ($($x:expr),*) => (vec![$($x.to_string()),*]);
@@ -10,37 +10,34 @@ macro_rules! svec {
 fn do_not_build_a_process_if_no_arguments_given() {
     let args = svec!["self"];
 
-    let process = parse_command_line(args);
+    let result = parse_command_line(args);
 
-    assert_err!(NoCommandToExecute, process);
+    let_assert!(Err(error) = result);
+    check!(error == NoCommandToExecute);
 }
 
 #[test]
 fn the_first_argument_should_be_set_as_the_executable() {
     let args = svec!["self", "my_bin"];
 
-    let process = parse_command_line(args);
+    let result = parse_command_line(args);
 
-    assert_ok!(
-        Process {
+    let_assert!(Ok(process) = result);
+    check!(process == Process {
             executable: "my_bin".into(),
             args: svec![]
-        },
-        process
-    );
+        });
 }
 
 #[test]
 fn the_following_arguments_should_be_set_as_executable_arguments() {
     let args = svec!["self", "my_bin", "arg1", "arg2"];
 
-    let process = parse_command_line(args);
+    let result = parse_command_line(args);
 
-    assert_ok!(
-        Process {
+    let_assert!(Ok(process) = result);
+    check!(process == Process {
             executable: "my_bin".into(),
             args: svec!["arg1", "arg2"]
-        },
-        process
-    );
+        });
 }

src/main.rs

@@ -9,9 +9,6 @@ use std::path::Path;
 mod command_runner;
 mod secret_loader;
 
-#[cfg(test)]
-mod test_macros;
-
 fn main() -> Result<(), String> {
     let result = load_and_run();
 

src/secret_loader_test.rs

@@ -2,21 +2,22 @@ use crate::secret_loader::load_from_path;
 use crate::FilesystemError::NotDirectory;
 use crate::FilesystemError::NotFile;
 use crate::FilesystemError::Unreadable;
-use crate::{assert_err, assert_ok};
 use std::collections::HashMap;
 use std::fs;
 use std::fs::File;
 use std::io::Write;
 use std::os::unix::fs::PermissionsExt;
 use std::path::Path;
+use assert2::{check, let_assert};
 
 #[test]
 fn no_secrets_directory_should_produce_an_empty_map() {
     let root = tempfile::tempdir().unwrap();
 
-    let secrets = load_from_path(root.path(), "var/run/secrets");
+    let result = load_from_path(root.path(), "var/run/secrets");
 
-    assert_ok!(HashMap::new(), secrets);
+    let_assert!(Ok(secrets) = result);
+    check!(secrets.is_empty());
 }
 
 #[test]
@@ -27,9 +28,10 @@ fn fail_if_secrets_path_is_not_a_directory() {
     let secrets_path = var_run_path.join(Path::new("secrets"));
     File::create(&secrets_path).unwrap();
 
-    let secrets = load_from_path(root.path(), "var/run/secrets");
+    let result = load_from_path(root.path(), "var/run/secrets");
 
-    assert_err!(NotDirectory(secrets_path), secrets);
+    let_assert!(Err(error) = result);
+    check!(error == NotDirectory(secrets_path));
 }
 
 #[test]
@@ -38,9 +40,10 @@ fn empty_secrets_directory_should_produce_an_empty_map() {
     let secrets_path = root.path().join(Path::new("var/run/secrets"));
     fs::create_dir_all(secrets_path.as_path()).unwrap();
 
-    let secrets = load_from_path(root.path(), "var/run/secrets");
+    let result = load_from_path(root.path(), "var/run/secrets");
 
-    assert_ok!(HashMap::new(), secrets);
+    let_assert!(Ok(secrets) = result);
+    check!(secrets.is_empty());
 }
 
 #[test]
@@ -49,9 +52,10 @@ fn fail_if_secret_entry_is_a_directory() {
     let secrets_path = root.path().join(Path::new("var/run/secrets/something"));
     fs::create_dir_all(secrets_path.as_path()).unwrap();
 
-    let secrets = load_from_path(root.path(), "var/run/secrets");
+    let result = load_from_path(root.path(), "var/run/secrets");
 
-    assert_err!(NotFile(secrets_path), secrets);
+    let_assert!(Err(error) = result);
+    check!(error == NotFile(secrets_path));
 }
 
 #[test]
@@ -63,12 +67,10 @@ fn a_valid_secret_should_be_returned() {
     let secret_file = File::create(&secret_path).unwrap();
     write!(&secret_file, "{}", "a_secret_value").unwrap();
 
-    let secrets = load_from_path(root.path(), "var/run/secrets");
+    let result = load_from_path(root.path(), "var/run/secrets");
 
-    assert_ok!(
-        HashMap::from([("A_SECRET".into(), "a_secret_value".to_string())]),
-        secrets
-    );
+    let_assert!(Ok(secrets) = result);
+    check!(secrets == HashMap::from([("A_SECRET".into(), "a_secret_value".to_string())]));
 }
 
 #[test]
@@ -80,9 +82,10 @@ fn fail_if_secrets_directory_is_not_readable() {
     perms.set_mode(0644);
     fs::set_permissions(&secrets_path, perms).unwrap();
 
-    let secrets = load_from_path(root.path(), "var/run/secrets");
+    let result = load_from_path(root.path(), "var/run/secrets");
 
-    assert_err!(Unreadable(secrets_path), secrets);
+    let_assert!(Err(error) = result);
+    check!(error == Unreadable(secrets_path));
 }
 
 #[test]
@@ -96,7 +99,8 @@ fn fail_if_secret_file_is_not_readable() {
     perms.set_mode(0000);
     fs::set_permissions(&secret_path, perms).unwrap();
 
-    let secrets = load_from_path(root.path(), "var/run/secrets");
+    let result = load_from_path(root.path(), "var/run/secrets");
 
-    assert_err!(Unreadable(secret_path), secrets);
+    let_assert!(Err(error) = result);
+    check!(error == Unreadable(secret_path));
 }