client_side_validations 3.1.5 → 3.2.0.beta.1

data/test/active_model/cases/test_numericality_validator.rb

@@ -1,46 +0,0 @@
-require 'active_model/cases/test_base'
-
-class ActiveModel::NumericalityValidatorTest < ClientSideValidations::ActiveModelTestBase
-
-  def test_numericality_client_side_hash
-    expected_hash = { :messages => { :numericality => "is not a number" } }
-    assert_equal expected_hash, NumericalityValidator.new(:attributes => [:age]).client_side_hash(@person, :age)
-  end
-
-  def test_numericality_client_side_hash_with_custom_message
-    expected_hash = { :messages => { :numericality => "bad number" } }
-    assert_equal expected_hash, NumericalityValidator.new(:attributes => [:age], :message => "bad number").client_side_hash(@person, :age)
-  end
-
-  def test_numericality_client_side_hash_with_options
-    expected_hash = {
-      :messages => {
-        :numericality => "is not a number",
-        :only_integer => "must be an integer",
-        :greater_than => "must be greater than 10",
-        :greater_than_or_equal_to => "must be greater than or equal to 10",
-        :equal_to => "must be equal to 10",
-        :less_than => "must be less than 10",
-        :less_than_or_equal_to => "must be less than or equal to 10",
-        :odd => "must be odd",
-        :even => "must be even"
-      },
-      :only_integer => true,
-      :greater_than => 10,
-      :greater_than_or_equal_to => 10,
-      :equal_to => 10,
-      :less_than => 10,
-      :less_than_or_equal_to => 10,
-      :odd => true,
-      :even => true
-    }
-    test_hash = NumericalityValidator.new(:attributes => [:age],
-      :only_integer => true, :greater_than => 10, :greater_than_or_equal_to => 10,
-      :equal_to => 10, :less_than => 10, :less_than_or_equal_to => 10,
-      :odd => true, :even => true).client_side_hash(@person, :age)
-
-    assert_equal expected_hash, test_hash
-  end
-
-end
-

data/test/active_model/cases/test_presence_validator.rb

@@ -1,16 +0,0 @@
-require 'active_model/cases/test_base'
-
-class ActiveModel::PresenceValidatorTest < ClientSideValidations::ActiveModelTestBase
-
-  def test_presence_client_side_hash
-    expected_hash = { :message => "can't be blank" }
-    assert_equal expected_hash, PresenceValidator.new(:attributes => [:name]).client_side_hash(@person, :age)
-  end
-
-  def test_presence_client_side_hash_with_custom_message
-    expected_hash = { :message => "is required" }
-    assert_equal expected_hash, PresenceValidator.new(:attributes => [:name], :message => "is required").client_side_hash(@person, :age)
-  end
-
-end
-

data/test/active_model/cases/test_validations.rb

@@ -1,175 +0,0 @@
-require 'active_model/cases/test_base'
-
-class ActiveModel::ValidationsTest < ClientSideValidations::ActiveModelTestBase
-
-  class Person
-    include ::ActiveModel::Validations
-    attr_accessor :first_name, :last_name, :age, :weight
-
-    def self.name
-      "Person"
-    end
-
-    def new_record?
-      true
-    end
-  end
-
-  def new_person
-    person = Class.new(Person)
-    yield(person)
-    person.new
-  end
-
-  def test_validations_to_client_side_hash
-    person = new_person do |p|
-      p.validates_presence_of :first_name
-    end
-    expected_hash = {
-      :first_name => {
-        :presence => {
-          :message => "can't be blank"
-        }
-      }
-    }
-    assert_equal expected_hash, person.client_side_validation_hash
-  end
-
-  def test_validations_to_client_side_hash_with_validations_allow_blank
-    person = new_person do |p|
-      p.validates_length_of :first_name, :is => 10, :allow_blank => true
-      p.validates_format_of :first_name, :with => //, :allow_blank => true
-    end
-    expected_hash = {
-      :first_name => {
-        :length => {
-          :messages => { :is => 'is the wrong length (should be 10 characters)'},
-          :is => 10,
-          :allow_blank => true
-        },
-        :format => {
-          :message => 'is invalid',
-          :with => //,
-          :allow_blank => true
-        }
-      }
-    }
-    assert_equal expected_hash, person.client_side_validation_hash
-  end
-
-  def test_validations_to_client_side_hash_with_validations_on_create
-    person = new_person do |p|
-      p.validates_length_of :first_name, :is => 10, :on => :create
-      p.validates_length_of :last_name, :is => 10, :on => :update
-      p.validates_format_of :first_name, :with => //, :on => :update
-      p.validates_format_of :last_name, :with => //, :on => :create
-      p.validates_numericality_of :age, :on => :create
-      p.validates_numericality_of :weight, :on => :update
-      p.class_eval do
-        def new_record?
-          true
-        end
-      end
-    end
-    expected_hash = {
-      :first_name => {
-        :length => {
-          :messages => { :is => 'is the wrong length (should be 10 characters)'},
-          :is => 10,
-        },
-      },
-      :last_name => {
-        :format => {
-          :message => 'is invalid',
-          :with => //,
-        }
-      },
-      :age => {
-        :numericality => {
-          :messages => { :numericality => 'is not a number' },
-        }
-      }
-    }
-    assert_equal expected_hash, person.client_side_validation_hash
-  end
-
-  def test_validations_to_client_side_hash_with_validations_on_update
-    person = new_person do |p|
-      p.validates_length_of :first_name, :is => 10, :on => :update
-      p.validates_length_of :last_name, :is => 10, :on => :create
-      p.validates_format_of :first_name, :with => //, :on => :create
-      p.validates_format_of :last_name, :with => //, :on => :update
-      p.validates_numericality_of :age, :on => :update
-      p.validates_numericality_of :weight, :on => :create
-      p.class_eval do
-        def new_record?
-          false
-        end
-      end
-    end
-    expected_hash = {
-      :first_name => {
-        :length => {
-          :messages => { :is => 'is the wrong length (should be 10 characters)'},
-          :is => 10,
-        },
-      },
-      :last_name => {
-        :format => {
-          :message => 'is invalid',
-          :with => //,
-        }
-      },
-      :age => {
-        :numericality => {
-          :messages => { :numericality => 'is not a number' },
-        }
-      }
-    }
-    assert_equal expected_hash, person.client_side_validation_hash
-  end
-
-  def test_validates_with_should_be_ignored
-    person = new_person do |p|
-      p.validates_with PersonValidator
-    end
-
-    expected_hash = {}
-    assert_equal expected_hash, person.client_side_validation_hash
-  end
-
-  def test_generic_block_validators_should_be_ignored
-    person = new_person do |p|
-      p.validates_each(:first_name) do |record, attr, value|
-        record.errors.add(:first_name, "failed")
-      end
-    end
-
-    expected_hash = {}
-    assert_equal expected_hash, person.client_side_validation_hash
-  end
-
-  def test_conditionals_persist_on_validator
-    person = new_person do |p|
-      p.validates :first_name, :presence => { :if => :can_validate? }
-      p.validates :last_name, :presence => { :unless => :cannot_validate? }
-    end
-
-    expected_hash = {
-      :first_name => {
-        :presence => {
-          :message => "can't be blank",
-          :if => :can_validate?
-        }
-      },
-      :last_name => {
-        :presence => {
-          :message => "can't be blank",
-          :unless => :cannot_validate?
-        }
-      }
-    }
-    assert_equal expected_hash, person.client_side_validation_hash
-  end
-end
-

data/test/active_model/models/person.rb

@@ -1,17 +0,0 @@
-class PersonValidator < ActiveModel::Validator
-  def validate(record)
-  end
-end
-
-class Person
-  include ActiveModel::Validations
-
-  attr_accessor :first_name, :last_name, :email, :age
-
-  validates_presence_of :first_name
-  validates_format_of :email, :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i
-
-  def new_record?
-    true
-  end
-end

data/test/active_record/cases/helper.rb

@@ -1,12 +0,0 @@
-require 'base_helper'
-require 'active_record'
-require 'client_side_validations/active_record'
-
-# Connection must be establised before anything else
-ActiveRecord::Base.establish_connection(
-  :adapter => defined?(JRUBY_VERSION) ? 'jdbcsqlite3' : 'sqlite3',
-  :database => ':memory:'
-)
-
-require 'active_record/models/user'
-require 'active_record/models/guid'

data/test/active_record/cases/test_base.rb

@@ -1,11 +0,0 @@
-require 'active_record/cases/helper'
-
-class ClientSideValidations::ActiveRecordTestBase < ActiveRecord::TestCase
-  include ActiveRecord::Validations
-
-  def setup
-    @user = User.new
-  end
-
-end
-

data/test/active_record/cases/test_middleware.rb

@@ -1,175 +0,0 @@
-# encoding: utf-8
-
-require 'middleware/cases/helper'
-require 'active_record/cases/helper'
-
-class ClientSideValidationsActiveRecordMiddlewareTest < Test::Unit::TestCase
-  include Rack::Test::Methods
-
-  def teardown
-    User.delete_all
-  end
-
-  def with_kcode(kcode)
-    if RUBY_VERSION < '1.9'
-      orig_kcode, $KCODE = $KCODE, kcode
-      begin
-        yield
-      ensure
-        $KCODE = orig_kcode
-      end
-    else
-      yield
-    end
-  end
-
-  def app
-    app = Proc.new { |env| [200, {}, ['success']] }
-    ClientSideValidations::Middleware::Validators.new(app)
-  end
-
-  def test_uniqueness_when_resource_exists
-    User.create(:email => 'user@test.com')
-    get '/validators/uniqueness', { 'user[email]' => 'user@test.com', 'case_sensitive' => true }
-
-    assert_equal 'false', last_response.body
-    assert last_response.ok?
-  end
-
-  def test_uniqueness_when_resource_exists_and_param_order_is_backwards
-    User.create(:email => 'user@test.com')
-    get '/validators/uniqueness', { 'case_sensitive' => true, 'user[email]' => 'user@test.com' }
-
-    assert_equal 'false', last_response.body
-    assert last_response.ok?
-  end
-
-  def test_uniqueness_when_resource_does_not_exist
-    get '/validators/uniqueness', { 'user[email]' => 'user@test.com', 'case_sensitive' => true }
-
-    assert_equal 'true', last_response.body
-    assert last_response.not_found?
-  end
-
-  def test_uniqueness_when_id_is_given
-    user = User.create(:email => 'user@test.com')
-    get '/validators/uniqueness', { 'user[email]' => 'user@test.com', 'id' => user.id, 'case_sensitive' => true }
-
-    assert_equal 'true', last_response.body
-    assert last_response.not_found?
-  end
-
-  def test_mysql_adapter_uniqueness_when_id_is_given
-    user = User.create(:email => 'user@test.com')
-    ActiveRecord::ConnectionAdapters::SQLite3Adapter.
-                                        any_instance.expects(:instance_variable_get).
-                                        with("@config").
-                                        returns({:adapter => "mysql"})
-
-    sql_without_binary = "#{User.arel_table["email"].eq(user.email).to_sql} AND #{User.arel_table.primary_key.not_eq(user.id).to_sql}"
-    relation = Arel::Nodes::SqlLiteral.new("BINARY #{sql_without_binary}")
-
-    #NOTE: Stubs User#where because SQLite3 don't know BINARY
-    result = User.where(sql_without_binary)
-    User.expects(:where).with(relation).returns(result)
-
-    get '/validators/uniqueness', { 'user[email]' => user.email, 'case_sensitive' => true, 'id' => user.id}
-    assert_equal 'true', last_response.body
-  end
-
-  def test_uniqueness_when_scope_is_given
-    User.create(:email => 'user@test.com', :age => 25)
-    get '/validators/uniqueness', { 'user[email]' => 'user@test.com', 'scope' => { 'age' => 30 }, 'case_sensitive' => true }
-
-    assert_equal 'true', last_response.body
-    assert last_response.not_found?
-  end
-
-  def test_uniqueness_when_multiple_scopes_are_given
-    User.create(:email => 'user@test.com', :age => 30, :name => 'Brian')
-    get '/validators/uniqueness', { 'user[email]' => 'user@test.com', 'scope' => { 'age' => 30, 'name' => 'Robert' }, 'case_sensitive' => true }
-
-    assert_equal 'true', last_response.body
-    assert last_response.not_found?
-  end
-
-  def test_uniqueness_when_case_insensitive
-    User.create(:name => 'Brian')
-    get '/validators/uniqueness', { 'user[name]' => 'BRIAN', 'case_sensitive' => false }
-
-    assert_equal 'false', last_response.body
-    assert last_response.ok?
-  end
-
-  def test_uniqueness_when_attribute_passes_as_an_integer
-    User.create(:name => 123)
-    get '/validators/uniqueness', { 'user[name]' => 123, 'case_sensitive' => true }
-
-    assert_equal 'false', last_response.body
-    assert last_response.ok?
-  end
-
-  def test_uniqueness_when_attribute_passes_as_an_integer
-    User.create(:name => 123)
-    get '/validators/uniqueness', { 'user[name]' => 123, 'case_sensitive' => true }
-
-    assert_equal 'false', last_response.body
-    assert last_response.ok?
-  end
-
-  def test_uniqueness_with_columns_which_are_sql_keywords
-    Guid.validates_uniqueness_of :key
-    assert_nothing_raised do
-      get '/validators/uniqueness', { 'guid[key]' => 'test', 'case_sensitive' => true }
-    end
-  end
-
-  def test_uniqueness_with_limit
-    # User.title is limited to 5 characters
-    User.create(:title => "abcde")
-    get '/validators/uniqueness', { 'user[title]' => 'abcdefgh', 'case_sensitive' => true }
-
-    assert_equal 'false', last_response.body
-    assert last_response.ok?
-  end
-
-  def test_uniqueness_with_limit_and_utf8
-    with_kcode('UTF8') do
-      # User.title is limited to 5 characters
-      User.create(:title => "一二三四五")
-      get '/validators/uniqueness', { 'user[title]' => '一二三四五六七八', 'case_sensitive' => true }
-
-      assert_equal 'false', last_response.body
-    assert last_response.ok?
-    end
-  end
-
-  def test_validate_straight_inheritance_uniqueness
-    get '/validators/uniqueness', { 'inept_wizard[name]' => 'Rincewind', 'case_sensitive' => true }
-    assert_equal 'true', last_response.body
-    assert last_response.not_found?
-
-    IneptWizard.create(:name => 'Rincewind')
-    get '/validators/uniqueness', { 'inept_wizard[name]' => 'Rincewind', 'case_sensitive' => true }
-    assert_equal 'false', last_response.body
-    assert last_response.ok?
-
-    get '/validators/uniqueness', { 'conjurer[name]' => 'Rincewind', 'case_sensitive' => true }
-    assert_equal 'false', last_response.body
-    assert last_response.ok?
-
-    Conjurer.create(:name => 'The Amazing Bonko')
-    get '/validators/uniqueness', { 'thaumaturgist[name]' => 'The Amazing Bonko', 'case_sensitive' => true }
-    assert_equal 'false', last_response.body
-    assert last_response.ok?
-  end
-
-  def test_uniqueness_when_resource_is_a_nested_module
-    ActiveRecordTestModule::User2.create(:email => 'user@test.com')
-    get '/validators/uniqueness', { 'active_record_test_module/user2[email]' => 'user@test.com', 'case_sensitive' => true }
-
-    assert_equal 'false', last_response.body
-    assert last_response.ok?
-  end
-end
-