require 'spec_helper'

describe SpamRulesEnforcer do

  before do
    SiteSetting.stubs(:flags_required_to_hide_post).returns(0) # never
    SiteSetting.stubs(:num_flags_to_block_new_user).returns(2)
    SiteSetting.stubs(:num_users_to_block_new_user).returns(2)
  end

  describe 'enforce!' do
    let(:post)  { Fabricate.build(:post, user: Fabricate.build(:user, trust_level: TrustLevel.levels[:newuser])) }
    subject     { SpamRulesEnforcer.new(post.user) }

    it "does nothing if the user's trust level is higher than 'new user'" do
      basic_user = Fabricate.build(:user, trust_level: TrustLevel.levels[:basic])
      enforcer = SpamRulesEnforcer.new(basic_user)
      enforcer.expects(:num_spam_flags_against_user).never
      enforcer.expects(:num_users_who_flagged_spam_against_user).never
      enforcer.expects(:punish_user).never
      enforcer.enforce!
    end

    it 'takes no action if not enough flags by enough users have been submitted' do
      subject.stubs(:block?).returns(false)
      subject.expects(:punish_user).never
      subject.enforce!
    end

    it 'delivers punishment when there are enough flags from enough users' do
      subject.stubs(:block?).returns(true)
      subject.expects(:punish_user)
      subject.enforce!
    end
  end

  describe 'num_spam_flags_against_user' do
    before { SpamRulesEnforcer.any_instance.stubs(:punish_user) }
    let(:post)     { Fabricate(:post) }
    let(:enforcer) { SpamRulesEnforcer.new(post.user) }
    subject        { enforcer.num_spam_flags_against_user }

    it 'returns 0 when there are no flags' do
      expect(subject).to eq(0)
    end

    it 'returns 0 when there is one flag that has a reason other than spam' do
      Fabricate(:flag, post: post, post_action_type_id: PostActionType.types[:off_topic])
      expect(subject).to eq(0)
    end

    it 'returns 2 when there are two flags with spam as the reason' do
      2.times { Fabricate(:flag, post: post, post_action_type_id: PostActionType.types[:spam]) }
      expect(subject).to eq(2)
    end

    it 'returns 2 when there are two spam flags, each on a different post' do
      Fabricate(:flag, post: post, post_action_type_id: PostActionType.types[:spam])
      Fabricate(:flag, post: Fabricate(:post, user: post.user), post_action_type_id: PostActionType.types[:spam])
      expect(subject).to eq(2)
    end
  end

  describe 'num_users_who_flagged_spam_against_user' do
    before { SpamRulesEnforcer.any_instance.stubs(:punish_user) }
    let(:post)     { Fabricate(:post) }
    let(:enforcer) { SpamRulesEnforcer.new(post.user) }
    subject        { enforcer.num_users_who_flagged_spam_against_user }

    it 'returns 0 when there are no flags' do
      expect(subject).to eq(0)
    end

    it 'returns 0 when there is one flag that has a reason other than spam' do
      Fabricate(:flag, post: post, post_action_type_id: PostActionType.types[:off_topic])
      expect(subject).to eq(0)
    end

    it 'returns 1 when there is one spam flag' do
      Fabricate(:flag, post: post, post_action_type_id: PostActionType.types[:spam])
      expect(subject).to eq(1)
    end

    it 'returns 2 when there are two spam flags from 2 users' do
      Fabricate(:flag, post: post, post_action_type_id: PostActionType.types[:spam])
      Fabricate(:flag, post: post, post_action_type_id: PostActionType.types[:spam])
      expect(subject).to eq(2)
    end

    it 'returns 1 when there are two spam flags on two different posts from 1 user' do
      flagger = Fabricate(:user)
      Fabricate(:flag, post: post, user: flagger, post_action_type_id: PostActionType.types[:spam])
      Fabricate(:flag, post: Fabricate(:post, user: post.user), user: flagger, post_action_type_id: PostActionType.types[:spam])
      expect(subject).to eq(1)
    end
  end

  describe 'punish_user' do
    let!(:admin)  { Fabricate(:admin) } # needed for SystemMessage
    let(:user)    { Fabricate(:user) }
    let!(:post)   { Fabricate(:post, user: user) }
    subject       { SpamRulesEnforcer.new(user) }

    before do
      SpamRulesEnforcer.stubs(:block?).with {|u| u.id != user.id }.returns(false)
      SpamRulesEnforcer.stubs(:block?).with {|u| u.id == user.id }.returns(true)
      subject.stubs(:block?).returns(true)
    end

    it "hides all the user's posts" do
      subject.punish_user
      expect(post.reload).to be_hidden
    end

    it "hides the topic if the post was the first post" do
      subject.punish_user
      expect(post.topic.reload).to_not be_visible
    end

    it 'prevents the user from making new posts' do
      subject.punish_user
      expect(Guardian.new(user).can_create_post?(nil)).to be_false
    end

    it 'sends private messages to the user and to moderators' do
      SystemMessage.expects(:create).with(user, anything, anything)
      moderator = Fabricate(:moderator)
      GroupMessage.expects(:create).with do |group, msg_type, params|
        group == Group[:moderators].name and msg_type == :user_automatically_blocked and params[:user].id == user.id
      end
      subject.punish_user
    end

    it 'sets the blocked flag' do
      subject.punish_user
      expect(user.reload.blocked).to be_true
    end
  end

  describe 'block?' do

    context 'never been blocked' do
      shared_examples "can't be blocked" do
        it "returns false" do
          enforcer = SpamRulesEnforcer.new(user)
          enforcer.expects(:num_spam_flags_against_user).never
          enforcer.expects(:num_users_who_flagged_spam_against_user).never
          expect(enforcer.block?).to be_false
        end
      end

      [:basic, :regular, :leader, :elder].each do |trust_level|
        context "user has trust level #{trust_level}" do
          let(:user) { Fabricate(:user, trust_level: TrustLevel.levels[trust_level]) }
          include_examples "can't be blocked"
        end
      end

      context "user is an admin" do
        let(:user) { Fabricate(:admin) }
        include_examples "can't be blocked"
      end

      context "user is a moderator" do
        let(:user) { Fabricate(:moderator) }
        include_examples "can't be blocked"
      end
    end

    context 'new user' do
      let(:user)  { Fabricate(:user, trust_level: TrustLevel.levels[:newuser]) }
      subject     { SpamRulesEnforcer.new(user) }

      it 'returns false if there are no spam flags' do
        subject.stubs(:num_spam_flags_against_user).returns(0)
        subject.stubs(:num_users_who_flagged_spam_against_user).returns(0)
        expect(subject.block?).to be_false
      end

      it 'returns false if there are not received enough flags' do
        subject.stubs(:num_spam_flags_against_user).returns(1)
        subject.stubs(:num_users_who_flagged_spam_against_user).returns(2)
        expect(subject.block?).to be_false
      end

      it 'returns false if there have not been enough users' do
        subject.stubs(:num_spam_flags_against_user).returns(2)
        subject.stubs(:num_users_who_flagged_spam_against_user).returns(1)
        expect(subject.block?).to be_false
      end

      it 'returns false if num_flags_to_block_new_user is 0' do
        SiteSetting.stubs(:num_flags_to_block_new_user).returns(0)
        subject.stubs(:num_spam_flags_against_user).returns(100)
        subject.stubs(:num_users_who_flagged_spam_against_user).returns(100)
        expect(subject.block?).to be_false
      end

      it 'returns false if num_users_to_block_new_user is 0' do
        SiteSetting.stubs(:num_users_to_block_new_user).returns(0)
        subject.stubs(:num_spam_flags_against_user).returns(100)
        subject.stubs(:num_users_who_flagged_spam_against_user).returns(100)
        expect(subject.block?).to be_false
      end

      it 'returns true when there are enough flags from enough users' do
        subject.stubs(:num_spam_flags_against_user).returns(2)
        subject.stubs(:num_users_who_flagged_spam_against_user).returns(2)
        expect(subject.block?).to be_true
      end
    end

    context "blocked, but has higher trust level now" do
      let(:user)  { Fabricate(:user, blocked: true, trust_level: TrustLevel.levels[:basic]) }
      subject     { SpamRulesEnforcer.new(user) }

      it 'returns false' do
        expect(subject.block?).to be_true
      end
    end
  end

  describe "clear_user" do
    let!(:admin)  { Fabricate(:admin) } # needed for SystemMessage
    let(:user)    { Fabricate(:user) }
    subject       { SpamRulesEnforcer.new(user) }

    it 'sets blocked flag to false' do
      subject.clear_user
      expect(user.reload).to_not be_blocked
    end

    it 'sends a system message' do
      SystemMessage.expects(:create).with(user, anything, anything)
      subject.clear_user
    end

    it 'allows user to make new posts' do
      subject.clear_user
      expect(Guardian.new(user).can_create_post?(nil)).to be_true
    end
  end

end