Skip to content

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

21.7 KB
Raw Blame
# frozen_string_literal: true

RSpec.describe DirectoryItemsController do
  fab!(:user)
  fab!(:evil_trout) { Fabricate(:evil_trout, search_index: true) }
  fab!(:walter_white) { Fabricate(:walter_white, search_index: true) }
  fab!(:stage_user) do
    Fabricate(:staged, username: "stage_user", name: "Stage User", search_index: true)
  end
  fab!(:group) { Fabricate(:group, users: [evil_trout, stage_user]) }

  it "requires a `period` param" do
    get "/directory_items.json"
    expect(response.status).to eq(400)
  end

  it "requires a proper `period` param" do
    get "/directory_items.json", params: { period: "eviltrout" }
    expect(response).not_to be_successful
  end

  context "with limit parameter" do
    let!(:users) { Array.new(DirectoryItemsController::PAGE_SIZE + 10) { Fabricate(:user) } }

    before { DirectoryItem.refresh! }

    it "limits the number of returned items" do
      get "/directory_items.json", params: { period: "all", limit: 2 }
      expect(response.status).to eq(200)
      json = response.parsed_body

      expect(json["directory_items"].length).to eq(2)
    end

    include_examples "invalid limit params", "/directory_items.json", described_class::PAGE_SIZE
  end

  context "with page parameter" do
    it "only accepts valid page numbers" do
      get "/directory_items.json", params: { period: "all", page: -1 }
      expect(response.status).to eq(400)

      get "/directory_items.json", params: { period: "all", page: 0 }
      expect(response.status).to eq(200)
    end

    it "has a page number limit" do
      get "/directory_items.json", params: { period: "all", page: described_class::PAGE_LIMIT + 1 }
      expect(response.status).to eq(400)
    end
  end

  context "with exclude_groups parameter" do
    before { DirectoryItem.refresh! }

    it "excludes users from specified groups" do
      get "/directory_items.json", params: { period: "all", exclude_groups: group.name }
      expect(response.status).to eq(200)
      json = response.parsed_body
      usernames = json["directory_items"].map { |item| item["user"]["username"] }

      expect(usernames).not_to include("eviltrout", "stage_user")
    end

    it "handles non-existent group names gracefully" do
      get "/directory_items.json", params: { period: "all", exclude_groups: "non_existent_group" }
      expect(response.status).to eq(200)
      json = response.parsed_body

      user_names = json["directory_items"].map { |item| item["user"]["username"] }
      expect(user_names).to include("eviltrout")
    end

    it "does not allow anonymous users to exclude private groups" do
      secret_group =
        Fabricate(
          :group,
          name: "secret_group",
          members_visibility_level: Group.visibility_levels[:members],
        )
      secret_group.add(evil_trout)
      DirectoryItem.refresh!

      get "/directory_items.json", params: { period: "all", username: evil_trout.username }
      expect(response.status).to eq(200)
      expect(response.parsed_body["directory_items"].length).to eq(1)

      get "/directory_items.json",
          params: {
            period: "all",
            username: evil_trout.username,
            exclude_groups: "secret_group",
          }
      expect(response.status).to eq(200)
      expect(response.parsed_body["directory_items"].length).to eq(1)
    end

    it "does not allow a regular user to exclude groups with non-public member visibility" do
      secret_group =
        Fabricate(
          :group,
          name: "secret_group",
          members_visibility_level: Group.visibility_levels[:staff],
        )
      secret_group.add(evil_trout)
      DirectoryItem.refresh!

      sign_in(user)

      get "/directory_items.json", params: { period: "all", username: evil_trout.username }
      expect(response.status).to eq(200)
      baseline_count = response.parsed_body["directory_items"].length

      get "/directory_items.json",
          params: {
            period: "all",
            username: evil_trout.username,
            exclude_groups: "secret_group",
          }
      expect(response.status).to eq(200)
      expect(response.parsed_body["directory_items"].length).to eq(baseline_count)
    end
  end

  context "with exclude_groups parameter and current user in the top positions" do
    before do
      sign_in(evil_trout)
      DirectoryItem.refresh!
    end

    it "doesn't include current user if they are already in the top positions" do
      get "/directory_items.json", params: { period: "all", exclude_groups: group.name }
      expect(response.status).to eq(200)
      json = response.parsed_body
      usernames = json["directory_items"].map { |item| item["user"]["username"] }

      expect(usernames).not_to include("eviltrout")
    end
  end

  context "without data" do
    context "with a logged in user" do
      before { sign_in(user) }

      it "returns 200 when the directory has no data" do
        get "/directory_items.json", params: { period: "all" }
        expect(response.status).to eq(200)
      end
    end
  end

  context "with data" do
    before { DirectoryItem.refresh! }

    it "succeeds with a valid value" do
      get "/directory_items.json", params: { period: "all" }
      expect(response.status).to eq(200)
      json = response.parsed_body

      expect(json).to be_present
      expect(json["directory_items"]).to be_present
      expect(json["meta"]["total_rows_directory_items"]).to be_present
      expect(json["meta"]["load_more_directory_items"]).to be_present
      expect(json["meta"]["last_updated_at"]).to be_present

      expect(json["directory_items"].length).to eq(4)
      expect(json["meta"]["total_rows_directory_items"]).to eq(4)
      expect(json["meta"]["load_more_directory_items"]).to include(".json")
    end

    it "respects more_params in load_more_directory_items" do
      get "/directory_items.json",
          params: {
            period: "all",
            order: "likes_given",
            group: group.name,
            user_field_ids: "1|2",
          }
      expect(response.status).to eq(200)
      json = response.parsed_body

      expect(json["meta"]["load_more_directory_items"]).to include("group=#{group.name}")
      expect(json["meta"]["load_more_directory_items"]).to include(
        "user_field_ids=#{CGI.escape("1|2")}",
      )
      expect(json["meta"]["load_more_directory_items"]).to include("order=likes_given")
      expect(json["meta"]["load_more_directory_items"]).to include("period=all")
    end

    it "fails when the directory is disabled" do
      SiteSetting.enable_user_directory = false

      get "/directory_items.json", params: { period: "all" }
      expect(response).not_to be_successful
    end

    it "sort username with asc as a parameter" do
      get "/directory_items.json", params: { asc: true, order: "username", period: "all" }
      expect(response.status).to eq(200)
      json = response.parsed_body

      names = json["directory_items"].map { |item| item["user"]["username"] }
      expect(names).to eq(names.sort)
    end

    it "sort username without asc as a parameter" do
      get "/directory_items.json", params: { order: "username", period: "all" }
      expect(response.status).to eq(200)
      json = response.parsed_body

      names = json["directory_items"].map { |item| item["user"]["username"] }

      expect(names).to eq(names.sort.reverse)
    end

    it "finds user by name" do
      get "/directory_items.json", params: { period: "all", name: evil_trout.name }
      expect(response.status).to eq(200)

      json = response.parsed_body
      expect(json).to be_present
      expect(json["directory_items"].length).to eq(1)
      expect(json["meta"]["total_rows_directory_items"]).to eq(1)
      expect(json["directory_items"][0]["user"]["username"]).to eq("eviltrout")
    end

    it "finds staged user by name" do
      get "/directory_items.json", params: { period: "all", name: stage_user.name }
      expect(response.status).to eq(200)

      json = response.parsed_body
      expect(json).to be_present
      expect(json["directory_items"].length).to eq(1)
      expect(json["meta"]["total_rows_directory_items"]).to eq(1)
      expect(json["directory_items"][0]["user"]["username"]).to eq("stage_user")
    end

    it "excludes users by username" do
      get "/directory_items.json",
          params: {
            period: "all",
            exclude_usernames: "stage_user,eviltrout",
          }
      expect(response.status).to eq(200)

      json = response.parsed_body
      expect(json).to be_present
      expect(json["directory_items"].length).to eq(2)
      expect(json["meta"]["total_rows_directory_items"]).to eq(2)
      expect(json["directory_items"][0]["user"]["username"]).to eq(walter_white.username) |
        eq(user.username)
      expect(json["directory_items"][1]["user"]["username"]).to eq(walter_white.username) |
        eq(user.username)
    end

    it "filters users by group" do
      get "/directory_items.json", params: { period: "all", group: group.name }
      expect(response.status).to eq(200)

      json = response.parsed_body
      expect(json).to be_present
      expect(json["directory_items"].length).to eq(2)
      expect(json["meta"]["total_rows_directory_items"]).to eq(2)
      expect(json["directory_items"][0]["user"]["username"]).to eq(evil_trout.username) |
        eq(stage_user.username)
      expect(json["directory_items"][1]["user"]["username"]).to eq(evil_trout.username) |
        eq(stage_user.username)
    end

    it "orders users by user fields" do
      group.add(walter_white)
      [walter_white, stage_user, evil_trout].each do |directory_user|
        directory_user.update!(trust_level: TrustLevel[2])
      end
      field1 = Fabricate(:user_field, searchable: true, show_on_profile: true)
      field2 = Fabricate(:user_field, searchable: true, show_on_profile: true)

      user_fields = [
        { user: walter_white, field: field1, value: "Yellow", order: 1 },
        { user: stage_user, field: field1, value: "Apple", order: 0 },
        { user: evil_trout, field: field2, value: "Moon", order: 2 },
      ]

      user_fields.each do |data|
        UserCustomField.create!(
          user_id: data[:user].id,
          name: "user_field_#{data[:field].id}",
          value: data[:value],
        )
      end

      get "/directory_items.json",
          params: {
            period: "all",
            group: group.name,
            order: field1.name,
            user_field_ids: "#{field1.id}|#{field2.id}",
            asc: true,
          }
      expect(response.status).to eq(200)

      json = response.parsed_body
      expect(json).to be_present
      items = json["directory_items"]
      expect(items.length).to eq(3)
      expect(json["meta"]["total_rows_directory_items"]).to eq(3)

      user_fields.each do |data|
        user = items[data[:order]]["user"]
        expect(user["username"]).to eq(data[:user].username)
        expect(user["user_fields"]).to eq(
          { data[:field].id.to_s => { "searchable" => true, "value" => [data[:value]] } },
        )
      end
    end

    it "does not order anonymous users by private user fields" do
      group.add(walter_white)
      private_field = Fabricate(:user_field, show_on_profile: false, show_on_user_card: false)

      [
        { user: evil_trout, field_value: "Alpha", likes_received: 3 },
        { user: walter_white, field_value: "Mike", likes_received: 2 },
        { user: stage_user, field_value: "Zulu", likes_received: 1 },
      ].each do |data|
        DirectoryItem.find_by!(
          period_type: DirectoryItem.period_types[:all],
          user: data[:user],
        ).update!(likes_received: data[:likes_received])
        UserCustomField.create!(
          user_id: data[:user].id,
          name: "user_field_#{private_field.id}",
          value: data[:field_value],
        )
      end

      get "/directory_items.json", params: { period: "all", group: group.name, asc: true }
      expect(response.status).to eq(200)
      baseline_usernames =
        response.parsed_body["directory_items"].map { |item| item["user"]["username"] }

      get "/directory_items.json",
          params: {
            period: "all",
            group: group.name,
            order: private_field.name,
            asc: true,
          }
      expect(response.status).to eq(200)
      ordered_usernames =
        response.parsed_body["directory_items"].map { |item| item["user"]["username"] }

      expect(baseline_usernames).to eq(
        [stage_user.username, walter_white.username, evil_trout.username],
      )
      expect(ordered_usernames).to eq(baseline_usernames)
    end

    it "searches users by user field value" do
      field1 = Fabricate(:user_field, searchable: true, show_on_profile: true)
      field2 = Fabricate(:user_field, searchable: true, show_on_profile: true)

      user_fields = [
        { user: walter_white, field: field1, value: "Yellow", order: 1 },
        { user: stage_user, field: field1, value: "Apple", order: 0 },
        { user: evil_trout, field: field2, value: "Moon", order: 2 },
      ]

      user_fields.each do |data|
        UserCustomField.create!(
          user_id: data[:user].id,
          name: "user_field_#{data[:field].id}",
          value: data[:value],
        )
      end

      # When the users are fabricated their custom user fields
      # aren't added to the index so we can index them here.
      SearchIndexer.with_indexing do
        [walter_white, stage_user, evil_trout].each do |directory_user|
          SearchIndexer.index(directory_user, force: true)
        end
      end

      get "/directory_items.json",
          params: {
            period: "all",
            order: field1.name,
            name: "Moon",
            user_field_ids: "#{field1.id}|#{field2.id}",
            asc: true,
          }
      expect(response.status).to eq(200)

      json = response.parsed_body
      expect(json).to be_present
      items = json["directory_items"]
      expect(items.length).to eq(1)
      expect(json["meta"]["total_rows_directory_items"]).to eq(1)
      expect(items[0]["user"]["username"]).to eq("eviltrout")
    end

    it "filters users by user field value" do
      field = Fabricate(:user_field, searchable: true, show_on_profile: true)

      users = Fabricate.times(30, :user)
      users.each do |user|
        UserCustomField.create!(user_id: user.id, name: "user_field_#{field.id}", value: "blue")
      end

      DirectoryItem.refresh!

      # When the users are fabricated their custom user fields
      # aren't added to the index so we can index them here.
      SearchIndexer.with_indexing do
        users.each { |directory_user| SearchIndexer.index(directory_user, force: true) }
      end

      get "/directory_items.json",
          params: {
            period: "all",
            order: field.name,
            name: "blue",
            user_field_ids: "#{field.id}",
            asc: true,
          }
      expect(response.status).to eq(200)

      json = response.parsed_body
      expect(json).to be_present
      items = json["directory_items"]
      # Internal reference: /t/139545
      expect(items.length).to eq(30)
      expect(json["meta"]["total_rows_directory_items"]).to eq(30)
    end

    it "does not expose public user fields when profile details are restricted" do
      public_field = Fabricate(:user_field, show_on_profile: true)
      evil_trout.update!(trust_level: TrustLevel[2])
      UserCustomField.create!(
        user_id: evil_trout.id,
        name: "user_field_#{public_field.id}",
        value: "public_value",
      )

      SiteSetting.hide_user_profiles_from_public = true
      get "/directory_items.json", params: { period: "all", user_field_ids: public_field.id.to_s }
      expect(response.status).to eq(200)

      et_entry =
        response.parsed_body["directory_items"].find do |item|
          item["user"]["username"] == "eviltrout"
        end
      expect(et_entry).to be_present
      expect(et_entry["user"]).not_to have_key("user_fields")

      SiteSetting.allow_users_to_hide_profile = true
      evil_trout.user_option.update!(hide_profile: true)
      sign_in(user)

      get "/directory_items.json",
          params: {
            period: "all",
            username: evil_trout.username,
            user_field_ids: public_field.id.to_s,
          }
      expect(response.status).to eq(200)

      et_entry =
        response.parsed_body["directory_items"].find do |item|
          item["user"]["username"] == "eviltrout"
        end
      expect(et_entry).to be_present
      expect(et_entry["user"]).not_to have_key("user_fields")
    end

    it "does not expose private user fields to anonymous users" do
      public_field = Fabricate(:user_field, show_on_profile: true)
      evil_trout.update!(trust_level: TrustLevel[2])
      private_field = Fabricate(:user_field, show_on_profile: false, show_on_user_card: false)

      UserCustomField.create!(
        user_id: evil_trout.id,
        name: "user_field_#{public_field.id}",
        value: "public_value",
      )
      UserCustomField.create!(
        user_id: evil_trout.id,
        name: "user_field_#{private_field.id}",
        value: "secret_value",
      )

      get "/directory_items.json",
          params: {
            period: "all",
            user_field_ids: "#{public_field.id}|#{private_field.id}",
          }
      expect(response.status).to eq(200)

      json = response.parsed_body
      et_entry = json["directory_items"].find { |item| item["user"]["username"] == "eviltrout" }
      user_fields = et_entry["user"]["user_fields"]

      expect(user_fields).to have_key(public_field.id.to_s)
      expect(user_fields).not_to have_key(private_field.id.to_s)
    end

    it "exposes private user fields to staff" do
      sign_in(Fabricate(:admin))
      private_field = Fabricate(:user_field, show_on_profile: false, show_on_user_card: false)

      UserCustomField.create!(
        user_id: evil_trout.id,
        name: "user_field_#{private_field.id}",
        value: "secret_value",
      )

      get "/directory_items.json", params: { period: "all", user_field_ids: private_field.id.to_s }
      expect(response.status).to eq(200)

      json = response.parsed_body
      et_entry = json["directory_items"].find { |item| item["user"]["username"] == "eviltrout" }
      expect(et_entry["user"]["user_fields"]).to have_key(private_field.id.to_s)
    end

    it "checks group permissions" do
      group.update!(visibility_level: Group.visibility_levels[:members])

      sign_in(evil_trout)
      get "/directory_items.json", params: { period: "all", group: group.name }
      expect(response.status).to eq(200)

      get "/directory_items.json", params: { period: "all", group: "not a group" }
      expect(response.status).to eq(400)

      sign_in(user)
      get "/directory_items.json", params: { period: "all", group: group.name }
      expect(response.status).to eq(403)
    end

    it "does not force-include self in group-filtered results" do
      me = Fabricate(:user)
      DirectoryItem.refresh!
      sign_in(me)

      get "/directory_items.json", params: { period: "all", group: group.name }
      expect(response.parsed_body["directory_items"].length).to eq(2)
    end
  end

  context "when searching by name" do
    it "searches users by custom field 'Music' ignoring the default 20 user limit" do
      field = Fabricate(:user_field, searchable: true, show_on_profile: true)
      users = Fabricate.times(100, :user, trust_level: TrustLevel[2])

      users
        .first(70)
        .each do |music_user|
          UserCustomField.create!(
            user_id: music_user.id,
            name: "user_field_#{field.id}",
            value: "Music",
          )
        end

      DirectoryItem.refresh!
      SearchIndexer.with_indexing do
        users.each { |music_user| SearchIndexer.index(music_user, force: true) }
      end

      get "/directory_items.json",
          params: {
            period: "all",
            name: "Music",
            user_field_ids: field.id.to_s,
          }

      json = response.parsed_body
      items = json["directory_items"]

      expect(items.size).to eq(50) # The directory’s PAGE_SIZE is set to 50, so we only see 50 per page
      expect(json["meta"]["total_rows_directory_items"]).to eq(70) # only 70 users have the Music field set

      items.each do |item|
        fields = item["user"]["user_fields"]
        expect(fields[field.id.to_s]["value"]).to include("Music")
      end
    end

    it "finds users by a searchable custom field value containing `_`, `.` or `-`" do
      field = Fabricate(:user_field, searchable: true, show_on_profile: true)
      member = Fabricate(:user)
      UserCustomField.create!(
        user_id: member.id,
        name: "user_field_#{field.id}",
        value: "Acme-Corp",
      )

      DirectoryItem.refresh!
      SearchIndexer.with_indexing { SearchIndexer.index(member, force: true) }

      get "/directory_items.json", params: { period: "all", name: "Acme-Corp" }

      expect(response.status).to eq(200)
      usernames = response.parsed_body["directory_items"].map { |item| item["user"]["username"] }
      expect(usernames).to include(member.username)
    end

    it "finds users by a searchable custom field value when `enable_names` is disabled" do
      SiteSetting.enable_names = false

      field = Fabricate(:user_field, searchable: true, show_on_profile: true)
      member = Fabricate(:user)
      UserCustomField.create!(
        user_id: member.id,
        name: "user_field_#{field.id}",
        value: "Cutrocket",
      )

      DirectoryItem.refresh!
      SearchIndexer.with_indexing { SearchIndexer.index(member, force: true) }

      get "/directory_items.json", params: { period: "all", name: "Cutrocket" }

      expect(response.status).to eq(200)
      usernames = response.parsed_body["directory_items"].map { |item| item["user"]["username"] }
      expect(usernames).to include(member.username)
    end
  end
end