shoulda-matchers 2.5.0 → 2.6.0

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

@@ -0,0 +1,157 @@
+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
+          @delegated_arguments = []
+        end
+
+        def matches?(_subject)
+          @subject = _subject
+          ensure_target_method_is_present!
+          stub_target
+
+          begin
+            subject.send(delegating_method, *delegated_arguments)
+            target_has_received_delegated_method? && target_has_received_arguments?
+          rescue NoMethodError
+            false
+          end
+        end
+
+        def description
+          add_clarifications_to(
+            "delegate method ##{delegating_method} to :#{target_method}"
+          )
+        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
+        alias failure_message_for_should failure_message
+
+        private
+
+        attr_reader :delegated_arguments, :delegating_method, :method, :subject,
+          :target_method, :method_on_target
+
+        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 target_has_received_delegated_method?
+          stubbed_target.has_received_method?
+        end
+
+        def target_has_received_arguments?
+          stubbed_target.has_received_arguments?(*delegated_arguments)
+        end
+
+        def stubbed_method
+          method_on_target || delegating_method
+        end
+
+        def stub_target
+          local_stubbed_target = stubbed_target
+          local_target_method = target_method
+
+          subject.instance_eval do
+            define_singleton_method local_target_method do
+              local_stubbed_target
+            end
+          end
+        end
+
+        def stubbed_target
+          @stubbed_target ||= StubbedTarget.new(stubbed_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)`'.squish
+        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/independent/delegate_matcher/stubbed_target.rb

@@ -0,0 +1,34 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module Independent # :nodoc:
+      class DelegateMatcher::StubbedTarget # :nodoc:
+        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
+
+        private
+
+        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

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

@@ -0,0 +1,36 @@
+module Shoulda
+  module Matchers
+    module Integrations
+      module NUnitTestCaseDetection
+        def self.possible_test_case_constants
+          [
+            -> { ActiveSupport::TestCase },
+            -> { Minitest::Test },
+            -> { MiniTest::Unit::TestCase },
+            -> { Test::Unit::TestCase }
+          ]
+        end
+
+        def self.resolve_constant(future_constant)
+          future_constant.call
+        rescue NameError
+          nil
+        end
+
+        def self.detected_test_case_constants
+          possible_test_case_constants.
+            map { |future_constant| resolve_constant(future_constant) }.
+            compact
+        end
+
+        def self.test_case_constants
+          @_test_case_constants ||= detected_test_case_constants
+        end
+      end
+    end
+
+    def self.nunit_test_case_constants
+      Integrations::NUnitTestCaseDetection.test_case_constants
+    end
+  end
+end

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

@@ -1,20 +1,19 @@
 # :enddoc:
-require 'rspec/core'
 
-RSpec.configure do |config|
-  if defined?(::ActiveRecord)
-    require 'shoulda/matchers/active_record'
-    require 'shoulda/matchers/active_model'
-    config.include Shoulda::Matchers::ActiveRecord
-    config.include Shoulda::Matchers::ActiveModel
+if RSpec.respond_to?(:configure)
+  RSpec.configure do |config|
+    config.include Shoulda::Matchers::Independent
 
-  elsif defined?(::ActiveModel)
-    require 'shoulda/matchers/active_model'
-    config.include Shoulda::Matchers::ActiveModel
-  end
+    if defined?(ActiveRecord)
+      config.include Shoulda::Matchers::ActiveRecord
+    end
+
+    if defined?(ActiveModel)
+      config.include Shoulda::Matchers::ActiveModel
+    end
 
-  if defined?(::ActionController)
-    require 'shoulda/matchers/action_controller'
-    config.include Shoulda::Matchers::ActionController
+    if defined?(ActionController)
+      config.include Shoulda::Matchers::ActionController
+    end
   end
 end

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

@@ -1,6 +1,14 @@
-if defined?(ActionController) && defined?(ActionController::TestCase)
-  require 'shoulda/matchers/action_controller'
+# :enddoc:
+require 'shoulda/matchers/integrations/nunit_test_case_detection'
 
+Shoulda::Matchers.nunit_test_case_constants.each do |constant|
+  constant.class_eval do
+    include Shoulda::Matchers::Independent
+    extend Shoulda::Matchers::Independent
+  end
+end
+
+if defined?(ActionController::TestCase)
   ActionController::TestCase.class_eval do
     include Shoulda::Matchers::ActionController
     extend Shoulda::Matchers::ActionController
@@ -11,17 +19,11 @@ if defined?(ActionController) && defined?(ActionController::TestCase)
   end
 end
 
-if defined?(ActiveRecord) && defined?(ActiveSupport::TestCase)
-  require 'shoulda/matchers/active_record'
-
+if defined?(ActiveSupport::TestCase)
   ActiveSupport::TestCase.class_eval do
     include Shoulda::Matchers::ActiveRecord
     extend Shoulda::Matchers::ActiveRecord
   end
-end
-
-if defined?(ActiveModel) && defined?(ActiveSupport::TestCase)
-  require 'shoulda/matchers/active_model'
 
   ActiveSupport::TestCase.class_eval do
     include Shoulda::Matchers::ActiveModel

data/lib/shoulda/matchers/version.rb

@@ -1,5 +1,5 @@
 module Shoulda
   module Matchers
-    VERSION = '2.5.0'.freeze
+    VERSION = '2.6.0'.freeze
   end
 end

data/lib/shoulda/matchers/warn.rb

@@ -0,0 +1,7 @@
+module Shoulda
+  module Matchers
+    def self.warn(msg)
+      Kernel.warn "Warning from shoulda-matchers:\n\n#{msg}"
+    end
+  end
+end

data/shoulda-matchers.gemspec

@@ -21,8 +21,9 @@ Gem::Specification.new do |s|
   s.required_ruby_version = '>= 1.9.2'
   s.add_dependency('activesupport', '>= 3.0.0')
 
-  s.add_development_dependency('appraisal',   '~> 0.4')
+  s.add_development_dependency('appraisal',   '~> 1.0.0.beta2')
   s.add_development_dependency('aruba')
+  s.add_development_dependency('pry')
   s.add_development_dependency('bourne',      '~> 1.3')
   s.add_development_dependency('bundler',     '~> 1.1')
   s.add_development_dependency('cucumber',    '~> 1.1')

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

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActionController::CallbackMatcher do
+  shared_examples 'CallbackMatcher' do |kind, callback_type|
+    let(:matcher) { described_class.new(:authenticate_user!, kind, callback_type) }
+    let(:controller) { define_controller('HookController') }
+
+    describe '#matches?' do
+      it "matches when a #{kind} hook is in place" do
+        add_callback(kind, callback_type, :authenticate_user!)
+
+        expect(matcher.matches?(controller)).to be_true
+      end
+
+      it "does not match when a #{kind} hook is missing" do
+        expect(matcher.matches?(controller)).to be_false
+      end
+    end
+
+    describe 'description' do
+      it 'includes the filter kind and name' do
+        expect(matcher.description).to eq "have :authenticate_user! as a #{kind}_#{callback_type}"
+      end
+    end
+
+    describe 'failure message' do
+      it 'includes the filter kind and name that was expected' do
+        message = "Expected that HookController would have :authenticate_user! as a #{kind}_#{callback_type}"
+
+        expect {
+          expect(controller).to send("use_#{kind}_#{callback_type}", :authenticate_user!)
+        }.to fail_with_message(message)
+      end
+    end
+
+    describe 'failure message when negated' do
+      it 'includes the filter kind and name that was expected' do
+        add_callback(kind, callback_type, :authenticate_user!)
+        message = "Expected that HookController would not have :authenticate_user! as a #{kind}_#{callback_type}"
+
+        expect {
+          expect(controller).not_to send("use_#{kind}_#{callback_type}", :authenticate_user!)
+        }.to fail_with_message(message)
+      end
+    end
+
+    private
+
+    def add_callback(kind, callback_type, callback)
+      controller.send("#{kind}_#{callback_type}", callback)
+    end
+  end
+
+  describe '#use_before_filter' do
+    it_behaves_like 'CallbackMatcher', :before, :filter
+  end
+
+  describe '#use_after_filter' do
+    it_behaves_like 'CallbackMatcher', :after, :filter
+  end
+
+  describe '#use_around_filter' do
+    it_behaves_like 'CallbackMatcher', :around, :filter
+  end
+
+  if rails_4_x?
+    describe '#use_before_action' do
+      it_behaves_like 'CallbackMatcher', :before, :action
+    end
+
+    describe '#use_after_action' do
+      it_behaves_like 'CallbackMatcher', :after, :action
+    end
+
+    describe '#use_around_action' do
+      it_behaves_like 'CallbackMatcher', :around, :action
+    end
+  end
+end

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

@@ -4,16 +4,16 @@ describe Shoulda::Matchers::ActionController::FilterParamMatcher do
   it 'accepts filtering a filtered parameter' do
     filter(:secret)
 
-    nil.should filter_param(:secret)
+    expect(nil).to filter_param(:secret)
   end
 
   it 'rejects filtering an unfiltered parameter' do
     filter(:secret)
     matcher = filter_param(:other)
 
-    matcher.matches?(nil).should be_false
+    expect(matcher.matches?(nil)).to eq false
 
-    matcher.failure_message.should =~ /Expected other to be filtered.*secret/
+    expect(matcher.failure_message).to match(/Expected other to be filtered.*secret/)
   end
 
   def filter(param)

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

@@ -3,40 +3,40 @@ require 'spec_helper'
 describe Shoulda::Matchers::ActionController::RedirectToMatcher do
   context 'a controller that redirects' do
     it 'accepts redirecting to that url' do
-      controller_redirecting_to('/some/url').should redirect_to('/some/url')
+      expect(controller_redirecting_to('/some/url')).to redirect_to('/some/url')
     end
 
     it 'rejects redirecting to a different url' do
-      controller_redirecting_to('/some/url').
-        should_not redirect_to('/some/other/url')
+      expect(controller_redirecting_to('/some/url')).
+        not_to redirect_to('/some/other/url')
     end
 
     it 'accepts redirecting to that url in a block' do
-      controller_redirecting_to('/some/url').
-        should redirect_to('somewhere') { '/some/url' }
+      expect(controller_redirecting_to('/some/url')).
+        to redirect_to('somewhere') { '/some/url' }
     end
 
     it 'rejects redirecting to a different url in a block' do
-      controller_redirecting_to('/some/url').
-        should_not redirect_to('somewhere else') { '/some/other/url' }
+      expect(controller_redirecting_to('/some/url')).
+        not_to redirect_to('somewhere else') { '/some/other/url' }
     end
 
     def controller_redirecting_to(url)
-      build_response { redirect_to url }
+      build_fake_response { redirect_to url }
     end
   end
 
   context 'a controller that does not redirect' do
     it 'rejects redirecting to a url' do
-      controller = build_response { render :text => 'hello' }
+      controller = build_fake_response { render text: 'hello' }
 
-      controller.should_not redirect_to('/some/url')
+      expect(controller).not_to redirect_to('/some/url')
     end
   end
 
   it 'provides the correct description when provided a block' do
     matcher = redirect_to('somewhere else') { '/some/other/url' }
 
-    matcher.description.should eq 'redirect to somewhere else'
+    expect(matcher.description).to eq 'redirect to somewhere else'
   end
 end