whyvalidationssuckin96 1.0.0

data/test/rails/active_record_test.rb

@@ -0,0 +1,187 @@
+require 'teststrap'
+require 'rails/active_record_test_helper'
+
+context "active record integration" do
+  
+  should "automatically be mixed into the records of the active variety" do
+    ActiveRecord::Base
+  end.respond_to(:validation_collection)
+  
+  context "given an example class, 'VisualWork'" do
+    setup { VisualWork } 
+    
+    should "not save when invalid?" do
+      inst = topic.new
+      inst.save
+      inst.new_record?
+    end
+    
+    should "save when valid" do
+      inst = topic.new(:name => "test")
+      inst.save
+      !inst.new_record?
+    end
+    
+    should "raise the expected exception when invalid and using save!" do
+      inst = topic.new
+      inst.save!
+    end.raises(ActiveRecord::RecordInvalid)
+
+    should "raise the expected exception when invalid and using create!" do
+      topic.create!
+    end.raises(ActiveRecord::RecordInvalid)
+    
+  end # given an example class, 'VisualWork'
+  
+  context "given an example class, 'MusicalWork'" do
+    setup { MusicalWork }
+    
+    should "have four validations in the collection" do
+      topic.validation_collection.size
+    end.equals(4)
+    
+    context "an instance testing basic validation functionality" do
+      setup { topic.new }
+      
+      should "have three passes when the 'state' attribute is nil" do
+        topic.state = nil
+        topic.valid?
+        topic.passed_validations.size
+      end.equals(3)
+      
+      should "have one fail when the 'state' attribute is :fail" do
+        topic.state = :fail
+        topic.valid?
+        topic.failed_validations.size
+      end.equals(1)
+
+      should "have two passes when the 'state' attribute is :fail" do
+        topic.state = :fail
+        topic.valid?
+        topic.passed_validations.size
+      end.equals(2)
+      
+      should "not be allowed to be saved in an invalid state" do
+        topic.state = :fail
+        topic.save
+      end.equals(false)
+      
+      should "not respond to the 'errors' method" do
+        topic.respond_to?(:errors)
+      end.equals(false)
+      
+    end # an instance testing basic validation functionality
+
+    context "an instance testing validation :on specification" do
+      context "on create" do
+        setup do
+          instance = topic.new
+          instance.save
+          instance.validations_run
+        end
+        
+        should "not have run the validation specified for :update" do
+          topic.include?(:validation_that_runs_on_update)
+        end.equals(false)
+        
+        should "have run the validation specified for :create" do
+          topic
+        end.includes(:validation_that_runs_on_create)
+      end # on create
+      
+      context "on update" do
+        setup do
+          instance = topic.new
+          instance.save
+          raise "Whoa there. Topic needs to be a saved record." if instance.new_record?
+          instance.validations_run.clear
+          instance.save
+          instance.validations_run
+        end
+        
+        should "have run the validation specified for :update" do
+          topic
+        end.includes(:validation_that_runs_on_update)
+        
+        should "not have run the validation specified for :create" do
+          topic.include?(:validation_that_runs_on_create)
+        end.equals(false)
+      end # on update
+    end   # an instance testing validation :on specification
+    
+    context "an instance testing callback functionality" do
+      
+      context "on create" do
+        setup do
+          instance = topic.new
+          instance.state = :fail
+          instance.save
+          instance.callbacks_run
+        end
+        
+        should "have run the before_validation callback" do
+          topic
+        end.includes(:before_validation)
+        
+        should "have run the before_validation_on_create callback" do
+          topic
+        end.includes(:before_validation_on_create)
+        
+        should "not have run the before_validation_on_update callback" do
+          topic.include?(:before_validation_on_update)
+        end.equals(false)
+        
+        should "have run the after_validation callback" do
+          topic
+        end.includes(:after_validation)
+        
+        should "have run the after_validation_on_create callback" do
+          topic
+        end.includes(:after_validation_on_create)
+        
+        should "not have run the after_validation_on_update callback" do
+          topic.include?(:after_validation_on_update)
+        end.equals(false)
+        
+      end # on create
+      
+      context "on update" do
+        setup do
+          instance = topic.new
+          instance.state = nil
+          instance.save
+          raise "Whoa there. Topic needs to be a saved record." if instance.new_record?
+          instance.callbacks_run.clear
+          instance.save
+          instance.callbacks_run
+        end
+        
+        should "have run the before_validation callback" do
+          topic
+        end.includes(:before_validation)
+        
+        should "not have run the before_validation_on_create callback" do
+          topic.include?(:before_validation_on_create)
+        end.equals(false)
+        
+        should "not have run the before_validation_on_update callback" do
+          topic
+        end.includes(:before_validation_on_update)
+        
+        should "have run the after_validation callback" do
+          topic
+        end.includes(:after_validation)
+        
+        should "have run the after_validation_on_create callback" do
+          topic.include?(:after_validation_on_create)
+        end.equals(false)
+        
+        should "not have run the after_validation_on_update callback" do
+          topic
+        end.includes(:after_validation_on_update)
+        
+      end # on create
+
+    end   # an instance testing callback functionality
+  end     # given an example class, 'MusicalWork'
+end       # active record integration

data/test/rails/active_record_test_helper.rb

@@ -0,0 +1,90 @@
+require 'whyvalidationssuckin96/rails/active_record'
+
+ActiveRecord::Base.establish_connection(:adapter  => "sqlite3", :database => ":memory:")
+ActiveRecord::Schema.define(:version => 1) do
+  create_table :musical_works do |t|
+    t.string :name
+  end
+  
+  create_table :visual_works do |t|
+    t.string :name
+    t.string :author
+    t.string :type
+  end
+end 
+
+class MusicalWork < ActiveRecord::Base
+  attr_accessor :state, :callbacks_run, :validations_run 
+
+  def after_initialize
+    @callbacks_run = []
+    @validations_run = []
+  end
+  
+  setup_validations do
+    validate :something_that_passes do
+      pass if validatable.state == :pass
+    end
+    
+    validate :something_that_fails do
+      fail if validatable.state == :fail
+    end
+    
+    validate :validation_that_runs_on_update, :on => :update do
+      validatable.validations_run << :validation_that_runs_on_update
+    end
+    
+    validate :validation_that_runs_on_create, :on => :create do
+      validatable.validations_run << :validation_that_runs_on_create
+    end
+  end
+  
+  def before_validation_on_update
+    callbacks_run << :before_validation_on_update
+  end
+
+  def before_validation
+    callbacks_run << :before_validation
+  end
+  
+  def before_validation_on_create
+    callbacks_run << :before_validation_on_create
+  end
+  
+  def after_validation_on_update
+    callbacks_run << :after_validation_on_update
+  end
+  
+  def after_validation
+    callbacks_run << :after_validation
+  end
+  
+  def after_validation_on_create
+    callbacks_run << :after_validation_on_create
+  end
+  
+end
+
+class VisualWork < ActiveRecord::Base
+  setup_validations do
+    validates_presence_of :name
+  end
+end
+
+class Photograph < VisualWork
+  setup_validations do
+    validates_uniqueness_of :author, :base_class_scope => false
+  end
+end
+
+class Painting < VisualWork
+  setup_validations do
+    validates_uniqueness_of :author, :base_class_scope => true
+  end
+end
+
+class Collage < VisualWork
+  setup_validations do
+    validates_uniqueness_of :name, :scope => :author
+  end
+end

data/test/rails/macros/validates_uniqueness_test.rb

@@ -0,0 +1,153 @@
+require 'teststrap'
+require 'rails/active_record_test_helper'
+
+context "validates uniqueness" do
+  
+  should "add a validation macro" do
+    WhyValidationsSuckIn96::ValidationBuilder.instance_methods
+  end.includes('validates_uniqueness_of')
+  
+  context "with some default options" do
+    setup do
+      WhyValidationsSuckIn96::ValidatesUniqueness.new(Object.new, :attribute => :username)
+    end
+  
+    should "have a message accessor with a default message" do
+      topic.message
+    end.equals("has already been taken")
+    
+    should "default to being case insensitive" do
+      topic.options[:case_sensitive]
+    end.equals(false)
+    
+    should "default :base_class_scope to true" do
+      topic.options[:base_class_scope]
+    end.equals(true)
+  end # with some default options
+  
+  context "validating an object" do
+    
+    context "with default options" do
+      setup do
+        Class.new(VisualWork) do
+          setup_validations do
+            validates_uniqueness_of :name
+          end
+        end # VisualWork
+      end   # setup do
+      
+      should "mark the second object with the same name as invalid" do
+        work = topic.new(:name => "example")
+        work.save!
+        other_work = topic.new(:name => "example")
+        !other_work.valid? && other_work.failed_validations.detect do |fv|
+          fv.kind_of?(WhyValidationsSuckIn96::ValidatesUniqueness) && fv.attribute == :name
+        end
+      end
+
+      should "allow two objects with different names" do
+        work = topic.new(:name => "example one")
+        work.save!
+        other = topic.new(:name => "example two")
+        other.valid?
+      end
+      
+      should "not care about case sensitivity by default" do
+        work = topic.new(:name => "cAsE SeNsItiViTy")
+        work.save!
+        other_work = topic.new(:name => "case sensitivity")
+        !other_work.valid? && other_work.failed_validations.detect do |fv|
+          fv.kind_of?(WhyValidationsSuckIn96::ValidatesUniqueness) && fv.attribute == :name
+        end
+      end
+      
+      should "allow the one object to be saved twice and not violate the constraint" do
+        work = topic.new(:name => "screenshot")
+        work.save
+        work.author = "gabe"
+        work.save
+      end
+    end # with default options
+    
+    context "specifying case sensitivity" do
+      setup do
+        Class.new(VisualWork) do
+          setup_validations do
+            validates_uniqueness_of :name, :case_sensitive => true
+          end
+        end # VisualWork
+      end   # setup do
+      
+      should "allow objects with the same name and different case to be valid" do
+        work = topic.create!(:name => "CASE SENSITIVE IS TRUE")
+        other_work = topic.new(:name => "case sensitive is true")
+        other_work.valid?
+      end
+      
+      should "mark the second object with the name in the same case as invalid" do
+        work = topic.create(:name => "SO WHAT")
+        other_work = topic.new(:name => "SO WHAT")
+        !other_work.valid? && other_work.failed_validations.detect do |fv|
+          fv.kind_of?(WhyValidationsSuckIn96::ValidatesUniqueness) && fv.attribute == :name
+        end
+      end
+    end # specifying case sensitivity
+    
+    context "specifying base class scope" do
+      context "as false" do
+        should "allow records to be created in different subclasses that violate the uniqueness" do
+          Painting.create!(:name => "painting one", :author => "humbug")
+          Photograph.new(:name => "photo one", :author => "humbug").valid?
+        end 
+        
+        should "not allow records to be created in the same class that violate the uniqueness" do
+          Photograph.create!(:name => "photo one", :author => "gus")
+          photo = Photograph.new(:name => "photo two", :author => "gus")
+          !photo.valid? && photo.failed_validations.detect do |fv|
+            fv.kind_of?(WhyValidationsSuckIn96::ValidatesUniqueness) && fv.attribute == :author
+          end
+        end
+      end # as false
+      
+      context "as true" do
+        should "not allow records to be created that violate a uniqueness constraint based on the base class" do
+          VisualWork.create!(:name => "mspaint", :author => "dan")
+          work = Painting.new(:name => "the treachery of images", :author => "dan")
+          !work.valid? && work.failed_validations.detect do |fv|
+            fv.kind_of?(WhyValidationsSuckIn96::ValidatesUniqueness) && fv.attribute == :author
+          end
+        end
+        
+        should "allow records to be created that don't violate the uniqueness constraint" do
+          VisualWork.create!(:name => "photoshop", :author => "alex")
+          Painting.create!(:name => "paintshop", :author => "evan")
+        end
+      end # as true
+    end   # specifying base class scope
+    
+    context "specifying scope options" do
+      should "pass when uniqueness is valid against the given scope column" do
+        Collage.create!(:name => "wired snippets", :author => "dan")
+        work = Collage.new(:name => "wired snippets", :author => "gabe")
+        work.valid?
+      end
+      
+      should "fail when uniqueness is invalid against the given scope column" do
+        Collage.create!(:name => "rolling stone snippets", :author => "gabe")
+        work = Collage.new(:name => "rolling stone snippets", :author => "gabe")
+        !work.valid? && work.failed_validations.detect do |fv|
+          fv.kind_of?(WhyValidationsSuckIn96::ValidatesUniqueness) && fv.attribute == :name
+        end
+      end
+    end # specifying scope options
+    
+    context "when using with_scope" do
+      should "basically just ignore with_scope" do
+        Painting.create!(:author => "fred", :name => "bbzzzt")
+        Painting.send(:with_scope, :find => {:conditions => {:author => "fred"}}) do
+          Painting.create!(:author => "myles", :name => "bitchesbrew")
+        end
+      end
+    end # when using with_scope
+  end   # validating an object
+end     # validates uniqueness

data/test/skippable_validation_test.rb

@@ -0,0 +1,102 @@
+require 'teststrap'
+require 'whyvalidationssuckin96/skippable_validation'
+
+context "skippable validation mixin" do
+  context "when mixed into a class" do
+    
+    setup do
+      Class.new(WhyValidationsSuckIn96::Validation) do
+        include WhyValidationsSuckIn96::SkippableValidation
+        attr_accessor :skip_validation
+        
+        def validate
+          super
+          options[:should_pass] ? pass : fail
+        end
+      end # Class.new
+    end   # setup
+    
+    context "when specifying an :if option" do
+      context "as a block" do
+        
+        setup do
+          topic.new(Object.new, :if => lambda { !skip_validation })
+        end
+        
+        should "not have run if the block returns false" do
+          topic.skip_validation = true
+          topic.validates?
+          topic.has_run?
+        end.equals(false)
+
+        should "have run if the block returns true" do
+          topic.skip_validation = false
+          topic.validates?
+          topic.has_run?
+        end
+      end # as a block
+
+      context "as a symbol" do
+        validatable = nil
+        
+        setup do
+          validatable = OpenStruct.new(:allow_validation => true)
+          topic.new(validatable, :if => :allow_validation)
+        end
+
+        should "not have run if the method named by the symbol returns false" do
+          validatable.allow_validation = false
+          topic.validates?
+          topic.has_run?
+        end.equals(false)
+
+        should "have run if the method named by the symbol returns true" do
+          validatable.allow_validation = true
+          topic.validates?
+          topic.has_run?
+        end      
+      end # as a symbol
+    end   # when specifying an :if option
+
+    context "when specifying an :unless option" do
+      context "as a block" do
+        setup do
+          topic.new(Object.new, :unless => lambda { skip_validation })
+        end
+        
+        should "have run if the block returns false" do
+          topic.skip_validation = false
+          topic.validates?
+          topic.has_run?
+        end
+
+        should "not have run if the block returns true" do
+          topic.skip_validation = true
+          topic.validates?
+          topic.has_run?
+        end.equals(false)
+      end # as a block
+
+      context "as a symbol" do
+        validatable = nil
+        
+        setup do
+          validatable = OpenStruct.new(:skip_validation => true)
+          topic.new(validatable, :unless => :skip_validation)
+        end
+        
+        should "have run if the method named by the symbol returns false" do
+          validatable.skip_validation = false
+          topic.validates?
+          topic.has_run?
+        end
+
+        should "not have run if the method named by the symbol returns true" do
+          validatable.skip_validation = true
+          topic.validates?
+          topic.has_run?
+        end.equals(false)
+      end # as a symbol
+    end   # when specifying an :unless option
+  end     # when mixed into a class
+end       # skippable validation mixin

data/test/teststrap.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'riot'
+require 'whyvalidationssuckin96'
+require 'ostruct'

data/test/validation_builder_test.rb

@@ -0,0 +1,62 @@
+require 'teststrap'
+require 'ostruct'
+
+context "validation builder" do
+  context "when defining some standard validations" do
+    setup do
+      fake_validation_target = OpenStruct.new(:validation_collection => [])
+      validation_block = lambda do
+        validate(:validates_whatever) {}
+        validate(:validates_whenever) {}
+      end
+      WhyValidationsSuckIn96::ValidationBuilder.new(fake_validation_target, validation_block).create_validations!
+      fake_validation_target
+    end
+
+    should "have a validates_whatever validation in the collection" do
+      topic.validation_collection.detect { |(validation, opts)| validation.name == :validates_whatever }
+    end
+    
+    should "have a validates_whenever validation in the collection" do
+      topic.validation_collection.detect { |(validation, opts)| validation.name == :validates_whenever }
+    end
+    
+    should "have Validation subclasses as the values for the validation_collection" do
+      topic.validation_collection.all? {|(klass,opts)| klass.ancestors.include?(WhyValidationsSuckIn96::Validation)}
+    end
+  end # when defining some standard validations
+  
+  context "when defining multiple validations with the same name in the one validation definition" do
+    setup do
+      fake_validation_target = OpenStruct.new(:validation_collection => [])
+      validation_block = lambda do
+        validate(:we_are_clones) {}
+        validate(:we_are_clones) {}
+      end # validation_block
+      WhyValidationsSuckIn96::ValidationBuilder.new(fake_validation_target, validation_block).create_validations!
+      fake_validation_target
+    end
+    
+    should "only have one validation in the collection on the target" do
+      topic.validation_collection.size
+    end.equals(1)
+    
+  end # when defining multiple validations with the same name in the one validation definition
+  
+  context "when defining multiple validations with the same name in more than one validation definition" do
+    setup do
+      fake_validation_target = OpenStruct.new(:validation_collection => [])
+      validation_block = lambda do
+        validate(:we_are_clones) {}
+      end # validation_block
+      WhyValidationsSuckIn96::ValidationBuilder.new(fake_validation_target, validation_block).create_validations!
+      WhyValidationsSuckIn96::ValidationBuilder.new(fake_validation_target, validation_block).create_validations!      
+      fake_validation_target
+    end
+    
+    should "only have one validation in the collection on the target" do
+      topic.validation_collection.size
+    end.equals(1)
+    
+  end # when defining multiple validations with the same name in the one validation definition
+end   # validation builder