A platform for community discussion. Free, open, simple.
# frozen_string_literal: true
RSpec.describe UserSuspender do
fab!(:user) { Fabricate(:user, trust_level: 0) }
fab!(:post) { Fabricate(:post, user: user) }
fab!(:admin)
describe "suspend" do
subject(:suspend_user) { suspender.suspend }
let(:suspender) do
UserSuspender.new(
user,
suspended_till: 5.hours.from_now,
reason: "because",
by_user: admin,
post_id: post.id,
message: "you have been suspended",
)
end
it "suspends the user and schedules automatic expiry" do
freeze_time(Time.zone.now.round)
suspend_user
expect(user.reload).to be_suspended
expect(user.suspended_till).to be_within_one_second_of(5.hours.from_now)
expect(user.suspended_at).to be_within_one_second_of(Time.zone.now)
job = Jobs::UserSuspensionExpired.jobs.last
expect(job["at"]).to eq(user.suspended_till.to_f)
expect(job["args"].first).to include(
"user_id" => user.id,
"suspended_at" => user.suspended_at.iso8601(UserSuspender::TIMESTAMP_PRECISION),
"suspended_till" => user.suspended_till.iso8601(UserSuspender::TIMESTAMP_PRECISION),
)
end
it "creates a staff action log" do
expect do suspend_user end.to change {
UserHistory.where(
action: UserHistory.actions[:suspend_user],
acting_user_id: admin.id,
target_user_id: user.id,
).count
}.from(0).to(1)
end
it "preserves the scheduled expiry in the log after an early unsuspension" do
freeze_time(Time.zone.now.round)
suspend_user
history = user.user_histories.find_by!(action: UserHistory.actions[:suspend_user])
expect(history.expires_at).to eq_time(user.reload.suspended_till)
UserSuspender.unsuspend(user, by_user: admin)
expect(history.reload.expires_at).to eq_time(5.hours.from_now)
expect(
user.user_histories.find_by!(action: UserHistory.actions[:unsuspend_user]).expires_at,
).to be_nil
end
it "links the staff action log to the reviewable when passed via opts" do
reviewable = Fabricate(:reviewable_flagged_post, target_created_by: user)
suspender =
UserSuspender.new(
user,
suspended_till: 5.hours.from_now,
reason: "because",
by_user: admin,
post_id: post.id,
message: "you have been suspended",
reviewable_id: reviewable.id,
)
expect { suspender.suspend }.to change {
UserHistory.where(
action: UserHistory.actions[:suspend_user],
reviewable_id: reviewable.id,
).count
}.by(1)
end
it "logs the user out" do
messages = MessageBus.track_publish("/logout/#{user.id}") { suspend_user }
expect(messages.size).to eq(1)
expect(messages[0].user_ids).to eq([user.id])
expect(messages[0].data).to eq(user.id)
end
it "fires a user_suspended event" do
freeze_time(Time.zone.now.round)
events = DiscourseEvent.track_events(:user_suspended) { suspend_user }
expect(events.size).to eq(1)
params = events[0][:params].first
expect(params[:user].id).to eq(user.id)
expect(params[:by_user]).to eq(admin)
expect(params[:reason]).to eq("because")
expect(params[:message]).to eq("you have been suspended")
expect(params[:suspended_till]).to be_within_one_second_of(5.hours.from_now)
expect(params[:suspended_at]).to eq(Time.zone.now)
end
context "when a message is provided" do
it "enqueues a critical user email job" do
expect do suspend_user end.to change { Jobs::CriticalUserEmail.jobs.size }.from(0).to(1)
job = Jobs::CriticalUserEmail.jobs.first
expect(job["args"].first["user_id"]).to eq(user.id)
expect(job["args"].first["user_history_id"]).to eq(suspender.user_history.id)
end
end
context "when a message is not provided" do
let(:suspender) do
UserSuspender.new(
user,
suspended_till: 5.hours.from_now,
reason: "because",
by_user: admin,
post_id: post.id,
message: nil,
)
end
it "delivers a suspension email with the reason when DSA reporting is enabled" do
enable_dsa_reporting
user.user_option.update!(timezone: "Asia/Singapore")
expect { suspend_user }.to change { Jobs::CriticalUserEmail.jobs.size }.by(1)
job = Jobs::CriticalUserEmail.jobs.sole.fetch("args").first
Jobs::CriticalUserEmail.new.execute(job.with_indifferent_access)
email = ActionMailer::Base.deliveries.sole
expect(email.to).to eq([user.email])
expect(email.subject).to include("Your account has been suspended")
expect(email.text_part.body.decoded).to include("because", "UTC+08:00")
end
it "skips the notification when DSA reporting is disabled" do
expect { suspend_user }.not_to change { Jobs::CriticalUserEmail.jobs.size }
end
it "skips the notification when the optional message is whitespace" do
suspender =
UserSuspender.new(
user,
suspended_till: 5.hours.from_now,
reason: "because",
by_user: admin,
message: " ",
)
expect { suspender.suspend }.not_to change { Jobs::CriticalUserEmail.jobs.size }
end
end
end
describe ".unsuspend" do
it "preserves the suspension on listener failure and identifies the moderator on retry" do
user.update!(suspended_at: 1.hour.ago, suspended_till: 1.day.from_now)
handler = proc { raise "Listener unavailable" }
DiscourseEvent.on(:user_unsuspended, &handler)
expect do described_class.unsuspend(user, by_user: admin) end.to raise_error(
"Listener unavailable",
)
expect(user.reload).to be_suspended
DiscourseEvent.off(:user_unsuspended, &handler)
events =
DiscourseEvent.track_events(:user_unsuspended) do
described_class.unsuspend(user, by_user: admin)
end
expect(user.reload).to have_attributes(suspended_at: nil, suspended_till: nil)
expect(events.map { |event| event[:params].first }).to contain_exactly(
user: user,
by_user: admin,
)
ensure
DiscourseEvent.off(:user_unsuspended, &handler) if handler
end
end
end