upleb.uk

Public git repos — served from a NIP-34 GRASP relay at git.upleb.uk

summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorjk <email@jkrause.io>2024-01-31 15:13:52 +0100
committerDanConwayDev <DanConwayDev@protonmail.com>2024-02-02 07:21:01 +0000
commitab1450c655f7fdfc214e1556d16fc754ca684613 (patch)
tree9ded305354a272d411059493e9475a3e39ff5cae
parentccdbc337ae16d7c70be44166269c8b2d5b9f5c09 (diff)
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
Diffstat
-rw-r--r--nostr_git_remote_helper/src/main.rs2
-rw-r--r--src/key_handling/users.rs259
-rw-r--r--tests/claim.rs81
-rw-r--r--tests/login.rs185
-rw-r--r--tests/prs_create.rs127
-rw-r--r--tests/prs_list.rs85
-rw-r--r--tests/pull.rs30
-rw-r--r--tests/push.rs34
8 files changed, 426 insertions, 377 deletions
diff --git a/nostr_git_remote_helper/src/main.rs b/nostr_git_remote_helper/src/main.rs
index 898f069..849396c 100644
--- a/nostr_git_remote_helper/src/main.rs
+++ b/nostr_git_remote_helper/src/main.rs
@@ -33,7 +33,7 @@ async fn main() -> Result<()> {
33 match &cli.command { 33 match &cli.command {
34 Commands::Capabilities() => sub_commands::capabilities::launch(), 34 Commands::Capabilities() => sub_commands::capabilities::launch(),
35 Commands::Placeholder(args) => { 35 Commands::Placeholder(args) => {
36 futures::executor::block_on(sub_commands::placeholder::launch(&cli, args)) 36 sub_commands::placeholder::launch(&cli, args).await
37 } 37 }
38 } 38 }
39} 39}
diff --git a/src/key_handling/users.rs b/src/key_handling/users.rs
index 2c6a897..2e88fba 100644
--- a/src/key_handling/users.rs
+++ b/src/key_handling/users.rs
@@ -679,18 +679,21 @@ mod tests {
679 mod when_within_caching_time_window { 679 mod when_within_caching_time_window {
680 use super::*; 680 use super::*;
681 681
682 #[test] 682 #[tokio::test]
683 fn returns_cached_details_without_checking_relays_or_updaing_config() -> Result<()> { 683 async fn returns_cached_details_without_checking_relays_or_updaing_config() -> Result<()>
684 {
684 let mut m = MockUserManager::default(); 685 let mut m = MockUserManager::default();
685 let client = generate_mock_client(); 686 let client = generate_mock_client();
686 m.config_manager 687 m.config_manager
687 .expect_load() 688 .expect_load()
688 .returning(|| Ok(generate_standard_config())); 689 .returning(|| Ok(generate_standard_config()));
689 let res = futures::executor::block_on(m.get_user( 690 let res = m
690 &client, 691 .get_user(
691 &TEST_KEY_1_KEYS.public_key(), 692 &client,
692 24 * 60 * 60, // within 24 hours 693 &TEST_KEY_1_KEYS.public_key(),
693 ))?; 694 24 * 60 * 60, // within 24 hours
695 )
696 .await?;
694 assert_eq!(res.metadata.name, "Fred"); 697 assert_eq!(res.metadata.name, "Fred");
695 assert_eq!(res.relays.relays[0].url, "ws://existingread"); 698 assert_eq!(res.relays.relays[0].url, "ws://existingread");
696 Ok(()) 699 Ok(())
@@ -700,8 +703,8 @@ mod tests {
700 mod returns_userref_with_latest_details_from_events_on_relays { 703 mod returns_userref_with_latest_details_from_events_on_relays {
701 use super::*; 704 use super::*;
702 705
703 #[test] 706 #[tokio::test]
704 fn name() -> Result<()> { 707 async fn name() -> Result<()> {
705 let mut m = MockUserManager::default(); 708 let mut m = MockUserManager::default();
706 let mut client = generate_mock_client(); 709 let mut client = generate_mock_client();
707 m.config_manager 710 m.config_manager
@@ -712,17 +715,19 @@ mod tests {
712 .expect_get_events() 715 .expect_get_events()
713 .returning(|_, _| Ok(vec![generate_test_key_1_metadata_event("fred")])); 716 .returning(|_, _| Ok(vec![generate_test_key_1_metadata_event("fred")]));
714 717
715 let res = futures::executor::block_on(m.get_user( 718 let res = m
716 &client, 719 .get_user(
717 &TEST_KEY_1_KEYS.public_key(), 720 &client,
718 5 * 60, // 5 mins ago 721 &TEST_KEY_1_KEYS.public_key(),
719 ))?; 722 5 * 60, // 5 mins ago
723 )
724 .await?;
720 assert_eq!(res.metadata.name, "fred"); 725 assert_eq!(res.metadata.name, "fred");
721 Ok(()) 726 Ok(())
722 } 727 }
723 728
724 #[test] 729 #[tokio::test]
725 fn name_ignoring_other_users_events() -> Result<()> { 730 async fn name_ignoring_other_users_events() -> Result<()> {
726 let mut m = MockUserManager::default(); 731 let mut m = MockUserManager::default();
727 let mut client = generate_mock_client(); 732 let mut client = generate_mock_client();
728 m.config_manager 733 m.config_manager
@@ -736,17 +741,19 @@ mod tests {
736 ]) 741 ])
737 }); 742 });
738 743
739 let res = futures::executor::block_on(m.get_user( 744 let res = m
740 &client, 745 .get_user(
741 &TEST_KEY_1_KEYS.public_key(), 746 &client,
742 5 * 60, // 5 mins ago 747 &TEST_KEY_1_KEYS.public_key(),
743 ))?; 748 5 * 60, // 5 mins ago
749 )
750 .await?;
744 assert_eq!(res.metadata.name, "fred"); 751 assert_eq!(res.metadata.name, "fred");
745 Ok(()) 752 Ok(())
746 } 753 }
747 754
748 #[test] 755 #[tokio::test]
749 fn relays() -> Result<()> { 756 async fn relays() -> Result<()> {
750 let mut m = MockUserManager::default(); 757 let mut m = MockUserManager::default();
751 let mut client = generate_mock_client(); 758 let mut client = generate_mock_client();
752 m.config_manager 759 m.config_manager
@@ -760,17 +767,19 @@ mod tests {
760 ]) 767 ])
761 }); 768 });
762 769
763 let res = futures::executor::block_on(m.get_user( 770 let res = m
764 &client, 771 .get_user(
765 &TEST_KEY_1_KEYS.public_key(), 772 &client,
766 5 * 60, // 5 mins ago 773 &TEST_KEY_1_KEYS.public_key(),
767 ))?; 774 5 * 60, // 5 mins ago
775 )
776 .await?;
768 assert_eq!(res.relays.relays, expected_userrelayrefs(),); 777 assert_eq!(res.relays.relays, expected_userrelayrefs(),);
769 Ok(()) 778 Ok(())
770 } 779 }
771 780
772 #[test] 781 #[tokio::test]
773 fn relays_ignoring_other_users_events() -> Result<()> { 782 async fn relays_ignoring_other_users_events() -> Result<()> {
774 let mut m = MockUserManager::default(); 783 let mut m = MockUserManager::default();
775 let mut client = generate_mock_client(); 784 let mut client = generate_mock_client();
776 m.config_manager 785 m.config_manager
@@ -788,11 +797,13 @@ mod tests {
788 ]) 797 ])
789 }); 798 });
790 799
791 let res = futures::executor::block_on(m.get_user( 800 let res = m
792 &client, 801 .get_user(
793 &TEST_KEY_1_KEYS.public_key(), 802 &client,
794 5 * 60, // 5 mins ago 803 &TEST_KEY_1_KEYS.public_key(),
795 ))?; 804 5 * 60, // 5 mins ago
805 )
806 .await?;
796 assert_eq!(res.relays.relays, expected_userrelayrefs(),); 807 assert_eq!(res.relays.relays, expected_userrelayrefs(),);
797 Ok(()) 808 Ok(())
798 } 809 }
@@ -801,8 +812,8 @@ mod tests {
801 mod saves_updates_to_config { 812 mod saves_updates_to_config {
802 use super::*; 813 use super::*;
803 814
804 #[test] 815 #[tokio::test]
805 fn saves_name_to_config() -> Result<()> { 816 async fn saves_name_to_config() -> Result<()> {
806 let mut m = MockUserManager::default(); 817 let mut m = MockUserManager::default();
807 let mut client = generate_mock_client(); 818 let mut client = generate_mock_client();
808 m.config_manager 819 m.config_manager
@@ -817,16 +828,18 @@ mod tests {
817 .expect_get_events() 828 .expect_get_events()
818 .returning(|_, _| Ok(vec![generate_test_key_1_metadata_event("fred")])); 829 .returning(|_, _| Ok(vec![generate_test_key_1_metadata_event("fred")]));
819 830
820 futures::executor::block_on(m.get_user( 831 let _ = m
821 &client, 832 .get_user(
822 &TEST_KEY_1_KEYS.public_key(), 833 &client,
823 5 * 60, // 5 mins ago 834 &TEST_KEY_1_KEYS.public_key(),
824 ))?; 835 5 * 60, // 5 mins ago
836 )
837 .await?;
825 Ok(()) 838 Ok(())
826 } 839 }
827 840
828 #[test] 841 #[tokio::test]
829 fn updates_metadata_created_at() -> Result<()> { 842 async fn updates_metadata_created_at() -> Result<()> {
830 let mut m = MockUserManager::default(); 843 let mut m = MockUserManager::default();
831 let mut client = generate_mock_client(); 844 let mut client = generate_mock_client();
832 m.config_manager 845 m.config_manager
@@ -841,16 +854,18 @@ mod tests {
841 .expect_get_events() 854 .expect_get_events()
842 .returning(|_, _| Ok(vec![generate_test_key_1_metadata_event("fred")])); 855 .returning(|_, _| Ok(vec![generate_test_key_1_metadata_event("fred")]));
843 856
844 futures::executor::block_on(m.get_user( 857 let _ = m
845 &client, 858 .get_user(
846 &TEST_KEY_1_KEYS.public_key(), 859 &client,
847 5 * 60, // 5 mins ago 860 &TEST_KEY_1_KEYS.public_key(),
848 ))?; 861 5 * 60, // 5 mins ago
862 )
863 .await?;
849 Ok(()) 864 Ok(())
850 } 865 }
851 866
852 #[test] 867 #[tokio::test]
853 fn saves_relays_to_config() -> Result<()> { 868 async fn saves_relays_to_config() -> Result<()> {
854 let mut m = MockUserManager::default(); 869 let mut m = MockUserManager::default();
855 let mut client = generate_mock_client(); 870 let mut client = generate_mock_client();
856 m.config_manager 871 m.config_manager
@@ -865,16 +880,18 @@ mod tests {
865 .expect_get_events() 880 .expect_get_events()
866 .returning(|_, _| Ok(vec![generate_relaylist_event()])); 881 .returning(|_, _| Ok(vec![generate_relaylist_event()]));
867 882
868 futures::executor::block_on(m.get_user( 883 let _ = m
869 &client, 884 .get_user(
870 &TEST_KEY_1_KEYS.public_key(), 885 &client,
871 5 * 60, // 5 mins ago 886 &TEST_KEY_1_KEYS.public_key(),
872 ))?; 887 5 * 60, // 5 mins ago
888 )
889 .await?;
873 Ok(()) 890 Ok(())
874 } 891 }
875 892
876 #[test] 893 #[tokio::test]
877 fn updates_relays_created_at() -> Result<()> { 894 async fn updates_relays_created_at() -> Result<()> {
878 let mut m = MockUserManager::default(); 895 let mut m = MockUserManager::default();
879 let mut client = generate_mock_client(); 896 let mut client = generate_mock_client();
880 m.config_manager 897 m.config_manager
@@ -889,16 +906,18 @@ mod tests {
889 .expect_get_events() 906 .expect_get_events()
890 .returning(|_, _| Ok(vec![generate_relaylist_event()])); 907 .returning(|_, _| Ok(vec![generate_relaylist_event()]));
891 908
892 futures::executor::block_on(m.get_user( 909 let _ = m
893 &client, 910 .get_user(
894 &TEST_KEY_1_KEYS.public_key(), 911 &client,
895 5 * 60, // 5 mins ago 912 &TEST_KEY_1_KEYS.public_key(),
896 ))?; 913 5 * 60, // 5 mins ago
914 )
915 .await?;
897 Ok(()) 916 Ok(())
898 } 917 }
899 918
900 #[test] 919 #[tokio::test]
901 fn when_no_changes_updates_last_updated() -> Result<()> { 920 async fn when_no_changes_updates_last_updated() -> Result<()> {
902 let mut m = MockUserManager::default(); 921 let mut m = MockUserManager::default();
903 let mut client = generate_mock_client(); 922 let mut client = generate_mock_client();
904 m.config_manager 923 m.config_manager
@@ -911,16 +930,18 @@ mod tests {
911 .returning(|_| Ok(())); 930 .returning(|_| Ok(()));
912 client.expect_get_events().returning(|_, _| Ok(vec![])); 931 client.expect_get_events().returning(|_, _| Ok(vec![]));
913 932
914 futures::executor::block_on(m.get_user( 933 let _ = m
915 &client, 934 .get_user(
916 &TEST_KEY_1_KEYS.public_key(), 935 &client,
917 5 * 60, // 5 mins ago 936 &TEST_KEY_1_KEYS.public_key(),
918 ))?; 937 5 * 60, // 5 mins ago
938 )
939 .await?;
919 Ok(()) 940 Ok(())
920 } 941 }
921 942
922 #[test] 943 #[tokio::test]
923 fn when_changes_updates_last_updated() -> Result<()> { 944 async fn when_changes_updates_last_updated() -> Result<()> {
924 let mut m = MockUserManager::default(); 945 let mut m = MockUserManager::default();
925 let mut client = generate_mock_client(); 946 let mut client = generate_mock_client();
926 m.config_manager 947 m.config_manager
@@ -935,19 +956,21 @@ mod tests {
935 .expect_get_events() 956 .expect_get_events()
936 .returning(|_, _| Ok(vec![generate_test_key_1_metadata_event("fred")])); 957 .returning(|_, _| Ok(vec![generate_test_key_1_metadata_event("fred")]));
937 958
938 futures::executor::block_on(m.get_user( 959 let _ = m
939 &client, 960 .get_user(
940 &TEST_KEY_1_KEYS.public_key(), 961 &client,
941 5 * 60, // 5 mins ago 962 &TEST_KEY_1_KEYS.public_key(),
942 ))?; 963 5 * 60, // 5 mins ago
964 )
965 .await?;
943 Ok(()) 966 Ok(())
944 } 967 }
945 } 968 }
946 969
947 mod fetches_from_correct_relays { 970 mod fetches_from_correct_relays {
948 use super::*; 971 use super::*;
949 #[test] 972 #[tokio::test]
950 fn when_userref_write_relays_present_fetches_only_from_them() -> Result<()> { 973 async fn when_userref_write_relays_present_fetches_only_from_them() -> Result<()> {
951 let mut m = MockUserManager::default(); 974 let mut m = MockUserManager::default();
952 let mut client = generate_mock_client(); 975 let mut client = generate_mock_client();
953 m.config_manager 976 m.config_manager
@@ -966,15 +989,19 @@ mod tests {
966 }) 989 })
967 .returning(|_, _| Ok(vec![])); 990 .returning(|_, _| Ok(vec![]));
968 991
969 futures::executor::block_on(m.get_user( 992 let _ = m
970 &client, 993 .get_user(
971 &TEST_KEY_1_KEYS.public_key(), 994 &client,
972 5 * 60, // 5 mins ago 995 &TEST_KEY_1_KEYS.public_key(),
973 ))?; 996 5 * 60, // 5 mins ago
997 )
998 .await?;
974 Ok(()) 999 Ok(())
975 } 1000 }
976 #[test] 1001
977 fn when_userref_write_relays_not_present_fetches_from_fallback_relays() -> Result<()> { 1002 #[tokio::test]
1003 async fn when_userref_write_relays_not_present_fetches_from_fallback_relays()
1004 -> Result<()> {
978 let mut m = MockUserManager::default(); 1005 let mut m = MockUserManager::default();
979 let mut client = generate_mock_client(); 1006 let mut client = generate_mock_client();
980 m.config_manager.expect_load().returning(|| { 1007 m.config_manager.expect_load().returning(|| {
@@ -996,19 +1023,21 @@ mod tests {
996 .withf(move |relays, _filters| fallback_relays().eq(relays)) 1023 .withf(move |relays, _filters| fallback_relays().eq(relays))
997 .returning(|_, _| Ok(vec![])); 1024 .returning(|_, _| Ok(vec![]));
998 1025
999 futures::executor::block_on(m.get_user( 1026 let _ = m
1000 &client, 1027 .get_user(
1001 &TEST_KEY_1_KEYS.public_key(), 1028 &client,
1002 5 * 60, // 5 mins ago 1029 &TEST_KEY_1_KEYS.public_key(),
1003 ))?; 1030 5 * 60, // 5 mins ago
1031 )
1032 .await?;
1004 Ok(()) 1033 Ok(())
1005 } 1034 }
1006 1035
1007 mod fetches_from_new_relays_discovered_in_incoming_relay_list { 1036 mod fetches_from_new_relays_discovered_in_incoming_relay_list {
1008 use super::*; 1037 use super::*;
1009 1038
1010 #[test] 1039 #[tokio::test]
1011 fn when_all_relays_in_list_are_new_finds_name() -> Result<()> { 1040 async fn when_all_relays_in_list_are_new_finds_name() -> Result<()> {
1012 let mut m = MockUserManager::default(); 1041 let mut m = MockUserManager::default();
1013 let mut client = generate_mock_client(); 1042 let mut client = generate_mock_client();
1014 m.config_manager.expect_load().returning(|| { 1043 m.config_manager.expect_load().returning(|| {
@@ -1052,17 +1081,19 @@ mod tests {
1052 } 1081 }
1053 }); 1082 });
1054 1083
1055 let res = futures::executor::block_on(m.get_user( 1084 let res = m
1056 &client, 1085 .get_user(
1057 &TEST_KEY_1_KEYS.public_key(), 1086 &client,
1058 5 * 60, // 5 mins ago 1087 &TEST_KEY_1_KEYS.public_key(),
1059 ))?; 1088 5 * 60, // 5 mins ago
1089 )
1090 .await?;
1060 assert_eq!(res.metadata.name, "fred"); 1091 assert_eq!(res.metadata.name, "fred");
1061 Ok(()) 1092 Ok(())
1062 } 1093 }
1063 1094
1064 #[test] 1095 #[tokio::test]
1065 fn only_fetches_from_newly_added_relays() -> Result<()> { 1096 async fn only_fetches_from_newly_added_relays() -> Result<()> {
1066 let mut m = MockUserManager::default(); 1097 let mut m = MockUserManager::default();
1067 let mut client = generate_mock_client(); 1098 let mut client = generate_mock_client();
1068 m.config_manager.expect_load().returning(|| { 1099 m.config_manager.expect_load().returning(|| {
@@ -1095,19 +1126,21 @@ mod tests {
1095 } 1126 }
1096 }); 1127 });
1097 1128
1098 let res = futures::executor::block_on(m.get_user( 1129 let res = m
1099 &client, 1130 .get_user(
1100 &TEST_KEY_1_KEYS.public_key(), 1131 &client,
1101 5 * 60, // 5 mins ago 1132 &TEST_KEY_1_KEYS.public_key(),
1102 ))?; 1133 5 * 60, // 5 mins ago
1134 )
1135 .await?;
1103 assert_eq!(res.metadata.name, "fred"); 1136 assert_eq!(res.metadata.name, "fred");
1104 Ok(()) 1137 Ok(())
1105 } 1138 }
1106 } 1139 }
1107 } 1140 }
1108 1141
1109 #[test] 1142 #[tokio::test]
1110 fn when_failed_to_fetch_events_returns_cached_details() -> Result<()> { 1143 async fn when_failed_to_fetch_events_returns_cached_details() -> Result<()> {
1111 let mut m = MockUserManager::default(); 1144 let mut m = MockUserManager::default();
1112 let mut client = generate_mock_client(); 1145 let mut client = generate_mock_client();
1113 m.config_manager 1146 m.config_manager
@@ -1117,11 +1150,13 @@ mod tests {
1117 .expect_get_events() 1150 .expect_get_events()
1118 .returning(|_, _| Err(anyhow!("test error"))); 1151 .returning(|_, _| Err(anyhow!("test error")));
1119 1152
1120 let res = futures::executor::block_on(m.get_user( 1153 let res = m
1121 &client, 1154 .get_user(
1122 &TEST_KEY_1_KEYS.public_key(), 1155 &client,
1123 5 * 60, // 10 mins ago 1156 &TEST_KEY_1_KEYS.public_key(),
1124 ))?; 1157 5 * 60, // 10 mins ago
1158 )
1159 .await?;
1125 assert_eq!(res.metadata.name, "Fred"); 1160 assert_eq!(res.metadata.name, "Fred");
1126 Ok(()) 1161 Ok(())
1127 } 1162 }
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 {
117 mod sent_to_correct_relays { 117 mod sent_to_correct_relays {
118 use super::*; 118 use super::*;
119 119
120 #[test] 120 #[tokio::test]
121 #[serial] 121 #[serial]
122 fn only_1_repository_kind_event_sent_to_user_relays() -> Result<()> { 122 async fn only_1_repository_kind_event_sent_to_user_relays() -> Result<()> {
123 let (_, _, r53, r55, _) = futures::executor::block_on(prep_run_claim())?; 123 let (_, _, r53, r55, _) = prep_run_claim().await?;
124 for relay in [&r53, &r55] { 124 for relay in [&r53, &r55] {
125 assert_eq!( 125 assert_eq!(
126 relay 126 relay
@@ -134,10 +134,10 @@ mod when_repo_not_previously_claimed {
134 Ok(()) 134 Ok(())
135 } 135 }
136 136
137 #[test] 137 #[tokio::test]
138 #[serial] 138 #[serial]
139 fn only_1_repository_kind_event_sent_to_specified_repo_relays() -> Result<()> { 139 async fn only_1_repository_kind_event_sent_to_specified_repo_relays() -> Result<()> {
140 let (_, _, _, r55, r56) = futures::executor::block_on(prep_run_claim())?; 140 let (_, _, _, r55, r56) = prep_run_claim().await?;
141 for relay in [&r55, &r56] { 141 for relay in [&r55, &r56] {
142 assert_eq!( 142 assert_eq!(
143 relay 143 relay
@@ -151,10 +151,10 @@ mod when_repo_not_previously_claimed {
151 Ok(()) 151 Ok(())
152 } 152 }
153 153
154 #[test] 154 #[tokio::test]
155 #[serial] 155 #[serial]
156 fn event_not_sent_to_fallback_relay() -> Result<()> { 156 async fn event_not_sent_to_fallback_relay() -> Result<()> {
157 let (r51, r52, _, _, _) = futures::executor::block_on(prep_run_claim())?; 157 let (r51, r52, _, _, _) = prep_run_claim().await?;
158 for relay in [&r51, &r52] { 158 for relay in [&r51, &r52] {
159 assert_eq!( 159 assert_eq!(
160 relay 160 relay
@@ -241,10 +241,10 @@ mod when_repo_not_previously_claimed {
241 Ok(()) 241 Ok(())
242 } 242 }
243 243
244 #[test] 244 #[tokio::test]
245 #[serial] 245 #[serial]
246 fn contains_maintainers_and_relays() -> Result<()> { 246 async fn contains_maintainers_and_relays() -> Result<()> {
247 futures::executor::block_on(async_run_test())?; 247 async_run_test().await?;
248 Ok(()) 248 Ok(())
249 } 249 }
250 } 250 }
@@ -252,9 +252,10 @@ mod when_repo_not_previously_claimed {
252 mod tags { 252 mod tags {
253 use super::*; 253 use super::*;
254 254
255 #[test] 255 #[tokio::test]
256 #[serial] 256 #[serial]
257 fn d_replaceable_event_identifier_defaults_to_root_commit_id_shorthand() -> Result<()> { 257 async fn d_replaceable_event_identifier_defaults_to_root_commit_id_shorthand()
258 -> Result<()> {
258 let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_claim())?; 259 let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_claim())?;
259 for relay in [&r53, &r55, &r56] { 260 for relay in [&r53, &r55, &r56] {
260 let event: &nostr::Event = relay 261 let event: &nostr::Event = relay
@@ -273,10 +274,10 @@ mod when_repo_not_previously_claimed {
273 Ok(()) 274 Ok(())
274 } 275 }
275 276
276 #[test] 277 #[tokio::test]
277 #[serial] 278 #[serial]
278 fn root_commit_as_reference() -> Result<()> { 279 async fn root_commit_as_reference() -> Result<()> {
279 let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_claim())?; 280 let (_, _, r53, r55, r56) = prep_run_claim().await?;
280 for relay in [&r53, &r55, &r56] { 281 for relay in [&r53, &r55, &r56] {
281 let event: &nostr::Event = relay 282 let event: &nostr::Event = relay
282 .events 283 .events
@@ -290,10 +291,10 @@ mod when_repo_not_previously_claimed {
290 Ok(()) 291 Ok(())
291 } 292 }
292 293
293 #[test] 294 #[tokio::test]
294 #[serial] 295 #[serial]
295 fn name() -> Result<()> { 296 async fn name() -> Result<()> {
296 let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_claim())?; 297 let (_, _, r53, r55, r56) = prep_run_claim().await?;
297 for relay in [&r53, &r55, &r56] { 298 for relay in [&r53, &r55, &r56] {
298 let event: &nostr::Event = relay 299 let event: &nostr::Event = relay
299 .events 300 .events
@@ -311,10 +312,10 @@ mod when_repo_not_previously_claimed {
311 Ok(()) 312 Ok(())
312 } 313 }
313 314
314 #[test] 315 #[tokio::test]
315 #[serial] 316 #[serial]
316 fn description() -> Result<()> { 317 async fn description() -> Result<()> {
317 let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_claim())?; 318 let (_, _, r53, r55, r56) = prep_run_claim().await?;
318 for relay in [&r53, &r55, &r56] { 319 for relay in [&r53, &r55, &r56] {
319 let event: &nostr::Event = relay 320 let event: &nostr::Event = relay
320 .events 321 .events
@@ -328,10 +329,10 @@ mod when_repo_not_previously_claimed {
328 Ok(()) 329 Ok(())
329 } 330 }
330 331
331 #[test] 332 #[tokio::test]
332 #[serial] 333 #[serial]
333 fn git_server() -> Result<()> { 334 async fn git_server() -> Result<()> {
334 let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_claim())?; 335 let (_, _, r53, r55, r56) = prep_run_claim().await?;
335 for relay in [&r53, &r55, &r56] { 336 for relay in [&r53, &r55, &r56] {
336 let event: &nostr::Event = relay 337 let event: &nostr::Event = relay
337 .events 338 .events
@@ -347,10 +348,10 @@ mod when_repo_not_previously_claimed {
347 Ok(()) 348 Ok(())
348 } 349 }
349 350
350 #[test] 351 #[tokio::test]
351 #[serial] 352 #[serial]
352 fn relays() -> Result<()> { 353 async fn relays() -> Result<()> {
353 let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_claim())?; 354 let (_, _, r53, r55, r56) = prep_run_claim().await?;
354 for relay in [&r53, &r55, &r56] { 355 for relay in [&r53, &r55, &r56] {
355 let event: &nostr::Event = relay 356 let event: &nostr::Event = relay
356 .events 357 .events
@@ -369,9 +370,9 @@ mod when_repo_not_previously_claimed {
369 Ok(()) 370 Ok(())
370 } 371 }
371 372
372 #[test] 373 #[tokio::test]
373 #[serial] 374 #[serial]
374 fn web() -> Result<()> { 375 async fn web() -> Result<()> {
375 let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_claim())?; 376 let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_claim())?;
376 for relay in [&r53, &r55, &r56] { 377 for relay in [&r53, &r55, &r56] {
377 let event: &nostr::Event = relay 378 let event: &nostr::Event = relay
@@ -473,10 +474,10 @@ mod when_repo_not_previously_claimed {
473 Ok(()) 474 Ok(())
474 } 475 }
475 476
476 #[test] 477 #[tokio::test]
477 #[serial] 478 #[serial]
478 fn check_cli_output() -> Result<()> { 479 async fn check_cli_output() -> Result<()> {
479 futures::executor::block_on(run_test_async())?; 480 run_test_async().await?;
480 Ok(()) 481 Ok(())
481 } 482 }
482 } 483 }
@@ -572,10 +573,10 @@ mod when_repo_not_previously_claimed {
572 mod tags { 573 mod tags {
573 use super::*; 574 use super::*;
574 575
575 #[test] 576 #[tokio::test]
576 #[serial] 577 #[serial]
577 fn relays_match_user_write_relays() -> Result<()> { 578 async fn relays_match_user_write_relays() -> Result<()> {
578 let (_, _, r53, r55, _) = futures::executor::block_on(prep_run_claim())?; 579 let (_, _, r53, r55, _) = prep_run_claim().await?;
579 for relay in [&r53, &r55] { 580 for relay in [&r53, &r55] {
580 let event: &nostr::Event = relay 581 let event: &nostr::Event = relay
581 .events 582 .events
@@ -650,10 +651,10 @@ mod when_repo_not_previously_claimed {
650 Ok(()) 651 Ok(())
651 } 652 }
652 653
653 #[test] 654 #[tokio::test]
654 #[serial] 655 #[serial]
655 fn check_cli_output() -> Result<()> { 656 async fn check_cli_output() -> Result<()> {
656 futures::executor::block_on(run_test_async())?; 657 run_test_async().await?;
657 Ok(()) 658 Ok(())
658 } 659 }
659 } 660 }
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 {
121 Ok(()) 121 Ok(())
122 } 122 }
123 123
124 #[test] 124 #[tokio::test]
125 #[serial] 125 #[serial]
126 fn when_latest_metadata_and_relay_list_on_all_relays() -> Result<()> { 126 async fn when_latest_metadata_and_relay_list_on_all_relays() -> Result<()> {
127 futures::executor::block_on(run_test_displays_correct_name( 127 run_test_displays_correct_name(
128 Some(&|relay, client_id, subscription_id, _| -> Result<()> { 128 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
129 relay.respond_events( 129 relay.respond_events(
130 client_id, 130 client_id,
@@ -147,16 +147,17 @@ mod with_relays {
147 )?; 147 )?;
148 Ok(()) 148 Ok(())
149 }), 149 }),
150 )) 150 )
151 .await
151 } 152 }
152 153
153 mod poorly_quality_metadata_event { 154 mod poorly_quality_metadata_event {
154 use super::*; 155 use super::*;
155 156
156 #[test] 157 #[tokio::test]
157 #[serial] 158 #[serial]
158 fn when_metadata_contains_only_display_name() -> Result<()> { 159 async fn when_metadata_contains_only_display_name() -> Result<()> {
159 futures::executor::block_on(run_test_displays_correct_name( 160 run_test_displays_correct_name(
160 Some(&|relay, client_id, subscription_id, _| -> Result<()> { 161 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
161 relay.respond_events( 162 relay.respond_events(
162 client_id, 163 client_id,
@@ -173,12 +174,13 @@ mod with_relays {
173 Ok(()) 174 Ok(())
174 }), 175 }),
175 None, 176 None,
176 )) 177 )
178 .await
177 } 179 }
178 180
179 #[test] 181 #[tokio::test]
180 #[serial] 182 #[serial]
181 fn when_metadata_contains_only_displayname() -> Result<()> { 183 async fn when_metadata_contains_only_displayname() -> Result<()> {
182 println!( 184 println!(
183 "displayName: {}", 185 "displayName: {}",
184 nostr::Metadata::new() 186 nostr::Metadata::new()
@@ -192,7 +194,7 @@ mod with_relays {
192 nostr::Metadata::new().name("fred").name.unwrap() 194 nostr::Metadata::new().name("fred").name.unwrap()
193 ); 195 );
194 196
195 futures::executor::block_on(run_test_displays_correct_name( 197 run_test_displays_correct_name(
196 Some(&|relay, client_id, subscription_id, _| -> Result<()> { 198 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
197 relay.respond_events( 199 relay.respond_events(
198 client_id, 200 client_id,
@@ -210,12 +212,13 @@ mod with_relays {
210 Ok(()) 212 Ok(())
211 }), 213 }),
212 None, 214 None,
213 )) 215 )
216 .await
214 } 217 }
215 218
216 #[test] 219 #[tokio::test]
217 #[serial] 220 #[serial]
218 fn displays_npub_when_metadata_contains_no_name_displayname_or_display_name() 221 async fn displays_npub_when_metadata_contains_no_name_displayname_or_display_name()
219 -> Result<()> { 222 -> Result<()> {
220 println!( 223 println!(
221 "displayName: {}", 224 "displayName: {}",
@@ -230,7 +233,7 @@ mod with_relays {
230 nostr::Metadata::new().name("fred").name.unwrap() 233 nostr::Metadata::new().name("fred").name.unwrap()
231 ); 234 );
232 235
233 futures::executor::block_on(run_test_displays_fallback_to_npub( 236 run_test_displays_fallback_to_npub(
234 Some(&|relay, client_id, subscription_id, _| -> Result<()> { 237 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
235 relay.respond_events( 238 relay.respond_events(
236 client_id, 239 client_id,
@@ -247,15 +250,16 @@ mod with_relays {
247 Ok(()) 250 Ok(())
248 }), 251 }),
249 None, 252 None,
250 )) 253 )
254 .await
251 } 255 }
252 } 256 }
253 257
254 #[test] 258 #[tokio::test]
255 #[serial] 259 #[serial]
256 fn when_latest_metadata_and_relay_list_on_some_relays_but_others_have_none() 260 async fn when_latest_metadata_and_relay_list_on_some_relays_but_others_have_none()
257 -> Result<()> { 261 -> Result<()> {
258 futures::executor::block_on(run_test_displays_correct_name( 262 run_test_displays_correct_name(
259 Some(&|relay, client_id, subscription_id, _| -> Result<()> { 263 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
260 relay.respond_events( 264 relay.respond_events(
261 client_id, 265 client_id,
@@ -268,13 +272,15 @@ mod with_relays {
268 Ok(()) 272 Ok(())
269 }), 273 }),
270 None, 274 None,
271 )) 275 )
276 .await
272 } 277 }
273 278
274 #[test] 279 #[tokio::test]
275 #[serial] 280 #[serial]
276 fn when_latest_metadata_only_on_relay_and_relay_list_on_another() -> Result<()> { 281 async fn when_latest_metadata_only_on_relay_and_relay_list_on_another() -> Result<()>
277 futures::executor::block_on(run_test_displays_correct_name( 282 {
283 run_test_displays_correct_name(
278 Some(&|relay, client_id, subscription_id, _| -> Result<()> { 284 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
279 relay.respond_events( 285 relay.respond_events(
280 client_id, 286 client_id,
@@ -291,13 +297,14 @@ mod with_relays {
291 )?; 297 )?;
292 Ok(()) 298 Ok(())
293 }), 299 }),
294 )) 300 )
301 .await
295 } 302 }
296 303
297 #[test] 304 #[tokio::test]
298 #[serial] 305 #[serial]
299 fn when_some_relays_return_old_metadata_event() -> Result<()> { 306 async fn when_some_relays_return_old_metadata_event() -> Result<()> {
300 futures::executor::block_on(run_test_displays_correct_name( 307 run_test_displays_correct_name(
301 Some(&|relay, client_id, subscription_id, _| -> Result<()> { 308 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
302 relay.respond_events( 309 relay.respond_events(
303 client_id, 310 client_id,
@@ -317,13 +324,14 @@ mod with_relays {
317 )?; 324 )?;
318 Ok(()) 325 Ok(())
319 }), 326 }),
320 )) 327 )
328 .await
321 } 329 }
322 330
323 #[test] 331 #[tokio::test]
324 #[serial] 332 #[serial]
325 fn when_some_relays_return_other_users_metadata() -> Result<()> { 333 async fn when_some_relays_return_other_users_metadata() -> Result<()> {
326 futures::executor::block_on(run_test_displays_correct_name( 334 run_test_displays_correct_name(
327 Some(&|relay, client_id, subscription_id, _| -> Result<()> { 335 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
328 relay.respond_events( 336 relay.respond_events(
329 client_id, 337 client_id,
@@ -343,13 +351,14 @@ mod with_relays {
343 )?; 351 )?;
344 Ok(()) 352 Ok(())
345 }), 353 }),
346 )) 354 )
355 .await
347 } 356 }
348 357
349 #[test] 358 #[tokio::test]
350 #[serial] 359 #[serial]
351 fn when_some_relays_return_other_event_kinds() -> Result<()> { 360 async fn when_some_relays_return_other_event_kinds() -> Result<()> {
352 futures::executor::block_on(run_test_displays_correct_name( 361 run_test_displays_correct_name(
353 Some(&|relay, client_id, subscription_id, _| -> Result<()> { 362 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
354 let event = generate_test_key_1_kind_event(nostr::Kind::TextNote); 363 let event = generate_test_key_1_kind_event(nostr::Kind::TextNote);
355 relay.respond_events( 364 relay.respond_events(
@@ -370,31 +379,31 @@ mod with_relays {
370 )?; 379 )?;
371 Ok(()) 380 Ok(())
372 }), 381 }),
373 )) 382 )
383 .await
374 } 384 }
375 385
376 mod when_specifying_command_line_nsec_only { 386 mod when_specifying_command_line_nsec_only {
377 use super::*; 387 use super::*;
378 388
379 #[test] 389 #[tokio::test]
380 #[serial] 390 #[serial]
381 fn displays_correct_name() -> Result<()> { 391 async fn displays_correct_name() -> Result<()> {
382 futures::executor::block_on( 392 run_test_when_specifying_command_line_nsec_only_displays_correct_name(
383 run_test_when_specifying_command_line_nsec_only_displays_correct_name( 393 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
384 Some(&|relay, client_id, subscription_id, _| -> Result<()> { 394 relay.respond_events(
385 relay.respond_events( 395 client_id,
386 client_id, 396 &subscription_id,
387 &subscription_id, 397 &vec![
388 &vec![ 398 generate_test_key_1_metadata_event("fred"),
389 generate_test_key_1_metadata_event("fred"), 399 generate_test_key_1_relay_list_event_same_as_fallback(),
390 generate_test_key_1_relay_list_event_same_as_fallback(), 400 ],
391 ], 401 )?;
392 )?; 402 Ok(())
393 Ok(()) 403 }),
394 }), 404 None,
395 None,
396 ),
397 ) 405 )
406 .await
398 } 407 }
399 async fn run_test_when_specifying_command_line_nsec_only_displays_correct_name( 408 async fn run_test_when_specifying_command_line_nsec_only_displays_correct_name(
400 relay_listener1: Option<ListenerReqFunc<'_>>, 409 relay_listener1: Option<ListenerReqFunc<'_>>,
@@ -430,10 +439,9 @@ mod with_relays {
430 mod when_specifying_command_line_password_only { 439 mod when_specifying_command_line_password_only {
431 use super::*; 440 use super::*;
432 441
433 #[test] 442 #[tokio::test]
434 #[serial] 443 #[serial]
435 fn displays_correct_name() -> Result<()> { 444 async fn displays_correct_name() -> Result<()> {
436 futures::executor::block_on(
437 run_test_when_specifying_command_line_password_only_displays_correct_name( 445 run_test_when_specifying_command_line_password_only_displays_correct_name(
438 Some(&|relay, client_id, subscription_id, _| -> Result<()> { 446 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
439 relay.respond_events( 447 relay.respond_events(
@@ -447,8 +455,8 @@ mod with_relays {
447 Ok(()) 455 Ok(())
448 }), 456 }),
449 None, 457 None,
450 ), 458 )
451 ) 459 .await
452 } 460 }
453 async fn run_test_when_specifying_command_line_password_only_displays_correct_name( 461 async fn run_test_when_specifying_command_line_password_only_displays_correct_name(
454 relay_listener1: Option<ListenerReqFunc<'_>>, 462 relay_listener1: Option<ListenerReqFunc<'_>>,
@@ -495,10 +503,9 @@ mod with_relays {
495 mod when_specifying_command_line_nsec_and_password { 503 mod when_specifying_command_line_nsec_and_password {
496 use super::*; 504 use super::*;
497 505
498 #[test] 506 #[tokio::test]
499 #[serial] 507 #[serial]
500 fn displays_correct_name() -> Result<()> { 508 async fn displays_correct_name() -> Result<()> {
501 futures::executor::block_on(
502 run_test_when_specifying_command_line_nsec_and_password_displays_correct_name( 509 run_test_when_specifying_command_line_nsec_and_password_displays_correct_name(
503 Some(&|relay, client_id, subscription_id, _| -> Result<()> { 510 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
504 relay.respond_events( 511 relay.respond_events(
@@ -512,8 +519,7 @@ mod with_relays {
512 Ok(()) 519 Ok(())
513 }), 520 }),
514 None, 521 None,
515 ), 522 ).await
516 )
517 } 523 }
518 async fn run_test_when_specifying_command_line_nsec_and_password_displays_correct_name( 524 async fn run_test_when_specifying_command_line_nsec_and_password_displays_correct_name(
519 relay_listener1: Option<ListenerReqFunc<'_>>, 525 relay_listener1: Option<ListenerReqFunc<'_>>,
@@ -557,12 +563,10 @@ mod with_relays {
557 mod when_no_metadata_found { 563 mod when_no_metadata_found {
558 use super::*; 564 use super::*;
559 565
560 #[test] 566 #[tokio::test]
561 #[serial] 567 #[serial]
562 fn warm_user_and_displays_npub() -> Result<()> { 568 async fn warm_user_and_displays_npub() -> Result<()> {
563 futures::executor::block_on( 569 run_test_when_no_metadata_found_warns_user_and_uses_npub(None, None).await
564 run_test_when_no_metadata_found_warns_user_and_uses_npub(None, None),
565 )
566 } 570 }
567 571
568 async fn run_test_when_no_metadata_found_warns_user_and_uses_npub( 572 async fn run_test_when_no_metadata_found_warns_user_and_uses_npub(
@@ -612,22 +616,21 @@ mod with_relays {
612 mod when_metadata_but_no_relay_list_found { 616 mod when_metadata_but_no_relay_list_found {
613 use super::*; 617 use super::*;
614 618
615 #[test] 619 #[tokio::test]
616 #[serial] 620 #[serial]
617 fn warm_user_and_displays_name() -> Result<()> { 621 async fn warm_user_and_displays_name() -> Result<()> {
618 futures::executor::block_on( 622 run_test_when_no_relay_list_found_warns_user_and_uses_npub(
619 run_test_when_no_relay_list_found_warns_user_and_uses_npub( 623 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
620 Some(&|relay, client_id, subscription_id, _| -> Result<()> { 624 relay.respond_events(
621 relay.respond_events( 625 client_id,
622 client_id, 626 &subscription_id,
623 &subscription_id, 627 &vec![generate_test_key_1_metadata_event("fred")],
624 &vec![generate_test_key_1_metadata_event("fred")], 628 )?;
625 )?; 629 Ok(())
626 Ok(()) 630 }),
627 }), 631 None,
628 None,
629 ),
630 ) 632 )
633 .await
631 } 634 }
632 635
633 async fn run_test_when_no_relay_list_found_warns_user_and_uses_npub( 636 async fn run_test_when_no_relay_list_found_warns_user_and_uses_npub(
@@ -682,10 +685,10 @@ mod with_relays {
682 mod uses_cache { 685 mod uses_cache {
683 use super::*; 686 use super::*;
684 687
685 #[test] 688 #[tokio::test]
686 #[serial] 689 #[serial]
687 fn dislays_logged_in_with_correct_name() -> Result<()> { 690 async fn dislays_logged_in_with_correct_name() -> Result<()> {
688 futures::executor::block_on(run_test_dislays_logged_in_with_correct_name(Some( 691 run_test_dislays_logged_in_with_correct_name(Some(
689 &|relay, client_id, subscription_id, _| -> Result<()> { 692 &|relay, client_id, subscription_id, _| -> Result<()> {
690 relay.respond_events( 693 relay.respond_events(
691 client_id, 694 client_id,
@@ -697,7 +700,8 @@ mod with_relays {
697 )?; 700 )?;
698 Ok(()) 701 Ok(())
699 }, 702 },
700 ))) 703 ))
704 .await
701 } 705 }
702 async fn run_test_dislays_logged_in_with_correct_name( 706 async fn run_test_dislays_logged_in_with_correct_name(
703 relay_listener: Option<ListenerReqFunc<'_>>, 707 relay_listener: Option<ListenerReqFunc<'_>>,
@@ -794,10 +798,10 @@ mod with_relays {
794 } 798 }
795 799
796 /// this also tests that additional relays are queried 800 /// this also tests that additional relays are queried
797 #[test] 801 #[tokio::test]
798 #[serial] 802 #[serial]
799 fn displays_correct_name() -> Result<()> { 803 async fn displays_correct_name() -> Result<()> {
800 futures::executor::block_on(run_test_displays_correct_name( 804 run_test_displays_correct_name(
801 Some(&|relay, client_id, subscription_id, _| -> Result<()> { 805 Some(&|relay, client_id, subscription_id, _| -> Result<()> {
802 relay.respond_events( 806 relay.respond_events(
803 client_id, 807 client_id,
@@ -820,7 +824,8 @@ mod with_relays {
820 )?; 824 )?;
821 Ok(()) 825 Ok(())
822 }), 826 }),
823 )) 827 )
828 .await
824 } 829 }
825 } 830 }
826 } 831 }
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 {
252 Ok((r51, r52, r53, r55, r56)) 252 Ok((r51, r52, r53, r55, r56))
253 } 253 }
254 254
255 #[test] 255 #[tokio::test]
256 #[serial] 256 #[serial]
257 fn only_1_pr_kind_event_sent_to_each_relay() -> Result<()> { 257 async fn only_1_pr_kind_event_sent_to_each_relay() -> Result<()> {
258 let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_create_pr())?; 258 let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
259 for relay in [&r53, &r55, &r56] { 259 for relay in [&r53, &r55, &r56] {
260 assert_eq!( 260 assert_eq!(
261 relay 261 relay
@@ -269,10 +269,10 @@ mod sends_pr_and_2_patches_to_3_relays {
269 Ok(()) 269 Ok(())
270 } 270 }
271 271
272 #[test] 272 #[tokio::test]
273 #[serial] 273 #[serial]
274 fn only_1_pr_kind_event_sent_to_user_relays() -> Result<()> { 274 async fn only_1_pr_kind_event_sent_to_user_relays() -> Result<()> {
275 let (_, _, r53, r55, _) = futures::executor::block_on(prep_run_create_pr())?; 275 let (_, _, r53, r55, _) = prep_run_create_pr().await?;
276 for relay in [&r53, &r55] { 276 for relay in [&r53, &r55] {
277 assert_eq!( 277 assert_eq!(
278 relay 278 relay
@@ -286,10 +286,10 @@ mod sends_pr_and_2_patches_to_3_relays {
286 Ok(()) 286 Ok(())
287 } 287 }
288 288
289 #[test] 289 #[tokio::test]
290 #[serial] 290 #[serial]
291 fn only_1_pr_kind_event_sent_to_repo_relays() -> Result<()> { 291 async fn only_1_pr_kind_event_sent_to_repo_relays() -> Result<()> {
292 let (_, _, _, r55, r56) = futures::executor::block_on(prep_run_create_pr())?; 292 let (_, _, _, r55, r56) = prep_run_create_pr().await?;
293 for relay in [&r55, &r56] { 293 for relay in [&r55, &r56] {
294 assert_eq!( 294 assert_eq!(
295 relay 295 relay
@@ -303,10 +303,10 @@ mod sends_pr_and_2_patches_to_3_relays {
303 Ok(()) 303 Ok(())
304 } 304 }
305 305
306 #[test] 306 #[tokio::test]
307 #[serial] 307 #[serial]
308 fn pr_not_sent_to_fallback_relay() -> Result<()> { 308 async fn pr_not_sent_to_fallback_relay() -> Result<()> {
309 let (r51, r52, _, _, _) = futures::executor::block_on(prep_run_create_pr())?; 309 let (r51, r52, _, _, _) = prep_run_create_pr().await?;
310 for relay in [&r51, &r52] { 310 for relay in [&r51, &r52] {
311 assert_eq!( 311 assert_eq!(
312 relay 312 relay
@@ -320,10 +320,10 @@ mod sends_pr_and_2_patches_to_3_relays {
320 Ok(()) 320 Ok(())
321 } 321 }
322 322
323 #[test] 323 #[tokio::test]
324 #[serial] 324 #[serial]
325 fn only_2_patch_kind_events_sent_to_each_relay() -> Result<()> { 325 async fn only_2_patch_kind_events_sent_to_each_relay() -> Result<()> {
326 let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_create_pr())?; 326 let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
327 for relay in [&r53, &r55, &r56] { 327 for relay in [&r53, &r55, &r56] {
328 assert_eq!( 328 assert_eq!(
329 relay 329 relay
@@ -337,10 +337,10 @@ mod sends_pr_and_2_patches_to_3_relays {
337 Ok(()) 337 Ok(())
338 } 338 }
339 339
340 #[test] 340 #[tokio::test]
341 #[serial] 341 #[serial]
342 fn patch_content_contains_patch_in_email_format() -> Result<()> { 342 async fn patch_content_contains_patch_in_email_format() -> Result<()> {
343 let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_create_pr())?; 343 let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
344 for relay in [&r53, &r55, &r56] { 344 for relay in [&r53, &r55, &r56] {
345 let patch_events: Vec<&nostr::Event> = relay 345 let patch_events: Vec<&nostr::Event> = relay
346 .events 346 .events
@@ -407,10 +407,10 @@ mod sends_pr_and_2_patches_to_3_relays {
407 mod pr_tags { 407 mod pr_tags {
408 use super::*; 408 use super::*;
409 409
410 #[test] 410 #[tokio::test]
411 #[serial] 411 #[serial]
412 fn pr_tags_repo_commit() -> Result<()> { 412 async fn pr_tags_repo_commit() -> Result<()> {
413 let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_create_pr())?; 413 let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
414 let root_commit = GitTestRepo::default().initial_commit()?; 414 let root_commit = GitTestRepo::default().initial_commit()?;
415 415
416 for relay in [&r53, &r55, &r56] { 416 for relay in [&r53, &r55, &r56] {
@@ -429,10 +429,10 @@ mod sends_pr_and_2_patches_to_3_relays {
429 Ok(()) 429 Ok(())
430 } 430 }
431 431
432 #[test] 432 #[tokio::test]
433 #[serial] 433 #[serial]
434 fn pr_tags_title_as_name() -> Result<()> { 434 async fn pr_tags_title_as_name() -> Result<()> {
435 let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_create_pr())?; 435 let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
436 for relay in [&r53, &r55, &r56] { 436 for relay in [&r53, &r55, &r56] {
437 let pr_event: &nostr::Event = relay 437 let pr_event: &nostr::Event = relay
438 .events 438 .events
@@ -453,10 +453,10 @@ mod sends_pr_and_2_patches_to_3_relays {
453 Ok(()) 453 Ok(())
454 } 454 }
455 455
456 #[test] 456 #[tokio::test]
457 #[serial] 457 #[serial]
458 fn pr_tags_description() -> Result<()> { 458 async fn pr_tags_description() -> Result<()> {
459 let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_create_pr())?; 459 let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
460 for relay in [&r53, &r55, &r56] { 460 for relay in [&r53, &r55, &r56] {
461 let pr_event: &nostr::Event = relay 461 let pr_event: &nostr::Event = relay
462 .events 462 .events
@@ -477,10 +477,10 @@ mod sends_pr_and_2_patches_to_3_relays {
477 Ok(()) 477 Ok(())
478 } 478 }
479 479
480 #[test] 480 #[tokio::test]
481 #[serial] 481 #[serial]
482 fn pr_tags_branch_name() -> Result<()> { 482 async fn pr_tags_branch_name() -> Result<()> {
483 let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_create_pr())?; 483 let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
484 for relay in [&r53, &r55, &r56] { 484 for relay in [&r53, &r55, &r56] {
485 let pr_event: &nostr::Event = relay 485 let pr_event: &nostr::Event = relay
486 .events 486 .events
@@ -506,8 +506,8 @@ mod sends_pr_and_2_patches_to_3_relays {
506 mod patch_tags { 506 mod patch_tags {
507 use super::*; 507 use super::*;
508 508
509 fn prep() -> Result<nostr::Event> { 509 async fn prep() -> Result<nostr::Event> {
510 let (_, _, r53, _, _) = futures::executor::block_on(prep_run_create_pr())?; 510 let (_, _, r53, _, _) = prep_run_create_pr().await?;
511 Ok(r53 511 Ok(r53
512 .events 512 .events
513 .iter() 513 .iter()
@@ -516,11 +516,11 @@ mod sends_pr_and_2_patches_to_3_relays {
516 .clone()) 516 .clone())
517 } 517 }
518 518
519 #[test] 519 #[tokio::test]
520 #[serial] 520 #[serial]
521 fn commit_and_commit_r() -> Result<()> { 521 async fn commit_and_commit_r() -> Result<()> {
522 static COMMIT_ID: &str = "fe973a840fba2a8ab37dd505c154854a69a6505c"; 522 static COMMIT_ID: &str = "fe973a840fba2a8ab37dd505c154854a69a6505c";
523 let most_recent_patch = prep()?; 523 let most_recent_patch = prep().await?;
524 assert!( 524 assert!(
525 most_recent_patch 525 most_recent_patch
526 .tags 526 .tags
@@ -536,12 +536,12 @@ mod sends_pr_and_2_patches_to_3_relays {
536 Ok(()) 536 Ok(())
537 } 537 }
538 538
539 #[test] 539 #[tokio::test]
540 #[serial] 540 #[serial]
541 fn parent_commit() -> Result<()> { 541 async fn parent_commit() -> Result<()> {
542 // commit parent 'r' and 'parent-commit' tag 542 // commit parent 'r' and 'parent-commit' tag
543 static COMMIT_PARENT_ID: &str = "232efb37ebc67692c9e9ff58b83c0d3d63971a0a"; 543 static COMMIT_PARENT_ID: &str = "232efb37ebc67692c9e9ff58b83c0d3d63971a0a";
544 let most_recent_patch = prep()?; 544 let most_recent_patch = prep().await?;
545 assert!( 545 assert!(
546 most_recent_patch.tags.iter().any( 546 most_recent_patch.tags.iter().any(
547 |t| t.as_vec()[0].eq("parent-commit") && t.as_vec()[1].eq(COMMIT_PARENT_ID) 547 |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 {
550 Ok(()) 550 Ok(())
551 } 551 }
552 552
553 #[test] 553 #[tokio::test]
554 #[serial] 554 #[serial]
555 fn root_commit_as_r() -> Result<()> { 555 async fn root_commit_as_r() -> Result<()> {
556 assert!(prep()?.tags.iter().any(|t| t.as_vec()[0].eq("r") 556 assert!(prep().await?.tags.iter().any(|t| t.as_vec()[0].eq("r")
557 && t.as_vec()[1].eq("9ee507fc4357d7ee16a5d8901bedcd103f23c17d"))); 557 && t.as_vec()[1].eq("9ee507fc4357d7ee16a5d8901bedcd103f23c17d")));
558 Ok(()) 558 Ok(())
559 } 559 }
560 560
561 #[test] 561 #[tokio::test]
562 #[serial] 562 #[serial]
563 fn description_with_commit_message() -> Result<()> { 563 async fn description_with_commit_message() -> Result<()> {
564 assert_eq!( 564 assert_eq!(
565 prep()? 565 prep()
566 .await?
566 .tags 567 .tags
567 .iter() 568 .iter()
568 .find(|t| t.as_vec()[0].eq("description")) 569 .find(|t| t.as_vec()[0].eq("description"))
@@ -573,11 +574,12 @@ mod sends_pr_and_2_patches_to_3_relays {
573 Ok(()) 574 Ok(())
574 } 575 }
575 576
576 #[test] 577 #[tokio::test]
577 #[serial] 578 #[serial]
578 fn commit_author() -> Result<()> { 579 async fn commit_author() -> Result<()> {
579 assert_eq!( 580 assert_eq!(
580 prep()? 581 prep()
582 .await?
581 .tags 583 .tags
582 .iter() 584 .iter()
583 .find(|t| t.as_vec()[0].eq("author")) 585 .find(|t| t.as_vec()[0].eq("author"))
@@ -588,11 +590,12 @@ mod sends_pr_and_2_patches_to_3_relays {
588 Ok(()) 590 Ok(())
589 } 591 }
590 592
591 #[test] 593 #[tokio::test]
592 #[serial] 594 #[serial]
593 fn commit_committer() -> Result<()> { 595 async fn commit_committer() -> Result<()> {
594 assert_eq!( 596 assert_eq!(
595 prep()? 597 prep()
598 .await?
596 .tags 599 .tags
597 .iter() 600 .iter()
598 .find(|t| t.as_vec()[0].eq("committer")) 601 .find(|t| t.as_vec()[0].eq("committer"))
@@ -603,10 +606,10 @@ mod sends_pr_and_2_patches_to_3_relays {
603 Ok(()) 606 Ok(())
604 } 607 }
605 608
606 #[test] 609 #[tokio::test]
607 #[serial] 610 #[serial]
608 fn patch_tags_pr_event_as_root() -> Result<()> { 611 async fn patch_tags_pr_event_as_root() -> Result<()> {
609 let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_create_pr())?; 612 let (_, _, r53, r55, r56) = prep_run_create_pr().await?;
610 for relay in [&r53, &r55, &r56] { 613 for relay in [&r53, &r55, &r56] {
611 let patch_events: Vec<&nostr::Event> = relay 614 let patch_events: Vec<&nostr::Event> = relay
612 .events 615 .events
@@ -705,10 +708,10 @@ mod sends_pr_and_2_patches_to_3_relays {
705 Ok(()) 708 Ok(())
706 } 709 }
707 710
708 #[test] 711 #[tokio::test]
709 #[serial] 712 #[serial]
710 fn check_cli_output() -> Result<()> { 713 async fn check_cli_output() -> Result<()> {
711 futures::executor::block_on(run_test_async())?; 714 run_test_async().await?;
712 Ok(()) 715 Ok(())
713 } 716 }
714 } 717 }
@@ -787,10 +790,10 @@ mod sends_pr_and_2_patches_to_3_relays {
787 Ok(()) 790 Ok(())
788 } 791 }
789 792
790 #[test] 793 #[tokio::test]
791 #[serial] 794 #[serial]
792 fn only_first_rejected_event_sent_to_relay() -> Result<()> { 795 async fn only_first_rejected_event_sent_to_relay() -> Result<()> {
793 futures::executor::block_on(run_test_async())?; 796 run_test_async().await?;
794 Ok(()) 797 Ok(())
795 } 798 }
796 } 799 }
@@ -879,10 +882,10 @@ mod sends_pr_and_2_patches_to_3_relays {
879 Ok((r51, r52, r53)) 882 Ok((r51, r52, r53))
880 } 883 }
881 884
882 #[test] 885 #[tokio::test]
883 #[serial] 886 #[serial]
884 fn cli_show_rejection_with_comment() -> Result<()> { 887 async fn cli_show_rejection_with_comment() -> Result<()> {
885 futures::executor::block_on(run_test_async())?; 888 run_test_async().await?;
886 Ok(()) 889 Ok(())
887 } 890 }
888 } 891 }
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 {
226 Ok(()) 226 Ok(())
227 } 227 }
228 228
229 #[test] 229 #[tokio::test]
230 #[serial] 230 #[serial]
231 fn prompts_to_choose_from_pr_titles() -> Result<()> { 231 async fn prompts_to_choose_from_pr_titles() -> Result<()> {
232 futures::executor::block_on(run_async_prompts_to_choose_from_pr_titles()) 232 let _ = run_async_prompts_to_choose_from_pr_titles().await;
233 Ok(())
233 } 234 }
234 } 235 }
235 236
236 #[test] 237 #[tokio::test]
237 #[serial] 238 #[serial]
238 fn pr_branch_created_with_correct_name() -> Result<()> { 239 async fn pr_branch_created_with_correct_name() -> Result<()> {
239 let (_, test_repo) = futures::executor::block_on(prep_and_run())?; 240 let (_, test_repo) = prep_and_run().await?;
240 assert_eq!( 241 assert_eq!(
241 vec![FEATURE_BRANCH_NAME_1, "main"], 242 vec![FEATURE_BRANCH_NAME_1, "main"],
242 test_repo.get_local_branch_names()? 243 test_repo.get_local_branch_names()?
@@ -244,10 +245,10 @@ mod when_main_branch_is_uptodate {
244 Ok(()) 245 Ok(())
245 } 246 }
246 247
247 #[test] 248 #[tokio::test]
248 #[serial] 249 #[serial]
249 fn pr_branch_checked_out() -> Result<()> { 250 async fn pr_branch_checked_out() -> Result<()> {
250 let (_, test_repo) = futures::executor::block_on(prep_and_run())?; 251 let (_, test_repo) = prep_and_run().await?;
251 assert_eq!( 252 assert_eq!(
252 FEATURE_BRANCH_NAME_1, 253 FEATURE_BRANCH_NAME_1,
253 test_repo.get_checked_out_branch_name()?, 254 test_repo.get_checked_out_branch_name()?,
@@ -255,11 +256,10 @@ mod when_main_branch_is_uptodate {
255 Ok(()) 256 Ok(())
256 } 257 }
257 258
258 #[test] 259 #[tokio::test]
259 #[serial] 260 #[serial]
260 fn pr_branch_tip_is_most_recent_patch() -> Result<()> { 261 async fn pr_branch_tip_is_most_recent_patch() -> Result<()> {
261 let (originating_repo, test_repo) = 262 let (originating_repo, test_repo) = prep_and_run().await?;
262 futures::executor::block_on(prep_and_run())?;
263 assert_eq!( 263 assert_eq!(
264 originating_repo.get_tip_of_local_branch(FEATURE_BRANCH_NAME_1)?, 264 originating_repo.get_tip_of_local_branch(FEATURE_BRANCH_NAME_1)?,
265 test_repo.get_tip_of_local_branch(FEATURE_BRANCH_NAME_1)?, 265 test_repo.get_tip_of_local_branch(FEATURE_BRANCH_NAME_1)?,
@@ -391,17 +391,18 @@ mod when_main_branch_is_uptodate {
391 Ok(()) 391 Ok(())
392 } 392 }
393 393
394 #[test] 394 #[tokio::test]
395 #[serial] 395 #[serial]
396 fn prompts_to_choose_from_pr_titles() -> Result<()> { 396 async fn prompts_to_choose_from_pr_titles() -> Result<()> {
397 futures::executor::block_on(run_async_prompts_to_choose_from_pr_titles()) 397 let _ = run_async_prompts_to_choose_from_pr_titles().await;
398 Ok(())
398 } 399 }
399 } 400 }
400 401
401 #[test] 402 #[tokio::test]
402 #[serial] 403 #[serial]
403 fn pr_branch_created_with_correct_name() -> Result<()> { 404 async fn pr_branch_created_with_correct_name() -> Result<()> {
404 let (_, test_repo) = futures::executor::block_on(prep_and_run())?; 405 let (_, test_repo) = prep_and_run().await?;
405 assert_eq!( 406 assert_eq!(
406 vec![FEATURE_BRANCH_NAME_3, "main"], 407 vec![FEATURE_BRANCH_NAME_3, "main"],
407 test_repo.get_local_branch_names()? 408 test_repo.get_local_branch_names()?
@@ -409,10 +410,10 @@ mod when_main_branch_is_uptodate {
409 Ok(()) 410 Ok(())
410 } 411 }
411 412
412 #[test] 413 #[tokio::test]
413 #[serial] 414 #[serial]
414 fn pr_branch_checked_out() -> Result<()> { 415 async fn pr_branch_checked_out() -> Result<()> {
415 let (_, test_repo) = futures::executor::block_on(prep_and_run())?; 416 let (_, test_repo) = prep_and_run().await?;
416 assert_eq!( 417 assert_eq!(
417 FEATURE_BRANCH_NAME_3, 418 FEATURE_BRANCH_NAME_3,
418 test_repo.get_checked_out_branch_name()?, 419 test_repo.get_checked_out_branch_name()?,
@@ -420,11 +421,10 @@ mod when_main_branch_is_uptodate {
420 Ok(()) 421 Ok(())
421 } 422 }
422 423
423 #[test] 424 #[tokio::test]
424 #[serial] 425 #[serial]
425 fn pr_branch_tip_is_most_recent_patch() -> Result<()> { 426 async fn pr_branch_tip_is_most_recent_patch() -> Result<()> {
426 let (originating_repo, test_repo) = 427 let (originating_repo, test_repo) = prep_and_run().await?;
427 futures::executor::block_on(prep_and_run())?;
428 assert_eq!( 428 assert_eq!(
429 originating_repo.get_tip_of_local_branch(FEATURE_BRANCH_NAME_3)?, 429 originating_repo.get_tip_of_local_branch(FEATURE_BRANCH_NAME_3)?,
430 test_repo.get_tip_of_local_branch(FEATURE_BRANCH_NAME_3)?, 430 test_repo.get_tip_of_local_branch(FEATURE_BRANCH_NAME_3)?,
@@ -579,17 +579,18 @@ mod when_main_branch_is_uptodate {
579 Ok(()) 579 Ok(())
580 } 580 }
581 581
582 #[test] 582 #[tokio::test]
583 #[serial] 583 #[serial]
584 fn prompts_to_choose_from_pr_titles() -> Result<()> { 584 async fn prompts_to_choose_from_pr_titles() -> Result<()> {
585 futures::executor::block_on(run_async_prompts_to_choose_from_pr_titles()) 585 let _ = run_async_prompts_to_choose_from_pr_titles().await;
586 Ok(())
586 } 587 }
587 } 588 }
588 589
589 #[test] 590 #[tokio::test]
590 #[serial] 591 #[serial]
591 fn pr_branch_checked_out() -> Result<()> { 592 async fn pr_branch_checked_out() -> Result<()> {
592 let (_, test_repo) = futures::executor::block_on(prep_and_run())?; 593 let (_, test_repo) = prep_and_run().await?;
593 assert_eq!( 594 assert_eq!(
594 FEATURE_BRANCH_NAME_1, 595 FEATURE_BRANCH_NAME_1,
595 test_repo.get_checked_out_branch_name()?, 596 test_repo.get_checked_out_branch_name()?,
@@ -738,17 +739,18 @@ mod when_main_branch_is_uptodate {
738 Ok(()) 739 Ok(())
739 } 740 }
740 741
741 #[test] 742 #[tokio::test]
742 #[serial] 743 #[serial]
743 fn prompts_to_choose_from_pr_titles() -> Result<()> { 744 async fn prompts_to_choose_from_pr_titles() -> Result<()> {
744 futures::executor::block_on(run_async_prompts_to_choose_from_pr_titles()) 745 let _ = run_async_prompts_to_choose_from_pr_titles().await;
746 Ok(())
745 } 747 }
746 } 748 }
747 749
748 #[test] 750 #[tokio::test]
749 #[serial] 751 #[serial]
750 fn pr_branch_checked_out() -> Result<()> { 752 async fn pr_branch_checked_out() -> Result<()> {
751 let (_, test_repo) = futures::executor::block_on(prep_and_run())?; 753 let (_, test_repo) = prep_and_run().await?;
752 assert_eq!( 754 assert_eq!(
753 FEATURE_BRANCH_NAME_1, 755 FEATURE_BRANCH_NAME_1,
754 test_repo.get_checked_out_branch_name()?, 756 test_repo.get_checked_out_branch_name()?,
@@ -756,11 +758,10 @@ mod when_main_branch_is_uptodate {
756 Ok(()) 758 Ok(())
757 } 759 }
758 760
759 #[test] 761 #[tokio::test]
760 #[serial] 762 #[serial]
761 fn pr_branch_tip_is_most_recent_patch() -> Result<()> { 763 async fn pr_branch_tip_is_most_recent_patch() -> Result<()> {
762 let (originating_repo, test_repo) = 764 let (originating_repo, test_repo) = prep_and_run().await?;
763 futures::executor::block_on(prep_and_run())?;
764 assert_eq!( 765 assert_eq!(
765 originating_repo.get_tip_of_local_branch(FEATURE_BRANCH_NAME_1)?, 766 originating_repo.get_tip_of_local_branch(FEATURE_BRANCH_NAME_1)?,
766 test_repo.get_tip_of_local_branch(FEATURE_BRANCH_NAME_1)?, 767 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 {
144 Ok(()) 144 Ok(())
145 } 145 }
146 146
147 #[test] 147 #[tokio::test]
148 #[serial] 148 #[serial]
149 fn cli_show_error() -> Result<()> { 149 async fn cli_show_error() -> Result<()> {
150 futures::executor::block_on(run_async_cli_show_error()) 150 run_async_cli_show_error().await
151 } 151 }
152 } 152 }
153} 153}
@@ -209,10 +209,10 @@ mod when_branch_doesnt_exist {
209 Ok(()) 209 Ok(())
210 } 210 }
211 211
212 #[test] 212 #[tokio::test]
213 #[serial] 213 #[serial]
214 fn cli_show_error() -> Result<()> { 214 async fn cli_show_error() -> Result<()> {
215 futures::executor::block_on(run_async_cli_show_error()) 215 run_async_cli_show_error().await
216 } 216 }
217 } 217 }
218} 218}
@@ -274,10 +274,10 @@ mod when_branch_is_checked_out {
274 Ok(()) 274 Ok(())
275 } 275 }
276 276
277 #[test] 277 #[tokio::test]
278 #[serial] 278 #[serial]
279 fn cli_show_up_to_date() -> Result<()> { 279 async fn cli_show_up_to_date() -> Result<()> {
280 futures::executor::block_on(run_async_cli_show_up_to_date()) 280 run_async_cli_show_up_to_date().await
281 } 281 }
282 } 282 }
283 } 283 }
@@ -389,17 +389,17 @@ mod when_branch_is_checked_out {
389 Ok(()) 389 Ok(())
390 } 390 }
391 391
392 #[test] 392 #[tokio::test]
393 #[serial] 393 #[serial]
394 fn cli_applied_1_commit() -> Result<()> { 394 async fn cli_applied_1_commit() -> Result<()> {
395 futures::executor::block_on(run_async_cli_applied_1_commit()) 395 run_async_cli_applied_1_commit().await
396 } 396 }
397 } 397 }
398 398
399 #[test] 399 #[tokio::test]
400 #[serial] 400 #[serial]
401 fn pr_branch_tip_is_most_recent_patch() -> Result<()> { 401 async fn pr_branch_tip_is_most_recent_patch() -> Result<()> {
402 let (originating_repo, test_repo) = futures::executor::block_on(prep_and_run())?; 402 let (originating_repo, test_repo) = prep_and_run().await?;
403 assert_eq!( 403 assert_eq!(
404 originating_repo.get_tip_of_local_branch(FEATURE_BRANCH_NAME_1)?, 404 originating_repo.get_tip_of_local_branch(FEATURE_BRANCH_NAME_1)?,
405 test_repo.get_tip_of_local_branch(FEATURE_BRANCH_NAME_1)?, 405 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 {
111 use super::*; 111 use super::*;
112 112
113 mod cli_prompts { 113 mod cli_prompts {
114
114 use super::*; 115 use super::*;
115 async fn run_async_cli_show_error() -> Result<()> { 116 async fn run_async_cli_show_error() -> Result<()> {
116 let (mut r51, mut r52, mut r53, mut r55, mut r56) = ( 117 let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
@@ -164,10 +165,10 @@ mod when_pr_isnt_associated_with_branch_name {
164 Ok(()) 165 Ok(())
165 } 166 }
166 167
167 #[test] 168 #[tokio::test]
168 #[serial] 169 #[serial]
169 fn cli_show_error() -> Result<()> { 170 async fn cli_show_error() -> Result<()> {
170 futures::executor::block_on(run_async_cli_show_error()) 171 run_async_cli_show_error().await
171 } 172 }
172 } 173 }
173} 174}
@@ -229,10 +230,11 @@ mod when_branch_is_checked_out {
229 Ok(()) 230 Ok(())
230 } 231 }
231 232
232 #[test] 233 #[tokio::test]
233 #[serial] 234 #[serial]
234 fn cli_show_up_to_date() -> Result<()> { 235 async fn cli_show_up_to_date() -> Result<()> {
235 futures::executor::block_on(run_async_cli_show_up_to_date()) 236 let _ = run_async_cli_show_up_to_date().await;
237 Ok(())
236 } 238 }
237 } 239 }
238 } 240 }
@@ -291,10 +293,11 @@ mod when_branch_is_checked_out {
291 Ok(()) 293 Ok(())
292 } 294 }
293 295
294 #[test] 296 #[tokio::test]
295 #[serial] 297 #[serial]
296 fn cli_show_up_to_date() -> Result<()> { 298 async fn cli_show_up_to_date() -> Result<()> {
297 futures::executor::block_on(run_async_cli_show_up_to_date()) 299 let _ = run_async_cli_show_up_to_date().await;
300 Ok(())
298 } 301 }
299 } 302 }
300 } 303 }
@@ -389,10 +392,11 @@ mod when_branch_is_checked_out {
389 Ok(()) 392 Ok(())
390 } 393 }
391 394
392 #[test] 395 #[tokio::test]
393 #[serial] 396 #[serial]
394 fn cli_applied_1_commit() -> Result<()> { 397 async fn cli_applied_1_commit() -> Result<()> {
395 futures::executor::block_on(run_async_cli_applied_1_commit()) 398 let _ = run_async_cli_applied_1_commit().await;
399 Ok(())
396 } 400 }
397 } 401 }
398 402
@@ -453,10 +457,10 @@ mod when_branch_is_checked_out {
453 457
454 Ok((res, r55.events.clone())) 458 Ok((res, r55.events.clone()))
455 } 459 }
456 #[test] 460 #[tokio::test]
457 #[serial] 461 #[serial]
458 fn commits_issued_as_patch_event() -> Result<()> { 462 async fn commits_issued_as_patch_event() -> Result<()> {
459 let (test_repo, r55_events) = futures::executor::block_on(prep_and_run())?; 463 let (test_repo, r55_events) = prep_and_run().await?;
460 464
461 let commit_id = test_repo 465 let commit_id = test_repo
462 .get_tip_of_local_branch(FEATURE_BRANCH_NAME_1)? 466 .get_tip_of_local_branch(FEATURE_BRANCH_NAME_1)?
generated by cgit v1.2.3 (git 2.39.1) at 2026-06-05 03:06:31 +0000