shoulda-matchers 3.1.3 → 4.0.0.rc1

data/spec/unit/shoulda/matchers/doublespeak/world_spec.rb

@@ -33,10 +33,8 @@ module Shoulda::Matchers::Doublespeak
         block_called = false
         double_collections = Array.new(3) { build_double_collection }
         double_collections.each do |double_collection|
-          allow(double_collection).to receive(:activate).ordered
-        end
-        double_collections.each do |double_collection|
-          allow(double_collection).to receive(:deactivate).ordered
+          allow(double_collection).to receive(:activate)
+          allow(double_collection).to receive(:deactivate)
         end
         klasses = Array.new(3) { |i| "Klass #{i}" }
         world = described_class.new

data/spec/unit/shoulda/matchers/independent/delegate_method_matcher_spec.rb

@@ -8,7 +8,7 @@ describe Shoulda::Matchers::Independent::DelegateMethodMatcher do
       context 'without any qualifiers' do
         it 'states that it should delegate method to the right object' do
           matcher = delegate_method(:method_name).to(:delegate)
-          message = 'delegate #method_name to #delegate object'
+          message = 'delegate #method_name to the #delegate object'
 
           expect(matcher.description).to eq message
         end
@@ -17,7 +17,7 @@ describe Shoulda::Matchers::Independent::DelegateMethodMatcher do
       context 'qualified with #as' do
         it 'states that it should delegate method to the right object and method' do
           matcher = delegate_method(:method_name).to(:delegate).as(:alternate)
-          message = 'delegate #method_name to #delegate object as #alternate'
+          message = 'delegate #method_name to the #delegate object as #alternate'
 
           expect(matcher.description).to eq message
         end
@@ -27,7 +27,7 @@ describe Shoulda::Matchers::Independent::DelegateMethodMatcher do
         it 'states that it should delegate method to the right object with right argument' do
           matcher = delegate_method(:method_name).to(:delegate).
             with_arguments(:foo, bar: [1, 2])
-          message = 'delegate #method_name to #delegate object passing arguments [:foo, {:bar=>[1, 2]}]'
+          message = 'delegate #method_name to the #delegate object passing arguments [:foo, {:bar=>[1, 2]}]'
 
           expect(matcher.description).to eq message
         end
@@ -53,7 +53,7 @@ describe Shoulda::Matchers::Independent::DelegateMethodMatcher do
 
               matcher = delegate_method(:hello).to(:country).with_prefix
               expect(matcher.description).
-                to eq('delegate #country_hello to #country object as #hello')
+                to eq('delegate #country_hello to the #country object as #hello')
             end
           end
         end
@@ -77,7 +77,7 @@ describe Shoulda::Matchers::Independent::DelegateMethodMatcher do
 
               matcher = delegate_method(:hello).to(:country).with_prefix(true)
               expect(matcher.description).
-                to eq('delegate #country_hello to #country object as #hello')
+                to eq('delegate #country_hello to the #country object as #hello')
             end
           end
         end
@@ -98,7 +98,7 @@ describe Shoulda::Matchers::Independent::DelegateMethodMatcher do
 
             matcher = delegate_method(:hello).to(:country).with_prefix('county')
             expect(matcher.description).
-              to eq('delegate #county_hello to #country object as #hello')
+              to eq('delegate #county_hello to the #country object as #hello')
           end
         end
       end
@@ -112,14 +112,14 @@ describe Shoulda::Matchers::Independent::DelegateMethodMatcher do
           matcher = delegate_method(:method_name).to(:delegate)
 
           expect(matcher.description).
-            to eq 'delegate .method_name to .delegate object'
+            to eq 'delegate .method_name to the .delegate object'
         end
       end
 
       context 'qualified with #as' do
         it 'states that it should delegate method to the right object and method' do
           matcher = delegate_method(:method_name).to(:delegate).as(:alternate)
-          message = 'delegate .method_name to .delegate object as .alternate'
+          message = 'delegate .method_name to the .delegate object as .alternate'
 
           expect(matcher.description).to eq message
         end
@@ -129,7 +129,7 @@ describe Shoulda::Matchers::Independent::DelegateMethodMatcher do
         it 'states that it should delegate method to the right object with right argument' do
           matcher = delegate_method(:method_name).to(:delegate).
             with_arguments(:foo, bar: [1, 2])
-          message = 'delegate .method_name to .delegate object passing arguments [:foo, {:bar=>[1, 2]}]'
+          message = 'delegate .method_name to the .delegate object passing arguments [:foo, {:bar=>[1, 2]}]'
 
           expect(matcher.description).to eq message
         end
@@ -178,7 +178,8 @@ describe Shoulda::Matchers::Independent::DelegateMethodMatcher do
       it 'rejects with the correct failure message' do
         post_office = PostOffice.new
         message = [
-          'Expected PostOffice to delegate #deliver_mail to #mailman object',
+          'Expected PostOffice to delegate #deliver_mail to the #mailman object.',
+          '',
           'Method calls sent to PostOffice#mailman: (none)'
         ].join("\n")
 
@@ -191,7 +192,8 @@ describe Shoulda::Matchers::Independent::DelegateMethodMatcher do
     context 'when the subject is a class' do
       it 'uses the proper syntax for class methods in errors' do
         message = [
-          'Expected PostOffice to delegate .deliver_mail to .mailman object',
+          'Expected PostOffice to delegate .deliver_mail to the .mailman object.',
+          '',
           'Method calls sent to PostOffice.mailman: (none)'
         ].join("\n")
 
@@ -225,7 +227,7 @@ describe Shoulda::Matchers::Independent::DelegateMethodMatcher do
     context 'negating the matcher' do
       it 'rejects with the correct failure message' do
         post_office = PostOffice.new
-        message = 'Expected PostOffice not to delegate #deliver_mail to #mailman object, but it did'
+        message = 'Expected PostOffice not to delegate #deliver_mail to the #mailman object, but it did.'
 
         expect {
           expect(post_office).not_to delegate_method(:deliver_mail).to(:mailman)
@@ -283,7 +285,7 @@ describe Shoulda::Matchers::Independent::DelegateMethodMatcher do
         context 'negating the matcher' do
           it 'rejects with the correct failure message' do
             post_office = PostOffice.new
-            message = 'Expected PostOffice not to delegate #deliver_mail to #mailman object passing arguments ["221B Baker St.", {:hastily=>true}], but it did'
+            message = 'Expected PostOffice not to delegate #deliver_mail to the #mailman object passing arguments ["221B Baker St.", {:hastily=>true}], but it did.'
 
             expect {
               expect(post_office).
@@ -299,8 +301,11 @@ describe Shoulda::Matchers::Independent::DelegateMethodMatcher do
         it 'rejects with the correct failure message' do
           post_office = PostOffice.new
           message = [
-            'Expected PostOffice to delegate #deliver_mail to #mailman object passing arguments ["123 Nowhere Ln."]',
+            'Expected PostOffice to delegate #deliver_mail to the #mailman object',
+            'passing arguments ["123 Nowhere Ln."].',
+            '',
             'Method calls sent to PostOffice#mailman:',
+            '',
             '1) deliver_mail("221B Baker St.", {:hastily=>true})'
           ].join("\n")
 
@@ -338,7 +343,7 @@ describe Shoulda::Matchers::Independent::DelegateMethodMatcher do
       context 'negating the assertion' do
         it 'rejects with the correct failure message' do
           post_office = PostOffice.new
-          message = 'Expected PostOffice not to delegate #deliver_mail to #mailman object as #deliver_mail_and_avoid_dogs, but it did'
+          message = 'Expected PostOffice not to delegate #deliver_mail to the #mailman object as #deliver_mail_and_avoid_dogs, but it did.'
 
           expect {
             expect(post_office).
@@ -354,8 +359,11 @@ describe Shoulda::Matchers::Independent::DelegateMethodMatcher do
       it 'rejects with the correct failure message' do
         post_office = PostOffice.new
         message = [
-          'Expected PostOffice to delegate #deliver_mail to #mailman object as #watch_tv',
+          'Expected PostOffice to delegate #deliver_mail to the #mailman object as',
+          '#watch_tv.',
+          '',
           'Method calls sent to PostOffice#mailman:',
+          '',
           '1) deliver_mail_and_avoid_dogs()'
         ].join("\n")
 
@@ -401,7 +409,9 @@ describe Shoulda::Matchers::Independent::DelegateMethodMatcher do
           end
 
           message = [
-            'Expected Person to delegate #country_hello to #country object as #hello',
+            'Expected Person to delegate #country_hello to the #country object as',
+            '#hello.',
+            '',
             'Method calls sent to Person#country: (none)'
           ].join("\n")
 
@@ -449,7 +459,9 @@ describe Shoulda::Matchers::Independent::DelegateMethodMatcher do
           end
 
           message = [
-            'Expected Person to delegate #country_hello to #country object as #hello',
+            'Expected Person to delegate #country_hello to the #country object as',
+            '#hello.',
+            '',
             'Method calls sent to Person#country: (none)'
           ].join("\n")
 
@@ -499,7 +511,9 @@ describe Shoulda::Matchers::Independent::DelegateMethodMatcher do
           end
 
           message = [
-            'Expected Person to delegate #county_hello to #country object as #hello',
+            'Expected Person to delegate #county_hello to the #country object as',
+            '#hello.',
+            '',
             'Method calls sent to Person#country: (none)'
           ].join("\n")
 
@@ -514,4 +528,123 @@ describe Shoulda::Matchers::Independent::DelegateMethodMatcher do
       end
     end
   end
+
+  context 'qualified with #allow_nil' do
+    context 'when using delegate from Rails' do
+      context 'when delegations were defined with :allow_nil' do
+        it 'accepts' do
+          define_class('Person') do
+            delegate :hello, to: :country, allow_nil: true
+            def country; end
+          end
+
+          person = Person.new
+
+          expect(person).to delegate_method(:hello).to(:country).allow_nil
+        end
+      end
+
+      context 'when delegations were not defined with :allow_nil' do
+        it 'rejects with the correct failure message' do
+          define_class('Person') do
+            delegate :hello, to: :country
+            def country; end
+          end
+
+          person = Person.new
+
+          message = <<-MESSAGE
+Expected Person to delegate #hello to the #country object, allowing
+#country to return nil.
+
+Person#hello did delegate to #country when it was non-nil, but it failed
+to account for when #country *was* nil.
+          MESSAGE
+
+          expectation = lambda do
+            expect(person).to delegate_method(:hello).to(:country).allow_nil
+          end
+
+          expect(&expectation).to fail_with_message(message)
+        end
+      end
+    end
+
+    context 'when using Forwardable' do
+      context 'when the delegate object is nil' do
+        it 'rejects with the correct failure message' do
+          define_class('Person') do
+            extend Forwardable
+
+            def_delegators :country, :hello
+
+            def country; end
+          end
+
+          person = Person.new
+
+          message = <<-MESSAGE
+Expected Person to delegate #hello to the #country object, allowing
+#country to return nil.
+
+Person#hello did delegate to #country when it was non-nil, but it failed
+to account for when #country *was* nil.
+          MESSAGE
+
+          expectation = lambda do
+            expect(person).to delegate_method(:hello).to(:country).allow_nil
+          end
+
+          expect(&expectation).to fail_with_message(message)
+        end
+      end
+    end
+
+    context 'when delegating manually' do
+      context 'when the delegating method accounts for the delegate object being nil' do
+        it 'accepts' do
+          define_class('Person') do
+            def country; end
+
+            def hello
+              return unless country
+              country.hello
+            end
+          end
+
+          person = Person.new
+
+          expect(person).to delegate_method(:hello).to(:country).allow_nil
+        end
+      end
+
+      context 'when the delegating method does not account for the delegate object being nil' do
+        it 'rejects with the correct failure message' do
+          define_class('Person') do
+            def country; end
+
+            def hello
+              country.hello
+            end
+          end
+
+          person = Person.new
+
+          message = <<-MESSAGE
+Expected Person to delegate #hello to the #country object, allowing
+#country to return nil.
+
+Person#hello did delegate to #country when it was non-nil, but it failed
+to account for when #country *was* nil.
+          MESSAGE
+
+          expectation = lambda do
+            expect(person).to delegate_method(:hello).to(:country).allow_nil
+          end
+
+          expect(&expectation).to fail_with_message(message)
+        end
+      end
+    end
+  end
 end

data/spec/unit/shoulda/matchers/routing/route_matcher_spec.rb

@@ -1,146 +1,222 @@
 require 'unit_spec_helper'
 
 describe 'Shoulda::Matchers::Routing::RouteMatcher', type: :routing do
-  before do
-    define_controller('ThingsController')
-  end
-
   shared_examples_for 'core tests' do
     context 'when the given method, path, controller, and action match an existing route' do
       it 'accepts' do
-        define_routes { get '/', to: 'things#index' }
+        define_controller_and_routes(
+          method: :get,
+          path: '/',
+          controller: 'things',
+          action: 'index',
+        )
 
-        assert_accepts add_target_to(
-          route(:get, '/'),
+        matcher = build_route_matcher(
+          method: :get,
+          path: '/',
           controller: 'things',
           action: 'index'
         )
+
+        is_expected.to(matcher)
       end
 
       context 'and the expected controller is specified as a symbol' do
         it 'accepts' do
-          define_routes { get '/', to: 'things#index' }
+          define_controller_and_routes(
+            method: :get,
+            path: '/',
+            controller: 'things',
+            action: 'index',
+          )
 
-          assert_accepts add_target_to(
-            route(:get, '/'),
+          matcher = build_route_matcher(
+            method: :get,
+            path: '/',
             controller: :things,
             action: 'index'
           )
+
+          is_expected.to(matcher)
         end
       end
 
       context 'and the expected action is specified as a symbol' do
         it 'accepts' do
-          define_routes { get '/', to: 'things#index' }
+          define_controller_and_routes(
+            method: :get,
+            path: '/',
+            controller: 'things',
+            action: 'index',
+          )
 
-          assert_accepts add_target_to(
-            route(:get, '/'),
+          matcher = build_route_matcher(
+            method: :get,
+            path: '/',
             controller: 'things',
-            action: :index
+            action: :index,
           )
+
+          is_expected.to(matcher)
         end
       end
     end
 
     context 'when the given method, path, controller, and action do not match an existing route' do
       it 'rejects' do
-        assert_rejects add_target_to(
-          route(:get, '/non_existent_route'),
-          controller: 'no_controller',
-          action: 'no_action'
+        matcher = build_route_matcher(
+          method: :get,
+          path: '/non_existent_route',
+          controller: 'some_controller',
+          action: 'some_action',
         )
+
+        is_expected.not_to(matcher)
       end
     end
 
     context 'when the given path, controller, and action match an existing route but the method does not' do
       it 'rejects' do
-        define_routes { post '/', to: 'things#index' }
+        define_controller_and_routes(
+          method: :get,
+          path: '/',
+          controller: 'things',
+          action: 'index',
+        )
 
-        assert_rejects add_target_to(
-          route(:get, '/'),
+        matcher = build_route_matcher(
+          method: :post,
+          path: '/',
           controller: 'things',
-          action: 'index'
+          action: 'index',
         )
+
+        is_expected.not_to(matcher)
       end
     end
 
     context 'when the given method, controller, and action match an existing route but the path does not' do
       it 'rejects' do
-        define_routes { get '/', to: 'things#index' }
+        define_controller_and_routes(
+          method: :get,
+          path: '/',
+          controller: 'things',
+          action: 'index',
+        )
 
-        assert_rejects add_target_to(
-          route(:get, '/different_path'),
+        matcher = build_route_matcher(
+          method: :get,
+          path: '/something_else',
           controller: 'things',
-          action: 'index'
+          action: 'index',
         )
+
+        is_expected.not_to(matcher)
       end
     end
 
     context 'when the given method and path match an existing route but the controller does not' do
       it 'rejects' do
-        define_routes { get '/', to: 'another_controller#index' }
-
-        assert_rejects add_target_to(
-          route(:get, '/'),
+        define_controller_and_routes(
+          method: :get,
+          path: '/',
           controller: 'things',
-          action: 'index'
+          action: 'index',
         )
+
+        matcher = build_route_matcher(
+          method: :get,
+          path: '/',
+          controller: 'some_other_controller',
+          action: 'index',
+        )
+
+        is_expected.not_to(matcher)
       end
     end
 
     context 'when the given method, path, and controller match an existing route but the action does not' do
       it 'rejects' do
-        define_routes { get '/', to: 'things#index' }
+        define_controller_and_routes(
+          method: :get,
+          path: '/',
+          controller: 'things',
+          action: 'index',
+        )
 
-        assert_rejects add_target_to(
-          route(:get, '/'),
+        matcher = build_route_matcher(
+          method: :get,
+          path: '/',
           controller: 'things',
-          action: 'another_action'
+          action: 'another_action',
         )
+
+        is_expected.not_to(matcher)
       end
     end
 
     context 'when the actual route has a param' do
       context 'and the expected params include that param' do
         it 'accepts' do
-          define_routes { get '/things/:id', to: 'things#show' }
+          define_controller_and_routes(
+            method: :get,
+            path: '/things/:id',
+            controller: 'things',
+            action: 'show',
+          )
 
-          assert_accepts add_target_to(
-            route(:get, '/things/1'),
+          matcher = build_route_matcher(
+            method: :get,
+            path: '/things/1',
             controller: 'things',
             action: 'show',
-            id: '1'
+            id: '1',
           )
+
+          is_expected.to(matcher)
         end
 
         context 'but its value was not specified as a string' do
           it 'accepts, treating it as a string' do
-            define_routes { get '/things/:id', to: 'things#show' }
+            define_controller_and_routes(
+              method: :get,
+              path: '/things/:id',
+              controller: 'things',
+              action: 'show',
+            )
 
-            assert_accepts add_target_to(
-              route(:get, '/things/1'),
+            matcher = build_route_matcher(
+              method: :get,
+              path: '/things/1',
               controller: 'things',
               action: 'show',
-              id: 1
+              id: 1,
             )
+
+            is_expected.to(matcher)
           end
         end
       end
 
       context 'and the expected params do not match the actual params' do
         it 'rejects' do
-          define_routes { get '/things/:id', to: 'things#show' }
+          define_controller_and_routes(
+            method: :get,
+            path: '/things/:id',
+            controller: 'things',
+            action: 'show',
+          )
 
-          params = {
+          matcher = build_route_matcher(
+            method: :get,
+            path: '/things/1',
             controller: 'things',
             action: 'show',
             some: 'other',
-            params: 'here'
-          }
-          assert_rejects add_target_to(
-            route(:get, '/things/:id'),
-            params
+            params: 'here',
           )
+
+          is_expected.not_to(matcher)
         end
       end
     end
@@ -149,35 +225,45 @@ describe 'Shoulda::Matchers::Routing::RouteMatcher', type: :routing do
       context 'and the expected params include a value for it' do
         context 'as a symbol' do
           it 'accepts' do
-            define_routes do
-              post '/things(.:format)',
-                to: 'things#create',
-                defaults: { format: :json }
-            end
-
-            assert_accepts add_target_to(
-              route(:post, '/things'),
+            define_controller_and_routes(
+              method: :post,
+              path: '/things(.:format)',
+              controller: 'things',
+              action: 'create',
+              defaults: { format: :json },
+            )
+
+            matcher = build_route_matcher(
+              method: :post,
+              path: '/things',
               controller: 'things',
               action: 'create',
-              format: :json
+              format: :json,
             )
+
+            is_expected.to(matcher)
           end
         end
 
         context 'as a string' do
           it 'accepts' do
-            define_routes do
-              post '/things(.:format)',
-                to: 'things#create',
-                defaults: { format: :json }
-            end
-
-            assert_accepts add_target_to(
-              route(:post, '/things'),
+            define_controller_and_routes(
+              method: :post,
+              path: '/things(.:format)',
+              controller: 'things',
+              action: 'create',
+              defaults: { format: :json },
+            )
+
+            matcher = build_route_matcher(
+              method: :post,
+              path: '/things',
               controller: 'things',
               action: 'create',
-              format: 'json'
+              format: 'json',
             )
+
+            is_expected.to(matcher)
           end
         end
       end
@@ -186,57 +272,135 @@ describe 'Shoulda::Matchers::Routing::RouteMatcher', type: :routing do
     context 'when the existing route has a glob segment' do
       context 'and a param is given which represents the segment' do
         it 'accepts' do
-          define_routes { get '/things/*id', to: 'things#whatever' }
+          define_controller_and_routes(
+            method: :get,
+            path: '/things/*id',
+            controller: 'things',
+            action: 'show',
+          )
 
-          assert_accepts add_target_to(
-            route(:get, '/things/foo/bar'),
+          matcher = build_route_matcher(
+            method: :get,
+            path: '/things/foo/bar',
             controller: 'things',
-            action: 'whatever',
-            id: 'foo/bar'
+            action: 'show',
+            id: 'foo/bar',
           )
+
+          is_expected.to(matcher)
         end
       end
 
       context 'and no param is given which represents the segment' do
         it 'rejects' do
-          define_routes { get '/things/*id', to: 'things#whatever' }
+          define_controller_and_routes(
+            method: :get,
+            path: '/things/*id',
+            controller: 'things',
+            action: 'show',
+          )
 
-          assert_rejects add_target_to(
-            route(:get, '/things'),
+          matcher = build_route_matcher(
+            method: :get,
+            path: '/things',
             controller: 'things',
-            action: 'whatever'
+            action: 'show',
           )
+
+          is_expected.not_to(matcher)
+        end
+      end
+    end
+
+    context 'when a port is specified' do
+      context 'when the route is constrained to the same port' do
+        it 'accepts' do
+          define_controller_and_routes(
+            method: :get,
+            path: '/',
+            controller: 'things',
+            action: 'show',
+            constraints: port_constraint_class.new(12345),
+          )
+
+          matcher = build_route_matcher(
+            method: :get,
+            path: '/',
+            controller: 'things',
+            action: 'show',
+            port: 12345,
+          )
+
+          is_expected.to(matcher)
+        end
+      end
+
+      context 'when the route is not constrained to the same port' do
+        it 'rejects' do
+          define_controller_and_routes(
+            method: :get,
+            path: '/',
+            controller: 'things',
+            action: 'show',
+            constraints: port_constraint_class.new(12345),
+          )
+
+          matcher = build_route_matcher(
+            method: :get,
+            path: '/',
+            controller: 'things',
+            action: 'show',
+            port: 99999,
+          )
+
+          is_expected.not_to(matcher)
         end
       end
     end
   end
 
   context 'given a controller and action specified as individual options' do
-    include_examples 'core tests'
-
-    def add_target_to(route_matcher, params)
-      route_matcher.to(params)
+    include_examples 'core tests' do
+      def build_route_matcher(method:, path:, port: nil, **params)
+        super(method: method, path: path, port: port).to(params)
+      end
     end
   end
 
   context 'given a controller and action joined together in a string' do
-    include_examples 'core tests'
-
-    def add_target_to(route_matcher, args)
-      controller = args.fetch(:controller)
-      action = args.fetch(:action)
-      route_matcher.to(
-        "#{controller}##{action}",
-        args.except(:controller, :action)
-      )
+    include_examples 'core tests' do
+      def build_route_matcher(method:, path:, controller:, action:, port: nil, **rest)
+        super(method: method, path: path, port: port).
+          to("#{controller}##{action}", **rest)
+      end
+    end
+  end
+
+  def define_controller_and_routes(method:, path:, controller:, action:, **params)
+    define_controller(controller.camelize)
+
+    define_routes do
+      send(method, path, controller: controller, action: action, **params)
     end
   end
 
-  def assert_accepts(matcher)
-    should(matcher)
+  def build_route_matcher(method:, path:, port:, **)
+    route(method, path, port: port)
   end
 
-  def assert_rejects(matcher)
-    should_not(matcher)
+  let(:port_constraint_class) do
+    Class.new do
+      def initialize(port)
+        @port = port
+      end
+
+      def matches?(request)
+        request.port == port
+      end
+
+      private
+
+      attr_reader :port
+    end
   end
 end