client_side_validations 0.6.0

data/spec/action_view_2_spec.rb

@@ -0,0 +1,74 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+gem 'actionpack', '~> 2.0'
+require 'action_pack'
+require 'action_view'
+require 'client_side_validations'
+
+describe 'ActionView 2.x Form Helper' do
+  context 'ActionView::Base' do
+    subject { ActionView::Base.new }
+    
+    context 'only the url' do
+      before do
+        @object_name = 'object'
+        @url         = '/objects/new.json'
+        @expected_javascript = <<-JS
+      <script type="text/javascript">
+        $(document).ready(function() {
+          $('##{@object_name}').clientSideValidations('#{@url}', 'jquery.validate');
+        })
+      </script>
+    JS
+        subject.should_receive(:dom_id).and_return(@object_name)
+      end
+      
+      it 'should generate the proper javascript' do
+        subject.client_side_validations(@object_name, 
+          :url => @url).should == @expected_javascript
+      end
+    end
+    
+    context 'a different adapter' do
+      before do
+        @object_name = 'object'
+        @url         = '/objects/new.json'
+        @adapter     = 'some.other.adapter'
+        @expected_javascript = <<-JS
+      <script type="text/javascript">
+        $(document).ready(function() {
+          $('##{@object_name}').clientSideValidations('#{@url}', '#{@adapter}');
+        })
+      </script>
+    JS
+        subject.should_receive(:dom_id).and_return(@object_name)
+      end
+      
+      it 'should generate the proper javascript' do
+        subject.client_side_validations(@object_name, 
+          :url => @url, :adapter => @adapter).should == @expected_javascript
+      end
+    end
+
+    context 'not including the :url' do
+      before do
+        @object_name = 'object'
+        @adapter     = 'some.other.adapter'
+        @expected_javascript = <<-JS
+      <script type="text/javascript">
+        $(document).ready(function() {
+          $('##{@object_name}').clientSideValidations('#{@url}', '#{@some_other_adapter}');
+        })
+      </script>
+    JS
+      end
+      
+      it 'should raise an error' do
+        expect {
+          subject.client_side_validations(@object_name, 
+            :adapter => @some_other_adapter)
+        }.to raise_error
+      end
+    end
+    
+  end
+end

data/spec/action_view_3_spec.rb

@@ -0,0 +1,74 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+gem 'actionpack', '~> 3.0'
+require 'action_pack'
+require 'action_view'
+require 'client_side_validations'
+
+describe 'ActionView 2.x Form Helper' do
+  context 'ActionView::Base' do
+    subject { ActionView::Base.new }
+    
+    context 'only the url' do
+      before do
+        @object_name = 'object'
+        @url         = '/objects/new.json'
+        @expected_javascript = <<-JS
+      <script type="text/javascript">
+        $(document).ready(function() {
+          $('##{@object_name}').clientSideValidations('#{@url}', 'jquery.validate');
+        })
+      </script>
+    JS
+        subject.should_receive(:dom_id).and_return(@object_name)
+      end
+      
+      it 'should generate the proper javascript' do
+        subject.client_side_validations(@object_name, 
+          :url => @url).should == @expected_javascript
+      end
+    end
+    
+    context 'a different adapter' do
+      before do
+        @object_name = 'object'
+        @url         = '/objects/new.json'
+        @adapter     = 'some.other.adapter'
+        @expected_javascript = <<-JS
+      <script type="text/javascript">
+        $(document).ready(function() {
+          $('##{@object_name}').clientSideValidations('#{@url}', '#{@adapter}');
+        })
+      </script>
+    JS
+        subject.should_receive(:dom_id).and_return(@object_name)
+      end
+      
+      it 'should generate the proper javascript' do
+        subject.client_side_validations(@object_name, 
+          :url => @url, :adapter => @adapter).should == @expected_javascript
+      end
+    end
+
+    context 'not including the :url' do
+      before do
+        @object_name = 'object'
+        @adapter     = 'some.other.adapter'
+        @expected_javascript = <<-JS
+      <script type="text/javascript">
+        $(document).ready(function() {
+          $('##{@object_name}').clientSideValidations('#{@url}', '#{@some_other_adapter}');
+        })
+      </script>
+    JS
+      end
+      
+      it 'should raise an error' do
+        expect {
+          subject.client_side_validations(@object_name, 
+            :adapter => @some_other_adapter)
+        }.to raise_error
+      end
+    end
+    
+  end
+end

data/spec/active_model_3_spec.rb

@@ -0,0 +1,271 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'active_model'
+require 'client_side_validations'
+
+describe "Validation to hash" do
+  
+  before do
+    class Klass
+      include ActiveModel::Validations
+    end
+  end
+  
+  after do
+    Object.send(:remove_const, :Klass)
+  end
+  
+  it "should support validate_presence_of" do
+    Klass.class_eval { validates_presence_of :string }
+    instance      = Klass.new
+    expected_hash = { "presence" => { "message" => "can't be blank"} }
+    result_hash   = instance.validation_to_hash(:string)
+    result_hash.should == expected_hash
+  end
+  
+  it "should support validates_format_of of" do
+    Klass.class_eval { validates_format_of :string, :with => /\A\d\Z/i }
+    instance      = Klass.new
+    expected_hash = { "format" => { "message" => "is invalid", "with" => "^\\d$" } }
+    result_hash   = instance.validation_to_hash(:string)
+    result_hash.should == expected_hash
+  end
+  
+  it "should support different ways to write regex" do
+    Klass.class_eval do
+      validates_format_of :string, :with => /^\d$/i
+      validates_format_of :string_2, :with => /\d/
+    end
+    instance        = Klass.new
+    expected_hash_1 = { "format" => { "message" => "is invalid", "with" => "^\\d$" } }
+    expected_hash_2 = { "format" => { "message" => "is invalid", "with" => "\\d" } }
+    result_hash_1   = instance.validation_to_hash(:string)
+    result_hash_2   = instance.validation_to_hash(:string_2)
+    result_hash_1.should == expected_hash_1
+    result_hash_2.should == expected_hash_2
+  end
+  
+  it "should support minimum validates_length_of of" do
+    Klass.class_eval { validates_length_of :string, :minimum => 10 }
+    instance      = Klass.new
+    expected_hash = { "length" => { "message" => "is too short (minimum is 10 characters)", "minimum" => 10 } }
+    result_hash   = instance.validation_to_hash(:string)
+    result_hash.should == expected_hash
+  end
+
+  it "should support maximum validates_length_of of" do
+    Klass.class_eval { validates_length_of :string, :maximum => 10 }
+    instance      = Klass.new
+    expected_hash = { "length" => { "message" => "is too long (maximum is 10 characters)", "maximum" => 10 } }
+    result_hash   = instance.validation_to_hash(:string)
+    result_hash.should == expected_hash
+  end
+  
+  it "should support validations with conditionals" do
+    Klass.class_eval do
+      validates_presence_of :string, :if => :need_string?
+      validates_presence_of :string_2, :unless => :need_string?
+      validates_presence_of :integer, :if => :need_integer?
+      
+      def need_string?
+        true
+      end
+      
+      def need_integer?
+        false
+      end
+    end
+    
+    instance        = Klass.new
+    expected_hash_1 = { "presence" => { "message" => "can't be blank" } }
+    result_hash_1   = instance.validation_to_hash(:string)
+    result_hash_1.should == expected_hash_1
+    
+    expected_hash_2 = { }
+    result_hash_2   = instance.validation_to_hash(:string_2)
+    result_hash_2.should == expected_hash_2
+    
+    expected_hash_3 = { }
+    result_hash_3   = instance.validation_to_hash(:integer)
+    result_hash_3.should == expected_hash_3
+  end
+  
+  it "should support validating the validates_numericality_of of" do
+    Klass.class_eval { validates_numericality_of :integer }
+    instance      = Klass.new
+    expected_hash = { "numericality" => { "message" => "is not a number" } }
+    result_hash   = instance.validation_to_hash(:integer)
+    result_hash.should == expected_hash
+  end
+  
+  it "should strip out the AR callback options" do
+    Klass.class_eval { validates_presence_of :string, :on => :create }
+    instance      = Klass.new
+    expected_hash = { "presence" => { "message" => "can't be blank"} }
+    result_hash   = instance.validation_to_hash(:string)
+    result_hash.should == expected_hash
+  end
+  
+  it "should support multiple validations for the same method" do
+    Klass.class_eval do
+      validates_presence_of :integer
+      validates_numericality_of :integer
+    end
+    
+    instance      = Klass.new
+    expected_hash = { "presence" => { "message" => "can't be blank" },
+                      "numericality" => { "message" => "is not a number" } }
+    result_hash   = instance.validation_to_hash(:integer)
+    result_hash.should == expected_hash
+  end
+  
+  context 'with custom validation messages' do
+    before do
+      add_translation(:en, :klass => { :attributes => { :string_2 => { :presence => "String_2" } } })
+      
+      Klass.class_eval do
+        validates_presence_of :string, :message => "String"
+        validates_presence_of :string_2, :message => :presence
+      end
+    end
+    
+    after do
+      remove_translation(:en, :klass)
+    end
+    
+    it 'should have a message of "String" for #string' do
+      instance      = Klass.new
+      expected_hash = { "presence" => { "message" => "String" } }
+      result_hash   = instance.validation_to_hash(:string)
+      result_hash.should == expected_hash
+    end
+
+    it 'should have a message of "String_2" for #string_2' do
+      instance      = Klass.new
+      expected_hash = { "presence" => { "message" => "String_2" } }
+      result_hash   = instance.validation_to_hash(:string_2)
+      result_hash.should == expected_hash
+    end
+  end
+  
+  context 'Other languages' do
+    before do
+      add_translation(:es, :klass => { :attributes => { :string => { :presence => "String-es" } } })
+      
+      Klass.class_eval do
+        validates_presence_of :string, :message => :presence
+      end
+    end
+    
+    after do
+      remove_translation(:es, :klass)
+    end
+    
+    it 'should result in "String-es" for Spanish translations' do
+      instance      = Klass.new
+      expected_hash = { "presence" => { "message" => "String-es" } }
+      result_hash   = instance.validation_to_hash(:string, :locale => :es)
+      result_hash.should == expected_hash
+    end
+    
+    it 'should result in "String-es" for Spanish translations when passed string "es" instead of symbol' do
+      instance      = Klass.new
+      expected_hash = { "presence" => { "message" => "String-es" } }
+      result_hash   = instance.validation_to_hash(:string, :locale => "es")
+      result_hash.should == expected_hash
+    end
+  end
+  
+  xit "should support the regular validate method" do
+    Klass.class_eval do
+      validate :do_something
+      
+      def do_something
+        errors.add(:string, "test this out")
+      end
+    end
+    
+    instance = Klass.new
+    # TODO: Unsupported right now
+  end
+
+  def add_translation(lang, hash)
+    validations = {
+      :errors => {
+        :models => hash
+      }
+    }
+    I18n.backend.store_translations(lang, validations)
+  end
+  
+  def remove_translation(lang, key)
+    model_validations = I18n.translate('errors.models')
+    model_validations.delete(key)
+    validations = {
+      :errors => model_validations
+    }
+    I18n.backend.store_translations(lang, validations)
+  end
+end
+
+describe "Validations to JSON" do
+  before do
+    class Klass
+      include ActiveModel::Validations
+    end
+  end
+  
+  after do
+    Object.send(:remove_const, :Klass)
+  end
+
+  it "should support a sinlgle validation" do
+    Klass.class_eval do
+      validates_presence_of :string
+    end
+    
+    instance      = Klass.new
+    expected_json = {:string => { "presence" => { "message" => "can't be blank" } } }.to_json
+    result_json   = instance.validations_to_json(:string)
+    result_json.should == expected_json
+  end
+
+  it "should support multiple validations on the same field" do
+    Klass.class_eval do
+      validates_presence_of :number
+      validates_numericality_of :number
+    end
+    
+    instance      = Klass.new
+    expected_json = {:number => { "presence" => { "message" => "can't be blank" }, "numericality" => { "message" => "is not a number" } } }.to_json
+    result_json   = instance.validations_to_json(:number)
+    result_json.should == expected_json
+  end
+  
+  it "should support single validations on different fields" do
+    Klass.class_eval do
+      validates_presence_of :string
+      validates_presence_of :string_2
+    end
+    
+    instance      = Klass.new
+    expected_json = {:string => { "presence" => { "message" => "can't be blank" } },
+                     :string_2 => { "presence" => { "message" => "can't be blank" } } }.to_json
+    result_json   = instance.validations_to_json(:string, :string_2)
+    result_json.should == expected_json
+  end
+  
+  it "should support multiple validations on different fields" do
+    Klass.class_eval do
+      validates_presence_of     :number_1
+      validates_numericality_of :number_1
+      validates_presence_of     :number_2
+      validates_numericality_of :number_2
+    end
+    
+    instance      = Klass.new
+    expected_json = {:number_1 => { "presence" => { "message" => "can't be blank" }, "numericality" => { "message" => "is not a number" } },
+                     :number_2 => { "presence" => { "message" => "can't be blank" }, "numericality" => { "message" => "is not a number" } } }.to_json
+    result_json   = instance.validations_to_json(:number_1, :number_2)
+    result_json.should == expected_json
+  end
+end

data/spec/active_record_2_spec.rb

@@ -0,0 +1,286 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+gem 'activerecord', '~> 2.0'
+require 'active_record'
+require 'client_side_validations'
+
+describe 'Validations' do
+  describe 'to hash' do
+  
+    before do
+      class Klass < ActiveRecord::Base
+        def self.columns() @columns ||= []; end
+      
+        def self.column(name, sql_type = nil, default = nil, null = true)
+          columns << ActiveRecord::ConnectionAdapters::Column.new(name.to_s, default, sql_type.to_s, null)
+        end
+      end
+    end
+  
+    after do
+      Object.send(:remove_const, :Klass)
+    end
+  
+    it "should support validate_presence_of" do
+      Klass.class_eval { validates_presence_of :string }
+      instance      = Klass.new
+      expected_hash = { "presence" => { "message" => "can't be blank"} }
+      result_hash   = instance.validation_to_hash(:string)
+      result_hash.should == expected_hash
+    end
+  
+    it "should support validates_format_of of" do
+      Klass.class_eval { validates_format_of :string, :with => /\A\d\Z/i }
+      instance      = Klass.new
+      expected_hash = { "format" => { "message" => "is invalid", "with" => "^\\d$" } }
+      result_hash   = instance.validation_to_hash(:string)
+      result_hash.should == expected_hash
+    end
+  
+    it "should support different ways to write regex" do
+      Klass.class_eval do
+        validates_format_of :string, :with => /^\d$/i
+        validates_format_of :string_2, :with => /\d/
+      end
+      instance        = Klass.new
+      expected_hash_1 = { "format" => { "message" => "is invalid", "with" => "^\\d$" } }
+      expected_hash_2 = { "format" => { "message" => "is invalid", "with" => "\\d" } }
+      result_hash_1   = instance.validation_to_hash(:string)
+      result_hash_2   = instance.validation_to_hash(:string_2)
+      result_hash_1.should == expected_hash_1
+      result_hash_2.should == expected_hash_2
+    end
+  
+    it "should support minimum validates_length_of of" do
+      Klass.class_eval { validates_length_of :string, :minimum => 10 }
+      instance      = Klass.new
+      expected_hash = { "length" => { "message" => "is too short (minimum is 10 characters)", "minimum" => 10 } }
+      result_hash   = instance.validation_to_hash(:string)
+      result_hash.should == expected_hash
+    end
+
+    it "should support maximum validates_length_of of" do
+      Klass.class_eval { validates_length_of :string, :maximum => 10 }
+      instance      = Klass.new
+      expected_hash = { "length" => { "message" => "is too long (maximum is 10 characters)", "maximum" => 10 } }
+      result_hash   = instance.validation_to_hash(:string)
+      result_hash.should == expected_hash
+    end
+  
+    it "should support validations with conditionals" do
+      Klass.class_eval do
+        validates_presence_of :string, :if => :need_string?
+        validates_presence_of :string_2, :unless => :need_string?
+        validates_presence_of :integer, :if => :need_integer?
+      
+        def need_string?
+          true
+        end
+      
+        def need_integer?
+          false
+        end
+      end
+    
+      instance        = Klass.new
+      expected_hash_1 = { "presence" => { "message" => "can't be blank" } }
+      result_hash_1   = instance.validation_to_hash(:string)
+      result_hash_1.should == expected_hash_1
+    
+      expected_hash_2 = { }
+      result_hash_2   = instance.validation_to_hash(:string_2)
+      result_hash_2.should == expected_hash_2
+    
+      expected_hash_3 = { }
+      result_hash_3   = instance.validation_to_hash(:integer)
+      result_hash_3.should == expected_hash_3
+    end
+  
+    it "should support validating the validates_numericality_of of" do
+      Klass.class_eval { validates_numericality_of :integer }
+      instance      = Klass.new
+      expected_hash = { "numericality" => { "message" => "is not a number" } }
+      result_hash   = instance.validation_to_hash(:integer)
+      result_hash.should == expected_hash
+    end
+  
+    it "should strip out the AR callback options" do
+      Klass.class_eval { validates_presence_of :string, :on => :create }
+      instance      = Klass.new
+      expected_hash = { "presence" => { "message" => "can't be blank"} }
+      result_hash   = instance.validation_to_hash(:string)
+      result_hash.should == expected_hash
+    end
+  
+    it "should support multiple validations for the same method" do
+      Klass.class_eval do
+        validates_presence_of :integer
+        validates_numericality_of :integer
+      end
+    
+      instance      = Klass.new
+      expected_hash = { "presence" => { "message" => "can't be blank" },
+                        "numericality"   => { "message" => "is not a number" } }
+      result_hash   = instance.validation_to_hash(:integer)
+      result_hash.should == expected_hash
+    end
+  
+    context 'with custom validation messages' do
+      before do
+        add_translation(:en, :klass => { :attributes => { :string_2 => { :presence => "String_2" } } })
+      
+        Klass.class_eval do
+          validates_presence_of :string, :message => "String"
+          validates_presence_of :string_2, :message => :presence
+        end
+      end
+    
+      after do
+        remove_translation(:en, :klass)
+      end
+    
+      it 'should have a message of "String" for #string' do
+        instance      = Klass.new
+        expected_hash = { "presence" => { "message" => "String" } }
+        result_hash   = instance.validation_to_hash(:string)
+        result_hash.should == expected_hash
+      end
+
+      it 'should have a message of "String_2" for #string_2' do
+        instance      = Klass.new
+        expected_hash = { "presence" => { "message" => "String_2" } }
+        result_hash   = instance.validation_to_hash(:string_2)
+        result_hash.should == expected_hash
+      end
+    end
+  
+    context 'Other languages' do
+      before do
+        add_translation(:es, :klass => { :attributes => { :string => { :presence => "String-es" } } })
+      
+        Klass.class_eval do
+          validates_presence_of :string, :message => :presence
+        end
+      end
+    
+      after do
+        remove_translation(:es, :klass)
+      end
+    
+      it 'should result in "String-es" for Spanish translations' do
+        instance      = Klass.new
+        expected_hash = { "presence" => { "message" => "String-es" } }
+        result_hash   = instance.validation_to_hash(:string, :locale => :es)
+        result_hash.should == expected_hash
+      end
+    
+      it 'should result in "String-es" for Spanish translations when passed string "es" instead of symbol' do
+        instance      = Klass.new
+        expected_hash = { "presence" => { "message" => "String-es" } }
+        result_hash   = instance.validation_to_hash(:string, :locale => "es")
+        result_hash.should == expected_hash
+      end
+    end
+  
+    xit "should support the regular validate method" do
+      Klass.class_eval do
+        validate :do_something
+      
+        def do_something
+          errors.add(:string, "test this out")
+        end
+      end
+    
+      instance = Klass.new
+      # TODO: Unsupported right now
+    end
+
+    def add_translation(lang, hash)
+      validations = {
+        :activerecord => {
+         :errors => {
+           :models => hash
+         }
+        }
+      }
+      I18n.backend.store_translations(lang, validations)
+    end
+  
+    def remove_translation(lang, key)
+      model_validations = I18n.translate('activerecord.errors.models')
+      model_validations.delete(key)
+      validations = {
+        :activerecord => {
+          :errors => model_validations
+        }
+      }
+      I18n.backend.store_translations(lang, validations)
+    end
+  end
+
+  describe 'to JSON' do
+    before do
+      class Klass < ActiveRecord::Base
+        def self.columns() @columns ||= []; end
+
+        def self.column(name, sql_type = nil, default = nil, null = true)
+          columns << ActiveRecord::ConnectionAdapters::Column.new(name.to_s, default, sql_type.to_s, null)
+        end
+      end
+    end
+  
+    after do
+      Object.send(:remove_const, :Klass)
+    end
+
+    it "should support a sinlgle validation" do
+      Klass.class_eval do
+        validates_presence_of :string
+      end
+    
+      instance      = Klass.new
+      expected_json = {:string => { "presence" => { "message" => "can't be blank" } } }.to_json
+      result_json   = instance.validations_to_json(:string)
+      result_json.should == expected_json
+    end
+
+    it "should support multiple validations on the same field" do
+      Klass.class_eval do
+        validates_presence_of :number
+        validates_numericality_of :number
+      end
+    
+      instance      = Klass.new
+      expected_json = {:number => { "presence" => { "message" => "can't be blank" }, "numericality" => { "message" => "is not a number" } } }.to_json
+      result_json   = instance.validations_to_json(:number)
+      result_json.should == expected_json
+    end
+  
+    it "should support single validations on different fields" do
+      Klass.class_eval do
+        validates_presence_of :string
+        validates_presence_of :string_2
+      end
+    
+      instance      = Klass.new
+      expected_json = {:string => { "presence" => { "message" => "can't be blank" } },
+                       :string_2 => { "presence" => { "message" => "can't be blank" } } }.to_json
+      result_json   = instance.validations_to_json(:string, :string_2)
+      result_json.should == expected_json
+    end
+  
+    it "should support multiple validations on different fields" do
+      Klass.class_eval do
+        validates_presence_of     :number_1
+        validates_numericality_of :number_1
+        validates_presence_of     :number_2
+        validates_numericality_of :number_2
+      end
+    
+      instance      = Klass.new
+      expected_json = {:number_1 => { "presence" => { "message" => "can't be blank" }, "numericality" => { "message" => "is not a number" } },
+                       :number_2 => { "presence" => { "message" => "can't be blank" }, "numericality" => { "message" => "is not a number" } } }.to_json
+      result_json   = instance.validations_to_json(:number_1, :number_2)
+      result_json.should == expected_json
+    end
+  end
+end