shoulda-matchers 2.6.0 → 2.6.1.rc1

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

@@ -0,0 +1,88 @@
+require '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
+
+        double.expects(:record_call).with(:args, :block)
+
+        implementation.call(double, :object, :args, :block)
+      end
+
+      context 'if no explicit implementation was set' do
+        it 'returns nil' do
+          implementation = described_class.new
+          double = build_double
+
+          return_value = implementation.call(double, :object, :args, :block)
+
+          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
+
+          return_value = implementation.call(double, :object, :args, :block)
+
+          expect(return_value).to eq 42
+        end
+      end
+
+      context 'if the implementation was set as a block' do
+        it 'calls the block with the object and args/block passed to the method' do
+          double = build_double
+          expected_object, expected_args, expected_block = :object, :args, :block
+          actual_object, actual_args, actual_block = []
+          implementation = described_class.new
+          implementation.returns do |object, args, block|
+            actual_object, actual_args, actual_block = object, args, block
+          end
+
+          implementation.call(
+            double,
+            expected_object,
+            expected_args,
+            expected_block
+          )
+
+          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
+
+          return_value = implementation.call(double, :object, :args, :block)
+
+          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
+
+          return_value = implementation.call(double, :object, :args, :block)
+
+          expect(return_value).to eq 42
+        end
+      end
+    end
+
+    def build_double
+      stub(record_call: nil)
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+module Shoulda::Matchers::Doublespeak
+  describe World do
+    describe '#register_double_collection' do
+      it 'calls DoubleCollection.new with the given class' do
+        DoubleCollection.expects(:new).with(:klass)
+        world = described_class.new
+        world.register_double_collection(:klass)
+      end
+
+      it 'returns the newly created DoubleCollection' do
+        double_collection = Object.new
+        DoubleCollection.stubs(:new).with(:klass).returns(double_collection)
+        world = described_class.new
+        expect(world.register_double_collection(: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) do
+          stub.tap do |double_collection|
+            sequence = sequence('with_doubles_activated')
+            double_collection.expects(:activate).in_sequence(sequence)
+            double_collection.expects(:deactivate).in_sequence(sequence)
+          end
+        end
+
+        world = described_class.new
+
+        DoubleCollection.stubs(:new).
+          with(:klass1).
+          returns(double_collections[0])
+        DoubleCollection.stubs(:new).
+          with(:klass2).
+          returns(double_collections[1])
+        DoubleCollection.stubs(:new).
+          with(:klass3).
+          returns(double_collections[2])
+        world.register_double_collection(:klass1)
+        world.register_double_collection(:klass2)
+        world.register_double_collection(:klass3)
+
+        world.with_doubles_activated { block_called = true }
+
+        expect(block_called).to eq true
+      end
+
+      it 'still makes sure to uninstall all doubles even if the block raises an error' do
+        double_collection = stub()
+        double_collection.stubs(:activate)
+        double_collection.expects(:deactivate)
+
+        world = described_class.new
+
+        DoubleCollection.stubs(:new).returns(double_collection)
+        world.register_double_collection(:klass)
+
+        begin
+          world.with_doubles_activated { raise 'error' }
+        rescue RuntimeError
+        end
+      end
+
+      it 'does not allow multiple DoubleCollections to be registered that represent the same class' do
+        double_collections = [stub, stub]
+        sequence = sequence('with_doubles_activated')
+        double_collections[0].expects(:activate).never
+        double_collections[0].expects(:deactivate).never
+        double_collections[1].expects(:activate).in_sequence(sequence)
+        double_collections[1].expects(:deactivate).in_sequence(sequence)
+
+        world = described_class.new
+
+        DoubleCollection.stubs(:new).
+          returns(double_collections[0]).then.
+          returns(double_collections[1])
+        world.register_double_collection(:klass1)
+        world.register_double_collection(:klass1)
+
+        world.with_doubles_activated { }
+      end
+    end
+  end
+end

data/spec/shoulda/matchers/doublespeak_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module Shoulda::Matchers
+  describe Doublespeak do
+    describe '.register_double_collection' do
+      it 'delegates to its world' do
+        Doublespeak.world.expects(:register_double_collection).with(:klass)
+        described_class.register_double_collection(:klass)
+      end
+    end
+
+    describe '.with_doubles_activated' do
+      it 'delegates to its world' do
+        Doublespeak.world.expects(:with_doubles_activated)
+        described_class.with_doubles_activated
+      end
+    end
+  end
+end

data/spec/shoulda/matchers/independent/delegate_matcher_spec.rb

@@ -6,8 +6,8 @@ describe Shoulda::Matchers::Independent::DelegateMatcher do
       it 'states that it should delegate method to the right object' do
         matcher = delegate_method(:method_name).to(:target)
 
-        expect(matcher.description)
-          .to eq 'delegate method #method_name to :target'
+        expect(matcher.description).
+          to eq 'delegate method #method_name to :target'
       end
     end
 
@@ -22,8 +22,8 @@ describe Shoulda::Matchers::Independent::DelegateMatcher do
 
     context 'with #with_argument chain' do
       it 'states that it should delegate method to the right object with right argument' do
-        matcher = delegate_method(:method_name).to(:target)
-          .with_arguments(:foo, bar: [1, 2])
+        matcher = delegate_method(:method_name).to(:target).
+          with_arguments(:foo, bar: [1, 2])
         message = 'delegate method #method_name to :target with arguments: [:foo, {:bar=>[1, 2]}]'
 
         expect(matcher.description).to eq message
@@ -31,16 +31,36 @@ describe Shoulda::Matchers::Independent::DelegateMatcher do
     end
   end
 
-  it 'raises an error if no delegation target is defined' do
+  it 'raises an error if the target method was never specified before matching' do
     expect {
-      delegate_method(:name).matches?(Object.new)
-    }.to raise_exception described_class::TargetNotDefinedError
+      expect(Object.new).to delegate_method(:name)
+    }.to raise_error described_class::TargetNotDefinedError
   end
 
-  it 'raises an error if called with #should_not' do
-    expect {
-      delegate_method(:name).to(:anyone).does_not_match?(Object.new)
-    }.to raise_exception described_class::InvalidDelegateMatcher
+  context 'stubbing an instance delegating method' 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 'given a method that does not delegate' do
@@ -54,14 +74,15 @@ describe Shoulda::Matchers::Independent::DelegateMatcher do
 
     it 'rejects' do
       post_office = PostOffice.new
-      matcher = delegate_method(:deliver_mail).to(:mailman)
-
-      expect(matcher.matches?(post_office)).to be false
+      expect(post_office).not_to delegate_method(:deliver_mail).to(:mailman)
     end
 
     it 'has a failure message that indicates which method should have been delegated' do
       post_office = PostOffice.new
-      message = 'Expected PostOffice#deliver_mail to delegate to PostOffice#mailman'
+      message = [
+        'Expected PostOffice#deliver_mail to delegate to PostOffice#mailman',
+        'Calls on PostOffice#mailman: (none)'
+      ].join("\n")
 
       expect {
         expect(post_office).to delegate_method(:deliver_mail).to(:mailman)
@@ -69,7 +90,10 @@ describe Shoulda::Matchers::Independent::DelegateMatcher do
     end
 
     it 'uses the proper syntax for class methods in errors' do
-      message = 'Expected PostOffice.deliver_mail to delegate to PostOffice.mailman'
+      message = [
+        'Expected PostOffice.deliver_mail to delegate to PostOffice.mailman',
+        'Calls on PostOffice.mailman: (none)'
+      ].join("\n")
 
       expect {
         expect(PostOffice).to delegate_method(:deliver_mail).to(:mailman)
@@ -78,7 +102,7 @@ describe Shoulda::Matchers::Independent::DelegateMatcher do
   end
 
   context 'given a method that delegates properly' do
-    it 'accepts' do
+    before do
       define_class(:mailman)
 
       define_class(:post_office) do
@@ -90,16 +114,24 @@ describe Shoulda::Matchers::Independent::DelegateMatcher do
           Mailman.new
         end
       end
+    end
 
+    it 'accepts' do
       post_office = PostOffice.new
-
       expect(post_office).to delegate_method(:deliver_mail).to(:mailman)
     end
+
+    it 'produces the correct failure message if the assertion was negated' do
+      post_office = PostOffice.new
+      message = 'Expected PostOffice#deliver_mail not to delegate to PostOffice#mailman, but it did'
+
+      expect {
+        expect(post_office).not_to delegate_method(:deliver_mail).to(:mailman)
+      }.to fail_with_message(message)
+    end
   end
 
   context 'given a method that delegates properly with arguments' do
-    let(:post_office) { PostOffice.new }
-
     before do
       define_class(:mailman)
 
@@ -116,33 +148,49 @@ describe Shoulda::Matchers::Independent::DelegateMatcher do
 
     context 'when given the correct arguments' do
       it 'accepts' do
-        expect(post_office).to delegate_method(:deliver_mail)
-          .to(:mailman).with_arguments('221B Baker St.', hastily: true)
+        post_office = PostOffice.new
+        expect(post_office).to delegate_method(:deliver_mail).
+          to(:mailman).with_arguments('221B Baker St.', hastily: true)
+      end
+
+      it 'produces the correct failure message if the assertion was negated' do
+        post_office = PostOffice.new
+        message = 'Expected PostOffice#deliver_mail not to delegate to PostOffice#mailman with 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
 
     context 'when not given the correct arguments' do
       it 'rejects' do
-        matcher = delegate_method(:deliver_mail).to(:mailman)
-          .with_arguments('123 Nowhere Ln.')
-
-        expect(matcher.matches?(post_office)).to be_false
+        post_office = PostOffice.new
+        expect(post_office).
+          not_to delegate_method(:deliver_mail).to(:mailman).
+          with_arguments('123 Nowhere Ln.')
       end
 
       it 'has a failure message that indicates which arguments were expected' do
-        message = 'Expected PostOffice#deliver_mail to delegate to PostOffice#mailman with arguments: ["123 Nowhere Ln."]'
+        post_office = PostOffice.new
+        message = [
+          'Expected PostOffice#deliver_mail to delegate to PostOffice#mailman with arguments: ["123 Nowhere Ln."]',
+          'Calls on 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.')
+          expect(post_office).to delegate_method(:deliver_mail).
+            to(:mailman).with_arguments('123 Nowhere Ln.')
         }.to fail_with_message(message)
       end
     end
   end
 
   context 'given a method that delegates properly to a method of a different name' do
-    let(:post_office) { PostOffice.new }
-
     before do
       define_class(:mailman)
 
@@ -159,24 +207,42 @@ describe Shoulda::Matchers::Independent::DelegateMatcher do
 
     context 'when given the correct method name' do
       it 'accepts' do
-        expect(post_office).to delegate_method(:deliver_mail)
-          .to(:mailman).as(:deliver_mail_and_avoid_dogs)
+        post_office = PostOffice.new
+        expect(post_office).to delegate_method(:deliver_mail).
+          to(:mailman).as(:deliver_mail_and_avoid_dogs)
+      end
+
+      it 'produces the correct failure message if the assertion was negated' do
+        post_office = PostOffice.new
+        message = 'Expected PostOffice#deliver_mail not to delegate to PostOffice#mailman 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
 
     context 'when given an incorrect method name' do
       it 'rejects' do
-        matcher = delegate_method(:deliver_mail).to(:mailman).as(:watch_tv)
-
-        expect(matcher.matches?(post_office)).to be_false
+        post_office = PostOffice.new
+        expect(post_office).
+          not_to delegate_method(:deliver_mail).to(:mailman).as(:watch_tv)
       end
 
       it 'has a failure message that indicates which method was expected' do
-        message = 'Expected PostOffice#deliver_mail to delegate to PostOffice#mailman as #watch_tv'
+        post_office = PostOffice.new
+        message = [
+          'Expected PostOffice#deliver_mail to delegate to PostOffice#mailman as #watch_tv',
+          'Calls on PostOffice#mailman:',
+          '1) deliver_mail_and_avoid_dogs()'
+        ].join("\n")
 
         expect {
-          expect(post_office).to delegate_method(:deliver_mail)
-            .to(:mailman).as(:watch_tv)
+          expect(post_office).to delegate_method(:deliver_mail).
+            to(:mailman).as(:watch_tv)
         }.to fail_with_message(message)
       end
     end

data/spec/support/controller_builder.rb

@@ -58,21 +58,30 @@ module ControllerBuilder
     $test_app.create_temp_view(path, contents)
   end
 
-  def controller_for_resource_with_strong_parameters(options = {}, &block)
-    define_model "User"
-    controller_class = define_controller "Users" do
-      define_method options.fetch(:action) do
-        @user = User.create(user_params)
+  def controller_for_resource_with_strong_parameters(options = {}, &action_body)
+    model_name = options.fetch(:model_name, 'User')
+    controller_name = options.fetch(:controller_name, 'UsersController')
+    collection_name = controller_name.
+      to_s.sub(/Controller$/, '').underscore.
+      to_sym
+    action_name = options.fetch(:action, :some_action)
+    routes ||= options.fetch(:routes, -> { resources collection_name })
+
+    define_model(model_name)
+
+    controller_class = define_controller(controller_name) do
+      define_method action_name do
+        if action_body
+          instance_eval(&action_body)
+        end
+
         render nothing: true
       end
-
-      private
-      define_method :user_params, &block
     end
 
     setup_rails_controller_test(controller_class)
 
-    define_routes { resources :users }
+    define_routes(&routes)
 
     controller_class
   end