require "rails_helper"

describe User do
  describe "#headings_voted_within_group" do
    it "returns the headings voted by a user" do
      budget = create(:budget)
      group = create(:budget_group, budget: budget)

      new_york = create(:budget_heading, group: group, name: "New york")
      san_francisco = create(:budget_heading, group: group, name: "San Franciso")
      wyoming = create(:budget_heading, group: group, name: "Wyoming")
      another_heading = create(:budget_heading, group: group)

      new_york_investment = create(:budget_investment, heading: new_york)
      san_franciso_investment = create(:budget_investment, heading: san_francisco)
      wyoming_investment = create(:budget_investment, heading: wyoming)

      user1 = create(:user, votables: [wyoming_investment, san_franciso_investment, new_york_investment])
      user2 = create(:user)

      expect(user1.headings_voted_within_group(group)).to match_array [new_york, san_francisco, wyoming]
      expect(user1.headings_voted_within_group(group)).not_to include(another_heading)

      expect(user2.headings_voted_within_group(group)).to be_empty
    end

    it "returns headings with multiple translations only once" do
      group = create(:budget_group)
      heading = create(:budget_heading, group: group, name_en: "English", name_es: "Spanish")
      user = create(:user, votables: [create(:budget_investment, heading: heading)])

      expect(user.headings_voted_within_group(group).count).to eq 1
    end
  end

  describe "#comment_flags" do
    let(:user) { create(:user) }

    it "returns {} if no comment" do
      expect(user.comment_flags([])).to eq({})
    end

    it "returns a hash of flaggable_ids with 'true' if they were flagged by the user" do
      comment1 = create(:comment)
      comment2 = create(:comment)
      comment3 = create(:comment)
      Flag.flag(user, comment1)
      Flag.flag(user, comment3)

      flagged = user.comment_flags([comment1, comment2, comment3])

      expect(flagged[comment1.id]).to be
      expect(flagged[comment2.id]).not_to be
      expect(flagged[comment3.id]).to be
    end
  end

  subject { build(:user) }

  it "is valid" do
    expect(subject).to be_valid
  end

  describe "#terms" do
    it "is not valid without accepting the terms of service" do
      subject.terms_of_service = nil
      expect(subject).not_to be_valid
    end
  end

  describe "#name" do
    it "is the username when the user is not an organization" do
      expect(subject.name).to eq(subject.username)
    end
  end

  describe "#age" do
    it "is the rounded integer age based on the date_of_birth" do
      user = create(:user, date_of_birth: 33.years.ago)
      expect(user.age).to eq(33)
    end
  end

  describe "#locale" do
    it "defaults to the default locale setting" do
      Setting["locales.default"] = "nl"

      user = build(:user, locale: nil)

      expect(user.locale).to eq "nl"
    end
  end

  describe "preferences" do
    describe "email_on_comment" do
      it "is false by default" do
        expect(subject.email_on_comment).to be false
      end
    end

    describe "email_on_comment_reply" do
      it "is false by default" do
        expect(subject.email_on_comment_reply).to be false
      end
    end

    describe "subscription_to_website_newsletter" do
      it "is true by default" do
        expect(subject.newsletter).to be true
      end
    end

    describe "email_digest" do
      it "is true by default" do
        expect(subject.email_digest).to be true
      end
    end

    describe "email_on_direct_message" do
      it "is true by default" do
        expect(subject.email_on_direct_message).to be true
      end
    end

    describe "official_position_badge" do
      it "is false by default" do
        expect(subject.official_position_badge).to be false
      end
    end
  end

  describe "administrator?" do
    it "is false when the user is not an admin" do
      expect(subject.administrator?).to be false
    end

    it "is true when the user is an admin" do
      subject.save!
      create(:administrator, user: subject)
      expect(subject.administrator?).to be true
    end
  end

  describe "moderator?" do
    it "is false when the user is not a moderator" do
      expect(subject.moderator?).to be false
    end

    it "is true when the user is a moderator" do
      subject.save!
      create(:moderator, user: subject)
      expect(subject.moderator?).to be true
    end
  end

  describe "valuator?" do
    it "is false when the user is not a valuator" do
      expect(subject.valuator?).to be false
    end

    it "is true when the user is a valuator" do
      subject.save!
      create(:valuator, user: subject)
      expect(subject.valuator?).to be true
    end
  end

  describe "manager?" do
    it "is false when the user is not a manager" do
      expect(subject.manager?).to be false
    end

    it "is true when the user is a manager" do
      subject.save!
      create(:manager, user: subject)
      expect(subject.manager?).to be true
    end
  end

  describe "sdg_manager?" do
    it "is false when the user is not a sdg manager" do
      expect(subject.sdg_manager?).to be false
    end

    it "is true when the user is a sdg manager" do
      subject.save!
      create(:sdg_manager, user: subject)
      expect(subject.sdg_manager?).to be true
    end
  end

  describe "poll_officer?" do
    it "is false when the user is not a poll officer" do
      expect(subject.poll_officer?).to be false
    end

    it "is true when the user is a poll officer" do
      subject.save!
      create(:poll_officer, user: subject)
      expect(subject.poll_officer?).to be true
    end
  end

  describe "organization?" do
    it "is false when the user is not an organization" do
      expect(subject.organization?).to be false
    end

    describe "when it is an organization" do
      before { create(:organization, user: subject) }

      it "is true when the user is an organization" do
        expect(subject.organization?).to be true
      end

      it "calculates the name using the organization name" do
        expect(subject.name).to eq(subject.organization.name)
      end
    end
  end

  describe "verified_organization?" do
    it "is falsy when the user is not an organization" do
      expect(subject).not_to be_verified_organization
    end

    describe "when it is an organization" do
      before { create(:organization, user: subject) }

      it "is false when the user is not a verified organization" do
        expect(subject).not_to be_verified_organization
      end

      it "is true when the user is a verified organization" do
        subject.organization.verify
        expect(subject).to be_verified_organization
      end
    end
  end

  describe "organization_attributes" do
    before { subject.organization_attributes = { name: "org", responsible_name: "julia" } }

    it "triggers the creation of an associated organization" do
      expect(subject.organization).to be
      expect(subject.organization.name).to eq("org")
      expect(subject.organization.responsible_name).to eq("julia")
    end

    it "deactivates the validation of username, and activates the validation of organization" do
      subject.username = nil
      expect(subject).to be_valid

      subject.organization.name = nil
      expect(subject).not_to be_valid
    end
  end

  describe "official?" do
    it "is false when the user is not an official" do
      expect(subject.official_level).to eq(0)
      expect(subject.official?).to be false
    end

    it "is true when the user is an official" do
      subject.official_level = 3
      subject.save!
      expect(subject.official?).to be true
    end
  end

  describe "add_official_position!" do
    it "raises an exception when level not valid" do
      expect { subject.add_official_position!("Boss", 89) }.to raise_error ActiveRecord::RecordInvalid
    end

    it "updates official position fields" do
      expect(subject).not_to be_official
      subject.add_official_position!("Veterinarian", 2)

      expect(subject).to be_official
      expect(subject.official_position).to eq("Veterinarian")
      expect(subject.official_level).to eq(2)

      subject.add_official_position!("Brain surgeon", 3)
      expect(subject.official_position).to eq("Brain surgeon")
      expect(subject.official_level).to eq(3)
    end
  end

  describe "remove_official_position!" do
    it "updates official position fields" do
      subject.add_official_position!("Brain surgeon", 3)
      expect(subject).to be_official

      subject.remove_official_position!

      expect(subject).not_to be_official
      expect(subject.official_position).to be nil
      expect(subject.official_level).to eq(0)
    end
  end

  describe "officials scope" do
    it "returns only users with official positions" do
      create(:user, official_position: "Mayor", official_level: 1)
      create(:user, official_position: "Director", official_level: 3)
      create(:user, official_position: "Math Teacher", official_level: 4)
      create(:user, official_position: "Manager", official_level: 5)
      2.times { create(:user) }

      officials = User.officials
      expect(officials.size).to eq(4)
      officials.each do |user|
        expect(user.official_level).to be > 0
        expect(user.official_position).to be_present
      end
    end
  end

  describe "has_official_email" do
    it "checks if the mail address has the officials domain" do
      # We will use empleados.madrid.es as the officials' domain
      # Subdomains are also accepted

      Setting["email_domain_for_officials"] = "officials.madrid.es"
      user1 = create(:user, email: "john@officials.madrid.es", confirmed_at: Time.current)
      user2 = create(:user, email: "john@yes.officials.madrid.es", confirmed_at: Time.current)
      user3 = create(:user, email: "john@unofficials.madrid.es", confirmed_at: Time.current)
      user4 = create(:user, email: "john@example.org", confirmed_at: Time.current)

      expect(user1.has_official_email?).to be true
      expect(user2.has_official_email?).to be true
      expect(user3.has_official_email?).to be false
      expect(user4.has_official_email?).to be false

      # We reset the officials' domain setting
      Setting.find_by(key: "email_domain_for_officials").update!(value: "")
    end
  end

  describe "official_position_badge" do
    describe "Users of level 1" do
      it "displays the badge if set in preferences" do
        user = create(:user, official_level: 1, official_position_badge: true)

        expect(user.display_official_position_badge?).to be true
      end

      it "does not display the badge if set in preferences" do
        user = create(:user, official_level: 1, official_position_badge: false)

        expect(user.display_official_position_badge?).to be false
      end
    end

    describe "Users higher than level 1" do
      it "displays the badge regardless of preferences" do
        user1 = create(:user, official_level: 2, official_position_badge: false)
        user2 = create(:user, official_level: 3, official_position_badge: false)
        user3 = create(:user, official_level: 4, official_position_badge: false)
        user4 = create(:user, official_level: 5, official_position_badge: false)

        expect(user1.display_official_position_badge?).to be true
        expect(user2.display_official_position_badge?).to be true
        expect(user3.display_official_position_badge?).to be true
        expect(user4.display_official_position_badge?).to be true
      end
    end
  end

  describe "scopes" do
    describe "active" do
      it "returns users that have not been erased" do
        user1 = create(:user, erased_at: nil)
        user2 = create(:user, erased_at: nil)
        user3 = create(:user, erased_at: Time.current)

        expect(User.active).to match_array [user1, user2]
        expect(User.active).not_to include(user3)
      end

      it "returns users that have not been blocked" do
        user1 = create(:user)
        user2 = create(:user)
        user3 = create(:user)
        user3.block

        expect(User.active).to match_array [user1, user2]
        expect(User.active).not_to include(user3)
      end
    end

    describe "erased" do
      it "returns users that have been erased" do
        user1 = create(:user, erased_at: Time.current)
        user2 = create(:user, erased_at: Time.current)
        user3 = create(:user, erased_at: nil)

        expect(User.erased).to match_array [user1, user2]
        expect(User.erased).not_to include(user3)
      end
    end

    describe ".by_username_email_or_document_number" do
      let!(:larry) do
        create(:user, email: "larry@consul.dev", username: "Larry Bird", document_number: "12345678Z")
      end

      before { create(:user, email: "robert@consul.dev", username: "Robert Parish") }

      it "finds users by email" do
        expect(User.by_username_email_or_document_number("larry@consul.dev")).to eq [larry]
      end

      it "finds users by email with whitespaces" do
        expect(User.by_username_email_or_document_number(" larry@consul.dev ")).to eq [larry]
      end

      it "finds users by name" do
        expect(User.by_username_email_or_document_number("larry")).to eq [larry]
      end

      it "finds users by name with whitespaces" do
        expect(User.by_username_email_or_document_number(" larry ")).to eq [larry]
      end

      it "finds users by document_number" do
        expect(User.by_username_email_or_document_number("12345678Z")).to eq [larry]
      end

      it "finds users by document_number with whitespaces" do
        expect(User.by_username_email_or_document_number(" 12345678Z ")).to eq [larry]
      end
    end

    describe ".between_ages" do
      it "returns users between certain ages, including both" do
        [21, 22, 23, 23, 42, 43, 44, 51].each do |age|
          create(:user, date_of_birth: age.years.ago)
        end

        expect(User.between_ages(0, 20).count).to eq 0
        expect(User.between_ages(0, 21).count).to eq 1
        expect(User.between_ages(21, 23).count).to eq 4
        expect(User.between_ages(24, 41).count).to eq 0
        expect(User.between_ages(41, 45).count).to eq 3
        expect(User.between_ages(51, 100).count).to eq 1
      end

      it "does not consider that people born in the same year share the same age" do
        april_1st_user = create(:user, date_of_birth: Time.zone.local(2001, 4, 1))
        april_2nd_user = create(:user, date_of_birth: Time.zone.local(2001, 4, 2))
        april_3rd_user = create(:user, date_of_birth: Time.zone.local(2001, 4, 3))

        travel_to "2021-04-02" do
          expect(User.between_ages(18, 19)).to eq [april_3rd_user]
          expect(User.between_ages(20, 21)).to match_array [april_1st_user, april_2nd_user]
          expect(User.between_ages(19, 20)).to match_array [april_1st_user, april_2nd_user, april_3rd_user]
        end
      end

      it "works on leap years with users born on leap years" do
        leap_day_user = create(:user, date_of_birth: Time.zone.local(2000, 2, 29))
        march_1st_user = create(:user, date_of_birth: Time.zone.local(2000, 3, 1))

        travel_to "2024-02-28" do
          expect(User.between_ages(22, 23)).to match_array [leap_day_user, march_1st_user]
          expect(User.between_ages(23, 24)).to match_array [leap_day_user, march_1st_user]
          expect(User.between_ages(24, 25)).to eq []
        end

        travel_to "2024-02-29" do
          expect(User.between_ages(22, 23)).to eq [march_1st_user]
          expect(User.between_ages(23, 24)).to match_array [leap_day_user, march_1st_user]
          expect(User.between_ages(24, 25)).to eq [leap_day_user]
        end

        travel_to "2024-03-01" do
          expect(User.between_ages(22, 23)).to eq []
          expect(User.between_ages(23, 24)).to match_array [leap_day_user, march_1st_user]
          expect(User.between_ages(24, 25)).to match_array [leap_day_user, march_1st_user]
        end
      end

      it "works on non-leap years with users born on leap years" do
        leap_day_user = create(:user, date_of_birth: Time.zone.local(2000, 2, 29))
        march_1st_user = create(:user, date_of_birth: Time.zone.local(2000, 3, 1))

        travel_to "2023-02-28" do
          expect(User.between_ages(21, 22)).to match_array [leap_day_user, march_1st_user]
          expect(User.between_ages(22, 23)).to match_array [leap_day_user, march_1st_user]
          expect(User.between_ages(23, 24)).to eq []
        end

        travel_to "2023-03-01" do
          expect(User.between_ages(21, 22)).to eq []
          expect(User.between_ages(22, 23)).to match_array [leap_day_user, march_1st_user]
          expect(User.between_ages(23, 24)).to match_array [leap_day_user, march_1st_user]
        end
      end

      it "works on leap years with users born on non-leap years" do
        march_1st_user = create(:user, date_of_birth: Time.zone.local(2001, 3, 1))

        travel_to "2024-02-28" do
          expect(User.between_ages(21, 22)).to eq [march_1st_user]
          expect(User.between_ages(22, 23)).to eq [march_1st_user]
          expect(User.between_ages(23, 24)).to eq []
        end

        travel_to "2024-02-29" do
          expect(User.between_ages(21, 22)).to eq [march_1st_user]
          expect(User.between_ages(22, 23)).to eq [march_1st_user]
          expect(User.between_ages(23, 24)).to eq []
        end

        travel_to "2024-03-01" do
          expect(User.between_ages(21, 22)).to eq []
          expect(User.between_ages(22, 23)).to match_array [march_1st_user]
          expect(User.between_ages(23, 24)).to match_array [march_1st_user]
        end
      end

      it "returns users between certain ages on a reference date" do
        reference_date = 20.years.ago

        travel_to(reference_date) do
          [21, 22, 23, 23, 34, 42, 43, 44, 50, 51].each do |age|
            create(:user, date_of_birth: age.years.ago)
          end
        end

        expect(User.between_ages(0, 20, at_time: reference_date).count).to eq 0
        expect(User.between_ages(21, 25, at_time: reference_date).count).to eq 4
        expect(User.between_ages(25, 30, at_time: reference_date).count).to eq 0
        expect(User.between_ages(30, 34, at_time: reference_date).count).to eq 1
        expect(User.between_ages(35, 39, at_time: reference_date).count).to eq 0
        expect(User.between_ages(40, 44, at_time: reference_date).count).to eq 3
        expect(User.between_ages(45, 49, at_time: reference_date).count).to eq 0
        expect(User.between_ages(50, 54, at_time: reference_date).count).to eq 2
        expect(User.between_ages(55, 100, at_time: reference_date).count).to eq 0
      end
    end
  end

  describe "self.search" do
    describe "find users" do
      let!(:larry) { create(:user, email: "larry@consul.dev", username: "Larry Bird") }

      before { create(:user, email: "robert@consul.dev", username: "Robert Parish") }

      it "by email" do
        expect(User.search("larry@consul.dev")).to eq [larry]
      end

      it "by email with whitespaces" do
        expect(User.search(" larry@consul.dev ")).to eq [larry]
      end

      it "by name" do
        expect(User.search("larry")).to eq [larry]
      end

      it "by name with whitespaces" do
        expect(User.search(" larry ")).to eq [larry]
      end
    end

    it "returns no results if no search term provided" do
      expect(User.search("    ")).to be_empty
    end
  end

  describe "verification" do
    it_behaves_like "verifiable"
  end

  describe "cache" do
    let(:user) { create(:user) }

    it "expires cache with becoming a moderator" do
      expect { create(:moderator, user: user) }.to change { user.cache_version }
    end

    it "expires cache with becoming an admin" do
      expect { create(:administrator, user: user) }.to change { user.cache_version }
    end

    it "expires cache with becoming a veridied organization" do
      create(:organization, user: user)
      expect { user.organization.verify }.to change { user.reload.cache_version }
    end
  end

  describe "document_number" do
    it "upcases document number" do
      user = User.new(document_number: "x1234567z")
      user.valid?
      expect(user.document_number).to eq("X1234567Z")
    end

    it "removes all characters except numbers and letters" do
      user = User.new(document_number: " 12.345.678 - B")
      user.valid?
      expect(user.document_number).to eq("12345678B")
    end
  end

  describe "#erase" do
    it "erases user information and marks him as erased" do
      user = create(:user,
                    username: "manolo",
                    email: "a@a.com",
                    unconfirmed_email: "a@a.com",
                    phone_number: "5678",
                    confirmed_phone: "5678",
                    unconfirmed_phone: "5678",
                    encrypted_password: "foobar",
                    confirmation_token: "token1",
                    reset_password_token: "token2",
                    email_verification_token: "token3")

      user.erase("a test")
      user.reload

      expect(user.erase_reason).to eq("a test")
      expect(user.erased_at).to    be

      expect(user.username).to be nil
      expect(user.email).to be nil
      expect(user.unconfirmed_email).to be nil
      expect(user.phone_number).to be nil
      expect(user.confirmed_phone).to be nil
      expect(user.unconfirmed_phone).to be nil
      expect(user.encrypted_password).to be_empty
      expect(user.confirmation_token).to be nil
      expect(user.reset_password_token).to be nil
      expect(user.email_verification_token).to be nil
    end

    it "maintains associated identification document" do
      user = create(:user, document_number: "1234", document_type: "1")
      user.erase
      user.reload

      expect(user.erased_at).to be
      expect(user.document_number).to be
      expect(user.document_type).to be
    end

    it "destroys associated social network identities" do
      user = create(:user)
      identity = create(:identity, user: user)

      user.erase("an identity test")

      expect(Identity.exists?(identity.id)).not_to be
    end

    it "removes all user roles" do
      user = create(:user)
      [:administrator, :moderator, :manager, :sdg_manager, :valuator].each do |role|
        create(role, user: user)
      end

      expect { user.erase }.to change { Administrator.count }.by(-1)
                           .and change { Moderator.count }.by(-1)
                           .and change { Manager.count }.by(-1)
                           .and change { SDG::Manager.count }.by(-1)
                           .and change { Valuator.count }.by(-1)
    end
  end

  describe "#take_votes_from" do
    it "logs info of previous users" do
      user = create(:user, :level_three)
      other_user = create(:user, :level_three)
      another_user = create(:user)

      expect(user.former_users_data_log).to be_blank

      user.take_votes_from other_user

      expect(user.former_users_data_log).to include("id: #{other_user.id}")

      user.take_votes_from another_user

      expect(user.former_users_data_log).to include("id: #{other_user.id}")
      expect(user.former_users_data_log).to include("| id: #{another_user.id}")
    end

    it "reassigns votes from other user" do
      other_user = create(:user, :level_three)
      user = create(:user, :level_three)

      v1 = create(:vote, voter: other_user, votable: create(:debate))
      v2 = create(:vote, voter: other_user, votable: create(:proposal))
      v3 = create(:vote, voter: other_user, votable: create(:comment))

      create(:vote)

      expect(other_user.votes.count).to eq(3)
      expect(user.votes.count).to eq(0)

      user.take_votes_from other_user

      expect(other_user.votes.count).to eq(0)
      expect(user.vote_ids).to match_array [v1.id, v2.id, v3.id]
    end

    it "reassigns budget ballots from other user" do
      other_user = create(:user, :level_three)
      user = create(:user, :level_three)

      b1 = create(:budget_ballot, user: other_user)
      b2 = create(:budget_ballot, user: other_user)

      create(:budget_ballot)

      expect(Budget::Ballot.where(user: other_user).count).to eq(2)
      expect(Budget::Ballot.where(user: user).count).to eq(0)

      user.take_votes_from other_user

      expect(Budget::Ballot.where(user: other_user).count).to eq(0)
      expect(Budget::Ballot.where(user: user)).to match_array [b1, b2]
    end

    it "reassigns poll voters from other user" do
      other_user = create(:user, :level_three)
      user = create(:user, :level_three)

      v1 = create(:poll_voter, user: other_user)
      v2 = create(:poll_voter, user: other_user)

      create(:poll_voter)

      expect(Poll::Voter.where(user: other_user).count).to eq(2)
      expect(Poll::Voter.where(user: user).count).to eq(0)

      user.take_votes_from other_user

      expect(Poll::Voter.where(user: other_user).count).to eq(0)
      expect(Poll::Voter.where(user: user)).to match_array [v1, v2]
    end
  end

  describe "#take_votes_if_erased_document" do
    it "does nothing if no erased user with received document" do
      user_1 = create(:user, :level_three)
      user_2 = create(:user, :level_three)

      create(:vote, voter: user_1)
      create(:budget_ballot, user: user_1)
      create(:poll_voter, user: user_1)

      user_2.take_votes_if_erased_document(111, 1)

      expect(user_1.votes.count).to eq(1)
      expect(user_2.votes.count).to eq(0)

      expect(Budget::Ballot.where(user: user_1).count).to eq(1)
      expect(Budget::Ballot.where(user: user_2).count).to eq(0)

      expect(Poll::Voter.where(user: user_1).count).to eq(1)
      expect(Poll::Voter.where(user: user_2).count).to eq(0)
    end

    it "takes votes from erased user with received document" do
      user_1 = create(:user, :level_two, document_number: "12345777", document_type: "1")
      user_2 = create(:user)

      create(:vote, voter: user_1)
      create(:budget_ballot, user: user_1)
      create(:poll_voter, user: user_1)

      user_1.erase

      user_2.take_votes_if_erased_document("12345777", "1")

      expect(user_1.votes.count).to eq(0)
      expect(user_2.votes.count).to eq(1)

      expect(Budget::Ballot.where(user: user_1).count).to eq(0)
      expect(Budget::Ballot.where(user: user_2).count).to eq(1)

      expect(Poll::Voter.where(user: user_1).count).to eq(0)
      expect(Poll::Voter.where(user: user_2).count).to eq(1)
    end

    it "removes document from erased user and logs info" do
      user_1 = create(:user, document_number: "12345777", document_type: "1")
      user_2 = create(:user)
      user_1.erase

      user_2.take_votes_if_erased_document("12345777", "1")

      expect(user_2.reload.former_users_data_log).to include("id: #{user_1.id}")
      expect(user_1.reload.document_number).to be_blank
    end
  end

  describe "email_required?" do
    it "is true for regular users" do
      expect(subject.email_required?).to be true
      expect(create(:user, :hidden).email_required?).to be true
    end

    it "is false for erased users" do
      user = create(:user)
      user.erase
      user.reload

      expect(user.email_required?).to be false
    end

    it "is false for verified users with no email" do
      user = create(:user, username: "Lois", email: "", verified_at: Time.current)

      expect(user).to be_valid
      expect(user.email_required?).to be false
    end
  end

  describe "#interests" do
    let(:user) { create(:user) }

    it "returns followed object tags" do
      create(:proposal, tag_list: "Sport", followers: [user])

      expect(user.interests).to eq ["Sport"]
    end

    it "deals gracefully with hidden proposals" do
      proposal = create(:proposal, tag_list: "Sport", followers: [user])

      proposal.hide

      expect(user.interests).to eq []
    end

    it "discards followed objects duplicated tags" do
      create(:proposal, tag_list: "Sport", followers: [user])
      create(:proposal, tag_list: "Sport", followers: [user])
      create(:budget_investment, tag_list: "Sport", followers: [user])

      expect(user.interests).to eq ["Sport"]
    end
  end

  describe "#public_interests" do
    it "is false by default" do
      expect(User.new.public_interests).to be false
    end
  end

  describe ".find_by_manager_login" do
    it "works with a low ID" do
      user = create(:user)
      expect(User.find_by_manager_login("admin_user_#{user.id}")).to eq user
    end

    it "works with a high ID" do
      10.times { create(:user) }
      user = User.last
      expect(User.find_by_manager_login("admin_user_#{user.id}")).to eq user
    end
  end

  describe "#block" do
    it "hides legislation proposals created by the user" do
      user = create(:user)
      other_user = create(:user)

      proposal = create(:legislation_proposal, author: user)
      other_proposal = create(:legislation_proposal, author: other_user)

      user.block

      expect(Legislation::Proposal.all).to eq [other_proposal]
      expect(Legislation::Proposal.with_hidden).to match_array [proposal, other_proposal]
    end

    it "removes all user roles" do
      user = create(:user)
      [:administrator, :moderator, :manager, :sdg_manager, :valuator].each do |role|
        create(role, user: user)
      end

      expect { user.block }.to change { Administrator.count }.by(-1)
                           .and change { Moderator.count }.by(-1)
                           .and change { Manager.count }.by(-1)
                           .and change { SDG::Manager.count }.by(-1)
                           .and change { Valuator.count }.by(-1)
    end
  end

  describe "#full_restore" do
    it "restore all previous hidden user content" do
      user = create(:user, :hidden)
      other_user = create(:user, :hidden)

      comment = create(:comment, :hidden, author: user)
      debate = create(:debate, :hidden, author: user)
      investment = create(:budget_investment, :hidden, author: user)
      proposal = create(:proposal, :hidden, author: user)
      legislation_proposal = create(:legislation_proposal, :hidden, author: user)
      proposal_notification = create(:proposal_notification, :hidden, proposal: proposal)

      old_hidden_comment = create(:comment, hidden_at: 3.days.ago, author: user)
      old_hidden_debate = create(:debate, hidden_at: 3.days.ago, author: user)
      old_hidden_investment = create(:budget_investment, hidden_at: 3.days.ago, author: user)
      old_hidden_proposal = create(:proposal, hidden_at: 3.days.ago, author: user)
      old_hidden_legislation_proposal = create(:legislation_proposal, hidden_at: 3.days.ago, author: user)
      old_hidden_proposal_notification = create(:proposal_notification,
                                                hidden_at: 3.days.ago,
                                                proposal: proposal)

      other_user_comment = create(:comment, :hidden, author: other_user)
      other_user_debate = create(:debate, :hidden, author: other_user)
      other_user_proposal = create(:proposal, :hidden, author: other_user)
      other_user_investment = create(:budget_investment, :hidden, author: other_user)
      other_user_legislation_proposal = create(:legislation_proposal, :hidden, author: other_user)
      other_user_proposal_notification = create(:proposal_notification,
                                                :hidden,
                                                proposal: other_user_proposal)

      user.full_restore

      expect(debate.reload).not_to be_hidden
      expect(comment.reload).not_to be_hidden
      expect(investment.reload).not_to be_hidden
      expect(proposal.reload).not_to be_hidden
      expect(proposal_notification.reload).not_to be_hidden
      expect(legislation_proposal.reload).not_to be_hidden

      expect(old_hidden_comment.reload).to be_hidden
      expect(old_hidden_debate.reload).to be_hidden
      expect(old_hidden_investment.reload).to be_hidden
      expect(old_hidden_proposal.reload).to be_hidden
      expect(old_hidden_proposal_notification.reload).to be_hidden
      expect(old_hidden_legislation_proposal.reload).to be_hidden

      expect(other_user_comment.reload).to be_hidden
      expect(other_user_debate.reload).to be_hidden
      expect(other_user_investment.reload).to be_hidden
      expect(other_user_proposal.reload).to be_hidden
      expect(other_user_proposal_notification.reload).to be_hidden
      expect(other_user_legislation_proposal.reload).to be_hidden
    end
  end

  describe "#add_subscriptions_token" do
    let(:user) { build(:user, subscriptions_token: nil) }

    it "generates a subscriptions token when the user doesn't have one" do
      user.add_subscriptions_token

      expect(user.subscriptions_token).to be_present
    end

    it "keeps the existing subscriptions token when the user already has one" do
      user.update!(subscriptions_token: "already_set")

      user.add_subscriptions_token

      expect(user.subscriptions_token).to eq "already_set"
    end
  end

  describe ".password_complexity" do
    it "returns no complexity when the secrets aren't configured" do
      expect(User.password_complexity).to eq({ digit: 0, lower: 0, symbol: 0, upper: 0 })
    end

    context "when secrets are configured" do
      before do
        allow(Rails.application).to receive(:secrets).and_return(ActiveSupport::OrderedOptions.new.merge(
          security: {
            password_complexity: true
          },
          tenants: {
            tolerant: {
              security: {
                password_complexity: false
              }
            }
          }
        ))
      end

      it "uses the general secrets for the main tenant" do
        expect(User.password_complexity).to eq({ digit: 1, lower: 1, symbol: 0, upper: 1 })
      end

      it "uses the tenant secrets for a tenant" do
        allow(Tenant).to receive(:current_schema).and_return("tolerant")

        expect(User.password_complexity).to eq({ digit: 0, lower: 0, symbol: 0, upper: 0 })
      end
    end
  end

  describe ".maximum_attempts" do
    it "returns 20 as default when the secrets aren't configured" do
      expect(User.maximum_attempts).to eq 20
    end

    context "when secrets are configured" do
      before do
        allow(Rails.application).to receive(:secrets).and_return(ActiveSupport::OrderedOptions.new.merge(
          security: {
            lockable: { maximum_attempts: "14" }
          },
          tenants: {
            superstrict: {
              security: {
                lockable: { maximum_attempts: "1" }
              }
            }
          }
        ))
      end

      it "uses the general secrets for the main tenant" do
        expect(User.maximum_attempts).to eq 14
      end

      it "uses the tenant secrets for a tenant" do
        allow(Tenant).to receive(:current_schema).and_return("superstrict")

        expect(User.maximum_attempts).to eq 1
      end
    end
  end

  describe ".unlock_in" do
    it "returns 1 as default when the secrets aren't configured" do
      expect(User.unlock_in).to eq 1.hour
    end

    context "when secrets are configured" do
      before do
        allow(Rails.application).to receive(:secrets).and_return(ActiveSupport::OrderedOptions.new.merge(
          security: {
            lockable: { unlock_in: "2" }
          },
          tenants: {
            superstrict: {
              security: {
                lockable: { unlock_in: "50" }
              }
            }
          }
        ))
      end

      it "uses the general secrets for the main tenant" do
        expect(User.unlock_in).to eq 2.hours
      end

      it "uses the tenant secrets for a tenant" do
        allow(Tenant).to receive(:current_schema).and_return("superstrict")

        expect(User.unlock_in).to eq 50.hours
      end
    end
  end
end
