crates/db_schema/src/impls/moderator.rs

   1 use crate::{source::moderator::*, traits::Crud};
   2 use diesel::{dsl::*, result::Error, *};
   3
   4 impl Crud for ModRemovePost {
   5   type Form = ModRemovePostForm;
   6   type IdType = i32;
   7   fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
   8     use crate::schema::mod_remove_post::dsl::*;
   9     mod_remove_post.find(from_id).first::<Self>(conn)
  10   }
  11
  12   fn create(conn: &PgConnection, form: &ModRemovePostForm) -> Result<Self, Error> {
  13     use crate::schema::mod_remove_post::dsl::*;
  14     insert_into(mod_remove_post)
  15       .values(form)
  16       .get_result::<Self>(conn)
  17   }
  18
  19   fn update(conn: &PgConnection, from_id: i32, form: &ModRemovePostForm) -> Result<Self, Error> {
  20     use crate::schema::mod_remove_post::dsl::*;
  21     diesel::update(mod_remove_post.find(from_id))
  22       .set(form)
  23       .get_result::<Self>(conn)
  24   }
  25 }
  26
  27 impl Crud for ModLockPost {
  28   type Form = ModLockPostForm;
  29   type IdType = i32;
  30   fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
  31     use crate::schema::mod_lock_post::dsl::*;
  32     mod_lock_post.find(from_id).first::<Self>(conn)
  33   }
  34
  35   fn create(conn: &PgConnection, form: &ModLockPostForm) -> Result<Self, Error> {
  36     use crate::schema::mod_lock_post::dsl::*;
  37     insert_into(mod_lock_post)
  38       .values(form)
  39       .get_result::<Self>(conn)
  40   }
  41
  42   fn update(conn: &PgConnection, from_id: i32, form: &ModLockPostForm) -> Result<Self, Error> {
  43     use crate::schema::mod_lock_post::dsl::*;
  44     diesel::update(mod_lock_post.find(from_id))
  45       .set(form)
  46       .get_result::<Self>(conn)
  47   }
  48 }
  49
  50 impl Crud for ModStickyPost {
  51   type Form = ModStickyPostForm;
  52   type IdType = i32;
  53   fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
  54     use crate::schema::mod_sticky_post::dsl::*;
  55     mod_sticky_post.find(from_id).first::<Self>(conn)
  56   }
  57
  58   fn create(conn: &PgConnection, form: &ModStickyPostForm) -> Result<Self, Error> {
  59     use crate::schema::mod_sticky_post::dsl::*;
  60     insert_into(mod_sticky_post)
  61       .values(form)
  62       .get_result::<Self>(conn)
  63   }
  64
  65   fn update(conn: &PgConnection, from_id: i32, form: &ModStickyPostForm) -> Result<Self, Error> {
  66     use crate::schema::mod_sticky_post::dsl::*;
  67     diesel::update(mod_sticky_post.find(from_id))
  68       .set(form)
  69       .get_result::<Self>(conn)
  70   }
  71 }
  72
  73 impl Crud for ModRemoveComment {
  74   type Form = ModRemoveCommentForm;
  75   type IdType = i32;
  76   fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
  77     use crate::schema::mod_remove_comment::dsl::*;
  78     mod_remove_comment.find(from_id).first::<Self>(conn)
  79   }
  80
  81   fn create(conn: &PgConnection, form: &ModRemoveCommentForm) -> Result<Self, Error> {
  82     use crate::schema::mod_remove_comment::dsl::*;
  83     insert_into(mod_remove_comment)
  84       .values(form)
  85       .get_result::<Self>(conn)
  86   }
  87
  88   fn update(conn: &PgConnection, from_id: i32, form: &ModRemoveCommentForm) -> Result<Self, Error> {
  89     use crate::schema::mod_remove_comment::dsl::*;
  90     diesel::update(mod_remove_comment.find(from_id))
  91       .set(form)
  92       .get_result::<Self>(conn)
  93   }
  94 }
  95
  96 impl Crud for ModRemoveCommunity {
  97   type Form = ModRemoveCommunityForm;
  98   type IdType = i32;
  99   fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
 100     use crate::schema::mod_remove_community::dsl::*;
 101     mod_remove_community.find(from_id).first::<Self>(conn)
 102   }
 103
 104   fn create(conn: &PgConnection, form: &ModRemoveCommunityForm) -> Result<Self, Error> {
 105     use crate::schema::mod_remove_community::dsl::*;
 106     insert_into(mod_remove_community)
 107       .values(form)
 108       .get_result::<Self>(conn)
 109   }
 110
 111   fn update(
 112     conn: &PgConnection,
 113     from_id: i32,
 114     form: &ModRemoveCommunityForm,
 115   ) -> Result<Self, Error> {
 116     use crate::schema::mod_remove_community::dsl::*;
 117     diesel::update(mod_remove_community.find(from_id))
 118       .set(form)
 119       .get_result::<Self>(conn)
 120   }
 121 }
 122
 123 impl Crud for ModBanFromCommunity {
 124   type Form = ModBanFromCommunityForm;
 125   type IdType = i32;
 126   fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
 127     use crate::schema::mod_ban_from_community::dsl::*;
 128     mod_ban_from_community.find(from_id).first::<Self>(conn)
 129   }
 130
 131   fn create(conn: &PgConnection, form: &ModBanFromCommunityForm) -> Result<Self, Error> {
 132     use crate::schema::mod_ban_from_community::dsl::*;
 133     insert_into(mod_ban_from_community)
 134       .values(form)
 135       .get_result::<Self>(conn)
 136   }
 137
 138   fn update(
 139     conn: &PgConnection,
 140     from_id: i32,
 141     form: &ModBanFromCommunityForm,
 142   ) -> Result<Self, Error> {
 143     use crate::schema::mod_ban_from_community::dsl::*;
 144     diesel::update(mod_ban_from_community.find(from_id))
 145       .set(form)
 146       .get_result::<Self>(conn)
 147   }
 148 }
 149
 150 impl Crud for ModBan {
 151   type Form = ModBanForm;
 152   type IdType = i32;
 153   fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
 154     use crate::schema::mod_ban::dsl::*;
 155     mod_ban.find(from_id).first::<Self>(conn)
 156   }
 157
 158   fn create(conn: &PgConnection, form: &ModBanForm) -> Result<Self, Error> {
 159     use crate::schema::mod_ban::dsl::*;
 160     insert_into(mod_ban).values(form).get_result::<Self>(conn)
 161   }
 162
 163   fn update(conn: &PgConnection, from_id: i32, form: &ModBanForm) -> Result<Self, Error> {
 164     use crate::schema::mod_ban::dsl::*;
 165     diesel::update(mod_ban.find(from_id))
 166       .set(form)
 167       .get_result::<Self>(conn)
 168   }
 169 }
 170
 171 impl Crud for ModHideCommunity {
 172   type Form = ModHideCommunityForm;
 173   type IdType = i32;
 174
 175   fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
 176     use crate::schema::mod_hide_community::dsl::*;
 177     mod_hide_community.find(from_id).first::<Self>(conn)
 178   }
 179
 180   fn create(conn: &PgConnection, form: &ModHideCommunityForm) -> Result<Self, Error> {
 181     use crate::schema::mod_hide_community::dsl::*;
 182     insert_into(mod_hide_community)
 183       .values(form)
 184       .get_result::<Self>(conn)
 185   }
 186
 187   fn update(conn: &PgConnection, from_id: i32, form: &ModHideCommunityForm) -> Result<Self, Error> {
 188     use crate::schema::mod_hide_community::dsl::*;
 189     diesel::update(mod_hide_community.find(from_id))
 190       .set(form)
 191       .get_result::<Self>(conn)
 192   }
 193 }
 194
 195 impl Crud for ModAddCommunity {
 196   type Form = ModAddCommunityForm;
 197   type IdType = i32;
 198   fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
 199     use crate::schema::mod_add_community::dsl::*;
 200     mod_add_community.find(from_id).first::<Self>(conn)
 201   }
 202
 203   fn create(conn: &PgConnection, form: &ModAddCommunityForm) -> Result<Self, Error> {
 204     use crate::schema::mod_add_community::dsl::*;
 205     insert_into(mod_add_community)
 206       .values(form)
 207       .get_result::<Self>(conn)
 208   }
 209
 210   fn update(conn: &PgConnection, from_id: i32, form: &ModAddCommunityForm) -> Result<Self, Error> {
 211     use crate::schema::mod_add_community::dsl::*;
 212     diesel::update(mod_add_community.find(from_id))
 213       .set(form)
 214       .get_result::<Self>(conn)
 215   }
 216 }
 217
 218 impl Crud for ModTransferCommunity {
 219   type Form = ModTransferCommunityForm;
 220   type IdType = i32;
 221   fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
 222     use crate::schema::mod_transfer_community::dsl::*;
 223     mod_transfer_community.find(from_id).first::<Self>(conn)
 224   }
 225
 226   fn create(conn: &PgConnection, form: &ModTransferCommunityForm) -> Result<Self, Error> {
 227     use crate::schema::mod_transfer_community::dsl::*;
 228     insert_into(mod_transfer_community)
 229       .values(form)
 230       .get_result::<Self>(conn)
 231   }
 232
 233   fn update(
 234     conn: &PgConnection,
 235     from_id: i32,
 236     form: &ModTransferCommunityForm,
 237   ) -> Result<Self, Error> {
 238     use crate::schema::mod_transfer_community::dsl::*;
 239     diesel::update(mod_transfer_community.find(from_id))
 240       .set(form)
 241       .get_result::<Self>(conn)
 242   }
 243 }
 244
 245 impl Crud for ModAdd {
 246   type Form = ModAddForm;
 247   type IdType = i32;
 248   fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
 249     use crate::schema::mod_add::dsl::*;
 250     mod_add.find(from_id).first::<Self>(conn)
 251   }
 252
 253   fn create(conn: &PgConnection, form: &ModAddForm) -> Result<Self, Error> {
 254     use crate::schema::mod_add::dsl::*;
 255     insert_into(mod_add).values(form).get_result::<Self>(conn)
 256   }
 257
 258   fn update(conn: &PgConnection, from_id: i32, form: &ModAddForm) -> Result<Self, Error> {
 259     use crate::schema::mod_add::dsl::*;
 260     diesel::update(mod_add.find(from_id))
 261       .set(form)
 262       .get_result::<Self>(conn)
 263   }
 264 }
 265
 266 impl Crud for AdminPurgePerson {
 267   type Form = AdminPurgePersonForm;
 268   type IdType = i32;
 269   fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
 270     use crate::schema::admin_purge_person::dsl::*;
 271     admin_purge_person.find(from_id).first::<Self>(conn)
 272   }
 273
 274   fn create(conn: &PgConnection, form: &Self::Form) -> Result<Self, Error> {
 275     use crate::schema::admin_purge_person::dsl::*;
 276     insert_into(admin_purge_person)
 277       .values(form)
 278       .get_result::<Self>(conn)
 279   }
 280
 281   fn update(conn: &PgConnection, from_id: i32, form: &Self::Form) -> Result<Self, Error> {
 282     use crate::schema::admin_purge_person::dsl::*;
 283     diesel::update(admin_purge_person.find(from_id))
 284       .set(form)
 285       .get_result::<Self>(conn)
 286   }
 287 }
 288
 289 impl Crud for AdminPurgeCommunity {
 290   type Form = AdminPurgeCommunityForm;
 291   type IdType = i32;
 292   fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
 293     use crate::schema::admin_purge_community::dsl::*;
 294     admin_purge_community.find(from_id).first::<Self>(conn)
 295   }
 296
 297   fn create(conn: &PgConnection, form: &Self::Form) -> Result<Self, Error> {
 298     use crate::schema::admin_purge_community::dsl::*;
 299     insert_into(admin_purge_community)
 300       .values(form)
 301       .get_result::<Self>(conn)
 302   }
 303
 304   fn update(conn: &PgConnection, from_id: i32, form: &Self::Form) -> Result<Self, Error> {
 305     use crate::schema::admin_purge_community::dsl::*;
 306     diesel::update(admin_purge_community.find(from_id))
 307       .set(form)
 308       .get_result::<Self>(conn)
 309   }
 310 }
 311
 312 impl Crud for AdminPurgePost {
 313   type Form = AdminPurgePostForm;
 314   type IdType = i32;
 315   fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
 316     use crate::schema::admin_purge_post::dsl::*;
 317     admin_purge_post.find(from_id).first::<Self>(conn)
 318   }
 319
 320   fn create(conn: &PgConnection, form: &Self::Form) -> Result<Self, Error> {
 321     use crate::schema::admin_purge_post::dsl::*;
 322     insert_into(admin_purge_post)
 323       .values(form)
 324       .get_result::<Self>(conn)
 325   }
 326
 327   fn update(conn: &PgConnection, from_id: i32, form: &Self::Form) -> Result<Self, Error> {
 328     use crate::schema::admin_purge_post::dsl::*;
 329     diesel::update(admin_purge_post.find(from_id))
 330       .set(form)
 331       .get_result::<Self>(conn)
 332   }
 333 }
 334
 335 impl Crud for AdminPurgeComment {
 336   type Form = AdminPurgeCommentForm;
 337   type IdType = i32;
 338   fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
 339     use crate::schema::admin_purge_comment::dsl::*;
 340     admin_purge_comment.find(from_id).first::<Self>(conn)
 341   }
 342
 343   fn create(conn: &PgConnection, form: &Self::Form) -> Result<Self, Error> {
 344     use crate::schema::admin_purge_comment::dsl::*;
 345     insert_into(admin_purge_comment)
 346       .values(form)
 347       .get_result::<Self>(conn)
 348   }
 349
 350   fn update(conn: &PgConnection, from_id: i32, form: &Self::Form) -> Result<Self, Error> {
 351     use crate::schema::admin_purge_comment::dsl::*;
 352     diesel::update(admin_purge_comment.find(from_id))
 353       .set(form)
 354       .get_result::<Self>(conn)
 355   }
 356 }
 357
 358 #[cfg(test)]
 359 mod tests {
 360   use crate::{
 361     source::{comment::*, community::*, moderator::*, person::*, post::*},
 362     traits::Crud,
 363     utils::establish_unpooled_connection,
 364   };
 365   use serial_test::serial;
 366
 367   // use Crud;
 368   #[test]
 369   #[serial]
 370   fn test_crud() {
 371     let conn = establish_unpooled_connection();
 372
 373     let new_mod = PersonForm {
 374       name: "the mod".into(),
 375       public_key: Some("pubkey".to_string()),
 376       ..PersonForm::default()
 377     };
 378
 379     let inserted_mod = Person::create(&conn, &new_mod).unwrap();
 380
 381     let new_person = PersonForm {
 382       name: "jim2".into(),
 383       public_key: Some("pubkey".to_string()),
 384       ..PersonForm::default()
 385     };
 386
 387     let inserted_person = Person::create(&conn, &new_person).unwrap();
 388
 389     let new_community = CommunityForm {
 390       name: "mod_community".to_string(),
 391       title: "nada".to_owned(),
 392       public_key: Some("pubkey".to_string()),
 393       ..CommunityForm::default()
 394     };
 395
 396     let inserted_community = Community::create(&conn, &new_community).unwrap();
 397
 398     let new_post = PostForm {
 399       name: "A test post thweep".into(),
 400       creator_id: inserted_person.id,
 401       community_id: inserted_community.id,
 402       ..PostForm::default()
 403     };
 404
 405     let inserted_post = Post::create(&conn, &new_post).unwrap();
 406
 407     let comment_form = CommentForm {
 408       content: "A test comment".into(),
 409       creator_id: inserted_person.id,
 410       post_id: inserted_post.id,
 411       ..CommentForm::default()
 412     };
 413
 414     let inserted_comment = Comment::create(&conn, &comment_form, None).unwrap();
 415
 416     // Now the actual tests
 417
 418     // remove post
 419     let mod_remove_post_form = ModRemovePostForm {
 420       mod_person_id: inserted_mod.id,
 421       post_id: inserted_post.id,
 422       reason: None,
 423       removed: None,
 424     };
 425     let inserted_mod_remove_post = ModRemovePost::create(&conn, &mod_remove_post_form).unwrap();
 426     let read_mod_remove_post = ModRemovePost::read(&conn, inserted_mod_remove_post.id).unwrap();
 427     let expected_mod_remove_post = ModRemovePost {
 428       id: inserted_mod_remove_post.id,
 429       post_id: inserted_post.id,
 430       mod_person_id: inserted_mod.id,
 431       reason: None,
 432       removed: Some(true),
 433       when_: inserted_mod_remove_post.when_,
 434     };
 435
 436     // lock post
 437
 438     let mod_lock_post_form = ModLockPostForm {
 439       mod_person_id: inserted_mod.id,
 440       post_id: inserted_post.id,
 441       locked: None,
 442     };
 443     let inserted_mod_lock_post = ModLockPost::create(&conn, &mod_lock_post_form).unwrap();
 444     let read_mod_lock_post = ModLockPost::read(&conn, inserted_mod_lock_post.id).unwrap();
 445     let expected_mod_lock_post = ModLockPost {
 446       id: inserted_mod_lock_post.id,
 447       post_id: inserted_post.id,
 448       mod_person_id: inserted_mod.id,
 449       locked: Some(true),
 450       when_: inserted_mod_lock_post.when_,
 451     };
 452
 453     // sticky post
 454
 455     let mod_sticky_post_form = ModStickyPostForm {
 456       mod_person_id: inserted_mod.id,
 457       post_id: inserted_post.id,
 458       stickied: None,
 459     };
 460     let inserted_mod_sticky_post = ModStickyPost::create(&conn, &mod_sticky_post_form).unwrap();
 461     let read_mod_sticky_post = ModStickyPost::read(&conn, inserted_mod_sticky_post.id).unwrap();
 462     let expected_mod_sticky_post = ModStickyPost {
 463       id: inserted_mod_sticky_post.id,
 464       post_id: inserted_post.id,
 465       mod_person_id: inserted_mod.id,
 466       stickied: Some(true),
 467       when_: inserted_mod_sticky_post.when_,
 468     };
 469
 470     // comment
 471
 472     let mod_remove_comment_form = ModRemoveCommentForm {
 473       mod_person_id: inserted_mod.id,
 474       comment_id: inserted_comment.id,
 475       reason: None,
 476       removed: None,
 477     };
 478     let inserted_mod_remove_comment =
 479       ModRemoveComment::create(&conn, &mod_remove_comment_form).unwrap();
 480     let read_mod_remove_comment =
 481       ModRemoveComment::read(&conn, inserted_mod_remove_comment.id).unwrap();
 482     let expected_mod_remove_comment = ModRemoveComment {
 483       id: inserted_mod_remove_comment.id,
 484       comment_id: inserted_comment.id,
 485       mod_person_id: inserted_mod.id,
 486       reason: None,
 487       removed: Some(true),
 488       when_: inserted_mod_remove_comment.when_,
 489     };
 490
 491     // community
 492
 493     let mod_remove_community_form = ModRemoveCommunityForm {
 494       mod_person_id: inserted_mod.id,
 495       community_id: inserted_community.id,
 496       reason: None,
 497       removed: None,
 498       expires: None,
 499     };
 500     let inserted_mod_remove_community =
 501       ModRemoveCommunity::create(&conn, &mod_remove_community_form).unwrap();
 502     let read_mod_remove_community =
 503       ModRemoveCommunity::read(&conn, inserted_mod_remove_community.id).unwrap();
 504     let expected_mod_remove_community = ModRemoveCommunity {
 505       id: inserted_mod_remove_community.id,
 506       community_id: inserted_community.id,
 507       mod_person_id: inserted_mod.id,
 508       reason: None,
 509       removed: Some(true),
 510       expires: None,
 511       when_: inserted_mod_remove_community.when_,
 512     };
 513
 514     // ban from community
 515
 516     let mod_ban_from_community_form = ModBanFromCommunityForm {
 517       mod_person_id: inserted_mod.id,
 518       other_person_id: inserted_person.id,
 519       community_id: inserted_community.id,
 520       reason: None,
 521       banned: None,
 522       expires: None,
 523     };
 524     let inserted_mod_ban_from_community =
 525       ModBanFromCommunity::create(&conn, &mod_ban_from_community_form).unwrap();
 526     let read_mod_ban_from_community =
 527       ModBanFromCommunity::read(&conn, inserted_mod_ban_from_community.id).unwrap();
 528     let expected_mod_ban_from_community = ModBanFromCommunity {
 529       id: inserted_mod_ban_from_community.id,
 530       community_id: inserted_community.id,
 531       mod_person_id: inserted_mod.id,
 532       other_person_id: inserted_person.id,
 533       reason: None,
 534       banned: Some(true),
 535       expires: None,
 536       when_: inserted_mod_ban_from_community.when_,
 537     };
 538
 539     // ban
 540
 541     let mod_ban_form = ModBanForm {
 542       mod_person_id: inserted_mod.id,
 543       other_person_id: inserted_person.id,
 544       reason: None,
 545       banned: None,
 546       expires: None,
 547     };
 548     let inserted_mod_ban = ModBan::create(&conn, &mod_ban_form).unwrap();
 549     let read_mod_ban = ModBan::read(&conn, inserted_mod_ban.id).unwrap();
 550     let expected_mod_ban = ModBan {
 551       id: inserted_mod_ban.id,
 552       mod_person_id: inserted_mod.id,
 553       other_person_id: inserted_person.id,
 554       reason: None,
 555       banned: Some(true),
 556       expires: None,
 557       when_: inserted_mod_ban.when_,
 558     };
 559
 560     // mod add community
 561
 562     let mod_add_community_form = ModAddCommunityForm {
 563       mod_person_id: inserted_mod.id,
 564       other_person_id: inserted_person.id,
 565       community_id: inserted_community.id,
 566       removed: None,
 567     };
 568     let inserted_mod_add_community =
 569       ModAddCommunity::create(&conn, &mod_add_community_form).unwrap();
 570     let read_mod_add_community =
 571       ModAddCommunity::read(&conn, inserted_mod_add_community.id).unwrap();
 572     let expected_mod_add_community = ModAddCommunity {
 573       id: inserted_mod_add_community.id,
 574       community_id: inserted_community.id,
 575       mod_person_id: inserted_mod.id,
 576       other_person_id: inserted_person.id,
 577       removed: Some(false),
 578       when_: inserted_mod_add_community.when_,
 579     };
 580
 581     // mod add
 582
 583     let mod_add_form = ModAddForm {
 584       mod_person_id: inserted_mod.id,
 585       other_person_id: inserted_person.id,
 586       removed: None,
 587     };
 588     let inserted_mod_add = ModAdd::create(&conn, &mod_add_form).unwrap();
 589     let read_mod_add = ModAdd::read(&conn, inserted_mod_add.id).unwrap();
 590     let expected_mod_add = ModAdd {
 591       id: inserted_mod_add.id,
 592       mod_person_id: inserted_mod.id,
 593       other_person_id: inserted_person.id,
 594       removed: Some(false),
 595       when_: inserted_mod_add.when_,
 596     };
 597
 598     Comment::delete(&conn, inserted_comment.id).unwrap();
 599     Post::delete(&conn, inserted_post.id).unwrap();
 600     Community::delete(&conn, inserted_community.id).unwrap();
 601     Person::delete(&conn, inserted_person.id).unwrap();
 602     Person::delete(&conn, inserted_mod.id).unwrap();
 603
 604     assert_eq!(expected_mod_remove_post, read_mod_remove_post);
 605     assert_eq!(expected_mod_lock_post, read_mod_lock_post);
 606     assert_eq!(expected_mod_sticky_post, read_mod_sticky_post);
 607     assert_eq!(expected_mod_remove_comment, read_mod_remove_comment);
 608     assert_eq!(expected_mod_remove_community, read_mod_remove_community);
 609     assert_eq!(expected_mod_ban_from_community, read_mod_ban_from_community);
 610     assert_eq!(expected_mod_ban, read_mod_ban);
 611     assert_eq!(expected_mod_add_community, read_mod_add_community);
 612     assert_eq!(expected_mod_add, read_mod_add);
 613   }
 614 }