Class ValidationsTest < ActiveModel::TestCase

# File activemodel/test/cases/validations_test.rb, line 14
def setup
  Topic._validators.clear
end

# File activemodel/test/cases/validations_test.rb, line 20
def teardown
  Topic.reset_callbacks(:validate)
end

# File activemodel/test/cases/validations_test.rb, line 266
def test_accessing_instance_of_validator_on_an_attribute
  Topic.validates_length_of :title, :minimum => 10
  assert_equal 10, Topic.validators_on(:title).first.options[:minimum]
end

# File activeresource/test/cases/validations_test.rb, line 51
def test_client_side_validation_maximum
  project = Project.new(:description => '123456789012345')
  assert ! project.valid?
  assert_equal ['is too long (maximum is 10 characters)'], project.errors[:description]
end

# File activerecord/test/cases/validations_test.rb, line 110
def test_create_with_exceptions_using_scope_and_empty_attributes
  assert_nothing_raised do
    ProtectedPerson.send(:with_scope,  :create => { :first_name => "Mary" } ) do
      person = ProtectedPerson.create!
      assert_equal person.first_name, "Mary", "should be ok when no attributes are passed to create!"
    end
  end
end

# File activerecord/test/cases/validations_test.rb, line 101
def test_create_with_exceptions_using_scope_for_protected_attributes
  assert_nothing_raised do
    ProtectedPerson.send(:with_scope,  :create => { :first_name => "Mary" } ) do
      person = ProtectedPerson.create! :addon => "Addon"
      assert_equal person.first_name, "Mary", "scope should ignore attr_protected"
    end
  end
end

# File activerecord/test/cases/validations_test.rb, line 119
def test_create_without_validation
  reply = WrongReply.new
  assert !reply.save
  assert reply.save(:validate => false)
end

# File activemodel/test/cases/validations_test.rb, line 44
def test_double_attr_validation_and_error_msg
  r = Reply.new
  assert r.invalid?

  assert r.errors[:title].any?, "A reply without title should mark that attribute as invalid"
  assert_equal ["is Empty"], r.errors["title"], "A reply without title should contain an error"

  assert r.errors[:content].any?, "A reply without content should mark that attribute as invalid"
  assert_equal ["is Empty"], r.errors["content"], "A reply without content should contain an error"

  assert_equal 2, r.errors.count
end

# File activemodel/test/cases/validations_test.rb, line 358
def test_dup_call_parent_dup_when_include_validations
  book = Book.new
  book['title'] = "Litterature"
  book['author'] = "Foo"
  duped = book.dup

  assert_equal book.keys, duped.keys
  assert_equal book.values, duped.values
end

# File activemodel/test/cases/validations_test.rb, line 343
def test_dup_validity_is_independent
  Topic.validates_presence_of :title
  topic = Topic.new("title" => "Litterature")
  topic.valid?

  duped = topic.dup
  duped.title = nil
  assert duped.invalid?

  topic.title = nil
  duped.title = 'Mathematics'
  assert topic.invalid?
  assert duped.valid?
end

# File activerecord/test/cases/validations_test.rb, line 22
def test_error_on_create
  r = WrongReply.new
  r.title = "Wrong Create"
  assert !r.save
  assert r.errors[:title].any?, "A reply with a bad title should mark that attribute as invalid"
  assert_equal ["is Wrong Create"], r.errors[:title], "A reply with a bad content should contain an error"
end

# File activerecord/test/cases/validations_test.rb, line 43
def test_error_on_given_context
  r = WrongReply.new(:title => "Valid title")
  assert !r.valid?(:special_case)
  assert_equal "Invalid", r.errors[:author_name].join

  r.author_name = "secret"
  r.content = "Good"
  assert r.valid?(:special_case)

  r.author_name = nil
  assert !r.save(:context => :special_case)
  assert_equal "Invalid", r.errors[:author_name].join

  r.author_name = "secret"
  assert r.save(:context => :special_case)
end

# File activerecord/test/cases/validations_test.rb, line 30
def test_error_on_update
  r = WrongReply.new
  r.title = "Bad"
  r.content = "Good"
  assert r.save, "First save should be successful"

  r.title = "Wrong Update"
  assert !r.save, "Second save should fail"

  assert r.errors[:title].any?, "A reply with a bad title should mark that attribute as invalid"
  assert_equal ["is Wrong Update"], r.errors[:title], "A reply with a bad content should contain an error"
end

# File activemodel/test/cases/validations_test.rb, line 174
def test_errors_conversions
  Topic.validates_presence_of %w(title content)
  t = Topic.new
  assert t.invalid?

  xml = t.errors.to_xml
  assert_match %r{<errors>}, xml
  assert_match %r{<error>Title can't be blank</error>}, xml
  assert_match %r{<error>Content can't be blank</error>}, xml

  hash = ActiveSupport::OrderedHash.new
  hash[:title] = ["can't be blank"]
  hash[:content] = ["can't be blank"]
  assert_equal t.errors.to_json, hash.to_json
end

# File activemodel/test/cases/validations_test.rb, line 118
def test_errors_empty_after_errors_on_check
  t = Topic.new
  assert t.errors[:id].empty?
  assert t.errors.empty?
end

# File activemodel/test/cases/validations_test.rb, line 87
def test_errors_on_base
  r = Reply.new
  r.content = "Mismatch"
  r.valid?
  r.errors.add(:base, "Reply is not dignifying")

  errors = r.errors.to_a.inject([]) { |result, error| result + [error] }

  assert_equal ["Reply is not dignifying"], r.errors[:base]

  assert errors.include?("Title is Empty")
  assert errors.include?("Reply is not dignifying")
  assert_equal 2, r.errors.count
end

# File activemodel/test/cases/validations_test.rb, line 102
def test_errors_on_base_with_symbol_message
  r = Reply.new
  r.content = "Mismatch"
  r.valid?
  r.errors.add(:base, :invalid)

  errors = r.errors.to_a.inject([]) { |result, error| result + [error] }

  assert_equal ["is invalid"], r.errors[:base]

  assert errors.include?("Title is Empty")
  assert errors.include?("is invalid")

  assert_equal 2, r.errors.count
end

# File activemodel/test/cases/validations_test.rb, line 81
def test_errors_on_nested_attributes_expands_name
  t = Topic.new
  t.errors["replies.name"] << "can't be blank"
  assert_equal ["Replies name can't be blank"], t.errors.full_messages
end

# File activerecord/test/cases/validations_test.rb, line 73
def test_exception_on_create_bang_many
  assert_raise(ActiveRecord::RecordInvalid) do
    WrongReply.create!([ { "title" => "OK" }, { "title" => "Wrong Create" }])
  end
end

# File activerecord/test/cases/validations_test.rb, line 87
def test_exception_on_create_bang_many_with_block
  assert_raise(ActiveRecord::RecordInvalid) do
    WrongReply.create!([{ "title" => "OK" }, { "title" => "Wrong Create" }]) do |r|
      r.content = nil
    end
  end
end

# File activerecord/test/cases/validations_test.rb, line 79
def test_exception_on_create_bang_with_block
  assert_raise(ActiveRecord::RecordInvalid) do
    WrongReply.create!({ "title" => "OK" }) do |r|
      r.content = nil
    end
  end
end

# File activeresource/test/cases/validations_test.rb, line 28
def test_fails_save!
  p = new_project(:name => nil)
  assert_raise(ActiveResource::ResourceInvalid) { p.save! }
end

# File activerecord/test/cases/validations_test.rb, line 60
def test_invalid_record_exception
  assert_raise(ActiveRecord::RecordInvalid) { WrongReply.create! }
  assert_raise(ActiveRecord::RecordInvalid) { WrongReply.new.save! }

  begin
    r = WrongReply.new
    r.save!
    flunk
  rescue ActiveRecord::RecordInvalid => invalid
    assert_equal r, invalid.record
  end
end

# File activemodel/test/cases/validations_test.rb, line 229
def test_invalid_should_be_the_opposite_of_valid
  Topic.validates_presence_of :title

  t = Topic.new
  assert t.invalid?
  assert t.errors[:title].any?

  t.title = 'Things are going to change'
  assert !t.invalid?
end

# File activemodel/test/cases/validations_test.rb, line 166
def test_invalid_validator
  Topic.validate :i_dont_exist
  assert_raise(NameError) do
    t = Topic.new
    t.valid?
  end
end

# File activemodel/test/cases/validations_test.rb, line 248
def test_list_of_validators_for_model
  Topic.validates_presence_of :title
  Topic.validates_length_of :title, :minimum => 2

  assert_equal 2, Topic.validators.count
  assert_equal [:presence, :length], Topic.validators.map(&:kind)
end

# File activemodel/test/cases/validations_test.rb, line 256
def test_list_of_validators_on_an_attribute
  Topic.validates_presence_of :title, :content
  Topic.validates_length_of :title, :minimum => 2

  assert_equal 2, Topic.validators_on(:title).count
  assert_equal [:presence, :length], Topic.validators_on(:title).map(&:kind)
  assert_equal 1, Topic.validators_on(:content).count
  assert_equal [:presence], Topic.validators_on(:content).map(&:kind)
end

# File activemodel/test/cases/validations_test.rb, line 271
def test_list_of_validators_on_multiple_attributes
  Topic.validates :title, :length => { :minimum => 10 }
  Topic.validates :author_name, :presence => true, :format => /a/

  validators = Topic.validators_on(:title, :author_name)

  assert_equal [
    ActiveModel::Validations::FormatValidator,
    ActiveModel::Validations::LengthValidator,
    ActiveModel::Validations::PresenceValidator
  ], validators.map { |v| v.class }.sort_by { |c| c.to_s }
end

# File activemodel/test/cases/validations_test.rb, line 284
def test_list_of_validators_will_be_empty_when_empty
  Topic.validates :title, :length => { :minimum => 10 }
  assert_equal [], Topic.validators_on(:author_name)
end

# File activemodel/test/cases/validations_test.rb, line 68
def test_multiple_errors_per_attr_iteration_with_full_error_composition
  r = Reply.new
  r.title   = ""
  r.content = ""
  r.valid?

  errors = r.errors.to_a

  assert_equal "Content is Empty", errors[0]
  assert_equal "Title is Empty", errors[1]
  assert_equal 2, r.errors.count
end

# File activeresource/test/cases/validations_test.rb, line 33
def test_save_without_validation
  p = new_project(:name => nil)
  assert !p.save
  assert p.save(:validate => false)
end

# File activerecord/test/cases/validations_test.rb, line 95
def test_scoped_create_without_attributes
  WrongReply.send(:with_scope, :create => {}) do
    assert_raise(ActiveRecord::RecordInvalid) { WrongReply.create! }
  end
end

# File activemodel/test/cases/validations_test.rb, line 35
def test_single_attr_validation_and_error_msg
  r = Reply.new
  r.title = "There's no content!"
  assert r.invalid?
  assert r.errors[:content].any?, "A reply without content should mark that attribute as invalid"
  assert_equal ["is Empty"], r.errors["content"], "A reply without content should contain an error"
  assert_equal 1, r.errors.count
end

# File activemodel/test/cases/validations_test.rb, line 57
def test_single_error_per_attr_iteration
  r = Reply.new
  r.valid?

  errors = []
  r.errors.each {|attr, messages| errors << [attr.to_s, messages] }

  assert errors.include?(["title", "is Empty"])
  assert errors.include?(["content", "is Empty"])
end

# File activemodel/test/cases/validations_test.rb, line 24
def test_single_field_validation
  r = Reply.new
  r.title = "There's no content!"
  assert r.invalid?, "A reply without content shouldn't be saveable"
  assert r.after_validation_performed, "after_validation callback should be called"

  r.content = "Messa content!"
  assert r.valid?, "A reply with content should be saveable"
  assert r.after_validation_performed, "after_validation callback should be called"
end

# File activemodel/test/cases/validations_test.rb, line 334
def test_strict_validation_error_message
  Topic.validates :title, :strict => true, :presence => true

  exception = assert_raises(ActiveModel::StrictValidationFailed) do
    Topic.new.valid?
  end
  assert_equal "Title can't be blank", exception.message
end

# File activemodel/test/cases/validations_test.rb, line 320
def test_strict_validation_in_custom_validator_helper
  Topic.validates_presence_of :title, :strict => true
  assert_raises ActiveModel::StrictValidationFailed do
    Topic.new.valid?
  end
end

# File activemodel/test/cases/validations_test.rb, line 301
def test_strict_validation_in_validates
  Topic.validates :title, :strict => true, :presence => true
  assert_raises ActiveModel::StrictValidationFailed do
    Topic.new.valid?
  end
end

# File activemodel/test/cases/validations_test.rb, line 308
def test_strict_validation_not_fails
  Topic.validates :title, :strict => true, :presence => true
  assert Topic.new(:title => "hello").valid?
end

# File activemodel/test/cases/validations_test.rb, line 313
def test_strict_validation_particular_validator
  Topic.validates :title,  :presence => { :strict => true }
  assert_raises ActiveModel::StrictValidationFailed do
    Topic.new.valid?
  end
end

# File activerecord/test/cases/validations_test.rb, line 133
def test_throw_away_typing
  d = Developer.new("name" => "David", "salary" => "100,000")
  assert !d.valid?
  assert_equal 100, d.salary
  assert_equal "100,000", d.salary_before_type_cast
end

# File activemodel/test/cases/validations_test.rb, line 150
def test_validate_block
  Topic.validate { errors.add("title", "will never be valid") }
  t = Topic.new("title" => "Title", "content" => "whatever")
  assert t.invalid?
  assert t.errors[:title].any?
  assert_equal ["will never be valid"], t.errors["title"]
end

# File activemodel/test/cases/validations_test.rb, line 158
def test_validate_block_with_params
  Topic.validate { |topic| topic.errors.add("title", "will never be valid") }
  t = Topic.new("title" => "Title", "content" => "whatever")
  assert t.invalid?
  assert t.errors[:title].any?
  assert_equal ["will never be valid"], t.errors["title"]
end

# File activeresource/test/cases/validations_test.rb, line 39
def test_validate_callback
  # we have a callback ensuring the description is longer than three letters
  p = new_project(:description => 'a')
  assert !p.valid?, "should not be a valid record when it fails a validation callback"
  assert !p.save, "should not have saved an invalid record"
  assert_equal ["must be greater than three letters long"], p.errors[:description], "should be an error on description"

  # should now allow this description
  p.description = 'abcd'
  assert p.save, "should have saved after fixing the validation, but had: #{p.errors.inspect}"
end

# File activerecord/test/cases/validations_test.rb, line 140
def test_validates_acceptance_of_as_database_column
  Topic.validates_acceptance_of(:approved)
  topic = Topic.create("approved" => true)
  assert topic["approved"]
end

# File activerecord/test/cases/validations_test.rb, line 125
def test_validates_acceptance_of_with_non_existant_table
  Object.const_set :IncorporealModel, Class.new(ActiveRecord::Base)

  assert_nothing_raised ActiveRecord::StatementInvalid do
    IncorporealModel.validates_acceptance_of(:incorporeal_column)
  end
end

# File activemodel/test/cases/validations_test.rb, line 124
def test_validates_each
  hits = 0
  Topic.validates_each(:title, :content, [:title, :content]) do |record, attr|
    record.errors.add attr, 'gotcha'
    hits += 1
  end
  t = Topic.new("title" => "valid", "content" => "whatever")
  assert t.invalid?
  assert_equal 4, hits
  assert_equal %w(gotcha gotcha), t.errors[:title]
  assert_equal %w(gotcha gotcha), t.errors[:content]
end

# File activemodel/test/cases/validations_test.rb, line 137
def test_validates_each_custom_reader
  hits = 0
  CustomReader.validates_each(:title, :content, [:title, :content]) do |record, attr|
    record.errors.add attr, 'gotcha'
    hits += 1
  end
  t = CustomReader.new("title" => "valid", "content" => "whatever")
  assert t.invalid?
  assert_equal 4, hits
  assert_equal %w(gotcha gotcha), t.errors[:title]
  assert_equal %w(gotcha gotcha), t.errors[:content]
end

# File activeresource/test/cases/validations_test.rb, line 17
def test_validates_presence_of
  p = new_project(:name => nil)
  assert !p.valid?, "should not be a valid record without name"
  assert !p.save, "should not have saved an invalid record"
  assert_equal ["can't be blank"], p.errors[:name], "should have an error on name"

  p.name = "something"

  assert p.save, "should have saved after fixing the validation, but had: #{p.errors.inspect}"
end

# File activemodel/test/cases/validations_test.rb, line 327
def test_validates_with_bang
  Topic.validates! :title,  :presence => true
  assert_raises ActiveModel::StrictValidationFailed do
    Topic.new.valid?
  end
end

# File activemodel/test/cases/validations_test.rb, line 190
def test_validation_order
  Topic.validates_presence_of :title
  Topic.validates_length_of :title, :minimum => 2

  t = Topic.new("title" => "")
  assert t.invalid?
  assert_equal "can't be blank", t.errors["title"].first
  Topic.validates_presence_of :title, :author_name
  Topic.validate {errors.add('author_email_address', 'will never be valid')}
  Topic.validates_length_of :title, :content, :minimum => 2

  t = Topic.new :title => ''
  assert t.invalid?

  assert_equal :title, key = t.errors.keys[0]
  assert_equal "can't be blank", t.errors[key][0]
  assert_equal 'is too short (minimum is 2 characters)', t.errors[key][1]
  assert_equal :author_name, key = t.errors.keys[1]
  assert_equal "can't be blank", t.errors[key][0]
  assert_equal :author_email_address, key = t.errors.keys[2]
  assert_equal 'will never be valid', t.errors[key][0]
  assert_equal :content, key = t.errors.keys[3]
  assert_equal 'is too short (minimum is 2 characters)', t.errors[key][0]
end

# File activemodel/test/cases/validations_test.rb, line 240
def test_validation_with_message_as_proc
  Topic.validates_presence_of(:title, :message => proc { "no blanks here".upcase })

  t = Topic.new
  assert t.invalid?
  assert_equal ["NO BLANKS HERE"], t.errors[:title]
end

# File activemodel/test/cases/validations_test.rb, line 289
def test_validations_on_the_instance_level
  auto = Automobile.new

  assert          auto.invalid?
  assert_equal 2, auto.errors.size

  auto.make  = 'Toyota'
  auto.model = 'Corolla'

  assert auto.valid?
end

# File activemodel/test/cases/validations_test.rb, line 215
def test_validaton_with_if_and_on
  Topic.validates_presence_of :title, :if => Proc.new{|x| x.author_name = "bad"; true }, :on => :update

  t = Topic.new(:title => "")

  # If block should not fire
  assert t.valid?
  assert t.author_name.nil?

  # If block should fire
  assert t.invalid?(:update)
  assert t.author_name == "bad"
end

# File activerecord/test/cases/validations_test.rb, line 146
def test_validators
  assert_equal 1, Parrot.validators.size
  assert_equal 1, Company.validators.size
  assert_equal 1, Parrot.validators_on(:name).size
  assert_equal 1, Company.validators_on(:name).size
end

# File activeresource/test/cases/validations_test.rb, line 62
def new_project(opts = {})
  Project.new(VALID_PROJECT_HASH.merge(opts))
end