Adding unit tests for person and community block.

crates/db_views/src/comment_view.rs

@@ -126,8 +126,8 @@ impl CommentView {
       .left_join(
         person_block::table.on(
           comment::creator_id
-            .eq(person_block::person_id)
+            .eq(person_block::recipient_id)
-            .and(person_block::recipient_id.eq(person_id_join)),
+            .and(person_block::person_id.eq(person_id_join)),
         ),
       )
       .left_join(
@@ -443,9 +443,10 @@ impl<'a> CommentQueryBuilder<'a> {
         .order_by(comment_aggregates::score.desc()),
     };
 
-    // Don't show blocked communities
+    // Don't show blocked communities or persons
     if self.my_person_id.is_some() {
       query = query.filter(community_block::person_id.is_null());
+      query = query.filter(person_block::person_id.is_null());
     }
 
     let (limit, offset) = limit_and_offset(self.page, self.limit);

crates/db_views/src/post_view.rs

@@ -319,8 +319,8 @@ impl<'a> PostQueryBuilder<'a> {
       .left_join(
         person_block::table.on(
           post::creator_id
-            .eq(person_block::person_id)
+            .eq(person_block::recipient_id)
-            .and(person_block::recipient_id.eq(person_id_join)),
+            .and(person_block::person_id.eq(person_id_join)),
         ),
       )
       .left_join(
@@ -407,9 +407,10 @@ impl<'a> PostQueryBuilder<'a> {
       query = query.filter(post_saved::id.is_not_null());
     };
 
-    // Don't show blocked communities
+    // Don't show blocked communities or persons
     if self.my_person_id.is_some() {
       query = query.filter(community_block::person_id.is_null());
+      query = query.filter(person_block::person_id.is_null());
     }
 
     query = match self.sort.unwrap_or(SortType::Hot) {
@@ -488,12 +489,19 @@ mod tests {
   use lemmy_db_queries::{
     aggregates::post_aggregates::PostAggregates,
     establish_unpooled_connection,
+    Blockable,
     Crud,
     Likeable,
     ListingType,
     SortType,
   };
-  use lemmy_db_schema::source::{community::*, person::*, post::*};
+  use lemmy_db_schema::source::{
+    community::*,
+    community_block::{CommunityBlock, CommunityBlockForm},
+    person::*,
+    person_block::{PersonBlock, PersonBlockForm},
+    post::*,
+  };
   use serial_test::serial;
 
   #[test]
@@ -529,6 +537,32 @@ mod tests {
 
     let inserted_community = Community::create(&conn, &new_community).unwrap();
 
+    // Test a person block, make sure the post query doesn't include their post
+    let blocked_person = PersonForm {
+      name: person_name.to_owned(),
+      ..PersonForm::default()
+    };
+
+    let inserted_blocked_person = Person::create(&conn, &blocked_person).unwrap();
+
+    let post_from_blocked_person = PostForm {
+      name: "blocked_person_post".to_string(),
+      creator_id: inserted_blocked_person.id,
+      community_id: inserted_community.id,
+      ..PostForm::default()
+    };
+
+    Post::create(&conn, &post_from_blocked_person).unwrap();
+
+    // block that person
+    let person_block = PersonBlockForm {
+      person_id: inserted_person.id,
+      recipient_id: inserted_blocked_person.id,
+    };
+
+    PersonBlock::block(&conn, &person_block).unwrap();
+
+    // A sample post
     let new_post = PostForm {
       name: post_name.to_owned(),
       creator_id: inserted_person.id,
@@ -662,15 +696,34 @@ mod tests {
       creator_blocked: false,
     };
 
+    // Test a community block
+    let community_block = CommunityBlockForm {
+      person_id: inserted_person.id,
+      community_id: inserted_community.id,
+    };
+    CommunityBlock::block(&conn, &community_block).unwrap();
+
+    let read_post_listings_with_person_after_block = PostQueryBuilder::create(&conn)
+      .listing_type(ListingType::Community)
+      .sort(SortType::New)
+      .show_bot_accounts(false)
+      .community_id(inserted_community.id)
+      .my_person_id(inserted_person.id)
+      .list()
+      .unwrap();
+
     // TODO More needs to be added here
     let mut expected_post_listing_with_user = expected_post_listing_no_person.to_owned();
     expected_post_listing_with_user.my_vote = Some(1);
 
     let like_removed = PostLike::remove(&conn, inserted_person.id, inserted_post.id).unwrap();
     let num_deleted = Post::delete(&conn, inserted_post.id).unwrap();
+    PersonBlock::unblock(&conn, &person_block).unwrap();
+    CommunityBlock::unblock(&conn, &community_block).unwrap();
     Community::delete(&conn, inserted_community.id).unwrap();
     Person::delete(&conn, inserted_person.id).unwrap();
     Person::delete(&conn, inserted_bot.id).unwrap();
+    Person::delete(&conn, inserted_blocked_person.id).unwrap();
 
     // The with user
     assert_eq!(
@@ -682,7 +735,7 @@ mod tests {
       read_post_listing_with_person
     );
 
-    // Should be only one person, IE the bot post should be missing
+    // Should be only one person, IE the bot post, and blocked should be missing
     assert_eq!(1, read_post_listings_with_person.len());
 
     // Without the user
@@ -692,8 +745,11 @@ mod tests {
     );
     assert_eq!(expected_post_listing_no_person, read_post_listing_no_person);
 
-    // Should be 2 posts, with the bot post
+    // Should be 2 posts, with the bot post, and the blocked
-    assert_eq!(2, read_post_listings_no_person.len());
+    assert_eq!(3, read_post_listings_no_person.len());
+
+    // Should be 0 posts after the community block
+    assert_eq!(0, read_post_listings_with_person_after_block.len());
 
     assert_eq!(expected_post_like, inserted_post_like);
     assert_eq!(1, like_removed);

migrations/2021-05-07-004941_create_user_community_block/up.sql

@@ -2,12 +2,14 @@ create table person_block (
   id serial primary key,
   person_id int references person on update cascade on delete cascade not null,
   recipient_id int references person on update cascade on delete cascade not null,
-  published timestamp not null default now()
+  published timestamp not null default now(),
+  unique(person_id, recipient_id)
 );
 
 create table community_block (
   id serial primary key,
   person_id int references person on update cascade on delete cascade not null,
   community_id int references community on update cascade on delete cascade not null,
-  published timestamp not null default now()
+  published timestamp not null default now(),
+  unique(person_id, community_id)
 );