shoulda-matchers 3.1.0 → 5.2.0

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

@@ -1,190 +0,0 @@
-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(build_world, :klass)
-
-        double_collection.register_stub(:a_method)
-
-        expect(DoubleImplementationRegistry).to have_received(:find).with(:stub)
-      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(world, :klass)
-
-        double_collection.register_stub(:a_method)
-
-        expect(Double).
-          to have_received(:new).
-          with(world, :klass, :a_method, :implementation)
-      end
-
-      context 'if a double has already been registered for the method' do
-        it 'does not call Double.new again' do
-          world = build_world
-          allow(DoubleImplementationRegistry).
-            to receive(:find).
-            and_return(:implementation)
-          allow(Double).to receive(:new)
-          double_collection = described_class.new(world, :klass)
-
-          double_collection.register_stub(:a_method)
-          double_collection.register_stub(:a_method)
-
-          expect(Double).to have_received(:new).once
-        end
-
-        it 'returns the same Double' do
-          world = build_world
-          allow(DoubleImplementationRegistry).
-            to receive(:find).
-            and_return(:implementation)
-          allow(Double).to receive(:new)
-          double_collection = described_class.new(world, :klass)
-
-          double1 = double_collection.register_stub(:a_method)
-          double2 = double_collection.register_stub(:a_method)
-
-          expect(double1).to equal(double2)
-        end
-      end
-    end
-
-    describe '#register_proxy' do
-      it 'calls DoubleImplementationRegistry.find correctly' do
-        allow(DoubleImplementationRegistry).to receive(:find)
-        double_collection = described_class.new(build_world, :klass)
-
-        double_collection.register_proxy(:a_method)
-
-        expect(DoubleImplementationRegistry).
-          to have_received(:find).
-          with(:proxy)
-      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(world, :klass)
-
-        double_collection.register_proxy(:a_method)
-
-        expect(Double).
-          to have_received(:new).
-          with(world, :klass, :a_method, :implementation)
-      end
-
-      context 'if a double has already been registered for the method' do
-        it 'does not call Double.new again' do
-          world = build_world
-          allow(DoubleImplementationRegistry).
-            to receive(:find).
-            and_return(:implementation)
-          allow(Double).to receive(:new)
-          double_collection = described_class.new(world, :klass)
-
-          double_collection.register_proxy(:a_method)
-          double_collection.register_proxy(:a_method)
-
-          expect(Double).to have_received(:new).once
-        end
-
-        it 'returns the same Double' do
-          world = build_world
-          allow(DoubleImplementationRegistry).
-            to receive(:find).
-            and_return(:implementation)
-          allow(Double).to receive(:new)
-          double_collection = described_class.new(world, :klass)
-
-          double1 = double_collection.register_proxy(:a_method)
-          double2 = double_collection.register_proxy(:a_method)
-
-          expect(double1).to equal(double2)
-        end
-      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(build_world, klass)
-        double_collection.register_stub(:first_method)
-        double_collection.register_stub(:second_method)
-
-        double_collection.activate
-
-        instance = klass.new
-        expect(instance.first_method).to eq nil
-        expect(instance.second_method).to eq nil
-      end
-    end
-
-    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(build_world, klass)
-        double_collection.register_stub(:first_method)
-        double_collection.register_stub(:second_method)
-
-        double_collection.activate
-        double_collection.deactivate
-
-        instance = klass.new
-        expect(instance.first_method).to eq 1
-        expect(instance.second_method).to eq 2
-      end
-    end
-
-    describe '#calls_to' do
-      it 'returns all calls to the given method' do
-        klass = create_class(a_method: nil)
-        double_collection = described_class.new(build_world, klass)
-        double_collection.register_stub(:a_method)
-        double_collection.activate
-
-        actual_calls = [
-          { args: [:some, :args, :here] },
-          { args: [:some, :args], block: -> { :whatever } }
-        ]
-        instance = klass.new
-        instance.a_method(*actual_calls[0][:args])
-        instance.a_method(*actual_calls[1][:args], &actual_calls[1][:block])
-
-        calls = double_collection.calls_to(:a_method)
-        expect(calls[0].args).to eq actual_calls[0][:args]
-        expect(calls[1].args).to eq actual_calls[1][:args]
-        expect(calls[1].block).to eq actual_calls[1][:block]
-      end
-
-      it 'returns an empty array if the method has never been doubled' do
-        klass = create_class
-        double_collection = described_class.new(build_world, klass)
-        expect(double_collection.calls_to(:non_existent_method)).to eq []
-      end
-    end
-
-    def create_class(methods = {})
-      Class.new.tap do |klass|
-        methods.each do |name, value|
-          klass.__send__(:define_method, name) { |*args| value }
-        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,21 +0,0 @@
-require 'doublespeak_spec_helper'
-
-module Shoulda::Matchers::Doublespeak
-  describe DoubleImplementationRegistry do
-    describe '.find' do
-      it 'returns an instance of StubImplementation if given :stub' do
-        expect(described_class.find(:stub)).to be_a(StubImplementation)
-      end
-
-      it 'returns ProxyImplementation if given :proxy' do
-        expect(described_class.find(:proxy)).to be_a(ProxyImplementation)
-      end
-
-      it 'raises an ArgumentError if not given a registered implementation' do
-        expect {
-          expect(described_class.find(:something_else))
-        }.to raise_error(ArgumentError)
-      end
-    end
-  end
-end

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

@@ -1,271 +0,0 @@
-require 'doublespeak_spec_helper'
-
-module Shoulda::Matchers::Doublespeak
-  describe Double do
-    describe 'initializer' do
-      context 'if doubles are currently activated on the world level' do
-        it 'immediately activates the new Double' do
-          world = build_world(doubles_activated?: true)
-          klass = create_class(a_method_name: nil)
-          implementation = build_implementation
-
-          double = described_class.new(world, klass, :a_method_name, implementation)
-
-          expect(double).to be_activated
-        end
-      end
-    end
-
-    describe '#to_return' do
-      it 'tells its implementation to call the given block' do
-        sent_block = -> { }
-        actual_block = nil
-        implementation = build_implementation
-        implementation.singleton_class.__send__(:undef_method, :returns)
-        implementation.singleton_class.__send__(:define_method, :returns) do |&block|
-          actual_block = block
-        end
-        double = described_class.new(
-          build_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(
-          build_world,
-          :klass,
-          :a_method,
-          implementation
-        )
-        double.to_return(:implementation)
-
-        expect(implementation).to have_received(:returns).with(:implementation)
-      end
-
-      it 'prefers a block over a non-block' do
-        sent_block = -> { }
-        actual_block = nil
-        implementation = build_implementation
-        implementation.singleton_class.__send__(:undef_method, :returns)
-        implementation.singleton_class.__send__(:define_method, :returns) do |&block|
-          actual_block = block
-        end
-        double = described_class.new(
-          build_world,
-          :klass,
-          :a_method,
-          implementation
-        )
-        double.to_return(:value, &sent_block)
-        expect(actual_block).to eq sent_block
-      end
-    end
-
-    describe '#activate' do
-      it 'replaces the method with an implementation' do
-        implementation = build_implementation
-        method_name = :a_method
-        klass = create_class(method_name => :some_return_value)
-        instance = klass.new
-        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,
-          caller: :some_caller
-        )
-
-        double.activate
-        instance.__send__(method_name, *args, &block)
-
-        expect(implementation).
-          to have_received(:call).
-          with(call)
-      end
-    end
-
-    describe '#deactivate' do
-      it 'restores the original method after being doubled' do
-        klass = create_class(a_method: 42)
-        world = build_world(
-          original_method_for: klass.instance_method(:a_method)
-        )
-        instance = klass.new
-        double = described_class.new(
-          world,
-          klass,
-          :a_method,
-          build_implementation
-        )
-
-        double.activate
-        double.deactivate
-        expect(instance.a_method).to eq 42
-      end
-
-      it 'still restores the original method if #activate was called twice' do
-        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(
-          world,
-          klass,
-          :a_method,
-          build_implementation
-        )
-
-        double.activate
-        double.activate
-        double.deactivate
-        expect(instance.a_method).to eq 42
-      end
-
-      it 'does nothing if the method has not been doubled' do
-        klass = create_class(a_method: 42)
-        instance = klass.new
-        double = described_class.new(
-          build_world,
-          klass,
-          :a_method,
-          build_implementation
-        )
-
-        double.deactivate
-        expect(instance.a_method).to eq 42
-      end
-    end
-
-    describe '#record_call' do
-      it 'adds the given call to the list of calls' do
-        double = described_class.new(
-          build_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 given object and calls it with the given args and block' do
-        expected_args = [:one, :two, :three]
-        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(call)
-
-        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
-        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)
-
-        instance.__send__(method_name)
-
-        expect(was_called).to be false
-      end
-    end
-
-    def create_class(methods = {})
-      Class.new.tap do |klass|
-        methods.each do |name, value|
-          klass.__send__(:define_method, name) { |*args| value }
-        end
-      end
-    end
-
-    def build_implementation
-      double('implementation', returns: nil, call: nil)
-    end
-
-    def build_world(methods = {})
-      defaults = {
-        original_method_for: nil,
-        store_original_method_for: nil,
-        doubles_activated?: nil
-      }
-      double('world', defaults.merge(methods))
-    end
-  end
-end

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