2 files changed, 562 insertions, 162 deletions

diff --git a/tests/prs_create.rs b/tests/prs_create.rs
index 6272ccd..316c9fe 100644
--- a/tests/prs_create.rs
+++ b/tests/prs_create.rs
@@ -1,6 +1,7 @@
 use anyhow::Result;
+use futures::join;
 use serial_test::serial;
-use test_utils::{git::GitTestRepo, *};
+use test_utils::{git::GitTestRepo, relay::Relay, *};
 
 #[test]
 fn when_to_branch_doesnt_exist_return_error() -> Result<()> {
@@ -150,121 +151,133 @@ fn is_patch(event: &nostr::Event) -> bool {
         && !event.iter_tags().any(|t| t.as_vec()[1].eq("cover-letter"))
 }
 
-mod sends_pr_and_2_patches_to_3_relays {
-    use futures::join;
-    use test_utils::relay::Relay;
-
-    use super::*;
+fn prep_git_repo() -> Result<GitTestRepo> {
+    let test_repo = GitTestRepo::default();
+    test_repo.populate()?;
+    // create feature branch with 2 commit ahead
+    test_repo.create_branch("feature")?;
+    test_repo.checkout("feature")?;
+    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 prep_git_repo() -> Result<GitTestRepo> {
-        let test_repo = GitTestRepo::default();
-        test_repo.populate()?;
-        // create feature branch with 2 commit ahead
-        test_repo.create_branch("feature")?;
-        test_repo.checkout("feature")?;
-        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_pr(git_repo: &GitTestRepo, include_cover_letter: bool) -> CliTester {
+    let mut args = vec![
+        "--nsec",
+        TEST_KEY_1_NSEC,
+        "--password",
+        TEST_PASSWORD,
+        "--disable-cli-spinners",
+        "prs",
+        "create",
+    ];
+    if include_cover_letter {
+        for arg in [
+            "--title",
+            "exampletitle",
+            "--description",
+            "exampledescription",
+        ] {
+            args.push(arg);
+        }
+    } else {
+        args.push("--no-cover-letter");
     }
+    CliTester::new_from_dir(&git_repo.dir, args)
+}
 
-    fn cli_tester_create_pr(git_repo: &GitTestRepo) -> CliTester {
-        CliTester::new_from_dir(
-            &git_repo.dir,
-            [
-                "--nsec",
-                TEST_KEY_1_NSEC,
-                "--password",
-                TEST_PASSWORD,
-                "--disable-cli-spinners",
-                "prs",
-                "create",
-                "--title",
-                "exampletitle",
-                "--description",
-                "exampledescription",
-            ],
-        )
-    }
+fn expect_msgs_first(p: &mut CliTester, include_cover_letter: bool) -> Result<()> {
+    p.expect("creating patch for 2 commits from 'head' that can be merged into 'main'\r\n")?;
+    p.expect("searching for your details...\r\n")?;
+    p.expect("\r")?;
+    p.expect("logged in as fred\r\n")?;
+    p.expect(format!(
+        "posting 2 patches {} a covering letter...\r\n",
+        if include_cover_letter {
+            "with"
+        } else {
+            "without"
+        }
+    ))?;
+    Ok(())
+}
 
-    fn expect_msgs_first(p: &mut CliTester) -> Result<()> {
-        p.expect("creating patch for 2 commits from 'head' that can be merged into 'main'\r\n")?;
-        p.expect("searching for your details...\r\n")?;
-        p.expect("\r")?;
-        p.expect("logged in as fred\r\n")?;
-        p.expect("posting 1 pull request with 2 commits...\r\n")?;
+async fn prep_run_create_pr(
+    include_cover_letter: bool,
+) -> 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_pr(&git_repo, include_cover_letter);
+        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))
+}
 
-    async fn prep_run_create_pr() -> 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_pr(&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 sends_cover_letter_and_2_patches_to_3_relays {
 
+    use super::*;
     #[tokio::test]
     #[serial]
     async fn only_1_pr_kind_event_sent_to_each_relay() -> Result<()> {
-        let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
+        let (_, _, r53, r55, r56) = prep_run_create_pr(true).await?;
         for relay in [&r53, &r55, &r56] {
             assert_eq!(
                 relay.events.iter().filter(|e| is_cover_letter(e)).count(),
@@ -277,7 +290,7 @@ mod sends_pr_and_2_patches_to_3_relays {
     #[tokio::test]
     #[serial]
     async fn only_1_pr_kind_event_sent_to_user_relays() -> Result<()> {
-        let (_, _, r53, r55, _) = prep_run_create_pr().await?;
+        let (_, _, r53, r55, _) = prep_run_create_pr(true).await?;
         for relay in [&r53, &r55] {
             assert_eq!(
                 relay.events.iter().filter(|e| is_cover_letter(e)).count(),
@@ -290,7 +303,7 @@ mod sends_pr_and_2_patches_to_3_relays {
     #[tokio::test]
     #[serial]
     async fn only_1_pr_kind_event_sent_to_repo_relays() -> Result<()> {
-        let (_, _, _, r55, r56) = prep_run_create_pr().await?;
+        let (_, _, _, r55, r56) = prep_run_create_pr(true).await?;
         for relay in [&r55, &r56] {
             assert_eq!(
                 relay.events.iter().filter(|e| is_cover_letter(e)).count(),
@@ -303,7 +316,7 @@ mod sends_pr_and_2_patches_to_3_relays {
     #[tokio::test]
     #[serial]
     async fn pr_not_sent_to_fallback_relay() -> Result<()> {
-        let (r51, r52, _, _, _) = prep_run_create_pr().await?;
+        let (r51, r52, _, _, _) = prep_run_create_pr(true).await?;
         for relay in [&r51, &r52] {
             assert_eq!(
                 relay.events.iter().filter(|e| is_cover_letter(e)).count(),
@@ -316,7 +329,7 @@ mod sends_pr_and_2_patches_to_3_relays {
     #[tokio::test]
     #[serial]
     async fn only_2_patch_kind_events_sent_to_each_relay() -> Result<()> {
-        let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
+        let (_, _, r53, r55, r56) = prep_run_create_pr(true).await?;
         for relay in [&r53, &r55, &r56] {
             assert_eq!(relay.events.iter().filter(|e| is_patch(e)).count(), 2,);
         }
@@ -327,18 +340,18 @@ mod sends_pr_and_2_patches_to_3_relays {
     #[serial]
     async fn patch_content_contains_patch_in_email_format_with_patch_series_numbers() -> Result<()>
     {
-        let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
+        let (_, _, r53, r55, r56) = prep_run_create_pr(true).await?;
         for relay in [&r53, &r55, &r56] {
             let patch_events: Vec<&nostr::Event> =
                 relay.events.iter().filter(|e| is_patch(e)).collect();
 
             assert_eq!(
-                patch_events[0].content,
+                patch_events[1].content,
                 "\
                     From fe973a840fba2a8ab37dd505c154854a69a6505c Mon Sep 17 00:00:00 2001\n\
                     From: Joe Bloggs <joe.bloggs@pm.me>\n\
                     Date: Thu, 1 Jan 1970 00:00:00 +0000\n\
-                    Subject: [PATCH 1/2] add t4.md\n\
+                    Subject: [PATCH 2/2] add t4.md\n\
                     \n\
                     ---\n \
                     t4.md | 1 +\n \
@@ -359,12 +372,12 @@ mod sends_pr_and_2_patches_to_3_relays {
                     ",
             );
             assert_eq!(
-                patch_events[1].content,
+                patch_events[0].content,
                 "\
                     From 232efb37ebc67692c9e9ff58b83c0d3d63971a0a Mon Sep 17 00:00:00 2001\n\
                     From: Joe Bloggs <joe.bloggs@pm.me>\n\
                     Date: Thu, 1 Jan 1970 00:00:00 +0000\n\
-                    Subject: [PATCH 2/2] add t3.md\n\
+                    Subject: [PATCH 1/2] add t3.md\n\
                     \n\
                     ---\n \
                     t3.md | 1 +\n \
@@ -394,7 +407,7 @@ mod sends_pr_and_2_patches_to_3_relays {
         #[tokio::test]
         #[serial]
         async fn root_commit_as_r() -> Result<()> {
-            let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
+            let (_, _, r53, r55, r56) = prep_run_create_pr(true).await?;
             for relay in [&r53, &r55, &r56] {
                 let pr_event: &nostr::Event =
                     relay.events.iter().find(|e| is_cover_letter(e)).unwrap();
@@ -414,7 +427,7 @@ mod sends_pr_and_2_patches_to_3_relays {
         #[tokio::test]
         #[serial]
         async fn a_tag_for_repo_event() -> Result<()> {
-            let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
+            let (_, _, r53, r55, r56) = prep_run_create_pr(true).await?;
             for relay in [&r53, &r55, &r56] {
                 let pr_event: &nostr::Event =
                     relay.events.iter().find(|e| is_cover_letter(e)).unwrap();
@@ -436,7 +449,7 @@ mod sends_pr_and_2_patches_to_3_relays {
                 .unwrap()
                 .as_vec()
                 .clone()[1..];
-            let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
+            let (_, _, r53, r55, r56) = prep_run_create_pr(true).await?;
             for relay in [&r53, &r55, &r56] {
                 for m in maintainers {
                     let pr_event: &nostr::Event =
@@ -454,7 +467,7 @@ mod sends_pr_and_2_patches_to_3_relays {
         #[tokio::test]
         #[serial]
         async fn t_tag_cover_letter() -> Result<()> {
-            let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
+            let (_, _, r53, r55, r56) = prep_run_create_pr(true).await?;
             for relay in [&r53, &r55, &r56] {
                 let pr_event: &nostr::Event =
                     relay.events.iter().find(|e| is_cover_letter(e)).unwrap();
@@ -470,7 +483,7 @@ mod sends_pr_and_2_patches_to_3_relays {
         #[tokio::test]
         #[serial]
         async fn t_tag_root() -> Result<()> {
-            let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
+            let (_, _, r53, r55, r56) = prep_run_create_pr(true).await?;
             for relay in [&r53, &r55, &r56] {
                 let pr_event: &nostr::Event =
                     relay.events.iter().find(|e| is_cover_letter(e)).unwrap();
@@ -486,7 +499,7 @@ mod sends_pr_and_2_patches_to_3_relays {
         #[tokio::test]
         #[serial]
         async fn pr_tags_branch_name() -> Result<()> {
-            let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
+            let (_, _, r53, r55, r56) = prep_run_create_pr(true).await?;
             for relay in [&r53, &r55, &r56] {
                 let pr_event: &nostr::Event =
                     relay.events.iter().find(|e| is_cover_letter(e)).unwrap();
@@ -509,14 +522,14 @@ mod sends_pr_and_2_patches_to_3_relays {
         use super::*;
 
         async fn prep() -> Result<nostr::Event> {
-            let (_, _, r53, _, _) = prep_run_create_pr().await?;
+            let (_, _, r53, _, _) = prep_run_create_pr(true).await?;
             Ok(r53.events.iter().find(|e| is_patch(e)).unwrap().clone())
         }
 
         #[tokio::test]
         #[serial]
         async fn commit_and_commit_r() -> Result<()> {
-            static COMMIT_ID: &str = "fe973a840fba2a8ab37dd505c154854a69a6505c";
+            static COMMIT_ID: &str = "232efb37ebc67692c9e9ff58b83c0d3d63971a0a";
             let most_recent_patch = prep().await?;
             assert!(
                 most_recent_patch
@@ -537,12 +550,16 @@ mod sends_pr_and_2_patches_to_3_relays {
         #[serial]
         async fn parent_commit() -> Result<()> {
             // commit parent 'r' and 'parent-commit' tag
-            static COMMIT_PARENT_ID: &str = "232efb37ebc67692c9e9ff58b83c0d3d63971a0a";
+            static COMMIT_PARENT_ID: &str = "431b84edc0d2fa118d63faa3c2db9c73d630a5ae";
             let most_recent_patch = prep().await?;
-            assert!(
-                most_recent_patch.tags.iter().any(
-                    |t| t.as_vec()[0].eq("parent-commit") && t.as_vec()[1].eq(COMMIT_PARENT_ID)
-                )
+            assert_eq!(
+                most_recent_patch
+                    .tags
+                    .iter()
+                    .find(|t| t.as_vec()[0].eq("parent-commit"))
+                    .unwrap()
+                    .as_vec()[1],
+                COMMIT_PARENT_ID,
             );
             Ok(())
         }
@@ -599,7 +616,7 @@ mod sends_pr_and_2_patches_to_3_relays {
                     .find(|t| t.as_vec()[0].eq("description"))
                     .unwrap()
                     .as_vec()[1],
-                "add t4.md"
+                "add t3.md"
             );
             Ok(())
         }
@@ -639,7 +656,7 @@ mod sends_pr_and_2_patches_to_3_relays {
         #[tokio::test]
         #[serial]
         async fn patch_tags_pr_event_as_root() -> Result<()> {
-            let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
+            let (_, _, r53, r55, r56) = prep_run_create_pr(true).await?;
             for relay in [&r53, &r55, &r56] {
                 let patch_events: Vec<&nostr::Event> =
                     relay.events.iter().filter(|e| is_patch(e)).collect();
@@ -659,6 +676,43 @@ mod sends_pr_and_2_patches_to_3_relays {
             }
             Ok(())
         }
+
+        #[tokio::test]
+        #[serial]
+        async fn second_patch_tags_first_with_reply() -> Result<()> {
+            let (_, _, r53, r55, r56) = prep_run_create_pr(true).await?;
+            for relay in [&r53, &r55, &r56] {
+                let patch_events = relay
+                    .events
+                    .iter()
+                    .filter(|e| is_patch(e))
+                    .collect::<Vec<&nostr::Event>>();
+                assert_eq!(
+                    patch_events[1]
+                        .iter_tags()
+                        .find(|t| t.as_vec()[0].eq("e")
+                            && t.as_vec().len().eq(&4)
+                            && t.as_vec()[3].eq("reply"))
+                        .unwrap()
+                        .as_vec()[1],
+                    patch_events[0].id.to_string(),
+                );
+            }
+            Ok(())
+        }
+
+        #[tokio::test]
+        #[serial]
+        async fn no_t_root_tag() -> Result<()> {
+            assert!(
+                !prep()
+                    .await?
+                    .tags
+                    .iter()
+                    .any(|t| t.as_vec()[0].eq("t") && t.as_vec()[1].eq("root"))
+            );
+            Ok(())
+        }
     }
     mod cli_ouput {
         use super::*;
@@ -701,8 +755,8 @@ mod sends_pr_and_2_patches_to_3_relays {
 
             // // check relay had the right number of events
             let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
-                let mut p = cli_tester_create_pr(&git_repo);
-                expect_msgs_first(&mut p)?;
+                let mut p = cli_tester_create_pr(&git_repo, true);
+                expect_msgs_first(&mut p, true)?;
                 relay::expect_send_with_progress(
                     &mut p,
                     vec![
@@ -790,7 +844,7 @@ mod sends_pr_and_2_patches_to_3_relays {
 
                 // // check relay had the right number of events
                 let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
-                    let mut p = cli_tester_create_pr(&git_repo);
+                    let mut p = cli_tester_create_pr(&git_repo, true);
                     p.expect_end_eventually()?;
                     for p in [51, 52, 53, 55, 56] {
                         relay::shutdown_relay(8000 + p)?;
@@ -869,8 +923,8 @@ mod sends_pr_and_2_patches_to_3_relays {
 
                 // // check relay had the right number of events
                 let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
-                    let mut p = cli_tester_create_pr(&git_repo);
-                    expect_msgs_first(&mut p)?;
+                    let mut p = cli_tester_create_pr(&git_repo, true);
+                    expect_msgs_first(&mut p, true)?;
                     // p.expect_end_with("bla")?;
                     relay::expect_send_with_progress(
                         &mut p,
@@ -915,7 +969,162 @@ mod sends_pr_and_2_patches_to_3_relays {
     }
 }
 
-mod without_cover_letter {
+mod sends_2_patches_without_cover_letter {
     use super::*;
-    // TODO
+
+    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_pr(&git_repo, false);
+
+                expect_msgs_first(&mut p, false)?;
+                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, ""),
+                    ],
+                    2,
+                )?;
+                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 no_cover_letter_event() -> Result<()> {
+        let (_, _, r53, r55, r56) = prep_run_create_pr(false).await?;
+        for relay in [&r53, &r55, &r56] {
+            assert_eq!(
+                relay.events.iter().filter(|e| is_cover_letter(e)).count(),
+                0,
+            );
+        }
+        Ok(())
+    }
+
+    #[tokio::test]
+    #[serial]
+    async fn two_patch_events() -> Result<()> {
+        let (_, _, r53, r55, r56) = prep_run_create_pr(false).await?;
+        for relay in [&r53, &r55, &r56] {
+            assert_eq!(relay.events.iter().filter(|e| is_patch(e)).count(), 2);
+        }
+        Ok(())
+    }
+
+    #[tokio::test]
+    #[serial]
+    // TODO check this is the ancestor
+    async fn first_patch_with_root_t_tag() -> Result<()> {
+        let (_, _, r53, r55, r56) = prep_run_create_pr(false).await?;
+        for relay in [&r53, &r55, &r56] {
+            let patch_events = relay
+                .events
+                .iter()
+                .filter(|e| is_patch(e))
+                .collect::<Vec<&nostr::Event>>();
+
+            // first patch tagged as root
+            assert!(
+                patch_events[0]
+                    .iter_tags()
+                    .any(|t| t.as_vec()[0].eq("t") && t.as_vec()[1].eq("root"))
+            );
+            // second patch not tagged as root
+            assert!(
+                !patch_events[1]
+                    .iter_tags()
+                    .any(|t| t.as_vec()[0].eq("t") && t.as_vec()[1].eq("root"))
+            );
+        }
+        Ok(())
+    }
+
+    #[tokio::test]
+    #[serial]
+    async fn second_patch_lists_first_as_root() -> Result<()> {
+        let (_, _, r53, r55, r56) = prep_run_create_pr(false).await?;
+        for relay in [&r53, &r55, &r56] {
+            let patch_events = relay
+                .events
+                .iter()
+                .filter(|e| is_patch(e))
+                .collect::<Vec<&nostr::Event>>();
+
+            assert_eq!(
+                patch_events[1]
+                    .iter_tags()
+                    .find(|t| t.as_vec()[0].eq("e")
+                        && t.as_vec().len().eq(&4)
+                        && t.as_vec()[3].eq("root"))
+                    .unwrap()
+                    .as_vec()[1],
+                patch_events[0].id.to_string(),
+            );
+        }
+        Ok(())
+    }
 }
diff --git a/tests/prs_list.rs b/tests/prs_list.rs
index 75704f6..7c0d8ec 100644
--- a/tests/prs_list.rs
+++ b/tests/prs_list.rs
@@ -6,6 +6,7 @@ use test_utils::{git::GitTestRepo, relay::Relay, *};
 static FEATURE_BRANCH_NAME_1: &str = "feature-example-t";
 static FEATURE_BRANCH_NAME_2: &str = "feature-example-f";
 static FEATURE_BRANCH_NAME_3: &str = "feature-example-c";
+static FEATURE_BRANCH_NAME_4: &str = "feature-example-d";
 
 static PR_TITLE_1: &str = "pr a";
 static PR_TITLE_2: &str = "pr b";
@@ -18,22 +19,19 @@ fn cli_tester_create_prs() -> Result<GitTestRepo> {
         &git_repo,
         FEATURE_BRANCH_NAME_1,
         "a",
-        PR_TITLE_1,
-        "pr a description",
+        Some((PR_TITLE_1, "pr a description")),
     )?;
     cli_tester_create_pr(
         &git_repo,
         FEATURE_BRANCH_NAME_2,
         "b",
-        PR_TITLE_2,
-        "pr b description",
+        Some((PR_TITLE_2, "pr b description")),
     )?;
     cli_tester_create_pr(
         &git_repo,
         FEATURE_BRANCH_NAME_3,
         "c",
-        PR_TITLE_3,
-        "pr c description",
+        Some((PR_TITLE_3, "pr c description")),
     )?;
     Ok(git_repo)
 }
@@ -66,28 +64,44 @@ fn cli_tester_create_pr(
     test_repo: &GitTestRepo,
     branch_name: &str,
     prefix: &str,
-    title: &str,
-    description: &str,
+    cover_letter_title_and_description: Option<(&str, &str)>,
 ) -> Result<()> {
     create_and_populate_branch(test_repo, branch_name, prefix, false)?;
 
-    let mut p = CliTester::new_from_dir(
-        &test_repo.dir,
-        [
-            "--nsec",
-            TEST_KEY_1_NSEC,
-            "--password",
-            TEST_PASSWORD,
-            "--disable-cli-spinners",
-            "prs",
-            "create",
-            "--title",
-            format!("\"{title}\"").as_str(),
-            "--description",
-            format!("\"{description}\"").as_str(),
-        ],
-    );
-    p.expect_end_eventually()?;
+    if let Some((title, description)) = cover_letter_title_and_description {
+        let mut p = CliTester::new_from_dir(
+            &test_repo.dir,
+            [
+                "--nsec",
+                TEST_KEY_1_NSEC,
+                "--password",
+                TEST_PASSWORD,
+                "--disable-cli-spinners",
+                "prs",
+                "create",
+                "--title",
+                format!("\"{title}\"").as_str(),
+                "--description",
+                format!("\"{description}\"").as_str(),
+            ],
+        );
+        p.expect_end_eventually()?;
+    } else {
+        let mut p = CliTester::new_from_dir(
+            &test_repo.dir,
+            [
+                "--nsec",
+                TEST_KEY_1_NSEC,
+                "--password",
+                TEST_PASSWORD,
+                "--disable-cli-spinners",
+                "prs",
+                "create",
+                "--no-cover-letter",
+            ],
+        );
+        p.expect_end_eventually()?;
+    }
     Ok(())
 }
 
@@ -432,6 +446,183 @@ mod when_main_branch_is_uptodate {
                     Ok(())
                 }
             }
+            mod when_forth_pr_has_no_cover_letter {
+                use super::*;
+
+                async fn prep_and_run() -> Result<(GitTestRepo, GitTestRepo)> {
+                    // 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, None),
+                        Relay::new(8052, None, None),
+                        Relay::new(8053, None, None),
+                        Relay::new(8055, None, None),
+                        Relay::new(8056, None, None),
+                    );
+
+                    r51.events.push(generate_test_key_1_relay_list_event());
+                    r51.events.push(generate_test_key_1_metadata_event("fred"));
+                    r51.events.push(generate_repo_ref_event());
+
+                    r55.events.push(generate_repo_ref_event());
+                    r55.events.push(generate_test_key_1_metadata_event("fred"));
+                    r55.events.push(generate_test_key_1_relay_list_event());
+
+                    let cli_tester_handle =
+                        std::thread::spawn(move || -> Result<(GitTestRepo, GitTestRepo)> {
+                            let originating_repo = cli_tester_create_prs()?;
+                            cli_tester_create_pr(
+                                &originating_repo,
+                                FEATURE_BRANCH_NAME_4,
+                                "d",
+                                None,
+                            )?;
+                            let test_repo = GitTestRepo::default();
+                            test_repo.populate()?;
+                            let mut p = CliTester::new_from_dir(&test_repo.dir, ["prs", "list"]);
+
+                            p.expect("finding PRs...\r\n")?;
+                            let mut c = p.expect_choice(
+                                "All PRs",
+                                vec![
+                                    format!("\"{PR_TITLE_1}\""),
+                                    format!("\"{PR_TITLE_2}\""),
+                                    format!("\"{PR_TITLE_3}\""),
+                                    format!("add d3.md"), // commit msg title
+                                ],
+                            )?;
+                            c.succeeds_with(3, true)?;
+                            let mut confirm =
+                                p.expect_confirm_eventually("check out branch?", Some(true))?;
+                            confirm.succeeds_with(None)?;
+                            p.expect_end_eventually_and_print()?;
+
+                            for p in [51, 52, 53, 55, 56] {
+                                relay::shutdown_relay(8000 + p)?;
+                            }
+                            Ok((originating_repo, test_repo))
+                        });
+
+                    // launch relay
+                    let _ = join!(
+                        r51.listen_until_close(),
+                        r52.listen_until_close(),
+                        r53.listen_until_close(),
+                        r55.listen_until_close(),
+                        r56.listen_until_close(),
+                    );
+                    let res = cli_tester_handle.join().unwrap()?;
+
+                    Ok(res)
+                }
+
+                mod cli_prompts {
+                    use super::*;
+                    async fn run_async_prompts_to_choose_from_pr_titles() -> Result<()> {
+                        let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
+                            Relay::new(8051, None, None),
+                            Relay::new(8052, None, None),
+                            Relay::new(8053, None, None),
+                            Relay::new(8055, None, None),
+                            Relay::new(8056, None, None),
+                        );
+
+                        r51.events.push(generate_test_key_1_relay_list_event());
+                        r51.events.push(generate_test_key_1_metadata_event("fred"));
+                        r51.events.push(generate_repo_ref_event());
+
+                        r55.events.push(generate_repo_ref_event());
+                        r55.events.push(generate_test_key_1_metadata_event("fred"));
+                        r55.events.push(generate_test_key_1_relay_list_event());
+
+                        let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
+                            let originating_repo = cli_tester_create_prs()?;
+                            cli_tester_create_pr(
+                                &originating_repo,
+                                FEATURE_BRANCH_NAME_4,
+                                "d",
+                                None,
+                            )?;
+                            let test_repo = GitTestRepo::default();
+                            test_repo.populate()?;
+                            let mut p = CliTester::new_from_dir(&test_repo.dir, ["prs", "list"]);
+
+                            p.expect("finding PRs...\r\n")?;
+                            let mut c = p.expect_choice(
+                                "All PRs",
+                                vec![
+                                    format!("\"{PR_TITLE_1}\""),
+                                    format!("\"{PR_TITLE_2}\""),
+                                    format!("\"{PR_TITLE_3}\""),
+                                    format!("add d3.md"), // commit msg title
+                                ],
+                            )?;
+                            c.succeeds_with(3, true)?;
+                            p.expect("finding commits...\r\n")?;
+                            let mut confirm = p.expect_confirm("check out branch?", Some(true))?;
+                            confirm.succeeds_with(None)?;
+                            p.expect("checked out PR branch. pulled 2 new commits\r\n")?;
+                            p.expect_end()?;
+
+                            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()?;
+                        println!("{:?}", r55.events);
+                        Ok(())
+                    }
+
+                    #[tokio::test]
+                    #[serial]
+                    async fn prompts_to_choose_from_pr_titles() -> Result<()> {
+                        let _ = run_async_prompts_to_choose_from_pr_titles().await;
+                        Ok(())
+                    }
+                }
+
+                #[tokio::test]
+                #[serial]
+                async fn pr_branch_created_with_correct_name() -> Result<()> {
+                    let (_, test_repo) = prep_and_run().await?;
+                    assert_eq!(
+                        vec![FEATURE_BRANCH_NAME_4, "main"],
+                        test_repo.get_local_branch_names()?
+                    );
+                    Ok(())
+                }
+
+                #[tokio::test]
+                #[serial]
+                async fn pr_branch_checked_out() -> Result<()> {
+                    let (_, test_repo) = prep_and_run().await?;
+                    assert_eq!(
+                        FEATURE_BRANCH_NAME_4,
+                        test_repo.get_checked_out_branch_name()?,
+                    );
+                    Ok(())
+                }
+
+                #[tokio::test]
+                #[serial]
+                async fn pr_branch_tip_is_most_recent_patch() -> Result<()> {
+                    let (originating_repo, test_repo) = prep_and_run().await?;
+                    assert_eq!(
+                        originating_repo.get_tip_of_local_branch(FEATURE_BRANCH_NAME_4)?,
+                        test_repo.get_tip_of_local_branch(FEATURE_BRANCH_NAME_4)?,
+                    );
+                    Ok(())
+                }
+            }
         }
     }