af-client_side_validations 3.1.4.af1

data/test/active_model/cases/test_validations.rb

@@ -0,0 +1,175 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,175 @@
+# 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
+

data/test/active_record/cases/test_uniqueness_validator.rb

@@ -0,0 +1,50 @@
+require 'active_record/cases/test_base'
+
+class ActiveRecord::UniquenessValidatorTest < ClientSideValidations::ActiveRecordTestBase
+
+  def test_uniqueness_client_side_hash
+    expected_hash = { :message => "has already been taken", :case_sensitive => true }
+    assert_equal expected_hash, UniquenessValidator.new(:attributes => [:name]).client_side_hash(@user, :name)
+  end
+
+  def test_uniqueness_client_side_hash_with_custom_message
+    expected_hash = { :message => "is not available", :case_sensitive => true }
+    assert_equal expected_hash, UniquenessValidator.new(:attributes => [:name], :message => "is not available").client_side_hash(@user, :name)
+  end
+
+  def test_uniqueness_client_side_hash
+    @user.stubs(:new_record?).returns(false)
+    @user.stubs(:id).returns(1)
+    expected_hash = { :message => "has already been taken", :case_sensitive => true, :id => 1 }
+    assert_equal expected_hash, UniquenessValidator.new(:attributes => [:name]).client_side_hash(@user, :name)
+  end
+
+  def test_uniqueness_client_side_hash_with_single_scope_item
+    @user.stubs(:age).returns(30)
+    @user.stubs(:title).returns("test title")
+    expected_hash = { :message => "has already been taken", :case_sensitive => true, :scope => {:title => "test title"} }
+    result_hash = UniquenessValidator.new(:attributes => [:name], :scope => :title).client_side_hash(@user, :name)
+    assert_equal expected_hash, result_hash
+  end
+
+  def test_uniqueness_client_side_hash_with_multiple_scope_items
+    @user.stubs(:age).returns(30)
+    @user.stubs(:title).returns("test title")
+    expected_hash = { :message => "has already been taken", :case_sensitive => true, :scope => {:age => 30, :title => "test title"} }
+    result_hash = UniquenessValidator.new(:attributes => [:name], :scope => [:age, :title]).client_side_hash(@user, :name)
+    assert_equal expected_hash, result_hash
+  end
+
+  def test_uniqueness_client_side_hash_with_empty_scope_array
+    expected_hash = { :message => "has already been taken", :case_sensitive => true }
+    result_hash = UniquenessValidator.new(:attributes => [:name], :scope => []).client_side_hash(@user, :name)
+    assert_equal expected_hash, result_hash
+  end
+
+  def test_uniqueness_client_side_hash_when_nested_module
+    @user = ActiveRecordTestModule::User2.new
+    expected_hash = { :message => "has already been taken", :case_sensitive => true, :class => 'active_record_test_module/user2' }
+    assert_equal expected_hash, UniquenessValidator.new(:attributes => [:name]).client_side_hash(@user, :name)
+  end
+end
+

data/test/active_record/models/guid.rb

@@ -0,0 +1,7 @@
+guids_table = %{CREATE TABLE guids (id INTEGER PRIMARY KEY, key text);}
+ActiveRecord::Base.connection.execute(guids_table)
+
+class Guid < ActiveRecord::Base
+
+end
+

data/test/active_record/models/user.rb

@@ -0,0 +1,14 @@
+users_table = %{CREATE TABLE users (id INTEGER PRIMARY KEY, age INTEGER, name TEXT, email TEXT, title VARCHAR(5));}
+ActiveRecord::Base.connection.execute(users_table)
+
+class User < ActiveRecord::Base
+
+end
+
+class IneptWizard < User; end
+class Conjurer < IneptWizard; end
+class Thaumaturgist < Conjurer; end
+
+module ActiveRecordTestModule
+  class User2 < User; end
+end

data/test/base_helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+require 'test/unit'
+require 'mocha'
+
+module ClientSideValidations; end

data/test/core_ext/cases/test_core_ext.rb

@@ -0,0 +1,46 @@
+require 'base_helper'
+require 'client_side_validations/core_ext'
+
+class CoreExtTest < Test::Unit::TestCase
+  def test_regexp_as_json
+    regexp = //
+    assert_equal regexp, regexp.as_json
+  end
+
+  def test_regexp_replace_A_and_Z
+    test_regexp = /\A\Z/
+    expected_regexp = /^$/
+    assert_equal expected_regexp, test_regexp.as_json
+  end
+
+  def test_regexp_replace_a_and_z
+    test_regexp = /\A\z/
+    expected_regexp = /^$/
+    assert_equal expected_regexp, test_regexp.as_json
+  end
+
+  def test_regexp_to_json
+    assert_equal "/^$/", /\A\Z/.to_json(nil)
+  end
+
+  def test_regexp_encode_json
+    assert_equal "//", //.encode_json(nil)
+  end
+
+  def test_regexp_as_jason_with_options
+    assert_equal //i, //i.as_json
+  end
+
+  def test_range_as_json
+    assert_equal [1,3], (1..3).as_json
+  end
+
+  def test_range_to_json
+    assert_equal '[1, 3]', (1..3).to_json(nil)
+  end
+
+  def test_range_as_json_with_floats
+    assert_equal [0.5,5.5], (0.5..5.5).as_json
+  end
+end
+

data/test/formtastic/cases/helper.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+require 'active_support'
+require 'formtastic/railtie' if defined?(::Rails)
+require 'formtastic/engine' if defined?(::Rails)
+require 'formtastic'
+require 'client_side_validations/formtastic'
+

data/test/formtastic/cases/test_form_builder.rb

@@ -0,0 +1,11 @@
+require 'formtastic/cases/helper'
+
+class ClientSideValidations::Formtastic::FormBuilderTest < Test::Unit::TestCase
+  def test_client_side_form_js_hash
+    expected = {
+      :type => 'Formtastic::FormBuilder',
+      :inline_error_class => 'inline-errors'
+    }
+    assert_equal expected, Formtastic::FormBuilder.client_side_form_settings(nil, nil)
+  end
+end

data/test/formtastic/cases/test_form_helper.rb

@@ -0,0 +1,21 @@
+require 'action_view/cases/helper'
+require 'formtastic/cases/helper'
+
+class ClientSideValidations::Formtastic::FormHelperTest < ActionView::TestCase
+  include ActionViewTestSetup
+  include Formtastic::Helpers::FormHelper
+
+  def client_side_form_settings_helper
+    ""
+  end
+
+  def test_semantic_form_for
+    semantic_form_for(@post, :validate => true) do |f|
+      concat f.input(:cost)
+    end
+
+    expected = %{<form accept-charset="UTF-8" action="/posts/123" class="formtastic post" data-validate="true" id="edit_post_123" method="post" novalidate="novalidate"><div style="margin:0;padding:0;display:inline"><input name="utf8" type="hidden" value="&#x2713;" /><input name="_method" type="hidden" value="put" /></div><li class="string input required stringish" id="post_cost_input"><label class=\" label\" for="post_cost">Cost<abbr title="required">*</abbr></label><input data-validate="true" id="post_cost" name="post[cost]" type="text" />\n\n</li></form><script>window['edit_post_123'] = {"type":"Formtastic::FormBuilder","inline_error_class":"inline-errors","validators":{"post[cost]":{"presence":{"message":"can't be blank"}}}};</script>}
+    assert_equal expected, output_buffer, "\n\n *** If you're running Ruby 1.8 and this test fails is is most likely due to 1.8's lack of insertion order persistence with Hashes ***\n"
+  end
+
+end

data/test/generators/cases/test_generators.rb

@@ -0,0 +1,70 @@
+require 'rails/generators/test_case'
+require 'generators/client_side_validations/install_generator'
+require 'generators/client_side_validations/copy_asset_generator'
+
+class InstallGeneratorTest < Rails::Generators::TestCase
+  tests ClientSideValidations::Generators::InstallGenerator
+  destination File.expand_path('../../tmp', __FILE__)
+  setup :prepare_destination
+
+  test 'Assert all files are properly created when no asset pipeline present' do
+    stub_configuration
+    run_generator
+    assert_file 'config/initializers/client_side_validations.rb'
+    assert_file 'public/javascripts/rails.validations.js'
+  end
+
+  test 'Assert all files are properly created when asset pipeline present and disabled' do
+    stub_configuration
+    Rails.configuration.stubs(:assets).returns({})
+    Rails.configuration.assets[:enabled] = false
+    run_generator
+    assert_file 'config/initializers/client_side_validations.rb'
+    assert_file 'public/javascripts/rails.validations.js'
+  end
+
+  test 'Assert all files are properly created when asset pipeline present and enabled' do
+    stub_configuration
+    Rails.configuration.stubs(:assets).returns({})
+    Rails.configuration.assets[:enabled] = true
+    run_generator
+    assert_file 'config/initializers/client_side_validations.rb'
+  end
+
+  def stub_configuration
+    Rails.stubs(:configuration).returns(mock('Configuration'))
+  end
+end
+
+class CopyAssetGeneratorTest < Rails::Generators::TestCase
+  tests ClientSideValidations::Generators::CopyAssetGenerator
+  destination File.expand_path('../../tmp', __FILE__)
+  setup :prepare_destination
+
+  test 'Assert file is properly created when no asset pipeline present' do
+    stub_configuration
+    run_generator
+    assert_file 'public/javascripts/rails.validations.js'
+  end
+
+  test 'Assert file is properly created when asset pipeline present and disabled' do
+    stub_configuration
+    Rails.configuration.stubs(:assets).returns({})
+    Rails.configuration.assets[:enabled] = false
+    run_generator
+    assert_file 'public/javascripts/rails.validations.js'
+  end
+
+  test 'Assert file is properly created when asset pipeline present and enabled' do
+    stub_configuration
+    Rails.configuration.stubs(:assets).returns({})
+    Rails.configuration.assets[:enabled] = true
+    run_generator
+    assert_file 'app/assets/javascripts/rails.validations.js'
+  end
+
+  def stub_configuration
+    Rails.stubs(:configuration).returns(mock('Configuration'))
+  end
+end
+

data/test/javascript/config.ru

@@ -0,0 +1,3 @@
+$LOAD_PATH.unshift File.expand_path('..', __FILE__)
+require 'server'
+run Sinatra::Application