discourse/spec/models/post_action_spec.rb

1189 lines
40 KiB
Ruby

require 'rails_helper'
require_dependency 'post_destroyer'
describe PostAction do
it { is_expected.to rate_limit }
let(:moderator) { Fabricate(:moderator) }
let(:codinghorror) { Fabricate(:coding_horror) }
let(:eviltrout) { Fabricate(:evil_trout) }
let(:admin) { Fabricate(:admin) }
let(:post) { Fabricate(:post) }
let(:second_post) { Fabricate(:post, topic: post.topic) }
let(:bookmark) { PostAction.new(user_id: post.user_id, post_action_type_id: PostActionType.types[:bookmark] , post_id: post.id) }
def value_for(user_id, dt)
GivenDailyLike.find_for(user_id, dt).pluck(:likes_given)[0] || 0
end
describe "rate limits" do
it "limits redo/undo" do
RateLimiter.enable
PostAction.act(eviltrout, post, PostActionType.types[:like])
PostAction.remove_act(eviltrout, post, PostActionType.types[:like])
PostAction.act(eviltrout, post, PostActionType.types[:like])
PostAction.remove_act(eviltrout, post, PostActionType.types[:like])
expect {
PostAction.act(eviltrout, post, PostActionType.types[:like])
}.to raise_error(RateLimiter::LimitExceeded)
end
end
describe "messaging" do
it "doesn't generate title longer than 255 characters" do
topic = create_topic(title: "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc sit amet rutrum neque. Pellentesque suscipit vehicula facilisis. Phasellus lacus sapien, aliquam nec convallis sit amet, vestibulum laoreet ante. Curabitur et pellentesque tortor. Donec non.")
post = create_post(topic: topic)
expect { PostAction.act(admin, post, PostActionType.types[:notify_user], message: "WAT") }.not_to raise_error
end
it "notify moderators integration test" do
post = create_post
mod = moderator
Group.refresh_automatic_groups!
action = PostAction.act(codinghorror, post, PostActionType.types[:notify_moderators], message: "this is my special long message")
posts = Post.joins(:topic)
.select('posts.id, topics.subtype, posts.topic_id')
.where('topics.archetype' => Archetype.private_message)
.to_a
expect(posts.count).to eq(1)
expect(action.related_post_id).to eq(posts[0].id.to_i)
expect(posts[0].subtype).to eq(TopicSubtype.notify_moderators)
topic = posts[0].topic
# Moderators should be invited to the private topic, otherwise they're not permitted to see it
topic_user_ids = topic.reload.topic_users.map { |x| x.user_id }
expect(topic_user_ids).to include(codinghorror.id)
expect(topic_user_ids).to include(mod.id)
expect(topic.topic_users.where(user_id: mod.id)
.pluck(:notification_level).first).to eq(TopicUser.notification_levels[:tracking])
expect(topic.topic_users.where(user_id: codinghorror.id)
.pluck(:notification_level).first).to eq(TopicUser.notification_levels[:watching])
# reply to PM should not clear flag
PostCreator.new(mod, topic_id: posts[0].topic_id, raw: "This is my test reply to the user, it should clear flags").create
action.reload
expect(action.deleted_at).to eq(nil)
# Acting on the flag should not post an automated status message (since a moderator already replied)
expect(topic.posts.count).to eq(2)
PostAction.agree_flags!(post, admin)
expect(action.user.user_stat.flags_agreed).to eq(1)
expect(action.user.user_stat.flags_disagreed).to eq(0)
topic.reload
expect(topic.posts.count).to eq(2)
# Clearing the flags should not post an automated status message
new_action = PostAction.act(mod, post, PostActionType.types[:notify_moderators], message: "another special message")
PostAction.clear_flags!(post, admin)
expect(new_action.user.user_stat.flags_agreed).to eq(0)
expect(new_action.user.user_stat.flags_disagreed).to eq(1)
topic.reload
expect(topic.posts.count).to eq(2)
# Acting on the flag should post an automated status message
another_post = create_post
action = PostAction.act(codinghorror, another_post, PostActionType.types[:notify_moderators], message: "foobar")
topic = action.related_post.topic
expect(topic.posts.count).to eq(1)
PostAction.agree_flags!(another_post, admin)
expect(action.user.user_stat.flags_agreed).to eq(2)
expect(action.user.user_stat.flags_disagreed).to eq(0)
topic.reload
expect(topic.posts.count).to eq(2)
expect(topic.posts.last.post_type).to eq(Post.types[:moderator_action])
end
describe 'notify_moderators' do
before do
PostAction.stubs(:create)
end
it "creates a pm if selected" do
post = build(:post, id: 1000)
PostCreator.any_instance.expects(:create).returns(post)
PostAction.act(build(:user), build(:post), PostActionType.types[:notify_moderators], message: "this is my special message")
end
end
describe "notify_user" do
before do
PostAction.stubs(:create)
post = build(:post)
post.user = build(:user)
end
it "sends an email to user if selected" do
PostCreator.any_instance.expects(:create).returns(build(:post))
PostAction.act(build(:user), post, PostActionType.types[:notify_user], message: "this is my special message")
end
end
end
describe "flag counts" do
before do
PostAction.update_flagged_posts_count
end
it "increments the numbers correctly" do
expect(PostAction.flagged_posts_count).to eq(0)
PostAction.act(codinghorror, post, PostActionType.types[:off_topic])
expect(PostAction.flagged_posts_count).to eq(1)
PostAction.clear_flags!(post, Discourse.system_user)
expect(PostAction.flagged_posts_count).to eq(0)
end
it "respects min_flags_staff_visibility" do
SiteSetting.min_flags_staff_visibility = 2
expect(PostAction.flagged_posts_count).to eq(0)
PostAction.act(codinghorror, post, PostActionType.types[:off_topic])
expect(PostAction.flagged_posts_count).to eq(0)
PostAction.act(eviltrout, post, PostActionType.types[:off_topic])
expect(PostAction.flagged_posts_count).to eq(1)
end
it "tl3 hidden posts will supersede min_flags_staff_visibility" do
SiteSetting.min_flags_staff_visibility = 2
expect(PostAction.flagged_posts_count).to eq(0)
codinghorror.update_column(:trust_level, 3)
post.user.update_column(:trust_level, 0)
PostAction.act(codinghorror, post, PostActionType.types[:spam])
expect(PostAction.flagged_posts_count).to eq(1)
end
it "tl4 hidden posts will supersede min_flags_staff_visibility" do
SiteSetting.min_flags_staff_visibility = 2
expect(PostAction.flagged_posts_count).to eq(0)
codinghorror.update_column(:trust_level, 4)
PostAction.act(codinghorror, post, PostActionType.types[:off_topic])
expect(PostAction.flagged_posts_count).to eq(1)
end
it "should reset counts when a topic is deleted" do
PostAction.act(codinghorror, post, PostActionType.types[:off_topic])
post.topic.trash!
expect(PostAction.flagged_posts_count).to eq(0)
end
it "should ignore flags on non-human users" do
post = create_post(user: Discourse.system_user)
PostAction.act(codinghorror, post, PostActionType.types[:off_topic])
expect(PostAction.flagged_posts_count).to eq(0)
end
it "should ignore validated flags" do
post = create_post
PostAction.act(codinghorror, post, PostActionType.types[:off_topic])
expect(post.hidden).to eq(false)
expect(post.hidden_at).to be_blank
PostAction.defer_flags!(post, admin)
expect(PostAction.flagged_posts_count).to eq(0)
post.reload
expect(post.hidden).to eq(false)
expect(post.hidden_at).to be_blank
PostAction.hide_post!(post, PostActionType.types[:off_topic])
post.reload
expect(post.hidden).to eq(true)
expect(post.hidden_at).to be_present
end
end
describe "update_counters" do
it "properly updates topic counters" do
freeze_time Date.today
# we need this to test it
TopicUser.change(codinghorror, post.topic, posted: true)
expect(value_for(moderator.id, Date.today)).to eq(0)
PostAction.act(moderator, post, PostActionType.types[:like])
PostAction.act(codinghorror, second_post, PostActionType.types[:like])
post.topic.reload
expect(post.topic.like_count).to eq(2)
expect(value_for(moderator.id, Date.today)).to eq(1)
tu = TopicUser.get(post.topic, codinghorror)
expect(tu.liked).to be true
expect(tu.bookmarked).to be false
end
end
describe "when a user bookmarks something" do
it "increases the post's bookmark count when saved" do
expect { bookmark.save; post.reload }.to change(post, :bookmark_count).by(1)
end
describe 'when deleted' do
before do
bookmark.save
post.reload
@topic = post.topic
@topic.reload
bookmark.deleted_at = DateTime.now
bookmark.save
end
it 'reduces the bookmark count of the post' do
expect { post.reload }.to change(post, :bookmark_count).by(-1)
end
end
end
describe "undo/redo repeatedly" do
it "doesn't create a second action for the same user/type" do
PostAction.act(codinghorror, post, PostActionType.types[:like])
PostAction.remove_act(codinghorror, post, PostActionType.types[:like])
PostAction.act(codinghorror, post, PostActionType.types[:like])
expect(PostAction.where(post: post).with_deleted.count).to eq(1)
PostAction.remove_act(codinghorror, post, PostActionType.types[:like])
# Check that we don't lose consistency into negatives
expect(post.reload.like_count).to eq(0)
end
end
describe 'when a user likes something' do
before do
PostActionNotifier.enable
end
it 'should generate and remove notifications correctly' do
PostAction.act(codinghorror, post, PostActionType.types[:like])
expect(Notification.count).to eq(1)
notification = Notification.last
expect(notification.user_id).to eq(post.user_id)
expect(notification.notification_type).to eq(Notification.types[:liked])
PostAction.remove_act(codinghorror, post, PostActionType.types[:like])
expect(Notification.count).to eq(0)
PostAction.act(codinghorror, post, PostActionType.types[:like])
expect(Notification.count).to eq(1)
notification = Notification.last
expect(notification.user_id).to eq(post.user_id)
expect(notification.notification_type).to eq(Notification.types[:liked])
end
it 'should not notify when never is selected' do
post.user.user_option.update!(
like_notification_frequency:
UserOption.like_notification_frequency_type[:never]
)
expect do
PostAction.act(codinghorror, post, PostActionType.types[:like])
end.to_not change { Notification.count }
end
it 'notifies on likes correctly' do
PostAction.act(eviltrout, post, PostActionType.types[:like])
PostAction.act(admin, post, PostActionType.types[:like])
# one like
expect(Notification.where(post_number: 1, topic_id: post.topic_id).count)
.to eq(1)
post.user.user_option.update!(
like_notification_frequency: UserOption.like_notification_frequency_type[:always]
)
admin2 = Fabricate(:admin)
# Travel 1 hour in time to test that order post_actions by `created_at`
freeze_time 1.hour.from_now
expect do
PostAction.act(admin2, post, PostActionType.types[:like])
end.to_not change { Notification.count }
# adds info to the notification
notification = Notification.find_by(
post_number: 1,
topic_id: post.topic_id
)
expect(notification.data_hash["count"].to_i).to eq(2)
expect(notification.data_hash["username2"]).to eq(eviltrout.username)
# this is a tricky thing ... removing a like should fix up the notifications
PostAction.remove_act(eviltrout, post, PostActionType.types[:like])
# rebuilds the missing notification
expect(Notification.where(post_number: 1, topic_id: post.topic_id).count)
.to eq(1)
notification = Notification.find_by(
post_number: 1,
topic_id: post.topic_id
)
expect(notification.data_hash["count"]).to eq(2)
expect(notification.data_hash["username"]).to eq(admin2.username)
expect(notification.data_hash["username2"]).to eq(admin.username)
post.user.user_option.update!(
like_notification_frequency:
UserOption.like_notification_frequency_type[:first_time_and_daily]
)
# this gets skipped
admin3 = Fabricate(:admin)
PostAction.act(admin3, post, PostActionType.types[:like])
freeze_time 2.days.from_now
admin4 = Fabricate(:admin)
PostAction.act(admin4, post, PostActionType.types[:like])
# first happend within the same day, no need to notify
expect(Notification.where(post_number: 1, topic_id: post.topic_id).count)
.to eq(2)
end
describe 'likes consolidation' do
let(:liker) { Fabricate(:user) }
let(:liker2) { Fabricate(:user) }
let(:likee) { Fabricate(:user) }
it "can be disabled" do
SiteSetting.likes_notification_consolidation_threshold = 0
expect do
PostAction.act(
liker,
Fabricate(:post, user: likee),
PostActionType.types[:like]
)
end.to change { likee.reload.notifications.count }.by(1)
SiteSetting.likes_notification_consolidation_threshold = 1
expect do
PostAction.act(
liker,
Fabricate(:post, user: likee),
PostActionType.types[:like]
)
end.to_not change { likee.reload.notifications.count }
end
describe 'frequency first_time_and_daily' do
before do
likee.user_option.update!(
like_notification_frequency:
UserOption.like_notification_frequency_type[:first_time_and_daily]
)
end
it 'should consolidate likes notification when the threshold is reached' do
SiteSetting.likes_notification_consolidation_threshold = 2
expect do
3.times do
PostAction.act(
liker,
Fabricate(:post, user: likee),
PostActionType.types[:like]
)
end
end.to change { likee.reload.notifications.count }.by(1)
notification = likee.notifications.last
expect(notification.notification_type).to eq(
Notification.types[:liked_consolidated]
)
data = JSON.parse(notification.data)
expect(data["username"]).to eq(liker.username)
expect(data["display_username"]).to eq(liker.username)
expect(data["count"]).to eq(3)
notification.update!(read: true)
expect do
2.times do
PostAction.act(
liker,
Fabricate(:post, user: likee),
PostActionType.types[:like]
)
end
end.to_not change { likee.reload.notifications.count }
data = JSON.parse(notification.reload.data)
expect(notification.read).to eq(false)
expect(data["count"]).to eq(5)
# Like from a different user shouldn't be consolidated
expect do
PostAction.act(
Fabricate(:user),
Fabricate(:post, user: likee),
PostActionType.types[:like]
)
end.to change { likee.reload.notifications.count }.by(1)
notification = likee.notifications.last
expect(notification.notification_type).to eq(
Notification.types[:liked]
)
freeze_time((
SiteSetting.likes_notification_consolidation_window_mins.minutes +
1
).since)
expect do
PostAction.act(
liker,
Fabricate(:post, user: likee),
PostActionType.types[:like]
)
end.to change { likee.reload.notifications.count }.by(1)
notification = likee.notifications.last
expect(notification.notification_type).to eq(Notification.types[:liked])
end
end
describe 'frequency always' do
before do
likee.user_option.update!(
like_notification_frequency:
UserOption.like_notification_frequency_type[:always]
)
end
it 'should consolidate liked notifications when threshold is reached' do
SiteSetting.likes_notification_consolidation_threshold = 2
post = Fabricate(:post, user: likee)
expect do
[liker2, liker].each do |user|
PostAction.act(user, post, PostActionType.types[:like])
end
end.to change { likee.reload.notifications.count }.by(1)
notification = likee.notifications.last
data_hash = notification.data_hash
expect(data_hash["original_username"]).to eq(liker.username)
expect(data_hash["username2"]).to eq(liker2.username)
expect(data_hash["count"].to_i).to eq(2)
expect do
2.times do
PostAction.act(
liker,
Fabricate(:post, user: likee),
PostActionType.types[:like]
)
end
end.to change { likee.reload.notifications.count }.by(2)
expect(likee.notifications.pluck(:notification_type).uniq)
.to contain_exactly(Notification.types[:liked])
expect do
PostAction.act(
liker,
Fabricate(:post, user: likee),
PostActionType.types[:like]
)
end.to change { likee.reload.notifications.count }.by(-1)
notification = likee.notifications.last
expect(notification.notification_type).to eq(
Notification.types[:liked_consolidated]
)
expect(notification.data_hash["count"].to_i).to eq(3)
expect(notification.data_hash["username"]).to eq(liker.username)
end
end
end
it "should not generate a notification if liker has been muted" do
mutee = Fabricate(:user)
MutedUser.create!(user_id: post.user.id, muted_user_id: mutee.id)
expect do
PostAction.act(mutee, post, PostActionType.types[:like])
end.to_not change { Notification.count }
end
it 'should not generate a notification if liker has the topic muted' do
post = Fabricate(:post, user: eviltrout)
TopicUser.create!(
topic: post.topic,
user: eviltrout,
notification_level: TopicUser.notification_levels[:muted]
)
expect do
PostAction.act(codinghorror, post, PostActionType.types[:like])
end.to_not change { Notification.count }
end
it "should generate a notification if liker is an admin irregardles of \
muting" do
MutedUser.create!(user_id: post.user.id, muted_user_id: admin.id)
expect do
PostAction.act(admin, post, PostActionType.types[:like])
end.to change { Notification.count }.by(1)
notification = Notification.last
expect(notification.user_id).to eq(post.user_id)
expect(notification.notification_type).to eq(Notification.types[:liked])
end
it 'should increase the `like_count` and `like_score` when a user likes something' do
freeze_time Date.today
PostAction.act(codinghorror, post, PostActionType.types[:like])
post.reload
expect(post.like_count).to eq(1)
expect(post.like_score).to eq(1)
post.topic.reload
expect(post.topic.like_count).to eq(1)
expect(value_for(codinghorror.id, Date.today)).to eq(1)
# When a staff member likes it
PostAction.act(moderator, post, PostActionType.types[:like])
post.reload
expect(post.like_count).to eq(2)
expect(post.like_score).to eq(4)
expect(post.topic.like_count).to eq(2)
# Removing likes
PostAction.remove_act(codinghorror, post, PostActionType.types[:like])
post.reload
expect(post.like_count).to eq(1)
expect(post.like_score).to eq(3)
expect(post.topic.like_count).to eq(1)
expect(value_for(codinghorror.id, Date.today)).to eq(0)
PostAction.remove_act(moderator, post, PostActionType.types[:like])
post.reload
expect(post.like_count).to eq(0)
expect(post.like_score).to eq(0)
expect(post.topic.like_count).to eq(0)
end
it "shouldn't change given_likes unless likes are given or removed" do
freeze_time(Time.zone.now)
PostAction.act(codinghorror, Fabricate(:post), PostActionType.types[:like])
expect(value_for(codinghorror.id, Date.today)).to eq(1)
PostActionType.types.each do |type_name, type_id|
post = Fabricate(:post)
PostAction.act(codinghorror, post, type_id)
actual_count = value_for(codinghorror.id, Date.today)
expected_count = type_name == :like ? 2 : 1
expect(actual_count).to eq(expected_count), "Expected likes_given to be #{expected_count} when adding '#{type_name}', but got #{actual_count}"
PostAction.remove_act(codinghorror, post, type_id)
actual_count = value_for(codinghorror.id, Date.today)
expect(actual_count).to eq(1), "Expected likes_given to be 1 when removing '#{type_name}', but got #{actual_count}"
end
end
end
describe 'flagging' do
context "flag_counts_for" do
it "returns the correct flag counts" do
post = create_post
SiteSetting.flags_required_to_hide_post = 7
# A post with no flags has 0 for flag counts
expect(PostAction.flag_counts_for(post.id)).to eq([0, 0])
_flag = PostAction.act(eviltrout, post, PostActionType.types[:spam])
expect(PostAction.flag_counts_for(post.id)).to eq([0, 1])
# If staff takes action, it is ranked higher
PostAction.act(admin, post, PostActionType.types[:spam], take_action: true)
expect(PostAction.flag_counts_for(post.id)).to eq([0, 8])
# If a flag is dismissed
PostAction.clear_flags!(post, admin)
expect(PostAction.flag_counts_for(post.id)).to eq([0, 8])
end
end
it 'does not allow you to flag stuff with the same reason more than once' do
post = Fabricate(:post)
PostAction.act(eviltrout, post, PostActionType.types[:spam])
expect { PostAction.act(eviltrout, post, PostActionType.types[:off_topic]) }.to raise_error(PostAction::AlreadyActed)
end
it 'allows you to flag stuff with another reason' do
post = Fabricate(:post)
PostAction.act(eviltrout, post, PostActionType.types[:spam])
PostAction.remove_act(eviltrout, post, PostActionType.types[:spam])
expect { PostAction.act(eviltrout, post, PostActionType.types[:off_topic]) }.not_to raise_error()
end
it 'should update counts when you clear flags' do
post = Fabricate(:post)
PostAction.act(eviltrout, post, PostActionType.types[:spam])
post.reload
expect(post.spam_count).to eq(1)
PostAction.clear_flags!(post, Discourse.system_user)
post.reload
expect(post.spam_count).to eq(0)
end
it "will not allow regular users to auto hide staff posts" do
mod = Fabricate(:moderator)
post = Fabricate(:post, user: mod)
SiteSetting.flags_required_to_hide_post = 2
Discourse.stubs(:site_contact_user).returns(admin)
PostAction.act(eviltrout, post, PostActionType.types[:spam])
PostAction.act(Fabricate(:walter_white), post, PostActionType.types[:spam])
post.reload
expect(post.hidden).to eq(false)
expect(post.hidden_at).to be_blank
end
it "allows staff users to auto hide staff posts" do
mod = Fabricate(:moderator)
post = Fabricate(:post, user: mod)
SiteSetting.flags_required_to_hide_post = 2
Discourse.stubs(:site_contact_user).returns(admin)
PostAction.act(eviltrout, post, PostActionType.types[:spam])
PostAction.act(Fabricate(:admin), post, PostActionType.types[:spam])
post.reload
expect(post.hidden).to eq(true)
expect(post.hidden_at).to be_present
end
it 'should follow the rules for automatic hiding workflow' do
post = create_post
walterwhite = Fabricate(:walter_white)
SiteSetting.flags_required_to_hide_post = 2
Discourse.stubs(:site_contact_user).returns(admin)
PostAction.act(eviltrout, post, PostActionType.types[:spam])
PostAction.act(walterwhite, post, PostActionType.types[:spam])
job_args = Jobs::SendSystemMessage.jobs.last["args"].first
expect(job_args["user_id"]).to eq(post.user.id)
expect(job_args["message_type"]).to eq("post_hidden")
post.reload
expect(post.hidden).to eq(true)
expect(post.hidden_at).to be_present
expect(post.hidden_reason_id).to eq(Post.hidden_reasons[:flag_threshold_reached])
expect(post.topic.visible).to eq(false)
post.revise(post.user, raw: post.raw + " ha I edited it ")
post.reload
expect(post.hidden).to eq(false)
expect(post.hidden_reason_id).to eq(Post.hidden_reasons[:flag_threshold_reached]) # keep most recent reason
expect(post.hidden_at).to be_present # keep the most recent hidden_at time
expect(post.topic.visible).to eq(true)
PostAction.act(eviltrout, post, PostActionType.types[:spam])
PostAction.act(walterwhite, post, PostActionType.types[:off_topic])
job_args = Jobs::SendSystemMessage.jobs.last["args"].first
expect(job_args["user_id"]).to eq(post.user.id)
expect(job_args["message_type"]).to eq("post_hidden_again")
post.reload
expect(post.hidden).to eq(true)
expect(post.hidden_at).to be_present
expect(post.hidden_reason_id).to eq(Post.hidden_reasons[:flag_threshold_reached_again])
expect(post.topic.visible).to eq(false)
post.revise(post.user, raw: post.raw + " ha I edited it again ")
post.reload
expect(post.hidden).to eq(true)
expect(post.hidden_at).to be_present
expect(post.hidden_reason_id).to eq(Post.hidden_reasons[:flag_threshold_reached_again])
expect(post.topic.visible).to eq(false)
end
it "doesn't fail when post has nil user" do
post = create_post
post.update!(user: nil)
PostAction.act(codinghorror, post, PostActionType.types[:spam], take_action: true)
post.reload
expect(post.hidden).to eq(true)
end
it "hide tl0 posts that are flagged as spam by a tl3 user" do
newuser = Fabricate(:newuser)
post = create_post(user: newuser)
Discourse.stubs(:site_contact_user).returns(admin)
PostAction.act(Fabricate(:leader), post, PostActionType.types[:spam])
post.reload
expect(post.hidden).to eq(true)
expect(post.hidden_at).to be_present
expect(post.hidden_reason_id).to eq(Post.hidden_reasons[:flagged_by_tl3_user])
end
it "hide non-tl4 posts that are flagged by a tl4 user" do
SiteSetting.site_contact_username = admin.username
post_action_type = PostActionType.types[:spam]
tl4_user = Fabricate(:trust_level_4)
user = Fabricate(:leader)
post = create_post(user: user)
PostAction.act(tl4_user, post, post_action_type)
post.reload
expect(post.hidden).to be_truthy
expect(post.hidden_at).to be_present
expect(post.hidden_reason_id).to eq(Post.hidden_reasons[:flagged_by_tl4_user])
post = create_post(user: user)
PostAction.act(Fabricate(:leader), post, post_action_type)
post.reload
expect(post.hidden).to be_falsey
post = create_post(user: user)
PostAction.act(Fabricate(:moderator), post, post_action_type)
post.reload
expect(post.hidden).to be_falsey
user = Fabricate(:trust_level_4)
post = create_post(user: user)
PostAction.act(tl4_user, post, post_action_type)
post.reload
expect(post.hidden).to be_falsey
end
it "can flag the topic instead of a post" do
post1 = create_post
_post2 = create_post(topic: post1.topic)
post_action = PostAction.act(Fabricate(:user), post1, PostActionType.types[:spam], flag_topic: true)
expect(post_action.targets_topic).to eq(true)
end
it "will flag the first post if you flag a topic but there is only one post in the topic" do
post = create_post
post_action = PostAction.act(Fabricate(:user), post, PostActionType.types[:spam], flag_topic: true)
expect(post_action.targets_topic).to eq(false)
expect(post_action.post_id).to eq(post.id)
end
it "will unhide the post when a moderator undos the flag on which s/he took action" do
Discourse.stubs(:site_contact_user).returns(admin)
post = create_post
PostAction.act(moderator, post, PostActionType.types[:spam], take_action: true)
post.reload
expect(post.hidden).to eq(true)
PostAction.remove_act(moderator, post, PostActionType.types[:spam])
post.reload
expect(post.hidden).to eq(false)
end
context "topic auto closing" do
let(:topic) { Fabricate(:topic) }
let(:post1) { create_post(topic: topic) }
let(:post2) { create_post(topic: topic) }
let(:post3) { create_post(topic: topic) }
let(:flagger1) { Fabricate(:user) }
let(:flagger2) { Fabricate(:user) }
before do
SiteSetting.flags_required_to_hide_post = 0
SiteSetting.num_flags_to_close_topic = 3
SiteSetting.num_flaggers_to_close_topic = 2
SiteSetting.num_hours_to_close_topic = 1
end
it "will automatically pause a topic due to large community flagging" do
# reaching `num_flaggers_to_close_topic` isn't enough
[flagger1, flagger2].each do |flagger|
PostAction.act(flagger, post1, PostActionType.types[:inappropriate])
end
expect(topic.reload.closed).to eq(false)
# clean up
PostAction.where(post: post1).delete_all
# reaching `num_flags_to_close_topic` isn't enough
[post1, post2, post3].each do |post|
PostAction.act(flagger1, post, PostActionType.types[:inappropriate])
end
expect(topic.reload.closed).to eq(false)
# clean up
PostAction.where(post: [post1, post2, post3]).delete_all
# reaching both should close the topic
[flagger1, flagger2].each do |flagger|
[post1, post2, post3].each do |post|
PostAction.act(flagger, post, PostActionType.types[:inappropriate])
end
end
expect(topic.reload.closed).to eq(true)
topic_status_update = TopicTimer.last
expect(topic_status_update.topic).to eq(topic)
expect(topic_status_update.execute_at).to be_within(1.second).of(1.hour.from_now)
expect(topic_status_update.status_type).to eq(TopicTimer.types[:open])
end
context "on a staff post" do
let(:staff_user) { Fabricate(:user, moderator: true) }
let(:topic) { Fabricate(:topic, user: staff_user) }
it "will not close topics opened by staff" do
[flagger1, flagger2].each do |flagger|
[post1, post2, post3].each do |post|
PostAction.act(flagger, post, PostActionType.types[:inappropriate])
end
end
expect(topic.reload.closed).to eq(false)
end
end
it "will keep the topic in closed status until the community flags are handled" do
freeze_time
PostAction.stubs(:auto_close_threshold_reached?).returns(true)
PostAction.auto_close_if_threshold_reached(topic)
expect(topic.reload.closed).to eq(true)
timer = TopicTimer.last
expect(timer.execute_at).to eq(1.hour.from_now)
freeze_time timer.execute_at
Jobs.expects(:enqueue_in).with(1.hour.to_i, :toggle_topic_closed, topic_timer_id: timer.id, state: false).returns(true)
Jobs::ToggleTopicClosed.new.execute(topic_timer_id: timer.id, state: false)
expect(topic.reload.closed).to eq(true)
expect(timer.reload.execute_at).to eq(1.hour.from_now)
freeze_time timer.execute_at
PostAction.stubs(:auto_close_threshold_reached?).returns(false)
Jobs::ToggleTopicClosed.new.execute(topic_timer_id: timer.id, state: false)
expect(topic.reload.closed).to eq(false)
end
it "will reopen topic after the flags are auto handled" do
freeze_time
[flagger1, flagger2].each do |flagger|
[post1, post2, post3].each do |post|
PostAction.act(flagger, post, PostActionType.types[:inappropriate])
end
end
expect(topic.reload.closed).to eq(true)
freeze_time 61.days.from_now
Jobs::AutoQueueHandler.new.execute({})
Jobs::ToggleTopicClosed.new.execute(topic_timer_id: TopicTimer.last.id, state: false)
expect(topic.reload.closed).to eq(false)
end
end
end
it "prevents user to act twice at the same time" do
# flags are already being tested
all_types_except_flags = PostActionType.types.except(PostActionType.flag_types_without_custom)
all_types_except_flags.values.each do |action|
expect do
PostAction.act(eviltrout, post, action)
PostAction.act(eviltrout, post, action)
end.to raise_error(PostAction::AlreadyActed)
end
end
describe ".create_message_for_post_action" do
it "does not create a message when there is no message" do
message_id = PostAction.create_message_for_post_action(Discourse.system_user, post, PostActionType.types[:spam], {})
expect(message_id).to be_nil
end
[:notify_moderators, :notify_user, :spam].each do |post_action_type|
it "creates a message for #{post_action_type}" do
message_id = PostAction.create_message_for_post_action(Discourse.system_user, post, PostActionType.types[post_action_type], message: "WAT")
expect(message_id).to be_present
end
end
it "should raise the right errors when it fails to create a post" do
begin
group = Group[:moderators]
messageable_level = group.messageable_level
group.update!(messageable_level: Group::ALIAS_LEVELS[:nobody])
expect do
PostAction.create_message_for_post_action(
Fabricate(:user),
post,
PostActionType.types[:notify_moderators],
message: 'testing',
)
end.to raise_error(ActiveRecord::RecordNotSaved)
ensure
group.update!(messageable_level: messageable_level)
end
end
it "should succeed even with low max title length" do
SiteSetting.max_topic_title_length = 50
post.topic.title = 'This is a test topic ' * 2
post.topic.save!
message_id = PostAction.create_message_for_post_action(Discourse.system_user, post, PostActionType.types[:notify_moderators], message: "WAT")
expect(message_id).to be_present
end
end
describe ".lookup_for" do
it "returns the correct map" do
user = Fabricate(:user)
post = Fabricate(:post)
post_action = PostAction.create(user_id: user.id, post_id: post.id, post_action_type_id: 1)
map = PostAction.lookup_for(user, [post.topic], post_action.post_action_type_id)
expect(map).to eq(post.topic_id => [post.post_number])
end
end
describe "#add_moderator_post_if_needed" do
it "should not add a moderator post when it's disabled" do
post = create_post
action = PostAction.act(moderator, post, PostActionType.types[:spam], message: "WAT")
action.reload
topic = action.related_post.topic
expect(topic.posts.count).to eq(1)
SiteSetting.auto_respond_to_flag_actions = false
PostAction.agree_flags!(post, admin)
expect(action.user.user_stat.flags_agreed).to eq(1)
topic.reload
expect(topic.posts.count).to eq(1)
end
it "should create a notification in the related topic" do
SiteSetting.queue_jobs = false
post = Fabricate(:post)
user = Fabricate(:user)
action = PostAction.act(user, post, PostActionType.types[:spam], message: "WAT")
topic = action.reload.related_post.topic
expect(user.notifications.count).to eq(0)
SiteSetting.auto_respond_to_flag_actions = true
PostAction.agree_flags!(post, admin)
expect(action.user.user_stat.flags_agreed).to eq(1)
user_notifications = user.notifications
expect(user_notifications.count).to eq(1)
expect(user_notifications.last.topic).to eq(topic)
end
it "should not add a moderator post when post is flagged via private message" do
SiteSetting.queue_jobs = false
post = Fabricate(:post)
user = Fabricate(:user)
action = PostAction.act(user, post, PostActionType.types[:notify_user], message: "WAT")
action.reload.related_post.topic
expect(user.notifications.count).to eq(0)
SiteSetting.auto_respond_to_flag_actions = true
PostAction.agree_flags!(post, admin)
expect(action.user.user_stat.flags_agreed).to eq(0)
user_notifications = user.notifications
expect(user_notifications.count).to eq(0)
end
end
describe "rate limiting" do
def limiter(tl)
user = Fabricate.build(:user)
user.trust_level = tl
action = PostAction.new(user: user, post_action_type_id: PostActionType.types[:like])
action.post_action_rate_limiter
end
it "should scale up like limits depending on liker" do
expect(limiter(0).max).to eq SiteSetting.max_likes_per_day
expect(limiter(1).max).to eq SiteSetting.max_likes_per_day
expect(limiter(2).max).to eq (SiteSetting.max_likes_per_day * SiteSetting.tl2_additional_likes_per_day_multiplier).to_i
expect(limiter(3).max).to eq (SiteSetting.max_likes_per_day * SiteSetting.tl3_additional_likes_per_day_multiplier).to_i
expect(limiter(4).max).to eq (SiteSetting.max_likes_per_day * SiteSetting.tl4_additional_likes_per_day_multiplier).to_i
SiteSetting.tl2_additional_likes_per_day_multiplier = -1
expect(limiter(2).max).to eq SiteSetting.max_likes_per_day
SiteSetting.tl2_additional_likes_per_day_multiplier = 0.8
expect(limiter(2).max).to eq SiteSetting.max_likes_per_day
SiteSetting.tl2_additional_likes_per_day_multiplier = "bob"
expect(limiter(2).max).to eq SiteSetting.max_likes_per_day
end
end
describe '#is_flag?' do
describe 'when post action is a flag' do
it 'should return true' do
PostActionType.notify_flag_types.each do |_type, id|
post_action = PostAction.new(
user: codinghorror,
post_action_type_id: id
)
expect(post_action.is_flag?).to eq(true)
end
end
end
describe 'when post action is not a flag' do
it 'should return false' do
post_action = PostAction.new(
user: codinghorror,
post_action_type_id: 99
)
expect(post_action.is_flag?).to eq(false)
end
end
end
describe "triggers Discourse events" do
let(:post) { Fabricate(:post) }
it 'flag created' do
event = DiscourseEvent.track_events { PostAction.act(eviltrout, post, PostActionType.types[:spam]) }.last
expect(event[:event_name]).to eq(:flag_created)
end
context "resolving flags" do
before do
@flag = PostAction.act(eviltrout, post, PostActionType.types[:spam])
end
it 'flag agreed' do
events = DiscourseEvent.track_events { PostAction.agree_flags!(post, moderator) }.last(2)
expect(events[0][:event_name]).to eq(:flag_reviewed)
expect(events[1][:event_name]).to eq(:flag_agreed)
expect(events[1][:params].first).to eq(@flag)
end
it 'flag disagreed' do
events = DiscourseEvent.track_events { PostAction.clear_flags!(post, moderator) }.last(2)
expect(events[0][:event_name]).to eq(:flag_reviewed)
expect(events[1][:event_name]).to eq(:flag_disagreed)
expect(events[1][:params].first).to eq(@flag)
end
it 'flag deferred' do
events = DiscourseEvent.track_events { PostAction.defer_flags!(post, moderator) }.last(2)
expect(events[0][:event_name]).to eq(:flag_reviewed)
expect(events[1][:event_name]).to eq(:flag_deferred)
expect(events[1][:params].first).to eq(@flag)
end
end
end
end