shoulda-matchers 1.4.1 → 1.4.2

data/lib/shoulda/matchers/active_model/only_integer_matcher.rb

@@ -0,0 +1,33 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveModel # :nodoc:
+      class OnlyIntegerMatcher # :nodoc:
+        NON_INTEGER_VALUE = 0.1
+
+        def initialize(attribute)
+          @attribute = attribute
+          @disallow_value_matcher = DisallowValueMatcher.new(NON_INTEGER_VALUE).
+            for(attribute).
+            with_message(:not_an_integer)
+        end
+
+        def matches?(subject)
+          @disallow_value_matcher.matches?(subject)
+        end
+
+        def with_message(message)
+          @disallow_value_matcher.with_message(message)
+          self
+        end
+
+        def allowed_types
+          "integer"
+        end
+
+        def failure_message
+          @disallow_value_matcher.failure_message
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/active_model/validate_numericality_of_matcher.rb

@@ -17,55 +17,74 @@ module Shoulda # :nodoc:
         ValidateNumericalityOfMatcher.new(attr)
       end
 
-      class ValidateNumericalityOfMatcher < ValidationMatcher # :nodoc:
+      class ValidateNumericalityOfMatcher
+        NON_NUMERIC_VALUE = 'abcd'
+
         def initialize(attribute)
-          super(attribute)
+          @attribute = attribute
           @options = {}
+          @submatchers = []
+
+          add_disallow_value_matcher
         end
 
         def only_integer
-          @options[:only_integer] = true
+          only_integer_matcher = OnlyIntegerMatcher.new(@attribute)
+          add_submatcher(only_integer_matcher)
           self
         end
 
         def with_message(message)
-          if message
-            @expected_message = message
-          end
+          @submatchers.each { |matcher| matcher.with_message(message) }
           self
         end
 
         def matches?(subject)
-          super(subject)
-          disallows_non_integers? && disallows_text?
+          @subject = subject
+          submatchers_match?
         end
 
         def description
-          "only allow #{allowed_type} values for #{@attribute}"
+          "only allow #{allowed_types} values for #{@attribute}"
+        end
+
+        def failure_message
+          submatcher_failure_messages.last
         end
 
         private
 
-        def allowed_type
-          if @options[:only_integer]
-            "integer"
-          else
-            "numeric"
-          end
+        def add_disallow_value_matcher
+          disallow_value_matcher = DisallowValueMatcher.new(NON_NUMERIC_VALUE).
+            for(@attribute).
+            with_message(:not_a_number)
+
+          add_submatcher(disallow_value_matcher)
+        end
+
+        def add_submatcher(submatcher)
+          @submatchers << submatcher
+        end
+
+        def submatchers_match?
+          failing_submatchers.empty?
+        end
+
+        def submatcher_failure_messages
+          failing_submatchers.map(&:failure_message)
+        end
+
+        def failing_submatchers
+          @failing_submatchers ||= @submatchers.select { |matcher| !matcher.matches?(@subject) }
         end
 
-        def disallows_non_integers?
-          if @options[:only_integer]
-            message = @expected_message || :not_an_integer
-            disallows_value_of(0.1, message)
-          else
-            true
-          end
+        def allowed_types
+          allowed = ["numeric"] + submatcher_allowed_types
+          allowed.join(", ")
         end
 
-        def disallows_text?
-          message = @expected_message || :not_a_number
-          disallows_value_of('abcd', message)
+        def submatcher_allowed_types
+          @submatchers.map(&:allowed_types).reject(&:empty?)
         end
       end
     end

data/lib/shoulda/matchers/independent.rb

@@ -0,0 +1,9 @@
+require 'shoulda/matchers/independent/delegate_matcher'
+
+module Shoulda
+  module Matchers
+    # = Matchers for non-Rails-dependent code.
+    module Independent
+    end
+  end
+end

data/lib/shoulda/matchers/independent/delegate_matcher.rb

@@ -0,0 +1,124 @@
+require 'bourne'
+
+module Shoulda # :nodoc:
+  module Matchers
+    module Independent # :nodoc:
+
+      # Ensure that a given method is delegated properly.
+      #
+      # Basic Syntax:
+      #   it { should delegate_method(:deliver_mail).to(:mailman) }
+      #
+      # Options:
+      # * <tt>:as</tt> - tests that the object being delegated to is called with a certain method (defaults to same name as delegating method)
+      # * <tt>:with_arguments</tt> - tests that the method on the object being delegated to is called with certain arguments
+      #
+      # Examples:
+      #   it { should delegate_method(:deliver_mail).to(:mailman).as(:deliver_with_haste)
+      #   it { should delegate_method(:deliver_mail).to(:mailman).with_arguments('221B Baker St.', :hastily => true)
+      #
+      def delegate_method(delegating_method)
+        DelegateMatcher.new(delegating_method)
+      end
+
+      class DelegateMatcher
+        def initialize(delegating_method)
+          @delegating_method = delegating_method
+        end
+
+        def matches?(subject)
+          @subject = subject
+          ensure_target_method_is_present!
+
+          begin
+            extend Mocha::API
+
+            stubbed_object = stub(method_on_target)
+            subject.stubs(@target_method).returns(stubbed_object)
+            subject.send(@delegating_method)
+
+            stubbed_object.should have_received(method_on_target).with(*@delegated_arguments)
+          rescue NoMethodError, RSpec::Expectations::ExpectationNotMetError, Mocha::ExpectationError
+            false
+          end
+        end
+
+        def does_not_match?(subject)
+          raise InvalidDelegateMatcher
+        end
+
+        def to(target_method)
+          @target_method = target_method
+          self
+        end
+
+        def as(method_on_target)
+          @method_on_target = method_on_target
+          self
+        end
+
+        def with_arguments(*arguments)
+          @delegated_arguments = arguments
+          self
+        end
+
+        def failure_message
+          base = "Expected #{delegating_method_name} to delegate to #{target_method_name}"
+          add_clarifications_to(base)
+        end
+
+        private
+
+        def add_clarifications_to(message)
+          if @delegated_arguments.present?
+            message << " with arguments: #{@delegated_arguments.inspect}"
+          end
+
+          if @method_on_target.present?
+            message << " as :#{@method_on_target}"
+          end
+
+          message
+        end
+
+        def delegating_method_name
+          method_name_with_class(@delegating_method)
+        end
+
+        def target_method_name
+          method_name_with_class(@target_method)
+        end
+
+        def method_name_with_class(method)
+          if Class === @subject
+            @subject.name + '.' + method.to_s
+          else
+            @subject.class.name + '#' + method.to_s
+          end
+        end
+
+        def method_on_target
+          @method_on_target || @delegating_method
+        end
+
+        def ensure_target_method_is_present!
+          if @target_method.blank?
+            raise TargetNotDefinedError
+          end
+        end
+      end
+
+      class DelegateMatcher::TargetNotDefinedError < StandardError
+        def message
+          'Delegation needs a target. Use the #to method to define one, e.g. `post_office.should delegate(:deliver_mail).to(:mailman)`'
+        end
+      end
+
+      class DelegateMatcher::InvalidDelegateMatcher < StandardError
+        def message
+          '#delegate_to does not support #should_not syntax.'
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/integrations/rspec.rb

@@ -1,5 +1,10 @@
 # :enddoc:
 
+require 'shoulda/matchers/independent'
+module RSpec::Matchers
+  include Shoulda::Matchers::Independent
+end
+
 if defined?(::ActiveRecord)
   require 'shoulda/matchers/active_record'
   require 'shoulda/matchers/active_model'

data/lib/shoulda/matchers/integrations/test_unit.rb

@@ -1,4 +1,15 @@
 # :enddoc:
+require 'test/unit/testcase'
+require 'shoulda/matchers/independent'
+
+module Test
+  module Unit
+    class TestCase
+      include Shoulda::Matchers::Independent
+      extend Shoulda::Matchers::Independent
+    end
+  end
+end
 
 if defined?(ActionController)
   require 'shoulda/matchers/action_controller'

data/lib/shoulda/matchers/version.rb

@@ -1,5 +1,5 @@
 module Shoulda
   module Matchers
-    VERSION = '1.4.1'.freeze
+    VERSION = '1.4.2'.freeze
   end
 end

data/shoulda-matchers.gemspec

@@ -18,10 +18,10 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   s.add_dependency('activesupport', '>= 3.0.0')
+  s.add_dependency('bourne',        '~> 1.1.2')
 
   s.add_development_dependency('appraisal',   '~> 0.4.0')
   s.add_development_dependency('aruba')
-  s.add_development_dependency('bourne',      '~> 1.1.2')
   s.add_development_dependency('bundler',     '~> 1.1')
   s.add_development_dependency('cucumber',    '~> 1.1.9')
   s.add_development_dependency('rails',       '~> 3.0')

data/spec/shoulda/active_model/disallow_value_matcher_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::DisallowValueMatcher do
+  it "does not allow any types" do
+    matcher = Shoulda::Matchers::ActiveModel::DisallowValueMatcher.new("abcde")
+    matcher.allowed_types.should == ""
+  end
+
+  context "an attribute with a format validation" do
+    before do
+      define_model :example, :attr => :string do
+        validates_format_of :attr, :with => /abc/
+      end
+      @model = Example.new
+    end
+
+    it "does not match if the value is allowed" do
+      matcher = new_matcher("abcde")
+      matcher.for(:attr)
+      matcher.matches?(@model).should be_false
+    end
+
+    it "matches if the value is not allowed" do
+      matcher = new_matcher("xyz")
+      matcher.for(:attr)
+      matcher.matches?(@model).should be_true
+    end
+  end
+
+  context "an attribute with a format validation and a custom message" do
+    before do
+      define_model :example, :attr => :string do
+        validates_format_of :attr, :with => /abc/, :message => 'good message'
+      end
+      @model = Example.new
+    end
+
+    it "does not match if the value and message are both correct" do
+      matcher = new_matcher("abcde")
+      matcher.for(:attr).with_message('good message')
+      matcher.matches?(@model).should be_false
+    end
+
+    it "delegates its failure message to its allow matcher's negative failure message" do
+      allow_matcher = stub_everything(:negative_failure_message => "allow matcher failure")
+      Shoulda::Matchers::ActiveModel::AllowValueMatcher.stubs(:new).returns(allow_matcher)
+
+      matcher = new_matcher("abcde")
+      matcher.for(:attr).with_message('good message')
+      matcher.matches?(@model)
+
+      matcher.failure_message.should == "allow matcher failure"
+    end
+
+    it "matches if the message is correct but the value is not" do
+      matcher = new_matcher("xyz")
+      matcher.for(:attr).with_message('good message')
+      matcher.matches?(@model).should be_true
+    end
+  end
+
+  def new_matcher(value)
+    matcher = Shoulda::Matchers::ActiveModel::DisallowValueMatcher.new(value)
+  end
+end

data/spec/shoulda/active_model/only_integer_matcher_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::OnlyIntegerMatcher do
+  context "given an attribute that only allows integer values" do
+    before do
+      define_model :example, :attr => :string do
+        validates_numericality_of :attr, { :only_integer => true }
+      end
+      @model = Example.new
+    end
+
+    it "matches" do
+      matcher = new_matcher(:attr)
+      matcher.matches?(@model).should be_true
+    end
+
+    it "allows integer types" do
+      matcher = new_matcher(:attr)
+      matcher.allowed_types.should == "integer"
+    end
+
+    it "returns itself when given a message" do
+      matcher = new_matcher(:attr)
+      matcher.with_message("some message").should == matcher
+    end
+  end
+
+  context "given an attribute that only allows integer values with a custom validation message" do
+    before do
+      define_model :example, :attr => :string do
+        validates_numericality_of :attr, { :only_integer => true, :message => 'custom' }
+      end
+      @model = Example.new
+    end
+
+    it "should only allow integer values for that attribute with that message" do
+      matcher = new_matcher(:attr)
+      matcher.with_message(/custom/)
+      matcher.matches?(@model).should be_true
+    end
+
+    it "should not allow integer values for that attribute with another message" do
+      matcher = new_matcher(:attr)
+      matcher.with_message(/wrong/)
+      matcher.matches?(@model).should be_false
+    end
+  end
+
+  context "given an attribute that allows values other than integers" do
+    before do
+      @model = define_model(:example, :attr => :string).new
+    end
+
+    it "does not match" do
+      matcher = new_matcher(:attr)
+      matcher.matches?(@model).should be_false
+    end
+
+    it "should fail with the ActiveRecord :not_an_integer message" do
+      matcher = new_matcher(:attr)
+      matcher.matches?(@model)
+      matcher.failure_message.should include 'Expected errors to include "must be an integer"'
+    end
+  end
+
+  def new_matcher(attribute)
+    matcher = Shoulda::Matchers::ActiveModel::OnlyIntegerMatcher.new(attribute)
+  end
+end