lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

relay_complement.rs (5041B)


      1 use std::collections::BTreeSet;
      2 
      3 use radroots_replica_schema::nostr_profile::{INostrProfileCreate, NostrProfileQueryBindValues};
      4 use radroots_replica_schema::nostr_profile_relay::INostrProfileRelayRelation;
      5 use radroots_replica_schema::nostr_relay::{
      6     INostrRelayCreate, INostrRelayDelete, INostrRelayFindMany, INostrRelayFindOne,
      7     INostrRelayFindOneRelArgs, NostrRelayFindManyRel, NostrRelayProfileArgs,
      8     NostrRelayQueryBindValues,
      9 };
     10 use radroots_replica_store::ReplicaSql;
     11 use radroots_sql_core::{SqlError, SqlxSqliteExecutor};
     12 use serde_json::json;
     13 
     14 type Database = ReplicaSql<SqlxSqliteExecutor>;
     15 
     16 const UNASSIGNED: &str = "wss://unassigned.example.test";
     17 const TARGET_ONLY: &str = "wss://target.example.test";
     18 const OTHER_ONLY: &str = "wss://other.example.test";
     19 const SHARED: &str = "wss://shared.example.test";
     20 
     21 fn target_key() -> String {
     22     "a".repeat(64)
     23 }
     24 
     25 fn fixture() -> Database {
     26     let db = ReplicaSql::new(SqlxSqliteExecutor::open_memory().unwrap());
     27     db.migrate_up().unwrap();
     28     let profiles: Vec<_> = [target_key(), "b".repeat(64)]
     29         .into_iter()
     30         .map(|public_key| {
     31             let input: INostrProfileCreate = serde_json::from_value(json!({
     32                 "public_key": public_key,
     33                 "profile_type": "person",
     34                 "name": "synthetic relation fixture"
     35             }))
     36             .unwrap();
     37             db.nostr_profile_create(&input).unwrap().result.id
     38         })
     39         .collect();
     40     let relays: Vec<_> = [UNASSIGNED, TARGET_ONLY, OTHER_ONLY, SHARED]
     41         .into_iter()
     42         .map(|url| {
     43             let input: INostrRelayCreate = serde_json::from_value(json!({ "url": url })).unwrap();
     44             db.nostr_relay_create(&input).unwrap().result.id
     45         })
     46         .collect();
     47     for (profile, relay) in [(0, 1), (1, 2), (0, 3), (1, 3)] {
     48         db.nostr_profile_relay_set(&INostrProfileRelayRelation {
     49             nostr_profile: NostrProfileQueryBindValues::Id {
     50                 id: profiles[profile].clone(),
     51             },
     52             nostr_relay: NostrRelayQueryBindValues::Id {
     53                 id: relays[relay].clone(),
     54             },
     55         })
     56         .unwrap();
     57     }
     58     db
     59 }
     60 
     61 fn off_profile(public_key: String) -> NostrRelayFindManyRel {
     62     NostrRelayFindManyRel::OffProfile(NostrRelayProfileArgs { public_key })
     63 }
     64 
     65 fn many(db: &Database, rel: NostrRelayFindManyRel) -> BTreeSet<String> {
     66     let rows = db
     67         .nostr_relay_find_many(&INostrRelayFindMany::Rel { rel })
     68         .unwrap()
     69         .results;
     70     let count = rows.len();
     71     let urls: BTreeSet<_> = rows.into_iter().map(|row| row.url).collect();
     72     assert_eq!(
     73         urls.len(),
     74         count,
     75         "relation reads must not duplicate relays"
     76     );
     77     urls
     78 }
     79 
     80 fn urls(expected: &[&str]) -> BTreeSet<String> {
     81     expected.iter().map(|url| (*url).to_owned()).collect()
     82 }
     83 
     84 #[test]
     85 fn off_profile_is_the_complete_membership_complement() {
     86     let db = fixture();
     87     assert_eq!(
     88         many(
     89             &db,
     90             NostrRelayFindManyRel::OnProfile(NostrRelayProfileArgs {
     91                 public_key: target_key(),
     92             })
     93         ),
     94         urls(&[TARGET_ONLY, SHARED])
     95     );
     96     assert_eq!(
     97         many(&db, off_profile(target_key())),
     98         urls(&[UNASSIGNED, OTHER_ONLY])
     99     );
    100 }
    101 
    102 #[test]
    103 fn absent_profile_has_no_members_and_all_relays_in_the_complement() {
    104     let db = fixture();
    105     assert!(
    106         many(
    107             &db,
    108             NostrRelayFindManyRel::OnProfile(NostrRelayProfileArgs {
    109                 public_key: "c".repeat(64),
    110             })
    111         )
    112         .is_empty()
    113     );
    114     assert_eq!(
    115         many(&db, off_profile("c".repeat(64))),
    116         urls(&[UNASSIGNED, TARGET_ONLY, OTHER_ONLY, SHARED])
    117     );
    118 }
    119 
    120 #[test]
    121 fn single_lookup_and_delete_preserve_assigned_relays() {
    122     let db = fixture();
    123     let mut remaining = urls(&[UNASSIGNED, OTHER_ONLY]);
    124     while !remaining.is_empty() {
    125         let selected = db
    126             .nostr_relay_find_one(&INostrRelayFindOne::Rel(INostrRelayFindOneRelArgs {
    127                 rel: off_profile(target_key()),
    128             }))
    129             .unwrap()
    130             .result
    131             .expect("the complement contains a relay");
    132         assert!(remaining.contains(&selected.url));
    133         db.nostr_relay_delete(&INostrRelayDelete::Rel(INostrRelayFindOneRelArgs {
    134             rel: off_profile(target_key()),
    135         }))
    136         .unwrap();
    137         let after = many(&db, off_profile(target_key()));
    138         assert_eq!(after.len(), remaining.len() - 1);
    139         assert!(after.is_subset(&remaining));
    140         remaining = after;
    141     }
    142     assert_eq!(
    143         many(
    144             &db,
    145             NostrRelayFindManyRel::OnProfile(NostrRelayProfileArgs {
    146                 public_key: target_key(),
    147             })
    148         ),
    149         urls(&[TARGET_ONLY, SHARED])
    150     );
    151     let missing = db.nostr_relay_delete(&INostrRelayDelete::Rel(INostrRelayFindOneRelArgs {
    152         rel: off_profile(target_key()),
    153     }));
    154     assert!(matches!(missing, Err(error) if matches!(error.error, SqlError::NotFound(_))));
    155 }