A platform for community discussion. Free, open, simple.
# 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