rspec-fire 0.3.0 → 0.4.0

data/HISTORY

@@ -12,3 +12,11 @@
 
 0.3.0 - 17 March 2012
   * Added support for doubling constants.
+
+0.4.0 - 1 April 2012
+  * Handle default args and splats correctly.
+  * rspec-mocks 2.9-master support.
+  * Allow `fire_double("Class", :foo => 17)` syntax.
+  * Allow `mock.stub(:foo => 17)` syntax.
+  * Don't count block params when determining max arity.
+  * Restore original const value when a const is stubbed more than once.

data/lib/rspec/fire.rb

@@ -4,6 +4,57 @@ require 'delegate'
 
 module RSpec
   module Fire
+    class SupportArityMatcher
+      def initialize(arity)
+        @arity = arity
+      end
+
+      attr_reader :arity, :method
+
+      def matches?(method)
+        @method = method
+        min_arity <= arity && arity <= max_arity
+      end
+
+      def failure_message_for_should
+        "Wrong number of arguments for #{method.name}. " +
+          "Expected #{arity_description}, got #{arity}."
+      end
+
+    private
+
+      INFINITY = 1/0.0
+
+      if method(:method).respond_to?(:parameters)
+        def max_arity
+          params = method.parameters
+          return INFINITY if params.any? { |(type, name)| type == :rest } # splat
+          params.count { |(type, name)| type != :block }
+        end
+      else
+        # On 1.8, Method#parameters does not exist.
+        # There's no way to distinguish between default and splat args, so
+        # there's no way to have it work correctly for both default and splat args,
+        # as far as I can tell.
+        # The best we can do is consider it INFINITY (to be tolerant of splat args).
+        def max_arity
+          method.arity < 0 ? INFINITY : method.arity
+        end
+      end
+
+      def min_arity
+        return method.arity if method.arity >= 0
+        # ~ inverts the one's complement and gives us the number of required args
+        ~method.arity
+      end
+
+      def arity_description
+        return min_arity if min_arity == max_arity
+        return "#{min_arity} or more" if max_arity == INFINITY
+        "#{min_arity} to #{max_arity}"
+      end
+    end
+
     module RecursiveConstMethods
       def recursive_const_get name
         name.split('::').inject(Object) {|klass,name| klass.const_get name }
@@ -19,7 +70,6 @@ module RSpec
     end
 
     class ShouldProxy < SimpleDelegator
-      extend RSpec::Matchers::DSL
       include RecursiveConstMethods
 
       AM = RSpec::Mocks::ArgumentMatchers
@@ -52,19 +102,12 @@ module RSpec
 
       def ensure_arity(actual)
         @double.with_doubled_class do |klass|
-          klass.send(@method_finder, @sym).should have_arity(actual)
+          klass.send(@method_finder, @sym).should support_arity(actual)
         end
       end
 
-      define :have_arity do |actual|
-        match do |method|
-          method.arity >= 0 && method.arity == actual
-        end
-
-        failure_message_for_should do |method|
-          "Wrong number of arguments for #{method.name}. " +
-            "Expected #{method.arity}, got #{actual}."
-        end
+      def support_arity(arity)
+        SupportArityMatcher.new(arity)
       end
     end
 
@@ -83,12 +126,18 @@ module RSpec
       end
 
       def stub(method_name)
-        ensure_implemented(method_name)
+        ensure_implemented(method_name) unless method_name.is_a?(Hash)
         super
       end
 
+      def stub!(method_name)
+        stub(method_name)
+      end
+
       def with_doubled_class
-        if recursive_const_defined?(@__doubled_class_name)
+        if original_stubbed_const_value = ConstantStubber.original_value_for(@__doubled_class_name)
+          yield original_stubbed_const_value
+        elsif recursive_const_defined?(@__doubled_class_name)
           yield recursive_const_get(@__doubled_class_name)
         end
       end
@@ -135,9 +184,11 @@ module RSpec
 
         # __declared_as copied from rspec/mocks definition of `double`
         args.last[:__declared_as] = 'FireDouble'
-        super
+
         @__checked_methods = :public_instance_methods
         @__method_finder   = :instance_method
+
+        super
       end
     end
 
@@ -150,8 +201,20 @@ module RSpec
           @__checked_methods = :public_methods
           @__method_finder   = :method
 
-          stubs.each do |message, response|
-            stub(message).and_return(response)
+          # TestDouble was added after rspec 2.9.0, and allows proper mocking
+          # of public methods that have clashing private methods. See spec for
+          # details.
+          if defined?(::RSpec::Mocks::TestDouble)
+            ::RSpec::Mocks::TestDouble.extend_onto self,
+              doubled_class, stubs.merge(:__declared_as => "FireClassDouble")
+          else
+            stubs.each do |message, response|
+              stub(message).and_return(response)
+            end
+
+            def self.method_missing(name, *args)
+              __mock_proxy.raise_unexpected_message_error(name, *args)
+            end
           end
 
           def self.as_replaced_constant(options = {})
@@ -171,10 +234,6 @@ module RSpec
           def self.name
             @__doubled_class_name
           end
-
-          def self.method_missing(name, *args)
-            __mock_proxy.raise_unexpected_message_error(name, *args)
-          end
         end
       end
 
@@ -190,7 +249,7 @@ module RSpec
 
       class DefinedConstantReplacer
         include RecursiveConstMethods
-        attr_reader :original_value
+        attr_reader :original_value, :full_constant_name
 
         def initialize(full_constant_name, stubbed_value, transfer_nested_constants)
           @full_constant_name        = full_constant_name
@@ -259,6 +318,8 @@ module RSpec
       class UndefinedConstantSetter
         include RecursiveConstMethods
 
+        attr_reader :full_constant_name
+
         def initialize(full_constant_name, stubbed_value)
           @full_constant_name = full_constant_name
           @stubbed_value      = stubbed_value
@@ -301,10 +362,38 @@ module RSpec
           UndefinedConstantSetter.new(constant_name, value)
         end
 
+        stubbers << stubber
+
         stubber.stub!
-        ::RSpec::Mocks.space.add(stubber)
+        ensure_registered_with_rspec_mocks
         stubber.original_value
       end
+
+      def self.ensure_registered_with_rspec_mocks
+        return if @registered_with_rspec_mocks
+        ::RSpec::Mocks.space.add(self)
+        @registered_with_rspec_mocks = true
+      end
+
+      def self.rspec_reset
+        @registered_with_rspec_mocks = false
+
+        # We use reverse order so that if the same constant
+        # was stubbed multiple times, the original value gets
+        # properly restored.
+        stubbers.reverse.each { |s| s.rspec_reset }
+
+        stubbers.clear
+      end
+
+      def self.stubbers
+        @stubbers ||= []
+      end
+
+      def self.original_value_for(constant_name)
+        stubber = stubbers.find { |s| s.full_constant_name == constant_name }
+        stubber.original_value if stubber
+      end
     end
 
     def stub_const(name, value, options = {})

data/rspec-fire.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name     = 'rspec-fire'
-  s.version  = '0.3.0'
+  s.version  = '0.4.0'
   s.summary  = 'More resilient test doubles for RSpec.'
   s.platform = Gem::Platform::RUBY
   s.authors  = ["Xavier Shay"]

data/spec/fire_double_spec.rb

@@ -1,14 +1,9 @@
 require 'spec_helper'
 
-TOP_LEVEL_VALUE_CONST = 7
+def use; end
+private :use
 
-RSpec::Mocks::Space.class_eval do
-  # Deal with the fact that #mocks was renamed to #receivers for RSpec 2.9:
-  # https://github.com/rspec/rspec-mocks/commit/17c259ea5143d309e90ca6d53d40f6356ac2d0a5
-  unless private_instance_methods.map(&:to_sym).include?(:receivers)
-    alias_method :receivers, :mocks
-  end
-end
+TOP_LEVEL_VALUE_CONST = 7
 
 module TestMethods
   def defined_method
@@ -25,6 +20,7 @@ class TestObject
 end
 
 class TestClass
+  include TestMethods
   extend TestMethods
 
   M = :m
@@ -34,6 +30,10 @@ class TestClass
     class NestedEvenMore
     end
   end
+
+  def self.use
+    raise "Y U NO MOCK?"
+  end
 end
 
 shared_examples_for 'a fire-enhanced double method' do
@@ -49,20 +49,26 @@ shared_examples_for 'a fire-enhanced double method' do
 end
 
 shared_examples_for 'a fire-enhanced double' do
-  def self.should_allow(method_name)
-    it "should allow #{method_name}" do
+  def self.should_allow(method_parameters)
+    method_to_stub = method_parameters.is_a?(Hash) ?
+      method_parameters.keys.first : method_parameters
+
+    it "should allow #{method_to_stub}" do
       lambda {
-        doubled_object.send(method_under_test, method_name)
+        doubled_object.send(method_under_test, method_parameters)
       }.should_not raise_error
       doubled_object.rspec_reset
     end
   end
 
-  def self.should_not_allow(method_name)
-    it "should not allow #{method_name}" do
+  def self.should_not_allow(method_parameters)
+    method_to_stub = method_parameters.is_a?(Hash) ?
+      method_parameters.keys.first : method_parameters
+
+    it "should not allow #{method_to_stub}" do
       lambda {
-        doubled_object.send(method_under_test, method_name)
-      }.should fail_matching("does not implement", method_name)
+        doubled_object.send(method_under_test, method_parameters)
+      }.should fail_matching("does not implement", method_to_stub)
     end
   end
 
@@ -136,9 +142,23 @@ shared_examples_for 'a fire-enhanced double' do
     it_should_behave_like 'a fire-enhanced double method'
   end
 
-  describe '#stub' do
-    let(:method_under_test) { :stub }
-    it_should_behave_like 'a fire-enhanced double method'
+  [ :stub, :stub! ].each do |stubber|
+    describe "##{stubber}" do
+      let(:method_under_test) { stubber }
+      it_should_behave_like 'a fire-enhanced double method'
+
+      context "RSpec's hash shortcut syntax" do
+        context 'doubled class is not loaded' do
+          let(:doubled_object) { fire_double("UnloadedObject") }
+          should_allow(:undefined_method => 123)
+        end
+
+        context 'doubled class is loaded' do
+          should_allow(:defined_method => 456)
+          should_not_allow(:undefined_method => 789)
+        end
+      end
+    end
   end
 end
 
@@ -146,6 +166,11 @@ describe '#fire_double' do
   let(:doubled_object) { fire_double("TestObject") }
 
   it_should_behave_like 'a fire-enhanced double'
+
+  it 'allows stubs to be passed as a hash' do
+    double = fire_double("TestObject", :defined_method => 17)
+    double.defined_method.should eq(17)
+  end
 end
 
 describe '#fire_class_double' do
@@ -178,6 +203,16 @@ describe '#fire_class_double' do
     double.a.should eq(5)
     double.b.should eq(8)
   end
+
+  it 'allows private methods to be stubbed, just like on a normal test double (but unlike a partial mock)' do
+    mod = Module.new
+    mod.stub(:use)
+    expect { mod.use }.to raise_error(/private method `use' called/)
+
+    fire_double = fire_class_double("TestClass")
+    fire_double.stub(:use)
+    fire_double.use # should not raise an error
+  end if defined?(::RSpec::Mocks::TestDouble)
 end
 
 def reset_rspec_mocks
@@ -202,6 +237,31 @@ describe '#fire_replaced_class_double (for an existing class)' do
     TestClass::M.should eq(:m)
     TestClass::N.should eq(:n)
   end
+
+  def use_doubles(class_double, instance_double)
+    instance_double.should_receive(:defined_method).and_return(3)
+    class_double.should_receive(:defined_method).and_return(4)
+
+    instance_double.defined_method.should eq(3)
+    class_double.defined_method.should eq(4)
+
+    expect { instance_double.should_receive(:undefined_method) }.to fail_matching("does not implement")
+    expect { class_double.should_receive(:undefined_method) }.to fail_matching("does not implement")
+  end
+
+  it 'can be used after a declared fire_double for the same class' do
+    instance_double = fire_double("TestClass")
+    class_double = fire_replaced_class_double("TestClass")
+
+    use_doubles class_double, instance_double
+  end
+
+  it 'can be used before a declared fire_double for the same class' do
+    class_double = fire_replaced_class_double("TestClass")
+    instance_double = fire_double("TestClass")
+
+    use_doubles class_double, instance_double
+  end
 end
 
 describe '#fire_replaced_class_double (for a non-existant class)' do
@@ -297,7 +357,7 @@ shared_examples_for "unloaded constant stubbing" do |const_name|
   it 'does not remove the constant when the example manually sets it' do
     begin
       stub_const(const_name, 7)
-      stubber = RSpec::Mocks.space.send(:receivers).first
+      stubber = RSpec::Fire::ConstantStubber.stubbers.first
       change_const_value_to(new_const_value = Object.new)
       reset_rspec_mocks
       const.should equal(new_const_value)
@@ -322,6 +382,16 @@ describe "#stub_const" do
   context 'for a loaded unnested constant' do
     it_behaves_like "loaded constant stubbing", "TestClass"
 
+    it 'can be stubbed multiple times but still restores the original value properly' do
+      orig_value = TestClass
+      stub1, stub2 = Module.new, Module.new
+      stub_const("TestClass", stub1)
+      stub_const("TestClass", stub2)
+
+      reset_rspec_mocks
+      TestClass.should be(orig_value)
+    end
+
     it 'allows nested constants to be transferred to a stub module' do
       tc_nested = TestClass::Nested
       stub = Module.new
@@ -443,3 +513,86 @@ describe "#stub_const" do
     end
   end
 end
+
+describe RSpec::Fire::SupportArityMatcher do
+  def support_arity(arity)
+    RSpec::Fire::SupportArityMatcher.new(arity)
+  end
+
+  context "a method with an exact arity" do
+    def two_args(a, b); end
+    def no_args; end
+
+    it 'passes when given the correct arity' do
+      method(:two_args).should support_arity(2)
+      method(:no_args).should support_arity(0)
+    end
+
+    it 'fails when given the wrong arity' do
+      expect {
+        method(:no_args).should support_arity(1)
+      }.to raise_error(/Expected 0, got 1/)
+
+      expect {
+        method(:two_args).should support_arity(1)
+      }.to raise_error(/Expected 2, got 1/)
+    end
+  end
+
+  context "a method with one required arg and two default args" do
+    def m(a, b=5, c=2); end
+
+    it 'passes when given 1 to 3 args' do
+      method(:m).should support_arity(1)
+      method(:m).should support_arity(2)
+      method(:m).should support_arity(3)
+    end
+
+    let(:can_distinguish_splat_from_defaults?) { method(:method).respond_to?(:parameters) }
+
+    it 'fails when given 0' do
+      pending("1.8 cannot distinguish default args from splats", :unless => can_distinguish_splat_from_defaults?) do
+        expect {
+          method(:m).should support_arity(0)
+        }.to raise_error(/Expected 1 to 3, got 0/)
+      end
+    end
+
+    it 'fails when given more than 3' do
+      pending("1.8 cannot distinguish default args from splats", :unless => can_distinguish_splat_from_defaults?) do
+        expect {
+          method(:m).should support_arity(4)
+        }.to raise_error(/Expected 1 to 3, got 4/)
+      end
+    end
+  end
+
+  context "a method with one required arg and a splat" do
+    def m(a, *b); end
+
+    it 'passes when given 1 or more' do
+      method(:m).should support_arity(1)
+      method(:m).should support_arity(20)
+    end
+
+    it 'fails when given 0' do
+      expect {
+        method(:m).should support_arity(0)
+      }.to raise_error(/Expected 1 or more, got 0/)
+    end
+  end
+
+  context "a method with an explicit block arg" do
+    def m(a, &b); end
+
+    it 'passes when given 1' do
+      method(:m).should support_arity(1)
+    end
+
+    it 'fails when given 2' do
+      expect {
+        method(:m).should support_arity(2)
+      }.to raise_error(/Expected 1, got 2/)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rspec-fire
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-18 00:00:00.000000000 Z
+date: 2012-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &2153330640 !ruby/object:Gem::Requirement
+  requirement: &2160595040 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2153330640
+  version_requirements: *2160595040
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2153330120 !ruby/object:Gem::Requirement
+  requirement: &2160594520 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,7 +32,7 @@ dependencies:
         version: '2.5'
   type: :development
   prerelease: false
-  version_requirements: *2153330120
+  version_requirements: *2160594520
 description: 
 email:
 - hello@xaviershay.com