better_receive 0.2.0 → 0.3.0

data/README.md

@@ -1,24 +1,26 @@
 # BetterReceive
 
-TODO: Write a gem description
+BetterReceive helps test drive new functionality and prevent bugs by asserting that an object responds to a method before mocking it.
 
 ## Installation
 
-Add this line to your application's Gemfile:
+    $ gem install better_receive
 
-    gem 'better_receive'
+## Usage
 
-And then execute:
 
-    $ bundle
+```ruby
+class Foo; end
+foo = Foo.new
 
-Or install it yourself as:
+foo.better_receive(:bar)
+```
+or
+```ruby
+Foo.any_instance.better_receive(:bar)
+```
 
-    $ gem install better_receive
-
-## Usage
-
-TODO: Write usage instructions here
+Either situation will raise an error because instances of Foo do not respond to :bar.
 
 ## Contributing
 
@@ -27,3 +29,10 @@ TODO: Write usage instructions here
 3. Commit your changes (`git commit -am 'Added some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
+
+## To Do
+
+* #better_stub
+* support arrity checks with #responds_to
+* support options other than Ruby 1.9.2+ and RSpec
+

data/better_receive.gemspec

@@ -5,7 +5,7 @@ Gem::Specification.new do |gem|
   gem.authors       = ["Steve Ellis", "Matthew Horan"]
   gem.email         = ["email@steveell.is", "matt@matthoran.com"]
   gem.description   = %q{Assert that an object responds to a method before asserting that the method is received.}
-  gem.summary       = %q{A better should_receive}
+  gem.summary       = %q{A more assertive mock.}
   gem.homepage      = "http://github.com/se3000/better_receive"
 
   gem.files         = `git ls-files`.split($\)
@@ -13,7 +13,7 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = "better_receive"
   gem.require_paths = ["lib"]
-  gem.version       = BetterReceive::VERSION
+  gem.version       = BetterReceive::BETTER_VERSION
 
   gem.add_dependency("rspec", "~> 2.0")
   gem.add_development_dependency("rake", ">= 0")

data/lib/better_receive/mock.rb

@@ -1,65 +1,64 @@
 module BetterReceive
   class Mock
 
-    def initialize(object)
-      @object = object
+    def initialize(subject)
+      @subject = subject
     end
 
-    def responds_to_and_receives(selector, options, &block)
-      better_respond_to(selector)
-
-      mock_method(selector, options, &block)
+    def responds_to_and_receives(selector, options={}, &block)
+      if subject.is_a?(RSpec::Mocks::AnyInstance::Recorder)
+        any_instance_better_receive(selector, options, &block)
+      else
+        subject.should respond_to selector
+        mock_subject_method(selector, options, &block)
+      end
     end
 
-    def rspec_verify
-    end
 
     private
 
-    attr_reader :object
+    attr_reader :subject
 
-    def better_respond_to(selector)
-      case object
-      when RSpec::Mocks::AnyInstance::Recorder
-        any_instance_should_respond_to selector
-      else
-        object.should respond_to(selector)
-      end
+    def respond_to(selector)
+      RSpec::Matchers::BuiltIn::RespondTo.new(selector)
     end
 
-    def any_instance_should_respond_to(selector)
-      klass = object.instance_variable_get(:@klass)
-      unless klass.method_defined?(selector)
-        raise "Expected instances of #{klass.name} to respond to :#{selector}"
-      end
+    def mock_subject_method(selector, options, &block)
+      location = options[:expected_from] || caller(1)[2]
+      subject_mock_proxy.add_message_expectation(location, selector, options, &block)
     end
 
-    def respond_to(selector)
-      RSpec::Matchers::BuiltIn::RespondTo.new(selector)
+    def subject_mock_proxy
+      @mock_proxy ||= subject.send(:__mock_proxy)
     end
 
-    def mock_method(selector, options, &block)
-      case object
-      when RSpec::Mocks::AnyInstance::Recorder
-        any_instance_should_receive selector, &block
-      else
-        location = options[:expected_from] || caller(1)[2]
-        mock_proxy.add_message_expectation(location, selector, options, &block)
+    def any_instance_better_receive(selector, options, &block)
+      any_instance_should_respond_to selector
+      any_instance_should_receive selector, &block
+    end
+
+    def any_instance_should_respond_to(selector)
+      klass = subject.instance_variable_get(:@klass)
+      unless klass.method_defined?(selector)
+        raise "Expected instances of #{klass.name} to respond to :#{selector}"
       end
     end
 
     def any_instance_should_receive(selector, &block)
-      RSpec::Mocks::space.add(object)
+      RSpec::Mocks::space.add(subject)
 
-      object.instance_variable_set(:@expectation_set, true)
-      object.send(:observe!, selector)
+      subject.instance_variable_set(:@expectation_set, true)
+      subject.send(:observe!, selector)
 
-      expectation_chain = RSpec::Mocks::AnyInstance::PositiveExpectationChain.new(selector, &block)
-      object.message_chains.add(selector, expectation_chain)
+      subject.message_chains.add(selector, expectation_chain(selector, &block))
     end
 
-    def mock_proxy
-      @mock_proxy ||= object.send(:__mock_proxy)
+    def expectation_chain(*args)
+      if defined?(RSpec::Mocks::AnyInstance::PositiveExpectationChain)
+        RSpec::Mocks::AnyInstance::PositiveExpectationChain.new(*args)
+      else
+        RSpec::Mocks::AnyInstance::ExpectationChain.new(*args)
+      end
     end
 
   end

data/lib/better_receive/version.rb

@@ -1,3 +1,3 @@
 module BetterReceive
-  VERSION = "0.2.0"
+  BETTER_VERSION = "0.3.0"
 end

data/lib/better_receive.rb

@@ -2,8 +2,8 @@ require "better_receive/version"
 require "better_receive/mock"
 
 module BetterReceive
-  def better_receive(method_name, options={}, &block)
-    Mock.new(self).responds_to_and_receives(method_name, options, &block)
+  def better_receive(*args)
+    Mock.new(self).responds_to_and_receives(*args)
   end
 end
 

data/spec/lib/better_receive/mock_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe BetterReceive do
+  class Foo
+    def bar(baz = nil)
+    end
+  end
+
+  describe "#responds_to_and_receives" do
+    let(:foo) { Foo.new }
+    let(:br_mock) { BetterReceive::Mock.new(foo) }
+
+    it "determines whether an object responds to a method" do
+      foo.should_receive(:respond_to?).with(:bar).and_return(true)
+
+      br_mock.responds_to_and_receives :bar
+
+      foo.bar
+    end
+
+    it "raises an error if it the method is not defined" do
+      expect {
+        br_mock.responds_to_and_receives :bar_baz
+      }.to raise_error(RSpec::Expectations::ExpectationNotMetError) { |error|
+        error.message.should =~ /to respond to :bar_baz/
+      }
+    end
+
+    context "when mocking" do
+      let(:mock_proxy) { double(RSpec::Mocks::Proxy) }
+
+      it "creates a mock proxy and adds an expectation to it" do
+        foo.should_receive(:send).with(:__mock_proxy).and_return(mock_proxy)
+        mock_proxy.should_receive(:add_message_expectation)
+
+        br_mock.responds_to_and_receives :bar
+      end
+
+      it "returns an rspec message expectation(responds to additional matchers ('with', 'once'...))" do
+        foo.better_receive(:bar).should be_a RSpec::Mocks::MessageExpectation
+
+        foo.bar
+
+        br_mock.responds_to_and_receives(:bar).with('wibble')
+
+        foo.bar('wibble')
+      end
+
+      context "and passing arguments" do
+        let(:block_param) { Proc.new {} }
+        let(:options) { {passed: true} }
+
+        it "passes all arguments through to the mock_proxy" do
+          foo.should_receive(:send).with(:__mock_proxy).and_return(mock_proxy)
+          mock_proxy.should_receive(:add_message_expectation) do |*args, &block|
+            args[1].should == :bar
+            args[2].should == options
+            block.should == block_param
+          end
+
+          br_mock.responds_to_and_receives(:bar, passed: true, &block_param)
+        end
+      end
+
+      context "on .any_instance" do
+        let(:br_mock) { BetterReceive::Mock.new(Foo.any_instance) }
+
+        context "when the method is defined" do
+          context "and the method is called" do
+            it 'does not raise an error' do
+              expect {
+                br_mock.responds_to_and_receives(:bar)
+                foo.bar
+              }.to_not raise_error
+            end
+          end
+
+          context 'and the method is not called' do
+            it 'does raise an error' do
+              expect {
+                br_mock.responds_to_and_receives(:bar)
+                RSpec::Mocks::space.verify_all
+              }.to raise_error(RSpec::Mocks::MockExpectationError) { |error|
+                error.message.should == "Exactly one instance should have received the following message(s) but didn't: bar"
+              }
+            end
+          end
+        end
+
+        context 'when the method is not defined' do
+          it 'raises an error' do
+            expect {
+              br_mock.responds_to_and_receives(:baz)
+            }.to raise_error { |error|
+              error.message.should == "Expected instances of Foo to respond to :baz"
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/better_receive_spec.rb

@@ -2,98 +2,25 @@ require 'spec_helper'
 
 describe BetterReceive do
   class Foo
-    def bar(baz = nil)
-    end
+    def bar; end
   end
 
   describe "#better_receive" do
     let(:foo) { Foo.new }
+    let(:br_instance) { double(BetterReceive::Mock).as_null_object }
 
-    it "determines whether an object responds to a method" do
-      foo.should_receive(:respond_to?).with(:bar).and_call_original
+    it "passes the object being mocked into a new BetterReceive::Mock instance" do
+      BetterReceive::Mock.should_receive(:new).with(foo).and_return(br_instance)
 
       foo.better_receive(:bar)
-
-      foo.bar
-    end
-
-    it "raises an error if it the method is not defined" do
-      expect {
-        foo.better_receive(:bar_baz)
-      }.to raise_error(RSpec::Expectations::ExpectationNotMetError) { |error|
-        error.message.should =~ /to respond to :bar_baz/
-      }
     end
 
-    context "when mocking" do
-      let(:mock_proxy) { double(RSpec::Mocks::Proxy) }
-
-      it "creates a mock proxy and adds an expectation to it" do
-        foo.should_receive(:send).with(:__mock_proxy).and_return(mock_proxy)
-        mock_proxy.should_receive(:add_message_expectation)
-
-        foo.better_receive(:bar)
-      end
-
-      it "returns an rspec message expectation(responds to additional matchers ('with', 'once'...))" do
-        foo.better_receive(:bar).should be_a RSpec::Mocks::MessageExpectation
-
-        foo.bar
+    it "checks that the object responds to the method and that the method is called" do
+      BetterReceive::Mock.stub(:new).with(foo).and_return(br_instance)
 
-        foo.better_receive(:bar).with('wibble')
+      br_instance.should_receive(:responds_to_and_receives).with(:bar)
 
-        foo.bar('wibble')
-      end
-
-      context "and passing arguments" do
-        let(:block_param) { Proc.new {} }
-        let(:options) { {passed: true} }
-
-        it "passes all arguments through to the mock_proxy" do
-          foo.should_receive(:send).with(:__mock_proxy).and_return(mock_proxy)
-          mock_proxy.should_receive(:add_message_expectation) do |*args, &block|
-            args[1].should == :bar
-            args[2].should == options
-            block.should == block_param
-          end
-
-          foo.better_receive(:bar, passed: true, &block_param)
-        end
-      end
-
-      context "on .any_instance" do
-        context "when the method is defined" do
-          context "and the method is called" do
-            it 'does not raise an error' do
-              expect {
-                Foo.any_instance.better_receive(:bar)
-                foo.bar
-              }.to_not raise_error
-            end
-          end
-
-          context 'and the method is not called' do
-            it 'does raise an error' do
-              expect {
-                Foo.any_instance.better_receive(:bar)
-                RSpec::Mocks::space.verify_all
-              }.to raise_error(RSpec::Mocks::MockExpectationError) { |error|
-                error.message.should == "Exactly one instance should have received the following message(s) but didn't: bar"
-              }
-            end
-          end
-        end
-
-        context 'when the method is not defined' do
-          it 'raises an error' do
-            expect {
-              Foo.any_instance.better_receive(:baz)
-            }.to raise_error { |error|
-              error.message.should == "Expected instances of Foo to respond to :baz"
-            }
-          end
-        end
-      end
+      foo.better_receive(:bar)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: better_receive
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-15 00:00:00.000000000 Z
+date: 2013-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -79,6 +79,7 @@ files:
 - lib/better_receive.rb
 - lib/better_receive/mock.rb
 - lib/better_receive/version.rb
+- spec/lib/better_receive/mock_spec.rb
 - spec/lib/better_receive_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/se3000/better_receive
@@ -104,7 +105,8 @@ rubyforge_project:
 rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: A better should_receive
+summary: A more assertive mock.
 test_files:
+- spec/lib/better_receive/mock_spec.rb
 - spec/lib/better_receive_spec.rb
 - spec/spec_helper.rb