rspec-fire 0.1 → 0.2

data/HISTORY

@@ -1,2 +1,5 @@
 0.1 - 3 September 2011
   * Initial release
+
+0.2 - 3 September 2011
+  * Checks method arity when a 'with' call is present

data/README.md

@@ -23,13 +23,28 @@ Making your test doubles more resilient.
 
       -- Desert Way, Charlie Hunter
 
-Test doubles are sweet for isolating your unit tests, but we lost something in the translation from typed languages. Ruby doesn't have a compiler that can verify the contracts being mocked out are indeed legit. This hurts larger refactorings, since you can totally change a collaborator --- renaming methods, changing the number of arguments --- and all the mocks that were standing in for it will keep pretending everything is ok.
-
-`rspec-fire` mitigates that problem, with very little change to your existing coding style.
-
-One solution would be to disallow stubbing of methods that don't exist. This is what mocha does with its `Mocha::Configuration.prevent(:stubbing_non_existent_method)` option. The downside is, you now have to load the collaborators/dependencies that you are mocking, which kind of defeats the purpose of isolated testing. Not ideal.
-
-Another solution, that `rspec-fire` adopts, is a more relaxed version that only checks that the methods exist _if the doubled class has already been loaded_. No checking will happen when running the spec in isolation, but when run in the context of the full app (either as a full spec run or by explicitly preloading collaborators on the command line) a failure will be triggered if an invalid method is being stubbed.
+Test doubles are sweet for isolating your unit tests, but we lost something in
+the translation from typed languages. Ruby doesn't have a compiler that can
+verify the contracts being mocked out are indeed legit. This hurts larger
+refactorings, since you can totally change a collaborator --- renaming methods,
+changing the number of arguments --- and all the mocks that were standing in
+for it will keep pretending everything is ok.
+
+`rspec-fire` mitigates that problem, with very little change to your existing
+coding style.
+
+One solution would be to disallow stubbing of methods that don't exist. This is
+what mocha does with its
+`Mocha::Configuration.prevent(:stubbing_non_existent_method)` option. The
+downside is, you now have to load the collaborators/dependencies that you are
+mocking, which kind of defeats the purpose of isolated testing. Not ideal.
+
+Another solution, that `rspec-fire` adopts, is a more relaxed version that only
+checks that the methods exist _if the doubled class has already been loaded_.
+No checking will happen when running the spec in isolation, but when run in the
+context of the full app (either as a full spec run or by explicitly preloading
+collaborators on the command line) a failure will be triggered if an invalid
+method is being stubbed.
 
 Usage
 -----
@@ -62,38 +77,52 @@ Specify the class being doubled in your specs:
 
 Run your specs:
 
-    rspec spec/user_spec.rb                         # Isolated, will pass always
-    rspec -Ilib/email_notifier.rb spec/user_spec.rb # Will fail if EmailNotifier#notify method is not defined
+    # Isolated, will pass always
+    rspec spec/user_spec.rb
 
-Currently only method presence/absense is checked, but theoretically arity can be checked also.
+    # Will fail if EmailNotifier#notify method is not defined
+    rspec -Ilib/email_notifier.rb spec/user_spec.rb
+
+Method presence/absence is checked, and if a `with` is provided then so is
+arity.
 
 Protips
 -------
 
 ### Using with an existing Rails project
 
-Create a new file `unit_helper.rb` that _does not_ require `spec_helper.rb`. Require this file where needed for isolated tests. To run an isolated spec in the context of your app:
+Create a new file `unit_helper.rb` that _does not_ require `spec_helper.rb`.
+Require this file where needed for isolated tests. To run an isolated spec in
+the context of your app:
 
     rspec -rspec/spec_helper.rb spec/unit/my_spec.rb
 
 ### Doubling class methods
 
-Particularly handy for `ActiveRecord` finders. Use `fire_class_double`. If you dig into the code, you'll find you can create subclasses of `FireDouble` to check for *any* set of methods.
+Particularly handy for `ActiveRecord` finders. Use `fire_class_double`. If you
+dig into the code, you'll find you can create subclasses of `FireDouble` to
+check for *any* set of methods.
 
 ### Mocking Done Right (tm)
 
 * Only mock methods on collaborators, _not_ the class under test.
 * Only mock public methods.
-* Extract common mock setup to keep your specs [DRY](http://en.wikipedia.org/wiki/DRY).
+* Extract common mock setup to keep your specs
+  [DRY](http://en.wikipedia.org/wiki/DRY).
 
-If you can't meet these criteria, your object is probably violating [SOLID](http://en.wikipedia.org/wiki/SOLID) principles and you should either refactor or use a non-isolated test.
+If you can't meet these criteria, your object is probably violating
+[SOLID](http://en.wikipedia.org/wiki/SOLID) principles and you should either
+refactor or use a non-isolated test.
 
 Compatibility
 -------------
 
 Only RSpec 2 is supported. Tested on all the rubies.
 
-[![Build Status](https://secure.travis-ci.org/xaviershay/rspec-fire.png)](http://travis-ci.org/xaviershay/rspec-fire)
+[![Build Status][build-image]][build-link]
+
+[build-image]: https://secure.travis-ci.org/xaviershay/rspec-fire.png
+[build-link]:  http://travis-ci.org/xaviershay/rspec-fire
 
 Developing
 ----------
@@ -102,9 +131,10 @@ Developing
     bundle install
     bundle exec rake spec
 
-Patches welcome! I won't merge anything that isn't spec'ed, but I can help you out with that if you are getting stuck.
+Patches welcome! I won't merge anything that isn't spec'ed, but I can help you
+out with that if you are getting stuck.
 
-Still need to support `#stub_chain` and `#with` methods.
+Still need to support `#stub_chain`.
 
 Status
 ------

data/lib/rspec/fire.rb

@@ -1,13 +1,81 @@
 require 'rspec/mocks'
+require 'delegate'
 
 module RSpec
   module Fire
+    module RecursiveConstMethods
+      def recursive_const_get object, name
+        name.split('::').inject(Object) {|klass,name| klass.const_get name }
+      end
+
+      def recursive_const_defined? object, name
+        !!name.split('::').inject(Object) {|klass,name|
+          if klass && klass.const_defined?(name)
+            klass.const_get name
+          end
+        }
+      end
+    end
+
+    class ShouldProxy < SimpleDelegator
+      include RecursiveConstMethods
+
+      AM = RSpec::Mocks::ArgumentMatchers
+
+      def initialize(doubled_class_name, method_finder, backing)
+        @doubled_class_name = doubled_class_name
+        @method_finder      = method_finder
+        @backing            = backing
+        super(backing)
+      end
+
+      def with(*args, &block)
+        unless AM::AnyArgsMatcher === args.first
+          expected_arity = if AM::NoArgsMatcher === args.first
+            0
+          elsif args.length > 0
+            args.length
+          elsif block
+            block.arity
+          else
+            raise ArgumentError.new("No arguments nor block given.")
+          end
+          ensure_arity(expected_arity)
+        end
+        __getobj__.with(*args, &block)
+      end
+
+      protected
+
+      def ensure_arity(actual)
+        if recursive_const_defined?(Object, @doubled_class_name)
+          recursive_const_get(Object, @doubled_class_name).
+            send(@method_finder, sym).
+            should have_arity(actual)
+        end
+      end
+
+      def have_arity(actual)
+        RSpec::Matchers::Matcher.new(:have_arity, actual) 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
+        end
+      end
+    end
+
     class FireDouble < RSpec::Mocks::Mock
+      include RecursiveConstMethods
+
       def initialize(doubled_class, *args)
         args << {} unless Hash === args.last
 
         @__doubled_class_name = doubled_class
-        @__checked_methods    = :public_instance_methods
 
         # __declared_as copied from rspec/mocks definition of `double`
         args.last[:__declared_as] = 'FireDouble'
@@ -16,7 +84,7 @@ module RSpec
 
       def should_receive(method_name)
         ensure_implemented(method_name)
-        super
+        ShouldProxy.new(@__doubled_class_name, @__method_finder, super)
       end
 
       def should_not_receive(method_name)
@@ -38,23 +106,15 @@ module RSpec
         end
       end
 
-      def recursive_const_get object, name
-        name.split('::').inject(Object) {|klass,name| klass.const_get name }
-      end
-
-      def recursive_const_defined? object, name
-        !!name.split('::').inject(Object) {|klass,name|
-          if klass && klass.const_defined?(name)
-            klass.const_get name
-          end
-        }
-      end
-
       def implement(expected_methods, checked_methods)
-        RSpec::Matchers::Matcher.new(:implement, expected_methods, checked_methods) do |expected_methods, checked_methods|
+        RSpec::Matchers::Matcher.new(:implement,
+          expected_methods,
+          checked_methods
+        ) do |expected_methods, checked_methods|
           unimplemented_methods = lambda {|doubled_class|
             implemented_methods = doubled_class.send(checked_methods)
-            expected_methods - implemented_methods.map(&:to_sym) # to_sym for non-1.9 compat
+            # to_sym for non-1.9 compat
+            expected_methods - implemented_methods.map(&:to_sym)
           }
 
           match do |doubled_class|
@@ -62,7 +122,8 @@ module RSpec
           end
 
           failure_message_for_should do |doubled_class|
-            implemented_methods   = Object.public_methods - doubled_class.send(checked_methods)
+            implemented_methods =
+              Object.public_methods - doubled_class.send(checked_methods)
             "%s does not implement:\n%s" % [
               doubled_class,
               unimplemented_methods[ doubled_class ].sort.map {|x|
@@ -74,15 +135,24 @@ module RSpec
       end
     end
 
+    class FireObjectDouble < FireDouble
+      def initialize(*args)
+        super
+        @__checked_methods = :public_instance_methods
+        @__method_finder   = :instance_method
+      end
+    end
+
     class FireClassDouble < FireDouble
       def initialize(*args)
         super
         @__checked_methods = :public_methods
+        @__method_finder   = :method
       end
     end
 
     def fire_double(*args)
-      FireDouble.new(*args)
+      FireObjectDouble.new(*args)
     end
 
     def fire_class_double(*args)

data/rspec-fire.gemspec

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

data/spec/fire_double_spec.rb

@@ -1,17 +1,23 @@
 require 'spec_helper'
 
-class TestObject
+module TestMethods
   def defined_method
     raise "Y U NO MOCK?"
   end
-end
 
-class TestClass
-  def self.defined_method
+  def defined_method_one_arg(arg1)
     raise "Y U NO MOCK?"
   end
 end
 
+class TestObject
+  include TestMethods
+end
+
+class TestClass
+  extend TestMethods
+end
+
 shared_examples_for 'a fire-enhanced double method' do
   describe 'doubled class is not loaded' do
     let(:doubled_object) { fire_double("UnloadedObject") }
@@ -38,13 +44,73 @@ shared_examples_for 'a fire-enhanced double' do
     it "should not allow #{method_name}" do
       lambda {
         doubled_object.send(method_under_test, method_name)
-      }.should fail_matching("#{method_name} does not implement", method_name)
+      }.should fail_matching("does not implement", method_name)
     end
   end
 
   describe '#should_receive' do
     let(:method_under_test) { :should_receive }
     it_should_behave_like 'a fire-enhanced double method'
+
+    describe '#with' do
+      it 'should delegate to RSpec #with method' do
+        doubled_object.
+          should_receive(:defined_method_one_arg).
+          with(1).
+          and_return(:value)
+        doubled_object.defined_method_one_arg(1).should == :value
+
+        doubled_object.
+          should_receive(:defined_method_one_arg).
+          with(2) {|x| x + 1 }
+        doubled_object.defined_method_one_arg(2).should == 3
+      end
+
+      it 'should not allow an arity mismatch for a method with 0 arguments' do
+        lambda {
+          doubled_object.should_receive(:defined_method).with(:x)
+        }.should fail_for_arguments(0, 1)
+      end
+
+      it 'should not allow an arity mismatch for a method with 1 argument' do
+        lambda {
+          doubled_object.should_receive(:defined_method_one_arg).with(:x, :y)
+        }.should fail_for_arguments(1, 2)
+      end
+
+      it 'should use arity of block when no arguments given' do
+        lambda {
+          doubled_object.should_receive(:defined_method_one_arg).with {|x, y| }
+        }.should fail_for_arguments(1, 2)
+      end
+
+      it 'should raise argument error when no arguments or block given' do
+        lambda {
+          doubled_object.should_receive(:defined_method_one_arg).with
+        }.should raise_error(ArgumentError)
+      end
+
+      it 'should recognize no_args param as 0 arity and fail' do
+        lambda {
+          doubled_object.should_receive(:defined_method_one_arg).with(no_args)
+        }.should fail_for_arguments(1, 0)
+      end
+
+      it 'should recognize any_args param' do
+        doubled_object.should_receive(:defined_method).with(any_args)
+      end
+
+      after do
+        doubled_object.rspec_reset
+      end
+
+      def fail_for_arguments(expected, actual)
+        fail_matching(
+          "Wrong number of arguments for defined_method",
+          "Expected #{expected}, got #{actual}"
+        )
+      end
+    end
   end
 
   describe '#should_not_receive' do

data/spec/spec_helper.rb

@@ -5,8 +5,8 @@ RSpec.configure do |config|
 
   def fail_matching(*messages)
     raise_error(RSpec::Expectations::ExpectationNotMetError) {|error|
-      messages.all? {|message|
-        error.message =~ /#{Regexp.escape(message)}/
+      messages.each {|message|
+        error.message.should =~ /#{Regexp.escape(message.to_s)}/
       }
     }
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rspec-fire
 version: !ruby/object:Gem::Version
-  version: '0.1'
+  version: '0.2'
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-03 00:00:00.000000000Z
+date: 2011-09-04 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &2162234400 !ruby/object:Gem::Requirement
+  requirement: &2161554360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2162234400
+  version_requirements: *2161554360
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2162233580 !ruby/object:Gem::Requirement
+  requirement: &2161553360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,7 +32,7 @@ dependencies:
         version: '2.5'
   type: :development
   prerelease: false
-  version_requirements: *2162233580
+  version_requirements: *2161553360
 description: 
 email:
 - hello@xaviershay.com