shoulda-matchers 2.6.2 → 2.7.0

data/lib/shoulda/matchers/independent/delegate_method_matcher/stubbed_target.rb

@@ -0,0 +1,37 @@
+module Shoulda
+  module Matchers
+    module Independent
+      class DelegateMethodMatcher
+        # @private
+        class StubbedTarget
+          def initialize(method)
+            @received_method = false
+            @received_arguments = []
+            stub_method(method)
+          end
+
+          def has_received_method?
+            received_method
+          end
+
+          def has_received_arguments?(*args)
+            args == received_arguments
+          end
+
+          protected
+
+          def stub_method(method)
+            class_eval do
+              define_method method do |*args|
+                @received_method = true
+                @received_arguments = args
+              end
+            end
+          end
+
+          attr_reader :received_method, :received_arguments
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/independent/delegate_method_matcher/target_not_defined_error.rb

@@ -0,0 +1,15 @@
+module Shoulda
+  module Matchers
+    module Independent
+      class DelegateMethodMatcher
+        # @private
+        class 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)`'.squish
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/version.rb

@@ -1,6 +1,6 @@
 module Shoulda
   module Matchers
     # @private
-    VERSION = '2.6.2'.freeze
+    VERSION = '2.7.0'.freeze
   end
 end

data/lib/shoulda/matchers/warn.rb

@@ -1,8 +1,36 @@
 module Shoulda
   module Matchers
+    TERMINAL_MAX_WIDTH = 72
+
     # @private
-    def self.warn(msg)
-      Kernel.warn "Warning from shoulda-matchers:\n\n#{msg}"
+    def self.warn(message)
+      header = "Warning from shoulda-matchers:"
+      divider = "*" * TERMINAL_MAX_WIDTH
+      wrapped_message = word_wrap(message, TERMINAL_MAX_WIDTH)
+      full_message = [
+        divider,
+        [header, wrapped_message.strip].join("\n\n"),
+        divider
+      ].join("\n")
+
+      Kernel.warn(full_message)
+    end
+
+    # @private
+    def self.warn_about_deprecated_method(old_method, new_method)
+      warn <<EOT
+#{old_method} is deprecated and will be removed in the next major
+release. Please use #{new_method} instead.
+EOT
+    end
+
+    # Source: <https://www.ruby-forum.com/topic/57805>
+    # @private
+    def self.word_wrap(text, width=80)
+      text.
+        gsub(/\n+/, " ").
+        gsub( /(\S{#{width}})(?=\S)/, '\1 ' ).
+        gsub( /(.{1,#{width}})(?:\s+|$)/, "\\1\n" )
     end
   end
 end

data/spec/shoulda/matchers/action_controller/filter_param_matcher_spec.rb

@@ -7,6 +7,12 @@ describe Shoulda::Matchers::ActionController::FilterParamMatcher do
     expect(nil).to filter_param(:secret)
   end
 
+  it 'accepts filtering a parameter matching a filtered regex' do
+    filter(/(?!tip)pin(?!g)/)
+
+    expect(nil).to filter_param(:pin)
+  end
+
   it 'rejects filtering an unfiltered parameter' do
     filter(:secret)
     matcher = filter_param(:other)

data/spec/shoulda/matchers/action_controller/set_session_matcher_spec.rb

@@ -6,6 +6,10 @@ describe Shoulda::Matchers::ActionController::SetSessionMatcher do
       expect(controller_with_session(var: 'hi')).to set_session(:var)
     end
 
+    it 'accepts assigning to that variable with specifying the key by string' do
+      expect(controller_with_session(var: 'hi')).to set_session('var')
+    end
+
     it 'accepts assigning the correct value to that variable' do
       expect(controller_with_session(var: 'hi')).to set_session(:var).to('hi')
     end
@@ -22,22 +26,80 @@ describe Shoulda::Matchers::ActionController::SetSessionMatcher do
       expect(controller_with_session(var: 'hi')).to set_session(:other).to(nil)
     end
 
+    it 'rejects assigning nil to that variable' do
+      expect(controller_with_session(var: 'hi')).not_to set_session(:var).to(nil)
+    end
+
+    it 'accepts assigning nil to cleared variable' do
+      expect(controller_with_session(var: nil)).to set_session(:var).to(nil)
+    end
+
     it 'accepts assigning false to that variable' do
       expect(controller_with_session(var: false)).to set_session(:var).to(false)
     end
 
+    it 'rejects assigning false to other variable' do
+      expect(controller_with_session(var: false)).not_to set_session(:other).to(false)
+    end
+
+    it 'rejects assigning false to a variable with value' do
+      expect(controller_with_session(var: 'hi')).not_to set_session(:other).to(false)
+    end
+
     it 'accepts assigning to the same value in the test context' do
-      expected = 'value'
+      context = stub(expected: 'value')
 
-      expect(controller_with_session(var: expected)).
-        to set_session(:var).in_context(self).to { expected }
+      expect(controller_with_session(var: 'value')).
+        to set_session(:var).in_context(context).to { expected }
     end
 
     it 'rejects assigning to the another value in the test context' do
-      expected = 'other'
+      context = stub(expected: 'other')
 
       expect(controller_with_session(var: 'unexpected')).
-        not_to set_session(:var).in_context(self).to { expected }
+        not_to set_session(:var).in_context(context).to { expected }
+    end
+
+    it 'accepts assigning nil to another variable in the test context' do
+      context = stub(expected: nil)
+
+      expect(controller_with_session(var: 'hi')).
+        to set_session(:other).in_context(context).to { expected }
+    end
+
+    it 'rejects assigning nil to that variable in the test context' do
+      context = stub(expected: nil)
+
+      expect(controller_with_session(var: 'hi')).
+        not_to set_session(:var).in_context(context).to { expected }
+    end
+
+    it 'accepts assigning nil to a cleared variable in the test context' do
+      context = stub(expected: nil)
+
+      expect(controller_with_session(var: nil)).
+        to set_session(:var).in_context(context).to { expected }
+    end
+
+    it 'accepts assigning false to that variable in the test context' do
+      context = stub(expected: false)
+
+      expect(controller_with_session(var: false)).
+        to set_session(:var).in_context(context).to { expected }
+    end
+
+    it 'accepts assigning false to other variable in the test context' do
+      context = stub(expected: false)
+
+      expect(controller_with_session(var: false)).
+        not_to set_session(:other).in_context(context).to { expected }
+    end
+
+    it 'accepts assigning false to other variable in the test context' do
+      context = stub(expected: false)
+
+      expect(controller_with_session(var: 'hi')).
+        not_to set_session(:var).in_context(context).to { expected }
     end
 
     def controller_with_session(session_hash)

data/spec/shoulda/matchers/action_controller/strong_parameters_matcher_spec.rb

@@ -72,7 +72,7 @@ describe Shoulda::Matchers::ActionController::StrongParametersMatcher do
       end
 
       matcher = described_class.new([:name]).in_context(self).for(:create)
-      expect(matcher.matches?(@controller)).to be_true
+      expect(matcher.matches?(@controller)).to be true
     end
 
     it 'is true for all the allowable attributes' do
@@ -81,7 +81,7 @@ describe Shoulda::Matchers::ActionController::StrongParametersMatcher do
       end
 
       matcher = described_class.new([:name, :age]).in_context(self).for(:create)
-      expect(matcher.matches?(@controller)).to be_true
+      expect(matcher.matches?(@controller)).to be true
     end
 
     it 'is false when any attributes are not allowed' do
@@ -90,14 +90,14 @@ describe Shoulda::Matchers::ActionController::StrongParametersMatcher do
       end
 
       matcher = described_class.new([:name, :admin]).in_context(self).for(:create)
-      expect(matcher.matches?(@controller)).to be_false
+      expect(matcher.matches?(@controller)).to be false
     end
 
     it 'is false when permit is not called' do
       controller_for_resource_with_strong_parameters(action: :create)
 
       matcher = described_class.new([:name]).in_context(self).for(:create)
-      expect(matcher.matches?(@controller)).to be_false
+      expect(matcher.matches?(@controller)).to be false
     end
 
     it 'requires an action' do
@@ -129,7 +129,7 @@ describe Shoulda::Matchers::ActionController::StrongParametersMatcher do
       matcher = described_class.new([:name]).
         in_context(self).
         for(:show, verb: :get, params: { slug: 'foo' })
-      expect(matcher.matches?(@controller)).to be_true
+      expect(matcher.matches?(@controller)).to be true
     end
 
     it 'works with #update specifically' do
@@ -140,7 +140,7 @@ describe Shoulda::Matchers::ActionController::StrongParametersMatcher do
       matcher = described_class.new([:name]).
         in_context(self).
         for(:update, params: { id: 1 })
-      expect(matcher.matches?(@controller)).to be_true
+      expect(matcher.matches?(@controller)).to be true
     end
 
     it 'does not raise an error when #fetch was used instead of #require (issue #495)' do
@@ -151,7 +151,7 @@ describe Shoulda::Matchers::ActionController::StrongParametersMatcher do
       matcher = described_class.new([:eta, :diner_id]).
         in_context(self).
         for(:create)
-      expect(matcher.matches?(@controller)).to be_true
+      expect(matcher.matches?(@controller)).to be true
     end
 
     it 'tracks multiple calls to #permit' do
@@ -167,12 +167,12 @@ describe Shoulda::Matchers::ActionController::StrongParametersMatcher do
       matcher = described_class.new(sets_of_attributes[0]).
         in_context(self).
         for(:create)
-      expect(matcher.matches?(@controller)).to be_true
+      expect(matcher.matches?(@controller)).to be true
 
       matcher = described_class.new(sets_of_attributes[1]).
         in_context(self).
         for(:create)
-      expect(matcher.matches?(@controller)).to be_true
+      expect(matcher.matches?(@controller)).to be true
     end
 
     context 'stubbing params on the controller' do

data/spec/shoulda/matchers/active_model/validate_absence_of_matcher_spec.rb

@@ -2,6 +2,21 @@ require 'spec_helper'
 
 describe Shoulda::Matchers::ActiveModel::ValidateAbsenceOfMatcher do
   if active_model_4_0?
+    def self.available_column_types
+      [
+        :string,
+        :text,
+        :integer,
+        :float,
+        :decimal,
+        :datetime,
+        :timestamp,
+        :time,
+        :date,
+        :binary
+      ]
+    end
+
     context 'a model with an absence validation' do
       it 'accepts' do
         expect(validating_absence_of(:attr)).to validate_absence_of(:attr)
@@ -10,6 +25,15 @@ describe Shoulda::Matchers::ActiveModel::ValidateAbsenceOfMatcher do
       it 'does not override the default message with a present' do
         expect(validating_absence_of(:attr)).to validate_absence_of(:attr).with_message(nil)
       end
+
+      available_column_types.each do |type|
+        context "when column is of type #{type}" do
+          it "accepts" do
+            expect(validating_absence_of(:attr, {}, type: type)).
+              to validate_absence_of(:attr)
+          end
+        end
+      end
     end
 
     context 'a model without an absence validation' do
@@ -95,9 +119,12 @@ describe Shoulda::Matchers::ActiveModel::ValidateAbsenceOfMatcher do
       end
     end
 
-    def validating_absence_of(attr, options = {})
-      define_model :example, attr => :string do
-        validates_absence_of attr, options
+    def validating_absence_of(attr, validation_options = {}, given_column_options = {})
+      default_column_options = { type: :string, options: {} }
+      column_options = default_column_options.merge(given_column_options)
+
+      define_model :example, attr => column_options do
+        validates_absence_of attr, validation_options
       end.new
     end
 

data/spec/shoulda/matchers/active_model/{ensure_exclusion_of_matcher_spec.rb → validate_exclusion_of_matcher_spec.rb}

@@ -1,39 +1,55 @@
 require 'spec_helper'
 
-describe Shoulda::Matchers::ActiveModel::EnsureExclusionOfMatcher do
+describe Shoulda::Matchers::ActiveModel do
+  describe '#ensure_exclusion_of' do
+    it 'is aliased to #validate_exclusion_of' do
+      matchers.expects(:validate_exclusion_of).with(:attr)
+
+      silence_warnings do
+        matchers.ensure_exclusion_of(:attr)
+      end
+    end
+  end
+
+  def matchers
+    @_matchers ||= Object.new.extend(described_class)
+  end
+end
+
+describe Shoulda::Matchers::ActiveModel::ValidateExclusionOfMatcher do
   context 'an attribute which must be excluded from a range' do
     it 'accepts ensuring the correct range' do
       expect(validating_exclusion(in: 2..5)).
-        to ensure_exclusion_of(:attr).in_range(2..5)
+        to validate_exclusion_of(:attr).in_range(2..5)
     end
 
     it 'rejects ensuring excluded value' do
       expect(validating_exclusion(in: 2..5)).
-        not_to ensure_exclusion_of(:attr).in_range(2..6)
+        not_to validate_exclusion_of(:attr).in_range(2..6)
     end
 
     it 'does not override the default message with a blank' do
       expect(validating_exclusion(in: 2..5)).
-        to ensure_exclusion_of(:attr).in_range(2..5).with_message(nil)
+        to validate_exclusion_of(:attr).in_range(2..5).with_message(nil)
     end
   end
 
   context 'an attribute which must be excluded from a range with excluded end' do
     it 'accepts ensuring the correct range' do
       expect(validating_exclusion(in: 2...5)).
-        to ensure_exclusion_of(:attr).in_range(2...5)
+        to validate_exclusion_of(:attr).in_range(2...5)
     end
 
     it 'rejects ensuring excluded value' do
       expect(validating_exclusion(in: 2...5)).
-        not_to ensure_exclusion_of(:attr).in_range(2...4)
+        not_to validate_exclusion_of(:attr).in_range(2...4)
     end
   end
 
   context 'an attribute with a custom validation message' do
     it 'accepts ensuring the correct range' do
       expect(validating_exclusion(in: 2..4, message: 'not good')).
-        to ensure_exclusion_of(:attr).in_range(2..4).with_message(/not good/)
+        to validate_exclusion_of(:attr).in_range(2..4).with_message(/not good/)
     end
   end
 
@@ -45,7 +61,7 @@ describe Shoulda::Matchers::ActiveModel::EnsureExclusionOfMatcher do
         end
       end
 
-      expect(model).to ensure_exclusion_of(:attr).in_range(2..5).
+      expect(model).to validate_exclusion_of(:attr).in_range(2..5).
         with_message(/should be out of this range/)
 
       model = custom_validation do
@@ -54,7 +70,7 @@ describe Shoulda::Matchers::ActiveModel::EnsureExclusionOfMatcher do
         end
       end
 
-      expect(model).to ensure_exclusion_of(:attr).in_range(2...5).
+      expect(model).to validate_exclusion_of(:attr).in_range(2...5).
         with_message(/should be out of this range/)
     end
   end
@@ -62,21 +78,21 @@ describe Shoulda::Matchers::ActiveModel::EnsureExclusionOfMatcher do
   context 'an attribute which must be excluded from an array' do
     it 'accepts with correct array' do
       expect(validating_exclusion(in: %w(one two))).
-        to ensure_exclusion_of(:attr).in_array(%w(one two))
+        to validate_exclusion_of(:attr).in_array(%w(one two))
     end
 
     it 'rejects when only part of array matches' do
       expect(validating_exclusion(in: %w(one two))).
-        not_to ensure_exclusion_of(:attr).in_array(%w(one wrong_value))
+        not_to validate_exclusion_of(:attr).in_array(%w(one wrong_value))
     end
 
     it 'rejects when array does not match at all' do
       expect(validating_exclusion(in: %w(one two))).
-        not_to ensure_exclusion_of(:attr).in_array(%w(cat dog))
+        not_to validate_exclusion_of(:attr).in_array(%w(cat dog))
     end
 
     it 'has correct description' do
-      expect(ensure_exclusion_of(:attr).in_array([true, 'dog']).description).
+      expect(validate_exclusion_of(:attr).in_array([true, 'dog']).description).
         to eq 'ensure exclusion of attr in [true, "dog"]'
     end