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

class UserTest < ActiveSupport::TestCase
  fixtures :users
  
  def setup
    @error_messages = ActiveRecord::Errors.default_error_messages
    @valid_user = users(:valid_user)
    @invalid_user = users(:invalid_user)
  end
  
  # Konstrukcja tego uytkownika powinna by poprawna
  def test_user_validity
    assert @valid_user.valid?
  end
  
  # Konstrukcja tego uytkownika powinna by bdna
  def test_user_invalidity
    assert !@invalid_user.valid?
    attributes = [:screen_name, :email, :password]
    attributes.each do |attribute|
      assert @invalid_user.errors.invalid?(attribute)
    end
  end

  # Jeden test, ktry sprawdza niepowtarzalno zarwno pseudonimu, jak i adresu e-mail
  def test_uniqueness_of_screen_name_and_email
    user_repeat = User.new(:screen_name => @valid_user.screen_name,
                           :email => @valid_user.email,
                           :password => @valid_user.password)
    assert !user_repeat.valid?
    assert_equal @error_messages[:taken], user_repeat.errors.on(:screen_name)
    assert_equal @error_messages[:taken], user_repeat.errors.on(:email)
  end
  
  # Sprawd, czy pseudonim nie jest zbyt krtki
  def test_screen_name_minimum_length
    user = @valid_user
    min_length = User::SCREEN_NAME_MIN_LENGTH
    
    # Pseudonim jest zbyt krtki
    user.screen_name = "a" * (min_length - 1)
    assert !user.valid?, "#{user.screen_name} powinien zgasza bd o minimalnej dugoci"    
    # Formatuj komunikat o bdzie na podstawie minimalnej dugoci
    correct_error_message = sprintf(@error_messages[:too_short], min_length)
    assert_equal correct_error_message, user.errors.on(:screen_name)

    # Pseudonim ma minimaln dugo
    user.screen_name = "a" * min_length
    assert user.valid?, "#{user.screen_name} powinien by wystarczajco dugi, by przej walidacj."
  end
  
  # Sprawd, czy pseudonim nie jest zbyt dugi
  def test_screen_name_maximum_length
    user = @valid_user
    max_length = User::SCREEN_NAME_MAX_LENGTH
    
    # Pseudonim jest zbyt dugi
    user.screen_name = "a" * (max_length + 1)
    assert !user.valid?, "#{user.screen_name} powinien zgasza bd o minimalnej dugoci."
    # Formatuj komunikat o bdzie na podstawie maksymalnej dugoci
    correct_error_message = sprintf(@error_messages[:too_long], max_length)
    assert_equal correct_error_message, user.errors.on(:screen_name)
  
    # Pseudonim ma maksymaln dugo
    user.screen_name = "a" * max_length
    assert user.valid?, "#{user.screen_name} powinien by wystarczajco dugi, by przej walidacj."
  end
  
  # Sprawd, czy haso nie moe by zbyt krtkie
  def test_password_minimum_length
    user = @valid_user
    min_length = User::PASSWORD_MIN_LENGTH
    
    # Haso jest zbyt krtkie
    user.password = "a" * (min_length - 1)
    assert !user.valid?, "#{user.password} powinno zgasza bd o minimalnej dugoci."
    # Formatuj komunikat o bdzie na podstawie minimalnej dugoci
    correct_error_message = sprintf(@error_messages[:too_short], min_length)
    assert_equal correct_error_message, user.errors.on(:password)
   
    # Haso jest odpowiednio dugie
    user.password = "a" * min_length
    assert user.valid?, "#{user.password} powinno by wystarczajco dugie, by przej walidacj."
  end

  # Sprawd, czy haso nie moe by zbyt dugie
  def test_password_maximum_length
    user = @valid_user
    max_length = User::PASSWORD_MAX_LENGTH
    
    # Haso jest zbyt dugie
    user.password = "a" * (max_length + 1)
    assert !user.valid?, "#{user.password} powinno zgasza bd o minimalnej dugoci."
    # Formatuj komunikat o bdzie na podstawie maksymalnej dugoci
    correct_error_message = sprintf(@error_messages[:too_long], max_length)
    assert_equal correct_error_message, user.errors.on(:password)

    # Haso ma maksymaln dugo
    user.password = "a" * max_length
    assert user.valid?, "#{user.password} powinno by wystarczajco dugie, by przej walidacj."
  end

  # Sprawd, czy e-mail nie jest zbyt dugi
  def test_email_maximum_length
    user = @valid_user
    max_length = User::EMAIL_MAX_LENGTH

    # Konstruuje poprawny, ale zbyt dugi adres e-mail
    user.email = "a" * (max_length - user.email.length + 1) + user.email
    assert !user.valid?, "#{user.email} powinien zgasza bd o maksymalnej dugoci."
    # Formatuj komunikat o bdzie na podstawie maksymalnej dugoci
    correct_error_message = sprintf(@error_messages[:too_long], max_length)
    assert_equal correct_error_message, user.errors.on(:email)
  end

  # Test walidatora adresu e-mail z uyciem poprawnego adresu
  def test_email_with_valid_examples
    user = @valid_user
    valid_endings = %w{com org net edu es jp info}
    valid_emails = valid_endings.collect do |ending|
      "foo.bar_1-9@baz-quux0.example.#{ending}"
    end
    
    valid_emails.each do |email|
      user.email = email
      assert user.valid?, "#{email} musi by prawidowym adresem e-mail."
    end
  end

  # Test walidatora adresu e-mail z uyciem niepoprawnych adresw
  def test_email_with_invalid_examples
    user = @valid_user
    invalid_emails = %w{foobar@example.c @example.com f@com foo@bar..com
                        foobar@example.infod foobar.example.com
                        foo,@example.com foo@ex(ample.com foo@example,com}
    invalid_emails.each do |email|
      user.email = email
      assert !user.valid?, "#{email} jest uznawany za prawidowy, cho nie powinien."
      assert_equal " musi by prawidowym adresem e-mail.", user.errors.on(:email)
    end
  end

  def test_screen_name_with_valid_examples
    user = @valid_user
    valid_screen_names = %w{aure michael web_20}
    valid_screen_names.each do |screen_name|
      user.screen_name = screen_name
      assert user.valid?, "#{screen_name} powinien przej walidacj, a tak si nie dzieje."
    end
  end

  def test_screen_name_with_invalid_examples
    user = @valid_user
    invalid_screen_names = %w{rails/rocks web2.0 javscript:something}
    invalid_screen_names.each do |screen_name|
      user.screen_name = screen_name
      assert !user.valid?, "#{screen_name} nie powinien przej walidacji, a przechodzi."
    end
  end
end

