mirror of
https://github.com/discourse/discourse.git
synced 2026-08-09 21:45:25 +08:00
b289f374daFollows up dbcdcdbcd2.
When AI spam detection (or other automation) flags a post and
silences/suspends the user, deleting that post would auto-ignore the
reviewable — leaving the user penalized with no staff review. Staff had
no visibility into what happened.
This change:
- Checks if the user was silenced or suspended for the specific post
before auto-ignoring the reviewable. If penalized, the reviewable stays
pending so staff can review and decide whether to lift the penalty.
- Adds a "Post deleted by X" event to the reviewable timeline, giving
staff visibility into author deletions when reviewing flagged content.
- Fixes a bug in discourse-ai's `llm_triage.rb` where `@post` was
incorrectly referenced instead of the local `post` variable when
recording silences.
The note that was previously created on author deletion is removed since
the timeline event now provides this visibility in a cleaner way.
Ref - https://meta.discourse.org/t/392090
99 lines
3.6 KiB
Ruby
Vendored
99 lines
3.6 KiB
Ruby
Vendored
# 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 "will not throw 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
|
|
|
|
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
|
|
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
|
|
end
|
