Truncate recordings when running in test + record mode

Signed-off-by: Joe Grund <[email protected]>

Author: Joe Grund

commandeer-cli/src/main.rs

@@ -5,7 +5,7 @@ use std::path::PathBuf;
 
 #[derive(Parser)]
 #[command(name = "commandeer")]
-#[command(about = "A CLI test binary substitute with record and replay modes")]
+/// A CLI test binary substitute with record and replay modes
 struct Cli {
     #[command(subcommand)]
     command: Commands,
@@ -14,14 +14,19 @@ struct Cli {
 #[derive(Subcommand)]
 enum Commands {
     Record {
+        /// Path to save recordings.
         #[arg(long, default_value = "recordings.json")]
         file: PathBuf,
+        /// Whether to truncate the file before recording.
+        #[arg(long)]
+        truncate: bool,
         #[arg(long)]
         command: String,
         #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
         args: Vec<String>,
     },
     Replay {
+        /// Path to the recordings.
         #[arg(long, default_value = "recordings.json")]
         file: PathBuf,
         #[arg(long)]
@@ -31,8 +36,13 @@ enum Commands {
     },
 }
 
-async fn record_mode(file_path: PathBuf, command: String, args: Vec<String>) -> Result<()> {
-    let invocation = record_command(file_path, command, args).await?;
+async fn record_mode(
+    truncate: bool,
+    file_path: PathBuf,
+    command: String,
+    args: Vec<String>,
+) -> Result<()> {
+    let invocation = record_command(truncate, file_path, command, args).await?;
 
     output_invocation(&invocation);
 
@@ -66,8 +76,9 @@ async fn main() -> Result<()> {
             file,
             command,
             args,
+            truncate,
         } => {
-            record_mode(file, command, args).await?;
+            record_mode(truncate, file, command, args).await?;
         }
         Commands::Replay {
             file,

commandeer-test/src/lib.rs

@@ -4,11 +4,15 @@ use serde::{Deserialize, Serialize};
 use std::{
     collections::HashMap,
     env, fmt,
-    fs::{self, DirBuilder},
+    fs::{self},
     path::{Path, PathBuf},
 };
 use tempfile::TempDir;
-use tokio::process::Command;
+use tokio::{
+    fs::{DirBuilder, try_exists},
+    io::AsyncReadExt as _,
+    process::Command,
+};
 
 pub use commandeer_macros::commandeer;
 
@@ -49,19 +53,17 @@ impl RecordedCommands {
 }
 
 pub async fn load_recordings(file_path: &PathBuf) -> Result<RecordedCommands> {
-    if !file_path.exists() {
-        tokio::fs::create_dir_all(
-            file_path.parent().ok_or_else(|| {
-                anyhow!("Couldn't get parent of recording {}", file_path.display())
-            })?,
-        )
+    let mut f = tokio::fs::File::options();
+
+    let mut contents = String::new();
+    f.create(true)
+        .write(true)
+        .read(true)
+        .open(file_path)
+        .await?
+        .read_to_string(&mut contents)
         .await?;
 
-        return Ok(RecordedCommands::default());
-    }
-
-    let contents = tokio::fs::read_to_string(file_path).await?;
-
     if contents.trim().is_empty() {
         return Ok(RecordedCommands::default());
     }
@@ -80,11 +82,29 @@ pub async fn save_recordings(file_path: &PathBuf, recordings: &RecordedCommands)
 }
 
 pub async fn record_command(
+    truncate: bool,
     file_path: PathBuf,
     command: String,
     args: Vec<String>,
 ) -> Result<CommandInvocation> {
-    let mut recordings = load_recordings(&file_path).await?;
+    let recording_dir = file_path
+        .parent()
+        .ok_or_else(|| anyhow!("Couldn't get parent of recording {}", file_path.display()))?;
+
+    DirBuilder::new()
+        .recursive(true)
+        .create(recording_dir)
+        .await?;
+
+    let mut recordings = if truncate {
+        if try_exists(&file_path).await? {
+            tokio::fs::remove_file(&file_path).await?;
+        }
+
+        RecordedCommands::default()
+    } else {
+        load_recordings(&file_path).await?
+    };
 
     let output = Command::new(&command).args(&args).output().await?;
 
@@ -121,7 +141,7 @@ pub fn exit_with_code(code: i32) -> ! {
     std::process::exit(code);
 }
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub enum Mode {
     Record,
     Replay,
@@ -150,7 +170,7 @@ impl Commandeer {
             std::env::var("CARGO_MANIFEST_DIR").expect("Failed to get crate directory."),
         );
 
-        DirBuilder::new()
+        std::fs::DirBuilder::new()
             .recursive(true)
             .create(&dir)
             .expect("Failed to create testcmds dir");
@@ -186,11 +206,16 @@ impl Commandeer {
 
         let wrapper = format!(
             r#"#!/usr/bin/env bash
-exec env PATH="{}" {} {} --file {} --command {command_name} "$@"
+exec env PATH="{}" {} {}{}--file {} --command {command_name} "$@"
 "#,
             self.original_path,
             self.mock_runner.path().display(),
             self.mode,
+            if self.mode == Mode::Record {
+                " --truncate "
+            } else {
+                " "
+            },
             self.fixture.display(),
         );
 

commandeer-test/testcmds/cmds_test_flag_args.json

@@ -1,24 +1,6 @@
 {
   "commands": {
     "git:--version": [
-      {
-        "binary_name": "git",
-        "args": [
-          "--version"
-        ],
-        "stdout": "git version 2.51.0\n",
-        "stderr": "",
-        "exit_code": 0
-      },
-      {
-        "binary_name": "git",
-        "args": [
-          "--version"
-        ],
-        "stdout": "git version 2.51.0\n",
-        "stderr": "",
-        "exit_code": 0
-      },
       {
         "binary_name": "git",
         "args": [