From 9c8bc542c56d334ebe222fb10e20f0263561fe95 Mon Sep 17 00:00:00 2001
From: Andrew Phillips <andrew.phillips2@canada.ca>
Date: Mon, 12 May 2025 16:44:43 -0300
Subject: [PATCH] refactor: format assert macros for better readability

---
 src/tests.rs | 215 ++++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 180 insertions(+), 35 deletions(-)

diff --git a/src/tests.rs b/src/tests.rs
index ce6c4fa..794afcb 100644
--- a/src/tests.rs
+++ b/src/tests.rs
@@ -40,7 +40,6 @@ mod tests {
 
     // Helper function to create test items with specific content and tags
     fn create_test_items(dir: &Path) {
-
         // Set the data directory for this test
         let env = format!("KEEP_DIR={} cargo run -- --verbose", dir.display());
 
@@ -52,7 +51,12 @@ mod tests {
         // Create second item with tag_b and tag
         let cmd = format!("echo {} | {} tag tag_b tag", INPUT_B, env);
         let output = run_sh(cmd.as_str());
-        assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
+        assert!(
+            output.status.success(),
+            "Command failed: {}  {}",
+            cmd,
+            output.status
+        );
     }
 
     // Helper function to check if a file exists in the data directory
@@ -83,7 +87,12 @@ mod tests {
             // Create a command that pipes input to keep with the specified environment
             let cmd = format!("echo {} | {} {}", input, env, tag);
             let output = run_sh(cmd.as_str());
-            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
+            assert!(
+                output.status.success(),
+                "Command failed: {}  {}",
+                cmd,
+                output.status
+            );
         });
     }
 
@@ -97,43 +106,78 @@ mod tests {
 
             let cmd = format!("{} --get 1", env);
             let output = run_sh(cmd.as_str());
-            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
+            assert!(
+                output.status.success(),
+                "Command failed: {}  {}",
+                cmd,
+                output.status
+            );
             let output_str = String::from_utf8_lossy(&output.stdout).to_string();
             assert!(output_str.contains(INPUT_A), "Command output does not contain expected string. Command: {}  Output: {}  Expected: \"{}\"", cmd, output_str, INPUT_A);
 
             let cmd = format!("{} -g 1", env);
             let output = run_sh(cmd.as_str());
-            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
+            assert!(
+                output.status.success(),
+                "Command failed: {}  {}",
+                cmd,
+                output.status
+            );
             let output_str = String::from_utf8_lossy(&output.stdout).to_string();
             assert!(output_str.contains(INPUT_A), "Command output does not contain expected string. Command: {}  Output: {}  Expected: \"{}\"", cmd, output_str, INPUT_A);
 
             let cmd = format!("{} 1", env);
             let output = run_sh(cmd.as_str());
-            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
+            assert!(
+                output.status.success(),
+                "Command failed: {}  {}",
+                cmd,
+                output.status
+            );
             let output_str = String::from_utf8_lossy(&output.stdout).to_string();
             assert!(output_str.contains(INPUT_A), "Command output does not contain expected string. Command: {}  Output: {}  Expected: \"{}\"", cmd, output_str, INPUT_A);
 
             let cmd = format!("{} --get", env);
             let output = run_sh(cmd.as_str());
-            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
+            assert!(
+                output.status.success(),
+                "Command failed: {}  {}",
+                cmd,
+                output.status
+            );
             let output_str = String::from_utf8_lossy(&output.stdout).to_string();
             assert!(output_str.contains(INPUT_B), "Command output does not contain expected string. Command: {}  Output: {}  Expected: \"{}\"", cmd, output_str, INPUT_B);
 
             let cmd = format!("{} --get tag_a", env);
             let output = run_sh(cmd.as_str());
-            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
+            assert!(
+                output.status.success(),
+                "Command failed: {}  {}",
+                cmd,
+                output.status
+            );
             let output_str = String::from_utf8_lossy(&output.stdout).to_string();
             assert!(output_str.contains(INPUT_A), "Command output does not contain expected string. Command: {}  Output: {}  Expected: \"{}\"", cmd, output_str, INPUT_A);
 
             let cmd = format!("{} --get tag_b", env);
             let output = run_sh(cmd.as_str());
-            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
+            assert!(
+                output.status.success(),
+                "Command failed: {}  {}",
+                cmd,
+                output.status
+            );
             let output_str = String::from_utf8_lossy(&output.stdout).to_string();
             assert!(output_str.contains(INPUT_B), "Command output does not contain expected string. Command: {}  Output: {}  Expected: \"{}\"", cmd, output_str, INPUT_B);
 
             let cmd = format!("{} --get tag", env);
             let output = run_sh(cmd.as_str());
-            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
+            assert!(
+                output.status.success(),
+                "Command failed: {}  {}",
+                cmd,
+                output.status
+            );
             let output_str = String::from_utf8_lossy(&output.stdout).to_string();
             assert!(output_str.contains(INPUT_B), "Command output does not contain expected string. Command: {}  Output: {}  Expected: \"{}\"", cmd, output_str, INPUT_B);
         });
@@ -150,15 +194,30 @@ mod tests {
 
             let cmd = format!("{} --list", env);
             let output = run_sh(cmd.as_str());
-            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
+            assert!(
+                output.status.success(),
+                "Command failed: {}  {}",
+                cmd,
+                output.status
+            );
 
             let cmd = format!("{} -l", env);
             let output = run_sh(cmd.as_str());
-            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
+            assert!(
+                output.status.success(),
+                "Command failed: {}  {}",
+                cmd,
+                output.status
+            );
 
             let cmd = format!("{} --list tag_a", env);
             let output = run_sh(cmd.as_str());
-            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
+            assert!(
+                output.status.success(),
+                "Command failed: {}  {}",
+                cmd,
+                output.status
+            );
         });
     }
 
@@ -173,19 +232,39 @@ mod tests {
 
             let cmd = format!("{} --delete tag", env);
             let output = run_sh(cmd.as_str());
-            assert!(!output.status.success(), "Command succeeded when it should have failed: {}  {}", cmd, output.status);
+            assert!(
+                !output.status.success(),
+                "Command succeeded when it should have failed: {}  {}",
+                cmd,
+                output.status
+            );
 
             let cmd = format!("{} --delete 1", env);
             let output = run_sh(cmd.as_str());
-            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
+            assert!(
+                output.status.success(),
+                "Command failed: {}  {}",
+                cmd,
+                output.status
+            );
 
             let cmd = format!("{} -d 2", env);
             let output = run_sh(cmd.as_str());
-            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
+            assert!(
+                output.status.success(),
+                "Command failed: {}  {}",
+                cmd,
+                output.status
+            );
 
             let cmd = format!("{} --delete 9999", env);
             let output = run_sh(cmd.as_str());
-            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
+            assert!(
+                output.status.success(),
+                "Command failed: {}  {}",
+                cmd,
+                output.status
+            );
             //assert!(!output.status.success(), "Command succeded when it should have failed: {}  {}", cmd, output.status);
         });
     }
@@ -201,7 +280,12 @@ mod tests {
 
             let cmd = format!("{} --diff 1 2", env);
             let output = run_sh(cmd.as_str());
-            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
+            assert!(
+                output.status.success(),
+                "Command failed: {}  {}",
+                cmd,
+                output.status
+            );
             let output_str = String::from_utf8_lossy(&output.stdout).to_string();
             assert!(output_str.contains(INPUT_A), "Command output does not contain expected string. Command: {}  Output: {}  Expected: \"{}\"", cmd, output_str, INPUT_A);
             let output_str = String::from_utf8_lossy(&output.stdout).to_string();
@@ -209,19 +293,39 @@ mod tests {
 
             let cmd = format!("{} --diff tag_a tag_b", env);
             let output = run_sh(cmd.as_str());
-            assert!(!output.status.success(), "Command succeeded when it should have failed: {}  {}", cmd, output.status);
+            assert!(
+                !output.status.success(),
+                "Command succeeded when it should have failed: {}  {}",
+                cmd,
+                output.status
+            );
 
             let cmd = format!("{} --diff tag_a 2", env);
             let output = run_sh(cmd.as_str());
-            assert!(!output.status.success(), "Command succeeded when it should have failed: {}  {}", cmd, output.status);
+            assert!(
+                !output.status.success(),
+                "Command succeeded when it should have failed: {}  {}",
+                cmd,
+                output.status
+            );
 
             let cmd = format!("{} --diff 9999 2", env);
             let output = run_sh(cmd.as_str());
-            assert!(!output.status.success(), "Command succeeded when it should have failed: {}  {}", cmd, output.status);
+            assert!(
+                !output.status.success(),
+                "Command succeeded when it should have failed: {}  {}",
+                cmd,
+                output.status
+            );
 
             // Output should be empty for non-existent item
             let output_str = String::from_utf8_lossy(&output.stdout).to_string();
-            assert!(output_str.is_empty(), "Command output is not empty. Command: {}  Output: {}", cmd, output_str);
+            assert!(
+                output_str.is_empty(),
+                "Command output is not empty. Command: {}  Output: {}",
+                cmd,
+                output_str
+            );
         });
     }
 
@@ -236,61 +340,102 @@ mod tests {
             let cmd = format!("echo {} | {} -c unknown unknown", INPUT_A, env);
             println!("RUNNING: {}", cmd);
             let output = run_sh(cmd.as_str());
-            assert!(!output.status.success(), "Command succeeded when it should have failed: {}  {}", cmd, output.status);
-            
+            assert!(
+                !output.status.success(),
+                "Command succeeded when it should have failed: {}  {}",
+                cmd,
+                output.status
+            );
 
             // Test with no compression
             let cmd = format!("echo {} | {} -c none none", INPUT_A, env);
             println!("RUNNING: {}", cmd);
             let output = run_sh(cmd.as_str());
-            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
+            assert!(
+                output.status.success(),
+                "Command failed: {}  {}",
+                cmd,
+                output.status
+            );
 
             let cmd = format!("{} --get none", env);
             println!("RUNNING: {}", cmd);
             let output = run_sh(cmd.as_str());
-            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
+            assert!(
+                output.status.success(),
+                "Command failed: {}  {}",
+                cmd,
+                output.status
+            );
             let output_str = String::from_utf8_lossy(&output.stdout).to_string();
             assert!(output_str.contains(INPUT_A), "Command output does not contain expected string. Command: {}  Output: {}  Expected: \"{}\"", cmd, output_str, INPUT_A);
 
-            
             // Test with lz4 compression
             let cmd = format!("echo {} | {} -c lz4 lz4", INPUT_A, env);
             println!("RUNNING: {}", cmd);
             let output = run_sh(cmd.as_str());
-            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
+            assert!(
+                output.status.success(),
+                "Command failed: {}  {}",
+                cmd,
+                output.status
+            );
 
             let cmd = format!("{} --get lz4", env);
             println!("RUNNING: {}", cmd);
             let output = run_sh(cmd.as_str());
-            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
+            assert!(
+                output.status.success(),
+                "Command failed: {}  {}",
+                cmd,
+                output.status
+            );
             let output_str = String::from_utf8_lossy(&output.stdout).to_string();
             assert!(output_str.contains(INPUT_A), "Command output does not contain expected string. Command: {}  Output: {}  Expected: \"{}\"", cmd, output_str, INPUT_A);
 
-            
             // Test with gzip compression
             let cmd = format!("echo {} | {} -c gzip gzip", INPUT_A, env);
             println!("RUNNING: {}", cmd);
             let output = run_sh(cmd.as_str());
-            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
+            assert!(
+                output.status.success(),
+                "Command failed: {}  {}",
+                cmd,
+                output.status
+            );
 
             let cmd = format!("{} --get gzip", env);
             println!("RUNNING: {}", cmd);
             let output = run_sh(cmd.as_str());
-            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
+            assert!(
+                output.status.success(),
+                "Command failed: {}  {}",
+                cmd,
+                output.status
+            );
             let output_str = String::from_utf8_lossy(&output.stdout).to_string();
             assert!(output_str.contains(INPUT_A), "Command output does not contain expected string. Command: {}  Output: {}  Expected: \"{}\"", cmd, output_str, INPUT_A);
 
-            
             // Test with bzip2 compression
             let cmd = format!("echo {} | {} -c bzip2 bzip2", INPUT_A, env);
             println!("RUNNING: {}", cmd);
             let output = run_sh(cmd.as_str());
-            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
+            assert!(
+                output.status.success(),
+                "Command failed: {}  {}",
+                cmd,
+                output.status
+            );
 
             let cmd = format!("{} --get bzip2", env);
             println!("RUNNING: {}", cmd);
             let output = run_sh(cmd.as_str());
-            assert!(output.status.success(), "Command failed: {}  {}", cmd, output.status);
+            assert!(
+                output.status.success(),
+                "Command failed: {}  {}",
+                cmd,
+                output.status
+            );
             let output_str = String::from_utf8_lossy(&output.stdout).to_string();
             assert!(output_str.contains(INPUT_A), "Command output does not contain expected string. Command: {}  Output: {}  Expected: \"{}\"", cmd, output_str, INPUT_A);
         });