upleb.uk

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

summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/key_handling/users.rs259
1 files changed, 147 insertions, 112 deletions
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 }
generated by cgit v1.2.3 (git 2.39.1) at 2026-06-05 05:20:57 +0000