Fixing unit tests.

lemmy_db/src/aggregates/comment_aggregates.rs

@@ -20,4 +20,210 @@ impl CommentAggregates {
   }
 }
 
-// TODO add tests here
+#[cfg(test)]
+mod tests {
+  use crate::{
+    aggregates::comment_aggregates::CommentAggregates,
+    source::{
+      comment::{Comment, CommentForm, CommentLike, CommentLikeForm},
+      community::{Community, CommunityForm},
+      post::{Post, PostForm},
+      user::{UserForm, User_},
+    },
+    tests::establish_unpooled_connection,
+    Crud,
+    Likeable,
+    ListingType,
+    SortType,
+  };
+
+  #[test]
+  fn test_crud() {
+    let conn = establish_unpooled_connection();
+
+    let new_user = UserForm {
+      name: "thommy_comment_agg".into(),
+      preferred_username: None,
+      password_encrypted: "nope".into(),
+      email: None,
+      matrix_user_id: None,
+      avatar: None,
+      banner: None,
+      admin: false,
+      banned: Some(false),
+      published: None,
+      updated: None,
+      show_nsfw: false,
+      theme: "browser".into(),
+      default_sort_type: SortType::Hot as i16,
+      default_listing_type: ListingType::Subscribed as i16,
+      lang: "browser".into(),
+      show_avatars: true,
+      send_notifications_to_email: false,
+      actor_id: None,
+      bio: None,
+      local: true,
+      private_key: None,
+      public_key: None,
+      last_refreshed_at: None,
+    };
+
+    let inserted_user = User_::create(&conn, &new_user).unwrap();
+
+    let another_user = UserForm {
+      name: "jerry_comment_agg".into(),
+      preferred_username: None,
+      password_encrypted: "nope".into(),
+      email: None,
+      matrix_user_id: None,
+      avatar: None,
+      banner: None,
+      admin: false,
+      banned: Some(false),
+      published: None,
+      updated: None,
+      show_nsfw: false,
+      theme: "browser".into(),
+      default_sort_type: SortType::Hot as i16,
+      default_listing_type: ListingType::Subscribed as i16,
+      lang: "browser".into(),
+      show_avatars: true,
+      send_notifications_to_email: false,
+      actor_id: None,
+      bio: None,
+      local: true,
+      private_key: None,
+      public_key: None,
+      last_refreshed_at: None,
+    };
+
+    let another_inserted_user = User_::create(&conn, &another_user).unwrap();
+
+    let new_community = CommunityForm {
+      name: "TIL_comment_agg".into(),
+      creator_id: inserted_user.id,
+      title: "nada".to_owned(),
+      description: None,
+      category_id: 1,
+      nsfw: false,
+      removed: None,
+      deleted: None,
+      updated: None,
+      actor_id: None,
+      local: true,
+      private_key: None,
+      public_key: None,
+      last_refreshed_at: None,
+      published: None,
+      icon: None,
+      banner: None,
+    };
+
+    let inserted_community = Community::create(&conn, &new_community).unwrap();
+
+    let new_post = PostForm {
+      name: "A test post".into(),
+      url: None,
+      body: None,
+      creator_id: inserted_user.id,
+      community_id: inserted_community.id,
+      removed: None,
+      deleted: None,
+      locked: None,
+      stickied: None,
+      nsfw: false,
+      updated: None,
+      embed_title: None,
+      embed_description: None,
+      embed_html: None,
+      thumbnail_url: None,
+      ap_id: None,
+      local: true,
+      published: None,
+    };
+
+    let inserted_post = Post::create(&conn, &new_post).unwrap();
+
+    let comment_form = CommentForm {
+      content: "A test comment".into(),
+      creator_id: inserted_user.id,
+      post_id: inserted_post.id,
+      removed: None,
+      deleted: None,
+      read: None,
+      parent_id: None,
+      published: None,
+      updated: None,
+      ap_id: None,
+      local: true,
+    };
+
+    let inserted_comment = Comment::create(&conn, &comment_form).unwrap();
+
+    let child_comment_form = CommentForm {
+      content: "A test comment".into(),
+      creator_id: inserted_user.id,
+      post_id: inserted_post.id,
+      removed: None,
+      deleted: None,
+      read: None,
+      parent_id: Some(inserted_comment.id),
+      published: None,
+      updated: None,
+      ap_id: None,
+      local: true,
+    };
+
+    let _inserted_child_comment = Comment::create(&conn, &child_comment_form).unwrap();
+
+    let comment_like = CommentLikeForm {
+      comment_id: inserted_comment.id,
+      post_id: inserted_post.id,
+      user_id: inserted_user.id,
+      score: 1,
+    };
+
+    CommentLike::like(&conn, &comment_like).unwrap();
+
+    let comment_aggs_before_delete = CommentAggregates::read(&conn, inserted_comment.id).unwrap();
+
+    assert_eq!(1, comment_aggs_before_delete.score);
+    assert_eq!(1, comment_aggs_before_delete.upvotes);
+    assert_eq!(0, comment_aggs_before_delete.downvotes);
+
+    // Add a post dislike from the other user
+    let comment_dislike = CommentLikeForm {
+      comment_id: inserted_comment.id,
+      post_id: inserted_post.id,
+      user_id: another_inserted_user.id,
+      score: -1,
+    };
+
+    CommentLike::like(&conn, &comment_dislike).unwrap();
+
+    let comment_aggs_after_dislike = CommentAggregates::read(&conn, inserted_comment.id).unwrap();
+
+    assert_eq!(0, comment_aggs_after_dislike.score);
+    assert_eq!(1, comment_aggs_after_dislike.upvotes);
+    assert_eq!(1, comment_aggs_after_dislike.downvotes);
+
+    // Remove the first comment like
+    CommentLike::remove(&conn, inserted_user.id, inserted_comment.id).unwrap();
+    let after_like_remove = CommentAggregates::read(&conn, inserted_comment.id).unwrap();
+    assert_eq!(-1, after_like_remove.score);
+    assert_eq!(0, after_like_remove.upvotes);
+    assert_eq!(1, after_like_remove.downvotes);
+
+    // Remove the parent post
+    Post::delete(&conn, inserted_post.id).unwrap();
+
+    // Should be none found, since the post was deleted
+    let after_delete = CommentAggregates::read(&conn, inserted_comment.id);
+    assert!(after_delete.is_err());
+
+    // This should delete all the associated rows, and fire triggers
+    User_::delete(&conn, another_inserted_user.id).unwrap();
+    let user_num_deleted = User_::delete(&conn, inserted_user.id).unwrap();
+    assert_eq!(1, user_num_deleted);
+  }
+}

lemmy_db/src/source/comment_report.rs

@@ -3,7 +3,9 @@ use serde::{Deserialize, Serialize};
 
 use crate::{naive_now, schema::comment_report, source::comment::Comment, Reportable};
 
-#[derive(Identifiable, Queryable, Associations, PartialEq, Serialize, Deserialize, Debug, Clone)]
+#[derive(
+  Identifiable, Queryable, Associations, PartialEq, Serialize, Deserialize, Debug, Clone,
+)]
 #[belongs_to(Comment)]
 #[table_name = "comment_report"]
 pub struct CommentReport {

lemmy_db/src/source/post_report.rs

@@ -3,7 +3,9 @@ use serde::{Deserialize, Serialize};
 
 use crate::{naive_now, schema::post_report, source::post::Post, Reportable};
 
-#[derive(Identifiable, Queryable, Associations, PartialEq, Serialize, Deserialize, Debug, Clone)]
+#[derive(
+  Identifiable, Queryable, Associations, PartialEq, Serialize, Deserialize, Debug, Clone,
+)]
 #[belongs_to(Post)]
 #[table_name = "post_report"]
 pub struct PostReport {

lemmy_db/src/views/comment_view.rs

@@ -519,6 +519,8 @@ mod tests {
 
     let _inserted_comment_like = CommentLike::like(&conn, &comment_like_form).unwrap();
 
+    let agg = CommentAggregates::read(&conn, inserted_comment.id).unwrap();
+
     let expected_comment_view_no_user = CommentView {
       creator_banned_from_community: false,
       my_vote: None,
@@ -594,7 +596,7 @@ mod tests {
         published: inserted_community.published,
       },
       counts: CommentAggregates {
-        id: inserted_comment.id, // TODO
+        id: agg.id,
         comment_id: inserted_comment.id,
         score: 1,
         upvotes: 1,

lemmy_db/src/views/post_view.rs

@@ -188,7 +188,7 @@ impl<'a> PostQueryBuilder<'a> {
   }
 
   pub fn my_user_id<T: MaybeOptional<i32>>(mut self, my_user_id: T) -> Self {
-    self.community_id = my_user_id.get_optional();
+    self.my_user_id = my_user_id.get_optional();
     self
   }
 
@@ -531,6 +531,8 @@ mod tests {
     let read_post_listing_with_user =
       PostView::read(&conn, inserted_post.id, Some(inserted_user.id)).unwrap();
 
+    let agg = PostAggregates::read(&conn, inserted_post.id).unwrap();
+
     // the non user version
     let expected_post_listing_no_user = PostView {
       post: Post {
@@ -590,7 +592,7 @@ mod tests {
         published: inserted_community.published,
       },
       counts: PostAggregates {
-        id: inserted_post.id, // TODO this might fail
+        id: agg.id,
         post_id: inserted_post.id,
         comments: 0,
         score: 1,

test.sh

@@ -1,8 +1,9 @@
 #!/bin/sh
 export DATABASE_URL=postgres://lemmy:password@localhost:5432/lemmy
-diesel migration run
 export LEMMY_DATABASE_URL=postgres://lemmy:password@localhost:5432/lemmy
+# Commenting since this will overwrite schema.rs, which will break things now
+# diesel migration run
 # Integration tests only work on stable due to a bug in config-rs
 # https://github.com/mehcode/config-rs/issues/158
 RUST_BACKTRACE=1 RUST_TEST_THREADS=1 \
-  cargo +stable test --workspace --no-fail-fast
+  cargo +1.47.0 test --workspace --no-fail-fast