use super::*; use gpui::executor::{Background, Deterministic}; use std::sync::Arc; macro_rules! test_both_dbs { ($postgres_test_name:ident, $sqlite_test_name:ident, $db:ident, $body:block) => { #[gpui::test] async fn $postgres_test_name() { let test_db = TestDb::postgres(Deterministic::new(0).build_background()); let $db = test_db.db(); $body } #[gpui::test] async fn $sqlite_test_name() { let test_db = TestDb::sqlite(Deterministic::new(0).build_background()); let $db = test_db.db(); $body } }; } test_both_dbs!( test_get_users_by_ids_postgres, test_get_users_by_ids_sqlite, db, { let mut user_ids = Vec::new(); let mut user_metric_ids = Vec::new(); for i in 1..=4 { let user = db .create_user( &format!("user{i}@example.com"), false, NewUserParams { github_login: format!("user{i}"), github_user_id: i, invite_count: 0, }, ) .await .unwrap(); user_ids.push(user.user_id); user_metric_ids.push(user.metrics_id); } assert_eq!( db.get_users_by_ids(user_ids.clone()).await.unwrap(), vec![ User { id: user_ids[0], github_login: "user1".to_string(), github_user_id: Some(1), email_address: Some("user1@example.com".to_string()), admin: false, metrics_id: user_metric_ids[0].parse().unwrap(), ..Default::default() }, User { id: user_ids[1], github_login: "user2".to_string(), github_user_id: Some(2), email_address: Some("user2@example.com".to_string()), admin: false, metrics_id: user_metric_ids[1].parse().unwrap(), ..Default::default() }, User { id: user_ids[2], github_login: "user3".to_string(), github_user_id: Some(3), email_address: Some("user3@example.com".to_string()), admin: false, metrics_id: user_metric_ids[2].parse().unwrap(), ..Default::default() }, User { id: user_ids[3], github_login: "user4".to_string(), github_user_id: Some(4), email_address: Some("user4@example.com".to_string()), admin: false, metrics_id: user_metric_ids[3].parse().unwrap(), ..Default::default() } ] ); } ); // test_both_dbs!( // test_get_user_by_github_account_postgres, // test_get_user_by_github_account_sqlite, // db, // { // let user_id1 = db // .create_user( // "user1@example.com", // false, // NewUserParams { // github_login: "login1".into(), // github_user_id: 101, // invite_count: 0, // }, // ) // .await // .unwrap() // .user_id; // let user_id2 = db // .create_user( // "user2@example.com", // false, // NewUserParams { // github_login: "login2".into(), // github_user_id: 102, // invite_count: 0, // }, // ) // .await // .unwrap() // .user_id; // let user = db // .get_user_by_github_account("login1", None) // .await // .unwrap() // .unwrap(); // assert_eq!(user.id, user_id1); // assert_eq!(&user.github_login, "login1"); // assert_eq!(user.github_user_id, Some(101)); // assert!(db // .get_user_by_github_account("non-existent-login", None) // .await // .unwrap() // .is_none()); // let user = db // .get_user_by_github_account("the-new-login2", Some(102)) // .await // .unwrap() // .unwrap(); // assert_eq!(user.id, user_id2); // assert_eq!(&user.github_login, "the-new-login2"); // assert_eq!(user.github_user_id, Some(102)); // } // ); // test_both_dbs!( // test_create_access_tokens_postgres, // test_create_access_tokens_sqlite, // db, // { // let user = db // .create_user( // "u1@example.com", // false, // NewUserParams { // github_login: "u1".into(), // github_user_id: 1, // invite_count: 0, // }, // ) // .await // .unwrap() // .user_id; // db.create_access_token_hash(user, "h1", 3).await.unwrap(); // db.create_access_token_hash(user, "h2", 3).await.unwrap(); // assert_eq!( // db.get_access_token_hashes(user).await.unwrap(), // &["h2".to_string(), "h1".to_string()] // ); // db.create_access_token_hash(user, "h3", 3).await.unwrap(); // assert_eq!( // db.get_access_token_hashes(user).await.unwrap(), // &["h3".to_string(), "h2".to_string(), "h1".to_string(),] // ); // db.create_access_token_hash(user, "h4", 3).await.unwrap(); // assert_eq!( // db.get_access_token_hashes(user).await.unwrap(), // &["h4".to_string(), "h3".to_string(), "h2".to_string(),] // ); // db.create_access_token_hash(user, "h5", 3).await.unwrap(); // assert_eq!( // db.get_access_token_hashes(user).await.unwrap(), // &["h5".to_string(), "h4".to_string(), "h3".to_string()] // ); // } // ); // test_both_dbs!(test_add_contacts_postgres, test_add_contacts_sqlite, db, { // let mut user_ids = Vec::new(); // for i in 0..3 { // user_ids.push( // db.create_user( // &format!("user{i}@example.com"), // false, // NewUserParams { // github_login: format!("user{i}"), // github_user_id: i, // invite_count: 0, // }, // ) // .await // .unwrap() // .user_id, // ); // } // let user_1 = user_ids[0]; // let user_2 = user_ids[1]; // let user_3 = user_ids[2]; // // User starts with no contacts // assert_eq!(db.get_contacts(user_1).await.unwrap(), &[]); // // User requests a contact. Both users see the pending request. // db.send_contact_request(user_1, user_2).await.unwrap(); // assert!(!db.has_contact(user_1, user_2).await.unwrap()); // assert!(!db.has_contact(user_2, user_1).await.unwrap()); // assert_eq!( // db.get_contacts(user_1).await.unwrap(), // &[Contact::Outgoing { user_id: user_2 }], // ); // assert_eq!( // db.get_contacts(user_2).await.unwrap(), // &[Contact::Incoming { // user_id: user_1, // should_notify: true // }] // ); // // User 2 dismisses the contact request notification without accepting or rejecting. // // We shouldn't notify them again. // db.dismiss_contact_notification(user_1, user_2) // .await // .unwrap_err(); // db.dismiss_contact_notification(user_2, user_1) // .await // .unwrap(); // assert_eq!( // db.get_contacts(user_2).await.unwrap(), // &[Contact::Incoming { // user_id: user_1, // should_notify: false // }] // ); // // User can't accept their own contact request // db.respond_to_contact_request(user_1, user_2, true) // .await // .unwrap_err(); // // User accepts a contact request. Both users see the contact. // db.respond_to_contact_request(user_2, user_1, true) // .await // .unwrap(); // assert_eq!( // db.get_contacts(user_1).await.unwrap(), // &[Contact::Accepted { // user_id: user_2, // should_notify: true, // busy: false, // }], // ); // assert!(db.has_contact(user_1, user_2).await.unwrap()); // assert!(db.has_contact(user_2, user_1).await.unwrap()); // assert_eq!( // db.get_contacts(user_2).await.unwrap(), // &[Contact::Accepted { // user_id: user_1, // should_notify: false, // busy: false, // }] // ); // // Users cannot re-request existing contacts. // db.send_contact_request(user_1, user_2).await.unwrap_err(); // db.send_contact_request(user_2, user_1).await.unwrap_err(); // // Users can't dismiss notifications of them accepting other users' requests. // db.dismiss_contact_notification(user_2, user_1) // .await // .unwrap_err(); // assert_eq!( // db.get_contacts(user_1).await.unwrap(), // &[Contact::Accepted { // user_id: user_2, // should_notify: true, // busy: false, // }] // ); // // Users can dismiss notifications of other users accepting their requests. // db.dismiss_contact_notification(user_1, user_2) // .await // .unwrap(); // assert_eq!( // db.get_contacts(user_1).await.unwrap(), // &[Contact::Accepted { // user_id: user_2, // should_notify: false, // busy: false, // }] // ); // // Users send each other concurrent contact requests and // // see that they are immediately accepted. // db.send_contact_request(user_1, user_3).await.unwrap(); // db.send_contact_request(user_3, user_1).await.unwrap(); // assert_eq!( // db.get_contacts(user_1).await.unwrap(), // &[ // Contact::Accepted { // user_id: user_2, // should_notify: false, // busy: false, // }, // Contact::Accepted { // user_id: user_3, // should_notify: false, // busy: false, // } // ] // ); // assert_eq!( // db.get_contacts(user_3).await.unwrap(), // &[Contact::Accepted { // user_id: user_1, // should_notify: false, // busy: false, // }], // ); // // User declines a contact request. Both users see that it is gone. // db.send_contact_request(user_2, user_3).await.unwrap(); // db.respond_to_contact_request(user_3, user_2, false) // .await // .unwrap(); // assert!(!db.has_contact(user_2, user_3).await.unwrap()); // assert!(!db.has_contact(user_3, user_2).await.unwrap()); // assert_eq!( // db.get_contacts(user_2).await.unwrap(), // &[Contact::Accepted { // user_id: user_1, // should_notify: false, // busy: false, // }] // ); // assert_eq!( // db.get_contacts(user_3).await.unwrap(), // &[Contact::Accepted { // user_id: user_1, // should_notify: false, // busy: false, // }], // ); // }); // test_both_dbs!(test_metrics_id_postgres, test_metrics_id_sqlite, db, { // let NewUserResult { // user_id: user1, // metrics_id: metrics_id1, // .. // } = db // .create_user( // "person1@example.com", // false, // NewUserParams { // github_login: "person1".into(), // github_user_id: 101, // invite_count: 5, // }, // ) // .await // .unwrap(); // let NewUserResult { // user_id: user2, // metrics_id: metrics_id2, // .. // } = db // .create_user( // "person2@example.com", // false, // NewUserParams { // github_login: "person2".into(), // github_user_id: 102, // invite_count: 5, // }, // ) // .await // .unwrap(); // assert_eq!(db.get_user_metrics_id(user1).await.unwrap(), metrics_id1); // assert_eq!(db.get_user_metrics_id(user2).await.unwrap(), metrics_id2); // assert_eq!(metrics_id1.len(), 36); // assert_eq!(metrics_id2.len(), 36); // assert_ne!(metrics_id1, metrics_id2); // }); // #[test] // fn test_fuzzy_like_string() { // assert_eq!(DefaultDb::fuzzy_like_string("abcd"), "%a%b%c%d%"); // assert_eq!(DefaultDb::fuzzy_like_string("x y"), "%x%y%"); // assert_eq!(DefaultDb::fuzzy_like_string(" z "), "%z%"); // } // #[gpui::test] // async fn test_fuzzy_search_users() { // let test_db = PostgresTestDb::new(build_background_executor()); // let db = test_db.db(); // for (i, github_login) in [ // "California", // "colorado", // "oregon", // "washington", // "florida", // "delaware", // "rhode-island", // ] // .into_iter() // .enumerate() // { // db.create_user( // &format!("{github_login}@example.com"), // false, // NewUserParams { // github_login: github_login.into(), // github_user_id: i as i32, // invite_count: 0, // }, // ) // .await // .unwrap(); // } // assert_eq!( // fuzzy_search_user_names(db, "clr").await, // &["colorado", "California"] // ); // assert_eq!( // fuzzy_search_user_names(db, "ro").await, // &["rhode-island", "colorado", "oregon"], // ); // async fn fuzzy_search_user_names(db: &Db, query: &str) -> Vec { // db.fuzzy_search_users(query, 10) // .await // .unwrap() // .into_iter() // .map(|user| user.github_login) // .collect::>() // } // } // #[gpui::test] // async fn test_invite_codes() { // let test_db = PostgresTestDb::new(build_background_executor()); // let db = test_db.db(); // let NewUserResult { user_id: user1, .. } = db // .create_user( // "user1@example.com", // false, // NewUserParams { // github_login: "user1".into(), // github_user_id: 0, // invite_count: 0, // }, // ) // .await // .unwrap(); // // Initially, user 1 has no invite code // assert_eq!(db.get_invite_code_for_user(user1).await.unwrap(), None); // // Setting invite count to 0 when no code is assigned does not assign a new code // db.set_invite_count_for_user(user1, 0).await.unwrap(); // assert!(db.get_invite_code_for_user(user1).await.unwrap().is_none()); // // User 1 creates an invite code that can be used twice. // db.set_invite_count_for_user(user1, 2).await.unwrap(); // let (invite_code, invite_count) = db.get_invite_code_for_user(user1).await.unwrap().unwrap(); // assert_eq!(invite_count, 2); // // User 2 redeems the invite code and becomes a contact of user 1. // let user2_invite = db // .create_invite_from_code(&invite_code, "user2@example.com", Some("user-2-device-id")) // .await // .unwrap(); // let NewUserResult { // user_id: user2, // inviting_user_id, // signup_device_id, // metrics_id, // } = db // .create_user_from_invite( // &user2_invite, // NewUserParams { // github_login: "user2".into(), // github_user_id: 2, // invite_count: 7, // }, // ) // .await // .unwrap() // .unwrap(); // let (_, invite_count) = db.get_invite_code_for_user(user1).await.unwrap().unwrap(); // assert_eq!(invite_count, 1); // assert_eq!(inviting_user_id, Some(user1)); // assert_eq!(signup_device_id.unwrap(), "user-2-device-id"); // assert_eq!(db.get_user_metrics_id(user2).await.unwrap(), metrics_id); // assert_eq!( // db.get_contacts(user1).await.unwrap(), // [Contact::Accepted { // user_id: user2, // should_notify: true, // busy: false, // }] // ); // assert_eq!( // db.get_contacts(user2).await.unwrap(), // [Contact::Accepted { // user_id: user1, // should_notify: false, // busy: false, // }] // ); // assert_eq!( // db.get_invite_code_for_user(user2).await.unwrap().unwrap().1, // 7 // ); // // User 3 redeems the invite code and becomes a contact of user 1. // let user3_invite = db // .create_invite_from_code(&invite_code, "user3@example.com", None) // .await // .unwrap(); // let NewUserResult { // user_id: user3, // inviting_user_id, // signup_device_id, // .. // } = db // .create_user_from_invite( // &user3_invite, // NewUserParams { // github_login: "user-3".into(), // github_user_id: 3, // invite_count: 3, // }, // ) // .await // .unwrap() // .unwrap(); // let (_, invite_count) = db.get_invite_code_for_user(user1).await.unwrap().unwrap(); // assert_eq!(invite_count, 0); // assert_eq!(inviting_user_id, Some(user1)); // assert!(signup_device_id.is_none()); // assert_eq!( // db.get_contacts(user1).await.unwrap(), // [ // Contact::Accepted { // user_id: user2, // should_notify: true, // busy: false, // }, // Contact::Accepted { // user_id: user3, // should_notify: true, // busy: false, // } // ] // ); // assert_eq!( // db.get_contacts(user3).await.unwrap(), // [Contact::Accepted { // user_id: user1, // should_notify: false, // busy: false, // }] // ); // assert_eq!( // db.get_invite_code_for_user(user3).await.unwrap().unwrap().1, // 3 // ); // // Trying to reedem the code for the third time results in an error. // db.create_invite_from_code(&invite_code, "user4@example.com", Some("user-4-device-id")) // .await // .unwrap_err(); // // Invite count can be updated after the code has been created. // db.set_invite_count_for_user(user1, 2).await.unwrap(); // let (latest_code, invite_count) = db.get_invite_code_for_user(user1).await.unwrap().unwrap(); // assert_eq!(latest_code, invite_code); // Invite code doesn't change when we increment above 0 // assert_eq!(invite_count, 2); // // User 4 can now redeem the invite code and becomes a contact of user 1. // let user4_invite = db // .create_invite_from_code(&invite_code, "user4@example.com", Some("user-4-device-id")) // .await // .unwrap(); // let user4 = db // .create_user_from_invite( // &user4_invite, // NewUserParams { // github_login: "user-4".into(), // github_user_id: 4, // invite_count: 5, // }, // ) // .await // .unwrap() // .unwrap() // .user_id; // let (_, invite_count) = db.get_invite_code_for_user(user1).await.unwrap().unwrap(); // assert_eq!(invite_count, 1); // assert_eq!( // db.get_contacts(user1).await.unwrap(), // [ // Contact::Accepted { // user_id: user2, // should_notify: true, // busy: false, // }, // Contact::Accepted { // user_id: user3, // should_notify: true, // busy: false, // }, // Contact::Accepted { // user_id: user4, // should_notify: true, // busy: false, // } // ] // ); // assert_eq!( // db.get_contacts(user4).await.unwrap(), // [Contact::Accepted { // user_id: user1, // should_notify: false, // busy: false, // }] // ); // assert_eq!( // db.get_invite_code_for_user(user4).await.unwrap().unwrap().1, // 5 // ); // // An existing user cannot redeem invite codes. // db.create_invite_from_code(&invite_code, "user2@example.com", Some("user-2-device-id")) // .await // .unwrap_err(); // let (_, invite_count) = db.get_invite_code_for_user(user1).await.unwrap().unwrap(); // assert_eq!(invite_count, 1); // } // #[gpui::test] // async fn test_signups() { // let test_db = PostgresTestDb::new(build_background_executor()); // let db = test_db.db(); // // people sign up on the waitlist // for i in 0..8 { // db.create_signup(Signup { // email_address: format!("person-{i}@example.com"), // platform_mac: true, // platform_linux: i % 2 == 0, // platform_windows: i % 4 == 0, // editor_features: vec!["speed".into()], // programming_languages: vec!["rust".into(), "c".into()], // device_id: Some(format!("device_id_{i}")), // }) // .await // .unwrap(); // } // assert_eq!( // db.get_waitlist_summary().await.unwrap(), // WaitlistSummary { // count: 8, // mac_count: 8, // linux_count: 4, // windows_count: 2, // unknown_count: 0, // } // ); // // retrieve the next batch of signup emails to send // let signups_batch1 = db.get_unsent_invites(3).await.unwrap(); // let addresses = signups_batch1 // .iter() // .map(|s| &s.email_address) // .collect::>(); // assert_eq!( // addresses, // &[ // "person-0@example.com", // "person-1@example.com", // "person-2@example.com" // ] // ); // assert_ne!( // signups_batch1[0].email_confirmation_code, // signups_batch1[1].email_confirmation_code // ); // // the waitlist isn't updated until we record that the emails // // were successfully sent. // let signups_batch = db.get_unsent_invites(3).await.unwrap(); // assert_eq!(signups_batch, signups_batch1); // // once the emails go out, we can retrieve the next batch // // of signups. // db.record_sent_invites(&signups_batch1).await.unwrap(); // let signups_batch2 = db.get_unsent_invites(3).await.unwrap(); // let addresses = signups_batch2 // .iter() // .map(|s| &s.email_address) // .collect::>(); // assert_eq!( // addresses, // &[ // "person-3@example.com", // "person-4@example.com", // "person-5@example.com" // ] // ); // // the sent invites are excluded from the summary. // assert_eq!( // db.get_waitlist_summary().await.unwrap(), // WaitlistSummary { // count: 5, // mac_count: 5, // linux_count: 2, // windows_count: 1, // unknown_count: 0, // } // ); // // user completes the signup process by providing their // // github account. // let NewUserResult { // user_id, // inviting_user_id, // signup_device_id, // .. // } = db // .create_user_from_invite( // &Invite { // email_address: signups_batch1[0].email_address.clone(), // email_confirmation_code: signups_batch1[0].email_confirmation_code.clone(), // }, // NewUserParams { // github_login: "person-0".into(), // github_user_id: 0, // invite_count: 5, // }, // ) // .await // .unwrap() // .unwrap(); // let user = db.get_user_by_id(user_id).await.unwrap().unwrap(); // assert!(inviting_user_id.is_none()); // assert_eq!(user.github_login, "person-0"); // assert_eq!(user.email_address.as_deref(), Some("person-0@example.com")); // assert_eq!(user.invite_count, 5); // assert_eq!(signup_device_id.unwrap(), "device_id_0"); // // cannot redeem the same signup again. // assert!(db // .create_user_from_invite( // &Invite { // email_address: signups_batch1[0].email_address.clone(), // email_confirmation_code: signups_batch1[0].email_confirmation_code.clone(), // }, // NewUserParams { // github_login: "some-other-github_account".into(), // github_user_id: 1, // invite_count: 5, // }, // ) // .await // .unwrap() // .is_none()); // // cannot redeem a signup with the wrong confirmation code. // db.create_user_from_invite( // &Invite { // email_address: signups_batch1[1].email_address.clone(), // email_confirmation_code: "the-wrong-code".to_string(), // }, // NewUserParams { // github_login: "person-1".into(), // github_user_id: 2, // invite_count: 5, // }, // ) // .await // .unwrap_err(); // } fn build_background_executor() -> Arc { Deterministic::new(0).build_background() }