2 files changed, 231 insertions, 33 deletions

diff --git a/src/sub_commands/send.rs b/src/sub_commands/send.rs
index 23016e1..6417870 100644
--- a/src/sub_commands/send.rs
+++ b/src/sub_commands/send.rs
@@ -50,43 +50,49 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
         if args.since_or_revision_range.is_empty()
             || args.since_or_revision_range.eq("master..HEAD")
         {
-            let (from_branch, to_branch, ahead, behind) =
-                identify_ahead_behind(&git_repo, &None, &None)?;
+            let (branch_name, tip) = git_repo.get_main_or_master_branch()?;
+            if branch_name.eq("main") || branch_name.eq("master") {
+                println!("creating 1 patch from latest commit");
+                vec![tip]
+            } else {
+                let (from_branch, to_branch, ahead, behind) =
+                    identify_ahead_behind(&git_repo, &None, &None)?;
 
-            if ahead.is_empty() {
-                bail!(format!(
-                    "'{from_branch}' is 0 commits ahead of '{to_branch}' so no patches were created"
-                ));
-            }
+                if ahead.is_empty() {
+                    bail!(format!(
+                        "'{from_branch}' is 0 commits ahead of '{to_branch}' so no patches were created"
+                    ));
+                }
 
-            if behind.is_empty() {
-                println!(
-                    "creating patch for {} commits from '{from_branch}' that can be merged into '{to_branch}'",
-                    ahead.len(),
-                );
-            } else {
-                if !Interactor::default().confirm(
-            PromptConfirmParms::default()
-                .with_prompt(
-                    format!(
-                        "'{from_branch}' is {} commits behind '{to_branch}' and {} ahead. Consider rebasing before sending patches. Proceed anyway?",
-                        behind.len(),
+                if behind.is_empty() {
+                    println!(
+                        "creating patch for {} commits from '{from_branch}' that can be merged into '{to_branch}'",
                         ahead.len(),
-                    )
-                )
-                .with_default(false)
-        ).context("failed to get confirmation response from interactor confirm")? {
-            bail!("aborting so branch can be rebased");
-        }
-                println!(
-                    "creating patch for {} commit{} from '{from_branch}' that {} {} behind '{to_branch}'",
-                    ahead.len(),
-                    if ahead.len() > 1 { "s" } else { "" },
-                    if ahead.len() > 1 { "are" } else { "is" },
-                    behind.len(),
-                );
+                    );
+                } else {
+                    if !Interactor::default().confirm(
+                    PromptConfirmParms::default()
+                        .with_prompt(
+                            format!(
+                                "'{from_branch}' is {} commits behind '{to_branch}' and {} ahead. Consider rebasing before sending patches. Proceed anyway?",
+                                behind.len(),
+                                ahead.len(),
+                            )
+                        )
+                        .with_default(false)
+                ).context("failed to get confirmation response from interactor confirm")? {
+                    bail!("aborting so branch can be rebased");
+                }
+                    println!(
+                        "creating patch for {} commit{} from '{from_branch}' that {} {} behind '{to_branch}'",
+                        ahead.len(),
+                        if ahead.len() > 1 { "s" } else { "" },
+                        if ahead.len() > 1 { "are" } else { "is" },
+                        behind.len(),
+                    );
+                }
+                ahead
             }
-            ahead
         } else {
             let ahead = git_repo
                 .parse_starting_commits(&args.since_or_revision_range)
diff --git a/tests/send.rs b/tests/send.rs
index 4b68821..2d02a7d 100644
--- a/tests/send.rs
+++ b/tests/send.rs
@@ -1137,6 +1137,198 @@ mod sends_2_patches_without_cover_letter {
         Ok(())
     }
 }
+
+mod when_on_main_branch_defaults_to_last_commit {
+    use super::*;
+
+    fn prep_git_repo() -> Result<GitTestRepo> {
+        let test_repo = GitTestRepo::default();
+        test_repo.populate()?;
+        // dont checkout feature branch
+        std::fs::write(test_repo.dir.join("t3.md"), "some content")?;
+        test_repo.stage_and_commit("add t3.md")?;
+        std::fs::write(test_repo.dir.join("t4.md"), "some content")?;
+        test_repo.stage_and_commit("add t4.md")?;
+        Ok(test_repo)
+    }
+
+    fn cli_tester_create_proposal(git_repo: &GitTestRepo) -> CliTester {
+        let args = vec![
+            "--nsec",
+            TEST_KEY_1_NSEC,
+            "--password",
+            TEST_PASSWORD,
+            "--disable-cli-spinners",
+            "send",
+            "--no-cover-letter",
+        ];
+        CliTester::new_from_dir(&git_repo.dir, args)
+    }
+    fn expect_msgs_first(p: &mut CliTester) -> Result<()> {
+        p.expect("creating 1 patch from latest commit\r\n")?;
+        p.expect("searching for profile and relay updates...\r\n")?;
+        p.expect("\r")?;
+        p.expect("logged in as fred\r\n")?;
+        p.expect("posting 1 patches without a covering letter...\r\n")?;
+        Ok(())
+    }
+    async fn prep_run_create_proposal() -> Result<(
+        Relay<'static>,
+        Relay<'static>,
+        Relay<'static>,
+        Relay<'static>,
+        Relay<'static>,
+    )> {
+        let git_repo = prep_git_repo()?;
+
+        // fallback (51,52) user write (53, 55) repo (55, 56)
+        let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
+            Relay::new(
+                8051,
+                None,
+                Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                    relay.respond_events(
+                        client_id,
+                        &subscription_id,
+                        &vec![
+                            generate_test_key_1_metadata_event("fred"),
+                            generate_test_key_1_relay_list_event(),
+                        ],
+                    )?;
+                    Ok(())
+                }),
+            ),
+            Relay::new(8052, None, None),
+            Relay::new(8053, None, None),
+            Relay::new(
+                8055,
+                None,
+                Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                    relay.respond_events(
+                        client_id,
+                        &subscription_id,
+                        &vec![generate_repo_ref_event()],
+                    )?;
+                    Ok(())
+                }),
+            ),
+            Relay::new(8056, None, None),
+        );
+
+        // // check relay had the right number of events
+        let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
+            let mut p = cli_tester_create_proposal(&git_repo);
+            p.expect_end_eventually()?;
+            for p in [51, 52, 53, 55, 56] {
+                relay::shutdown_relay(8000 + p)?;
+            }
+            Ok(())
+        });
+
+        // launch relay
+        let _ = join!(
+            r51.listen_until_close(),
+            r52.listen_until_close(),
+            r53.listen_until_close(),
+            r55.listen_until_close(),
+            r56.listen_until_close(),
+        );
+        cli_tester_handle.join().unwrap()?;
+        Ok((r51, r52, r53, r55, r56))
+    }
+    mod cli_ouput {
+        use super::*;
+
+        async fn run_test_async() -> Result<()> {
+            let git_repo = prep_git_repo()?;
+
+            let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
+                Relay::new(
+                    8051,
+                    None,
+                    Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                        relay.respond_events(
+                            client_id,
+                            &subscription_id,
+                            &vec![
+                                generate_test_key_1_metadata_event("fred"),
+                                generate_test_key_1_relay_list_event(),
+                            ],
+                        )?;
+                        Ok(())
+                    }),
+                ),
+                Relay::new(8052, None, None),
+                Relay::new(8053, None, None),
+                Relay::new(
+                    8055,
+                    None,
+                    Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                        relay.respond_events(
+                            client_id,
+                            &subscription_id,
+                            &vec![generate_repo_ref_event()],
+                        )?;
+                        Ok(())
+                    }),
+                ),
+                Relay::new(8056, None, None),
+            );
+
+            // // check relay had the right number of events
+            let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
+                let mut p = cli_tester_create_proposal(&git_repo);
+
+                expect_msgs_first(&mut p)?;
+                relay::expect_send_with_progress(
+                    &mut p,
+                    vec![
+                        (" [my-relay] [repo-relay] ws://localhost:8055", true, ""),
+                        (" [my-relay] ws://localhost:8053", true, ""),
+                        (" [repo-relay] ws://localhost:8056", true, ""),
+                        (" [default] ws://localhost:8051", true, ""),
+                        (" [default] ws://localhost:8052", true, ""),
+                    ],
+                    1,
+                )?;
+                p.expect_end_with_whitespace()?;
+                for p in [51, 52, 53, 55, 56] {
+                    relay::shutdown_relay(8000 + p)?;
+                }
+                Ok(())
+            });
+
+            // launch relay
+            let _ = join!(
+                r51.listen_until_close(),
+                r52.listen_until_close(),
+                r53.listen_until_close(),
+                r55.listen_until_close(),
+                r56.listen_until_close(),
+            );
+            cli_tester_handle.join().unwrap()?;
+            Ok(())
+        }
+
+        #[tokio::test]
+        #[serial]
+        async fn check_cli_output() -> Result<()> {
+            run_test_async().await?;
+            Ok(())
+        }
+    }
+
+    #[tokio::test]
+    #[serial]
+    async fn one_patch_event_sent() -> Result<()> {
+        let (_, _, r53, r55, r56) = prep_run_create_proposal().await?;
+        for relay in [&r53, &r55, &r56] {
+            assert_eq!(relay.events.iter().filter(|e| is_patch(e)).count(), 1);
+        }
+        Ok(())
+    }
+}
+
 mod specify_starting_commits_whist_on_main_branch {
     use super::*;