chore(repo): prune dead code and duplicate abstractions (#3413)

fluxer_users/src/shard_impl.rs

@@ -1,9 +1,13 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
-use crate::types::{ApiUserPartial, User, UserPartial, UserRequest, UserResponse, now_ms};
+use crate::types::{ApiUserPartial, UserPartial, UserRequest, UserResponse};
 #[cfg(feature = "scylla")]
 use chrono::{DateTime, Utc};
-use fluxer_common::user_flags::AccountStanding;
+use fluxer_common::time::unix_millis;
+use fluxer_common::user_flags::{AccountStanding, USER_FLAG_STAFF};
+use fluxer_common::user_partial::{
+    FLUXER_SYSTEM_DISCRIMINATOR, FLUXER_SYSTEM_USER_ID, FLUXER_SYSTEM_USERNAME,
+};
 use fluxer_svc::shard::ShardService;
 use fluxer_svc::{postgres, postgres::KeyPart};
 use futures::stream::{self, StreamExt};
@@ -39,10 +43,6 @@ const USER_BATCH_SIZE: usize = 128;
 const USER_BATCH_CONCURRENCY: usize = 8;
 const USER_CACHE_MIN_GENERATION_STRIPES: usize = 4096;
 const USER_CACHE_MAX_GENERATION_STRIPES: usize = 1 << 20;
-const FLUXER_SYSTEM_USER_ID: i64 = 0;
-const FLUXER_SYSTEM_USERNAME: &str = "Fluxer";
-const FLUXER_SYSTEM_DISCRIMINATOR: i32 = 0;
-const USER_FLAG_STAFF: i64 = 1;
 
 pub struct UsersShard {
     storage: UsersStorage,
@@ -80,7 +80,7 @@ struct ScyllaUsersStorage {
     stmt_partial_batch: PreparedStatement,
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 struct PartialUserDbRow {
     user_id: i64,
     username: String,
@@ -264,7 +264,7 @@ impl UsersShard {
 
     async fn get_partial_user(&self, user_id: i64) -> anyhow::Result<Option<UserPartial>> {
         if user_id == FLUXER_SYSTEM_USER_ID {
-            return Ok(Some(fluxer_system_user().to_partial()));
+            return Ok(Some(system_user_partial()));
         }
         self.caches
             .get_or_fetch_partial(user_id, self.storage.fetch_partial_user(user_id))
@@ -278,7 +278,7 @@ impl UsersShard {
         let mut misses = Vec::new();
         for user_id in user_ids {
             if user_id == FLUXER_SYSTEM_USER_ID {
-                partials.push(fluxer_system_user().to_partial());
+                partials.push(system_user_partial());
                 continue;
             }
             match self.caches.get_partial(user_id).await {
@@ -452,64 +452,21 @@ fn decode_postgres_user_partial(row: serde_json::Value) -> anyhow::Result<UserPa
     Ok(row.into())
 }
 
-fn fluxer_system_user() -> User {
-    User {
+fn system_user_partial() -> UserPartial {
+    UserPartial {
         user_id: FLUXER_SYSTEM_USER_ID,
         username: FLUXER_SYSTEM_USERNAME.to_owned(),
         discriminator: FLUXER_SYSTEM_DISCRIMINATOR,
+        global_name: None,
+        avatar_hash: None,
         bot: Some(true),
         system: Some(true),
-        email: None,
-        email_verified: None,
-        email_bounced: None,
-        authenticator_types: Vec::new(),
-        avatar_hash: None,
-        avatar_color: None,
+        flags: Some(USER_FLAG_STAFF),
         banner_hash: None,
         banner_color: None,
-        bio: None,
         accent_color: None,
-        date_of_birth: None,
-        locale: None,
-        flags: Some(USER_FLAG_STAFF),
-        premium_flags: None,
-        global_name: None,
-        pronouns: None,
-        traits: Vec::new(),
-        premium_type: None,
-        premium_since: None,
-        premium_until: None,
-        premium_gift_extension_ends_at: None,
-        premium_lifetime_sequence: None,
-        premium_billing_cycle: None,
-        premium_will_cancel: None,
-        premium_onboarding_dismissed_at: None,
-        has_ever_purchased: None,
-        stripe_subscription_id: None,
-        stripe_customer_id: None,
-        gift_inventory_server_seq: None,
-        gift_inventory_client_seq: None,
-        terms_agreed_at: None,
-        privacy_agreed_at: None,
-        last_active_at: None,
-        last_active_ip: None,
-        temp_banned_until: None,
-        pending_deletion_at: None,
-        pending_bulk_message_deletion_at: None,
-        pending_bulk_message_deletion_channel_count: None,
-        pending_bulk_message_deletion_message_count: None,
-        password_last_changed_at: None,
-        acls: Vec::new(),
-        deletion_reason_code: None,
-        deletion_public_reason: None,
-        deletion_audit_log_reason: None,
-        first_refund_at: None,
-        version: 1,
-        premium_grace_ends_at: None,
+        avatar_color: None,
         mention_flags: None,
-        last_voice_activity_sharing_change_at: None,
-        timezone: None,
-        timezone_privacy_flags: None,
         content_hidden_since: None,
     }
 }
@@ -597,7 +554,7 @@ impl From<PartialUserDbRow> for UserPartial {
             mention_flags: row.mention_flags,
             content_hidden_since: row.content_hidden_since,
         }
-        .visible_to_others(&standing, now_ms())
+        .visible_to_others(&standing, unix_millis())
     }
 }
 
@@ -606,54 +563,43 @@ mod tests {
     use super::*;
     use serde_json::json;
 
-    fn test_user(user_id: i64) -> User {
-        let mut user = fluxer_system_user();
-        user.user_id = user_id;
-        user.username = "Ada".to_owned();
-        user.discriminator = 7;
-        user.global_name = Some("Ada Lovelace".to_owned());
-        user.avatar_hash = Some("avatar_hash".to_owned());
-        user.bot = Some(false);
-        user.system = Some(false);
-        user.email = Some("[email protected]".to_owned());
-        user.bio = Some("analytical engine enjoyer".to_owned());
-        user.stripe_customer_id = Some("cus_123".to_owned());
-        user
+    fn test_user(user_id: i64) -> PartialUserDbRow {
+        PartialUserDbRow {
+            user_id,
+            username: "Ada".to_owned(),
+            discriminator: 7,
+            global_name: Some("Ada Lovelace".to_owned()),
+            avatar_hash: Some("avatar_hash".to_owned()),
+            bot: Some(false),
+            system: Some(false),
+            flags: Some(USER_FLAG_STAFF),
+            banner_hash: None,
+            banner_color: None,
+            accent_color: None,
+            avatar_color: None,
+            mention_flags: None,
+            temp_banned_until: None,
+            pending_deletion_at: None,
+            deletion_reason_code: None,
+            content_hidden_since: None,
+        }
     }
 
     fn caches() -> UserCaches {
         UserCaches::new(16, Duration::from_secs(60))
     }
 
-    #[tokio::test]
-    async fn partial_reads_populate_only_the_partial_cache() {
-        let caches = caches();
-        let partial = test_user(42).to_partial();
-
-        let fetched = caches
-            .get_or_fetch_partial(42, async { Ok(Some(partial)) })
-            .await
-            .unwrap()
-            .unwrap();
-
-        assert_eq!(fetched.username, "Ada");
-        assert_eq!(
-            caches.get_partial(42).await.unwrap().unwrap().username,
-            "Ada"
-        );
-    }
-
     #[tokio::test]
     async fn partial_cache_hits_do_not_reach_storage_again() {
         let caches = caches();
-        let partial = test_user(42).to_partial();
+        let partial = UserPartial::from(test_user(42));
         caches
             .get_or_fetch_partial(42, async { Ok(Some(partial)) })
             .await
             .unwrap();
 
         let fetched = caches
-            .get_or_fetch_partial(42, async { Ok(Some(test_user(7).to_partial())) })
+            .get_or_fetch_partial(42, async { Ok(Some(UserPartial::from(test_user(7)))) })
             .await
             .unwrap()
             .unwrap();
@@ -665,7 +611,7 @@ mod tests {
     async fn invalidation_clears_a_partial_only_entry() {
         let caches = caches();
         caches
-            .get_or_fetch_partial(42, async { Ok(Some(test_user(42).to_partial())) })
+            .get_or_fetch_partial(42, async { Ok(Some(UserPartial::from(test_user(42)))) })
             .await
             .unwrap();
 
@@ -674,27 +620,6 @@ mod tests {
         assert!(caches.get_partial(42).await.is_none());
     }
 
-    #[tokio::test]
-    async fn invalidation_counts_generation_bumps() {
-        let caches = caches();
-        assert_eq!(caches.generation_bumps.load(Ordering::Relaxed), 0);
-
-        caches.invalidate(42).await;
-        caches.invalidate(43).await;
-
-        assert_eq!(caches.generation_bumps.load(Ordering::Relaxed), 2);
-    }
-
-    #[test]
-    fn generation_stripes_follow_the_configured_capacity() {
-        assert_eq!(generation_stripes(16), USER_CACHE_MIN_GENERATION_STRIPES);
-        assert_eq!(generation_stripes(100_000), 131_072);
-        assert_eq!(
-            generation_stripes(u64::MAX),
-            USER_CACHE_MAX_GENERATION_STRIPES
-        );
-    }
-
     #[cfg(feature = "scylla")]
     #[test]
     fn partial_columns_match_the_user_partial_fields_exactly() {
@@ -706,7 +631,7 @@ mod tests {
             .collect::<BTreeSet<_>>();
         let mut user = test_user(42);
         user.content_hidden_since = Some(1);
-        let partial = serde_json::to_value(user.to_partial()).unwrap();
+        let partial = serde_json::to_value(UserPartial::from(user.clone())).unwrap();
         let mut fields = partial
             .as_object()
             .unwrap()
@@ -724,7 +649,7 @@ mod tests {
 
     #[test]
     fn fluxer_system_user_partial_is_virtual_id_zero() {
-        let partial = fluxer_system_user().to_partial();
+        let partial = system_user_partial();
 
         assert_eq!(partial.user_id, 0);
         assert_eq!(partial.username, "Fluxer");
@@ -741,7 +666,7 @@ mod tests {
     const DISABLED: i64 = 1 << 38;
     const PROFILE_HIDDEN: i64 = 1 << 7;
 
-    fn styled(user_id: i64, flags: i64) -> User {
+    fn styled(user_id: i64, flags: i64) -> PartialUserDbRow {
         let mut user = test_user(user_id);
         user.flags = Some(flags);
         user.banner_hash = Some("banner_hash".to_owned());
@@ -770,9 +695,7 @@ mod tests {
 
     #[test]
     fn a_masked_partial_matches_the_shared_development_vector() {
-        let api = styled(1_174_109_840_998_400_001, SPAMMER)
-            .to_partial()
-            .to_api_partial();
+        let api = UserPartial::from(styled(1_174_109_840_998_400_001, SPAMMER)).to_api_partial();
         assert_eq!(
             (api.username.as_str(), api.discriminator.as_str()),
             ("MambaEgret", "6542")
@@ -782,19 +705,9 @@ mod tests {
         assert_eq!(api.avatar, None);
     }
 
-    #[test]
-    fn a_masked_partial_is_stable_across_reads() {
-        let first = styled(53, PROFILE_HIDDEN).to_partial();
-        let second = styled(53, PROFILE_HIDDEN).to_partial();
-        assert_eq!(
-            (first.username, first.discriminator),
-            (second.username, second.discriminator)
-        );
-    }
-
     #[test]
     fn hidden_and_enforced_accounts_get_a_neutral_partial_and_keep_their_stored_profile() {
-        let now = now_ms();
+        let now = unix_millis();
         let mut banned = styled(43, DISABLED);
         banned.temp_banned_until = Some(now + 60_000);
         let mut deleting = styled(44, 0);
@@ -806,7 +719,7 @@ mod tests {
             banned,
             deleting,
         ] {
-            assert_hidden(&user.to_partial());
+            assert_hidden(&UserPartial::from(user.clone()));
             assert_eq!(user.username, "Ada");
             assert_eq!(user.avatar_hash.as_deref(), Some("avatar_hash"));
         }
@@ -814,14 +727,14 @@ mod tests {
 
     #[test]
     fn lifted_bans_self_disables_and_normal_accounts_keep_their_partial() {
-        let now = now_ms();
+        let now = unix_millis();
         let mut expired = styled(45, DISABLED);
         expired.temp_banned_until = Some(now - 60_000);
         let mut self_deleting = styled(46, 0);
         self_deleting.pending_deletion_at = Some(now + 60_000);
         self_deleting.deletion_reason_code = Some(1);
         for user in [styled(47, 0), styled(48, DISABLED), expired, self_deleting] {
-            let partial = user.to_partial();
+            let partial = UserPartial::from(user.clone());
             assert_eq!(partial.username, "Ada", "{}", user.user_id);
             assert_eq!(partial.global_name.as_deref(), Some("Ada Lovelace"));
             assert_eq!(partial.banner_hash.as_deref(), Some("banner_hash"));
@@ -847,7 +760,7 @@ mod tests {
                 "temp_banned_until": until(ms),
             })
         };
-        let now = now_ms();
+        let now = unix_millis();
         assert_hidden(&decode_postgres_user_partial(row(now + 60_000)).unwrap());
         let lifted = decode_postgres_user_partial(row(now - 60_000)).unwrap();
         assert_eq!(lifted.username, "ada");
@@ -859,22 +772,22 @@ mod tests {
         let since = 1_790_000_000_000;
         let mut hidden = styled(49, 0);
         hidden.content_hidden_since = Some(since);
-        let partial = hidden.to_partial();
+        let partial = UserPartial::from(hidden.clone());
         assert_eq!(partial.content_hidden_since, Some(since));
         assert_eq!(partial.username, "Ada");
         let mut masked = styled(50, PROFILE_HIDDEN);
         masked.content_hidden_since = Some(since);
-        let partial = masked.to_partial();
+        let partial = UserPartial::from(masked.clone());
         assert_hidden(&partial);
         assert_eq!(partial.content_hidden_since, Some(since));
         assert_eq!(
-            styled(51, PROFILE_HIDDEN).to_partial().content_hidden_since,
+            UserPartial::from(styled(51, PROFILE_HIDDEN)).content_hidden_since,
             None
         );
-        let wire = serde_json::to_value(styled(52, 0).to_partial()).unwrap();
+        let wire = serde_json::to_value(UserPartial::from(styled(52, 0))).unwrap();
         assert!(wire.get("content_hidden_since").is_none());
         assert!(
-            serde_json::to_value(hidden.to_partial().to_api_partial())
+            serde_json::to_value(UserPartial::from(hidden.clone()).to_api_partial())
                 .unwrap()
                 .get("content_hidden_since")
                 .is_none()

fluxer_users/src/types.rs

@@ -1,9 +1,15 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
 use crate::pseudonym::pseudonym;
-use fluxer_common::user_flags::{AccountStanding, USER_FLAG_STAFF, visible_user_flags};
+use fluxer_common::user_flags::AccountStanding;
+#[cfg(test)]
+use fluxer_common::user_flags::USER_FLAG_STAFF;
 #[cfg(test)]
 use fluxer_common::user_flags::{USER_FLAG_PARTNER, USER_FLAG_STAFF_HIDDEN};
+pub use fluxer_common::user_partial::ApiUserPartial;
+#[cfg(test)]
+use fluxer_common::user_partial::FLUXER_SYSTEM_USERNAME;
+use fluxer_common::user_partial::{FLUXER_SYSTEM_USER_ID, UserPartialFields};
 use serde::{Deserialize, Deserializer, Serialize};
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -26,72 +32,9 @@ pub enum UserRequest {
 pub enum UserResponse {
     FoundPartials(Vec<UserPartial>),
     FoundApiPartials(Vec<ApiUserPartial>),
-    NotFound,
     Invalidated,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct User {
-    pub user_id: i64,
-    pub username: String,
-    pub discriminator: i32,
-    pub bot: Option<bool>,
-    pub system: Option<bool>,
-    pub email: Option<String>,
-    pub email_verified: Option<bool>,
-    pub email_bounced: Option<bool>,
-    pub authenticator_types: Vec<i32>,
-    pub avatar_hash: Option<String>,
-    pub avatar_color: Option<i32>,
-    pub banner_hash: Option<String>,
-    pub banner_color: Option<i32>,
-    pub bio: Option<String>,
-    pub accent_color: Option<i32>,
-    pub date_of_birth: Option<String>,
-    pub locale: Option<String>,
-    pub flags: Option<i64>,
-    pub premium_flags: Option<i32>,
-    pub global_name: Option<String>,
-    pub pronouns: Option<String>,
-    pub traits: Vec<String>,
-    pub premium_type: Option<i32>,
-    pub premium_since: Option<i64>,
-    pub premium_until: Option<i64>,
-    pub premium_gift_extension_ends_at: Option<i64>,
-    pub premium_lifetime_sequence: Option<i32>,
-    pub premium_billing_cycle: Option<String>,
-    pub premium_will_cancel: Option<bool>,
-    pub premium_onboarding_dismissed_at: Option<i64>,
-    pub has_ever_purchased: Option<bool>,
-    pub stripe_subscription_id: Option<String>,
-    pub stripe_customer_id: Option<String>,
-    pub gift_inventory_server_seq: Option<i32>,
-    pub gift_inventory_client_seq: Option<i32>,
-    pub terms_agreed_at: Option<i64>,
-    pub privacy_agreed_at: Option<i64>,
-    pub last_active_at: Option<i64>,
-    pub last_active_ip: Option<String>,
-    pub temp_banned_until: Option<i64>,
-    pub pending_deletion_at: Option<i64>,
-    pub pending_bulk_message_deletion_at: Option<i64>,
-    pub pending_bulk_message_deletion_channel_count: Option<i32>,
-    pub pending_bulk_message_deletion_message_count: Option<i32>,
-    pub password_last_changed_at: Option<i64>,
-    pub acls: Vec<String>,
-    pub deletion_reason_code: Option<i32>,
-    pub deletion_public_reason: Option<String>,
-    pub deletion_audit_log_reason: Option<String>,
-    pub first_refund_at: Option<i64>,
-    pub version: i32,
-    pub premium_grace_ends_at: Option<i64>,
-    pub mention_flags: Option<i32>,
-    pub last_voice_activity_sharing_change_at: Option<i64>,
-    pub timezone: Option<String>,
-    pub timezone_privacy_flags: Option<i32>,
-    #[serde(default)]
-    pub content_hidden_since: Option<i64>,
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct UserPartial {
     pub user_id: i64,
@@ -111,68 +54,6 @@ pub struct UserPartial {
     pub content_hidden_since: Option<i64>,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ApiUserPartial {
-    pub id: String,
-    pub username: String,
-    pub discriminator: String,
-    pub global_name: Option<String>,
-    pub avatar: Option<String>,
-    pub avatar_color: Option<i32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub bot: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub system: Option<bool>,
-    pub flags: i32,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub mention_flags: Option<i32>,
-}
-
-const FLUXER_SYSTEM_USER_ID: i64 = 0;
-const FLUXER_SYSTEM_USERNAME: &str = "Fluxer";
-const FLUXER_SYSTEM_DISCRIMINATOR: &str = "0000";
-
-pub fn now_ms() -> i64 {
-    std::time::SystemTime::now()
-        .duration_since(std::time::UNIX_EPOCH)
-        .map_or(0, |d| d.as_millis() as i64)
-}
-
-impl User {
-    pub fn standing(&self) -> AccountStanding {
-        AccountStanding {
-            flags: self.flags.unwrap_or_default(),
-            temp_banned_until_ms: self.temp_banned_until,
-            pending_deletion_at_ms: self.pending_deletion_at,
-            deletion_reason_code: self.deletion_reason_code,
-        }
-    }
-
-    pub fn to_partial(&self) -> UserPartial {
-        self.to_own_partial()
-            .visible_to_others(&self.standing(), now_ms())
-    }
-
-    fn to_own_partial(&self) -> UserPartial {
-        UserPartial {
-            user_id: self.user_id,
-            username: self.username.clone(),
-            discriminator: self.discriminator,
-            global_name: self.global_name.clone(),
-            avatar_hash: self.avatar_hash.clone(),
-            bot: self.bot,
-            system: self.system,
-            flags: self.flags,
-            banner_hash: self.banner_hash.clone(),
-            banner_color: self.banner_color,
-            accent_color: self.accent_color,
-            avatar_color: self.avatar_color,
-            mention_flags: self.mention_flags,
-            content_hidden_since: self.content_hidden_since,
-        }
-    }
-}
-
 impl UserPartial {
     pub fn visible_to_others(self, standing: &AccountStanding, now_ms: i64) -> UserPartial {
         if self.user_id == FLUXER_SYSTEM_USER_ID || !standing.profile_hidden(now_ms) {
@@ -193,36 +74,18 @@ impl UserPartial {
     }
 
     pub fn to_api_partial(&self) -> ApiUserPartial {
-        if self.user_id == FLUXER_SYSTEM_USER_ID {
-            return fluxer_system_user();
-        }
-        ApiUserPartial {
-            id: self.user_id.to_string(),
+        ApiUserPartial::from(UserPartialFields {
+            user_id: self.user_id,
             username: self.username.clone(),
-            discriminator: format!("{:04}", self.discriminator),
+            discriminator: self.discriminator,
             global_name: self.global_name.clone(),
-            avatar: self.avatar_hash.clone(),
+            avatar_hash: self.avatar_hash.clone(),
             avatar_color: self.avatar_color,
-            bot: self.bot.filter(|bot| *bot),
-            system: self.system.filter(|system| *system),
-            flags: visible_user_flags(self.flags.unwrap_or_default()),
-            mention_flags: self.mention_flags.filter(|flags| *flags != 0),
-        }
-    }
-}
-
-fn fluxer_system_user() -> ApiUserPartial {
-    ApiUserPartial {
-        id: FLUXER_SYSTEM_USER_ID.to_string(),
-        username: FLUXER_SYSTEM_USERNAME.to_owned(),
-        discriminator: FLUXER_SYSTEM_DISCRIMINATOR.to_owned(),
-        global_name: None,
-        avatar: None,
-        avatar_color: None,
-        bot: Some(true),
-        system: Some(true),
-        flags: USER_FLAG_STAFF as i32,
-        mention_flags: None,
+            bot: self.bot,
+            system: self.system,
+            flags: self.flags,
+            mention_flags: self.mention_flags,
+        })
     }
 }
 
@@ -269,86 +132,6 @@ mod tests {
         }
     }
 
-    fn user_with_flags(user_id: i64, flags: i64) -> User {
-        User {
-            user_id,
-            username: "Ada".to_owned(),
-            discriminator: 7,
-            bot: Some(false),
-            system: Some(false),
-            email: Some("[email protected]".to_owned()),
-            email_verified: Some(true),
-            email_bounced: Some(false),
-            authenticator_types: vec![1],
-            avatar_hash: Some("avatar_hash".to_owned()),
-            avatar_color: Some(0x336699),
-            banner_hash: Some("banner_hash".to_owned()),
-            banner_color: Some(0x112233),
-            bio: Some("analytical engine enjoyer".to_owned()),
-            accent_color: Some(0x445566),
-            date_of_birth: Some("1815-12-10".to_owned()),
-            locale: Some("en-US".to_owned()),
-            flags: Some(flags),
-            premium_flags: Some(1),
-            global_name: Some("Ada Lovelace".to_owned()),
-            pronouns: Some("she/her".to_owned()),
-            traits: vec!["founder".to_owned()],
-            premium_type: Some(2),
-            premium_since: Some(1_781_526_896_789),
-            premium_until: Some(1_781_526_896_789),
-            premium_gift_extension_ends_at: None,
-            premium_lifetime_sequence: None,
-            premium_billing_cycle: Some("monthly".to_owned()),
-            premium_will_cancel: Some(false),
-            premium_onboarding_dismissed_at: None,
-            has_ever_purchased: Some(true),
-            stripe_subscription_id: Some("sub_123".to_owned()),
-            stripe_customer_id: Some("cus_123".to_owned()),
-            gift_inventory_server_seq: Some(3),
-            gift_inventory_client_seq: Some(3),
-            terms_agreed_at: Some(1_781_526_896_789),
-            privacy_agreed_at: Some(1_781_526_896_789),
-            last_active_at: Some(1_781_526_896_789),
-            last_active_ip: Some("203.0.113.7".to_owned()),
-            temp_banned_until: None,
-            pending_deletion_at: None,
-            pending_bulk_message_deletion_at: None,
-            pending_bulk_message_deletion_channel_count: None,
-            pending_bulk_message_deletion_message_count: None,
-            password_last_changed_at: Some(1_781_526_896_789),
-            acls: vec!["admin".to_owned()],
-            deletion_reason_code: None,
-            deletion_public_reason: None,
-            deletion_audit_log_reason: None,
-            first_refund_at: None,
-            version: 3,
-            premium_grace_ends_at: None,
-            mention_flags: Some(2),
-            last_voice_activity_sharing_change_at: None,
-            timezone: Some("Europe/London".to_owned()),
-            timezone_privacy_flags: Some(1),
-            content_hidden_since: None,
-        }
-    }
-
-    #[test]
-    fn api_partial_ignores_fields_outside_the_partial() {
-        let mut user = user_with_flags(123, USER_FLAG_STAFF);
-        user.mention_flags = Some(0);
-        let api_partial = user.to_partial().to_api_partial();
-
-        assert_eq!(api_partial.id, "123");
-        assert_eq!(api_partial.username, "Ada");
-        assert_eq!(api_partial.discriminator, "0007");
-        assert_eq!(api_partial.global_name, Some("Ada Lovelace".to_owned()));
-        assert_eq!(api_partial.avatar, Some("avatar_hash".to_owned()));
-        assert_eq!(api_partial.avatar_color, Some(0x336699));
-        assert_eq!(api_partial.bot, None);
-        assert_eq!(api_partial.system, None);
-        assert_eq!(api_partial.flags, USER_FLAG_STAFF as i32);
-        assert_eq!(api_partial.mention_flags, None);
-    }
-
     #[test]
     fn api_partial_requests_use_string_snowflakes() {
         let request: UserRequest = serde_json::from_value(json!({