test: replace block_on with tokio::tests

This is intended to improve the reliabilty of the tests. there have been
particular issues with random tests never ending when run in the nix
configuration

see discussion here
https://github.com/DanConwayDev/ngit-cli/issues/
6#issuecomment-1918971239

and:
https://github.com/DanConwayDev/ngit-cli/pull/7

6 files changed, 278 insertions, 264 deletions

diff --git a/tests/claim.rs b/tests/claim.rs
index 93feb54..ef669d0 100644
--- a/tests/claim.rs
+++ b/tests/claim.rs
@@ -117,10 +117,10 @@ mod when_repo_not_previously_claimed {
         mod sent_to_correct_relays {
             use super::*;
 
-            #[test]
+            #[tokio::test]
             #[serial]
-            fn only_1_repository_kind_event_sent_to_user_relays() -> Result<()> {
-                let (_, _, r53, r55, _) = futures::executor::block_on(prep_run_claim())?;
+            async fn only_1_repository_kind_event_sent_to_user_relays() -> Result<()> {
+                let (_, _, r53, r55, _) = prep_run_claim().await?;
                 for relay in [&r53, &r55] {
                     assert_eq!(
                         relay
@@ -134,10 +134,10 @@ mod when_repo_not_previously_claimed {
                 Ok(())
             }
 
-            #[test]
+            #[tokio::test]
             #[serial]
-            fn only_1_repository_kind_event_sent_to_specified_repo_relays() -> Result<()> {
-                let (_, _, _, r55, r56) = futures::executor::block_on(prep_run_claim())?;
+            async fn only_1_repository_kind_event_sent_to_specified_repo_relays() -> Result<()> {
+                let (_, _, _, r55, r56) = prep_run_claim().await?;
                 for relay in [&r55, &r56] {
                     assert_eq!(
                         relay
@@ -151,10 +151,10 @@ mod when_repo_not_previously_claimed {
                 Ok(())
             }
 
-            #[test]
+            #[tokio::test]
             #[serial]
-            fn event_not_sent_to_fallback_relay() -> Result<()> {
-                let (r51, r52, _, _, _) = futures::executor::block_on(prep_run_claim())?;
+            async fn event_not_sent_to_fallback_relay() -> Result<()> {
+                let (r51, r52, _, _, _) = prep_run_claim().await?;
                 for relay in [&r51, &r52] {
                     assert_eq!(
                         relay
@@ -241,10 +241,10 @@ mod when_repo_not_previously_claimed {
                 Ok(())
             }
 
-            #[test]
+            #[tokio::test]
             #[serial]
-            fn contains_maintainers_and_relays() -> Result<()> {
-                futures::executor::block_on(async_run_test())?;
+            async fn contains_maintainers_and_relays() -> Result<()> {
+                async_run_test().await?;
                 Ok(())
             }
         }
@@ -252,9 +252,10 @@ mod when_repo_not_previously_claimed {
         mod tags {
             use super::*;
 
-            #[test]
+            #[tokio::test]
             #[serial]
-            fn d_replaceable_event_identifier_defaults_to_root_commit_id_shorthand() -> Result<()> {
+            async fn d_replaceable_event_identifier_defaults_to_root_commit_id_shorthand()
+            -> Result<()> {
                 let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_claim())?;
                 for relay in [&r53, &r55, &r56] {
                     let event: &nostr::Event = relay
@@ -273,10 +274,10 @@ mod when_repo_not_previously_claimed {
                 Ok(())
             }
 
-            #[test]
+            #[tokio::test]
             #[serial]
-            fn root_commit_as_reference() -> Result<()> {
-                let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_claim())?;
+            async fn root_commit_as_reference() -> Result<()> {
+                let (_, _, r53, r55, r56) = prep_run_claim().await?;
                 for relay in [&r53, &r55, &r56] {
                     let event: &nostr::Event = relay
                         .events
@@ -290,10 +291,10 @@ mod when_repo_not_previously_claimed {
                 Ok(())
             }
 
-            #[test]
+            #[tokio::test]
             #[serial]
-            fn name() -> Result<()> {
-                let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_claim())?;
+            async fn name() -> Result<()> {
+                let (_, _, r53, r55, r56) = prep_run_claim().await?;
                 for relay in [&r53, &r55, &r56] {
                     let event: &nostr::Event = relay
                         .events
@@ -311,10 +312,10 @@ mod when_repo_not_previously_claimed {
                 Ok(())
             }
 
-            #[test]
+            #[tokio::test]
             #[serial]
-            fn description() -> Result<()> {
-                let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_claim())?;
+            async fn description() -> Result<()> {
+                let (_, _, r53, r55, r56) = prep_run_claim().await?;
                 for relay in [&r53, &r55, &r56] {
                     let event: &nostr::Event = relay
                         .events
@@ -328,10 +329,10 @@ mod when_repo_not_previously_claimed {
                 Ok(())
             }
 
-            #[test]
+            #[tokio::test]
             #[serial]
-            fn git_server() -> Result<()> {
-                let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_claim())?;
+            async fn git_server() -> Result<()> {
+                let (_, _, r53, r55, r56) = prep_run_claim().await?;
                 for relay in [&r53, &r55, &r56] {
                     let event: &nostr::Event = relay
                         .events
@@ -347,10 +348,10 @@ mod when_repo_not_previously_claimed {
                 Ok(())
             }
 
-            #[test]
+            #[tokio::test]
             #[serial]
-            fn relays() -> Result<()> {
-                let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_claim())?;
+            async fn relays() -> Result<()> {
+                let (_, _, r53, r55, r56) = prep_run_claim().await?;
                 for relay in [&r53, &r55, &r56] {
                     let event: &nostr::Event = relay
                         .events
@@ -369,9 +370,9 @@ mod when_repo_not_previously_claimed {
                 Ok(())
             }
 
-            #[test]
+            #[tokio::test]
             #[serial]
-            fn web() -> Result<()> {
+            async fn web() -> Result<()> {
                 let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_claim())?;
                 for relay in [&r53, &r55, &r56] {
                     let event: &nostr::Event = relay
@@ -473,10 +474,10 @@ mod when_repo_not_previously_claimed {
                 Ok(())
             }
 
-            #[test]
+            #[tokio::test]
             #[serial]
-            fn check_cli_output() -> Result<()> {
-                futures::executor::block_on(run_test_async())?;
+            async fn check_cli_output() -> Result<()> {
+                run_test_async().await?;
                 Ok(())
             }
         }
@@ -572,10 +573,10 @@ mod when_repo_not_previously_claimed {
         mod tags {
             use super::*;
 
-            #[test]
+            #[tokio::test]
             #[serial]
-            fn relays_match_user_write_relays() -> Result<()> {
-                let (_, _, r53, r55, _) = futures::executor::block_on(prep_run_claim())?;
+            async fn relays_match_user_write_relays() -> Result<()> {
+                let (_, _, r53, r55, _) = prep_run_claim().await?;
                 for relay in [&r53, &r55] {
                     let event: &nostr::Event = relay
                         .events
@@ -650,10 +651,10 @@ mod when_repo_not_previously_claimed {
                 Ok(())
             }
 
-            #[test]
+            #[tokio::test]
             #[serial]
-            fn check_cli_output() -> Result<()> {
-                futures::executor::block_on(run_test_async())?;
+            async fn check_cli_output() -> Result<()> {
+                run_test_async().await?;
                 Ok(())
             }
         }
diff --git a/tests/login.rs b/tests/login.rs
index ee7450d..7fc9356 100644
--- a/tests/login.rs
+++ b/tests/login.rs
@@ -121,10 +121,10 @@ mod with_relays {
                     Ok(())
                 }
 
-                #[test]
+                #[tokio::test]
                 #[serial]
-                fn when_latest_metadata_and_relay_list_on_all_relays() -> Result<()> {
-                    futures::executor::block_on(run_test_displays_correct_name(
+                async fn when_latest_metadata_and_relay_list_on_all_relays() -> Result<()> {
+                    run_test_displays_correct_name(
                         Some(&|relay, client_id, subscription_id, _| -> Result<()> {
                             relay.respond_events(
                                 client_id,
@@ -147,16 +147,17 @@ mod with_relays {
                             )?;
                             Ok(())
                         }),
-                    ))
+                    )
+                    .await
                 }
 
                 mod poorly_quality_metadata_event {
                     use super::*;
 
-                    #[test]
+                    #[tokio::test]
                     #[serial]
-                    fn when_metadata_contains_only_display_name() -> Result<()> {
-                        futures::executor::block_on(run_test_displays_correct_name(
+                    async fn when_metadata_contains_only_display_name() -> Result<()> {
+                        run_test_displays_correct_name(
                             Some(&|relay, client_id, subscription_id, _| -> Result<()> {
                                 relay.respond_events(
                                     client_id,
@@ -173,12 +174,13 @@ mod with_relays {
                                 Ok(())
                             }),
                             None,
-                        ))
+                        )
+                        .await
                     }
 
-                    #[test]
+                    #[tokio::test]
                     #[serial]
-                    fn when_metadata_contains_only_displayname() -> Result<()> {
+                    async fn when_metadata_contains_only_displayname() -> Result<()> {
                         println!(
                             "displayName: {}",
                             nostr::Metadata::new()
@@ -192,7 +194,7 @@ mod with_relays {
                             nostr::Metadata::new().name("fred").name.unwrap()
                         );
 
-                        futures::executor::block_on(run_test_displays_correct_name(
+                        run_test_displays_correct_name(
                             Some(&|relay, client_id, subscription_id, _| -> Result<()> {
                                 relay.respond_events(
                                     client_id,
@@ -210,12 +212,13 @@ mod with_relays {
                                 Ok(())
                             }),
                             None,
-                        ))
+                        )
+                        .await
                     }
 
-                    #[test]
+                    #[tokio::test]
                     #[serial]
-                    fn displays_npub_when_metadata_contains_no_name_displayname_or_display_name()
+                    async fn displays_npub_when_metadata_contains_no_name_displayname_or_display_name()
                     -> Result<()> {
                         println!(
                             "displayName: {}",
@@ -230,7 +233,7 @@ mod with_relays {
                             nostr::Metadata::new().name("fred").name.unwrap()
                         );
 
-                        futures::executor::block_on(run_test_displays_fallback_to_npub(
+                        run_test_displays_fallback_to_npub(
                             Some(&|relay, client_id, subscription_id, _| -> Result<()> {
                                 relay.respond_events(
                                     client_id,
@@ -247,15 +250,16 @@ mod with_relays {
                                 Ok(())
                             }),
                             None,
-                        ))
+                        )
+                        .await
                     }
                 }
 
-                #[test]
+                #[tokio::test]
                 #[serial]
-                fn when_latest_metadata_and_relay_list_on_some_relays_but_others_have_none()
+                async fn when_latest_metadata_and_relay_list_on_some_relays_but_others_have_none()
                 -> Result<()> {
-                    futures::executor::block_on(run_test_displays_correct_name(
+                    run_test_displays_correct_name(
                         Some(&|relay, client_id, subscription_id, _| -> Result<()> {
                             relay.respond_events(
                                 client_id,
@@ -268,13 +272,15 @@ mod with_relays {
                             Ok(())
                         }),
                         None,
-                    ))
+                    )
+                    .await
                 }
 
-                #[test]
+                #[tokio::test]
                 #[serial]
-                fn when_latest_metadata_only_on_relay_and_relay_list_on_another() -> Result<()> {
-                    futures::executor::block_on(run_test_displays_correct_name(
+                async fn when_latest_metadata_only_on_relay_and_relay_list_on_another() -> Result<()>
+                {
+                    run_test_displays_correct_name(
                         Some(&|relay, client_id, subscription_id, _| -> Result<()> {
                             relay.respond_events(
                                 client_id,
@@ -291,13 +297,14 @@ mod with_relays {
                             )?;
                             Ok(())
                         }),
-                    ))
+                    )
+                    .await
                 }
 
-                #[test]
+                #[tokio::test]
                 #[serial]
-                fn when_some_relays_return_old_metadata_event() -> Result<()> {
-                    futures::executor::block_on(run_test_displays_correct_name(
+                async fn when_some_relays_return_old_metadata_event() -> Result<()> {
+                    run_test_displays_correct_name(
                         Some(&|relay, client_id, subscription_id, _| -> Result<()> {
                             relay.respond_events(
                                 client_id,
@@ -317,13 +324,14 @@ mod with_relays {
                             )?;
                             Ok(())
                         }),
-                    ))
+                    )
+                    .await
                 }
 
-                #[test]
+                #[tokio::test]
                 #[serial]
-                fn when_some_relays_return_other_users_metadata() -> Result<()> {
-                    futures::executor::block_on(run_test_displays_correct_name(
+                async fn when_some_relays_return_other_users_metadata() -> Result<()> {
+                    run_test_displays_correct_name(
                         Some(&|relay, client_id, subscription_id, _| -> Result<()> {
                             relay.respond_events(
                                 client_id,
@@ -343,13 +351,14 @@ mod with_relays {
                             )?;
                             Ok(())
                         }),
-                    ))
+                    )
+                    .await
                 }
 
-                #[test]
+                #[tokio::test]
                 #[serial]
-                fn when_some_relays_return_other_event_kinds() -> Result<()> {
-                    futures::executor::block_on(run_test_displays_correct_name(
+                async fn when_some_relays_return_other_event_kinds() -> Result<()> {
+                    run_test_displays_correct_name(
                         Some(&|relay, client_id, subscription_id, _| -> Result<()> {
                             let event = generate_test_key_1_kind_event(nostr::Kind::TextNote);
                             relay.respond_events(
@@ -370,31 +379,31 @@ mod with_relays {
                             )?;
                             Ok(())
                         }),
-                    ))
+                    )
+                    .await
                 }
 
                 mod when_specifying_command_line_nsec_only {
                     use super::*;
 
-                    #[test]
+                    #[tokio::test]
                     #[serial]
-                    fn displays_correct_name() -> Result<()> {
-                        futures::executor::block_on(
-                            run_test_when_specifying_command_line_nsec_only_displays_correct_name(
-                                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_same_as_fallback(),
-                                        ],
-                                    )?;
-                                    Ok(())
-                                }),
-                                None,
-                            ),
+                    async fn displays_correct_name() -> Result<()> {
+                        run_test_when_specifying_command_line_nsec_only_displays_correct_name(
+                            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_same_as_fallback(),
+                                    ],
+                                )?;
+                                Ok(())
+                            }),
+                            None,
                         )
+                        .await
                     }
                     async fn run_test_when_specifying_command_line_nsec_only_displays_correct_name(
                         relay_listener1: Option<ListenerReqFunc<'_>>,
@@ -430,10 +439,9 @@ mod with_relays {
                 mod when_specifying_command_line_password_only {
                     use super::*;
 
-                    #[test]
+                    #[tokio::test]
                     #[serial]
-                    fn displays_correct_name() -> Result<()> {
-                        futures::executor::block_on(
+                    async fn displays_correct_name() -> Result<()> {
                         run_test_when_specifying_command_line_password_only_displays_correct_name(
                             Some(&|relay, client_id, subscription_id, _| -> Result<()> {
                                 relay.respond_events(
@@ -447,8 +455,8 @@ mod with_relays {
                                 Ok(())
                             }),
                             None,
-                        ),
-                    )
+                        )
+                        .await
                     }
                     async fn run_test_when_specifying_command_line_password_only_displays_correct_name(
                         relay_listener1: Option<ListenerReqFunc<'_>>,
@@ -495,10 +503,9 @@ mod with_relays {
                 mod when_specifying_command_line_nsec_and_password {
                     use super::*;
 
-                    #[test]
+                    #[tokio::test]
                     #[serial]
-                    fn displays_correct_name() -> Result<()> {
-                        futures::executor::block_on(
+                    async fn displays_correct_name() -> Result<()> {
                         run_test_when_specifying_command_line_nsec_and_password_displays_correct_name(
                             Some(&|relay, client_id, subscription_id, _| -> Result<()> {
                                 relay.respond_events(
@@ -512,8 +519,7 @@ mod with_relays {
                                 Ok(())
                             }),
                             None,
-                        ),
-                    )
+                        ).await
                     }
                     async fn run_test_when_specifying_command_line_nsec_and_password_displays_correct_name(
                         relay_listener1: Option<ListenerReqFunc<'_>>,
@@ -557,12 +563,10 @@ mod with_relays {
             mod when_no_metadata_found {
                 use super::*;
 
-                #[test]
+                #[tokio::test]
                 #[serial]
-                fn warm_user_and_displays_npub() -> Result<()> {
-                    futures::executor::block_on(
-                        run_test_when_no_metadata_found_warns_user_and_uses_npub(None, None),
-                    )
+                async fn warm_user_and_displays_npub() -> Result<()> {
+                    run_test_when_no_metadata_found_warns_user_and_uses_npub(None, None).await
                 }
 
                 async fn run_test_when_no_metadata_found_warns_user_and_uses_npub(
@@ -612,22 +616,21 @@ mod with_relays {
             mod when_metadata_but_no_relay_list_found {
                 use super::*;
 
-                #[test]
+                #[tokio::test]
                 #[serial]
-                fn warm_user_and_displays_name() -> Result<()> {
-                    futures::executor::block_on(
-                        run_test_when_no_relay_list_found_warns_user_and_uses_npub(
-                            Some(&|relay, client_id, subscription_id, _| -> Result<()> {
-                                relay.respond_events(
-                                    client_id,
-                                    &subscription_id,
-                                    &vec![generate_test_key_1_metadata_event("fred")],
-                                )?;
-                                Ok(())
-                            }),
-                            None,
-                        ),
+                async fn warm_user_and_displays_name() -> Result<()> {
+                    run_test_when_no_relay_list_found_warns_user_and_uses_npub(
+                        Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                            relay.respond_events(
+                                client_id,
+                                &subscription_id,
+                                &vec![generate_test_key_1_metadata_event("fred")],
+                            )?;
+                            Ok(())
+                        }),
+                        None,
                     )
+                    .await
                 }
 
                 async fn run_test_when_no_relay_list_found_warns_user_and_uses_npub(
@@ -682,10 +685,10 @@ mod with_relays {
             mod uses_cache {
                 use super::*;
 
-                #[test]
+                #[tokio::test]
                 #[serial]
-                fn dislays_logged_in_with_correct_name() -> Result<()> {
-                    futures::executor::block_on(run_test_dislays_logged_in_with_correct_name(Some(
+                async fn dislays_logged_in_with_correct_name() -> Result<()> {
+                    run_test_dislays_logged_in_with_correct_name(Some(
                         &|relay, client_id, subscription_id, _| -> Result<()> {
                             relay.respond_events(
                                 client_id,
@@ -697,7 +700,8 @@ mod with_relays {
                             )?;
                             Ok(())
                         },
-                    )))
+                    ))
+                    .await
                 }
                 async fn run_test_dislays_logged_in_with_correct_name(
                     relay_listener: Option<ListenerReqFunc<'_>>,
@@ -794,10 +798,10 @@ mod with_relays {
             }
 
             /// this also tests that additional relays are queried
-            #[test]
+            #[tokio::test]
             #[serial]
-            fn displays_correct_name() -> Result<()> {
-                futures::executor::block_on(run_test_displays_correct_name(
+            async fn displays_correct_name() -> Result<()> {
+                run_test_displays_correct_name(
                     Some(&|relay, client_id, subscription_id, _| -> Result<()> {
                         relay.respond_events(
                             client_id,
@@ -820,7 +824,8 @@ mod with_relays {
                         )?;
                         Ok(())
                     }),
-                ))
+                )
+                .await
             }
         }
     }
diff --git a/tests/prs_create.rs b/tests/prs_create.rs
index ca92ac2..4f71e5a 100644
--- a/tests/prs_create.rs
+++ b/tests/prs_create.rs
@@ -252,10 +252,10 @@ mod sends_pr_and_2_patches_to_3_relays {
         Ok((r51, r52, r53, r55, r56))
     }
 
-    #[test]
+    #[tokio::test]
     #[serial]
-    fn only_1_pr_kind_event_sent_to_each_relay() -> Result<()> {
-        let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_create_pr())?;
+    async fn only_1_pr_kind_event_sent_to_each_relay() -> Result<()> {
+        let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
         for relay in [&r53, &r55, &r56] {
             assert_eq!(
                 relay
@@ -269,10 +269,10 @@ mod sends_pr_and_2_patches_to_3_relays {
         Ok(())
     }
 
-    #[test]
+    #[tokio::test]
     #[serial]
-    fn only_1_pr_kind_event_sent_to_user_relays() -> Result<()> {
-        let (_, _, r53, r55, _) = futures::executor::block_on(prep_run_create_pr())?;
+    async fn only_1_pr_kind_event_sent_to_user_relays() -> Result<()> {
+        let (_, _, r53, r55, _) = prep_run_create_pr().await?;
         for relay in [&r53, &r55] {
             assert_eq!(
                 relay
@@ -286,10 +286,10 @@ mod sends_pr_and_2_patches_to_3_relays {
         Ok(())
     }
 
-    #[test]
+    #[tokio::test]
     #[serial]
-    fn only_1_pr_kind_event_sent_to_repo_relays() -> Result<()> {
-        let (_, _, _, r55, r56) = futures::executor::block_on(prep_run_create_pr())?;
+    async fn only_1_pr_kind_event_sent_to_repo_relays() -> Result<()> {
+        let (_, _, _, r55, r56) = prep_run_create_pr().await?;
         for relay in [&r55, &r56] {
             assert_eq!(
                 relay
@@ -303,10 +303,10 @@ mod sends_pr_and_2_patches_to_3_relays {
         Ok(())
     }
 
-    #[test]
+    #[tokio::test]
     #[serial]
-    fn pr_not_sent_to_fallback_relay() -> Result<()> {
-        let (r51, r52, _, _, _) = futures::executor::block_on(prep_run_create_pr())?;
+    async fn pr_not_sent_to_fallback_relay() -> Result<()> {
+        let (r51, r52, _, _, _) = prep_run_create_pr().await?;
         for relay in [&r51, &r52] {
             assert_eq!(
                 relay
@@ -320,10 +320,10 @@ mod sends_pr_and_2_patches_to_3_relays {
         Ok(())
     }
 
-    #[test]
+    #[tokio::test]
     #[serial]
-    fn only_2_patch_kind_events_sent_to_each_relay() -> Result<()> {
-        let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_create_pr())?;
+    async fn only_2_patch_kind_events_sent_to_each_relay() -> Result<()> {
+        let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
         for relay in [&r53, &r55, &r56] {
             assert_eq!(
                 relay
@@ -337,10 +337,10 @@ mod sends_pr_and_2_patches_to_3_relays {
         Ok(())
     }
 
-    #[test]
+    #[tokio::test]
     #[serial]
-    fn patch_content_contains_patch_in_email_format() -> Result<()> {
-        let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_create_pr())?;
+    async fn patch_content_contains_patch_in_email_format() -> Result<()> {
+        let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
         for relay in [&r53, &r55, &r56] {
             let patch_events: Vec<&nostr::Event> = relay
                 .events
@@ -407,10 +407,10 @@ mod sends_pr_and_2_patches_to_3_relays {
     mod pr_tags {
         use super::*;
 
-        #[test]
+        #[tokio::test]
         #[serial]
-        fn pr_tags_repo_commit() -> Result<()> {
-            let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_create_pr())?;
+        async fn pr_tags_repo_commit() -> Result<()> {
+            let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
             let root_commit = GitTestRepo::default().initial_commit()?;
 
             for relay in [&r53, &r55, &r56] {
@@ -429,10 +429,10 @@ mod sends_pr_and_2_patches_to_3_relays {
             Ok(())
         }
 
-        #[test]
+        #[tokio::test]
         #[serial]
-        fn pr_tags_title_as_name() -> Result<()> {
-            let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_create_pr())?;
+        async fn pr_tags_title_as_name() -> Result<()> {
+            let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
             for relay in [&r53, &r55, &r56] {
                 let pr_event: &nostr::Event = relay
                     .events
@@ -453,10 +453,10 @@ mod sends_pr_and_2_patches_to_3_relays {
             Ok(())
         }
 
-        #[test]
+        #[tokio::test]
         #[serial]
-        fn pr_tags_description() -> Result<()> {
-            let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_create_pr())?;
+        async fn pr_tags_description() -> Result<()> {
+            let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
             for relay in [&r53, &r55, &r56] {
                 let pr_event: &nostr::Event = relay
                     .events
@@ -477,10 +477,10 @@ mod sends_pr_and_2_patches_to_3_relays {
             Ok(())
         }
 
-        #[test]
+        #[tokio::test]
         #[serial]
-        fn pr_tags_branch_name() -> Result<()> {
-            let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_create_pr())?;
+        async fn pr_tags_branch_name() -> Result<()> {
+            let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
             for relay in [&r53, &r55, &r56] {
                 let pr_event: &nostr::Event = relay
                     .events
@@ -506,8 +506,8 @@ mod sends_pr_and_2_patches_to_3_relays {
     mod patch_tags {
         use super::*;
 
-        fn prep() -> Result<nostr::Event> {
-            let (_, _, r53, _, _) = futures::executor::block_on(prep_run_create_pr())?;
+        async fn prep() -> Result<nostr::Event> {
+            let (_, _, r53, _, _) = prep_run_create_pr().await?;
             Ok(r53
                 .events
                 .iter()
@@ -516,11 +516,11 @@ mod sends_pr_and_2_patches_to_3_relays {
                 .clone())
         }
 
-        #[test]
+        #[tokio::test]
         #[serial]
-        fn commit_and_commit_r() -> Result<()> {
+        async fn commit_and_commit_r() -> Result<()> {
             static COMMIT_ID: &str = "fe973a840fba2a8ab37dd505c154854a69a6505c";
-            let most_recent_patch = prep()?;
+            let most_recent_patch = prep().await?;
             assert!(
                 most_recent_patch
                     .tags
@@ -536,12 +536,12 @@ mod sends_pr_and_2_patches_to_3_relays {
             Ok(())
         }
 
-        #[test]
+        #[tokio::test]
         #[serial]
-        fn parent_commit() -> Result<()> {
+        async fn parent_commit() -> Result<()> {
             // commit parent 'r' and 'parent-commit' tag
             static COMMIT_PARENT_ID: &str = "232efb37ebc67692c9e9ff58b83c0d3d63971a0a";
-            let most_recent_patch = prep()?;
+            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)
@@ -550,19 +550,20 @@ mod sends_pr_and_2_patches_to_3_relays {
             Ok(())
         }
 
-        #[test]
+        #[tokio::test]
         #[serial]
-        fn root_commit_as_r() -> Result<()> {
-            assert!(prep()?.tags.iter().any(|t| t.as_vec()[0].eq("r")
+        async fn root_commit_as_r() -> Result<()> {
+            assert!(prep().await?.tags.iter().any(|t| t.as_vec()[0].eq("r")
                 && t.as_vec()[1].eq("9ee507fc4357d7ee16a5d8901bedcd103f23c17d")));
             Ok(())
         }
 
-        #[test]
+        #[tokio::test]
         #[serial]
-        fn description_with_commit_message() -> Result<()> {
+        async fn description_with_commit_message() -> Result<()> {
             assert_eq!(
-                prep()?
+                prep()
+                    .await?
                     .tags
                     .iter()
                     .find(|t| t.as_vec()[0].eq("description"))
@@ -573,11 +574,12 @@ mod sends_pr_and_2_patches_to_3_relays {
             Ok(())
         }
 
-        #[test]
+        #[tokio::test]
         #[serial]
-        fn commit_author() -> Result<()> {
+        async fn commit_author() -> Result<()> {
             assert_eq!(
-                prep()?
+                prep()
+                    .await?
                     .tags
                     .iter()
                     .find(|t| t.as_vec()[0].eq("author"))
@@ -588,11 +590,12 @@ mod sends_pr_and_2_patches_to_3_relays {
             Ok(())
         }
 
-        #[test]
+        #[tokio::test]
         #[serial]
-        fn commit_committer() -> Result<()> {
+        async fn commit_committer() -> Result<()> {
             assert_eq!(
-                prep()?
+                prep()
+                    .await?
                     .tags
                     .iter()
                     .find(|t| t.as_vec()[0].eq("committer"))
@@ -603,10 +606,10 @@ mod sends_pr_and_2_patches_to_3_relays {
             Ok(())
         }
 
-        #[test]
+        #[tokio::test]
         #[serial]
-        fn patch_tags_pr_event_as_root() -> Result<()> {
-            let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_create_pr())?;
+        async fn patch_tags_pr_event_as_root() -> Result<()> {
+            let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
             for relay in [&r53, &r55, &r56] {
                 let patch_events: Vec<&nostr::Event> = relay
                     .events
@@ -705,10 +708,10 @@ mod sends_pr_and_2_patches_to_3_relays {
             Ok(())
         }
 
-        #[test]
+        #[tokio::test]
         #[serial]
-        fn check_cli_output() -> Result<()> {
-            futures::executor::block_on(run_test_async())?;
+        async fn check_cli_output() -> Result<()> {
+            run_test_async().await?;
             Ok(())
         }
     }
@@ -787,10 +790,10 @@ mod sends_pr_and_2_patches_to_3_relays {
                 Ok(())
             }
 
-            #[test]
+            #[tokio::test]
             #[serial]
-            fn only_first_rejected_event_sent_to_relay() -> Result<()> {
-                futures::executor::block_on(run_test_async())?;
+            async fn only_first_rejected_event_sent_to_relay() -> Result<()> {
+                run_test_async().await?;
                 Ok(())
             }
         }
@@ -879,10 +882,10 @@ mod sends_pr_and_2_patches_to_3_relays {
                 Ok((r51, r52, r53))
             }
 
-            #[test]
+            #[tokio::test]
             #[serial]
-            fn cli_show_rejection_with_comment() -> Result<()> {
-                futures::executor::block_on(run_test_async())?;
+            async fn cli_show_rejection_with_comment() -> Result<()> {
+                run_test_async().await?;
                 Ok(())
             }
         }
diff --git a/tests/prs_list.rs b/tests/prs_list.rs
index 7f753c0..75704f6 100644
--- a/tests/prs_list.rs
+++ b/tests/prs_list.rs
@@ -226,17 +226,18 @@ mod when_main_branch_is_uptodate {
                         Ok(())
                     }
 
-                    #[test]
+                    #[tokio::test]
                     #[serial]
-                    fn prompts_to_choose_from_pr_titles() -> Result<()> {
-                        futures::executor::block_on(run_async_prompts_to_choose_from_pr_titles())
+                    async fn prompts_to_choose_from_pr_titles() -> Result<()> {
+                        let _ = run_async_prompts_to_choose_from_pr_titles().await;
+                        Ok(())
                     }
                 }
 
-                #[test]
+                #[tokio::test]
                 #[serial]
-                fn pr_branch_created_with_correct_name() -> Result<()> {
-                    let (_, test_repo) = futures::executor::block_on(prep_and_run())?;
+                async fn pr_branch_created_with_correct_name() -> Result<()> {
+                    let (_, test_repo) = prep_and_run().await?;
                     assert_eq!(
                         vec![FEATURE_BRANCH_NAME_1, "main"],
                         test_repo.get_local_branch_names()?
@@ -244,10 +245,10 @@ mod when_main_branch_is_uptodate {
                     Ok(())
                 }
 
-                #[test]
+                #[tokio::test]
                 #[serial]
-                fn pr_branch_checked_out() -> Result<()> {
-                    let (_, test_repo) = futures::executor::block_on(prep_and_run())?;
+                async fn pr_branch_checked_out() -> Result<()> {
+                    let (_, test_repo) = prep_and_run().await?;
                     assert_eq!(
                         FEATURE_BRANCH_NAME_1,
                         test_repo.get_checked_out_branch_name()?,
@@ -255,11 +256,10 @@ mod when_main_branch_is_uptodate {
                     Ok(())
                 }
 
-                #[test]
+                #[tokio::test]
                 #[serial]
-                fn pr_branch_tip_is_most_recent_patch() -> Result<()> {
-                    let (originating_repo, test_repo) =
-                        futures::executor::block_on(prep_and_run())?;
+                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_1)?,
                         test_repo.get_tip_of_local_branch(FEATURE_BRANCH_NAME_1)?,
@@ -391,17 +391,18 @@ mod when_main_branch_is_uptodate {
                         Ok(())
                     }
 
-                    #[test]
+                    #[tokio::test]
                     #[serial]
-                    fn prompts_to_choose_from_pr_titles() -> Result<()> {
-                        futures::executor::block_on(run_async_prompts_to_choose_from_pr_titles())
+                    async fn prompts_to_choose_from_pr_titles() -> Result<()> {
+                        let _ = run_async_prompts_to_choose_from_pr_titles().await;
+                        Ok(())
                     }
                 }
 
-                #[test]
+                #[tokio::test]
                 #[serial]
-                fn pr_branch_created_with_correct_name() -> Result<()> {
-                    let (_, test_repo) = futures::executor::block_on(prep_and_run())?;
+                async fn pr_branch_created_with_correct_name() -> Result<()> {
+                    let (_, test_repo) = prep_and_run().await?;
                     assert_eq!(
                         vec![FEATURE_BRANCH_NAME_3, "main"],
                         test_repo.get_local_branch_names()?
@@ -409,10 +410,10 @@ mod when_main_branch_is_uptodate {
                     Ok(())
                 }
 
-                #[test]
+                #[tokio::test]
                 #[serial]
-                fn pr_branch_checked_out() -> Result<()> {
-                    let (_, test_repo) = futures::executor::block_on(prep_and_run())?;
+                async fn pr_branch_checked_out() -> Result<()> {
+                    let (_, test_repo) = prep_and_run().await?;
                     assert_eq!(
                         FEATURE_BRANCH_NAME_3,
                         test_repo.get_checked_out_branch_name()?,
@@ -420,11 +421,10 @@ mod when_main_branch_is_uptodate {
                     Ok(())
                 }
 
-                #[test]
+                #[tokio::test]
                 #[serial]
-                fn pr_branch_tip_is_most_recent_patch() -> Result<()> {
-                    let (originating_repo, test_repo) =
-                        futures::executor::block_on(prep_and_run())?;
+                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_3)?,
                         test_repo.get_tip_of_local_branch(FEATURE_BRANCH_NAME_3)?,
@@ -579,17 +579,18 @@ mod when_main_branch_is_uptodate {
                         Ok(())
                     }
 
-                    #[test]
+                    #[tokio::test]
                     #[serial]
-                    fn prompts_to_choose_from_pr_titles() -> Result<()> {
-                        futures::executor::block_on(run_async_prompts_to_choose_from_pr_titles())
+                    async fn prompts_to_choose_from_pr_titles() -> Result<()> {
+                        let _ = run_async_prompts_to_choose_from_pr_titles().await;
+                        Ok(())
                     }
                 }
 
-                #[test]
+                #[tokio::test]
                 #[serial]
-                fn pr_branch_checked_out() -> Result<()> {
-                    let (_, test_repo) = futures::executor::block_on(prep_and_run())?;
+                async fn pr_branch_checked_out() -> Result<()> {
+                    let (_, test_repo) = prep_and_run().await?;
                     assert_eq!(
                         FEATURE_BRANCH_NAME_1,
                         test_repo.get_checked_out_branch_name()?,
@@ -738,17 +739,18 @@ mod when_main_branch_is_uptodate {
                         Ok(())
                     }
 
-                    #[test]
+                    #[tokio::test]
                     #[serial]
-                    fn prompts_to_choose_from_pr_titles() -> Result<()> {
-                        futures::executor::block_on(run_async_prompts_to_choose_from_pr_titles())
+                    async fn prompts_to_choose_from_pr_titles() -> Result<()> {
+                        let _ = run_async_prompts_to_choose_from_pr_titles().await;
+                        Ok(())
                     }
                 }
 
-                #[test]
+                #[tokio::test]
                 #[serial]
-                fn pr_branch_checked_out() -> Result<()> {
-                    let (_, test_repo) = futures::executor::block_on(prep_and_run())?;
+                async fn pr_branch_checked_out() -> Result<()> {
+                    let (_, test_repo) = prep_and_run().await?;
                     assert_eq!(
                         FEATURE_BRANCH_NAME_1,
                         test_repo.get_checked_out_branch_name()?,
@@ -756,11 +758,10 @@ mod when_main_branch_is_uptodate {
                     Ok(())
                 }
 
-                #[test]
+                #[tokio::test]
                 #[serial]
-                fn pr_branch_tip_is_most_recent_patch() -> Result<()> {
-                    let (originating_repo, test_repo) =
-                        futures::executor::block_on(prep_and_run())?;
+                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_1)?,
                         test_repo.get_tip_of_local_branch(FEATURE_BRANCH_NAME_1)?,
diff --git a/tests/pull.rs b/tests/pull.rs
index 9b88cb5..92d0ba9 100644
--- a/tests/pull.rs
+++ b/tests/pull.rs
@@ -144,10 +144,10 @@ mod when_main_is_checked_out {
             Ok(())
         }
 
-        #[test]
+        #[tokio::test]
         #[serial]
-        fn cli_show_error() -> Result<()> {
-            futures::executor::block_on(run_async_cli_show_error())
+        async fn cli_show_error() -> Result<()> {
+            run_async_cli_show_error().await
         }
     }
 }
@@ -209,10 +209,10 @@ mod when_branch_doesnt_exist {
             Ok(())
         }
 
-        #[test]
+        #[tokio::test]
         #[serial]
-        fn cli_show_error() -> Result<()> {
-            futures::executor::block_on(run_async_cli_show_error())
+        async fn cli_show_error() -> Result<()> {
+            run_async_cli_show_error().await
         }
     }
 }
@@ -274,10 +274,10 @@ mod when_branch_is_checked_out {
                 Ok(())
             }
 
-            #[test]
+            #[tokio::test]
             #[serial]
-            fn cli_show_up_to_date() -> Result<()> {
-                futures::executor::block_on(run_async_cli_show_up_to_date())
+            async fn cli_show_up_to_date() -> Result<()> {
+                run_async_cli_show_up_to_date().await
             }
         }
     }
@@ -389,17 +389,17 @@ mod when_branch_is_checked_out {
                 Ok(())
             }
 
-            #[test]
+            #[tokio::test]
             #[serial]
-            fn cli_applied_1_commit() -> Result<()> {
-                futures::executor::block_on(run_async_cli_applied_1_commit())
+            async fn cli_applied_1_commit() -> Result<()> {
+                run_async_cli_applied_1_commit().await
             }
         }
 
-        #[test]
+        #[tokio::test]
         #[serial]
-        fn pr_branch_tip_is_most_recent_patch() -> Result<()> {
-            let (originating_repo, test_repo) = futures::executor::block_on(prep_and_run())?;
+        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_1)?,
                 test_repo.get_tip_of_local_branch(FEATURE_BRANCH_NAME_1)?,
diff --git a/tests/push.rs b/tests/push.rs
index 4fdb6eb..4af5bd4 100644
--- a/tests/push.rs
+++ b/tests/push.rs
@@ -111,6 +111,7 @@ mod when_pr_isnt_associated_with_branch_name {
     use super::*;
 
     mod cli_prompts {
+
         use super::*;
         async fn run_async_cli_show_error() -> Result<()> {
             let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
@@ -164,10 +165,10 @@ mod when_pr_isnt_associated_with_branch_name {
             Ok(())
         }
 
-        #[test]
+        #[tokio::test]
         #[serial]
-        fn cli_show_error() -> Result<()> {
-            futures::executor::block_on(run_async_cli_show_error())
+        async fn cli_show_error() -> Result<()> {
+            run_async_cli_show_error().await
         }
     }
 }
@@ -229,10 +230,11 @@ mod when_branch_is_checked_out {
                 Ok(())
             }
 
-            #[test]
+            #[tokio::test]
             #[serial]
-            fn cli_show_up_to_date() -> Result<()> {
-                futures::executor::block_on(run_async_cli_show_up_to_date())
+            async fn cli_show_up_to_date() -> Result<()> {
+                let _ = run_async_cli_show_up_to_date().await;
+                Ok(())
             }
         }
     }
@@ -291,10 +293,11 @@ mod when_branch_is_checked_out {
                 Ok(())
             }
 
-            #[test]
+            #[tokio::test]
             #[serial]
-            fn cli_show_up_to_date() -> Result<()> {
-                futures::executor::block_on(run_async_cli_show_up_to_date())
+            async fn cli_show_up_to_date() -> Result<()> {
+                let _ = run_async_cli_show_up_to_date().await;
+                Ok(())
             }
         }
     }
@@ -389,10 +392,11 @@ mod when_branch_is_checked_out {
                 Ok(())
             }
 
-            #[test]
+            #[tokio::test]
             #[serial]
-            fn cli_applied_1_commit() -> Result<()> {
-                futures::executor::block_on(run_async_cli_applied_1_commit())
+            async fn cli_applied_1_commit() -> Result<()> {
+                let _ = run_async_cli_applied_1_commit().await;
+                Ok(())
             }
         }
 
@@ -453,10 +457,10 @@ mod when_branch_is_checked_out {
 
             Ok((res, r55.events.clone()))
         }
-        #[test]
+        #[tokio::test]
         #[serial]
-        fn commits_issued_as_patch_event() -> Result<()> {
-            let (test_repo, r55_events) = futures::executor::block_on(prep_and_run())?;
+        async fn commits_issued_as_patch_event() -> Result<()> {
+            let (test_repo, r55_events) = prep_and_run().await?;
 
             let commit_id = test_repo
                 .get_tip_of_local_branch(FEATURE_BRANCH_NAME_1)?