A platform for community discussion. Free, open, simple.
FEATURE: React to user lifecycle and moderation changes
Régis Hanolf84081dc5830
diff --git a/app/controllers/admin/users_controller.rb b/app/controllers/admin/users_controller.rbindex 67306e9eef3..9282f7c6981 100644--- a/app/controllers/admin/users_controller.rb+++ b/app/controllers/admin/users_controller.rb@@ -172,13 +172,7 @@ class Admin::UsersController < Admin::StaffControllerdef unsuspendguardian.ensure_can_unsuspend!(@user)- @user.suspended_till = nil- @user.suspended_at = nil- @user.save!-- StaffActionLogger.new(current_user).log_user_unsuspend(@user)-- DiscourseEvent.trigger(:user_unsuspended, user: @user)+ UserSuspender.unsuspend(@user, by_user: current_user)render_json_dump(suspension: { suspended_till: nil, suspended_at: nil })enddiff --git a/app/jobs/regular/user_suspension_expired.rb b/app/jobs/regular/user_suspension_expired.rbnew file mode 100644index 00000000000..bbdbe3ac1eb--- /dev/null+++ b/app/jobs/regular/user_suspension_expired.rb@@ -0,0 +1,16 @@+# frozen_string_literal: true++module Jobs+ class UserSuspensionExpired < ::Jobs::Base+ def execute(args)+ user = User.find_by(id: args[:user_id])+ return if user.nil?++ UserSuspender.expire(+ user,+ suspended_at: Time.iso8601(args[:suspended_at]),+ suspended_till: Time.iso8601(args[:suspended_till]),+ )+ end+ end+enddiff --git a/app/services/user_suspender.rb b/app/services/user_suspender.rbindex b93ee03daf7..ea7160104b5 100644--- a/app/services/user_suspender.rb+++ b/app/services/user_suspender.rb@@ -1,8 +1,41 @@# frozen_string_literal: trueclass UserSuspender+ SUSPENSION_EXPIRY_CONTEXT = "suspension_expired"+ TIMESTAMP_PRECISION = 6+attr_reader :user_history+ def self.expire(user, suspended_at:, suspended_till:)+ actor = Discourse.system_user++ user.with_lock(requires_new: true) do+ return if user.suspended_at != suspended_at || user.suspended_till != suspended_till+ return if user.suspended?++ context = [+ SUSPENSION_EXPIRY_CONTEXT,+ suspended_at.utc.iso8601(TIMESTAMP_PRECISION),+ suspended_till.utc.iso8601(TIMESTAMP_PRECISION),+ ].join(":")+ return if user.user_histories.where(context: context).exists?++ StaffActionLogger.new(actor).log_user_unsuspend(user, context: context)+ DiscourseEvent.trigger(:user_unsuspended, user: user, by_user: actor)+ end+ end++ def self.unsuspend(user, by_user:)+ user.with_lock(requires_new: true) do+ return if user.suspended_till.nil?++ user.update!(suspended_at: nil, suspended_till: nil)+ StaffActionLogger.new(by_user).log_user_unsuspend(user)++ DiscourseEvent.trigger(:user_unsuspended, user: user, by_user: by_user)+ end+ end+def initialize(user,suspended_till:,@@ -41,6 +74,14 @@ class UserSuspenderend@user.log_out!+ Jobs.enqueue_at(+ @user.suspended_till,+ :user_suspension_expired,+ user_id: @user.id,+ suspended_at: @user.suspended_at.iso8601(TIMESTAMP_PRECISION),+ suspended_till: @user.suspended_till.iso8601(TIMESTAMP_PRECISION),+ )+if @message.present?Jobs.enqueue(Jobs::CriticalUserEmail,@@ -53,6 +94,7 @@ class UserSuspenderDiscourseEvent.trigger(:user_suspended,user: @user,+ by_user: @by_user,reason: @reason,message: @message,user_history: @user_history,diff --git a/plugins/discourse-workflows/USE_CASES.md b/plugins/discourse-workflows/USE_CASES.mdindex 984acd32b7c..16e3434a8a4 100644--- a/plugins/discourse-workflows/USE_CASES.md+++ b/plugins/discourse-workflows/USE_CASES.md@@ -64,6 +64,8 @@ For each run, record:- Topic status triggers are separate nodes: `topic_closed`, `topic_reopened`, `topic_archived`, `topic_unarchived`, `topic_listed`, `topic_unlisted`, `topic_pinned`, `topic_unpinned`, `topic_pinned_globally`, and `topic_unpinned_globally` (all prefixed with `trigger:`). They share category and tag filters. Closing includes automatic closes; unpin events use the previous pin scope. Workflow and AI actions use the same status updater.- Review outcome triggers are `trigger:reviewable_approved`, `trigger:reviewable_rejected`, `trigger:reviewable_ignored`, `trigger:reviewable_deleted`, and `trigger:reviewable_pending`. They share the reviewable-type filter. Pending handles an existing item returning to review; use `trigger:reviewable_created` for new items.- Connect multiple event triggers to the same downstream node to handle several events. Existing `trigger:topic_status_changed` and `trigger:reviewable_status_changed` nodes remain editable and executable, but are hidden from the picker and AI discovery. Fixed-event nodes have no status selector and ignore any supplied `statuses` configuration.+- `trigger:user_trust_level_changed` exposes old and new levels, including demotions. `trigger:user_first_logged_in` follows the first-login event, whose first-visit check uses `last_seen_at`.+- `trigger:user_moderation_changed` exposes `change`, the affected `user`, optional `actor` and `reason`, and `expires_at`. Automatic suspension expiry is announced for suspensions scheduled after this functionality is deployed; existing suspensions are not backfilled.- Topic-only triggers that need author/post fields should use `action:topic` get before filtering or messaging.- Generic prompts like "when someone posts" should use `trigger:post_created` for all regular posts; do not ask whether to include replies unless the prompt explicitly narrows the scope.- Actions that replace item JSON require downstream nodes to use the action output schema, not the original trigger schema.@@ -77,3 +79,11 @@ For each run, record:- `trigger:post_destroyed` and `trigger:post_recovered` expose `$json.user` as the acting moderator, not the post author; use `$json.post.username` for the author.- DM/personal-message notifications should use `action:send_personal_message` instead of chat or topic reply nodes.- Forum `search`/`read` should not be used for node/schema discovery; use `workflow_node_catalog` and `workflow_validate_patch`.++## Moderation entrypoints++Live suspensions from admin actions (single and bulk), AI tools, and automation use `UserSuspender`. Manual unsuspension and scheduled expiry use the same class. Expiry preserves historical suspension dates and deduplicates its event through staff history; clearing those dates would change badge eligibility.++`UserSilencer` already handles admin, review queue, spam, chat, AI, and workflow silence actions, manual unsilencing, and scheduled unsilencing. No additional silence service is needed.++Direct field writes intentionally remain in historical imports, anonymous shadow-account synchronization, and AI bot self-repair. These restore or copy state rather than perform independent human moderation actions, so they must not send moderation messages or create duplicate workflow events.diff --git a/plugins/discourse-workflows/config/locales/client.en.yml b/plugins/discourse-workflows/config/locales/client.en.ymlindex 3478fc63136..8625ed634a0 100644--- a/plugins/discourse-workflows/config/locales/client.en.yml+++ b/plugins/discourse-workflows/config/locales/client.en.yml@@ -218,6 +218,9 @@ en:"trigger:topic_timer_changed": "Topic timer changed""trigger:topic_status_changed": "Topic status changed""trigger:reviewable_status_changed": "Review outcome changed"+ "trigger:user_trust_level_changed": "Trust level changed"+ "trigger:user_first_logged_in": "User first logged in"+ "trigger:user_moderation_changed": "User moderation changed""trigger:topic_closed": "Topic closed""trigger:topic_reopened": "Topic reopened""trigger:topic_archived": "Topic archived"@@ -298,6 +301,9 @@ en:"trigger:topic_timer_changed": "Fires when a topic timer is created, updated, cancelled, or completed""trigger:topic_status_changed": "Fires when a topic is closed, reopened, archived, listed, or pinned, or those changes are reversed""trigger:reviewable_status_changed": "Fires when an item's status changes in the review queue"+ "trigger:user_trust_level_changed": "Fires when a user's trust level increases or decreases"+ "trigger:user_first_logged_in": "Fires when a user logs in for the first time"+ "trigger:user_moderation_changed": "Fires when a user is suspended, unsuspended, silenced, or unsilenced""trigger:topic_closed": "Fires when a topic is closed by a user or auto-close timer""trigger:topic_reopened": "Fires when a topic is reopened""trigger:topic_archived": "Fires when a topic is archived"@@ -939,6 +945,21 @@ en:statuses_rejected: "Rejected"statuses_ignored: "Ignored"statuses_deleted: "Deleted"+ user_trust_level_changed:+ old_trust_levels: "Previous trust levels"+ old_trust_levels_description: "Leave empty to match any previous trust level."+ old_trust_levels_placeholder: "Any trust level"+ new_trust_levels: "New trust levels"+ new_trust_levels_description: "Leave empty to match any new trust level."+ new_trust_levels_placeholder: "Any trust level"+ user_moderation_changed:+ changes: "Changes"+ changes_description: "Leave empty to match any change."+ changes_placeholder: "Any change"+ changes_suspended: "Suspended"+ changes_unsuspended: "Unsuspended"+ changes_silenced: "Silenced"+ changes_unsilenced: "Unsilenced"post_created:topic_type: "Topic type"topic_type_description: "Choose whether topics, personal messages, or both should trigger the workflow"diff --git a/plugins/discourse-workflows/lib/discourse_workflows/event_listener.rb b/plugins/discourse-workflows/lib/discourse_workflows/event_listener.rbindex d703ce0223d..d3f6f314e9e 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/event_listener.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/event_listener.rb@@ -2,11 +2,11 @@module DiscourseWorkflowsclass EventListener- def self.handle(trigger_class, *args)+ def self.handle(trigger_class, *args, event_name: nil)return unless SiteSetting.enable_discourse_workflowsreturn if WorkflowDependency.active_node_types.exclude?(trigger_class.identifier)- trigger = trigger_class.new(*args)+ trigger = trigger_class.from_event(event_name, *args)return unless trigger.valid?trigger_data = nildiff --git a/plugins/discourse-workflows/lib/discourse_workflows/node_type.rb b/plugins/discourse-workflows/lib/discourse_workflows/node_type.rbindex cde504959fc..30915882b0f 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/node_type.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/node_type.rb@@ -246,8 +246,12 @@ module DiscourseWorkflowsendprivate_class_method :unknown_contract?- def self.event_name- description[:event]&.to_sym+ def self.event_names+ Array.wrap(description[:event]).map(&:to_sym)+ end++ def self.from_event(_event_name, *args)+ new(*args)enddef self.manually_triggerable?diff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/user_first_logged_in/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/user_first_logged_in/v1.rbnew file mode 100644index 00000000000..4d3f916b171--- /dev/null+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/user_first_logged_in/v1.rb@@ -0,0 +1,41 @@+# frozen_string_literal: true++module DiscourseWorkflows+ module Nodes+ module UserFirstLoggedIn+ class V1 < NodeType+ description(+ name: "trigger:user_first_logged_in",+ version: "1.0",+ defaults: {+ icon: "right-to-bracket",+ color: "teal",+ },+ group: "discourse_triggers",+ event: :user_first_logged_in,+ output_contracts: [{ schema: Schema::USER_SCHEMA }],+ capabilities: {+ provides_current_user: true,+ },+ )++ def initialize(user)+ super(parameters: {})+ @user = user+ end++ def valid?+ @user.present? && @user.human?+ end++ def user_id+ @user.id+ end++ def output+ { user: serialize_user(@user) }+ end+ end+ end+ end+enddiff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/user_moderation_changed/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/user_moderation_changed/v1.rbnew file mode 100644index 00000000000..9322d74dc19--- /dev/null+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/user_moderation_changed/v1.rb@@ -0,0 +1,105 @@+# frozen_string_literal: true++module DiscourseWorkflows+ module Nodes+ module UserModerationChanged+ class V1 < NodeType+ CHANGES = {+ user_suspended: "suspended",+ user_unsuspended: "unsuspended",+ user_silenced: "silenced",+ user_unsilenced: "unsilenced",+ }.freeze++ OUTPUT_SCHEMA =+ Schema.merge(+ Schema::USER_SCHEMA,+ Schema.document(+ "change" => {+ "type" => "string",+ "enum" => CHANGES.values,+ },+ "actor" => {+ "type" => %w[object null],+ "properties" => Schema::BASIC_USER_PROPERTIES,+ },+ "reason" => {+ "type" => %w[string null],+ },+ "expires_at" => {+ "type" => %w[string null],+ "format" => "date-time",+ },+ ),+ ).freeze++ description(+ name: "trigger:user_moderation_changed",+ version: "1.0",+ defaults: {+ icon: "user-xmark",+ color: "red",+ },+ group: "discourse_triggers",+ event: CHANGES.keys,+ output_contracts: [{ schema: OUTPUT_SCHEMA }],+ properties: {+ changes: {+ type: :multi_options,+ required: false,+ default: [],+ options: CHANGES.values,+ },+ },+ capabilities: {+ provides_current_user: true,+ },+ )++ def self.from_event(event_name, *args)+ new(event_name, *args)+ end++ def initialize(event_name, payload = {})+ super(parameters: {})+ @change = CHANGES[event_name]+ @user = payload[:user]+ @actor = payload[:by_user] || payload[:silenced_by]+ @reason = payload[:reason]+ end++ def valid?+ @change.present? && @user.present? && @user.human?+ end++ def user_id+ @user.id+ end++ def output+ expiry =+ case @change+ when "suspended"+ @user.suspended_till+ when "silenced"+ @user.silenced_till+ end++ {+ user: serialize_user(@user),+ change: @change,+ actor: @actor && serialize_record(@actor, BasicUserSerializer),+ reason: @reason,+ expires_at: expiry&.iso8601,+ }+ end++ def matches?(trigger_ctx)+ changes =+ Array.wrap(trigger_ctx.get_node_parameter("changes", [])).compact_blank.map(&:to_s)+ changes.empty? || changes.include?(@change)+ end+ end+ end+ end+enddiff --git a/plugins/discourse-workflows/lib/discourse_workflows/nodes/user_trust_level_changed/v1.rb b/plugins/discourse-workflows/lib/discourse_workflows/nodes/user_trust_level_changed/v1.rbnew file mode 100644index 00000000000..f62a1fdcb9c--- /dev/null+++ b/plugins/discourse-workflows/lib/discourse_workflows/nodes/user_trust_level_changed/v1.rb@@ -0,0 +1,86 @@+# frozen_string_literal: true++module DiscourseWorkflows+ module Nodes+ module UserTrustLevelChanged+ class V1 < NodeType+ OUTPUT_SCHEMA =+ Schema.merge(+ Schema::USER_SCHEMA,+ Schema.document(+ "old_trust_level" => {+ "type" => "integer",+ },+ "new_trust_level" => {+ "type" => "integer",+ },+ ),+ ).freeze++ description(+ name: "trigger:user_trust_level_changed",+ version: "1.0",+ defaults: {+ icon: "user-shield",+ color: "teal",+ },+ group: "discourse_triggers",+ event: :user_promoted,+ output_contracts: [{ schema: OUTPUT_SCHEMA }],+ properties: {+ old_trust_levels: {+ type: :multi_options,+ default: [],+ options: trust_level_options,+ },+ new_trust_levels: {+ type: :multi_options,+ default: [],+ options: trust_level_options,+ },+ },+ capabilities: {+ provides_current_user: true,+ },+ )++ def initialize(data)+ super(parameters: {})+ @user = ::User.find_by(id: data[:user_id])+ @old_trust_level = data[:old_trust_level]+ @new_trust_level = data[:new_trust_level]+ end++ def valid?+ @user.present? && @user.human? && @old_trust_level != @new_trust_level+ end++ def user_id+ @user.id+ end++ def output+ {+ user: serialize_user(@user),+ old_trust_level: @old_trust_level,+ new_trust_level: @new_trust_level,+ }+ end++ def matches?(trigger_ctx)+ matches_level?(trigger_ctx, "old_trust_levels", @old_trust_level) &&+ matches_level?(trigger_ctx, "new_trust_levels", @new_trust_level)+ end++ private++ def matches_level?(trigger_ctx, parameter, level)+ levels =+ Array.wrap(trigger_ctx.get_node_parameter(parameter, [])).compact_blank.map(&:to_s)++ levels.empty? || levels.include?(level.to_s)+ end+ end+ end+ end+enddiff --git a/plugins/discourse-workflows/lib/discourse_workflows/plugin_node_registration.rb b/plugins/discourse-workflows/lib/discourse_workflows/plugin_node_registration.rbindex 6f85a644491..b0c4e572eab 100644--- a/plugins/discourse-workflows/lib/discourse_workflows/plugin_node_registration.rb+++ b/plugins/discourse-workflows/lib/discourse_workflows/plugin_node_registration.rb@@ -55,14 +55,16 @@ module DiscourseWorkflows# `Plugin::Instance#on` gates the handler on the owning plugin being enabled,# so a node stops listening as soon as its plugin is turned off.def subscribe_node_event(node_class, plugin)- event_name = node_class.event_name if node_class.respond_to?(:event_name)- return if event_name.blank?+ event_names = node_class.event_names if node_class.respond_to?(:event_names)+ return if event_names.blank?# Event handlers outlive Zeitwerk reloads, so resolve named classes at dispatch.node_reference = node_class.name || node_class- plugin.on(event_name) do |*args|- current_class = node_reference.is_a?(String) ? node_reference.constantize : node_reference- EventListener.handle(current_class, *args)+ event_names.each do |event_name|+ plugin.on(event_name) do |*args|+ current_class = node_reference.is_a?(String) ? node_reference.constantize : node_reference+ EventListener.handle(current_class, *args, event_name:)+ endendendenddiff --git a/plugins/discourse-workflows/spec/integration/status_event_triggers_spec.rb b/plugins/discourse-workflows/spec/integration/status_event_triggers_spec.rbindex 11e70fddd44..6e95c1d7a84 100644--- a/plugins/discourse-workflows/spec/integration/status_event_triggers_spec.rb+++ b/plugins/discourse-workflows/spec/integration/status_event_triggers_spec.rb@@ -2,6 +2,7 @@RSpec.describe "Workflow status event triggers" dofab!(:admin)+ fab!(:user)fab!(:topic, :topic_with_op)before { DiscourseWorkflows::WorkflowDependency.clear_cache! }@@ -72,6 +73,44 @@ RSpec.describe "Workflow status event triggers" doendend+ it "dispatches promotions with both trust levels and the execution user" do+ user.update!(trust_level: TrustLevel.levels[:basic])+ create_workflow(+ "promoted",+ "trigger:user_trust_level_changed",+ "old_trust_levels" => [TrustLevel.levels[:basic].to_s],+ "new_trust_levels" => [TrustLevel.levels[:member].to_s],+ )++ Promotion.new(user).change_trust_level!(TrustLevel.levels[:member])++ expect(enqueued_jobs.size).to eq(1)+ expect(enqueued_jobs.first["user_id"]).to eq(user.id)+ expect(enqueued_jobs.first["trigger_data"]).to include(+ "old_trust_level" => TrustLevel.levels[:basic],+ "new_trust_level" => TrustLevel.levels[:member],+ )+ expect(enqueued_jobs.first["trigger_data"]).to match_node_output_schema(+ DiscourseWorkflows::Nodes::UserTrustLevelChanged::V1,+ )+ end++ it "dispatches first login without dispatching later logins" do+ user.update!(last_seen_at: nil)+ create_workflow("first-login", "trigger:user_first_logged_in")++ user.logged_in+ user.update!(last_seen_at: Time.current)+ user.logged_in++ expect(enqueued_jobs.size).to eq(1)+ expect(enqueued_jobs.first["user_id"]).to eq(user.id)+ expect(enqueued_jobs.first.dig("trigger_data", "user", "id")).to eq(user.id)+ expect(enqueued_jobs.first["trigger_data"]).to match_node_output_schema(+ DiscourseWorkflows::Nodes::UserFirstLoggedIn::V1,+ )+ end+def create_workflow(trigger_id, trigger_type, configuration = {})graph =build_workflow_graph do |graph_builder|diff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/user_first_logged_in_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/user_first_logged_in_spec.rbnew file mode 100644index 00000000000..386d38408f6--- /dev/null+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/user_first_logged_in_spec.rb@@ -0,0 +1,13 @@+# frozen_string_literal: true++RSpec.describe DiscourseWorkflows::Nodes::UserFirstLoggedIn::V1 do+ fab!(:user)++ describe "#valid?" do+ it "accepts human users" do+ expect(described_class.new(user)).to be_valid+ expect(described_class.new(nil)).not_to be_valid+ expect(described_class.new(Discourse.system_user)).not_to be_valid+ end+ end+enddiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/user_moderation_changed_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/user_moderation_changed_spec.rbnew file mode 100644index 00000000000..ccf8f035236--- /dev/null+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/user_moderation_changed_spec.rb@@ -0,0 +1,58 @@+# frozen_string_literal: true++RSpec.describe DiscourseWorkflows::Nodes::UserModerationChanged::V1 do+ fab!(:user)+ fab!(:admin)++ it "dispatches moderation changes with safe actor data and filters selected changes" do+ freeze_time+ expiry = 1.day.from_now+ graph =+ build_workflow_graph do |builder|+ builder.node "moderation", described_class.identifier+ builder.node "suspended",+ described_class.identifier,+ configuration: {+ changes: ["suspended"],+ }+ end+ Fabricate(:discourse_workflows_workflow, created_by: admin, published: true, **graph)++ UserSuspender.new(user, by_user: admin, reason: "Spam", suspended_till: expiry).suspend+ UserSuspender.unsuspend(user, by_user: admin)+ UserSilencer.silence(user, admin, reason: "Spam", silenced_till: expiry, keep_posts: true)+ UserSilencer.unsilence(user, admin)++ jobs = Jobs::DiscourseWorkflows::ExecuteWorkflow.jobs.map { |job| job["args"].first }+ data = jobs.filter_map { |job| job["trigger_data"] if job["trigger_node_id"] == "moderation" }+ expect(data.pluck("change")).to eq(%w[suspended unsuspended silenced unsilenced])+ expect(data.pluck("reason")).to eq(["Spam", nil, "Spam", nil])+ expect(data.pluck("expires_at")).to eq([expiry.iso8601, nil, expiry.iso8601, nil])+ expect(+ jobs.filter_map do |job|+ job["trigger_data"]["change"] if job["trigger_node_id"] == "suspended"+ end,+ ).to eq(["suspended"])+ data.each do |output|+ expect(output["user"]).to include("id" => user.id, "username" => user.username)+ expect(output["actor"]).to include("id" => admin.id, "username" => admin.username)+ expect(output["actor"]).not_to have_key("email")+ expect(output).to match_node_output_schema(described_class)+ end+ end++ it "preserves an unknown actor and reason" do+ user.update!(silenced_till: 1.day.from_now)++ output = described_class.from_event(:user_silenced, user: user).output++ expect(output).to include(actor: nil, reason: nil, expires_at: user.silenced_till.iso8601)+ expect(output).to match_node_output_schema(described_class)+ end++ it "rejects missing users, bots, and unsupported events" do+ expect(described_class.from_event(:user_suspended, {})).not_to be_valid+ expect(described_class.from_event(:user_suspended, user: Discourse.system_user)).not_to be_valid+ expect(described_class.from_event(:user_updated, user: user)).not_to be_valid+ end+enddiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/user_trust_level_changed_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/user_trust_level_changed_spec.rbnew file mode 100644index 00000000000..161b9643dac--- /dev/null+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/nodes/user_trust_level_changed_spec.rb@@ -0,0 +1,48 @@+# frozen_string_literal: true++RSpec.describe DiscourseWorkflows::Nodes::UserTrustLevelChanged::V1 do+ fab!(:user)++ let(:old_level) { TrustLevel.levels[:basic] }+ let(:new_level) { TrustLevel.levels[:member] }+ let(:event_data) { { user_id: user.id, old_trust_level: old_level, new_trust_level: new_level } }++ describe "#valid?" do+ it "requires changed trust levels and a human user" do+ expect(described_class.new(event_data)).to be_valid+ expect(+ described_class.new(+ event_data.merge(old_trust_level: new_level, new_trust_level: old_level),+ ),+ ).to be_valid++ expect(described_class.new(event_data.merge(new_trust_level: old_level))).not_to be_valid+ expect(described_class.new(event_data.merge(user_id: nil))).not_to be_valid+ expect(+ described_class.new(event_data.merge(user_id: Discourse::SYSTEM_USER_ID)),+ ).not_to be_valid+ end+ end++ describe "#matches?" do+ it "filters both the previous and new trust levels" do+ trigger = described_class.new(event_data)++ expect(trigger.matches?(trigger_context({}))).to eq(true)+ expect(+ trigger.matches?(+ trigger_context(+ "old_trust_levels" => [old_level.to_s],+ "new_trust_levels" => [new_level.to_s],+ ),+ ),+ ).to eq(true)+ expect(trigger.matches?(trigger_context("old_trust_levels" => [new_level]))).to eq(false)+ expect(trigger.matches?(trigger_context("new_trust_levels" => [old_level]))).to eq(false)+ end+ end++ def trigger_context(parameters)+ DiscourseWorkflows::TriggerNodeContext.new({ "parameters" => parameters })+ end+enddiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/plugin_node_registration_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/plugin_node_registration_spec.rbindex db70c7b09a9..e6df3dbcd5b 100644--- a/plugins/discourse-workflows/spec/lib/discourse_workflows/plugin_node_registration_spec.rb+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/plugin_node_registration_spec.rb@@ -27,7 +27,7 @@ RSpec.describe DiscourseWorkflows dobefore doDiscourseWorkflows.node_registration_ready = true- allow(DiscourseWorkflows::EventListener).to receive(:handle) do |klass, *args|+ allow(DiscourseWorkflows::EventListener).to receive(:handle) do |klass, *args, **|handled << [klass, args]endenddiff --git a/plugins/discourse-workflows/spec/lib/discourse_workflows/registry_reload_spec.rb b/plugins/discourse-workflows/spec/lib/discourse_workflows/registry_reload_spec.rbindex b11bf0b408e..1650024223c 100644--- a/plugins/discourse-workflows/spec/lib/discourse_workflows/registry_reload_spec.rb+++ b/plugins/discourse-workflows/spec/lib/discourse_workflows/registry_reload_spec.rb@@ -59,8 +59,8 @@ RSpec.describe DiscourseWorkflows::Registry doplugin,)described_class.reset_indexes!- allow(DiscourseWorkflows::EventListener).to receive(:handle) do |klass, *args|- handled << [klass, args]+ allow(DiscourseWorkflows::EventListener).to receive(:handle) do |klass, *args, event_name:|+ handled << [klass, args, event_name]endend@@ -111,7 +111,7 @@ RSpec.describe DiscourseWorkflows::Registry doexpect(serialized[:metadata]).to eq("channels" => [{ id: 1, name: color }])DiscourseEvent.trigger(:workflow_reload_test, color)- expect(handled.last).to eq([current, [color]])+ expect(handled.last).to eq([current, [color], :workflow_reload_test])previous = currentenddiff --git a/spec/jobs/user_suspension_expired_spec.rb b/spec/jobs/user_suspension_expired_spec.rbnew file mode 100644index 00000000000..3b8d12677ea--- /dev/null+++ b/spec/jobs/user_suspension_expired_spec.rb@@ -0,0 +1,103 @@+# frozen_string_literal: true++RSpec.describe Jobs::UserSuspensionExpired do+ fab!(:user)++ describe "#execute" do+ it "announces an expired suspension once and preserves its history" do+ freeze_time(Time.zone.now.round)+ started_at = 1.day.ago+ expiry = 1.hour.ago+ user.update!(suspended_at: started_at, suspended_till: expiry)+ args = {+ user_id: user.id,+ suspended_at: started_at.iso8601(UserSuspender::TIMESTAMP_PRECISION),+ suspended_till: expiry.iso8601(UserSuspender::TIMESTAMP_PRECISION),+ }++ events =+ DiscourseEvent.track_events(:user_unsuspended) do+ described_class.new.execute(args)+ described_class.new.execute(args)+ user+ .user_histories+ .where(action: UserHistory.actions[:unsuspend_user])+ .update_all(action: UserHistory.actions[:removed_unsuspend_user])+ described_class.new.execute(args)+ end++ expect(user.reload).to have_attributes(suspended_at: started_at, suspended_till: expiry)+ expect(events.map { |event| event[:params].first }).to contain_exactly(+ user: user,+ by_user: Discourse.system_user,+ )+ end++ it "ignores replaced suspensions and early jobs" do+ freeze_time(Time.zone.now.round)+ expiry = 1.day.from_now+ user.update!(suspended_at: 1.day.ago, suspended_till: 1.hour.ago)++ events =+ DiscourseEvent.track_events(:user_unsuspended) do+ described_class.new.execute(+ user_id: user.id,+ suspended_at: user.suspended_at.iso8601(UserSuspender::TIMESTAMP_PRECISION),+ suspended_till: 2.hours.ago.iso8601(UserSuspender::TIMESTAMP_PRECISION),+ )+ user.update!(suspended_till: expiry)+ described_class.new.execute(+ user_id: user.id,+ suspended_at: user.suspended_at.iso8601(UserSuspender::TIMESTAMP_PRECISION),+ suspended_till: expiry.iso8601(UserSuspender::TIMESTAMP_PRECISION),+ )+ end++ expect(user.reload.suspended_till).to eq(expiry)+ expect(events).to be_empty+ end++ it "distinguishes separate suspensions with the same expiry" do+ freeze_time(Time.zone.now.round)+ expiry = 1.hour.ago+ user.update!(suspended_at: 2.days.ago, suspended_till: expiry)+ args = {+ user_id: user.id,+ suspended_at: user.suspended_at.iso8601(UserSuspender::TIMESTAMP_PRECISION),+ suspended_till: expiry.iso8601(UserSuspender::TIMESTAMP_PRECISION),+ }++ events =+ DiscourseEvent.track_events(:user_unsuspended) do+ described_class.new.execute(args)+ user.update!(suspended_at: 1.day.ago)+ described_class.new.execute(args)+ described_class.new.execute(+ args.merge(suspended_at: user.suspended_at.iso8601(UserSuspender::TIMESTAMP_PRECISION)),+ )+ end++ expect(events.size).to eq(2)+ expect(user.reload).to have_attributes(suspended_at: 1.day.ago, suspended_till: expiry)+ end++ it "retries notification when an event listener fails" do+ user.update!(suspended_at: 1.day.ago, suspended_till: 1.hour.ago)+ args = {+ user_id: user.id,+ suspended_at: user.suspended_at.iso8601(UserSuspender::TIMESTAMP_PRECISION),+ suspended_till: user.suspended_till.iso8601(UserSuspender::TIMESTAMP_PRECISION),+ }+ handler = proc { raise "Listener unavailable" }+ DiscourseEvent.on(:user_unsuspended, &handler)++ expect { described_class.new.execute(args) }.to raise_error("Listener unavailable")+ DiscourseEvent.off(:user_unsuspended, &handler)+ events = DiscourseEvent.track_events(:user_unsuspended) { described_class.new.execute(args) }++ expect(events.size).to eq(1)+ ensure+ DiscourseEvent.off(:user_unsuspended, &handler) if handler+ end+ end+enddiff --git a/spec/services/user_suspender_spec.rb b/spec/services/user_suspender_spec.rbindex bb99866068f..e5ef4afe188 100644--- a/spec/services/user_suspender_spec.rb+++ b/spec/services/user_suspender_spec.rb@@ -19,12 +19,22 @@ RSpec.describe UserSuspender do)end- it "suspends the user correctly" do- freeze_time+ it "suspends the user and schedules automatic expiry" do+ freeze_time(Time.zone.now.round)+suspend_user+expect(user.reload).to be_suspendedexpect(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),+ )endit "creates a staff action log" do@@ -66,12 +76,13 @@ RSpec.describe UserSuspender doendit "fires a user_suspended event" do- freeze_time+ freeze_time(Time.zone.now.round)events = DiscourseEvent.track_events(:user_suspended) { suspend_user }expect(events.size).to eq(1)params = events[0][:params].firstexpect(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)@@ -105,4 +116,31 @@ RSpec.describe UserSuspender doendendend++ 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+ endend