2019-04-29 20:27:42 -04:00
|
|
|
# frozen_string_literal: true
|
|
|
|
|
2015-10-11 05:41:23 -04:00
|
|
|
require 'rails_helper'
|
2013-09-03 17:19:29 -04:00
|
|
|
|
|
|
|
describe PostSerializer do
|
2019-05-09 22:04:29 -04:00
|
|
|
fab!(:post) { Fabricate(:post) }
|
2013-09-03 17:19:29 -04:00
|
|
|
|
2013-10-03 19:48:03 -04:00
|
|
|
context "a post with lots of actions" do
|
2019-05-06 23:12:20 -04:00
|
|
|
fab!(:actor) { Fabricate(:user) }
|
|
|
|
fab!(:admin) { Fabricate(:admin) }
|
2014-06-26 13:19:35 -04:00
|
|
|
let(:acted_ids) {
|
2013-10-03 19:48:03 -04:00
|
|
|
PostActionType.public_types.values
|
2017-10-17 13:31:45 -04:00
|
|
|
.concat([:notify_user, :spam].map { |k| PostActionType.types[k] })
|
2013-10-03 19:48:03 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
def visible_actions_for(user)
|
|
|
|
serializer = PostSerializer.new(post, scope: Guardian.new(user), root: false)
|
|
|
|
# NOTE this is messy, we should extract all this logic elsewhere
|
|
|
|
serializer.post_actions = PostAction.counts_for([post], actor)[post.id] if user.try(:id) == actor.id
|
|
|
|
actions = serializer.as_json[:actions_summary]
|
|
|
|
lookup = PostActionType.types.invert
|
2015-07-14 15:50:27 -04:00
|
|
|
actions.keep_if { |a| (a[:count] || 0) > 0 }.map { |a| lookup[a[:id]] }
|
2013-10-03 19:48:03 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
before do
|
|
|
|
acted_ids.each do |id|
|
2019-01-03 12:03:01 -05:00
|
|
|
PostActionCreator.new(actor, post, id).perform
|
2013-10-03 19:48:03 -04:00
|
|
|
end
|
|
|
|
post.reload
|
|
|
|
end
|
|
|
|
|
|
|
|
it "displays the correct info" do
|
2018-07-09 04:54:18 -04:00
|
|
|
expect(visible_actions_for(actor).sort).to eq([:like, :notify_user, :spam])
|
|
|
|
expect(visible_actions_for(post.user).sort).to eq([:like])
|
|
|
|
expect(visible_actions_for(nil).sort).to eq([:like])
|
|
|
|
expect(visible_actions_for(admin).sort).to eq([:like, :notify_user, :spam])
|
2013-10-03 19:48:03 -04:00
|
|
|
end
|
|
|
|
|
2014-07-25 16:36:57 -04:00
|
|
|
it "can't flag your own post to notify yourself" do
|
|
|
|
serializer = PostSerializer.new(post, scope: Guardian.new(post.user), root: false)
|
|
|
|
notify_user_action = serializer.actions_summary.find { |a| a[:id] == PostActionType.types[:notify_user] }
|
2015-07-14 15:50:27 -04:00
|
|
|
expect(notify_user_action).to be_blank
|
2015-07-15 11:18:01 -04:00
|
|
|
end
|
2019-05-09 22:04:29 -04:00
|
|
|
|
|
|
|
it "should not allow user to flag post and notify non human user" do
|
|
|
|
post.update!(user: Discourse.system_user)
|
|
|
|
|
|
|
|
serializer = PostSerializer.new(post,
|
|
|
|
scope: Guardian.new(actor),
|
|
|
|
root: false
|
|
|
|
)
|
|
|
|
|
|
|
|
notify_user_action = serializer.actions_summary.find do |a|
|
|
|
|
a[:id] == PostActionType.types[:notify_user]
|
|
|
|
end
|
|
|
|
|
|
|
|
expect(notify_user_action).to eq(nil)
|
|
|
|
end
|
2013-10-03 19:48:03 -04:00
|
|
|
end
|
|
|
|
|
2019-05-03 14:26:37 -04:00
|
|
|
context "a post with reviewable content" do
|
|
|
|
let!(:reviewable) { PostActionCreator.spam(Fabricate(:user), post).reviewable }
|
|
|
|
|
|
|
|
it "includes the reviewable data" do
|
|
|
|
json = PostSerializer.new(post, scope: Guardian.new(Fabricate(:moderator)), root: false).as_json
|
|
|
|
expect(json[:reviewable_id]).to eq(reviewable.id)
|
|
|
|
expect(json[:reviewable_score_count]).to eq(1)
|
|
|
|
expect(json[:reviewable_score_pending_count]).to eq(1)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2013-09-03 17:19:29 -04:00
|
|
|
context "a post by a nuked user" do
|
|
|
|
before do
|
2019-05-09 22:04:29 -04:00
|
|
|
post.update!(
|
|
|
|
user_id: nil,
|
|
|
|
deleted_at: Time.zone.now
|
|
|
|
)
|
2013-09-03 17:19:29 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
subject { PostSerializer.new(post, scope: Guardian.new(Fabricate(:admin)), root: false).as_json }
|
|
|
|
|
|
|
|
it "serializes correctly" do
|
2014-09-25 11:44:48 -04:00
|
|
|
[:name, :username, :display_username, :avatar_template, :user_title, :trust_level].each do |attr|
|
2014-12-31 09:55:03 -05:00
|
|
|
expect(subject[attr]).to be_nil
|
2013-09-03 17:19:29 -04:00
|
|
|
end
|
2014-09-25 11:44:48 -04:00
|
|
|
[:moderator, :staff, :yours].each do |attr|
|
2014-12-31 09:55:03 -05:00
|
|
|
expect(subject[attr]).to eq(false)
|
2013-09-03 17:19:29 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2013-10-30 15:45:13 -04:00
|
|
|
context "display_username" do
|
2019-05-09 22:04:29 -04:00
|
|
|
let(:user) { post.user }
|
2013-10-30 15:45:13 -04:00
|
|
|
let(:serializer) { PostSerializer.new(post, scope: Guardian.new, root: false) }
|
|
|
|
let(:json) { serializer.as_json }
|
|
|
|
|
|
|
|
it "returns the display_username it when `enable_names` is on" do
|
2017-07-07 02:09:14 -04:00
|
|
|
SiteSetting.enable_names = true
|
2014-12-31 09:55:03 -05:00
|
|
|
expect(json[:display_username]).to be_present
|
2013-10-30 15:45:13 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
it "doesn't return the display_username it when `enable_names` is off" do
|
2017-07-07 02:09:14 -04:00
|
|
|
SiteSetting.enable_names = false
|
2014-12-31 09:55:03 -05:00
|
|
|
expect(json[:display_username]).to be_blank
|
2013-10-30 15:45:13 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2014-04-15 12:48:49 -04:00
|
|
|
context "a hidden post with add_raw enabled" do
|
2020-06-09 03:40:41 -04:00
|
|
|
let(:user) { Fabricate.build(:user, id: -99999) }
|
2014-04-30 14:21:43 -04:00
|
|
|
let(:raw) { "Raw contents of the post." }
|
2014-04-15 12:48:49 -04:00
|
|
|
|
2014-04-30 14:21:43 -04:00
|
|
|
context "a public post" do
|
|
|
|
let(:post) { Fabricate.build(:post, raw: raw, user: user) }
|
2014-04-15 12:48:49 -04:00
|
|
|
|
2014-04-30 14:21:43 -04:00
|
|
|
it "includes the raw post for everyone" do
|
2014-06-26 13:19:35 -04:00
|
|
|
[nil, user, Fabricate(:user), Fabricate(:moderator), Fabricate(:admin)].each do |user|
|
2014-12-31 09:55:03 -05:00
|
|
|
expect(serialized_post_for_user(user)[:raw]).to eq(raw)
|
2014-06-26 13:19:35 -04:00
|
|
|
end
|
2014-04-30 14:21:43 -04:00
|
|
|
end
|
2014-04-15 12:48:49 -04:00
|
|
|
end
|
|
|
|
|
2014-04-30 14:21:43 -04:00
|
|
|
context "a hidden post" do
|
|
|
|
let(:post) { Fabricate.build(:post, raw: raw, user: user, hidden: true, hidden_reason_id: Post.hidden_reasons[:flag_threshold_reached]) }
|
|
|
|
|
|
|
|
it "shows the raw post only if authorized to see it" do
|
2014-12-31 09:55:03 -05:00
|
|
|
expect(serialized_post_for_user(nil)[:raw]).to eq(nil)
|
|
|
|
expect(serialized_post_for_user(Fabricate(:user))[:raw]).to eq(nil)
|
2014-06-26 13:19:35 -04:00
|
|
|
|
2014-12-31 09:55:03 -05:00
|
|
|
expect(serialized_post_for_user(user)[:raw]).to eq(raw)
|
|
|
|
expect(serialized_post_for_user(Fabricate(:moderator))[:raw]).to eq(raw)
|
|
|
|
expect(serialized_post_for_user(Fabricate(:admin))[:raw]).to eq(raw)
|
2014-04-30 14:21:43 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
it "can view edit history only if authorized" do
|
2014-12-31 09:55:03 -05:00
|
|
|
expect(serialized_post_for_user(nil)[:can_view_edit_history]).to eq(false)
|
|
|
|
expect(serialized_post_for_user(Fabricate(:user))[:can_view_edit_history]).to eq(false)
|
2014-06-26 13:19:35 -04:00
|
|
|
|
2014-12-31 09:55:03 -05:00
|
|
|
expect(serialized_post_for_user(user)[:can_view_edit_history]).to eq(true)
|
|
|
|
expect(serialized_post_for_user(Fabricate(:moderator))[:can_view_edit_history]).to eq(true)
|
|
|
|
expect(serialized_post_for_user(Fabricate(:admin))[:can_view_edit_history]).to eq(true)
|
2014-06-26 13:19:35 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2018-10-31 10:47:00 -04:00
|
|
|
context "a hidden revised post" do
|
2019-05-10 06:59:31 -04:00
|
|
|
fab!(:post) { Fabricate(:post, raw: 'Hello world!', hidden: true) }
|
2018-10-31 10:47:00 -04:00
|
|
|
|
|
|
|
before do
|
|
|
|
SiteSetting.editing_grace_period_max_diff = 1
|
|
|
|
|
|
|
|
revisor = PostRevisor.new(post)
|
|
|
|
revisor.revise!(post.user, raw: 'Hello, everyone!')
|
|
|
|
end
|
|
|
|
|
|
|
|
it "will not leak version to users" do
|
|
|
|
json = PostSerializer.new(post, scope: Guardian.new(user), root: false).as_json
|
|
|
|
expect(json[:version]).to eq(1)
|
|
|
|
end
|
|
|
|
|
|
|
|
it "will show real version to staff" do
|
|
|
|
json = PostSerializer.new(post, scope: Guardian.new(Fabricate(:admin)), root: false).as_json
|
|
|
|
expect(json[:version]).to eq(2)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2014-06-26 13:19:35 -04:00
|
|
|
context "a public wiki post" do
|
|
|
|
let(:post) { Fabricate.build(:post, raw: raw, user: user, wiki: true) }
|
|
|
|
|
|
|
|
it "can view edit history" do
|
|
|
|
[nil, user, Fabricate(:user), Fabricate(:moderator), Fabricate(:admin)].each do |user|
|
2014-12-31 09:55:03 -05:00
|
|
|
expect(serialized_post_for_user(user)[:can_view_edit_history]).to eq(true)
|
2014-06-26 13:19:35 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context "a hidden wiki post" do
|
2018-06-05 03:29:17 -04:00
|
|
|
let(:post) {
|
|
|
|
Fabricate.build(
|
|
|
|
:post,
|
|
|
|
raw: raw,
|
|
|
|
user: user,
|
|
|
|
wiki: true,
|
|
|
|
hidden: true,
|
|
|
|
hidden_reason_id: Post.hidden_reasons[:flag_threshold_reached])
|
|
|
|
}
|
2014-06-26 13:19:35 -04:00
|
|
|
|
|
|
|
it "can view edit history only if authorized" do
|
2014-12-31 09:55:03 -05:00
|
|
|
expect(serialized_post_for_user(nil)[:can_view_edit_history]).to eq(false)
|
|
|
|
expect(serialized_post_for_user(Fabricate(:user))[:can_view_edit_history]).to eq(false)
|
|
|
|
expect(serialized_post_for_user(user)[:can_view_edit_history]).to eq(true)
|
|
|
|
expect(serialized_post_for_user(Fabricate(:moderator))[:can_view_edit_history]).to eq(true)
|
|
|
|
expect(serialized_post_for_user(Fabricate(:admin))[:can_view_edit_history]).to eq(true)
|
2014-04-30 14:21:43 -04:00
|
|
|
end
|
|
|
|
end
|
2014-06-26 13:19:35 -04:00
|
|
|
|
2014-04-15 12:48:49 -04:00
|
|
|
end
|
|
|
|
|
2019-03-11 05:19:58 -04:00
|
|
|
context "a post with notices" do
|
2019-05-10 06:59:31 -04:00
|
|
|
fab!(:user) { Fabricate(:user, trust_level: 1) }
|
|
|
|
fab!(:user_tl1) { Fabricate(:user, trust_level: 1) }
|
|
|
|
fab!(:user_tl2) { Fabricate(:user, trust_level: 2) }
|
2019-03-11 05:19:58 -04:00
|
|
|
|
|
|
|
let(:post) {
|
|
|
|
post = Fabricate(:post, user: user)
|
2020-11-11 07:49:53 -05:00
|
|
|
post.custom_fields[Post::NOTICE] = { type: Post.notices[:returning_user], last_posted_at: 1.day.ago }
|
2019-03-11 05:19:58 -04:00
|
|
|
post.save_custom_fields
|
|
|
|
post
|
|
|
|
}
|
|
|
|
|
|
|
|
def json_for_user(user)
|
|
|
|
PostSerializer.new(post, scope: Guardian.new(user), root: false).as_json
|
|
|
|
end
|
|
|
|
|
2019-04-10 15:06:27 -04:00
|
|
|
it "is visible for TL2+ users (except poster)" do
|
2020-11-11 07:49:53 -05:00
|
|
|
expect(json_for_user(nil)[:notice]).to eq(nil)
|
|
|
|
expect(json_for_user(user)[:notice]).to eq(nil)
|
2019-03-12 17:06:28 -04:00
|
|
|
|
2019-04-19 10:53:58 -04:00
|
|
|
SiteSetting.returning_user_notice_tl = 2
|
2020-11-11 07:49:53 -05:00
|
|
|
expect(json_for_user(user_tl1)[:notice]).to eq(nil)
|
|
|
|
expect(json_for_user(user_tl2)[:notice][:type]).to eq(Post.notices[:returning_user])
|
2019-03-12 17:06:28 -04:00
|
|
|
|
2019-04-19 10:53:58 -04:00
|
|
|
SiteSetting.returning_user_notice_tl = 1
|
2020-11-11 07:49:53 -05:00
|
|
|
expect(json_for_user(user_tl1)[:notice][:type]).to eq(Post.notices[:returning_user])
|
|
|
|
expect(json_for_user(user_tl2)[:notice][:type]).to eq(Post.notices[:returning_user])
|
2019-04-10 15:06:27 -04:00
|
|
|
end
|
2019-03-11 05:19:58 -04:00
|
|
|
end
|
|
|
|
|
2019-12-10 23:04:02 -05:00
|
|
|
context "post with bookmarks" do
|
|
|
|
let(:current_user) { Fabricate(:user) }
|
2019-12-12 01:28:01 -05:00
|
|
|
let(:topic_view) { TopicView.new(post.topic, current_user) }
|
2019-12-10 23:04:02 -05:00
|
|
|
let(:serialized) do
|
|
|
|
s = serialized_post(current_user)
|
|
|
|
s.post_actions = PostAction.counts_for([post], current_user)[post.id]
|
2019-12-12 01:28:01 -05:00
|
|
|
s.topic_view = topic_view
|
2019-12-10 23:04:02 -05:00
|
|
|
s
|
|
|
|
end
|
|
|
|
|
|
|
|
context "when a Bookmark record exists for the user on the post" do
|
|
|
|
let!(:bookmark) { Fabricate(:bookmark_next_business_day_reminder, user: current_user, post: post) }
|
|
|
|
|
2020-04-21 23:44:19 -04:00
|
|
|
context "bookmarks with reminders" do
|
2019-12-10 23:04:02 -05:00
|
|
|
it "returns true" do
|
2020-04-29 20:09:22 -04:00
|
|
|
expect(serialized.as_json[:bookmarked]).to eq(true)
|
2019-12-10 23:04:02 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
it "returns the reminder_at for the bookmark" do
|
|
|
|
expect(serialized.as_json[:bookmark_reminder_at]).to eq(bookmark.reminder_at.iso8601)
|
|
|
|
end
|
2019-12-12 01:28:01 -05:00
|
|
|
|
|
|
|
context "if topic_view is blank" do
|
|
|
|
let(:topic_view) { nil }
|
|
|
|
|
2020-07-10 00:35:53 -04:00
|
|
|
it "the bookmarked attribute will be false" do
|
|
|
|
expect(serialized.as_json[:bookmarked]).to eq(false)
|
2019-12-12 01:28:01 -05:00
|
|
|
end
|
|
|
|
end
|
2019-12-10 23:04:02 -05:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-07-28 17:15:04 -04:00
|
|
|
context "posts when group moderation is enabled" do
|
|
|
|
fab!(:topic) { Fabricate(:topic) }
|
|
|
|
fab!(:group_user) { Fabricate(:group_user) }
|
|
|
|
fab!(:post) { Fabricate(:post, topic: topic) }
|
|
|
|
|
|
|
|
before do
|
|
|
|
SiteSetting.enable_category_group_moderation = true
|
|
|
|
topic.category.update!(reviewable_by_group_id: group_user.group.id)
|
|
|
|
end
|
|
|
|
|
|
|
|
it "does nothing for regular users" do
|
|
|
|
expect(serialized_post_for_user(nil)[:group_moderator]).to eq(nil)
|
|
|
|
end
|
|
|
|
|
|
|
|
it "returns a group_moderator attribute for category group moderators" do
|
|
|
|
post.update!(user: group_user.user)
|
|
|
|
expect(serialized_post_for_user(nil)[:group_moderator]).to eq(true)
|
|
|
|
end
|
|
|
|
|
|
|
|
end
|
|
|
|
|
2019-12-10 23:04:02 -05:00
|
|
|
def serialized_post(u)
|
|
|
|
s = PostSerializer.new(post, scope: Guardian.new(u), root: false)
|
|
|
|
s.add_raw = true
|
|
|
|
s
|
|
|
|
end
|
|
|
|
|
|
|
|
def serialized_post_for_user(u)
|
|
|
|
s = serialized_post(u)
|
|
|
|
s.as_json
|
|
|
|
end
|
2013-09-03 17:19:29 -04:00
|
|
|
end
|