# frozen_string_literal: true

RSpec.describe User do
  fab!(:group) { Fabricate(:group) }

  subject(:user) { Fabricate(:user, last_seen_at: 1.day.ago) }

  def user_error_message(*keys)
    I18n.t(:"activerecord.errors.models.user.attributes.#{keys.join('.')}")
  end

  it { is_expected.to have_many(:pending_posts).class_name('ReviewableQueuedPost').with_foreign_key(:created_by_id) }

  describe 'Associations' do
    it 'should delete sidebar_section_links when a user is destroyed' do
      Fabricate(:category_sidebar_section_link, user: user)
      Fabricate(:tag_sidebar_section_link, user: user)

      expect { user.destroy! }.to change { SidebarSectionLink.where(user: user).count }.from(2).to(0)
    end
  end

  describe 'Callbacks' do
    describe 'default sidebar section links' do
      fab!(:category) { Fabricate(:category) }

      fab!(:secured_category) do |category|
        category = Fabricate(:category)
        category.permissions = { "staff" => :full }
        category.save!
        category
      end

      fab!(:tag) { Fabricate(:tag) }
      fab!(:hidden_tag) { Fabricate(:tag) }
      fab!(:staff_tag_group) { Fabricate(:tag_group, permissions: { "staff" => 1 }, tag_names: [hidden_tag.name]) }

      before do
        SiteSetting.enable_experimental_sidebar_hamburger = true
        SiteSetting.tagging_enabled = true
        SiteSetting.default_sidebar_categories = "#{category.id}|#{secured_category.id}"
        SiteSetting.default_sidebar_tags = "#{tag.name}|#{hidden_tag.name}"
      end

      it 'creates the right sidebar section link records for categories and tags that a user can see' do
        user = Fabricate(:user)

        expect(SidebarSectionLink.where(linkable_type: 'Category', user_id: user.id).pluck(:linkable_id)).to contain_exactly(
          category.id
        )

        expect(SidebarSectionLink.where(linkable_type: 'Tag', user_id: user.id).pluck(:linkable_id)).to contain_exactly(
          tag.id
        )

        admin = Fabricate(:admin)

        expect(SidebarSectionLink.where(linkable_type: 'Category', user_id: admin.id).pluck(:linkable_id)).to contain_exactly(
          category.id,
          secured_category.id
        )

        expect(SidebarSectionLink.where(linkable_type: 'Tag', user_id: admin.id).pluck(:linkable_id)).to contain_exactly(
          tag.id,
          hidden_tag.id
        )

        # A user promoted to admin should get secured sidebar records
        user.update(admin: true)

        expect(SidebarSectionLink.where(linkable_type: 'Category', user_id: user.id).pluck(:linkable_id)).to contain_exactly(
          category.id,
          secured_category.id
        )

        expect(SidebarSectionLink.where(linkable_type: 'Tag', user_id: user.id).pluck(:linkable_id)).to contain_exactly(
          tag.id,
          hidden_tag.id
        )
      end

      it 'should not create any sidebar section link records when experimental sidebar is disabled' do
        SiteSetting.enable_experimental_sidebar_hamburger = false

        user = Fabricate(:user)

        expect(SidebarSectionLink.exists?(user_id: user.id)).to eq(false)
      end

      it 'should not create any sidebar section link records for staged users' do
        user = Fabricate(:user, staged: true)

        expect(SidebarSectionLink.exists?).to eq(false)
      end

      it 'should create sidebar section link records when user has been unstaged' do
        user = Fabricate(:user, staged: true)
        user.unstage!

        expect(SidebarSectionLink.exists?(user: user)).to eq(true)
      end

      it 'should not create any sidebar section link records for non human users' do
        user = Fabricate(:user, id: -Time.now.to_i)

        expect(SidebarSectionLink.exists?).to eq(false)
      end

      it 'should not create any tag sidebar section link records when tagging is disabled' do
        SiteSetting.tagging_enabled = false

        user = Fabricate(:user)

        expect(SidebarSectionLink.exists?(linkable_type: 'Category', user_id: user.id)).to eq(true)
        expect(SidebarSectionLink.exists?(linkable_type: 'Tag', user_id: user.id)).to eq(false)
      end
    end
  end

  describe 'Validations' do
    describe '#username' do
      it { is_expected.to validate_presence_of :username }

      describe 'when username already exists' do
        it 'should not be valid' do
          new_user = Fabricate.build(:user, username: user.username.upcase)

          expect(new_user).to_not be_valid

          expect(new_user.errors.full_messages.first)
            .to include(I18n.t(:'user.username.unique'))
        end
      end

      describe 'when group with a same name already exists' do
        it 'should not be valid' do
          new_user = Fabricate.build(:user, username: group.name.upcase)

          expect(new_user).to_not be_valid

          expect(new_user.errors.full_messages.first)
            .to include(I18n.t(:'user.username.unique'))
        end
      end

      it 'is not valid if username changes to be same as password' do
        user.username = 'myawesomepassword'
        expect(user).to_not be_valid
        expect(user.errors.full_messages.first)
          .to include(user_error_message(:username, :same_as_password))
      end

      it 'is not valid if username lowercase changes to be same as password' do
        user.username = 'MyAwesomePassword'
        expect(user).to_not be_valid
        expect(user.errors.full_messages.first)
          .to include(user_error_message(:username, :same_as_password))
      end

      describe 'when a username is an integer' do
        it 'is converted to a string on normalization' do
          expect(User.normalize_username(123)).to eq("123") # This is possible via the API
        end
      end
    end

    describe 'name' do
      it 'is not valid if it changes to be the same as the password' do
        user.name = 'myawesomepassword'
        expect(user).to_not be_valid
        expect(user.errors.full_messages.first)
          .to include(user_error_message(:name, :same_as_password))
      end

      it 'is not valid if name lowercase changes to be the same as the password' do
        user.name = 'MyAwesomePassword'
        expect(user).to_not be_valid
        expect(user.errors.full_messages.first)
          .to include(user_error_message(:name, :same_as_password))
      end

      it "doesn't raise an error if the name is longer than the max password length" do
        user.name = 'x' * (User.max_password_length + 1)
        expect(user).to be_valid
      end
    end

    describe 'emails' do
      it { is_expected.to validate_presence_of :primary_email }

      let(:user) { Fabricate.build(:user) }

      describe 'when record has a valid email' do
        it "should be valid" do
          user.email = 'test@gmail.com'

          expect(user).to be_valid
        end
      end

      describe 'when record has an invalid email' do
        it 'should not be valid' do
          user.email = 'test@gmailcom'

          expect(user).to_not be_valid
          expect(user.errors.messages.keys).to contain_exactly(:primary_email)
        end
      end

      describe 'when record has an email that as already been taken' do
        it 'should not be valid' do
          user2 = Fabricate(:user)
          user.email = user2.email.upcase

          expect(user).to_not be_valid

          expect(user.errors.messages[:primary_email]).to include(I18n.t(
            'activerecord.errors.messages.taken'
          ))
        end
      end

      describe 'when user is staged' do
        it 'should still validate presence of primary_email' do
          user.staged = true
          user.email = nil

          expect(user).to_not be_valid
          expect(user.errors.messages).to include(:primary_email)
        end
      end

      describe 'when primary_email is being reassigned to another user' do
        it "should not be valid" do
          user2 = Fabricate.build(:user, email: nil)
          user.save!
          user2.primary_email = user.primary_email

          expect(user2).to_not be_valid
          expect(user2.errors.messages).to include(:primary_email)
          expect(user2.primary_email.errors.messages).to include(:user_id)
        end
      end
    end

    describe "#user_fields" do
      fab!(:user_field) { Fabricate(:user_field, show_on_profile: true) }
      let(:user_field_value) { user.reload.user_fields[user_field.id.to_s] }
      fab!(:watched_word) { Fabricate(:watched_word, word: "bad") }

      before { user.set_user_field(user_field.id, value) }

      context "when user fields contain watched words" do
        context "when watched words are of type 'Block'" do
          let(:value) { "bad user field value" }

          context "when user field is public" do
            it "is not valid" do
              user.valid?
              expect(user.errors[:base].size).to eq(1)
              expect(user.errors.messages[:base]).to include(/you can't post the word/)
            end
          end

          context "when user field is private" do
            before { user_field.update(show_on_profile: false) }

            it { is_expected.to be_valid }
          end
        end

        context "when watched words are of type 'Censor'" do
          let!(:censored_word) { Fabricate(:watched_word, word: "censored", action: WatchedWord.actions[:censor]) }
          let(:value) { "censored word" }

          context "when user field is public" do
            it "censors the words upon saving" do
              user.save!
              expect(user_field_value).to eq "■■■■■■■■ word"
            end
          end

          context "when user field is private" do
            before { user_field.update(show_on_profile: false) }

            it "does not censor anything" do
              user.save!
              expect(user_field_value).to eq "censored word"
            end
          end
        end

        context "when watched words are of type 'Replace'" do
          let(:value) { "word to replace" }
          let!(:replace_word) do
            Fabricate(:watched_word, word: "to replace", replacement: "replaced", action: WatchedWord.actions[:replace])
          end

          context "when user field is public" do
            it "replaces the words upon saving" do
              user.save!
              expect(user_field_value).to eq "word replaced"
            end
          end

          context "when user field is private" do
            before { user_field.update(show_on_profile: false) }

            it "does not replace anything" do
              user.save!
              expect(user_field_value).to eq "word to replace"
            end
          end
        end
      end

      context "when user fields do not contain watched words" do
        let(:value) { "good user field value" }

        it { is_expected.to be_valid }
      end

      context "when user fields contain URL" do
        let(:value) { "https://discourse.org" }

        it "is not cooked" do
          user.save!
          expect(user_field_value).to eq "https://discourse.org"
        end
      end

      context "with a multiselect user field" do
        fab!(:user_field) do
          Fabricate(:user_field, field_type: 'multiselect', show_on_profile: true) do
            user_field_options do
              [
                Fabricate(:user_field_option, value: 'Axe'),
                Fabricate(:user_field_option, value: 'Sword')
              ]
            end
          end
        end

        let(:user_field_value) { user.reload.user_fields[user_field.id.to_s] }

        context "with a blocked word" do
          let(:value) { %w{ Axe bad Sword } }

          it "does not block the word since it is not user generated-content" do
            user.save!
            expect(user_field_value).to eq %w{ Axe bad Sword }
          end
        end

        context "with a censored word" do
          let(:value) { %w{ Axe bad Sword } }
          before { watched_word.action = WatchedWord.actions[:censor] }

          it "does not censor the word since it is not user generated-content" do
            user.save!
            expect(user_field_value).to eq %w{ Axe bad Sword }
          end
        end

      end

      context "when reseting user fields" do
        let!(:censored_word) { Fabricate(:watched_word, word: "censored", action: WatchedWord.actions[:censor]) }
        let(:value) { nil }

        it "works" do
          user.save!
          expect(user_field_value).to eq nil
        end
      end
    end
  end

  describe '#count_by_signup_date' do
    before(:each) do
      User.destroy_all
      freeze_time DateTime.parse('2017-02-01 12:00')
      Fabricate(:user)
      Fabricate(:user, created_at: 1.day.ago)
      Fabricate(:user, created_at: 1.day.ago)
      Fabricate(:user, created_at: 2.days.ago)
      Fabricate(:user, created_at: 4.days.ago)
    end
    let(:signups_by_day) { { 1.day.ago.to_date => 2, 2.days.ago.to_date => 1, Time.now.utc.to_date => 1 } }

    it 'collect closed interval signups' do
      expect(User.count_by_signup_date(2.days.ago, Time.now)).to include(signups_by_day)
      expect(User.count_by_signup_date(2.days.ago, Time.now)).not_to include(4.days.ago.to_date => 1)
    end
  end

  describe '.enqueue_welcome_message' do
    fab!(:user) { Fabricate(:user) }

    it 'enqueues the system message' do
      SiteSetting.send_welcome_message = true

      expect_enqueued_with(job: :send_system_message, args: { user_id: user.id, message_type: 'welcome_user' }) do
        user.enqueue_welcome_message('welcome_user')
      end
    end

    it "doesn't enqueue the system message when the site settings disable it" do
      SiteSetting.send_welcome_message = false

      expect_not_enqueued_with(job: :send_system_message, args: { user_id: user.id, message_type: 'welcome_user' }) do
        user.enqueue_welcome_message('welcome_user')
      end
    end
  end

  describe 'enqueue_staff_welcome_message' do
    fab!(:first_admin) { Fabricate(:admin) }
    fab!(:user) { Fabricate(:user) }

    it 'enqueues message for admin' do
      expect {
        user.grant_admin!
      }.to change { Jobs::SendSystemMessage.jobs.count }.by 1
    end

    it 'enqueues message for moderator' do
      expect {
        user.grant_moderation!
      }.to change { Jobs::SendSystemMessage.jobs.count }.by 1
    end

    it 'skips the message if already an admin' do
      user.update(admin: true)
      expect {
        user.grant_admin!
      }.not_to change { Jobs::SendSystemMessage.jobs.count }
    end
  end

  describe '.set_default_tags_preferences' do
    let(:tag) { Fabricate(:tag) }

    it "should set default tag preferences when new user created" do
      SiteSetting.default_tags_watching = tag.name
      user = Fabricate(:user)
      expect(TagUser.exists?(tag_id: tag.id, user_id: user.id, notification_level: TagUser.notification_levels[:watching])).to be_truthy
    end
  end

  describe 'reviewable' do
    let(:user) { Fabricate(:user, active: false) }
    fab!(:admin) { Fabricate(:admin) }

    before do
      Jobs.run_immediately!
    end

    it "creates a reviewable for the user if must_approve_users is true and activate is called" do
      SiteSetting.must_approve_users = true
      user

      # Inactive users don't have reviewables
      reviewable = ReviewableUser.find_by(target: user)
      expect(reviewable).to be_blank

      user.activate
      reviewable = ReviewableUser.find_by(target: user)
      expect(reviewable).to be_present
      expect(reviewable.score > 0).to eq(true)
      expect(reviewable.reviewable_scores).to be_present
    end

    it "creates a reviewable for the user if must_approve_users is true and their token is confirmed" do
      SiteSetting.must_approve_users = true
      user

      # Inactive users don't have reviewables
      reviewable = ReviewableUser.find_by(target: user)
      expect(reviewable).to be_blank

      EmailToken.confirm(Fabricate(:email_token, user: user).token)
      expect(user.reload.active).to eq(true)
      reviewable = ReviewableUser.find_by(target: user)
      expect(reviewable).to be_present
    end

    it "doesn't create a reviewable if must_approve_users is false" do
      user
      expect(ReviewableUser.find_by(target: user)).to be_blank
    end

    it "will reject a reviewable if the user is deactivated" do
      SiteSetting.must_approve_users = true
      user

      user.activate
      reviewable = ReviewableUser.find_by(target: user)
      expect(reviewable.pending?).to eq(true)

      user.deactivate(admin)
      expect(reviewable.reload.rejected?).to eq(true)
    end
  end

  describe 'delete posts in batches' do
    fab!(:post1) { Fabricate(:post) }
    fab!(:user) { post1.user }
    fab!(:post2) { Fabricate(:post, topic: post1.topic, user: user) }
    fab!(:post3) { Fabricate(:post, user: user) }
    fab!(:posts) { [post1, post2, post3] }
    fab!(:post_ids) { [post1.id, post2.id, post3.id] }
    let(:guardian) { Guardian.new(Fabricate(:admin)) }
    fab!(:reviewable_queued_post) { Fabricate(:reviewable_queued_post, created_by: user) }

    it 'deletes only one batch of posts' do
      post2
      deleted_posts = user.delete_posts_in_batches(guardian, 1)
      expect(Post.where(id: post_ids).count).to eq(2)
      expect(deleted_posts.length).to eq(1)
      expect(deleted_posts[0]).to eq(post2)
    end

    it 'correctly deletes posts and topics' do
      posts
      user.delete_posts_in_batches(guardian, 20)

      expect(Post.where(id: post_ids)).to be_empty
      expect(Reviewable.where(created_by: user).count).to eq(0)

      posts.each do |p|
        if p.is_first_post?
          expect(Topic.find_by(id: p.topic_id)).to be_nil
        end
      end
    end

    it 'does not allow non moderators to delete all posts' do
      invalid_guardian = Guardian.new(Fabricate(:user))

      expect do
        user.delete_posts_in_batches(invalid_guardian)
      end.to raise_error Discourse::InvalidAccess

      posts.each do |p|
        p.reload
        expect(p).to be_present
        expect(p.topic).to be_present
      end
    end
  end

  describe 'new' do

    subject { Fabricate.build(:user) }

    it { is_expected.to be_valid }
    it { is_expected.not_to be_admin }
    it { is_expected.not_to be_approved }

    it "is properly initialized" do
      expect(subject.approved_at).to be_blank
      expect(subject.approved_by_id).to be_blank
    end

    it 'triggers an extensibility event' do
      event = DiscourseEvent.track_events { subject.save! }.first

      expect(event[:event_name]).to eq(:user_created)
      expect(event[:params].first).to eq(subject)
    end

    context 'with after_save' do
      before { subject.save! }

      it "has correct settings" do
        expect(subject.email_tokens).to be_present
        expect(subject.user_stat).to be_present
        expect(subject.user_profile).to be_present
        expect(subject.user_option.email_messages_level).to eq(UserOption.email_level_types[:always])
        expect(subject.user_option.email_level).to eq(UserOption.email_level_types[:only_when_away])
      end
    end

    it "downcases email addresses" do
      user = Fabricate.build(:user, email: 'Fancy.Caps.4.U@gmail.com')
      user.valid?
      expect(user.email).to eq('fancy.caps.4.u@gmail.com')
    end

    it "strips whitespace from email addresses" do
      user = Fabricate.build(:user, email: ' example@gmail.com ')
      user.valid?
      expect(user.email).to eq('example@gmail.com')
    end
  end

  describe 'ip address validation' do
    it 'validates ip_address for new users' do
      u = Fabricate.build(:user)
      AllowedIpAddressValidator.any_instance.expects(:validate_each).with(u, :ip_address, u.ip_address)
      u.valid?
    end

    it 'does not validate ip_address when updating an existing user' do
      u = Fabricate(:user)
      u.ip_address = '87.123.23.11'
      AllowedIpAddressValidator.any_instance.expects(:validate_each).never
      u.valid?
    end
  end

  describe "trust levels" do

    # NOTE be sure to use build to avoid db calls
    let(:user) { Fabricate.build(:user, trust_level: TrustLevel[0]) }

    it "sets to the default trust level setting" do
      SiteSetting.default_trust_level = TrustLevel[4]
      expect(User.new.trust_level).to eq(TrustLevel[4])
    end

    describe 'has_trust_level?' do

      it "raises an error with an invalid level" do
        expect { user.has_trust_level?(:wat) }.to raise_error(InvalidTrustLevel)
      end

      it "is true for your basic level" do
        expect(user.has_trust_level?(TrustLevel[0])).to eq(true)
      end

      it "is false for a higher level" do
        expect(user.has_trust_level?(TrustLevel[2])).to eq(false)
      end

      it "is true if you exceed the level" do
        user.trust_level = TrustLevel[4]
        expect(user.has_trust_level?(TrustLevel[1])).to eq(true)
      end

      it "is true for an admin even with a low trust level" do
        user.trust_level = TrustLevel[0]
        user.admin = true
        expect(user.has_trust_level?(TrustLevel[1])).to eq(true)
      end

    end

    describe 'moderator' do
      it "isn't a moderator by default" do
        expect(user.moderator?).to eq(false)
      end

      it "is a moderator if the user level is moderator" do
        user.moderator = true
        expect(user.has_trust_level?(TrustLevel[4])).to eq(true)
      end

      it "is staff if the user is an admin" do
        user.admin = true
        expect(user.staff?).to eq(true)
      end

    end

  end

  describe 'staff and regular users' do
    let(:user) { Fabricate.build(:user) }

    describe '#staff?' do
      subject { user.staff? }

      it { is_expected.to eq(false) }

      context 'for a moderator user' do
        before { user.moderator = true }

        it { is_expected.to eq(true) }
      end

      context 'for an admin user' do
        before { user.admin = true }

        it { is_expected.to eq(true) }
      end
    end

    describe '#regular?' do
      subject { user.regular? }

      it { is_expected.to eq(true) }

      context 'for a moderator user' do
        before { user.moderator = true }

        it { is_expected.to eq(false) }
      end

      context 'for an admin user' do
        before { user.admin = true }

        it { is_expected.to eq(false) }
      end
    end
  end

  describe 'email_hash' do
    before_all do
      @user = Fabricate(:user)
    end

    it 'should have a sane email hash' do
      expect(@user.email_hash).to match(/^[0-9a-f]{32}$/)
    end

    it 'should use downcase email' do
      @user.email = "example@example.com"
      @user2 = Fabricate(:user)
      @user2.email = "ExAmPlE@eXaMpLe.com"

      expect(@user.email_hash).to eq(@user2.email_hash)
    end

    it 'should trim whitespace before hashing' do
      @user.email = "example@example.com"
      @user2 = Fabricate(:user)
      @user2.email = " example@example.com "

      expect(@user.email_hash).to eq(@user2.email_hash)
    end
  end

  describe 'associated_accounts' do
    it 'should correctly find social associations' do
      user = Fabricate(:user)
      expect(user.associated_accounts).to eq([])

      UserAssociatedAccount.create(user_id: user.id, provider_name: "twitter", provider_uid: "1", info: { nickname: "sam" })
      UserAssociatedAccount.create(user_id: user.id, provider_name: "facebook", provider_uid: "1234", info: { email: "test@example.com" })
      UserAssociatedAccount.create(user_id: user.id, provider_name: "discord", provider_uid: "examplel123123", info: { nickname: "sam" })
      UserAssociatedAccount.create(user_id: user.id, provider_name: "google_oauth2", provider_uid: "1", info: { email: "sam@sam.com" })
      UserAssociatedAccount.create(user_id: user.id, provider_name: "github", provider_uid: "1", info: { nickname: "sam" })

      user.reload
      expect(user.associated_accounts.map { |a| a[:name] }).to contain_exactly('twitter', 'facebook', 'google_oauth2', 'github', 'discord')

    end
  end

  describe '.is_singular_admin?' do
    it 'returns true if user is singular admin' do
      admin = Fabricate(:admin)
      expect(admin.is_singular_admin?).to eq(true)
    end

    it 'returns false if user is not the only admin' do
      admin = Fabricate(:admin)
      Fabricate(:admin)

      expect(admin.is_singular_admin?).to eq(false)
    end
  end

  describe 'name heuristics' do
    it 'is able to guess a decent name from an email' do
      expect(User.suggest_name('sam.saffron@gmail.com')).to eq('Sam Saffron')
    end

    it 'is able to guess a decent name from username' do
      expect(User.suggest_name('@sam.saffron')).to eq('Sam Saffron')
    end

    it 'is able to guess a decent name from name' do
      expect(User.suggest_name('sam saffron')).to eq('Sam Saffron')
    end
  end

  describe 'username format' do
    fab!(:user) { Fabricate(:user) }

    def assert_bad(username)
      user.username = username
      expect(user.valid?).to eq(false)
    end

    def assert_good(username)
      user.username = username
      expect(user.valid?).to eq(true)
    end

    it "should be SiteSetting.min_username_length chars or longer" do
      SiteSetting.min_username_length = 5
      assert_bad("abcd")
      assert_good("abcde")
    end

    context 'when Unicode usernames are disabled' do
      before { SiteSetting.unicode_usernames = false }

      %w{
        first.last
        first
        first-last
        _name
        first_last
        mc.hammer_nose
        UPPERCASE
        sgif
      }.each do |username|
        it "allows #{username}" do
          assert_good(username)
        end
      end

      %w{
        traildot.
        has\ space
        double__underscore
        with%symbol
        Exclamation!
        @twitter
        my@email.com
        .tester
        sa$sy
        sam.json
        sam.xml
        sam.html
        sam.htm
        sam.js
        sam.woff
        sam.Png
        sam.gif
      }.each do |username|
        it "disallows #{username}" do
          assert_bad(username)
        end
      end
    end

    context 'when Unicode usernames are enabled' do
      before { SiteSetting.unicode_usernames = true }

      %w{
        Джофрэй
        Джо.фрэй
        Джофр-эй
        Д.жофрэй
        乔夫雷
        乔夫_雷
        _乔夫雷
      }.each do |username|
        it "allows #{username}" do
          assert_good(username)
        end
      end

      %w{
        .Джофрэй
        Джофрэй.
        Джо\ фрэй
        Джоф__рэй
        乔夫雷.js
        乔夫雷.
        乔夫%雷
      }.each do |username|
        it "disallows #{username}" do
          assert_bad(username)
        end
      end
    end
  end

  describe 'username uniqueness' do
    before_all do
      @user = Fabricate.build(:user)
      @user.save!
      @codinghorror = Fabricate.build(:coding_horror)
    end

    it "should not allow saving if username is reused" do
      @codinghorror.username = @user.username
      expect(@codinghorror.save).to eq(false)
    end

    it "should not allow saving if username is reused in different casing" do
      @codinghorror.username = @user.username.upcase
      expect(@codinghorror.save).to eq(false)
    end
  end

  describe '.username_available?' do
    it "returns true for a username that is available" do
      expect(User.username_available?('BruceWayne')).to eq(true)
    end

    it 'returns false when a username is taken' do
      expect(User.username_available?(Fabricate(:user).username)).to eq(false)
    end

    it 'returns false when a username is reserved' do
      SiteSetting.reserved_usernames = 'test|donkey'
      expect(User.username_available?('tESt')).to eq(false)
    end

    it 'returns true when reserved username is explicitly allowed' do
      SiteSetting.reserved_usernames = 'test|donkey'

      expect(User.username_available?(
        'tESt',
        nil,
        allow_reserved_username: true)
      ).to eq(true)
    end

    it "returns true when username is associated to a staged user of the same email" do
      staged = Fabricate(:user, staged: true, email: "foo@bar.com")
      expect(User.username_available?(staged.username, staged.primary_email.email)).to eq(true)

      user = Fabricate(:user, email: "bar@foo.com")
      expect(User.username_available?(user.username, user.primary_email.email)).to eq(false)
    end

    it 'returns false when a username equals an existing group name' do
      Fabricate(:group, name: 'foo')
      expect(User.username_available?('Foo')).to eq(false)
    end

    context "with Unicode usernames enabled" do
      before { SiteSetting.unicode_usernames = true }

      it 'returns false when the username is taken, but the Unicode normalization form is different' do
        Fabricate(:user, username: "L\u00F6we") # NFC
        requested_username = "Lo\u0308we" # NFD
        expect(User.username_available?(requested_username)).to eq(false)
      end

      it 'returns false when the username is taken and the case differs' do
        Fabricate(:user, username: 'LÖWE')
        expect(User.username_available?('löwe')).to eq(false)
      end
    end
  end

  describe '.reserved_username?' do
    it 'returns true when a username is reserved' do
      SiteSetting.reserved_usernames = 'test|donkey'

      expect(User.reserved_username?('donkey')).to eq(true)
      expect(User.reserved_username?('DonKey')).to eq(true)
      expect(User.reserved_username?('test')).to eq(true)
    end

    it 'should not allow usernames matched against an expression' do
      SiteSetting.reserved_usernames = "test)|*admin*|foo*|*bar|abc.def|löwe|ka\u0308fer"

      expect(User.reserved_username?('test')).to eq(false)
      expect(User.reserved_username?('abc9def')).to eq(false)

      expect(User.reserved_username?('admin')).to eq(true)
      expect(User.reserved_username?('foo')).to eq(true)
      expect(User.reserved_username?('bar')).to eq(true)

      expect(User.reserved_username?('admi')).to eq(false)
      expect(User.reserved_username?('bar.foo')).to eq(false)
      expect(User.reserved_username?('foo.bar')).to eq(true)
      expect(User.reserved_username?('baz.bar')).to eq(true)

      expect(User.reserved_username?('LÖwe')).to eq(true)
      expect(User.reserved_username?("Lo\u0308we")).to eq(true) # NFD
      expect(User.reserved_username?('löwe')).to eq(true) # NFC
      expect(User.reserved_username?('käfer')).to eq(true) # NFC
    end
  end

  describe 'email_validator' do
    it 'should allow good emails' do
      user = Fabricate.build(:user, email: 'good@gmail.com')
      expect(user).to be_valid
    end

    it 'should reject some emails based on the blocked_email_domains site setting' do
      SiteSetting.blocked_email_domains = 'mailinator.com'
      expect(Fabricate.build(:user, email: 'notgood@mailinator.com')).not_to be_valid
      expect(Fabricate.build(:user, email: 'mailinator@gmail.com')).to be_valid
    end

    it 'should reject some emails based on the blocked_email_domains site setting' do
      SiteSetting.blocked_email_domains = 'mailinator.com|trashmail.net'
      expect(Fabricate.build(:user, email: 'notgood@mailinator.com')).not_to be_valid
      expect(Fabricate.build(:user, email: 'notgood@trashmail.net')).not_to be_valid
      expect(Fabricate.build(:user, email: 'mailinator.com@gmail.com')).to be_valid
    end

    it 'should not reject partial matches' do
      SiteSetting.blocked_email_domains = 'mail.com'
      expect(Fabricate.build(:user, email: 'mailinator@gmail.com')).to be_valid
    end

    it 'should reject some emails based on the blocked_email_domains site setting ignoring case' do
      SiteSetting.blocked_email_domains = 'trashmail.net'
      expect(Fabricate.build(:user, email: 'notgood@TRASHMAIL.NET')).not_to be_valid
    end

    it 'should reject emails based on the blocked_email_domains site setting matching subdomain' do
      SiteSetting.blocked_email_domains = 'domain.com'
      expect(Fabricate.build(:user, email: 'notgood@sub.domain.com')).not_to be_valid
    end

    it 'skips the blocklist if skip_email_validation is set' do
      SiteSetting.blocked_email_domains = 'domain.com'
      user = Fabricate.build(:user, email: 'notgood@sub.domain.com')
      user.skip_email_validation = true
      expect(user).to be_valid
    end

    it 'blocklist should not reject developer emails' do
      Rails.configuration.stubs(:developer_emails).returns('developer@discourse.org')
      SiteSetting.blocked_email_domains = 'discourse.org'
      expect(Fabricate.build(:user, email: 'developer@discourse.org')).to be_valid
    end

    it 'should not interpret a period as a wildcard' do
      SiteSetting.blocked_email_domains = 'trashmail.net'
      expect(Fabricate.build(:user, email: 'good@trashmailinet.com')).to be_valid
    end

    it 'should not be used to validate existing records' do
      u = Fabricate(:user, email: 'in_before_blocklisted@fakemail.com')
      SiteSetting.blocked_email_domains = 'fakemail.com'
      expect(u).to be_valid
    end

    it 'should be used when email is being changed' do
      SiteSetting.blocked_email_domains = 'mailinator.com'
      u = Fabricate(:user, email: 'good@gmail.com')
      u.email = 'nope@mailinator.com'
      expect(u).not_to be_valid
    end

    it 'allowlist should reject some emails based on the allowed_email_domains site setting' do
      SiteSetting.allowed_email_domains = 'vaynermedia.com'
      user = Fabricate.build(:user, email: 'notgood@mailinator.com')
      expect(user).not_to be_valid
      expect(user.errors.messages[:primary_email]).to include(I18n.t('user.email.not_allowed'))
      expect(Fabricate.build(:user, email: 'sbauch@vaynermedia.com')).to be_valid
    end

    it 'should reject some emails based on the allowed_email_domains site setting when allowlisting multiple domains' do
      SiteSetting.allowed_email_domains = 'vaynermedia.com|gmail.com'
      expect(Fabricate.build(:user, email: 'notgood@mailinator.com')).not_to be_valid
      expect(Fabricate.build(:user, email: 'notgood@trashmail.net')).not_to be_valid
      expect(Fabricate.build(:user, email: 'mailinator.com@gmail.com')).to be_valid
      expect(Fabricate.build(:user, email: 'mailinator.com@vaynermedia.com')).to be_valid
    end

    it 'should accept some emails based on the allowed_email_domains site setting ignoring case' do
      SiteSetting.allowed_email_domains = 'vaynermedia.com'
      expect(Fabricate.build(:user, email: 'good@VAYNERMEDIA.COM')).to be_valid
    end

    it 'allowlist should accept developer emails' do
      Rails.configuration.stubs(:developer_emails).returns('developer@discourse.org')
      SiteSetting.allowed_email_domains = 'awesome.org'
      expect(Fabricate.build(:user, email: 'developer@discourse.org')).to be_valid
    end

    it 'email allowlist should not be used to validate existing records' do
      u = Fabricate(:user, email: 'in_before_allowlisted@fakemail.com')
      SiteSetting.blocked_email_domains = 'vaynermedia.com'
      expect(u).to be_valid
    end

    it 'email allowlist should be used when email is being changed' do
      SiteSetting.allowed_email_domains = 'vaynermedia.com'
      u = Fabricate(:user, email: 'good@vaynermedia.com')
      u.email = 'nope@mailinator.com'
      expect(u).not_to be_valid
    end

    it "doesn't validate email address for staged users" do
      SiteSetting.allowed_email_domains = "foo.com"
      SiteSetting.blocked_email_domains = "bar.com"

      user = Fabricate.build(:user, staged: true, email: "foo@bar.com")

      expect(user.save).to eq(true)
    end
  end

  describe 'passwords' do

    it "should not have an active account with a good password" do
      @user = Fabricate.build(:user, active: false)
      @user.password = "ilovepasta"
      @user.save!

      expect(@user.active).to eq(false)
      expect(@user.confirm_password?("ilovepasta")).to eq(true)

      email_token = Fabricate(:email_token, user: @user, email: 'pasta@delicious.com')

      UserAuthToken.generate!(user_id: @user.id)

      @user.password = "passwordT0"
      @user.save!

      # must expire old token on password change
      expect(@user.user_auth_tokens.count).to eq(0)

      email_token.reload
      expect(email_token.expired).to eq(true)
    end
  end

  describe "previous_visit_at" do
    fab!(:user) { Fabricate(:user) }
    let!(:first_visit_date) { Time.zone.now }
    let!(:second_visit_date) { 2.hours.from_now }
    let!(:third_visit_date) { 5.hours.from_now }

    before do
      SiteSetting.active_user_rate_limit_secs = 0
      SiteSetting.previous_visit_timeout_hours = 1
    end

    after do
      reset_last_seen_cache!(user)
    end

    it "should act correctly" do
      expect(user.previous_visit_at).to eq(nil)

      # first visit
      user.update_last_seen!(first_visit_date)
      expect(user.previous_visit_at).to eq(nil)

      # updated same time
      user.update_last_seen!(first_visit_date)
      user.reload
      expect(user.previous_visit_at).to eq(nil)

      # second visit
      user.update_last_seen!(second_visit_date)
      user.reload
      expect(user.previous_visit_at).to eq_time(first_visit_date)

      # third visit
      user.update_last_seen!(third_visit_date)
      user.reload
      expect(user.previous_visit_at).to eq_time(second_visit_date)
    end

  end

  describe "update_last_seen!" do
    fab!(:user) { Fabricate(:user) }
    let!(:first_visit_date) { Time.zone.now }
    let!(:second_visit_date) { 2.hours.from_now }

    after do
      reset_last_seen_cache!(user)
    end

    it "should update the last seen value" do
      expect(user.last_seen_at).to eq nil
      user.update_last_seen!(first_visit_date)
      expect(user.reload.last_seen_at).to eq_time(first_visit_date)
    end

    it "should update the first seen value if it doesn't exist" do
      user.update_last_seen!(first_visit_date)
      expect(user.reload.first_seen_at).to eq_time(first_visit_date)
    end

    it "should not update the first seen value if it doesn't exist" do
      user.update_last_seen!(first_visit_date)
      user.update_last_seen!(second_visit_date)
      expect(user.reload.first_seen_at).to eq_time(first_visit_date)
    end
  end

  describe "update_timezone_if_missing" do
    let(:timezone) { nil }

    it "does nothing if timezone is nil" do
      user.update_timezone_if_missing(timezone)
      expect(user.reload.user_option.timezone).to eq(nil)
    end

    context "if timezone is provided" do
      context "if the timezone is valid" do
        let(:timezone) { "Australia/Melbourne" }
        context "if no timezone exists on user option" do
          it "sets the timezone for the user" do
            user.update_timezone_if_missing(timezone)
            expect(user.reload.user_option.timezone).to eq(timezone)
          end
        end
      end

      context "if the timezone is not valid" do
        let(:timezone) { "Jupiter" }
        context "if no timezone exists on user option" do
          it "does not set the timezone for the user" do
            user.update_timezone_if_missing(timezone)
            expect(user.reload.user_option.timezone).to eq(nil)
          end
        end
      end

      context "if a timezone already exists on user option" do
        before do
          user.user_option.update_attribute(:timezone, "America/Denver")
        end

        it "does not update the timezone" do
          user.update_timezone_if_missing(timezone)
          expect(user.reload.user_option.timezone).to eq("America/Denver")
        end
      end
    end
  end

  describe "last_seen_at" do
    fab!(:user) { Fabricate(:user) }

    it "should have a blank last seen on creation" do
      expect(user.last_seen_at).to eq(nil)
    end

    it "should have 0 for days_visited" do
      expect(user.user_stat.days_visited).to eq(0)
    end

    describe 'with no previous values' do
      after do
        reset_last_seen_cache!(user)
        unfreeze_time
        reset_last_seen_cache!(user)
      end

      it "updates last_seen_at" do
        date = freeze_time
        user.update_last_seen!

        expect(user.last_seen_at).to eq_time(date)
      end

      it "should have 0 for days_visited" do
        user.update_last_seen!
        user.reload

        expect(user.user_stat.days_visited).to eq(1)
      end

      it "should log a user_visit with the date" do
        date = freeze_time
        user.update_last_seen!

        expect(user.user_visits.first.visited_at).to eq_time(date.to_date)
      end

      context "when called twice" do
        it "doesn't increase days_visited twice" do
          freeze_time
          user.update_last_seen!
          user.update_last_seen!
          user.reload

          expect(user.user_stat.days_visited).to eq(1)
        end
      end

      describe "after 3 days" do
        it "should log a second visited_at record when we log an update later" do
          user.update_last_seen!
          future_date = freeze_time(3.days.from_now)
          user.update_last_seen!

          expect(user.user_visits.count).to eq(2)
        end
      end
    end
  end

  describe 'email_confirmed?' do
    fab!(:user) { Fabricate(:user) }

    context 'when email has not been confirmed yet' do
      it 'should return false' do
        expect(user.email_confirmed?).to eq(false)
      end
    end

    context 'when email has been confirmed' do
      it 'should return true' do
        token = Fabricate(:email_token, user: user)
        EmailToken.confirm(token.token)
        expect(user.email_confirmed?).to eq(true)
      end
    end

    context 'when user has no email tokens for some reason' do
      it 'should return false' do
        user.email_tokens.each { |t| t.destroy }
        user.reload
        expect(user.email_confirmed?).to eq(true)
      end
    end
  end

  describe "flag_linked_posts_as_spam" do
    fab!(:user) { Fabricate(:user) }
    fab!(:admin) { Fabricate(:admin) }
    fab!(:post) { PostCreator.new(user, title: "this topic contains spam", raw: "this post has a link: http://discourse.org").create }
    fab!(:another_post) { PostCreator.new(user, title: "this topic also contains spam", raw: "this post has a link: http://discourse.org/asdfa").create }
    fab!(:post_without_link) { PostCreator.new(user, title: "this topic shouldn't be spam", raw: "this post has no links in it.").create }

    it "has flagged all the user's posts as spam" do
      user.flag_linked_posts_as_spam

      post.reload
      expect(post.spam_count).to eq(1)

      another_post.reload
      expect(another_post.spam_count).to eq(1)

      post_without_link.reload
      expect(post_without_link.spam_count).to eq(0)

      # It doesn't raise an exception if called again
      user.flag_linked_posts_as_spam
    end

    it "does not flags post as spam if the previous flag for that post was disagreed" do
      results = user.flag_linked_posts_as_spam

      expect(post.reload.spam_count).to eq(1)

      results.each { |result| result.reviewable.perform(admin, :disagree) }

      user.flag_linked_posts_as_spam

      expect(post.reload.spam_count).to eq(0)
    end

  end

  describe '#readable_name' do
    context 'when name is missing' do
      it 'returns just the username' do
        expect(Fabricate(:user, username: 'foo', name: nil).readable_name).to eq('foo')
      end
    end
    context 'when name and username are identical' do
      it 'returns just the username' do
        expect(Fabricate(:user, username: 'foo', name: 'foo').readable_name).to eq('foo')
      end
    end
    context 'when name and username are not identical' do
      it 'returns the name and username' do
        expect(Fabricate(:user, username: 'foo', name: 'Bar Baz').readable_name).to eq('Bar Baz (foo)')
      end
    end
  end

  describe '.find_by_username_or_email' do
    it 'finds users' do
      bob = Fabricate(:user, username: 'bob', email: 'bob@example.com')
      found_user = User.find_by_username_or_email('Bob')
      expect(found_user).to eq bob

      found_user = User.find_by_username_or_email('bob@Example.com')
      expect(found_user).to eq bob

      found_user = User.find_by_username_or_email('Bob@Example.com')
      expect(found_user).to eq bob

      found_user = User.find_by_username_or_email('bob1')
      expect(found_user).to be_nil

      found_user = User.find_by_email('bob@Example.com')
      expect(found_user).to eq bob

      found_user = User.find_by_email('BOB@Example.com')
      expect(found_user).to eq bob

      found_user = User.find_by_email('bob')
      expect(found_user).to be_nil

      found_user = User.find_by_username('bOb')
      expect(found_user).to eq bob
    end

    it 'finds users with Unicode username' do
      SiteSetting.unicode_usernames = true
      user = Fabricate(:user, username: 'löwe')

      expect(User.find_by_username('LÖWE')).to eq(user) # NFC
      expect(User.find_by_username("LO\u0308WE")).to eq(user) # NFD
      expect(User.find_by_username("lo\u0308we")).to eq(user) # NFD
    end
  end

  describe "#new_user_posting_on_first_day?" do

    def test_user?(opts = {})
      Fabricate.build(:user, { created_at: Time.zone.now }.merge(opts)).new_user_posting_on_first_day?
    end

    it "handles when user has never posted" do
      expect(test_user?).to eq(true)
      expect(test_user?(moderator: true)).to eq(false)
      expect(test_user?(trust_level: TrustLevel[2])).to eq(false)
      expect(test_user?(created_at: 2.days.ago)).to eq(true)
    end

    it "is true for a user who posted less than 24 hours ago but was created over 1 day ago" do
      u = Fabricate(:user, created_at: 28.hours.ago)
      u.user_stat.first_post_created_at = 1.hour.ago
      expect(u.new_user_posting_on_first_day?).to eq(true)
    end

    it "is false if first post was more than 24 hours ago" do
      u = Fabricate(:user, created_at: 28.hours.ago)
      u.user_stat.first_post_created_at = 25.hours.ago
      expect(u.new_user_posting_on_first_day?).to eq(false)
    end

    it "considers trust level 0 users as new users unconditionally" do
      u = Fabricate(:user, created_at: 28.hours.ago, trust_level: TrustLevel[0])
      u.user_stat.first_post_created_at = 25.hours.ago
      expect(u.new_user_posting_on_first_day?).to eq(true)
    end
  end

  describe "posted too much in topic" do
    let!(:user) { Fabricate(:user, trust_level: TrustLevel[0]) }
    let!(:topic) { Fabricate(:post).topic }

    before do
      # To make testing easier, say 1 reply is too much
      SiteSetting.newuser_max_replies_per_topic = 1
      UserActionManager.enable
    end

    context "for a user who didn't create the topic" do
      let!(:post) { Fabricate(:post, topic: topic, user: user) }

      it "does not return true for staff" do
        user.stubs(:staff?).returns(true)
        expect(user.posted_too_much_in_topic?(topic.id)).to eq(false)
      end

      it "returns true when the user has posted too much" do
        expect(user.posted_too_much_in_topic?(topic.id)).to eq(true)
      end

      context "with a reply" do
        before do
          Jobs.run_immediately!
          PostCreator.new(Fabricate(:user),
                          raw: 'whatever this is a raw post',
                          topic_id: topic.id,
                          reply_to_post_number: post.post_number).create
        end

        it "resets the `posted_too_much` threshold" do
          expect(user.posted_too_much_in_topic?(topic.id)).to eq(false)
        end
      end
    end

    it "returns false for a user who created the topic" do
      topic_user = topic.user
      topic_user.trust_level = TrustLevel[0]
      expect(topic.user.posted_too_much_in_topic?(topic.id)).to eq(false)
    end

  end

  describe "#find_email" do

    fab!(:user) { Fabricate(:user, email: "bob@example.com") }

    context "when email is exists in the email logs" do
      before { user.stubs(:last_sent_email_address).returns("bob@lastemail.com") }

      it "returns email from the logs" do
        expect(user.find_email).to eq("bob@lastemail.com")
      end
    end

    context "when email does not exist in the email logs" do
      before { user.stubs(:last_sent_email_address).returns(nil) }

      it "fetches the user's email" do
        expect(user.find_email).to eq(user.email)
      end
    end
  end

  describe "#gravatar_template" do

    it "returns a gravatar based template" do
      expect(User.gravatar_template("em@il.com")).to eq("//www.gravatar.com/avatar/6dc2fde946483a1d8a84b89345a1b638.png?s={size}&r=pg&d=identicon")
    end

  end

  describe "#custom_gravatar" do
    before do
      SiteSetting.gravatar_base_url = "seccdn.libravatar.org"
    end

    it "returns a gravatar url as set in the settings" do
      expect(User.gravatar_template("em@il.com")).to eq("//seccdn.libravatar.org/avatar/6dc2fde946483a1d8a84b89345a1b638.png?s={size}&r=pg&d=identicon")
    end
  end

  describe "#letter_avatar_color" do
    before do
      SiteSetting.restrict_letter_avatar_colors = "2F70AC|ED207B|AAAAAA|77FF33"
    end

    it "returns custom color if restrict_letter_avatar_colors site setting is set" do
      expect(User.letter_avatar_color("username_one")).to eq("2F70AC")
      expect(User.letter_avatar_color("username_two")).to eq("ED207B")
      expect(User.letter_avatar_color("username_three")).to eq("AAAAAA")
      expect(User.letter_avatar_color("username_four")).to eq("77FF33")
    end
  end

  describe ".small_avatar_url" do

    let(:user) { build(:user, username: 'Sam') }

    it "returns a 45-pixel-wide avatar" do
      SiteSetting.external_system_avatars_enabled = false
      expect(user.small_avatar_url).to eq("//test.localhost/letter_avatar/sam/45/#{LetterAvatar.version}.png")

      SiteSetting.external_system_avatars_enabled = true
      expect(user.small_avatar_url).to eq("//test.localhost/letter_avatar_proxy/v4/letter/s/5f9b8f/45.png")
    end

  end

  describe ".avatar_template_url" do

    let(:user) { build(:user, uploaded_avatar_id: 99, username: 'Sam') }

    it "returns a schemaless avatar template with correct id" do
      expect(user.avatar_template_url).to eq("//test.localhost/user_avatar/test.localhost/sam/{size}/99_#{OptimizedImage::VERSION}.png")
    end

    it "returns a schemaless cdn-based avatar template" do
      Rails.configuration.action_controller.stubs(:asset_host).returns("http://my.cdn.com")
      expect(user.avatar_template_url).to eq("//my.cdn.com/user_avatar/test.localhost/sam/{size}/99_#{OptimizedImage::VERSION}.png")
    end

  end

  describe '#avatar_template' do
    it 'uses the small logo if the user is the system user' do
      logo_small_url = Discourse.store.cdn_url(SiteSetting.logo_small.url)

      expect(Discourse.system_user.avatar_template).to eq(logo_small_url)
    end

    it 'uses the system user avatar if the logo is nil' do
      SiteSetting.logo_small = nil
      system_user = Discourse.system_user
      expected = User.avatar_template(system_user.username, system_user.uploaded_avatar_id)

      expect(Discourse.system_user.avatar_template).to eq(expected)
    end

    it 'uses the regular avatar for other users' do
      user = Fabricate(:user)
      expected = User.avatar_template(user.username, user.uploaded_avatar_id)

      expect(user.avatar_template).to eq(expected)
    end
  end

  describe "update_posts_read!" do
    context "with a UserVisit record" do
      fab!(:user) { Fabricate(:user) }
      let!(:now) { Time.zone.now }
      before { user.update_last_seen!(now) }
      after do
        reset_last_seen_cache!(user)
      end

      it "with existing UserVisit record, increments the posts_read value" do
        expect {
          user_visit = user.update_posts_read!(2)
          expect(user_visit.posts_read).to eq(2)
        }.to_not change { UserVisit.count }
      end

      it "with no existing UserVisit record, creates a new UserVisit record and increments the posts_read count" do
        expect {
          user_visit = user.update_posts_read!(3, at: 5.days.ago)
          expect(user_visit.posts_read).to eq(3)
        }.to change { UserVisit.count }.by(1)
      end
    end
  end

  describe "primary_group_id" do
    fab!(:user) { Fabricate(:user) }

    it "has no primary_group_id by default" do
      expect(user.primary_group_id).to eq(nil)
    end

    context "when the user has a group" do

      before do
        group.usernames = user.username
        group.save
        user.primary_group_id = group.id
        user.save
        user.reload
      end

      it "should allow us to use it as a primary group" do
        expect(user.primary_group_id).to eq(group.id)

        # If we remove the user from the group
        group.usernames = ""
        group.save

        # It should unset it from the primary_group_id
        user.reload
        expect(user.primary_group_id).to eq(nil)
      end
    end
  end

  describe "automatic avatar creation" do
    it "sets a system avatar for new users" do
      SiteSetting.external_system_avatars_enabled = false

      u = User.create!(username: "bob", email: "bob@bob.com")
      u.reload
      expect(u.uploaded_avatar_id).to eq(nil)
      expect(u.avatar_template).to eq("/letter_avatar/bob/{size}/#{LetterAvatar.version}.png")
    end
  end

  describe "custom fields" do
    it "allows modification of custom fields" do
      user = Fabricate(:user)

      expect(user.custom_fields["a"]).to eq(nil)

      user.custom_fields["bob"] = "marley"
      user.custom_fields["jack"] = "black"
      user.save

      user = User.find(user.id)

      expect(user.custom_fields["bob"]).to eq("marley")
      expect(user.custom_fields["jack"]).to eq("black")

      user.custom_fields.delete("bob")
      user.custom_fields["jack"] = "jill"

      user.save
      user = User.find(user.id)

      expect(user.custom_fields).to eq("jack" => "jill")
    end
  end

  describe "refresh_avatar" do
    it "enqueues the update_gravatar job when automatically downloading gravatars" do
      SiteSetting.automatically_download_gravatars = true

      user = Fabricate(:user)

      expect_enqueued_with(job: :update_gravatar, args: { user_id: user.id }) do
        user.refresh_avatar
      end
    end
  end

  describe "#purge_unactivated" do
    fab!(:user) { Fabricate(:user) }
    fab!(:unactivated) { Fabricate(:user, active: false) }
    fab!(:unactivated_old) { Fabricate(:user, active: false, created_at: 1.month.ago) }
    fab!(:unactivated_old_with_system_pm) { Fabricate(:user, active: false, created_at: 2.months.ago) }
    fab!(:unactivated_old_with_human_pm) { Fabricate(:user, active: false, created_at: 2.months.ago) }
    fab!(:unactivated_old_with_post) { Fabricate(:user, active: false, created_at: 1.month.ago) }

    before do
      Group.refresh_automatic_groups!

      PostCreator.new(Discourse.system_user,
                      title: "Welcome to our Discourse",
                      raw: "This is a welcome message",
                      archetype: Archetype.private_message,
                      target_usernames: [unactivated_old_with_system_pm.username],
      ).create

      PostCreator.new(user,
                      title: "Welcome to our Discourse",
                      raw: "This is a welcome message",
                      archetype: Archetype.private_message,
                      target_usernames: [unactivated_old_with_human_pm.username],
      ).create

      PostCreator.new(unactivated_old_with_post,
                      title: "Test topic from a user",
                      raw: "This is a sample message"
      ).create
    end

    it 'should only remove old, unactivated users' do
      User.purge_unactivated
      expect(User.real.all).to match_array([user, unactivated, unactivated_old_with_human_pm, unactivated_old_with_post])
    end

    it "does nothing if purge_unactivated_users_grace_period_days is 0" do
      SiteSetting.purge_unactivated_users_grace_period_days = 0
      User.purge_unactivated
      expect(User.real.all).to match_array([
        user, unactivated, unactivated_old, unactivated_old_with_system_pm, unactivated_old_with_human_pm, unactivated_old_with_post
      ])
    end
  end

  describe "hash_passwords" do

    let(:too_long) { "x" * (User.max_password_length + 1) }

    def hash(password, salt)
      User.new.send(:hash_password, password, salt)
    end

    it "returns the same hash for the same password and salt" do
      expect(hash('poutine', 'gravy')).to eq(hash('poutine', 'gravy'))
    end

    it "returns a different hash for the same salt and different password" do
      expect(hash('poutine', 'gravy')).not_to eq(hash('fries', 'gravy'))
    end

    it "returns a different hash for the same password and different salt" do
      expect(hash('poutine', 'gravy')).not_to eq(hash('poutine', 'cheese'))
    end

    it "raises an error when passwords are too long" do
      expect { hash(too_long, 'gravy') }.to raise_error(StandardError)
    end

  end

  describe "automatic group membership" do

    fab!(:group) {
      Fabricate(:group,
                automatic_membership_email_domains: "bar.com|wat.com",
                grant_trust_level: 1,
                title: "bars and wats",
                primary_group: true
      )
    }

    it "doesn't automatically add staged users" do
      staged_user = Fabricate(:user, active: true, staged: true, email: "wat@wat.com")
      EmailToken.confirm(Fabricate(:email_token, user: staged_user).token)
      group.reload
      expect(group.users.include?(staged_user)).to eq(false)
    end

    it "is automatically added to a group when the email matches" do
      user = Fabricate(:user, active: true, email: "foo@bar.com")
      EmailToken.confirm(Fabricate(:email_token, user: user).token)
      group.reload
      expect(group.users.include?(user)).to eq(true)

      group_history = GroupHistory.last

      expect(group_history.action).to eq(GroupHistory.actions[:add_user_to_group])
      expect(group_history.acting_user).to eq(Discourse.system_user)
      expect(group_history.target_user).to eq(user)
    end

    it "is automatically added to a group when the email matches the SSO record" do
      user = Fabricate(:user, active: true, email: "sso@bar.com")
      user.create_single_sign_on_record(external_id: 123, external_email: "sso@bar.com", last_payload: "")
      user.set_automatic_groups
      group.reload
      expect(group.users.include?(user)).to eq(true)
    end

    it "get attributes from the group" do
      user = Fabricate.build(:user,
                             active: true,
                             trust_level: 0,
                             email: "foo@bar.com",
                             password: "strongpassword4Uguys"
      )

      user.password_required!
      user.save!
      EmailToken.confirm(Fabricate(:email_token, user: user).token)
      user.reload

      expect(user.title).to eq("bars and wats")
      expect(user.trust_level).to eq(1)
      expect(user.manual_locked_trust_level).to be_nil
      expect(user.group_granted_trust_level).to eq(1)
    end
  end

  describe 'staff info' do
    fab!(:user) { Fabricate(:user) }
    fab!(:moderator) { Fabricate(:moderator) }

    describe "#number_of_flags_given" do
      it "doesn't count disagreed flags" do
        post_agreed = Fabricate(:post)
        PostActionCreator.inappropriate(user, post_agreed).reviewable.perform(moderator, :agree_and_keep)

        post_deferred = Fabricate(:post)
        PostActionCreator.inappropriate(user, post_deferred).reviewable.perform(moderator, :ignore)

        post_disagreed = Fabricate(:post)
        PostActionCreator.inappropriate(user, post_disagreed).reviewable.perform(moderator, :disagree)

        expect(user.number_of_flags_given).to eq(2)
      end
    end

    describe "number_of_deleted_posts" do
      it "counts all the posts" do
        # at least 1 "unchanged" post
        Fabricate(:post, user: user)

        post_deleted_by_moderator = Fabricate(:post, user: user)
        PostDestroyer.new(moderator, post_deleted_by_moderator).destroy

        post_deleted_by_user = Fabricate(:post, user: user, post_number: 2)
        PostDestroyer.new(user, post_deleted_by_user).destroy

        # fake stub deletion
        post_deleted_by_user.update_columns(updated_at: 2.days.ago)
        PostDestroyer.destroy_stubs

        expect(user.number_of_deleted_posts).to eq(2)
      end
    end

    describe '#number_of_rejected_posts' do
      it 'counts rejected posts' do
        Fabricate(:reviewable_queued_post, created_by: user, status: Reviewable.statuses[:rejected])

        expect(user.number_of_rejected_posts).to eq(1)
      end

      it 'ignore non-rejected posts' do
        Fabricate(:reviewable_queued_post, created_by: user, status: Reviewable.statuses[:approved])

        expect(user.number_of_rejected_posts).to eq(0)
      end
    end

    describe '#number_of_flagged_posts' do
      it 'counts flagged posts from the user' do
        Fabricate(:reviewable_flagged_post, target_created_by: user)

        expect(user.number_of_flagged_posts).to eq(1)
      end

      it 'ignores flagged posts from another user' do
        Fabricate(:reviewable_flagged_post, target_created_by: Fabricate(:user))

        expect(user.number_of_flagged_posts).to eq(0)
      end
    end
  end

  describe "new_user?" do
    it "correctly detects new user" do
      user = User.new(created_at: Time.now, trust_level: TrustLevel[0])

      expect(user.new_user?).to eq(true)

      user.trust_level = TrustLevel[1]

      expect(user.new_user?).to eq(true)

      user.trust_level = TrustLevel[2]

      expect(user.new_user?).to eq(false)

      user.trust_level = TrustLevel[0]
      user.moderator = true

      expect(user.new_user?).to eq(false)
    end
  end

  context "when user preferences are overridden" do

    fab!(:category0) { Fabricate(:category) }
    fab!(:category1) { Fabricate(:category) }
    fab!(:category2) { Fabricate(:category) }
    fab!(:category3) { Fabricate(:category) }
    fab!(:category4) { Fabricate(:category) }

    before do
      SiteSetting.default_email_digest_frequency = 1440 # daily
      SiteSetting.default_email_level = UserOption.email_level_types[:never]
      SiteSetting.default_email_messages_level = UserOption.email_level_types[:never]
      SiteSetting.disable_mailing_list_mode = false
      SiteSetting.default_email_mailing_list_mode = true

      SiteSetting.default_other_new_topic_duration_minutes = -1 # not viewed
      SiteSetting.default_other_auto_track_topics_after_msecs = 0 # immediately
      SiteSetting.default_other_notification_level_when_replying = 3 # immediately
      SiteSetting.default_other_external_links_in_new_tab = true
      SiteSetting.default_other_enable_quoting = false
      SiteSetting.default_other_dynamic_favicon = true
      SiteSetting.default_other_skip_new_user_tips = true

      SiteSetting.default_hide_profile_and_presence = true
      SiteSetting.default_topics_automatic_unpin = false

      SiteSetting.default_categories_watching = category0.id.to_s
      SiteSetting.default_categories_tracking = category1.id.to_s
      SiteSetting.default_categories_muted = category2.id.to_s
      SiteSetting.default_categories_watching_first_post = category3.id.to_s
      SiteSetting.default_categories_normal = category4.id.to_s
    end

    it "has overridden preferences" do
      user = Fabricate(:user)
      options = user.user_option
      expect(options.mailing_list_mode).to eq(true)
      expect(options.digest_after_minutes).to eq(1440)
      expect(options.email_level).to eq(UserOption.email_level_types[:never])
      expect(options.email_messages_level).to eq(UserOption.email_level_types[:never])
      expect(options.external_links_in_new_tab).to eq(true)
      expect(options.enable_quoting).to eq(false)
      expect(options.dynamic_favicon).to eq(true)
      expect(options.skip_new_user_tips).to eq(true)
      expect(options.hide_profile_and_presence).to eq(true)
      expect(options.automatically_unpin_topics).to eq(false)
      expect(options.new_topic_duration_minutes).to eq(-1)
      expect(options.auto_track_topics_after_msecs).to eq(0)
      expect(options.notification_level_when_replying).to eq(3)

      expect(CategoryUser.lookup(user, :watching).pluck(:category_id)).to eq([category0.id])
      expect(CategoryUser.lookup(user, :tracking).pluck(:category_id)).to eq([category1.id])
      expect(CategoryUser.lookup(user, :muted).pluck(:category_id)).to eq([category2.id])
      expect(CategoryUser.lookup(user, :watching_first_post).pluck(:category_id)).to eq([category3.id])
      expect(CategoryUser.lookup(user, :regular).pluck(:category_id)).to eq([category4.id])
    end

    it "does not set category preferences for staged users" do
      user = Fabricate(:user, staged: true)
      expect(CategoryUser.lookup(user, :watching).pluck(:category_id)).to eq([])
      expect(CategoryUser.lookup(user, :tracking).pluck(:category_id)).to eq([])
      expect(CategoryUser.lookup(user, :muted).pluck(:category_id)).to eq([])
      expect(CategoryUser.lookup(user, :watching_first_post).pluck(:category_id)).to eq([])
      expect(CategoryUser.lookup(user, :regular).pluck(:category_id)).to eq([])
    end
  end

  context UserOption do

    it "Creates a UserOption row when a user record is created and destroys once done" do
      user = Fabricate(:user)
      expect(user.user_option.email_level).to eq(UserOption.email_level_types[:only_when_away])

      user_id = user.id
      user.destroy!
      expect(UserOption.find_by(user_id: user_id)).to eq(nil)

    end

  end

  describe "#logged_out" do
    fab!(:user) { Fabricate(:user) }

    it 'should publish the right message' do
      message = MessageBus.track_publish('/logout') { user.logged_out }.first

      expect(message.data).to eq(user.id)
    end
  end

  describe '#read_first_notification?' do
    fab!(:user) { Fabricate(:user, trust_level: TrustLevel[0]) }
    fab!(:notification) { Fabricate(:private_message_notification) }

    describe 'when first notification has not been seen' do
      it 'should return the right value' do
        expect(user.read_first_notification?).to eq(false)
      end
    end

    describe 'when first notification has been seen' do
      it 'should return the right value' do
        user.update!(seen_notification_id: notification.id)
        expect(user.reload.read_first_notification?).to eq(true)
      end
    end

    describe 'when user is trust level 1' do
      it 'should return the right value' do
        user.update!(trust_level: TrustLevel[1])

        expect(user.read_first_notification?).to eq(false)
      end
    end

    describe 'when user is trust level 2' do
      it 'should return the right value' do
        user.update!(trust_level: TrustLevel[2])

        expect(user.read_first_notification?).to eq(true)
      end
    end

    describe 'when user is an old user' do
      it 'should return the right value' do
        user.update!(first_seen_at: 1.year.ago)

        expect(user.read_first_notification?).to eq(true)
      end
    end

    describe 'when user skipped new user tips' do
      it 'should return the right value' do
        user.user_option.update!(skip_new_user_tips: true)

        expect(user.read_first_notification?).to eq(true)
      end
    end
  end

  describe "#featured_user_badges" do
    fab!(:user) { Fabricate(:user) }
    let!(:user_badge_tl1) { UserBadge.create(badge_id: Badge::BasicUser, user: user, granted_by: Discourse.system_user, granted_at: Time.now) }
    let!(:user_badge_tl2) { UserBadge.create(badge_id: Badge::Member, user: user, granted_by: Discourse.system_user, granted_at: Time.now) }
    let!(:user_badge_like) { UserBadge.create(badge_id: Badge::FirstLike, user: user, granted_by: Discourse.system_user, granted_at: Time.now) }

    it 'should display badges in the correct order' do
      expect(user.featured_user_badges.map(&:badge_id)).to eq([Badge::Member, Badge::FirstLike, Badge::BasicUser])
    end
  end

  describe ".clear_global_notice_if_needed" do

    fab!(:user) { Fabricate(:user) }
    fab!(:admin) { Fabricate(:admin) }

    before do
      SiteSetting.has_login_hint = true
      SiteSetting.global_notice = "some notice"
    end

    it "doesn't clear the login hint when a regular user is saved" do
      user.save
      expect(SiteSetting.has_login_hint).to eq(true)
      expect(SiteSetting.global_notice).to eq("some notice")
    end

    it "doesn't clear the notice when a system user is saved" do
      Discourse.system_user.save
      expect(SiteSetting.has_login_hint).to eq(true)
      expect(SiteSetting.global_notice).to eq("some notice")
    end

    it "clears the notice when the admin is saved" do
      admin.save
      expect(SiteSetting.has_login_hint).to eq(false)
      expect(SiteSetting.global_notice).to eq("")
    end

  end

  describe '.human_users' do
    it 'should only return users with a positive primary key' do
      Fabricate(:bot)
      user = Fabricate(:user)

      expect(User.human_users).to eq([user])
    end
  end

  describe '.not_staged' do
    let!(:user0) { Fabricate(:user, staged: true) }
    let!(:user1) { Fabricate(:user) }

    it "doesn't return staged users" do
      expect(User.not_staged).to_not include(user0)
      expect(User.not_staged).to include(user1)
    end
  end

  describe '#publish_notifications_state' do
    it 'should publish the right message sorted by ID desc' do
      notification = Fabricate(:notification, user: user)
      notification2 = Fabricate(:notification, user: user, read: true)

      message = MessageBus.track_publish("/notification/#{user.id}") do
        user.publish_notifications_state
      end.first

      expect(message.data[:recent]).to eq([
        [notification2.id, true], [notification.id, false]
      ])
    end

    it 'floats the unread high priority notifications to the top' do
      notification = Fabricate(:notification, user: user)
      notification2 = Fabricate(:notification, user: user, read: true)
      notification3 = Fabricate(:notification, user: user, notification_type: Notification.types[:private_message])
      notification4 = Fabricate(:notification, user: user, notification_type: Notification.types[:bookmark_reminder])

      message = MessageBus.track_publish("/notification/#{user.id}") do
        user.publish_notifications_state
      end.first

      expect(message.data[:recent]).to eq([
        [notification4.id, false], [notification3.id, false],
        [notification2.id, true], [notification.id, false]
      ])
    end

    it "has the correct counts" do
      notification = Fabricate(:notification, user: user)
      notification2 = Fabricate(:notification, user: user, read: true)
      notification3 = Fabricate(:notification, user: user, notification_type: Notification.types[:private_message])
      notification4 = Fabricate(:notification, user: user, notification_type: Notification.types[:bookmark_reminder])

      message = MessageBus.track_publish("/notification/#{user.id}") do
        user.publish_notifications_state
      end.first

      expect(message.data[:unread_notifications]).to eq(1)
      # NOTE: because of deprecation this will be equal to unread_high_priority_notifications,
      #       to be removed in 2.5
      expect(message.data[:unread_private_messages]).to eq(2)
      expect(message.data[:unread_high_priority_notifications]).to eq(2)
    end

    it "does not publish to the /notification channel for users who have not been seen in > 30 days" do
      notification = Fabricate(:notification, user: user)
      notification2 = Fabricate(:notification, user: user, read: true)
      user.update(last_seen_at: 31.days.ago)

      message = MessageBus.track_publish("/notification/#{user.id}") do
        user.publish_notifications_state
      end.first

      expect(message).to eq(nil)
    end

    context "with redesigned_user_menu_enabled on" do
      before do
        SiteSetting.enable_experimental_sidebar_hamburger = true
      end

      it "adds all_unread_notifications and grouped_unread_notifications to the payload" do
        user.update!(admin: true)
        Fabricate(:notification, user: user, notification_type: 1)
        Fabricate(:notification, notification_type: 15, high_priority: true, read: false, user: user)

        messages = MessageBus.track_publish("/notification/#{user.id}") do
          user.publish_notifications_state
        end

        expect(messages.size).to eq(1)

        message = messages.first

        expect(message.data[:all_unread_notifications_count]).to eq(2)
        expect(message.data[:grouped_unread_notifications]).to eq({ 1 => 1, 15 => 1 })
      end
    end
  end

  describe "silenced?" do

    it "is not silenced by default" do
      expect(Fabricate(:user)).not_to be_silenced
    end

    it "is not silenced with a date in the past" do
      expect(Fabricate(:user, silenced_till: 1.month.ago)).not_to be_silenced
    end

    it "is is silenced with a date in the future" do
      expect(Fabricate(:user, silenced_till: 1.month.from_now)).to be_silenced
    end

    context "with finders" do
      let!(:user0) { Fabricate(:user, silenced_till: 1.month.ago) }
      let!(:user1) { Fabricate(:user, silenced_till: 1.month.from_now) }

      it "doesn't return old silenced records" do
        expect(User.silenced).to_not include(user0)
        expect(User.silenced).to include(user1)
        expect(User.not_silenced).to include(user0)
        expect(User.not_silenced).to_not include(user1)
      end
    end
  end

  describe "#unread_notifications" do
    fab!(:user) { Fabricate(:user) }
    before do
      User.max_unread_notifications = 3
    end

    after do
      User.max_unread_notifications = nil
    end

    it "limits to MAX_UNREAD_NOTIFICATIONS" do
      4.times do
        Notification.create!(user_id: user.id, notification_type: 1, read: false, data: '{}')
      end

      expect(user.unread_notifications).to eq(3)
    end

    it "does not include high priority notifications" do
      Notification.create!(user_id: user.id, notification_type: 1, read: false, data: '{}')
      Notification.create!(user_id: user.id, notification_type: Notification.types[:private_message], read: false, data: '{}')
      Notification.create!(user_id: user.id, notification_type: Notification.types[:bookmark_reminder], read: false, data: '{}')

      expect(user.unread_notifications).to eq(1)
    end
  end

  describe "#unread_high_priority_notifications" do
    fab!(:user) { Fabricate(:user) }

    it "only returns an unread count of PM and bookmark reminder notifications" do
      Notification.create!(user_id: user.id, notification_type: 1, read: false, data: '{}')
      Notification.create!(user_id: user.id, notification_type: Notification.types[:private_message], read: false, data: '{}')
      Notification.create!(user_id: user.id, notification_type: Notification.types[:bookmark_reminder], read: false, data: '{}')

      expect(user.unread_high_priority_notifications).to eq(2)
    end
  end

  describe "#unstage!" do
    let!(:user) { Fabricate(:staged, email: 'staged@account.com', active: true, username: 'staged1', name: 'Stage Name') }

    it "correctly unstages a user" do
      user.unstage!
      expect(user.staged).to eq(false)
    end

    it "removes all previous notifications during unstaging" do
      Fabricate(:notification, user: user)
      Fabricate(:private_message_notification, user: user)
      expect(user.total_unread_notifications).to eq(2)

      user.unstage!
      user.reload
      expect(user.total_unread_notifications).to eq(0)
      expect(user.staged).to eq(false)
    end

    it "triggers an event" do
      event = DiscourseEvent.track(:user_unstaged) { user.unstage! }
      expect(event).to be_present
      expect(event[:params].first).to eq(user)
    end
  end

  describe "#activate" do
    let!(:inactive) { Fabricate(:user, active: false) }

    it 'confirms email token and activates user' do
      inactive.activate
      inactive.reload
      expect(inactive.email_confirmed?).to eq(true)
      expect(inactive.active).to eq(true)
    end

    it 'works without needing to reload the model' do
      inactive.activate
      expect(inactive.email_confirmed?).to eq(true)
      expect(inactive.active).to eq(true)
    end

    it 'activates user even if email token is already confirmed' do
      token = inactive.email_tokens.find_by(email: inactive.email)
      token.update_column(:confirmed, true)
      inactive.activate
      expect(inactive.active).to eq(true)
    end
  end

  def filter_by(method)
    username = 'someuniqueusername'
    user.update!(username: username)

    username2 = 'awesomeusername'
    user2 = Fabricate(:user, username: username2)

    expect(User.public_send(method, username))
      .to eq([user])

    expect(User.public_send(method, 'UNiQuE'))
      .to eq([user])

    expect(User.public_send(method, [username, username2]))
      .to contain_exactly(user, user2)

    expect(User.public_send(method, ['UNiQuE', 'sOME']))
      .to contain_exactly(user, user2)
  end

  describe '#filter_by_username' do
    it 'should be able to filter by username' do
      filter_by(:filter_by_username)
    end
  end

  describe '#filter_by_username_or_email' do
    it 'should be able to filter by email' do
      email = 'veryspecialtest@discourse.org'
      user.update!(email: email)

      expect(User.filter_by_username_or_email(email))
        .to eq([user])

      expect(User.filter_by_username_or_email('veryspeCiaLtest'))
        .to eq([user])
    end

    it 'should be able to filter by username' do
      filter_by(:filter_by_username_or_email)
    end
  end

  describe "#secondary_emails" do
    fab!(:user) { Fabricate(:user) }

    it "only contains secondary emails" do
      expect(user.user_emails.secondary).to eq([])

      secondary_email = Fabricate(:secondary_email, user: user)

      expect(user.user_emails.secondary).to contain_exactly(secondary_email)
    end
  end

  describe "#email=" do
    let(:new_email) { "newprimary@example.com" }
    it 'sets the primary email' do
      user.update!(email: new_email)
      expect(User.find(user.id).email).to eq(new_email)
    end

    it 'only saves when save called' do
      old_email = user.email
      user.email = new_email
      expect(User.find(user.id).email).to eq(old_email)
      user.save!
      expect(User.find(user.id).email).to eq(new_email)
    end

    it 'will automatically remove matching secondary emails' do
      secondary_email_record = Fabricate(:secondary_email, user: user)
      user.reload
      expect(user.secondary_emails.count).to eq(1)
      user.email = secondary_email_record.email
      user.save!

      expect(User.find(user.id).email).to eq(secondary_email_record.email)
      expect(user.secondary_emails.count).to eq(0)
    end

  end

  describe "set_random_avatar" do
    it "sets a random avatar when selectable avatars is enabled" do
      avatar1 = Fabricate(:upload)
      avatar2 = Fabricate(:upload)
      SiteSetting.selectable_avatars = [avatar1, avatar2]
      SiteSetting.selectable_avatars_mode = "no_one"

      user = Fabricate(:user)
      expect(user.uploaded_avatar_id).not_to be(nil)
      expect([avatar1.id, avatar2.id]).to include(user.uploaded_avatar_id)
      expect(user.user_avatar.custom_upload_id).to eq(user.uploaded_avatar_id)
    end
  end

  describe "ensure_consistency!" do

    it "will clean up dangling avatars" do
      upload = Fabricate(:upload)
      user = Fabricate(:user, uploaded_avatar_id: upload.id)

      upload.destroy!
      user.reload
      expect(user.uploaded_avatar_id).to eq(nil)

      user.update_columns(uploaded_avatar_id: upload.id)

      User.ensure_consistency!

      user.reload
      expect(user.uploaded_avatar_id).to eq(nil)
    end

  end

  describe '#match_primary_group_changes' do
    let(:group_a) { Fabricate(:group, title: 'A', users: [user]) }
    let(:group_b) { Fabricate(:group, title: 'B', users: [user]) }

    it "updates user's title only when it is blank or matches the previous primary group" do
      expect { user.update(primary_group: group_a) }.to change { user.reload.title }.from(nil).to('A')
      expect { user.update(primary_group: group_b) }.to change { user.reload.title }.from('A').to('B')

      user.update(title: 'Different')
      expect { user.update(primary_group: group_a) }.to_not change { user.reload.title }
    end

    it "updates user's title only when it is blank or matches the previous primary group" do
      expect { user.update(primary_group: group_a) }.to change { user.reload.flair_group }.from(nil).to(group_a)
      expect { user.update(primary_group: group_b) }.to change { user.reload.flair_group }.from(group_a).to(group_b)

      user.update(flair_group: group_a)
      expect { user.update(primary_group: group_a) }.to_not change { user.reload.flair_group }
    end
  end

  describe '#title=' do
    fab!(:badge) { Fabricate(:badge, name: 'Badge', allow_title: false) }

    it 'sets badge_granted_title correctly' do
      BadgeGranter.grant(badge, user)

      user.update!(title: badge.name)
      expect(user.user_profile.reload.badge_granted_title).to eq(false)

      user.update!(title: 'Custom')
      expect(user.user_profile.reload.badge_granted_title).to eq(false)

      badge.update!(allow_title: true)
      user.badges.reload
      user.update!(title: badge.name)
      expect(user.user_profile.reload.badge_granted_title).to eq(true)
      expect(user.user_profile.reload.granted_title_badge_id).to eq(badge.id)

      user.update!(title: nil)
      expect(user.user_profile.reload.badge_granted_title).to eq(false)
      expect(user.user_profile.granted_title_badge_id).to eq(nil)
    end

    context 'when a custom badge name has been set and it matches the title' do
      let(:customized_badge_name) { 'Merit Badge' }

      before do
        TranslationOverride.upsert!(I18n.locale, Badge.i18n_key(badge.name), customized_badge_name)
      end

      it 'sets badge_granted_title correctly' do
        BadgeGranter.grant(badge, user)

        badge.update!(allow_title: true)
        user.update!(title: customized_badge_name)
        expect(user.user_profile.reload.badge_granted_title).to eq(true)
        expect(user.user_profile.reload.granted_title_badge_id).to eq(badge.id)
      end

      after do
        TranslationOverride.revert!(I18n.locale, Badge.i18n_key(badge.name))
      end
    end
  end

  describe '#next_best_title' do
    fab!(:group_a) { Fabricate(:group, title: 'Group A') }
    fab!(:group_b) { Fabricate(:group, title: 'Group B') }
    fab!(:group_c) { Fabricate(:group, title: 'Group C') }
    fab!(:badge) { Fabricate(:badge, name: 'Badge', allow_title: true) }

    it 'only includes groups with title' do
      group_a.add(user)
      expect(user.next_best_title).to eq('Group A')

      group_a.update!(title: nil)
      expect(user.next_best_title).to eq(nil)
    end

    it 'only includes badges that allow to be set as title' do
      BadgeGranter.grant(badge, user)
      expect(user.next_best_title).to eq('Badge')

      badge.update!(allow_title: false)
      expect(user.next_best_title).to eq(nil)
    end

    it "picks the next best title in the order: user's primary group, primary group, groups, and badges" do
      group_a.add(user)
      group_b.add(user)
      group_c.add(user)
      BadgeGranter.grant(badge, user)

      group_a.update!(primary_group: true)
      group_b.update!(primary_group: true)
      user.update!(primary_group_id: group_a.id)
      expect(user.next_best_title).to eq('Group A')

      user.update!(primary_group_id: group_b.id)
      expect(user.next_best_title).to eq('Group B')

      group_b.remove(user)
      expect(user.next_best_title).to eq('Group A')

      group_a.remove(user)
      expect(user.next_best_title).to eq('Group C')

      group_c.remove(user)
      expect(user.next_best_title).to eq('Badge')

      BadgeGranter.revoke(UserBadge.find_by(user_id: user.id, badge_id: badge.id))
      expect(user.next_best_title).to eq(nil)
    end
  end

  describe 'check_site_contact_username' do
    before { SiteSetting.site_contact_username = contact_user.username }

    context 'when admin' do
      let(:contact_user) { Fabricate(:admin) }

      it 'clears site_contact_username site setting when admin privilege is revoked' do
        contact_user.revoke_admin!
        expect(SiteSetting.site_contact_username).to eq(SiteSetting.defaults[:site_contact_username])
      end
    end

    context 'when moderator' do
      let(:contact_user) { Fabricate(:moderator) }

      it 'clears site_contact_username site setting when moderator privilege is revoked' do
        contact_user.revoke_moderation!
        expect(SiteSetting.site_contact_username).to eq(SiteSetting.defaults[:site_contact_username])
      end
    end

    context 'when admin and moderator' do
      let(:contact_user) { Fabricate(:moderator, admin: true) }

      it 'does not change site_contact_username site setting when admin privilege is revoked' do
        contact_user.revoke_admin!
        expect(SiteSetting.site_contact_username).to eq(contact_user.username)
      end

      it 'does not change site_contact_username site setting when moderator privilege is revoked' do
        contact_user.revoke_moderation!
        expect(SiteSetting.site_contact_username).to eq(contact_user.username)
      end

      it 'clears site_contact_username site setting when staff privileges are revoked' do
        contact_user.revoke_admin!
        contact_user.revoke_moderation!
        expect(SiteSetting.site_contact_username).to eq(SiteSetting.defaults[:site_contact_username])
      end
    end
  end

  describe "#destroy!" do
    it 'clears up associated data on destroy!' do
      user = Fabricate(:user)
      post = Fabricate(:post)

      PostActionCreator.like(user, post)
      PostActionDestroyer.destroy(user, post, :like)

      UserAction.create!(user_id: user.id, action_type: UserAction::LIKE)
      UserAction.create!(user_id: -1, action_type: UserAction::LIKE, target_user_id: user.id)
      UserAction.create!(user_id: -1, action_type: UserAction::LIKE, acting_user_id: user.id)
      Developer.create!(user_id: user.id)

      user.reload

      user.destroy!

      expect(UserAction.where(user_id: user.id).length).to eq(0)
      expect(UserAction.where(target_user_id: user.id).length).to eq(0)
      expect(UserAction.where(acting_user_id: user.id).length).to eq(0)
      expect(PostAction.with_deleted.where(user_id: user.id).length).to eq(0)
      expect(Developer.where(user_id: user.id).length).to eq(0)
    end
  end

  describe "#human?" do
    it "returns true for a regular user" do
      expect(Fabricate(:user)).to be_human
    end

    it "returns false for the system user" do
      expect(Discourse.system_user).not_to be_human
    end
  end

  describe "Unicode username" do
    before { SiteSetting.unicode_usernames = true }

    let(:user) { Fabricate(:user, username: "Lo\u0308we") } # NFD

    it "normalizes usernames" do
      expect(user.username).to eq("L\u00F6we") # NFC
      expect(user.username_lower).to eq("l\u00F6we") # NFC
    end

    describe ".username_exists?" do
      it "normalizes username before executing query" do
        expect(User.username_exists?(user.username)).to eq(true)
        expect(User.username_exists?("Lo\u0308we")).to eq(true) # NFD
        expect(User.username_exists?("L\u00F6we")).to eq(true)  # NFC
        expect(User.username_exists?("LO\u0308WE")).to eq(true) # NFD
        expect(User.username_exists?("l\u00D6wE")).to eq(true)  # NFC
        expect(User.username_exists?("foo")).to eq(false)
      end
    end

    describe ".system_avatar_template" do
      context "with external system avatars enabled" do
        before { SiteSetting.external_system_avatars_enabled = true }

        it "uses the normalized username" do
          expect(User.system_avatar_template("Lo\u0308we")).to match(%r|/letter_avatar_proxy/v\d/letter/l/71e660/{size}.png|)
          expect(User.system_avatar_template("L\u00F6wE")).to match(%r|/letter_avatar_proxy/v\d/letter/l/71e660/{size}.png|)
        end

        it "uses the first grapheme cluster and URL encodes it" do
          expect(User.system_avatar_template("बहुत")).to match(%r|/letter_avatar_proxy/v\d/letter/%E0%A4%AC/ea5d25/{size}.png|)
        end

        it "substitutes {username} with the URL encoded username" do
          SiteSetting.external_system_avatars_url = "https://{hostname}/{username}.png"
          expect(User.system_avatar_template("बहुत")).to eq("https://#{Discourse.current_hostname}/%E0%A4%AC%E0%A4%B9%E0%A5%81%E0%A4%A4.png")
        end
      end
    end
  end

  describe "Second-factor authenticators" do
    describe "#totps" do
      it "only includes enabled totp 2FA" do
        enabled_totp_2fa = Fabricate(:user_second_factor_totp, user: user, name: 'Enabled TOTP', enabled: true)
        disabled_totp_2fa = Fabricate(:user_second_factor_totp, user: user, name: 'Disabled TOTP', enabled: false)

        expect(user.totps.map(&:id)).to eq([enabled_totp_2fa.id])
      end
    end

    describe "#security_keys" do
      it "only includes enabled security_key 2FA" do
        enabled_security_key_2fa = Fabricate(:user_security_key_with_random_credential, user: user, name: 'Enabled YubiKey', enabled: true)
        disabled_security_key_2fa = Fabricate(:user_security_key_with_random_credential, user: user, name: 'Disabled YubiKey', enabled: false)

        expect(user.security_keys.map(&:id)).to eq([enabled_security_key_2fa.id])
      end
    end
  end

  describe 'Secure identifier for a user which is a string other than the ID used to identify the user in some cases e.g. security keys' do
    describe '#create_or_fetch_secure_identifier' do
      context 'if the user already has a secure identifier' do
        let(:sec_ident) { SecureRandom.hex(20) }
        before do
          user.update(secure_identifier: sec_ident)
        end

        it 'returns the identifier' do
          expect(user.create_or_fetch_secure_identifier).to eq(sec_ident)
        end
      end

      context 'if the user already does not have a secure identifier' do
        it 'creates one' do
          expect(user.secure_identifier).to eq(nil)
          user.create_or_fetch_secure_identifier
          expect(user.reload.secure_identifier).not_to eq(nil)
        end
      end
    end
  end

  describe 'Granting admin or moderator status' do
    context 'when granting admin status' do
      context 'when there is a reviewable' do
        fab!(:user) { Fabricate(:reviewable_user) }

        context 'when the user isn’t approved yet' do
          it 'approves the associated reviewable' do
            expect { user.target.grant_admin! }.to change { user.reload.dup }.to be_approved
          end
        end

        context "when the user is already approved" do
          before do
            user.perform(Discourse.system_user, :approve_user)
          end

          it 'does nothing' do
            expect { user.target.grant_admin! }.not_to change { user.reload.approved? }
          end
        end
      end

      context 'when there is no reviewable' do
        let(:user) { Fabricate(:user, approved: false) }

        it 'approves the user' do
          expect { user.grant_admin! }.to change { user.reload.approved }.to true
        end
      end
    end

    context 'when granting moderator status' do
      context 'when there is a reviewable' do
        let(:user) { Fabricate(:reviewable_user) }

        it 'approves the associated reviewable' do
          expect { user.target.grant_moderation! }.to change { user.reload.dup }.to be_approved
        end
      end
    end
  end

  describe "#recent_time_read" do
    fab!(:user) { Fabricate(:user) }
    fab!(:user2) { Fabricate(:user) }

    before_all do
      UserVisit.create(user_id: user.id, visited_at: 1.minute.ago, posts_read: 1, mobile: false, time_read: 10)
      UserVisit.create(user_id: user.id, visited_at: 2.days.ago, posts_read: 1, mobile: false, time_read: 20)
      UserVisit.create(user_id: user.id, visited_at: 1.week.ago, posts_read: 1, mobile: false, time_read: 30)
      UserVisit.create(user_id: user.id, visited_at: 1.year.ago, posts_read: 1, mobile: false, time_read: 40) # Old, should be ignored
      UserVisit.create(user_id: user2.id, visited_at: 1.minute.ago, posts_read: 1, mobile: false, time_read: 50)
    end

    it "calculates correctly" do
      expect(user.recent_time_read).to eq(60)
      expect(user2.recent_time_read).to eq(50)
    end

    it "preloads correctly" do
      User.preload_recent_time_read([user, user2])

      expect(user.instance_variable_get(:@recent_time_read)).to eq(60)
      expect(user2.instance_variable_get(:@recent_time_read)).to eq(50)

      expect(user.recent_time_read).to eq(60)
      expect(user2.recent_time_read).to eq(50)
    end
  end

  def reset_last_seen_cache!(user)
    Discourse.redis.del("user:#{user.id}:#{Time.zone.now.to_date}")
  end

  describe ".encoded_username" do
    it "doesn't encoded ASCII usernames" do
      user = Fabricate(:user, username: "John")
      expect(user.encoded_username).to eq("John")
      expect(user.encoded_username(lower: true)).to eq("john")
    end

    it "encodes Unicode characters" do
      SiteSetting.unicode_usernames = true
      user = Fabricate(:user, username: "Löwe")
      expect(user.encoded_username).to eq("L%C3%B6we")
      expect(user.encoded_username(lower: true)).to eq("l%C3%B6we")
    end
  end

  describe '#update_ip_address!' do
    it 'updates ip_address correctly' do
      expect do
        user.update_ip_address!('127.0.0.1')
      end.to change { user.reload.ip_address.to_s }.to('127.0.0.1')

      expect do
        user.update_ip_address!('127.0.0.1')
      end.to_not change { user.reload.ip_address }
    end

    describe 'keeping old ip address' do
      before do
        SiteSetting.keep_old_ip_address_count = 2
      end

      it 'tracks old user record correctly' do
        expect do
          user.update_ip_address!('127.0.0.1')
        end.to change { UserIpAddressHistory.where(user_id: user.id).count }.by(1)

        freeze_time 10.minutes.from_now

        expect do
          user.update_ip_address!('0.0.0.0')
        end.to change { UserIpAddressHistory.where(user_id: user.id).count }.by(1)

        freeze_time 11.minutes.from_now

        expect do
          user.update_ip_address!('127.0.0.1')
        end.to_not change { UserIpAddressHistory.where(user_id: user.id).count }

        expect(UserIpAddressHistory.find_by(
          user_id: user.id, ip_address: '127.0.0.1'
        ).updated_at).to eq_time(Time.zone.now)

        freeze_time 12.minutes.from_now

        expect do
          user.update_ip_address!('0.0.0.1')
        end.not_to change { UserIpAddressHistory.where(user_id: user.id).count }

        expect(
          UserIpAddressHistory.where(user_id: user.id).pluck(:ip_address).map(&:to_s)
        ).to eq(['127.0.0.1', '0.0.0.1'])
      end
    end
  end

  describe "#do_not_disturb?" do
    it "is true when a dnd timing is present for the current time" do
      Fabricate(:do_not_disturb_timing, user: user, starts_at: Time.zone.now, ends_at: 1.day.from_now)
      expect(user.do_not_disturb?).to eq(true)
    end

    it "is false when no dnd timing is present for the current time" do
      Fabricate(:do_not_disturb_timing, user: user, starts_at: Time.zone.now - 2.day, ends_at: 1.minute.ago)
      expect(user.do_not_disturb?).to eq(false)
    end
  end

  describe "#invited_by" do
    it 'returns even if invites was trashed' do
      invite = Fabricate(:invite, invited_by: Fabricate(:user))
      Fabricate(:invited_user, invite: invite, user: user)
      invite.trash!

      expect(user.invited_by).to eq(invite.invited_by)
    end
  end

  describe "#username_equals_to?" do
    [
      ["returns true for equal usernames", "john", "john", true],
      ["returns false for different usernames", "john", "bill", false],
      ["considers usernames that are different only in case as equal", "john", "JoHN", true]
    ].each do |testcase_name, current_username, another_username, is_equal|
      it "#{testcase_name}" do
        user = Fabricate(:user, username: current_username)
        result = user.username_equals_to?(another_username)

        expect(result).to be(is_equal)
      end
    end

    it "considers usernames that are equal after unicode normalization as equal" do
      SiteSetting.unicode_usernames = true

      raw = "Lo\u0308we" # Löwe, u0308 stands for ¨, so o\u0308 adds up to ö
      normalized = "l\u00F6we" # Löwe normilized, \u00F6 stands for ö
      user = Fabricate(:user, username: normalized)
      result = user.username_equals_to?(raw)

      expect(result).to be(true)
    end
  end

  describe "#whisperer?" do
    before do
      SiteSetting.enable_whispers = true
    end

    it 'returns true for an admin user' do
      admin = Fabricate.create(:admin)
      expect(admin.whisperer?).to eq(true)
    end

    it 'returns false for an admin user when whispers are not enabled' do
      SiteSetting.enable_whispers = false

      admin = Fabricate.create(:admin)
      expect(admin.whisperer?).to eq(false)
    end

    it 'returns true for user belonging to whisperers groups' do
      group = Fabricate(:group)
      whisperer = Fabricate(:user)
      user = Fabricate(:user)
      SiteSetting.whispers_allowed_groups = "#{group.id}"

      expect(whisperer.whisperer?).to eq(false)
      expect(user.whisperer?).to eq(false)

      group.add(whisperer)

      expect(whisperer.whisperer?).to eq(true)
      expect(user.whisperer?).to eq(false)
    end
  end

  describe "#grouped_unread_notifications" do
    it "returns a map of types to their unread count" do
      Fabricate(:notification, user: user, notification_type: 1, high_priority: true, read: true)
      Fabricate(:notification, user: user, notification_type: 1, high_priority: true, read: false)
      Fabricate(:notification, user: user, notification_type: 1, high_priority: false, read: true)
      Fabricate(:notification, user: user, notification_type: 1, high_priority: false, read: false)

      Fabricate(:notification, user: user, notification_type: 2, high_priority: true, read: false, topic: nil)

      Fabricate(:notification, user: user, notification_type: 3, high_priority: true, read: false).tap do |n|
        n.topic.trash!(Fabricate(:admin))
      end

      Fabricate(:notification, user: user, notification_type: 3, high_priority: false, read: true)

      # notification for another user. it shouldn't be included
      Fabricate(:notification, notification_type: 4, high_priority: true, read: false)

      expect(user.grouped_unread_notifications).to eq({ 1 => 2, 2 => 1 })
    end
  end

  describe "#all_unread_notifications_count" do
    it "returns count of unseen and unread high priority and normal priority notifications" do
      Fabricate(:notification, user: user, high_priority: true, read: false)
      n2 = Fabricate(:notification, user: user, high_priority: false, read: false)
      expect(user.all_unread_notifications_count).to eq(2)

      n2.update!(read: true)
      user.reload

      expect(user.all_unread_notifications_count).to eq(1)

      user.update!(seen_notification_id: n2.id)
      user.reload

      expect(user.all_unread_notifications_count).to eq(0)

      n3 = Fabricate(:notification, user: user)
      user.reload

      expect(user.all_unread_notifications_count).to eq(1)

      n3.topic.trash!(Fabricate(:admin))
      user.reload

      expect(user.all_unread_notifications_count).to eq(0)
    end
  end

  describe "#unseen_reviewable_count" do
    fab!(:admin_reviewable) { Fabricate(:reviewable, reviewable_by_moderator: false) }
    fab!(:mod_reviewable) { Fabricate(:reviewable, reviewable_by_moderator: true) }
    fab!(:group_reviewable) { Fabricate(:reviewable, reviewable_by_moderator: false, reviewable_by_group: group) }

    it "doesn't include reviewables that can't be seen by the user" do
      SiteSetting.enable_category_group_moderation = true
      expect(user.unseen_reviewable_count).to eq(0)
      user.groups << group
      user.save!
      expect(user.unseen_reviewable_count).to eq(1)
      user.update!(moderator: true)
      expect(user.unseen_reviewable_count).to eq(2)
      user.update!(admin: true)
      expect(user.unseen_reviewable_count).to eq(3)
    end

    it "returns count of unseen reviewables" do
      user.update!(admin: true)
      expect(user.unseen_reviewable_count).to eq(3)
      user.update!(last_seen_reviewable_id: mod_reviewable.id)
      expect(user.unseen_reviewable_count).to eq(1)
      user.update!(last_seen_reviewable_id: group_reviewable.id)
      expect(user.unseen_reviewable_count).to eq(0)
    end
  end

  describe "#bump_last_seen_reviewable!" do
    it "doesn't error if there are no reviewables" do
      Reviewable.destroy_all
      user.bump_last_seen_reviewable!
      expect(user.last_seen_reviewable_id).to eq(nil)
    end

    it "picks the reviewable of the largest id" do
      user.update!(admin: true)
      Fabricate(
        :reviewable,
        created_at: 3.minutes.ago,
        updated_at: 3.minutes.ago,
        score: 100
      )
      reviewable2 = Fabricate(
        :reviewable,
        created_at: 30.minutes.ago,
        updated_at: 30.minutes.ago,
        score: 10
      )
      user.bump_last_seen_reviewable!
      expect(user.last_seen_reviewable_id).to eq(reviewable2.id)
    end

    it "stays at the maximum reviewable if there are no new reviewables" do
      user.update!(admin: true)
      reviewable = Fabricate(:reviewable)
      user.bump_last_seen_reviewable!
      expect(user.last_seen_reviewable_id).to eq(reviewable.id)
      user.bump_last_seen_reviewable!
      expect(user.last_seen_reviewable_id).to eq(reviewable.id)
    end

    it "respects reviewables security" do
      admin = Fabricate(:admin)
      moderator = Fabricate(:moderator)
      group = Fabricate(:group)
      user.update!(groups: [group])
      SiteSetting.enable_category_group_moderation = true

      group_reviewable = Fabricate(:reviewable, reviewable_by_moderator: false, reviewable_by_group: group)
      mod_reviewable = Fabricate(:reviewable, reviewable_by_moderator: true)
      admin_reviewable = Fabricate(:reviewable, reviewable_by_moderator: false)

      [admin, moderator, user].each(&:bump_last_seen_reviewable!)

      expect(admin.last_seen_reviewable_id).to eq(admin_reviewable.id)
      expect(moderator.last_seen_reviewable_id).to eq(mod_reviewable.id)
      expect(user.last_seen_reviewable_id).to eq(group_reviewable.id)
    end

    it "publishes a message to the user's /reviewable_counts message bus channel" do
      user.update!(admin: true)
      Fabricate(:reviewable)
      messages = MessageBus.track_publish do
        user.bump_last_seen_reviewable!
      end
      expect(messages.size).to eq(1)
      expect(messages.first).to have_attributes(
        channel: "/reviewable_counts/#{user.id}",
        user_ids: [user.id],
        data: { unseen_reviewable_count: 0 }
      )
    end
  end

  describe "#bump_last_seen_notification!" do
    it "doesn't error if there are no notifications" do
      Notification.destroy_all
      expect(user.bump_last_seen_notification!).to eq(false)
      expect(user.reload.seen_notification_id).to eq(0)
    end

    it "updates seen_notification_id to the last notification that the user can see" do
      last_notification = Fabricate(:notification, user: user)
      deleted_notification = Fabricate(:notification, user: user)
      deleted_notification.topic.trash!
      someone_else_notification = Fabricate(:notification, user: Fabricate(:user))

      expect(user.bump_last_seen_notification!).to eq(true)
      expect(user.reload.seen_notification_id).to eq(last_notification.id)
    end
  end

  describe '#visible_sidebar_tags' do
    fab!(:user) { Fabricate(:user) }
    fab!(:tag) { Fabricate(:tag) }
    fab!(:hidden_tag) { Fabricate(:tag, name: "secret") }
    fab!(:staff_tag_group) { Fabricate(:tag_group, permissions: { "staff" => 1 }, tag_names: ["secret"]) }
    fab!(:tag_sidebar_section_link) { Fabricate(:tag_sidebar_section_link, user: user, linkable: tag) }
    fab!(:tag_sidebar_section_link_2) { Fabricate(:tag_sidebar_section_link, user: user, linkable: hidden_tag) }

    it 'should only return tag sidebar section link records of tags that the user is allowed to see' do
      expect(user.visible_sidebar_tags).to contain_exactly(tag)

      user.update!(admin: true)

      expect(user.visible_sidebar_tags).to contain_exactly(tag, hidden_tag)
    end
  end

  describe '#secure_category_ids' do
    fab!(:admin) { Fabricate(:admin) }
    fab!(:group) { Fabricate(:group) }
    fab!(:private_category) { Fabricate(:private_category, group: group) }

    it 'allows admin to see all secure categories' do
      expect(admin.secure_category_ids).to include(private_category.id)
    end

    context 'when SiteSetting.suppress_secured_categories_from_admin is true' do
      it 'hides secure categories from admins' do
        SiteSetting.suppress_secured_categories_from_admin = true
        expect(admin.secure_category_ids).not_to include(private_category.id)
      end
    end

  end
end