require File.dirname(__FILE__) + '/../test_helper'

class UserTest < ActiveSupport::TestCase

  context "A user, when signing up, " do
    setup do
      @user = Factory(:user,  :password => "password123", :password_confirmation => "password123")
     end

    should_have_many :pages

    should_validate_presence_of :login, :message => I18n.t(:empty_login)
    should_validate_uniqueness_of :login, :message => I18n.t(:existing_login)
    should_ensure_length_in_range :login, (3..40), :short_message => I18n.t(:too_short_login), :long_message => I18n.t(:too_long_login)
    should_not_allow_values_for :login, "&nbsp;", "*&%{}[]?\\", :message => I18n.t(:invalid_login)
    should_allow_values_for :login, "a@b.", "dfgAFGKDSFJL"

    should_validate_presence_of :email, :message => I18n.t(:empty_email)
    should_validate_uniqueness_of :email, :message => I18n.t(:existing_email)
    should_ensure_length_in_range :email, (6..100), :short_message => I18n.t(:too_short_email), :long_message => I18n.t(:too_long_email)
    should_not_allow_values_for :email, "patrikjira at gmail.com", "papricek@seznam", :message => I18n.t(:invalid_email)
    should_allow_values_for :email, "patrikjira@gmail.com", "papricek@seznam.cz", "Patrik.Jira@tn.cz"

    should_not_allow_mass_assignment_of :salt, :encrypted_password, :remember_token, :remember_token_expires_at
  end

  context "A user without crypted password" do
    setup do
      @user = Factory.build(:user,  :password => "password123", :password_confirmation => "password123")
    end
    should_validate_presence_of :password, :message => I18n.t(:empty_password)
    should_validate_presence_of :password_confirmation, :message => I18n.t(:empty_password_confirmation)
  end

  context "A new (unactivated) user" do
    setup do
      @user = create_user;
      @user.register!
    end

    should "be created" do
      assert_difference 'User.count' do
        user = create_user
        assert !user.new_record?, "#{user.errors.full_messages.to_sentence}"
      end
    end

    should "initialize its activation code upon creation" do
      @user.reload
      assert_not_nil @user.activation_code
    end

    should "be created and start in pending state" do
      @user.reload
      assert @user.pending?
    end
  end

  context "An existing (activated) user" do
    setup do
      @user = Factory(:quentin)
    end

    should "reset password" do
      @user.update_attributes(:password => 'new password', :password_confirmation => 'new password')
      assert_equal @user, User.authenticate(@user.login, 'new password')
    end

    should "not rehash password" do
      @user.update_attributes(:password => 'new password', :password_confirmation => 'new password')
      assert_equal @user, User.authenticate(@user.login, 'new password')
    end

    should "be authenticated" do
      assert_equal @user, User.authenticate(@user.login, 'monkey')
    end

    should "set remember token" do
      @user.remember_me
      assert_not_nil @user.remember_token
      assert_not_nil @user.remember_token_expires_at
    end


    should "unset remember token" do
      @user.remember_me
      assert_not_nil @user.remember_token
      @user.forget_me
      assert_nil @user.remember_token
    end

    should "be remembered for one week" do
      before = 1.week.from_now.utc
      @user.remember_me_for 1.week
      after = 1.week.from_now.utc
      assert_not_nil @user.remember_token
      assert_not_nil @user.remember_token_expires_at
      assert @user.remember_token_expires_at.between?(before, after)
    end

    should "be remembered until one week" do
      time = 1.week.from_now.utc
      @user.remember_me_until time
      assert_not_nil @user.remember_token
      assert_not_nil @user.remember_token_expires_at
      assert_equal @user.remember_token_expires_at, time
    end

    should "be remembered default two week" do
      before = 2.weeks.from_now.utc
      @user.remember_me
      after = 2.weeks.from_now.utc
      assert_not_nil @user.remember_token
      assert_not_nil @user.remember_token_expires_at
      assert @user.remember_token_expires_at.between?(before, after)
    end

    should "be registered when passive" do
      user = Factory.build(:user, :password => nil, :password_confirmation => nil)
      assert user.passive?
      user.update_attributes(:password => 'some password', :password_confirmation => 'some password')
      user.register!
      assert user.pending?
    end

    should "be suspended" do
      @user.suspend!
      assert @user.suspended?
    end

    should "not authenticate when suspended" do
      @user.suspend!
      assert_not_equal @user, User.authenticate('quentin', 'test')
    end

    should "be unsuspended to active state" do
      @user.suspend!
      assert @user.suspended?
      @user.unsuspend!
      assert @user.active?
    end

    should "be unsuspended with nil activation code and activated to passive state" do
      @user.suspend!
      User.update_all :activation_code => nil, :activated_at => nil
      assert @user.suspended?
      @user.reload.unsuspend!
      assert @user.passive?
    end

    should "be unsuspended with activation code and nil activated_at to pending state" do
      @user.suspend!
      User.update_all :activation_code => 'foo-bar', :activated_at => nil
      assert @user.suspended?
      @user.reload.unsuspend!
      assert @user.pending?
    end

    should "be deleted" do
      assert_nil @user.deleted_at
      @user.delete!
      assert_not_nil @user.deleted_at
      assert @user.deleted?
    end
  end

  protected
  def create_user(options = {})
    Factory(:user, {:password => "password123", :password_confirmation => "password123"}.merge(options))
  end

end