ratnikov-shoulda 2.0.6.3 → 2.9.0

data/lib/shoulda/active_record/matchers/validate_uniqueness_of_matcher.rb

@@ -0,0 +1,148 @@
+module Shoulda # :nodoc:
+  module ActiveRecord # :nodoc:
+    module Matchers
+
+      # Ensures that the model is invalid if the given attribute is not unique.
+      #
+      # Internally, this uses values from existing records to test validations,
+      # so this will always fail if you have not saved at least one record for
+      # the model being tested, like so:
+      #
+      #   describe User do
+      #     before(:each) { User.create!(:email => 'address@example.com') }
+      #     it { should validate_uniqueness_of(:email) }
+      #   end
+      #
+      # Options:
+      #
+      # * <tt>with_message</tt> - value the test expects to find in
+      #   <tt>errors.on(:attribute)</tt>. <tt>Regexp</tt> or <tt>String</tt>.
+      #   Defaults to the translation for <tt>:taken</tt>.
+      # * <tt>scoped_to</tt> - field(s) to scope the uniqueness to.
+      # * <tt>case_insensitive</tt> - ensures that the validation does not
+      #   check case. Off by default. Ignored by non-text attributes.
+      #
+      # Examples:
+      #   it { should validate_uniqueness_of(:keyword) }
+      #   it { should validate_uniqueness_of(:keyword).with_message(/dup/) }
+      #   it { should validate_uniqueness_of(:email).scoped_to(:name) }
+      #   it { should validate_uniqueness_of(:email).
+      #                 scoped_to(:first_name, :last_name) }
+      #   it { should validate_uniqueness_of(:keyword).case_insensitive }
+      #
+      def validate_uniqueness_of(attr)
+        ValidateUniquenessOfMatcher.new(attr)
+      end
+
+      class ValidateUniquenessOfMatcher < ValidationMatcher # :nodoc:
+        include Helpers
+
+        def initialize(attribute)
+          @attribute = attribute
+        end
+
+        def scoped_to(*scopes)
+          @scopes = [*scopes].flatten
+          self
+        end
+
+        def with_message(message)
+          @expected_message = message
+          self
+        end
+
+        def case_insensitive
+          @case_insensitive = true
+          self
+        end
+
+        def description
+          result = "require "
+          result << "case sensitive " unless @case_insensitive
+          result << "unique value for #{@attribute}"
+          result << " scoped to #{@scopes.join(', ')}" unless @scopes.blank?
+          result
+        end
+
+        def matches?(subject)
+          @subject = subject.class.new
+          @expected_message ||= :taken
+          find_existing && 
+            set_scoped_attributes && 
+            validate_attribute &&
+            validate_after_scope_change
+        end
+
+        private
+
+        def find_existing
+          if @existing = @subject.class.find(:first)
+            @failure_message = "Can't find first #{class_name}"
+            true
+          else
+            false
+          end
+        end
+
+        def set_scoped_attributes
+          unless @scopes.blank?
+            @scopes.each do |scope|
+              setter = :"#{scope}="
+              unless @subject.respond_to?(setter)
+                @failure_message =
+                  "#{class_name} doesn't seem to have a #{scope} attribute."
+                return false
+              end
+              @subject.send("#{scope}=", @existing.send(scope))
+            end
+          end
+          true
+        end
+
+        def validate_attribute
+          disallows_value_of(existing_value, @expected_message)
+        end
+
+        # TODO:  There is a chance that we could change the scoped field
+        # to a value that's already taken.  An alternative implementation
+        # could actually find all values for scope and create a unique
+        def validate_after_scope_change
+          if @scopes.blank?
+            true
+          else
+            @scopes.all? do |scope|
+              previous_value = @existing.send(scope)
+
+              # Assume the scope is a foreign key if the field is nil
+              previous_value ||= 0
+
+              next_value = previous_value.next
+
+              @subject.send("#{scope}=", next_value)
+
+              if allows_value_of(existing_value, @expected_message)
+                @negative_failure_message << 
+                  " (with different value of #{scope})"
+                true
+              else
+                @failure_message << " (with different value of #{scope})"
+                false
+              end
+            end
+          end
+        end
+
+        def class_name
+          @subject.class.name
+        end
+
+        def existing_value
+          value = @existing.send(@attribute)
+          value.swapcase! if @case_insensitive && value.respond_to?(:swapcase!)
+          value
+        end
+      end
+
+    end
+  end
+end

data/lib/shoulda/active_record/matchers/validation_matcher.rb

@@ -0,0 +1,56 @@
+module Shoulda # :nodoc:
+  module ActiveRecord # :nodoc:
+    module Matchers
+
+      class ValidationMatcher # :nodoc:
+
+        attr_reader :failure_message
+
+        def initialize(attribute)
+          @attribute = attribute
+        end
+
+        def negative_failure_message
+          @negative_failure_message || @failure_message
+        end
+
+        def matches?(subject)
+          @subject = subject
+          false
+        end
+
+        private
+
+        def allows_value_of(value, message = nil)
+          allow = AllowValueMatcher.
+            new(value).
+            for(@attribute).
+            with_message(message)
+          if allow.matches?(@subject)
+            @negative_failure_message = allow.failure_message
+            true
+          else
+            @failure_message = allow.negative_failure_message
+            false
+          end
+        end
+
+        def disallows_value_of(value, message = nil)
+          disallow = AllowValueMatcher.
+            new(value).
+            for(@attribute).
+            with_message(message)
+          if disallow.matches?(@subject)
+            @failure_message = disallow.negative_failure_message
+            false
+          else
+            @negative_failure_message = disallow.failure_message
+            true
+          end
+        end
+      end
+
+    end
+  end
+end
+

data/lib/shoulda/active_record/matchers.rb

@@ -0,0 +1,42 @@
+require 'shoulda/active_record/helpers'
+require 'shoulda/active_record/matchers/validation_matcher'
+require 'shoulda/active_record/matchers/allow_value_matcher'
+require 'shoulda/active_record/matchers/ensure_length_of_matcher'
+require 'shoulda/active_record/matchers/ensure_inclusion_of_matcher'
+require 'shoulda/active_record/matchers/validate_presence_of_matcher'
+require 'shoulda/active_record/matchers/validate_uniqueness_of_matcher'
+require 'shoulda/active_record/matchers/validate_acceptance_of_matcher'
+require 'shoulda/active_record/matchers/validate_numericality_of_matcher'
+require 'shoulda/active_record/matchers/association_matcher'
+require 'shoulda/active_record/matchers/have_db_column_matcher'
+require 'shoulda/active_record/matchers/have_index_matcher'
+require 'shoulda/active_record/matchers/have_readonly_attribute_matcher'
+require 'shoulda/active_record/matchers/allow_mass_assignment_of_matcher'
+require 'shoulda/active_record/matchers/have_named_scope_matcher'
+
+
+module Shoulda # :nodoc:
+  module ActiveRecord # :nodoc:
+    # = Matchers for your active record models
+    #
+    # These matchers will test most of the validations and associations for your
+    # ActiveRecord models.
+    #
+    #   describe User do
+    #     it { should validate_presence_of(:name) }
+    #     it { should validate_presence_of(:phone_number) }
+    #     %w(abcd 1234).each do |value|
+    #       it { should_not allow_value(value).for(:phone_number) }
+    #     end
+    #     it { should allow_value("(123) 456-7890").for(:phone_number) }
+    #     it { should_not allow_mass_assignment_of(:password) }
+    #     it { should have_one(:profile) }
+    #     it { should have_many(:dogs) }
+    #     it { should have_many(:messes).through(:dogs) }
+    #     it { should belong_to(:lover) }
+    #   end
+    #
+    module Matchers
+    end
+  end
+end

data/lib/shoulda/active_record.rb

@@ -1,10 +1,14 @@
 require 'shoulda'
+require 'shoulda/active_record/helpers'
+require 'shoulda/active_record/matchers'
 require 'shoulda/active_record/assertions'
 require 'shoulda/active_record/macros'
 
 module Test # :nodoc: all
   module Unit
     class TestCase
+      include Shoulda::ActiveRecord::Helpers
+      include Shoulda::ActiveRecord::Matchers
       include Shoulda::ActiveRecord::Assertions
       extend Shoulda::ActiveRecord::Macros
     end

data/lib/shoulda/assertions.rb

@@ -43,5 +43,17 @@ module Shoulda # :nodoc:
         assert(!collection.include?(x), msg)
       end
     end
+
+    # Asserts that the given matcher returns true when +target+ is passed to #matches?
+    def assert_accepts(matcher, target)
+      success = matcher.matches?(target)
+      assert_block(matcher.failure_message) { success }
+    end
+
+    # Asserts that the given matcher returns false when +target+ is passed to #matches?
+    def assert_rejects(matcher, target)
+      success = !matcher.matches?(target)
+      assert_block(matcher.negative_failure_message) { success }
+    end
   end
 end

data/lib/shoulda/autoload_macros.rb

@@ -0,0 +1,46 @@
+module Shoulda # :nodoc:
+  # Call autoload_macros when you want to load test macros automatically in a non-Rails 
+  # project (it's done automatically for Rails projects).
+  # You don't need to specify ROOT/test/shoulda_macros explicitly. Your custom macros
+  # are loaded automatically when you call autoload_macros.
+  #
+  # The first argument is the path to you application's root directory.
+  # All following arguments are directories relative to your root, which contain 
+  # shoulda_macros subdirectories. These directories support the same kinds of globs as the 
+  # Dir class.
+  # 
+  # Basic usage (from a test_helper):
+  # Shoulda.autoload_macros(File.dirname(__FILE__) + '/..')
+  #	will load everything in 
+  #	- your_app/test/shoulda_macros
+  #
+  #	To load vendored macros as well:
+  # Shoulda.autoload_macros(APP_ROOT, 'vendor/*')
+  #	will load everything in 
+  #	- APP_ROOT/vendor/*/shoulda_macros
+  #	- APP_ROOT/test/shoulda_macros
+  #
+  #	To load macros in an app with a vendor directory laid out like Rails':
+  # Shoulda.autoload_macros(APP_ROOT, 'vendor/{plugins,gems}/*')
+  # or
+  # Shoulda.autoload_macros(APP_ROOT, 'vendor/plugins/*', 'vendor/gems/*')
+  #	will load everything in 
+  #	- APP_ROOT/vendor/plugins/*/shoulda_macros
+  #	- APP_ROOT/vendor/gems/*/shoulda_macros
+  #	- APP_ROOT/test/shoulda_macros
+  #
+  #	If you prefer to stick testing dependencies away from your production dependencies:
+  # Shoulda.autoload_macros(APP_ROOT, 'vendor/*', 'test/vendor/*')
+  #	will load everything in 
+  #	- APP_ROOT/vendor/*/shoulda_macros
+  #	- APP_ROOT/test/vendor/*/shoulda_macros
+  #	- APP_ROOT/test/shoulda_macros
+  def self.autoload_macros(root, *dirs)
+    dirs << File.join('test')
+    complete_dirs = dirs.map{|d| File.join(root, d, 'shoulda_macros')}
+    all_files     = complete_dirs.inject([]){ |files, dir| files + Dir[File.join(dir, '*.rb')] }
+    all_files.each do |file|
+      require file
+    end
+  end
+end

data/lib/shoulda/rails.rb

@@ -8,12 +8,5 @@ require 'shoulda/action_mailer' if defined? ActionMailer::Base
 
 if defined?(RAILS_ROOT)
   # load in the 3rd party macros from vendorized plugins and gems
-  Dir[File.join(RAILS_ROOT, "vendor", "{plugins,gems}", "*", "shoulda_macros", "*.rb")].each do |macro_file_path|
-    require macro_file_path
-  end
-
-  # load in the local application specific macros
-  Dir[File.join(RAILS_ROOT, "test", "shoulda_macros", "*.rb")].each do |macro_file_path|
-    require macro_file_path
-  end
+  Shoulda.autoload_macros RAILS_ROOT, File.join("vendor", "{plugins,gems}", "*")
 end

data/lib/shoulda/rspec.rb

@@ -0,0 +1,5 @@
+require 'shoulda/active_record/matchers'
+
+Spec::Runner.configure do |config|
+  config.include Shoulda::ActiveRecord::Matchers, :type => :model
+end

data/lib/shoulda/tasks/list_tests.rake

@@ -13,7 +13,12 @@ namespace :shoulda do
     test_files = Dir.glob(File.join('test', '**', '*_test.rb'))
     test_files.each do |file|
       load file
-      klass = File.basename(file, '.rb').classify.constantize
+      klass = File.basename(file, '.rb').classify
+      unless Object.const_defined?(klass.to_s)
+        puts "Skipping #{klass} because it doesn't map to a Class"
+        next
+      end
+      klass = klass.constantize
 
       puts klass.name.gsub('Test', '')
 

data/lib/shoulda/test_unit.rb

@@ -0,0 +1,19 @@
+require 'shoulda/context'
+require 'shoulda/proc_extensions'
+require 'shoulda/assertions'
+require 'shoulda/macros'
+require 'shoulda/helpers'
+require 'shoulda/autoload_macros'
+require 'shoulda/rails' if defined? RAILS_ROOT
+
+module Test # :nodoc: all
+  module Unit
+    class TestCase
+      extend Shoulda::ClassMethods
+      include Shoulda::Assertions
+      extend Shoulda::Macros
+      include Shoulda::Helpers
+    end
+  end
+end
+

data/lib/shoulda.rb

@@ -1,21 +1,9 @@
-require 'shoulda/context'
-require 'shoulda/proc_extensions'
-require 'shoulda/assertions'
-require 'shoulda/macros'
-require 'shoulda/helpers'
-require 'shoulda/rails' if defined? RAILS_ROOT
-
 module Shoulda
-  VERSION = "2.0.6.3"
+  VERSION = "2.9.0"
 end
 
-module Test # :nodoc: all
-  module Unit
-    class TestCase
-      extend Shoulda::ClassMethods
-      include Shoulda::Assertions
-      extend Shoulda::Macros
-      include Shoulda::Helpers
-    end
-  end
+if defined? Spec
+  require 'shoulda/rspec'
+else
+  require 'shoulda/test_unit'
 end

data/rails/init.rb

@@ -1 +1 @@
-require 'shoulda/rails'
+require 'shoulda/rails' if RAILS_ENV == 'test'

data/test/README

@@ -6,7 +6,7 @@ The test directory contains the following files and subdirectories:
 
 * rails_root - contains the stripped down rails application that the tests run against.  The rails root contains:
 ** the models, controllers, and views defined under app/
-** the sqlite3.rb environment file
+** the test.rb environment file
 ** a migration file for each model
 ** a shoulda initializer that simulates loading the plugin but without relying on vendor/plugins
 * fixtures - contain the sample DB data for each model
@@ -14,7 +14,7 @@ The test directory contains the following files and subdirectories:
 * unit - model tests for each of the models under rails_root/app
 * other - tests for the shoulda contexts, should statements, and assertions
 * test_helper.rb - responsible for initializing the test environment
-** sets the rails_env to sqlite3
+** sets the rails_env to test
 ** sets the rails_root
 ** runs all the migrations against the in-memory sqlite3 db
 ** adds some magic to load the right fixture files

data/test/fail_macros.rb

@@ -8,8 +8,8 @@ module Shoulda
     # example, to ensure that a set of test macros should fail, do this:
     #
     #   should_fail do
-    #     should_require_attributes :comments
-    #     should_protect_attributes :name
+    #     should_validate_presence_of :comments
+    #     should_not_allow_mass_assignment_of :name
     #   end
     def should_fail(&block)
       context "should fail when trying to run:" do

data/test/matchers/allow_mass_assignment_of_matcher_test.rb

@@ -0,0 +1,68 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class AllowMassAssignmentOfMatcherTest < Test::Unit::TestCase # :nodoc:
+
+  context "an attribute that is blacklisted from mass-assignment" do
+    setup do
+      define_model :example, :attr => :string do
+        attr_protected :attr
+      end
+      @model = Example.new
+    end
+
+    should "reject being mass-assignable" do
+      assert_rejects allow_mass_assignment_of(:attr), @model
+    end
+  end
+
+  context "an attribute that is not whitelisted for mass-assignment" do
+    setup do
+      define_model :example, :attr => :string, :other => :string do
+        attr_accessible :other
+      end
+      @model = Example.new
+    end
+
+    should "reject being mass-assignable" do
+      assert_rejects allow_mass_assignment_of(:attr), @model
+    end
+  end
+
+  context "an attribute that is whitelisted for mass-assignment" do
+    setup do
+      define_model :example, :attr => :string do
+        attr_accessible :attr
+      end
+      @model = Example.new
+    end
+
+    should "accept being mass-assignable" do
+      assert_accepts allow_mass_assignment_of(:attr), @model
+    end
+  end
+
+  context "an attribute not included in the mass-assignment blacklist" do
+    setup do
+      define_model :example, :attr => :string, :other => :string do
+        attr_protected :other
+      end
+      @model = Example.new
+    end
+
+    should "accept being mass-assignable" do
+      assert_accepts allow_mass_assignment_of(:attr), @model
+    end
+  end
+
+  context "an attribute on a class with no protected attributes" do
+    setup do
+      define_model :example, :attr => :string
+      @model = Example.new
+    end
+
+    should "accept being mass-assignable" do
+      assert_accepts allow_mass_assignment_of(:attr), @model
+    end
+  end
+
+end

data/test/matchers/allow_value_matcher_test.rb

@@ -0,0 +1,41 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class AllowValueMatcherTest < Test::Unit::TestCase # :nodoc:
+
+  context "an attribute with a format validation" do
+    setup do
+      define_model :example, :attr => :string do
+        validates_format_of :attr, :with => /abc/
+      end
+      @model = Example.new
+    end
+
+    should "allow a good value" do
+      assert_accepts allow_value("abcde").for(:attr), @model
+    end
+    
+    should "not allow a bad value" do
+      assert_rejects allow_value("xyz").for(:attr), @model
+    end
+  end
+
+  context "an attribute with a format validation and a custom message" do
+    setup do
+      define_model :example, :attr => :string do
+        validates_format_of :attr, :with => /abc/, :message => 'bad value'
+      end
+      @model = Example.new
+    end
+
+    should "allow a good value" do
+      assert_accepts allow_value('abcde').for(:attr).with_message(/bad/),
+                     @model
+    end
+    
+    should "not allow a bad value" do
+      assert_rejects allow_value('xyz').for(:attr).with_message(/bad/),
+                     @model
+    end
+  end
+
+end