shoulda-matchers 4.0.0.rc1 → 4.0.1

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

@@ -1,77 +0,0 @@
-require 'doublespeak_spec_helper'
-
-module Shoulda::Matchers::Doublespeak
-  describe ObjectDouble do
-    it 'responds to any method' do
-      double = described_class.new
-
-      expect(double.respond_to?(:foo)).to be true
-      expect(double.respond_to?(:bar)).to be true
-      expect(double.respond_to?(:baz)).to be true
-    end
-
-    it 'returns nil from any method call' do
-      double = described_class.new
-
-      expect(double.foo).to be nil
-      expect(double.bar).to be nil
-      expect(double.baz).to be nil
-    end
-
-    it 'records every method call' do
-      double = described_class.new
-
-      block = -> { :some_return_value }
-      double.foo
-      double.bar(42)
-      double.baz(:zing, :zang, &block)
-
-      expect(double.calls.size).to eq 3
-      double.calls[0].tap do |call|
-        expect(call.args).to eq []
-        expect(call.block).to eq nil
-      end
-      double.calls[1].tap do |call|
-        expect(call.args).to eq [42]
-        expect(call.block).to eq nil
-      end
-      double.calls[2].tap do |call|
-        expect(call.args).to eq [:zing, :zang]
-        expect(call.block).to eq block
-      end
-    end
-
-    describe '#calls_to' do
-      it 'returns all of the invocations of the given method and their arguments/block' do
-        double = described_class.new
-
-        block = -> { :some_return_value }
-        double.foo
-        double.foo(42)
-        double.foo(:zing, :zang, &block)
-        double.some_other_method(:doesnt_matter)
-
-        calls = double.calls_to(:foo)
-
-        expect(calls.size).to eq 3
-        calls[0].tap do |call|
-          expect(call.args).to eq []
-          expect(call.block).to eq nil
-        end
-        calls[1].tap do |call|
-          expect(call.args).to eq [42]
-          expect(call.block).to eq nil
-        end
-        calls[2].tap do |call|
-          expect(call.args).to eq [:zing, :zang]
-          expect(call.block).to eq block
-        end
-      end
-
-      it 'returns an empty array if the given method was never called' do
-        double = described_class.new
-        expect(double.calls_to(:unknown_method)).to eq []
-      end
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-require 'doublespeak_spec_helper'
-
-module Shoulda::Matchers::Doublespeak
-  describe ProxyImplementation do
-    describe '#returns' do
-      it 'delegates to its stub_implementation' do
-        stub_implementation = build_stub_implementation
-        implementation = described_class.new(stub_implementation)
-        implementation.returns(:value)
-
-        expect(stub_implementation).to have_received(:returns).with(:value)
-      end
-    end
-
-    describe '#call' do
-      it 'calls #call_original_method on the double' do
-        stub_implementation = build_stub_implementation
-        double = build_double
-        call = build_call(double: double)
-        allow(double).to receive(:call_original_method)
-        implementation = described_class.new(stub_implementation)
-
-        implementation.call(call)
-
-        expect(double).
-          to have_received(:call_original_method).
-          with(call)
-      end
-
-      it 'delegates to its stub_implementation' do
-        stub_implementation = build_stub_implementation
-        double = build_double
-        call2 = build_call
-        call = build_call(double: double, with_return_value: call2)
-        allow(double).to receive(:call_original_method)
-        implementation = described_class.new(stub_implementation)
-
-        implementation.call(call)
-
-        expect(stub_implementation).
-          to have_received(:call).
-          with(call2)
-      end
-
-      it 'returns the return value of the original method' do
-        return_value = :some_return_value
-        stub_implementation = build_stub_implementation
-        double = build_double(call_original_method: return_value)
-        call = build_call(double: double)
-        implementation = described_class.new(stub_implementation)
-
-        return_value = implementation.call(call)
-
-        expect(return_value).to be return_value
-      end
-    end
-
-    def build_stub_implementation
-      double('stub_implementation', returns: nil, call: nil)
-    end
-
-    def build_double(methods = {})
-      defaults = { call_original_method: nil }
-      double('double', defaults.merge(methods))
-    end
-
-    def build_call(methods = {})
-      defaults = { double: build_double, with_return_value: nil }
-      double('call', defaults.merge(methods))
-    end
-  end
-end

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

@@ -1,101 +0,0 @@
-require 'doublespeak_spec_helper'
-
-module Shoulda::Matchers::Doublespeak
-  describe StubImplementation do
-    describe '#call' do
-      it 'calls #record_call on the double' do
-        implementation = described_class.new
-        double = build_double
-        call = build_call(double: double)
-
-        allow(double).to receive(:record_call).with(call)
-
-        implementation.call(call)
-      end
-
-      context 'if no explicit implementation was set' do
-        it 'returns nil' do
-          implementation = described_class.new
-          double = build_double
-          call = build_call(double: double)
-
-          return_value = implementation.call(call)
-
-          expect(return_value).to eq nil
-        end
-      end
-
-      context 'if the implementation was set as a value' do
-        it 'returns the set return value' do
-          implementation = described_class.new
-          implementation.returns(42)
-          double = build_double
-          call = build_call(double: double)
-
-          return_value = implementation.call(call)
-
-          expect(return_value).to eq 42
-        end
-      end
-
-      context 'if the implementation was set as a block' do
-        it 'calls the block with the MethodCall object the implementation was called with' do
-          double = build_double
-          expected_object, expected_args, expected_block = :object, :args, :block
-          call = build_call(
-            double: double,
-            object: expected_object,
-            args: expected_args,
-            block: expected_block
-          )
-          actual_object, actual_args, actual_block = []
-          implementation = described_class.new
-          implementation.returns do |actual_call|
-            actual_object = actual_call.object
-            actual_args = actual_call.args
-            actual_block = actual_call.block
-          end
-
-          implementation.call(call)
-
-          expect(actual_object).to eq expected_object
-          expect(actual_args).to eq expected_args
-          expect(actual_block).to eq expected_block
-        end
-
-        it 'returns the return value of the block' do
-          implementation = described_class.new
-          implementation.returns { 42 }
-          double = build_double
-          call = build_call(double: double)
-
-          return_value = implementation.call(call)
-
-          expect(return_value).to eq 42
-        end
-      end
-
-      context 'if the implementation was set as both a value and a block' do
-        it 'prefers the block over the value' do
-          implementation = described_class.new
-          implementation.returns(:something_else) { 42 }
-          double = build_double
-          call = build_call(double: double)
-
-          return_value = implementation.call(call)
-
-          expect(return_value).to eq 42
-        end
-      end
-    end
-
-    def build_double
-      double('double', record_call: nil)
-    end
-
-    def build_call(options = {})
-      defaults = { double: build_double }
-      double('call', defaults.merge(options))
-    end
-  end
-end

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

@@ -1,78 +0,0 @@
-require 'doublespeak_spec_helper'
-
-module Shoulda::Matchers::Doublespeak
-  describe World do
-    describe '#double_collection_for' do
-      it 'calls DoubleCollection.new once with the given class' do
-        allow(DoubleCollection).to receive(:new).and_return(:klass)
-        world = described_class.new
-
-        world.double_collection_for(:klass)
-        world.double_collection_for(:klass)
-
-        expect(DoubleCollection).
-          to have_received(:new).
-          with(world, :klass).
-          once
-      end
-
-      it 'returns the created DoubleCollection' do
-        world = described_class.new
-        double_collection = build_double_collection
-        allow(DoubleCollection).
-          to receive(:new).
-          with(world, :klass).
-          and_return(double_collection)
-
-        expect(world.double_collection_for(:klass)).to be double_collection
-      end
-    end
-
-    describe '#with_doubles_activated' do
-      it 'installs all doubles, yields the block, then uninstalls them all' do
-        block_called = false
-        double_collections = Array.new(3) { build_double_collection }
-        double_collections.each do |double_collection|
-          allow(double_collection).to receive(:activate)
-          allow(double_collection).to receive(:deactivate)
-        end
-        klasses = Array.new(3) { |i| "Klass #{i}" }
-        world = described_class.new
-        double_collections.zip(klasses).each do |double_collection, klass|
-          allow(DoubleCollection).
-            to receive(:new).
-            with(world, klass).
-            and_return(double_collection)
-          world.double_collection_for(klass)
-        end
-
-        world.with_doubles_activated { block_called = true }
-
-        expect(block_called).to eq true
-
-        double_collections.each do |double_collection|
-          expect(double_collection).to have_received(:activate)
-          expect(double_collection).to have_received(:deactivate)
-        end
-      end
-
-      it 'still makes sure to uninstall all doubles even if the block raises an error' do
-        double_collection = build_double_collection
-        allow(DoubleCollection).to receive(:new).and_return(double_collection)
-        world = described_class.new
-        world.double_collection_for(:klass)
-
-        begin
-          world.with_doubles_activated { raise 'error' }
-        rescue RuntimeError
-        end
-
-        expect(double_collection).to have_received(:deactivate)
-      end
-    end
-
-    def build_double_collection
-      double('double_collection', activate: nil, deactivate: nil)
-    end
-  end
-end

data/spec/unit/shoulda/matchers/doublespeak_spec.rb

@@ -1,27 +0,0 @@
-require 'doublespeak_spec_helper'
-
-module Shoulda::Matchers
-  describe Doublespeak do
-    describe '.double_collection_for' do
-      it 'delegates to its world' do
-        allow(Doublespeak.world).to receive(:double_collection_for)
-
-        described_class.double_collection_for(:klass)
-
-        expect(Doublespeak.world).
-          to have_received(:double_collection_for).
-          with(:klass)
-      end
-    end
-
-    describe '.with_doubles_activated' do
-      it 'delegates to its world' do
-        allow(Doublespeak.world).to receive(:with_doubles_activated)
-
-        described_class.with_doubles_activated
-
-        expect(Doublespeak.world).to have_received(:with_doubles_activated)
-      end
-    end
-  end
-end

data/spec/unit/shoulda/matchers/independent/delegate_method_matcher/stubbed_target_spec.rb

@@ -1,43 +0,0 @@
-require 'unit_spec_helper'
-
-describe Shoulda::Matchers::Independent::DelegateMethodMatcher::StubbedTarget do
-  subject(:target) { described_class.new(:stubbed_method) }
-
-  describe '#has_received_method?' do
-    it 'returns true when the method has been called on the target' do
-      target.stubbed_method
-
-      expect(target).to have_received_method
-    end
-
-    it 'returns false when the method has not been called on the target' do
-      expect(target).not_to have_received_method
-    end
-  end
-
-  describe '#has_received_arguments?' do
-    context 'method is called with specified arguments' do
-      it 'returns true' do
-        target.stubbed_method(:arg1, :arg2)
-
-        expect(target).to have_received_arguments(:arg1, :arg2)
-      end
-    end
-
-    context 'method is not called with specified arguments' do
-      it 'returns false' do
-        target.stubbed_method
-
-        expect(target).not_to have_received_arguments(:arg1)
-      end
-    end
-
-    context 'method is called with arguments in incorrect order' do
-      it 'returns false' do
-        target.stubbed_method(:arg2, :arg1)
-
-        expect(target).not_to have_received_arguments(:arg1, :arg2)
-      end
-    end
-  end
-end

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

@@ -1,650 +0,0 @@
-require 'unit_spec_helper'
-
-describe Shoulda::Matchers::Independent::DelegateMethodMatcher do
-  describe '#description' do
-    context 'when the subject is an instance' do
-      subject { Object.new }
-
-      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 the #delegate object'
-
-          expect(matcher.description).to eq message
-        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 the #delegate object as #alternate'
-
-          expect(matcher.description).to eq message
-        end
-      end
-
-      context 'qualified with #with_arguments' 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 the #delegate object passing arguments [:foo, {:bar=>[1, 2]}]'
-
-          expect(matcher.description).to eq message
-        end
-      end
-
-      context 'qualified with #with_prefix' do
-        context 'without arguments' do
-          before do
-            define_model('Country') do
-              def hello; 'hello' end
-            end
-          end
-
-          context "when the subject's delegating method also has a prefix" do
-            it 'produces the correct description' do
-              define_class('Person') do
-                delegate :hello, to: :country, prefix: true
-
-                def country
-                  Country.new
-                end
-              end
-
-              matcher = delegate_method(:hello).to(:country).with_prefix
-              expect(matcher.description).
-                to eq('delegate #country_hello to the #country object as #hello')
-            end
-          end
-        end
-
-        context 'as true' do
-          before do
-            define_model('Country') do
-              def hello; 'hello' end
-            end
-          end
-
-          context "when the subject's delegating method also has a prefix" do
-            it 'produces the correct description' do
-              define_class('Person') do
-                delegate :hello, to: :country, prefix: true
-
-                def country
-                  Country.new
-                end
-              end
-
-              matcher = delegate_method(:hello).to(:country).with_prefix(true)
-              expect(matcher.description).
-                to eq('delegate #country_hello to the #country object as #hello')
-            end
-          end
-        end
-
-        context 'as a symbol/string' do
-          it 'should delegate as (prefix_supplied)_(method_on_target)' do
-            define_model('Country') do
-              def hello; 'hello' end
-            end
-
-            define_class('Person') do
-              delegate :hello, to: :country, prefix: 'county'
-
-              def country
-                Country.new
-              end
-            end
-
-            matcher = delegate_method(:hello).to(:country).with_prefix('county')
-            expect(matcher.description).
-              to eq('delegate #county_hello to the #country object as #hello')
-          end
-        end
-      end
-    end
-
-    context 'when the subject is a class' do
-      subject { Object }
-
-      context 'without any qualifiers' do
-        it 'states that it should delegate method to the right object' do
-          matcher = delegate_method(:method_name).to(:delegate)
-
-          expect(matcher.description).
-            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 the .delegate object as .alternate'
-
-          expect(matcher.description).to eq message
-        end
-      end
-
-      context 'qualified with #with_arguments' 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 the .delegate object passing arguments [:foo, {:bar=>[1, 2]}]'
-
-          expect(matcher.description).to eq message
-        end
-      end
-    end
-  end
-
-  it 'raises an error if the delegate object was never specified before matching' do
-    expect {
-      expect(Object.new).to delegate_method(:name)
-    }.to raise_error described_class::DelegateObjectNotSpecified
-  end
-
-  context 'stubbing a delegating method on an instance' do
-    it 'only happens temporarily and is removed after the match' do
-      define_class('Company') do
-        def name
-          'Acme Company'
-        end
-      end
-
-      define_class('Person') do
-        def company_name
-          company.name
-        end
-
-        def company
-          Company.new
-        end
-      end
-
-      person = Person.new
-      matcher = delegate_method(:company_name).to(:company).as(:name)
-      matcher.matches?(person)
-
-      expect(person.company.name).to eq 'Acme Company'
-    end
-  end
-
-  context 'when the subject does not delegate anything' do
-    before do
-      define_class('PostOffice')
-    end
-
-    context 'when the subject is an instance' do
-      it 'rejects with the correct failure message' do
-        post_office = PostOffice.new
-        message = [
-          'Expected PostOffice to delegate #deliver_mail to the #mailman object.',
-          '',
-          'Method calls sent to PostOffice#mailman: (none)'
-        ].join("\n")
-
-        expect {
-          expect(post_office).to delegate_method(:deliver_mail).to(:mailman)
-        }.to fail_with_message(message)
-      end
-    end
-
-    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 the .mailman object.',
-          '',
-          'Method calls sent to PostOffice.mailman: (none)'
-        ].join("\n")
-
-        expect {
-          expect(PostOffice).to delegate_method(:deliver_mail).to(:mailman)
-        }.to fail_with_message(message)
-      end
-    end
-  end
-
-  context 'when the subject delegates correctly' do
-    before do
-      define_class('Mailman')
-
-      define_class('PostOffice') do
-        def deliver_mail
-          mailman.deliver_mail
-        end
-
-        def mailman
-          Mailman.new
-        end
-      end
-    end
-
-    it 'accepts' do
-      post_office = PostOffice.new
-      expect(post_office).to delegate_method(:deliver_mail).to(:mailman)
-    end
-
-    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 the #mailman object, but it did.'
-
-        expect {
-          expect(post_office).not_to delegate_method(:deliver_mail).to(:mailman)
-        }.to fail_with_message(message)
-      end
-    end
-  end
-
-  context 'when the delegating method is private' do
-    before do
-      define_class('Mailman')
-
-      define_class('PostOffice') do
-        def deliver_mail
-          mailman.deliver_mail
-        end
-
-        def mailman
-          Mailman.new
-        end
-
-        private :mailman
-      end
-    end
-
-    it 'accepts' do
-      post_office = PostOffice.new
-      expect(post_office).to delegate_method(:deliver_mail).to(:mailman)
-    end
-  end
-
-  context 'qualified with #with_arguments' do
-    before do
-      define_class('Mailman')
-
-      define_class('PostOffice') do
-        def deliver_mail(*args)
-          mailman.deliver_mail('221B Baker St.', hastily: true)
-        end
-
-        def mailman
-          Mailman.new
-        end
-      end
-    end
-
-    context 'qualified with #with_arguments' do
-      context 'when the subject delegates with matching arguments' do
-        it 'accepts' do
-          post_office = PostOffice.new
-          expect(post_office).to delegate_method(:deliver_mail).
-            to(:mailman).with_arguments('221B Baker St.', hastily: true)
-        end
-
-        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 the #mailman object passing arguments ["221B Baker St.", {:hastily=>true}], but it did.'
-
-            expect {
-              expect(post_office).
-                not_to delegate_method(:deliver_mail).
-                to(:mailman).
-                with_arguments('221B Baker St.', hastily: true)
-            }.to fail_with_message(message)
-          end
-        end
-      end
-
-      context 'when not given the correct arguments' do
-        it 'rejects with the correct failure message' do
-          post_office = PostOffice.new
-          message = [
-            '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")
-
-          expect {
-            expect(post_office).to delegate_method(:deliver_mail).
-              to(:mailman).with_arguments('123 Nowhere Ln.')
-          }.to fail_with_message(message)
-        end
-      end
-    end
-  end
-
-  context 'qualified with #as' do
-    before do
-      define_class(:mailman)
-
-      define_class(:post_office) do
-        def deliver_mail
-          mailman.deliver_mail_and_avoid_dogs
-        end
-
-        def mailman
-          Mailman.new
-        end
-      end
-    end
-
-    context "when the given method is the same as the subject's delegating method" do
-      it 'accepts' do
-        post_office = PostOffice.new
-        expect(post_office).to delegate_method(:deliver_mail).
-          to(:mailman).as(:deliver_mail_and_avoid_dogs)
-      end
-
-      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 the #mailman object as #deliver_mail_and_avoid_dogs, but it did.'
-
-          expect {
-            expect(post_office).
-              not_to delegate_method(:deliver_mail).
-              to(:mailman).
-              as(:deliver_mail_and_avoid_dogs)
-          }.to fail_with_message(message)
-        end
-      end
-    end
-
-    context "when the given method is not the same as the subject's delegating method" do
-      it 'rejects with the correct failure message' do
-        post_office = PostOffice.new
-        message = [
-          '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")
-
-        expect {
-          expect(post_office).to delegate_method(:deliver_mail).
-            to(:mailman).as(:watch_tv)
-        }.to fail_with_message(message)
-      end
-    end
-  end
-
-  context 'qualified with #with_prefix' do
-    context 'without arguments' do
-      before do
-        define_model('Country') do
-          def hello; 'hello' end
-        end
-      end
-
-      context "when the subject's delegating method also has a prefix" do
-        it 'accepts' do
-          define_class('Person') do
-            delegate :hello, to: :country, prefix: true
-
-            def country
-              Country.new
-            end
-          end
-
-          person = Person.new
-          expect(person).to delegate_method(:hello). to(:country).with_prefix
-        end
-      end
-
-      context "when the subject's delegating method does not have a prefix" do
-        it 'rejects with the correct failure message' do
-          define_class('Person') do
-            delegate :hello, to: :country
-
-            def country
-              Country.new
-            end
-          end
-
-          message = [
-            'Expected Person to delegate #country_hello to the #country object as',
-            '#hello.',
-            '',
-            'Method calls sent to Person#country: (none)'
-          ].join("\n")
-
-          person = Person.new
-
-          expect {
-            expect(person).to delegate_method(:hello). to(:country).with_prefix
-          }.to fail_with_message(message)
-        end
-      end
-    end
-
-    context 'as true' do
-      before do
-        define_model('Country') do
-          def hello; 'hello' end
-        end
-      end
-
-      context "when the subject's delegating method also has a prefix" do
-        it 'accepts' do
-          define_class('Person') do
-            delegate :hello, to: :country, prefix: true
-
-            def country
-              Country.new
-            end
-          end
-
-          person = Person.new
-          expect(person).
-            to delegate_method(:hello).
-            to(:country).with_prefix(true)
-        end
-      end
-
-      context "when the subject's delegating method does not have a prefix" do
-        it 'rejects with the correct failure message' do
-          define_class('Person') do
-            delegate :hello, to: :country
-
-            def country
-              Country.new
-            end
-          end
-
-          message = [
-            'Expected Person to delegate #country_hello to the #country object as',
-            '#hello.',
-            '',
-            'Method calls sent to Person#country: (none)'
-          ].join("\n")
-
-          person = Person.new
-
-          expect {
-            expect(person).
-              to delegate_method(:hello).
-              to(:country).with_prefix(true)
-          }.to fail_with_message(message)
-        end
-      end
-    end
-
-    context 'as a symbol/string' do
-      before do
-        define_model('Country') do
-          def hello; 'hello' end
-        end
-      end
-
-      context "when the subject's delegating method has the same prefix" do
-        it 'accepts' do
-          define_class('Person') do
-            delegate :hello, to: :country, prefix: 'county'
-
-            def country
-              Country.new
-            end
-          end
-
-          person = Person.new
-          expect(person).
-            to delegate_method(:hello).
-            to(:country).with_prefix('county')
-        end
-      end
-
-      context "when the subject's delegating method has a different prefix" do
-        it 'rejects with the correct failure message' do
-          define_class('Person') do
-            delegate :hello, to: :country, prefix: 'something_else'
-
-            def country
-              Country.new
-            end
-          end
-
-          message = [
-            'Expected Person to delegate #county_hello to the #country object as',
-            '#hello.',
-            '',
-            'Method calls sent to Person#country: (none)'
-          ].join("\n")
-
-          person = Person.new
-
-          expect {
-            expect(person).
-              to delegate_method(:hello).
-              to(:country).with_prefix('county')
-          }.to fail_with_message(message)
-        end
-      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