Skip to content

A platform for community discussion. Free, open, simple.

5.8 KB
Raw Blame
# frozen_string_literal: true

RSpec.describe ReviewableSerializer do
  fab!(:reviewable, :reviewable_queued_post)
  fab!(:reviewable_user)
  fab!(:admin)

  it "serializes all the fields" do
    json = described_class.new(reviewable, scope: Guardian.new(admin), root: nil).as_json

    expect(json[:id]).to eq(reviewable.id)
    expect(json[:status]).to eq(reviewable.status_for_database)
    expect(json[:type]).to eq(reviewable.type)
    expect(json[:type_source]).to eq(reviewable.type_source)
    expect(json[:created_at]).to eq(reviewable.created_at)
    expect(json[:category_id]).to eq(reviewable.category_id)
    expect(json[:can_edit]).to eq(true)
    expect(json[:version]).to eq(0)
    expect(json[:removed_topic_id]).to be_nil
    expect(json[:created_from_flag]).to eq(false)
  end

  it "Includes the removed topic id when the topis was deleted" do
    reviewable.topic.trash!(admin)
    json = described_class.new(reviewable.reload, scope: Guardian.new(admin), root: nil).as_json
    expect(json[:removed_topic_id]).to eq reviewable.topic_id
  end

  it "does not raise an error when the payload is nil" do
    reviewable.payload = nil
    json =
      ReviewableQueuedPostSerializer.new(reviewable, scope: Guardian.new(admin), root: nil).as_json
    expect(json["payload"]).to be_blank
  end

  it "resolves note mentions in a constant number of queries" do
    SiteSetting.enable_mentions = true
    users = Fabricate.times(3, :user)
    Fabricate(
      :reviewable_note,
      reviewable: reviewable,
      user: admin,
      content: "@#{users.first.username}",
    )
    loaded_reviewable = Reviewable.viewable_by(admin).find(reviewable.id)
    described_class.new(loaded_reviewable, scope: admin.guardian).as_json
    queries_for_one =
      track_sql_queries { described_class.new(loaded_reviewable, scope: admin.guardian).as_json }

    users
      .drop(1)
      .each do |user|
        Fabricate(
          :reviewable_note,
          reviewable: reviewable,
          user: admin,
          content: "@#{user.username}",
        )
      end
    loaded_reviewable = Reviewable.viewable_by(admin).find(reviewable.id)
    described_class.new(loaded_reviewable, scope: admin.guardian).as_json
    json = nil
    queries_for_many =
      track_sql_queries do
        json = described_class.new(loaded_reviewable, scope: admin.guardian).as_json
      end

    expect(queries_for_many.size).to eq(queries_for_one.size)
    mentions =
      json
        .fetch(:reviewable_notes)
        .flat_map { |note| Nokogiri::HTML5.fragment(note[:cooked]).css("a.mention").map(&:text) }
    expect(mentions).to contain_exactly(*users.map { |user| "@#{user.username}" })
  end

  describe "urls" do
    it "links to the flagged post" do
      fp = Fabricate(:reviewable_flagged_post)
      json = described_class.new(fp, scope: Guardian.new(admin), root: nil).as_json
      expect(json[:target_url]).to eq(Discourse.base_url + fp.post.url)
      expect(json[:topic_url]).to eq(fp.topic.url)
    end

    it "supports deleted topics" do
      fp = Fabricate(:reviewable_flagged_post)
      fp.topic.trash!(admin)
      fp.reload

      json = described_class.new(fp, scope: Guardian.new(admin), root: nil).as_json
      expect(json[:topic_url]).to be_blank
    end

    it "links to the queued post" do
      json = described_class.new(reviewable, scope: Guardian.new(admin), root: nil).as_json
      expect(json[:target_url]).to eq(reviewable.topic.url)
      expect(json[:topic_url]).to eq(reviewable.topic.url)
    end
  end

  describe "target_created_by" do
    it "serializes the user who created a reviewable post" do
      json = described_class.new(reviewable, scope: Guardian.new(admin), root: nil).as_json
      expect(json[:target_created_by_id]).to eq(reviewable.target_created_by.id)
    end

    it "serializes a reviewable user directly" do
      json = described_class.new(reviewable_user, scope: Guardian.new(admin), root: nil).as_json
      expect(json[:target_created_by_id]).to eq(reviewable_user.target.id)
    end

    it "includes FlaggedUserSerializer fields when the flagger is also the post author" do
      post = Fabricate(:post, user: admin)
      reviewable = PostActionCreator.off_topic(admin, post).reviewable

      json = ReviewableFlaggedPostSerializer.new(reviewable, scope: Guardian.new(admin)).as_json
      target_user = json["users"].find { |u| u[:id] == admin.id }

      expect(target_user).to be_present
      expect(target_user).to include(:created_at, :post_count, :trust_level)
    end
  end

  describe "target_deleted_by" do
    it "serializes when post was staff-deleted" do
      fp = Fabricate(:reviewable_flagged_post)
      fp.target.trash!(admin)
      fp.reload

      json = described_class.new(fp, scope: Guardian.new(admin), root: nil).as_json
      post = Post.with_deleted.find(fp.target_id)
      expect(json[:target_deleted_by_id]).to eq(admin.id)
      expect(json[:target_deleted_at]).to eq(post.deleted_at)
    end

    it "serializes when post was user-deleted" do
      fp = Fabricate(:reviewable_flagged_post)
      post = fp.target

      freeze_time do
        revision = post.revisions.create!(user: post.user, modifications: {})
        post.update!(user_deleted: true)
        fp.reload

        json = described_class.new(fp, scope: Guardian.new(admin), root: nil).as_json
        expect(json[:target_deleted_by_id]).to eq(post.user.id)
        expect(json[:target_deleted_at]).to eq_time(revision.created_at)
      end
    end
  end

  describe "topic_tags" do
    it "returns tag objects with id, name, and slug" do
      SiteSetting.tagging_enabled = true
      tag = Fabricate(:tag)
      reviewable.topic.tags = [tag]
      json = described_class.new(reviewable, scope: Guardian.new(admin), root: nil).as_json
      expect(json[:topic_tags]).to eq([{ id: tag.id, name: tag.name, slug: tag.slug }])
    end
  end
end