Add basic test and a new flag to support noninteractive tests

Author: quodlibetor

src/main.rs

@@ -51,6 +51,10 @@ struct Args {
     /// The maximum number of commits to show when looking for your merge point
     #[structopt(short = "m", long = "max-commits", default_value = "15")]
     max_commits: usize,
+
+    /// Specify a commit to ammend by the subject line of the commit
+    #[structopt(short = "P", long)]
+    commit_message_pattern: Option<String>,
 }
 
 #[derive(Eq, PartialEq, Debug)]
@@ -64,7 +68,7 @@ fn main() {
     if env::args().next().unwrap().ends_with("squash") {
         args.squash = true
     }
-    if let Err(e) = run(args.squash, args.max_commits) {
+    if let Err(e) = run(args.squash, args.max_commits, args.commit_message_pattern) {
         // An empty message means don't display any error message
         let msg = e.to_string();
         if !msg.is_empty() {
@@ -73,7 +77,11 @@ fn main() {
     }
 }
 
-fn run(squash: bool, max_commits: usize) -> Result<(), Box<dyn Error>> {
+fn run(
+    squash: bool,
+    max_commits: usize,
+    message_pattern: Option<String>,
+) -> Result<(), Box<dyn Error>> {
     let repo = Repository::open(".")?;
     let head = repo
         .head()
@@ -82,8 +90,15 @@ fn run(squash: bool, max_commits: usize) -> Result<(), Box<dyn Error>> {
     let head_branch = Branch::wrap(head);
     let diff = repo.diff_tree_to_index(Some(&head_tree), None, None)?;
     let upstream = get_upstream(&repo, &head_branch)?;
-    let commit_to_amend =
-        create_fixup_commit(&repo, &head_branch, upstream, &diff, squash, max_commits)?;
+    let commit_to_amend = create_fixup_commit(
+        &repo,
+        &head_branch,
+        upstream,
+        &diff,
+        squash,
+        max_commits,
+        &message_pattern,
+    )?;
     println!(
         "selected: {} {}",
         &commit_to_amend.id().to_string()[0..10],
@@ -143,6 +158,7 @@ fn create_fixup_commit<'a>(
     diff: &'a Diff,
     squash: bool,
     max_commits: usize,
+    message_pattern: &Option<String>,
 ) -> Result<Commit<'a>, Box<dyn Error>> {
     let diffstat = diff.stats()?;
     if diffstat.files_changed() == 0 {
@@ -166,7 +182,7 @@ fn create_fixup_commit<'a>(
         println!("Staged changes:");
         print_diff(Changes::Staged)?;
     }
-    let commit_to_amend = select_commit_to_amend(&repo, upstream, max_commits)?;
+    let commit_to_amend = select_commit_to_amend(&repo, upstream, max_commits, message_pattern)?;
     do_fixup_commit(&repo, &head_branch, &commit_to_amend, squash)?;
     Ok(commit_to_amend)
 }
@@ -195,6 +211,7 @@ fn select_commit_to_amend<'a>(
     repo: &'a Repository,
     upstream: Option<Object<'a>>,
     max_commits: usize,
+    message_pattern: &Option<String>,
 ) -> Result<Commit<'a>, anyhow::Error> {
     let mut walker = repo.revwalk()?;
     walker.push_head()?;
@@ -230,33 +247,49 @@ fn select_commit_to_amend<'a>(
             })
         })
         .collect();
-    let rev_aliases = commits
-        .iter()
-        .enumerate()
-        .map(|(i, commit)| {
-            let bname = if i > 0 {
-                branches
-                    .get(&commit.id())
-                    .map(|n| format!("({}) ", n))
-                    .unwrap_or_else(String::new)
-            } else {
-                String::new()
-            };
-            format!(
-                "{} {}{}",
-                &style(&commit.id().to_string()[0..10]).blue(),
-                style(bname).green(),
-                commit.summary().unwrap_or("no commit summary")
-            )
-        })
-        .collect::<Vec<_>>();
-    if upstream.is_none() {
-        eprintln!("Select a commit to amend (no upstream for HEAD):");
+    if let Some(message_pattern) = message_pattern.as_ref() {
+        eprintln!(
+            "trying to find message_pattern in {} commits",
+            commits.len()
+        );
+        commits
+            .into_iter()
+            .find(|commit| {
+                commit
+                    .summary()
+                    .map(|s| s.contains(message_pattern))
+                    .unwrap_or(false)
+            })
+            .ok_or_else(|| anyhow::anyhow!("No commit contains the pattern in its summary"))
     } else {
-        eprintln!("Select a commit to amend:");
+        let rev_aliases = commits
+            .iter()
+            .enumerate()
+            .map(|(i, commit)| {
+                let bname = if i > 0 {
+                    branches
+                        .get(&commit.id())
+                        .map(|n| format!("({}) ", n))
+                        .unwrap_or_else(String::new)
+                } else {
+                    String::new()
+                };
+                format!(
+                    "{} {}{}",
+                    &style(&commit.id().to_string()[0..10]).blue(),
+                    style(bname).green(),
+                    commit.summary().unwrap_or("no commit summary")
+                )
+            })
+            .collect::<Vec<_>>();
+        if upstream.is_none() {
+            eprintln!("Select a commit to amend (no upstream for HEAD):");
+        } else {
+            eprintln!("Select a commit to amend:");
+        }
+        let selected = Select::new().items(&rev_aliases).default(0).interact();
+        Ok(repo.find_commit(commits[selected?].id())?)
     }
-    let selected = Select::new().items(&rev_aliases).default(0).interact();
-    Ok(repo.find_commit(commits[selected?].id())?)
 }
 
 fn format_ref(rf: &git2::Reference<'_>) -> Result<String, anyhow::Error> {

tests/basic.rs

@@ -1,10 +1,13 @@
+use std::process::Output;
+
 use assert_cmd::Command;
 use assert_fs::prelude::*;
 use itertools::Itertools;
 
 #[test]
 fn test_can_compile() {
-    let mut cmd = fixup();
+    let td = assert_fs::TempDir::new().unwrap();
+    let mut cmd = fixup(&td);
     let ex = cmd.arg("--help").output().unwrap();
     let out = String::from_utf8(ex.stdout).unwrap();
     let err = String::from_utf8(ex.stderr).unwrap();
@@ -23,18 +26,8 @@ fn test_straightforward() {
 
     git_file_commit("a", &td);
     git_file_commit("b", &td);
-    let out = git_log(&td);
-    assert_eq!(
-        out,
-        "\
-* b HEAD -> main
-* a
-",
-        "log:\n{}",
-        out
-    );
-
     git(&["checkout", "-b", "changes", "HEAD~"], &td);
+    git(&["branch", "-u", "main"], &td);
     for n in &["c", "d", "e"] {
         git_file_commit(&n, &td);
     }
@@ -55,20 +48,40 @@ fn test_straightforward() {
     );
 
     td.child("new").touch().unwrap();
+    git(&["add", "new"], &td);
+
+    fixup(&td).args(&["-P", "d"]).output().unwrap();
 
-    let cmd = fixup().write_stdin("q\n\n\n").unwrap();
-    let err = string(cmd.stderr);
+    let shown = git_out(
+        &["diff-tree", "--no-commit-id", "--name-only", "-r", ":/d"],
+        &td,
+    );
+    let files = string(shown.stdout);
+    let err = string(shown.stderr);
 
-    assert_eq!(err, "nope", "err: {}", err);
+    assert_eq!(
+        files,
+        "\
+file_d
+new
+",
+        "out: {} err: {}",
+        files,
+        err
+    );
 }
+///////////////////////////////////////////////////////////////////////////////
+// Helpers
 
 fn git_init(tempdir: &assert_fs::TempDir) {
     git(&["init", "--initial-branch=main"], &tempdir);
+    git(&["config", "user.email", "[email protected]"], &tempdir);
+    git(&["config", "user.name", "nobody"], &tempdir);
 }
 
 /// Create a file and commit it with a mesage that is just the name of the file
 fn git_file_commit(name: &str, tempdir: &assert_fs::TempDir) {
-    tempdir.child(name).touch().unwrap();
+    tempdir.child(format!("file_{}", name)).touch().unwrap();
     git(&["add", "-A"], &tempdir);
     git(&["commit", "-m", &name], &tempdir);
 }
@@ -78,6 +91,10 @@ fn git(args: &[&str], tempdir: &assert_fs::TempDir) {
     git_inner(args, tempdir).ok().unwrap();
 }
 
+fn git_out(args: &[&str], tempdir: &assert_fs::TempDir) -> Output {
+    git_inner(args, tempdir).output().unwrap()
+}
+
 fn git_log(tempdir: &assert_fs::TempDir) -> String {
     let mut s = String::from_utf8(
         git_inner(&["log", "--all", "--format=%s %D", "--graph"], &tempdir)
@@ -104,6 +121,8 @@ fn git_inner(args: &[&str], tempdir: &assert_fs::TempDir) -> Command {
 }
 
 /// Get something that can get args added to it
-fn fixup() -> Command {
-    Command::cargo_bin("git-fixup").unwrap()
+fn fixup(dir: &assert_fs::TempDir) -> Command {
+    let mut c = Command::cargo_bin("git-fixup").unwrap();
+    c.current_dir(&dir.path());
+    c
 }