shoulda-matchers 2.8.0 → 3.0.0.rc1

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

@@ -1,11 +1,11 @@
-require 'unit_spec_helper'
+require 'doublespeak_spec_helper'
 
 module Shoulda::Matchers::Doublespeak
   describe DoubleCollection do
     describe '#register_stub' do
       it 'calls DoubleImplementationRegistry.find correctly' do
         allow(DoubleImplementationRegistry).to receive(:find)
-        double_collection = described_class.new(:klass)
+        double_collection = described_class.new(build_world, :klass)
 
         double_collection.register_stub(:a_method)
 
@@ -13,24 +13,25 @@ module Shoulda::Matchers::Doublespeak
       end
 
       it 'calls Double.new correctly' do
+        world = build_world
         allow(DoubleImplementationRegistry).
           to receive(:find).
           and_return(:implementation)
         allow(Double).to receive(:new)
-        double_collection = described_class.new(:klass)
+        double_collection = described_class.new(world, :klass)
 
         double_collection.register_stub(:a_method)
 
         expect(Double).
           to have_received(:new).
-          with(:klass, :a_method, :implementation)
+          with(world, :klass, :a_method, :implementation)
       end
     end
 
     describe '#register_proxy' do
       it 'calls DoubleImplementationRegistry.find correctly' do
         allow(DoubleImplementationRegistry).to receive(:find)
-        double_collection = described_class.new(:klass)
+        double_collection = described_class.new(build_world, :klass)
 
         double_collection.register_proxy(:a_method)
 
@@ -40,24 +41,25 @@ module Shoulda::Matchers::Doublespeak
       end
 
       it 'calls Double.new correctly' do
+        world = build_world
         allow(DoubleImplementationRegistry).
           to receive(:find).
           and_return(:implementation)
         allow(Double).to receive(:new)
-        double_collection = described_class.new(:klass)
+        double_collection = described_class.new(world, :klass)
 
         double_collection.register_proxy(:a_method)
 
         expect(Double).
           to have_received(:new).
-          with(:klass, :a_method, :implementation)
+          with(world, :klass, :a_method, :implementation)
       end
     end
 
     describe '#activate' do
       it 'replaces all registered methods with doubles' do
         klass = create_class(first_method: 1, second_method: 2)
-        double_collection = described_class.new(klass)
+        double_collection = described_class.new(build_world, klass)
         double_collection.register_stub(:first_method)
         double_collection.register_stub(:second_method)
 
@@ -72,7 +74,7 @@ module Shoulda::Matchers::Doublespeak
     describe '#deactivate' do
       it 'restores the original methods that were doubled' do
         klass = create_class(first_method: 1, second_method: 2)
-        double_collection = described_class.new(klass)
+        double_collection = described_class.new(build_world, klass)
         double_collection.register_stub(:first_method)
         double_collection.register_stub(:second_method)
 
@@ -88,7 +90,7 @@ module Shoulda::Matchers::Doublespeak
     describe '#calls_to' do
       it 'returns all calls to the given method' do
         klass = create_class(a_method: nil)
-        double_collection = described_class.new(klass)
+        double_collection = described_class.new(build_world, klass)
         double_collection.register_stub(:a_method)
         double_collection.activate
 
@@ -108,7 +110,7 @@ module Shoulda::Matchers::Doublespeak
 
       it 'returns an empty array if the method has never been doubled' do
         klass = create_class
-        double_collection = described_class.new(klass)
+        double_collection = described_class.new(build_world, klass)
         expect(double_collection.calls_to(:non_existent_method)).to eq []
       end
     end
@@ -120,5 +122,9 @@ module Shoulda::Matchers::Doublespeak
         end
       end
     end
+
+    def build_world
+      Shoulda::Matchers::Doublespeak::World.new
+    end
   end
 end

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

@@ -1,4 +1,4 @@
-require 'unit_spec_helper'
+require 'doublespeak_spec_helper'
 
 module Shoulda::Matchers::Doublespeak
   describe DoubleImplementationRegistry do

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

@@ -1,4 +1,4 @@
-require 'unit_spec_helper'
+require 'doublespeak_spec_helper'
 
 module Shoulda::Matchers::Doublespeak
   describe Double do
@@ -11,14 +11,24 @@ module Shoulda::Matchers::Doublespeak
         implementation.singleton_class.__send__(:define_method, :returns) do |&block|
           actual_block = block
         end
-        double = described_class.new(:klass, :a_method, implementation)
+        double = described_class.new(
+          :a_world,
+          :klass,
+          :a_method,
+          implementation
+        )
         double.to_return(&sent_block)
         expect(actual_block).to eq sent_block
       end
 
       it 'tells its implementation to return the given value' do
         implementation = build_implementation
-        double = described_class.new(:klass, :a_method, implementation)
+        double = described_class.new(
+          :a_world,
+          :klass,
+          :a_method,
+          implementation
+        )
         double.to_return(:implementation)
 
         expect(implementation).to have_received(:returns).with(:implementation)
@@ -32,7 +42,12 @@ module Shoulda::Matchers::Doublespeak
         implementation.singleton_class.__send__(:define_method, :returns) do |&block|
           actual_block = block
         end
-        double = described_class.new(:klass, :a_method, implementation)
+        double = described_class.new(
+          :a_world,
+          :klass,
+          :a_method,
+          implementation
+        )
         double.to_return(:value, &sent_block)
         expect(actual_block).to eq sent_block
       end
@@ -41,27 +56,47 @@ module Shoulda::Matchers::Doublespeak
     describe '#activate' do
       it 'replaces the method with an implementation' do
         implementation = build_implementation
-        klass = create_class(a_method: 42)
+        method_name = :a_method
+        klass = create_class(method_name => :some_return_value)
         instance = klass.new
-        double = described_class.new(klass, :a_method, implementation)
+        double = described_class.new(
+          build_world,
+          klass,
+          method_name,
+          implementation
+        )
         args = [:any, :args]
         block = -> {}
+        call = MethodCall.new(
+          double: double,
+          object: instance,
+          method_name: method_name,
+          args: args,
+          block: block
+        )
 
         double.activate
-        instance.a_method(*args, &block)
+        instance.__send__(method_name, *args, &block)
 
         expect(implementation).
           to have_received(:call).
-          with(double, instance, args, block)
+          with(call)
       end
     end
 
     describe '#deactivate' do
       it 'restores the original method after being doubled' do
-        implementation = build_implementation
         klass = create_class(a_method: 42)
+        world = build_world(
+          original_method_for: klass.instance_method(:a_method)
+        )
         instance = klass.new
-        double = described_class.new(klass, :a_method, implementation)
+        double = described_class.new(
+          world,
+          klass,
+          :a_method,
+          build_implementation
+        )
 
         double.activate
         double.deactivate
@@ -69,10 +104,18 @@ module Shoulda::Matchers::Doublespeak
       end
 
       it 'still restores the original method if #activate was called twice' do
-        implementation = build_implementation
-        klass = create_class(a_method: 42)
+        method_name = :a_method
+        klass = create_class(method_name => 42)
+        world = build_world(
+          original_method_for: klass.instance_method(:a_method)
+        )
         instance = klass.new
-        double = described_class.new(klass, :a_method, implementation)
+        double = described_class.new(
+          world,
+          klass,
+          :a_method,
+          build_implementation
+        )
 
         double.activate
         double.activate
@@ -81,10 +124,14 @@ module Shoulda::Matchers::Doublespeak
       end
 
       it 'does nothing if the method has not been doubled' do
-        implementation = build_implementation
         klass = create_class(a_method: 42)
         instance = klass.new
-        double = described_class.new(klass, :a_method, implementation)
+        double = described_class.new(
+          :a_world,
+          klass,
+          :a_method,
+          build_implementation
+        )
 
         double.deactivate
         expect(instance.a_method).to eq 42
@@ -92,50 +139,96 @@ module Shoulda::Matchers::Doublespeak
     end
 
     describe '#record_call' do
-      it 'stores the arguments and block given to the method in calls' do
-        double = described_class.new(:klass, :a_method, :implementation)
-        calls = [
-          [:any, :args], :block,
-          [:more, :args]
-        ]
-        double.record_call(calls[0][0], calls[0][1])
-        double.record_call(calls[1][0], nil)
-
-        expect(double.calls[0].args).to eq calls[0][0]
-        expect(double.calls[0].block).to eq calls[0][1]
-        expect(double.calls[1].args).to eq calls[1][0]
+      it 'adds the given call to the list of calls' do
+        double = described_class.new(
+          :a_world,
+          :a_klass,
+          :a_method,
+          :an_implementation
+        )
+        double.record_call(:some_call)
+        expect(double.calls.last).to eq :some_call
       end
     end
 
     describe '#call_original_method' do
-      it 'binds the stored method object to the class and calls it with the given args and block' do
-        klass = create_class
-        instance = klass.new
-        actual_args = actual_block = method_called = nil
+      it 'binds the stored method object to the given object and calls it with the given args and block' do
         expected_args = [:one, :two, :three]
         expected_block = -> { }
-        double = described_class.new(klass, :a_method, :implementation)
-
-        klass.__send__(:define_method, :a_method) do |*args, &block|
-          actual_args = expected_args
-          actual_block = expected_block
+        actual_args = actual_block = method_called = nil
+        method_name = :a_method
+        klass = create_class
+        klass.__send__(:define_method, method_name) do |*args, &block|
+          actual_args = args
+          actual_block = block
           method_called = true
         end
+        world = build_world(
+          original_method_for: klass.instance_method(method_name)
+        )
+        instance = klass.new
+        call = double('call',
+          object: instance,
+          method_name: method_name,
+          args: expected_args,
+          block: expected_block
+        )
+        double = described_class.new(
+          world,
+          klass,
+          method_name,
+          :an_implementation
+        )
 
         double.activate
-        double.call_original_method(instance, expected_args, expected_block)
+        double.call_original_method(call)
 
-        expect(expected_args).to eq actual_args
-        expect(expected_block).to eq actual_block
+        expect(actual_args).to eq expected_args
+        expect(actual_block).to eq expected_block
         expect(method_called).to eq true
       end
 
       it 'does nothing if no method has been stored' do
-        double = described_class.new(:klass, :a_method, :implementation)
+        method_name = :a_method
+        world = build_world(original_method_for: nil)
+        call = double('call', method_name: method_name)
+        double = described_class.new(
+          world,
+          :klass,
+          method_name,
+          :an_implementation
+        )
+        expect { double.call_original_method(call) }.not_to raise_error
+      end
+
+      it 'does not store the original method multiple times when a method is doubled multiple times' do
+        world = Shoulda::Matchers::Doublespeak::World.new
+        klass = create_class(a_method: :some_return_value)
+        method_name = :a_method
+        doubles = 2.times.map do
+          described_class.new(
+            world,
+            klass,
+            method_name,
+            build_implementation
+          )
+        end
+        instance = klass.new
+
+        doubles[0].activate
+
+        was_called = false
+        klass.__send__(:define_method, method_name) do
+          was_called = true
+        end
+
+        doubles[1].activate
+
+        doubles.each(&:deactivate)
 
-        expect {
-          double.call_original_method(:instance, [:any, :args], nil)
-        }.not_to raise_error
+        instance.__send__(method_name)
+
+        expect(was_called).to be false
       end
     end
 
@@ -150,5 +243,13 @@ module Shoulda::Matchers::Doublespeak
     def build_implementation
       double('implementation', returns: nil, call: nil)
     end
+
+    def build_world(methods = {})
+      defaults = {
+        original_method_for: nil,
+        store_original_method_for: nil
+      }
+      double('world', defaults.merge(methods))
+    end
   end
 end

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

@@ -1,4 +1,4 @@
-require 'unit_spec_helper'
+require 'doublespeak_spec_helper'
 
 module Shoulda::Matchers::Doublespeak
   describe ObjectDouble do

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

@@ -1,4 +1,4 @@
-require 'unit_spec_helper'
+require 'doublespeak_spec_helper'
 
 module Shoulda::Matchers::Doublespeak
   describe ProxyImplementation do
@@ -13,26 +13,45 @@ module Shoulda::Matchers::Doublespeak
     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(double, :object, :args, :block)
+
+        implementation.call(call)
 
         expect(stub_implementation).
           to have_received(:call).
-          with(double, :object, :args, :block)
+          with(call2)
       end
 
-      it 'calls #call_original_method on the double' do
+      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)
-        double = build_double
-        implementation.call(double, :object, :args, :block)
 
-        expect(double).
-          to have_received(:call_original_method).
-          with(:object, :args, :block)
+        return_value = implementation.call(call)
+
+        expect(return_value).to be return_value
       end
     end
 
@@ -40,8 +59,14 @@ module Shoulda::Matchers::Doublespeak
       double('stub_implementation', returns: nil, call: nil)
     end
 
-    def build_double
-      double('double', call_original_method: nil)
+    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