crates/db_schema/src/impls/actor_language.rs

   1 use crate::{
   2   diesel::JoinOnDsl,
   3   newtypes::{CommunityId, InstanceId, LanguageId, LocalUserId, SiteId},
   4   schema::{local_site, site, site_language},
   5   source::{
   6     actor_language::{
   7       CommunityLanguage,
   8       CommunityLanguageForm,
   9       LocalUserLanguage,
  10       LocalUserLanguageForm,
  11       SiteLanguage,
  12       SiteLanguageForm,
  13     },
  14     language::Language,
  15     site::Site,
  16   },
  17   utils::{get_conn, DbPool},
  18 };
  19 use diesel::{
  20   delete,
  21   dsl::{count, exists},
  22   insert_into,
  23   result::Error,
  24   select,
  25   ExpressionMethods,
  26   QueryDsl,
  27 };
  28 use diesel_async::{AsyncPgConnection, RunQueryDsl};
  29 use lemmy_utils::error::{LemmyError, LemmyErrorType};
  30 use tokio::sync::OnceCell;
  31
  32 pub const UNDETERMINED_ID: LanguageId = LanguageId(0);
  33
  34 impl LocalUserLanguage {
  35   pub async fn read(
  36     pool: &mut DbPool<'_>,
  37     for_local_user_id: LocalUserId,
  38   ) -> Result<Vec<LanguageId>, Error> {
  39     use crate::schema::local_user_language::dsl::{
  40       language_id,
  41       local_user_id,
  42       local_user_language,
  43     };
  44     let conn = &mut get_conn(pool).await?;
  45
  46     conn
  47       .build_transaction()
  48       .run(|conn| {
  49         Box::pin(async move {
  50           let langs = local_user_language
  51             .filter(local_user_id.eq(for_local_user_id))
  52             .order(language_id)
  53             .select(language_id)
  54             .get_results(conn)
  55             .await?;
  56           convert_read_languages(conn, langs).await
  57         }) as _
  58       })
  59       .await
  60   }
  61
  62   /// Update the user's languages.
  63   ///
  64   /// If no language_id vector is given, it will show all languages
  65   pub async fn update(
  66     pool: &mut DbPool<'_>,
  67     language_ids: Vec<LanguageId>,
  68     for_local_user_id: LocalUserId,
  69   ) -> Result<(), Error> {
  70     let conn = &mut get_conn(pool).await?;
  71     let mut lang_ids = convert_update_languages(conn, language_ids).await?;
  72
  73     // No need to update if languages are unchanged
  74     let current = LocalUserLanguage::read(&mut conn.into(), for_local_user_id).await?;
  75     if current == lang_ids {
  76       return Ok(());
  77     }
  78
  79     // TODO: Force enable undetermined language for all users. This is necessary because many posts
  80     //       don't have a language tag (e.g. those from other federated platforms), so Lemmy users
  81     //       won't see them if undetermined language is disabled.
  82     //       This hack can be removed once a majority of posts have language tags, or when it is
  83     //       clearer for new users that they need to enable undetermined language.
  84     //       See https://github.com/LemmyNet/lemmy-ui/issues/999
  85     if !lang_ids.contains(&UNDETERMINED_ID) {
  86       lang_ids.push(UNDETERMINED_ID);
  87     }
  88
  89     conn
  90       .build_transaction()
  91       .run(|conn| {
  92         Box::pin(async move {
  93           use crate::schema::local_user_language::dsl::{local_user_id, local_user_language};
  94           // Clear the current user languages
  95           delete(local_user_language.filter(local_user_id.eq(for_local_user_id)))
  96             .execute(conn)
  97             .await?;
  98
  99           for l in lang_ids {
 100             let form = LocalUserLanguageForm {
 101               local_user_id: for_local_user_id,
 102               language_id: l,
 103             };
 104             insert_into(local_user_language)
 105               .values(form)
 106               .get_result::<Self>(conn)
 107               .await?;
 108           }
 109           Ok(())
 110         }) as _
 111       })
 112       .await
 113   }
 114 }
 115
 116 impl SiteLanguage {
 117   pub async fn read_local_raw(pool: &mut DbPool<'_>) -> Result<Vec<LanguageId>, Error> {
 118     let conn = &mut get_conn(pool).await?;
 119     site::table
 120       .inner_join(local_site::table)
 121       .inner_join(site_language::table)
 122       .order(site_language::id)
 123       .select(site_language::language_id)
 124       .load(conn)
 125       .await
 126   }
 127
 128   pub async fn read(pool: &mut DbPool<'_>, for_site_id: SiteId) -> Result<Vec<LanguageId>, Error> {
 129     let conn = &mut get_conn(pool).await?;
 130     let langs = site_language::table
 131       .filter(site_language::site_id.eq(for_site_id))
 132       .order(site_language::language_id)
 133       .select(site_language::language_id)
 134       .load(conn)
 135       .await?;
 136
 137     convert_read_languages(conn, langs).await
 138   }
 139
 140   pub async fn update(
 141     pool: &mut DbPool<'_>,
 142     language_ids: Vec<LanguageId>,
 143     site: &Site,
 144   ) -> Result<(), Error> {
 145     let conn = &mut get_conn(pool).await?;
 146     let for_site_id = site.id;
 147     let instance_id = site.instance_id;
 148     let lang_ids = convert_update_languages(conn, language_ids).await?;
 149
 150     // No need to update if languages are unchanged
 151     let current = SiteLanguage::read(&mut conn.into(), site.id).await?;
 152     if current == lang_ids {
 153       return Ok(());
 154     }
 155
 156     conn
 157       .build_transaction()
 158       .run(|conn| {
 159         Box::pin(async move {
 160           use crate::schema::site_language::dsl::{site_id, site_language};
 161
 162           // Clear the current languages
 163           delete(site_language.filter(site_id.eq(for_site_id)))
 164             .execute(conn)
 165             .await?;
 166
 167           for l in lang_ids {
 168             let form = SiteLanguageForm {
 169               site_id: for_site_id,
 170               language_id: l,
 171             };
 172             insert_into(site_language)
 173               .values(form)
 174               .get_result::<Self>(conn)
 175               .await?;
 176           }
 177
 178           CommunityLanguage::limit_languages(conn, instance_id).await?;
 179
 180           Ok(())
 181         }) as _
 182       })
 183       .await
 184   }
 185 }
 186
 187 impl CommunityLanguage {
 188   /// Returns true if the given language is one of configured languages for given community
 189   pub async fn is_allowed_community_language(
 190     pool: &mut DbPool<'_>,
 191     for_language_id: Option<LanguageId>,
 192     for_community_id: CommunityId,
 193   ) -> Result<(), LemmyError> {
 194     use crate::schema::community_language::dsl::{community_id, community_language, language_id};
 195     let conn = &mut get_conn(pool).await?;
 196
 197     if let Some(for_language_id) = for_language_id {
 198       let is_allowed = select(exists(
 199         community_language
 200           .filter(language_id.eq(for_language_id))
 201           .filter(community_id.eq(for_community_id)),
 202       ))
 203       .get_result(conn)
 204       .await?;
 205
 206       if is_allowed {
 207         Ok(())
 208       } else {
 209         Err(LemmyErrorType::LanguageNotAllowed)?
 210       }
 211     } else {
 212       Ok(())
 213     }
 214   }
 215
 216   /// When site languages are updated, delete all languages of local communities which are not
 217   /// also part of site languages. This is because post/comment language is only checked against
 218   /// community language, and it shouldnt be possible to post content in languages which are not
 219   /// allowed by local site.
 220   async fn limit_languages(
 221     conn: &mut AsyncPgConnection,
 222     for_instance_id: InstanceId,
 223   ) -> Result<(), Error> {
 224     use crate::schema::{
 225       community::dsl as c,
 226       community_language::dsl as cl,
 227       site_language::dsl as sl,
 228     };
 229     let community_languages: Vec<LanguageId> = cl::community_language
 230       .left_outer_join(sl::site_language.on(cl::language_id.eq(sl::language_id)))
 231       .inner_join(c::community)
 232       .filter(c::instance_id.eq(for_instance_id))
 233       .filter(sl::language_id.is_null())
 234       .select(cl::language_id)
 235       .get_results(conn)
 236       .await?;
 237
 238     for c in community_languages {
 239       delete(cl::community_language.filter(cl::language_id.eq(c)))
 240         .execute(conn)
 241         .await?;
 242     }
 243     Ok(())
 244   }
 245
 246   pub async fn read(
 247     pool: &mut DbPool<'_>,
 248     for_community_id: CommunityId,
 249   ) -> Result<Vec<LanguageId>, Error> {
 250     use crate::schema::community_language::dsl::{community_id, community_language, language_id};
 251     let conn = &mut get_conn(pool).await?;
 252     let langs = community_language
 253       .filter(community_id.eq(for_community_id))
 254       .order(language_id)
 255       .select(language_id)
 256       .get_results(conn)
 257       .await?;
 258     convert_read_languages(conn, langs).await
 259   }
 260
 261   pub async fn update(
 262     pool: &mut DbPool<'_>,
 263     mut language_ids: Vec<LanguageId>,
 264     for_community_id: CommunityId,
 265   ) -> Result<(), Error> {
 266     if language_ids.is_empty() {
 267       language_ids = SiteLanguage::read_local_raw(pool).await?;
 268     }
 269     let conn = &mut get_conn(pool).await?;
 270     let lang_ids = convert_update_languages(conn, language_ids).await?;
 271
 272     // No need to update if languages are unchanged
 273     let current = CommunityLanguage::read(&mut conn.into(), for_community_id).await?;
 274     if current == lang_ids {
 275       return Ok(());
 276     }
 277
 278     let form = lang_ids
 279       .into_iter()
 280       .map(|language_id| CommunityLanguageForm {
 281         community_id: for_community_id,
 282         language_id,
 283       })
 284       .collect::<Vec<_>>();
 285
 286     conn
 287       .build_transaction()
 288       .run(|conn| {
 289         Box::pin(async move {
 290           use crate::schema::community_language::dsl::{community_id, community_language};
 291           use diesel::result::DatabaseErrorKind::UniqueViolation;
 292           // Clear the current languages
 293           delete(community_language.filter(community_id.eq(for_community_id)))
 294             .execute(conn)
 295             .await?;
 296
 297           let insert_res = insert_into(community_language)
 298             .values(form)
 299             .get_result::<Self>(conn)
 300             .await;
 301
 302           if let Err(Error::DatabaseError(UniqueViolation, _info)) = insert_res {
 303             // race condition: this function was probably called simultaneously from another caller. ignore error
 304             // tracing::warn!("unique error: {_info:#?}");
 305             // _info.constraint_name() should be = "community_language_community_id_language_id_key"
 306             return Ok(());
 307           } else {
 308             insert_res?;
 309           }
 310           Ok(())
 311         }) as _
 312       })
 313       .await
 314   }
 315 }
 316
 317 pub async fn default_post_language(
 318   pool: &mut DbPool<'_>,
 319   community_id: CommunityId,
 320   local_user_id: LocalUserId,
 321 ) -> Result<Option<LanguageId>, Error> {
 322   use crate::schema::{community_language::dsl as cl, local_user_language::dsl as ul};
 323   let conn = &mut get_conn(pool).await?;
 324   let mut intersection = ul::local_user_language
 325     .inner_join(cl::community_language.on(ul::language_id.eq(cl::language_id)))
 326     .filter(ul::local_user_id.eq(local_user_id))
 327     .filter(cl::community_id.eq(community_id))
 328     .select(cl::language_id)
 329     .get_results::<LanguageId>(conn)
 330     .await?;
 331
 332   if intersection.len() == 1 {
 333     Ok(intersection.pop())
 334   } else if intersection.len() == 2 && intersection.contains(&UNDETERMINED_ID) {
 335     intersection.retain(|i| i != &UNDETERMINED_ID);
 336     Ok(intersection.pop())
 337   } else {
 338     Ok(None)
 339   }
 340 }
 341
 342 /// If no language is given, set all languages
 343 async fn convert_update_languages(
 344   conn: &mut AsyncPgConnection,
 345   language_ids: Vec<LanguageId>,
 346 ) -> Result<Vec<LanguageId>, Error> {
 347   if language_ids.is_empty() {
 348     Ok(
 349       Language::read_all(&mut conn.into())
 350         .await?
 351         .into_iter()
 352         .map(|l| l.id)
 353         .collect(),
 354     )
 355   } else {
 356     Ok(language_ids)
 357   }
 358 }
 359
 360 /// If all languages are returned, return empty vec instead
 361 async fn convert_read_languages(
 362   conn: &mut AsyncPgConnection,
 363   language_ids: Vec<LanguageId>,
 364 ) -> Result<Vec<LanguageId>, Error> {
 365   static ALL_LANGUAGES_COUNT: OnceCell<usize> = OnceCell::const_new();
 366   let count = ALL_LANGUAGES_COUNT
 367     .get_or_init(|| async {
 368       use crate::schema::language::dsl::{id, language};
 369       let count: i64 = language
 370         .select(count(id))
 371         .first(conn)
 372         .await
 373         .expect("read number of languages");
 374       count as usize
 375     })
 376     .await;
 377
 378   if &language_ids.len() == count {
 379     Ok(vec![])
 380   } else {
 381     Ok(language_ids)
 382   }
 383 }
 384
 385 #[cfg(test)]
 386 mod tests {
 387   use super::*;
 388   use crate::{
 389     impls::actor_language::{
 390       convert_read_languages,
 391       convert_update_languages,
 392       default_post_language,
 393       get_conn,
 394       CommunityLanguage,
 395       DbPool,
 396       Language,
 397       LanguageId,
 398       LocalUserLanguage,
 399       QueryDsl,
 400       RunQueryDsl,
 401       SiteLanguage,
 402     },
 403     source::{
 404       community::{Community, CommunityInsertForm},
 405       instance::Instance,
 406       local_site::{LocalSite, LocalSiteInsertForm},
 407       local_user::{LocalUser, LocalUserInsertForm},
 408       person::{Person, PersonInsertForm},
 409       site::{Site, SiteInsertForm},
 410     },
 411     traits::Crud,
 412     utils::build_db_pool_for_tests,
 413   };
 414   use serial_test::serial;
 415
 416   async fn test_langs1(pool: &mut DbPool<'_>) -> Vec<LanguageId> {
 417     vec![
 418       Language::read_id_from_code(pool, Some("en"))
 419         .await
 420         .unwrap()
 421         .unwrap(),
 422       Language::read_id_from_code(pool, Some("fr"))
 423         .await
 424         .unwrap()
 425         .unwrap(),
 426       Language::read_id_from_code(pool, Some("ru"))
 427         .await
 428         .unwrap()
 429         .unwrap(),
 430     ]
 431   }
 432   async fn test_langs2(pool: &mut DbPool<'_>) -> Vec<LanguageId> {
 433     vec![
 434       Language::read_id_from_code(pool, Some("fi"))
 435         .await
 436         .unwrap()
 437         .unwrap(),
 438       Language::read_id_from_code(pool, Some("se"))
 439         .await
 440         .unwrap()
 441         .unwrap(),
 442     ]
 443   }
 444
 445   async fn create_test_site(pool: &mut DbPool<'_>) -> (Site, Instance) {
 446     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
 447       .await
 448       .unwrap();
 449
 450     let site_form = SiteInsertForm::builder()
 451       .name("test site".to_string())
 452       .instance_id(inserted_instance.id)
 453       .build();
 454     let site = Site::create(pool, &site_form).await.unwrap();
 455
 456     // Create a local site, since this is necessary for local languages
 457     let local_site_form = LocalSiteInsertForm::builder().site_id(site.id).build();
 458     LocalSite::create(pool, &local_site_form).await.unwrap();
 459
 460     (site, inserted_instance)
 461   }
 462
 463   #[tokio::test]
 464   #[serial]
 465   async fn test_convert_update_languages() {
 466     let pool = &build_db_pool_for_tests().await;
 467     let pool = &mut pool.into();
 468
 469     // call with empty vec, returns all languages
 470     let conn = &mut get_conn(pool).await.unwrap();
 471     let converted1 = convert_update_languages(conn, vec![]).await.unwrap();
 472     assert_eq!(184, converted1.len());
 473
 474     // call with nonempty vec, returns same vec
 475     let test_langs = test_langs1(&mut conn.into()).await;
 476     let converted2 = convert_update_languages(conn, test_langs.clone())
 477       .await
 478       .unwrap();
 479     assert_eq!(test_langs, converted2);
 480   }
 481   #[tokio::test]
 482   #[serial]
 483   async fn test_convert_read_languages() {
 484     use crate::schema::language::dsl::{id, language};
 485     let pool = &build_db_pool_for_tests().await;
 486     let pool = &mut pool.into();
 487
 488     // call with all languages, returns empty vec
 489     let conn = &mut get_conn(pool).await.unwrap();
 490     let all_langs = language.select(id).get_results(conn).await.unwrap();
 491     let converted1: Vec<LanguageId> = convert_read_languages(conn, all_langs).await.unwrap();
 492     assert_eq!(0, converted1.len());
 493
 494     // call with nonempty vec, returns same vec
 495     let test_langs = test_langs1(&mut conn.into()).await;
 496     let converted2 = convert_read_languages(conn, test_langs.clone())
 497       .await
 498       .unwrap();
 499     assert_eq!(test_langs, converted2);
 500   }
 501
 502   #[tokio::test]
 503   #[serial]
 504   async fn test_site_languages() {
 505     let pool = &build_db_pool_for_tests().await;
 506     let pool = &mut pool.into();
 507
 508     let (site, instance) = create_test_site(pool).await;
 509     let site_languages1 = SiteLanguage::read_local_raw(pool).await.unwrap();
 510     // site is created with all languages
 511     assert_eq!(184, site_languages1.len());
 512
 513     let test_langs = test_langs1(pool).await;
 514     SiteLanguage::update(pool, test_langs.clone(), &site)
 515       .await
 516       .unwrap();
 517
 518     let site_languages2 = SiteLanguage::read_local_raw(pool).await.unwrap();
 519     // after update, site only has new languages
 520     assert_eq!(test_langs, site_languages2);
 521
 522     Site::delete(pool, site.id).await.unwrap();
 523     Instance::delete(pool, instance.id).await.unwrap();
 524     LocalSite::delete(pool).await.unwrap();
 525   }
 526
 527   #[tokio::test]
 528   #[serial]
 529   async fn test_user_languages() {
 530     let pool = &build_db_pool_for_tests().await;
 531     let pool = &mut pool.into();
 532
 533     let (site, instance) = create_test_site(pool).await;
 534     let mut test_langs = test_langs1(pool).await;
 535     SiteLanguage::update(pool, test_langs.clone(), &site)
 536       .await
 537       .unwrap();
 538
 539     let person_form = PersonInsertForm::builder()
 540       .name("my test person".to_string())
 541       .public_key("pubkey".to_string())
 542       .instance_id(instance.id)
 543       .build();
 544     let person = Person::create(pool, &person_form).await.unwrap();
 545     let local_user_form = LocalUserInsertForm::builder()
 546       .person_id(person.id)
 547       .password_encrypted("my_pw".to_string())
 548       .build();
 549
 550     let local_user = LocalUser::create(pool, &local_user_form).await.unwrap();
 551     let local_user_langs1 = LocalUserLanguage::read(pool, local_user.id).await.unwrap();
 552
 553     // new user should be initialized with site languages and undetermined
 554     //test_langs.push(UNDETERMINED_ID);
 555     //test_langs.sort();
 556     test_langs.insert(0, UNDETERMINED_ID);
 557     assert_eq!(test_langs, local_user_langs1);
 558
 559     // update user languages
 560     let test_langs2 = test_langs2(pool).await;
 561     LocalUserLanguage::update(pool, test_langs2, local_user.id)
 562       .await
 563       .unwrap();
 564     let local_user_langs2 = LocalUserLanguage::read(pool, local_user.id).await.unwrap();
 565     assert_eq!(3, local_user_langs2.len());
 566
 567     Person::delete(pool, person.id).await.unwrap();
 568     LocalUser::delete(pool, local_user.id).await.unwrap();
 569     Site::delete(pool, site.id).await.unwrap();
 570     LocalSite::delete(pool).await.unwrap();
 571     Instance::delete(pool, instance.id).await.unwrap();
 572   }
 573
 574   #[tokio::test]
 575   #[serial]
 576   async fn test_community_languages() {
 577     let pool = &build_db_pool_for_tests().await;
 578     let pool = &mut pool.into();
 579     let (site, instance) = create_test_site(pool).await;
 580     let test_langs = test_langs1(pool).await;
 581     SiteLanguage::update(pool, test_langs.clone(), &site)
 582       .await
 583       .unwrap();
 584
 585     let read_site_langs = SiteLanguage::read(pool, site.id).await.unwrap();
 586     assert_eq!(test_langs, read_site_langs);
 587
 588     // Test the local ones are the same
 589     let read_local_site_langs = SiteLanguage::read_local_raw(pool).await.unwrap();
 590     assert_eq!(test_langs, read_local_site_langs);
 591
 592     let community_form = CommunityInsertForm::builder()
 593       .name("test community".to_string())
 594       .title("test community".to_string())
 595       .public_key("pubkey".to_string())
 596       .instance_id(instance.id)
 597       .build();
 598     let community = Community::create(pool, &community_form).await.unwrap();
 599     let community_langs1 = CommunityLanguage::read(pool, community.id).await.unwrap();
 600
 601     // community is initialized with site languages
 602     assert_eq!(test_langs, community_langs1);
 603
 604     let allowed_lang1 =
 605       CommunityLanguage::is_allowed_community_language(pool, Some(test_langs[0]), community.id)
 606         .await;
 607     assert!(allowed_lang1.is_ok());
 608
 609     let test_langs2 = test_langs2(pool).await;
 610     let allowed_lang2 =
 611       CommunityLanguage::is_allowed_community_language(pool, Some(test_langs2[0]), community.id)
 612         .await;
 613     assert!(allowed_lang2.is_err());
 614
 615     // limit site languages to en, fi. after this, community languages should be updated to
 616     // intersection of old languages (en, fr, ru) and (en, fi), which is only fi.
 617     SiteLanguage::update(pool, vec![test_langs[0], test_langs2[0]], &site)
 618       .await
 619       .unwrap();
 620     let community_langs2 = CommunityLanguage::read(pool, community.id).await.unwrap();
 621     assert_eq!(vec![test_langs[0]], community_langs2);
 622
 623     // update community languages to different ones
 624     CommunityLanguage::update(pool, test_langs2.clone(), community.id)
 625       .await
 626       .unwrap();
 627     let community_langs3 = CommunityLanguage::read(pool, community.id).await.unwrap();
 628     assert_eq!(test_langs2, community_langs3);
 629
 630     Community::delete(pool, community.id).await.unwrap();
 631     Site::delete(pool, site.id).await.unwrap();
 632     LocalSite::delete(pool).await.unwrap();
 633     Instance::delete(pool, instance.id).await.unwrap();
 634   }
 635
 636   #[tokio::test]
 637   #[serial]
 638   async fn test_default_post_language() {
 639     let pool = &build_db_pool_for_tests().await;
 640     let pool = &mut pool.into();
 641     let (site, instance) = create_test_site(pool).await;
 642     let test_langs = test_langs1(pool).await;
 643     let test_langs2 = test_langs2(pool).await;
 644
 645     let community_form = CommunityInsertForm::builder()
 646       .name("test community".to_string())
 647       .title("test community".to_string())
 648       .public_key("pubkey".to_string())
 649       .instance_id(instance.id)
 650       .build();
 651     let community = Community::create(pool, &community_form).await.unwrap();
 652     CommunityLanguage::update(pool, test_langs, community.id)
 653       .await
 654       .unwrap();
 655
 656     let person_form = PersonInsertForm::builder()
 657       .name("my test person".to_string())
 658       .public_key("pubkey".to_string())
 659       .instance_id(instance.id)
 660       .build();
 661     let person = Person::create(pool, &person_form).await.unwrap();
 662     let local_user_form = LocalUserInsertForm::builder()
 663       .person_id(person.id)
 664       .password_encrypted("my_pw".to_string())
 665       .build();
 666     let local_user = LocalUser::create(pool, &local_user_form).await.unwrap();
 667     LocalUserLanguage::update(pool, test_langs2, local_user.id)
 668       .await
 669       .unwrap();
 670
 671     // no overlap in user/community languages, so defaults to undetermined
 672     let def1 = default_post_language(pool, community.id, local_user.id)
 673       .await
 674       .unwrap();
 675     assert_eq!(None, def1);
 676
 677     let ru = Language::read_id_from_code(pool, Some("ru"))
 678       .await
 679       .unwrap()
 680       .unwrap();
 681     let test_langs3 = vec![
 682       ru,
 683       Language::read_id_from_code(pool, Some("fi"))
 684         .await
 685         .unwrap()
 686         .unwrap(),
 687       Language::read_id_from_code(pool, Some("se"))
 688         .await
 689         .unwrap()
 690         .unwrap(),
 691       UNDETERMINED_ID,
 692     ];
 693     LocalUserLanguage::update(pool, test_langs3, local_user.id)
 694       .await
 695       .unwrap();
 696
 697     // this time, both have ru as common lang
 698     let def2 = default_post_language(pool, community.id, local_user.id)
 699       .await
 700       .unwrap();
 701     assert_eq!(Some(ru), def2);
 702
 703     Person::delete(pool, person.id).await.unwrap();
 704     Community::delete(pool, community.id).await.unwrap();
 705     LocalUser::delete(pool, local_user.id).await.unwrap();
 706     Site::delete(pool, site.id).await.unwrap();
 707     LocalSite::delete(pool).await.unwrap();
 708     Instance::delete(pool, instance.id).await.unwrap();
 709   }
 710 }