whyvalidationssuckin96 1.0.0

data/test/macros/validates_confirmation_test.rb

@@ -0,0 +1,63 @@
+require 'teststrap'
+
+context "validates confirmation" do
+  
+  should "add a validation macro" do
+    WhyValidationsSuckIn96::ValidationBuilder.instance_methods
+  end.includes('validates_confirmation_of')
+  
+  context "with some default options" do
+    setup do
+      WhyValidationsSuckIn96::ValidatesConfirmation.new(Object.new, :attribute => :password)
+    end
+  
+    should "have a message accessor with a default message" do
+      topic.message
+    end.equals("does not match the confirmation")  
+  end # with some default options
+  
+  context "validating an object" do
+  
+    context "without a confirmation field" do
+      validatable = Class.new do
+        def password
+          "foo"
+        end
+      end.new
+
+      setup do
+        WhyValidationsSuckIn96::ValidatesConfirmation.new(validatable, :attribute => :password)
+      end
+      
+      should "raise if a confirmation field isn't available" do
+        topic.validates?
+      end.raises(NoMethodError)
+      
+    end # without a confirmation field
+
+    context "with a confirmation field" do
+      validatable = OpenStruct.new(:password => "foo")
+
+      setup do
+        WhyValidationsSuckIn96::ValidatesConfirmation.new(validatable, :attribute => :password)
+      end
+      
+      should "fail if field does not match the confirmation" do
+        validatable.password = "foo"
+        validatable.password_confirmation = "bleh"
+        topic.validates?
+      end.equals(false)
+    
+      should "pass if the field matches the confirmation" do
+        validatable.password = validatable.password_confirmation = "foo"
+        topic.validates?
+      end
+    
+      should "skip the validation if the confirmation is nil" do
+        validatable.password_confirmation = nil
+        topic.validates?
+        topic.has_run?
+      end.equals(false)
+    end # with a confirmation field
+  end   # validating an object
+end     # validates confirmation

data/test/macros/validates_exclusion_test.rb

@@ -0,0 +1,37 @@
+require 'teststrap'
+
+context "validates exclusion" do
+  
+  should "add a validation macro" do
+    WhyValidationsSuckIn96::ValidationBuilder.instance_methods
+  end.includes('validates_exclusion_of')
+  
+  should "raise if an :in option is not given" do
+      WhyValidationsSuckIn96::ValidatesExclusion.new(Object.new, :attribute => :colour)    
+  end.raises(ArgumentError, "Collection to check for exclusion against should be specified with :in")
+  
+  context "with some default options" do
+    setup do
+      WhyValidationsSuckIn96::ValidatesExclusion.new(Object.new, :attribute => :colour, :in => %w[1 2 3])
+    end
+  
+    should "have a message accessor with a default message" do
+      topic.message
+    end.equals("is in the excluded collection")
+  end # with some default options
+  
+  context "validating an object" do
+    
+    should "fail if the attribute is in the excluded set" do
+      validation = WhyValidationsSuckIn96::ValidatesExclusion.new(OpenStruct.new(:colour => "red"), :attribute => :colour,
+                                                                  :in => %w[red blue])
+      validation.validates?
+    end.equals(false)
+    
+    should "pass if the attribute is out of the excluded set" do
+      validation = WhyValidationsSuckIn96::ValidatesExclusion.new(OpenStruct.new(:colour => "red"), :attribute => :colour,
+                                                                  :in => %w[green blue])
+      validation.validates?
+    end
+  end   # validating an object
+end     # validates exclusion

data/test/macros/validates_format_test.rb

@@ -0,0 +1,43 @@
+require 'teststrap'
+
+context "validates format" do
+  
+  should "add a validation macro" do
+    WhyValidationsSuckIn96::ValidationBuilder.instance_methods
+  end.includes('validates_format_of')
+  
+  should "raise if a :with option is not given" do
+      WhyValidationsSuckIn96::ValidatesFormat.new(Object.new, :attribute => :colour)    
+  end.raises(ArgumentError, "Regular expression to check against must be given as :with")
+  
+  context "with some default options" do
+    setup do
+      WhyValidationsSuckIn96::ValidatesFormat.new(Object.new, :attribute => :colour, :with => /\d{3}/)
+    end
+  
+    should "have a message accessor with a default message" do
+      topic.message
+    end.equals("does not match the given format")
+  end # with some default options
+  
+  context "validating an object" do
+
+    should "fail if given attribute does not match the regular expression" do
+      validation = WhyValidationsSuckIn96::ValidatesFormat.new(OpenStruct.new(:number => "1"), :attribute => :number,
+                                                               :with => /\d{3}/)
+      validation.validates?
+    end.equals(false)
+    
+    should "pass if given attribute matches the regular expression" do
+      validation = WhyValidationsSuckIn96::ValidatesFormat.new(OpenStruct.new(:number => "111"), :attribute => :number,
+                                                               :with => /\d{3}/)
+      validation.validates?
+    end
+    
+    should "to_s the attribute when checking validity" do
+      validation = WhyValidationsSuckIn96::ValidatesFormat.new(OpenStruct.new(:number => 333), :attribute => :number,
+                                                               :with => /\d{3}/)
+      validation.validates?
+    end
+  end   # validating an object
+end     # validates format

data/test/macros/validates_inclusion_test.rb

@@ -0,0 +1,37 @@
+require 'teststrap'
+
+context "validates inclusion" do
+  
+  should "add a validation macro" do
+    WhyValidationsSuckIn96::ValidationBuilder.instance_methods
+  end.includes('validates_inclusion_of')
+  
+  should "raise if an :in option is not given" do
+      WhyValidationsSuckIn96::ValidatesInclusion.new(Object.new, :attribute => :colour)    
+  end.raises(ArgumentError, "Collection to check for inclusion against should be specified with :in")
+  
+  context "with some default options" do
+    setup do
+      WhyValidationsSuckIn96::ValidatesInclusion.new(Object.new, :attribute => :colour, :in => %w[1 2 3])
+    end
+  
+    should "have a message accessor with a default message" do
+      topic.message
+    end.equals("is not in the acceptable collection")
+  end # with some default options
+  
+  context "validating an object" do
+    
+    should "fail if the attribute is not in the given set" do
+      validation = WhyValidationsSuckIn96::ValidatesInclusion.new(OpenStruct.new(:colour => "red"), :attribute => :colour,
+                                                                  :in => %w[blue green])
+      validation.validates?
+    end.equals(false)
+    
+    should "pass if the attribute is in the given set" do
+      validation = WhyValidationsSuckIn96::ValidatesInclusion.new(OpenStruct.new(:colour => "red"), :attribute => :colour,
+                                                                  :in => %w[red green blue])
+      validation.validates?
+    end
+  end   # validating an object
+end     # validates inclusion

data/test/macros/validates_length_test.rb

@@ -0,0 +1,179 @@
+require 'teststrap'
+
+context "validates length" do
+  
+  should "add a validation macro" do
+    WhyValidationsSuckIn96::ValidationBuilder.instance_methods
+  end.includes('validates_length_of')
+  
+  should "raise if an no options are given" do
+    WhyValidationsSuckIn96::ValidatesLength.new(Object.new, :attribute => :text)
+  end.raises(ArgumentError, "Length options must be given as :minimum, :maximum, :is, or :in")
+
+  should "have a message accessor with a default message" do
+    WhyValidationsSuckIn96::ValidatesLength.new(Object.new, :attribute => :text, :is => 3).message
+  end.equals("does not meet the given length restrictions")
+  
+  context "when specifying the :is option" do
+    should "not raise if solely :is is given" do
+      WhyValidationsSuckIn96::ValidatesLength.new(Object.new, :attribute => :text, :is => 3)
+    end
+    
+    should "raise if :minimum is given" do
+      WhyValidationsSuckIn96::ValidatesLength.new(Object.new, :attribute => :text, :is => 3, :minimum => 4)
+    end.raises(ArgumentError, "Option :is can not be mixed with :minimum")
+    
+    should "raise if :maximum is given" do
+      WhyValidationsSuckIn96::ValidatesLength.new(Object.new, :attribute => :text, :is => 3, :maximum => 2)
+    end.raises(ArgumentError, "Option :is can not be mixed with :maximum")
+    
+    should "raise if :in is given" do
+      WhyValidationsSuckIn96::ValidatesLength.new(Object.new, :attribute => :text, :is => 3, :in => 5..10)
+    end.raises(ArgumentError, "Option :in can not be mixed with :is")
+    
+    should "fail if the attribute length isn't exactly the given value" do
+      validation = WhyValidationsSuckIn96::ValidatesLength.new(OpenStruct.new(:text => "testing"), :attribute => :text, :is => 4)
+      validation.validates?
+    end.equals(false)
+    
+    should "pass if the attribute length is exactly the given value" do
+      validation = WhyValidationsSuckIn96::ValidatesLength.new(OpenStruct.new(:text => "test"), :attribute => :text, :is => 4)
+      validation.validates?
+    end
+  end # when specifying the :is option
+  
+  context "when specifying the :in option" do
+
+    should "not raise if solely :in is given" do
+      WhyValidationsSuckIn96::ValidatesLength.new(Object.new, :attribute => :text, :in => 1..10)
+    end
+    
+    should "raise if :minimum is given" do
+      WhyValidationsSuckIn96::ValidatesLength.new(Object.new, :attribute => :text, :in => 1..10, :minimum => 4)
+    end.raises(ArgumentError, "Option :in can not be mixed with :minimum")
+    
+    should "raise if :maximum is given" do
+      WhyValidationsSuckIn96::ValidatesLength.new(Object.new, :attribute => :text, :in => 1..10, :maximum => 4)
+    end.raises(ArgumentError, "Option :in can not be mixed with :maximum")
+    
+    should "raise if :is is given" do
+      WhyValidationsSuckIn96::ValidatesLength.new(Object.new, :attribute => :text, :in => 1..10, :is => 3)
+    end.raises(ArgumentError, "Option :in can not be mixed with :is")
+
+    context "using a two dot range" do
+      validatable = OpenStruct.new(:text => "test")
+      
+      setup do
+        WhyValidationsSuckIn96::ValidatesLength.new(validatable, :attribute => :text, :in => 2..10)
+      end
+      
+      should "fail if the value is less than the beginning of the range" do
+        validatable.text = "a"
+        topic.validates?
+      end.equals(false)
+      
+      should "fail if the value is more than the end of the range" do
+        validatable.text = "a" * 12
+        topic.validates?
+      end.equals(false)
+      
+      should "pass if the value is exactly at the end of the range" do
+        validatable.text = "a" * 10
+        topic.validates?
+      end
+      
+      should "pass if the value falls inside the range" do
+        validatable.text = "test"
+        topic.validates?
+      end
+    end # using a two dot range
+    
+    context "using a three dot range" do
+      validatable = OpenStruct.new(:text => "test")
+      
+      setup do
+        WhyValidationsSuckIn96::ValidatesLength.new(validatable, :attribute => :text, :in => 2...10)
+      end
+      
+      should "fail if the value is less than the beginning of the range" do
+        validatable.text = "a"
+        topic.validates?
+      end.equals(false)
+      
+      should "fail if the value is more than the end of the range" do
+        validatable.text = "a" * 12
+        topic.validates?
+      end.equals(false)
+      
+      should "fail if the value is exactly at the end of the range" do
+        validatable.text = "a" * 10
+        topic.validates?
+      end.equals(false)
+      
+      should "pass if the value falls inside the range" do
+        validatable.text = "test"
+        topic.validates?
+      end
+    end # using a three dot range
+    
+  end # when specifying the :in option
+
+  context "when specifying the :minimum option" do
+    validatable = OpenStruct.new(:text => "test")
+    
+    setup do
+      WhyValidationsSuckIn96::ValidatesLength.new(validatable, :attribute => :text, :minimum => 4)
+    end
+    
+    should "pass if the attribute length is above the minimum value" do
+      validatable.text = "a" * 5
+      topic.validates?
+    end
+    
+    should "pass if the attribute length is equal to the minimum value" do
+      validatable.text = "a" * 4
+      topic.validates?
+    end
+    
+    should "fail if the attribute length is less than the minimum value" do
+      validatable.text = "a" * 2
+      topic.validates?
+    end.equals(false)
+  end # when specifying the :minimum option
+  
+  context "when specifying the :maximum option" do
+    validatable = OpenStruct.new(:text => "test")
+    
+    setup do
+      WhyValidationsSuckIn96::ValidatesLength.new(validatable, :attribute => :text, :maximum => 10)
+    end
+    
+    should "pass if the attribute length is below the maximum value" do
+      validatable.text = "a" * 9
+      topic.validates?
+    end
+    
+    should "pass if the attribute length is equal to the maximum value" do
+      validatable.text = "a" * 10
+      topic.validates?
+    end
+    
+    should "fail if the attribute length is more than the maximum value" do
+      validatable.text = "a" * 15
+      topic.validates?
+    end.equals(false)
+  end # when specifying the :maximum option
+  
+  context "when specifying the :minimum and :maximum options" do
+    validatable = OpenStruct.new(:text => "test")
+    
+    setup do
+      WhyValidationsSuckIn96::ValidatesLength.new(validatable, :attribute => :text, :minimum => 3, :maximum => 10)
+    end
+    
+    should "pass if the attribute length falls into the min/max range" do
+      validatable.text = "a" * 5
+      topic.validates?
+    end
+  end # when specifying the :minimum and :maximum options
+end     # validates length

data/test/macros/validates_numericality_test.rb

@@ -0,0 +1,129 @@
+require 'teststrap'
+
+context "validates numericality" do
+  
+  should "add a validation macro" do
+    WhyValidationsSuckIn96::ValidationBuilder.instance_methods
+  end.includes('validates_numericality_of')
+  
+  context "with some default options" do
+    setup do
+      WhyValidationsSuckIn96::ValidatesNumericality.new(Object.new, :attribute => :number)
+    end
+  
+    should "have a message accessor with a default message" do
+      topic.message
+    end.equals("is not a numerical value")
+  end # with some default options
+  
+  context "validating an object" do
+    
+    context "with the default option of :only_integer being false" do
+      validatable = OpenStruct.new(:number => 123)
+      
+      setup do
+        WhyValidationsSuckIn96::ValidatesNumericality.new(validatable, :attribute => :number)
+      end
+      
+      should "pass for an actual integer" do
+        validatable.number = 30000
+        topic.validates?
+      end
+      
+      should "pass for a regular old integer string" do
+        validatable.number = "123"
+        topic.validates?
+      end
+      
+      should "pass for a valid integer with spaces" do
+        validatable.number = "123 456"
+        topic.validates?
+      end
+      
+      should "pass for a valid integer with commas" do
+        validatable.number = "123,456"
+        topic.validates?
+      end
+      
+      should "pass for a valid integer with a positive sign" do
+        validatable.number = "+1234"
+        topic.validates?
+      end
+      
+      should "pass for a valid integer with a negative sign" do
+        validatable.number "-1234"
+        topic.validates?
+      end
+      
+      should "fail for an integer with letters" do
+        validatable.number = "a1234"
+        topic.validates?
+      end.equals(false)
+      
+      should "fail for an integer with other punctuation" do
+        validatable.number = "!1234"
+        topic.validates?
+      end.equals(false)
+      
+      should "pass for an actual float" do
+        validatable.number = 123.45
+        topic.validates?
+      end
+      
+      should "pass for a regular old float" do
+        validatable.number = "123.456"
+        topic.validates?
+      end
+      
+      should "pass for a valid float with spaces" do
+        validatable.number = "123 456.10"
+        topic.validates?
+      end
+      
+      should "pass for a valid float with commas" do
+        validatable.number = "123,456.10"
+        topic.validates?
+      end
+      
+      should "pass for a valid float with a positive sign" do
+        validatable.number = "+123456.10"
+        topic.validates?
+      end
+      
+      should "pass for a valid float with a negative sign" do
+        validatable.number = "-123456.10"
+        topic.validates?
+      end
+      
+      should "fail for a float with letters other than the exponent" do
+        validatable.number = "123z456.10"
+        topic.validates?
+      end.equals(false)
+      
+      should "fail for a float with other punctuation" do
+        validatable.number = "$123456.10"
+        topic.validates?
+      end.equals(false)
+      
+    end # with the default option of :only_integer being false
+    
+    context "with the :only_integer option being true" do
+      validatable = OpenStruct.new(:number => 123)
+      
+      setup do
+        WhyValidationsSuckIn96::ValidatesNumericality.new(validatable, :attribute => :number, :only_integer => true)
+      end
+
+      should "not allow float values" do
+        validatable.number = 123.456
+        topic.validates?
+      end.equals(false)
+      
+      should "allow integer values" do
+        validatable.number = 123
+        topic.validates?
+      end
+      
+    end # with the :only_integer option being true
+  end   # validating an object
+end     # validates numericality

data/test/macros/validates_presence_test.rb

@@ -0,0 +1,31 @@
+require 'teststrap'
+
+context "validates presence" do
+  
+  should "add a validation macro" do
+    WhyValidationsSuckIn96::ValidationBuilder.instance_methods
+  end.includes('validates_presence_of')
+  
+  context "validating an object" do
+    validatable = OpenStruct.new(:message => "foo")
+    
+    setup do
+      WhyValidationsSuckIn96::ValidatesPresence.new(validatable, :attribute => :message)
+    end
+    
+    should "have a message accessor with a default message" do
+      topic.message
+    end.equals("is not present")
+    
+    should "fail if the attribute is blank" do
+      validatable.message = ""
+      topic.validates?
+    end.equals(false)
+    
+    should "pass if the attribute is non blank" do
+      validatable.message = "blah"
+      topic.validates?
+    end
+    
+  end   # validating an object
+end     # validates presence