Skip to content

A platform for community discussion. Free, open, simple.

29.9 KB
Raw Blame
# frozen_string_literal: true

RSpec.describe DiscourseAssign::AssignController do
  before do
    SiteSetting.assign_enabled = true
    SiteSetting.assign_allowed_on_groups = "#{allowed_group.id}|#{staff_group.id}"
  end

  fab!(:staff_group) { Group.find_by(name: "staff") }
  fab!(:non_allowed_group, :group)
  fab!(:allowed_group, :group)

  fab!(:admin)
  fab!(:allowed_user) { Fabricate(:user, username: "mads", name: "Mads", groups: [allowed_group]) }
  fab!(:non_admin_staff) { Fabricate(:user, groups: [staff_group]) }
  fab!(:user_in_non_allowed_group) { Fabricate(:user, groups: [non_allowed_group]) }

  fab!(:post)

  describe "only allow users from allowed groups to assign" do
    it "filters requests where current_user is not member of an allowed group" do
      sign_in(user_in_non_allowed_group)

      put "/assign/assign.json",
          params: {
            target_id: post.topic_id,
            target_type: "Topic",
            username: admin.username,
          }

      expect(response.status).to eq(403)
    end

    it "filters requests where assigned group is not allowed" do
      sign_in(admin)

      put "/assign/assign.json",
          params: {
            target_id: post.topic_id,
            target_type: "Topic",
            group_name: non_allowed_group.name,
          }

      expect(response.status).to eq(400)
    end
  end

  describe "#suggestions" do
    before { sign_in(admin) }

    def assign_user_to_post
      assignee = Fabricate(:user, groups: [allowed_group])
      Fabricate(:post_assignment, assigned_to: assignee, assigned_by_user: admin)
      assignee
    end

    def suggested_usernames
      response.parsed_body["suggestions"].map { |user| user["username"] }
    end

    it "only suggests recent assignees who can still be assigned" do
      Assigner.new(post.topic, admin).assign(allowed_user)
      Fabricate(:post_assignment, assigned_to: user_in_non_allowed_group, assigned_by_user: admin)

      get "/assign/suggestions.json"

      expect(suggested_usernames).to contain_exactly(allowed_user.username, admin.username)
    end

    it "suggests the current user + the last 5 previously assigned users" do
      assignees = 6.times.map { |_| assign_user_to_post.username }

      get "/assign/suggestions.json"

      expect(suggested_usernames).to contain_exactly(admin.username, *assignees[1..5])
    end

    it "doesn't suggest users on holiday, except the current user" do
      user_on_vacation = assign_user_to_post
      [user_on_vacation, admin].each do |user|
        user.upsert_custom_fields(DiscourseAssign::DiscourseCalendar::HOLIDAY_CUSTOM_FIELD => "t")
      end

      get "/assign/suggestions.json"

      expect(suggested_usernames).to contain_exactly(admin.username)
    end

    it "excludes other users from the suggestions when they already reached the max assigns limit" do
      SiteSetting.max_assigned_topics = 1
      another_user = Fabricate(:user)
      Fabricate(:post_assignment, assigned_to: another_user, assigned_by_user: admin)

      get "/assign/suggestions.json"

      expect(suggested_usernames).to contain_exactly(admin.username)
    end

    it "suggests the visible groups assignable on the target" do
      SiteSetting.assign_allowed_on_groups = ""
      topic = Fabricate(:topic, category: Fabricate(:category))
      scoped_group = Fabricate(:group)
      hidden_group = Fabricate(:group, visibility_level: Group.visibility_levels[:owners])
      scoped_user = Fabricate(:user, groups: [scoped_group])
      allow_group_to_assign_in_category(topic.category, scoped_group, hidden_group)

      sign_in(scoped_user)
      get "/assign/suggestions.json", params: { target_id: topic.id, target_type: "Topic" }

      expect(response.parsed_body["groups"].map { |group| group["name"] }).to contain_exactly(
        scoped_group.name,
      )
    end
  end

  describe "#search" do
    before_all { SearchIndexer.enable }

    fab!(:team_a) do
      Fabricate(
        :group,
        name: "team_a",
        members_visibility_level: Group.visibility_levels[:members],
        assignable_level: Group::ALIAS_LEVELS[:members_mods_and_admins],
      )
    end
    fab!(:team_b) do
      Fabricate(
        :group,
        name: "team_b",
        members_visibility_level: Group.visibility_levels[:members],
        assignable_level: Group::ALIAS_LEVELS[:members_mods_and_admins],
      )
    end
    fab!(:assigner) { Fabricate(:user, username: "assigner", groups: [team_a]) }
    fab!(:target_alice) { Fabricate(:user, username: "target_alice", groups: [team_a]) }
    fab!(:target_bob) { Fabricate(:user, username: "target_bob", groups: [team_b]) }
    fab!(:target_carol) { Fabricate(:user, username: "target_carol", groups: [non_allowed_group]) }
    fab!(:target_admin) { Fabricate(:admin, username: "target_admin") }

    let(:topic) { post.topic }

    before { SiteSetting.assign_allowed_on_groups = "#{team_a.id}|#{team_b.id}" }

    def search(term, target = topic)
      params = { term: }
      params.merge!(target_id: target.id, target_type: target.class.name) if target
      get "/assign/search.json", params:
    end

    def usernames
      response.parsed_body["users"].map { |user| user["username"] }
    end

    def group_names
      response.parsed_body["groups"].map { |group| group["name"] }
    end

    it "finds assignable users, even in groups whose members the assigner cannot see" do
      sign_in(assigner)
      search("target")

      expect(usernames).to contain_exactly(
        target_alice.username,
        target_bob.username,
        target_admin.username,
      )
    end

    it "finds visible groups the assigner can assign on the target" do
      scoped_group = Fabricate(:group, name: "team_scoped")
      hidden_group =
        Fabricate(:group, name: "team_hidden", visibility_level: Group.visibility_levels[:owners])
      allow_group_to_assign_in_category(topic.category, scoped_group, hidden_group)
      sign_in(assigner)

      search("team")

      expect(group_names).to contain_exactly(team_a.name, scoped_group.name)
    end

    it "rejects blank terms and targets the assigner cannot see" do
      sign_in(assigner)

      search(" ")
      expect(response.status).to eq(400)

      search("target", Fabricate(:private_message_topic))
      expect(response.status).to eq(404)
    end

    context "with only category-scoped groups" do
      before { SiteSetting.assign_allowed_on_groups = "" }

      it "finds members of groups scoped to the target's category" do
        scoped_group = Fabricate(:group, members_visibility_level: Group.visibility_levels[:owners])
        scoped_group.add(target_carol)
        allow_group_to_assign_in_category(topic.category, scoped_group)
        sign_in(admin)

        search("target_carol")
        expect(usernames).to contain_exactly(target_carol.username)

        search("target_carol", post)
        expect(usernames).to contain_exactly(target_carol.username)

        search("target_carol", Fabricate(:topic, category: Fabricate(:category)))
        expect(usernames).to be_empty
      end

      it "finds what the assigner can assign anywhere when there is no target" do
        own_group = Fabricate(:group)
        own_group.add(assigner)
        own_group.add(target_carol)
        allow_group_to_assign_in_category(Fabricate(:category), own_group)
        allow_group_to_assign_in_category(Fabricate(:category), team_b)

        sign_in(assigner)
        search("target", nil)
        expect(usernames).to contain_exactly(target_carol.username, target_admin.username)

        search("team", nil)
        expect(group_names).to contain_exactly(team_a.name)

        sign_in(admin)
        search("target", nil)
        expect(usernames).to contain_exactly(
          target_bob.username,
          target_carol.username,
          target_admin.username,
        )
      end

      it "denies users who cannot assign the target" do
        scoped_group = Fabricate(:group)
        scoped_group.add(assigner)
        allow_group_to_assign_in_category(Fabricate(:category), scoped_group)
        sign_in(assigner)

        search("target")

        expect(response.status).to eq(403)
      end
    end
  end

  describe "#unassign" do
    include_context "with group that is allowed to assign"

    it "returns 404 when the acting user cannot see the target topic" do
      restricted_group = Fabricate(:group)
      private_category = Fabricate(:private_category, group: restricted_group)
      private_topic = Fabricate(:topic, category: private_category)
      Fabricate(
        :topic_assignment,
        target: private_topic,
        assigned_to: admin,
        assigned_by_user: admin,
      )

      sign_in(allowed_user)

      put "/assign/unassign.json", params: { target_id: private_topic.id, target_type: "Topic" }
      expect(response.status).to eq(404)
    end

    it "returns 404 when the acting user cannot see the target PM" do
      pm_topic = Fabricate(:private_message_topic)
      Fabricate(:topic_assignment, target: pm_topic, assigned_to: admin, assigned_by_user: admin)

      sign_in(allowed_user)

      put "/assign/unassign.json", params: { target_id: pm_topic.id, target_type: "Topic" }
      expect(response.status).to eq(404)
    end

    it "only allows category scoped users to unassign topics in the scoped category" do
      SiteSetting.assign_allowed_on_groups = ""
      allowed_category = Fabricate(:category)
      other_category = Fabricate(:category)
      allowed_topic =
        Fabricate(:post).topic.tap { |topic| topic.update!(category: allowed_category) }
      other_topic = Fabricate(:post).topic.tap { |topic| topic.update!(category: other_category) }
      scoped_group = Fabricate(:group)
      scoped_user = Fabricate(:user, groups: [scoped_group])
      allow_group_to_assign_in_category(allowed_category, scoped_group)
      Fabricate(
        :topic_assignment,
        target: allowed_topic,
        assigned_to: admin,
        assigned_by_user: admin,
      )
      Fabricate(:topic_assignment, target: other_topic, assigned_to: admin, assigned_by_user: admin)

      sign_in(scoped_user)
      put "/assign/unassign.json", params: { target_id: other_topic.id, target_type: "Topic" }
      expect(response.status).to eq(403)
      expect(other_topic.reload.assignment).to be_present

      put "/assign/unassign.json", params: { target_id: allowed_topic.id, target_type: "Topic" }
      expect(response.status).to eq(200)
      expect(allowed_topic.reload.assignment).to be_blank
    end

    it "unassigns a topic with an API key scoped to assign -> assign" do
      category = Fabricate(:category)
      topic = Fabricate(:post).topic.tap { |topic| topic.update!(category: category) }
      api_key = Fabricate(:api_key, user: admin)
      Fabricate(:api_key_scope, resource: "assign", action: "assign", api_key_id: api_key.id)
      Fabricate(:topic_assignment, target: topic, assigned_to: admin, assigned_by_user: admin)

      put "/assign/unassign.json",
          headers: {
            "HTTP_API_KEY" => api_key.key,
            "HTTP_API_USERNAME" => admin.username,
          },
          params: {
            target_id: topic.id,
            target_type: "Topic",
          }

      expect(response.status).to eq(200)
    end
  end

  describe "#assign" do
    include_context "with group that is allowed to assign"

    before do
      sign_in(admin)
      SiteSetting.enable_assign_status = true
    end

    it "returns 404 when the acting user cannot see the target topic" do
      restricted_group = Fabricate(:group)
      private_category = Fabricate(:private_category, group: restricted_group)
      private_topic = Fabricate(:topic, category: private_category)
      assign_allowed_group.add(allowed_user)

      sign_in(allowed_user)

      put "/assign/assign.json",
          params: {
            target_id: private_topic.id,
            target_type: "Topic",
            username: admin.username,
          }
      expect(response.status).to eq(404)
    end

    it "returns 404 when the acting user cannot see the target PM" do
      pm_topic = Fabricate(:private_message_topic)
      assign_allowed_group.add(allowed_user)

      sign_in(allowed_user)

      put "/assign/assign.json",
          params: {
            target_id: pm_topic.id,
            target_type: "Topic",
            username: admin.username,
          }
      expect(response.status).to eq(404)
    end

    it "assigns topic to a user" do
      put "/assign/assign.json",
          params: {
            target_id: post.topic_id,
            target_type: "Topic",
            username: allowed_user.username,
          }

      expect(response.status).to eq(200)
      expect(post.topic.reload.assignment.assigned_to_id).to eq(allowed_user.id)
    end

    it "does not assign to a group hidden from the acting user" do
      hidden_group =
        Fabricate(
          :group,
          visibility_level: Group.visibility_levels[:staff],
          assignable_level: Group::ALIAS_LEVELS[:everyone],
        )

      sign_in(allowed_user)

      get "/g/#{hidden_group.name}.json"
      expect(response.status).to eq(404)

      put "/assign/assign.json",
          params: {
            target_id: post.topic_id,
            target_type: "Topic",
            group_name: hidden_group.name,
          }

      expect(response.status).to eq(403)
      expect(response.body).not_to include(hidden_group.name)
      expect(post.topic.reload.assignment).to be_nil
    end

    it "returns a 400 when neither a username nor a group name is given" do
      put "/assign/assign.json", params: { target_id: post.topic_id, target_type: "Topic" }

      expect(response.status).to eq(400)
      expect(post.topic.reload.assignment).to be_nil
    end

    it "rejects assignment notes longer than the maximum post length" do
      oversized_note = "a" * (SiteSetting.max_post_length + 1)

      put "/assign/assign.json",
          params: {
            target_id: post.topic_id,
            target_type: "Topic",
            username: allowed_user.username,
            note: oversized_note,
          }

      expect(response.status).to eq(400)
      expect(response.body).not_to include(oversized_note)
      expect(post.topic.reload.assignment).to be_nil
      expect(post.topic.posts.pluck(:raw)).not_to include(oversized_note)
    end

    it "assigns topic with a note and a status to a user" do
      put "/assign/assign.json",
          params: {
            target_id: post.topic_id,
            target_type: "Topic",
            username: allowed_user.username,
            note: "do dis pls",
            status: "In Progress",
          }

      assignment = post.topic.reload.assignment
      expect(assignment.note).to eq("do dis pls")
      expect(assignment.status).to eq("In Progress")
    end

    it "assigns topic with default status to a user" do
      put "/assign/assign.json",
          params: {
            target_id: post.topic_id,
            target_type: "Topic",
            username: allowed_user.username,
          }

      expect(post.topic.reload.assignment.status).to eq("New")
    end

    it "assigns topic to a group" do
      put "/assign/assign.json",
          params: {
            target_id: post.topic_id,
            target_type: "Topic",
            group_name: assign_allowed_group.name,
          }

      expect(response.status).to eq(200)
      expect(post.topic.reload.assignment.assigned_to).to eq(assign_allowed_group)
    end

    it "only allows category scoped users to assign in the exact scoped category" do
      SiteSetting.assign_allowed_on_groups = ""
      parent_category = Fabricate(:category)
      child_category = Fabricate(:category, parent_category: parent_category)
      parent_topic = Fabricate(:post).topic.tap { |topic| topic.update!(category: parent_category) }
      child_topic = Fabricate(:post).topic.tap { |topic| topic.update!(category: child_category) }
      scoped_group = Fabricate(:group)
      scoped_user = Fabricate(:user, groups: [scoped_group])
      assignee = Fabricate(:user, groups: [scoped_group])
      allow_group_to_assign_in_category(parent_category, scoped_group)

      sign_in(scoped_user)
      put "/assign/assign.json",
          params: {
            target_id: parent_topic.id,
            target_type: "Topic",
            username: assignee.username,
          }
      expect(response.status).to eq(200)
      expect(parent_topic.reload.assignment.assigned_to).to eq(assignee)

      put "/assign/assign.json",
          params: {
            target_id: child_topic.id,
            target_type: "Topic",
            username: assignee.username,
          }
      expect(response.status).to eq(400)
      expect(response.parsed_body["error"]).to eq(
        I18n.t("discourse_assign.forbidden_assigner_not_allowed"),
      )
    end

    it "fails to assign topic to the user if its already assigned to the same user" do
      put "/assign/assign.json",
          params: {
            target_id: post.topic_id,
            target_type: "Topic",
            username: allowed_user.username,
          }

      expect(response.status).to eq(200)
      expect(post.topic.reload.assignment.assigned_to_id).to eq(allowed_user.id)

      put "/assign/assign.json",
          params: {
            target_id: post.topic_id,
            target_type: "Topic",
            username: allowed_user.username,
          }

      expect(response.status).to eq(400)
      expect(JSON.parse(response.body)["error"]).to eq(
        I18n.t("discourse_assign.already_assigned", username: allowed_user.username),
      )
    end

    it "fails to assign topic to the user if they already reached the max assigns limit" do
      another_user = Fabricate(:user)
      assign_allowed_group.add(another_user)
      another_post = Fabricate(:post)
      max_assigns = 1
      SiteSetting.max_assigned_topics = max_assigns
      Assigner.new(post.topic, admin).assign(another_user)

      put "/assign/assign.json",
          params: {
            target_id: another_post.topic_id,
            target_type: "Topic",
            username: another_user.username,
          }

      expect(response.status).to eq(400)
      expect(JSON.parse(response.body)["error"]).to eq(
        I18n.t(
          "discourse_assign.too_many_assigns",
          username: another_user.username,
          max: max_assigns,
        ),
      )
    end

    it "fails with a specific error message if the topic is a PM and the assignee can not see it" do
      pm = Fabricate(:private_message_post, user: admin).topic
      another_user = Fabricate(:user)
      assign_allowed_group.add(another_user)
      put "/assign/assign.json",
          params: {
            target_id: pm.id,
            target_type: "Topic",
            username: another_user.username,
          }

      expect(response.parsed_body["error"]).to eq(
        I18n.t(
          "discourse_assign.forbidden_assignee_not_pm_participant",
          username: another_user.username,
        ),
      )
    end

    it "notifies the assignee when the topic is assigned to a group" do
      admins = Group[:admins]
      admins.messageable_level = Group::ALIAS_LEVELS[:everyone]
      admins.assignable_level = Group::ALIAS_LEVELS[:everyone]
      admins.save!

      SiteSetting.invite_on_assign = true
      pm = Fabricate(:private_message_post, user: admin).topic

      another_user = Fabricate(:user)
      admins.add(another_user)
      admins
        .group_users
        .find_by(user_id: another_user.id)
        .update!(notification_level: NotificationLevels.all[:watching])

      Notification.delete_all
      Jobs.run_immediately!

      put "/assign/assign.json",
          params: {
            target_id: pm.id,
            target_type: "Topic",
            group_name: admins.name,
          }

      expect(Notification.count).to be > 0
    end

    it "does not notify the assignee when the topic is assigned to a group if should_notify option is set to false" do
      admins = Group[:admins]
      admins.messageable_level = Group::ALIAS_LEVELS[:everyone]
      admins.assignable_level = Group::ALIAS_LEVELS[:everyone]
      admins.save!

      SiteSetting.invite_on_assign = true
      pm = Fabricate(:private_message_post, user: admin).topic

      another_user = Fabricate(:user)
      admins.add(another_user)
      admins
        .group_users
        .find_by(user_id: another_user.id)
        .update!(notification_level: NotificationLevels.all[:watching])

      Notification.delete_all
      Jobs.run_immediately!

      put "/assign/assign.json",
          params: {
            target_id: pm.id,
            target_type: "Topic",
            group_name: admins.name,
            should_notify: false,
          }
      expect(Notification.count).to eq(0)
      expect(SilencedAssignment.count).to eq(1)
    end

    it "fails with a specific error message if the topic is not a PM and the assignee can not see it" do
      topic = Fabricate(:topic, category: Fabricate(:private_category, group: Fabricate(:group)))
      another_user = Fabricate(:user)
      assign_allowed_group.add(another_user)
      put "/assign/assign.json",
          params: {
            target_id: topic.id,
            target_type: "Topic",
            username: another_user.username,
          }

      expect(response.parsed_body["error"]).to eq(
        I18n.t(
          "discourse_assign.forbidden_assignee_cant_see_topic",
          username: another_user.username,
        ),
      )
    end

    it "assigns a topic with an API key scoped to assign -> assign" do
      category = Fabricate(:category)
      topic = Fabricate(:post).topic.tap { |topic| topic.update!(category: category) }
      api_key = Fabricate(:api_key, user: admin)
      Fabricate(:api_key_scope, resource: "assign", action: "assign", api_key_id: api_key.id)

      put "/assign/assign.json",
          headers: {
            "HTTP_API_KEY" => api_key.key,
            "HTTP_API_USERNAME" => admin.username,
          },
          params: {
            target_id: topic.id,
            target_type: "Topic",
            username: admin.username,
          }

      expect(response.status).to eq(200)
    end
  end

  describe "#assigned" do
    fab!(:topic1) { Fabricate(:topic, bumped_at: 1.hour.from_now) }
    fab!(:topic2) { Fabricate(:topic, bumped_at: 2.hours.from_now) }
    fab!(:topic3) { Fabricate(:topic, bumped_at: 3.hours.from_now) }

    fab!(:assignments) do
      Fabricate(
        :topic_assignment,
        target: topic1,
        assigned_to: allowed_user,
        assigned_by_user: admin,
      )
      Fabricate(:topic_assignment, target: topic2, assigned_to: admin, assigned_by_user: admin)
      Fabricate(
        :topic_assignment,
        target: topic3,
        assigned_to: allowed_user,
        assigned_by_user: admin,
      )
    end

    before { sign_in(admin) }

    it "lists topics ordered by user id" do
      get "/assign/assigned.json"
      expect(JSON.parse(response.body)["topics"].map { |t| t["id"] }).to match_array(
        [topic2.id, topic1.id, topic3.id],
      )

      get "/assign/assigned.json", params: { limit: 2 }
      expect(JSON.parse(response.body)["topics"].map { |t| t["id"] }).to match_array(
        [topic3.id, topic2.id],
      )

      get "/assign/assigned.json", params: { offset: 2 }
      expect(JSON.parse(response.body)["topics"].map { |t| t["id"] }).to match_array([topic1.id])
    end

    context "with custom allowed groups" do
      let(:custom_allowed_group) { Fabricate(:group, name: "my-group") }
      let(:other_user) { Fabricate(:user, groups: [custom_allowed_group]) }

      before { SiteSetting.assign_allowed_on_groups += "|#{custom_allowed_group.id}" }

      it "works for admins" do
        get "/assign/assigned.json"
        expect(response.status).to eq(200)
      end

      it "does not work for other groups" do
        sign_in(other_user)
        get "/assign/assigned.json"
        expect(response.status).to eq(403)
      end
    end
  end

  describe "#group_members" do
    fab!(:other_allowed_user) { Fabricate(:user, groups: [allowed_group]) }

    fab!(:topic)
    fab!(:post_in_same_topic) { Fabricate(:post, topic: topic) }

    fab!(:assignments) do
      Fabricate(
        :topic_assignment,
        assigned_to: other_allowed_user,
        target: topic,
        assigned_by_user: admin,
      )

      Fabricate(
        :post_assignment,
        assigned_to: other_allowed_user,
        target: post_in_same_topic,
        assigned_by_user: admin,
      )

      Fabricate(:topic_assignment, assigned_to: allowed_user, assigned_by_user: admin)
      Fabricate(:topic_assignment, assigned_to: other_allowed_user, assigned_by_user: admin)

      Fabricate(:topic_assignment, assigned_to: allowed_group, assigned_by_user: admin)
      Fabricate(:post_assignment, assigned_to: allowed_group, assigned_by_user: admin)
    end

    it "does not list members for a group hidden from the user" do
      hidden_group =
        Fabricate(
          :group,
          visibility_level: Group.visibility_levels[:staff],
          members_visibility_level: Group.visibility_levels[:logged_on_users],
        )
      hidden_member = Fabricate(:user)
      hidden_group.add(hidden_member)
      Fabricate(:topic_assignment, assigned_to: hidden_member, assigned_by_user: admin)

      sign_in(allowed_user)

      get "/g/#{hidden_group.name}.json"
      expect(response.status).to eq(404)

      get "/assign/members/#{hidden_group.name}.json"
      expect(response.status).to eq(403)
      expect(
        response.parsed_body.fetch("members", []).map { |member| member["username"] },
      ).not_to include(hidden_member.username)
    end

    describe "members" do
      describe "without filter" do
        it "list members ordered by the number of assignments" do
          sign_in(admin)

          get "/assign/members/#{allowed_group.name}.json"
          members = JSON.parse(response.body)["members"]

          expect(response.status).to eq(200)
          expect(members[0]).to include({ "id" => other_allowed_user.id, "assignments_count" => 3 })
          expect(members[1]).to include({ "id" => allowed_user.id, "assignments_count" => 1 })
        end

        it "doesn't include members with no assignments" do
          sign_in(admin)
          allowed_group.users << non_admin_staff

          get "/assign/members/#{allowed_group.name}.json"
          expect(response.status).to eq(200)
          expect(JSON.parse(response.body)["members"].map { |m| m["id"] }).to_not include(
            non_admin_staff.id,
          )
        end
      end

      describe "with filter" do
        it "does not disclose hidden name matches while filtering usernames" do
          hidden_name_member =
            Fabricate(
              :user,
              username: "opaque-assignee",
              name: "Confidential Name Token",
              groups: [allowed_group],
            )
          Fabricate(:topic_assignment, assigned_to: hidden_name_member, assigned_by_user: admin)
          SiteSetting.enable_names = false
          sign_in(allowed_user)

          get "/assign/members/#{allowed_group.name}.json",
              params: {
                filter: hidden_name_member.name,
              }

          expect(response.status).to eq(200)
          expect(response.parsed_body["members"].map { |member| member["id"] }).not_to include(
            hidden_name_member.id,
          )
          expect(response.body).not_to include(hidden_name_member.name)

          get "/assign/members/#{allowed_group.name}.json",
              params: {
                filter: hidden_name_member.username,
              }

          expect(response.status).to eq(200)
          expect(response.parsed_body["members"].map { |member| member["id"] }).to contain_exactly(
            hidden_name_member.id,
          )
        end

        it "returns members as according to filter" do
          sign_in(admin)

          get "/assign/members/#{allowed_group.name}.json", params: { filter: "a" }
          expect(response.status).to eq(200)
          expect(JSON.parse(response.body)["members"].map { |m| m["id"] }).to match_array(
            [other_allowed_user.id, allowed_user.id],
          )

          get "/assign/members/#{allowed_group.name}.json",
              params: {
                filter: "#{allowed_user.username}",
              }
          expect(response.status).to eq(200)
          expect(JSON.parse(response.body)["members"].map { |m| m["id"] }).to match_array(
            [allowed_user.id],
          )

          get "/assign/members/#{allowed_group.name}.json",
              params: {
                filter: "#{allowed_user.name}",
              }
          expect(response.status).to eq(200)
          expect(JSON.parse(response.body)["members"].map { |m| m["id"] }).to match_array(
            [allowed_user.id],
          )
        end
      end
    end

    describe "assignment_count" do
      it "returns the total number of assignments for group users and the group" do
        sign_in(admin)

        get "/assign/members/#{allowed_group.name}.json"

        expect(JSON.parse(response.body)["assignment_count"]).to eq(6)
      end
    end

    describe "group_assignment_count" do
      it "returns the number of assignments assigned to the group" do
        sign_in(admin)

        get "/assign/members/#{allowed_group.name}.json"

        expect(JSON.parse(response.body)["group_assignment_count"]).to eq(2)
      end
    end

    it "404 error to non-group-members" do
      normal_user = Fabricate(:user)

      sign_in(normal_user)

      get "/assign/members/#{allowed_group.name}.json"
      expect(response.status).to eq(403)
    end

    it "returns 403 for users who can only assign in scoped categories" do
      SiteSetting.assign_allowed_on_groups = ""
      category = Fabricate(:category)
      scoped_group = Fabricate(:group)
      scoped_user = Fabricate(:user, groups: [scoped_group])
      allow_group_to_assign_in_category(category, scoped_group)

      sign_in(scoped_user)

      get "/assign/members/#{scoped_group.name}.json"
      expect(response.status).to eq(403)
    end

    it "allows non-member-admin" do
      non_member_admin = Fabricate(:admin)

      sign_in(non_member_admin)

      get "/assign/members/#{allowed_group.name}.json"
      expect(response.status).to eq(200)
    end
  end
end