better_receive 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2374b6397328e21d63f479e68e74a2dfdc843960
-  data.tar.gz: c4e755a254de947b2fe8bed0bcca4e390177a513
+  metadata.gz: 7dba7386ed326d7d13c41a1b901255f356d9547c
+  data.tar.gz: 8d01d997bf38eadbb9945e3f79284d6689baf4d3
 SHA512:
-  metadata.gz: 9c755925be275f776cb9e7bfc86372785b96fb96a348583b2d03252d4e4b4771f13ab7189652a6e498f7de6cbdc7937d87406c129a71b324fc4b8a00289412b8
-  data.tar.gz: 2692f614cf4c2803c7f24e91fa9fc92ec545c5e54432aadc9a943934155ac54900bcb0c16ee9cb25c0c82121811ff00d853bd4d786c281288fd1e84abc211085
+  metadata.gz: 8d2fc544f91d3a9ae0af34325406dfb7951c97b26bb406ec232e7b79a104bdc106050ca38d0c1ec770921cfe2f1e33e6b071188231d9cb13511250ecf4d27482
+  data.tar.gz: aa613a45884efc818abcefcbf5d44cd05663bd141f0c3eeeac3bb90b1a920f15ac11906190039923f2a82bd9e06e036c2d2d5888c95dc203b2ec605a8ae1db04

data/README.md

@@ -9,7 +9,6 @@ Test drive new functionality and prevent bugs by asserting objects respond to me
 
 ## Usage
 
-
 ```ruby
 
 class Foo; end
@@ -30,6 +29,8 @@ Any of these situation will raise an error because instances of Foo do not respo
 After the initial extra assertion, they continue to act like regular RSpec mocks/stubs.
 
 
+If you are using a version of RSpec < 2.14, lock to BetterReceive version 0.5 or earlier.
+
 ## Contributing
 
 1. Fork it

data/better_receive.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = BetterReceive::BETTER_VERSION
 
-  gem.add_dependency("rspec", "~> 2.0")
+  gem.add_dependency("rspec", "~> 2.14")
   gem.add_development_dependency("rake", ">= 0")
   gem.add_development_dependency("pry", ">= 0")
 end

data/lib/better_receive/base.rb

@@ -18,10 +18,6 @@ module BetterReceive
       RSpec::Matchers::BuiltIn::RespondTo.new(selector)
     end
 
-    def subject_mock_proxy
-      @mock_proxy ||= subject.send(:__mock_proxy)
-    end
-
     def any_instance_better_expect(selector, options, &block)
       any_instance_should_respond_to selector
       any_instance_add_expectation selector, &block
@@ -40,21 +36,15 @@ module BetterReceive
     end
 
     def any_instance_add_expectation(selector, &block)
-      RSpec::Mocks::space.add(subject)
-
-      subject.instance_variable_set(:@expectation_set, true)
       subject.send(:observe!, selector)
 
       subject.message_chains.add(selector, expectation_chain(selector, &block))
     end
 
     def any_instance_add_negative_expectation(selector, &block)
-      RSpec::Mocks::space.add(subject)
-
-      subject.instance_variable_set(:@expectation_set, true)
       subject.send(:observe!, selector)
 
-      subject.message_chains.add(selector, negative_expectation_chain(selector, &block))
+      subject.message_chains.add(selector, expectation_chain(selector, &block)).never
     end
 
   end

data/lib/better_receive/mock.rb

@@ -4,6 +4,7 @@ module BetterReceive
     def assert_with(selector, options={}, &block)
       selector = selector.to_sym
       if subject_is_any_instance?
+        subject.instance_variable_set(:@expectation_set, true)
         any_instance_better_expect(selector, options, &block)
       else
         subject.should respond_to selector
@@ -14,6 +15,7 @@ module BetterReceive
     def assert_negative_with(selector, options={}, &block)
       selector = selector.to_sym
       if subject_is_any_instance?
+        subject.instance_variable_set(:@expectation_set, true)
         any_instance_better_not_expect(selector, options, &block)
       else
         subject.should respond_to selector
@@ -24,6 +26,10 @@ module BetterReceive
 
     private
 
+    def subject_mock_proxy
+      @mock_proxy ||= RSpec::Mocks.proxy_for(subject)
+    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)
@@ -31,24 +37,11 @@ module BetterReceive
 
     def negative_mock_subject_method(selector, options, &block)
       location = options[:expected_from] || caller(1)[2]
-      subject_mock_proxy.add_negative_message_expectation(location, selector, &block)
+      subject_mock_proxy.add_message_expectation(location, selector, options, &block).never
     end
 
     def expectation_chain(*args)
-      if defined?(RSpec::Mocks::AnyInstance::PositiveExpectationChain)
-        RSpec::Mocks::AnyInstance::PositiveExpectationChain.new(*args)
-      else
-        RSpec::Mocks::AnyInstance::ExpectationChain.new(*args)
-      end
+      RSpec::Mocks::AnyInstance::PositiveExpectationChain.new(*args)
     end
-
-    def negative_expectation_chain(*args)
-      if defined?(RSpec::Mocks::AnyInstance::NegativeExpectationChain)
-        RSpec::Mocks::AnyInstance::NegativeExpectationChain.new(*args)
-      else
-        RSpec::Mocks::AnyInstance::NegativeExpectationChain.new(*args)
-      end
-    end
-
   end
 end

data/lib/better_receive/stub.rb

@@ -20,18 +20,12 @@ module BetterReceive
         any_instance_better_expect(selector, options, &block)
       else
         subject.should respond_to selector
-        stub_subject_method(selector, options, &block)
+        subject.stub(selector, options, &block)
       end
     end
 
-    def stub_subject_method(selector, options, &block)
-      location = options[:expected_from] || caller(1)[2]
-      subject_mock_proxy.add_stub(location, selector, options, &block)
-    end
-
     def expectation_chain(*args)
       RSpec::Mocks::AnyInstance::StubChain.new(*args)
     end
-
   end
 end

data/lib/better_receive/version.rb

@@ -1,3 +1,3 @@
 module BetterReceive
-  BETTER_VERSION = "0.5.0"
+  BETTER_VERSION = "0.6.0"
 end

data/spec/lib/better_receive/mock_spec.rb

@@ -26,86 +26,82 @@ describe BetterReceive::Mock do
       }
     end
 
-    context "when mocking" do
-      let(:mock_proxy) { double(RSpec::Mocks::Proxy) }
+    it "returns an rspec message expectation" do
+      foo.better_receive(:bar).should be_a RSpec::Mocks::MessageExpectation
 
-      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.bar
+    end
 
-        br_mock.assert_with :bar
-      end
+    it "responds to additional matchers(:with, :once...)" do
+      br_mock.assert_with(:bar).with('wibble')
 
-      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('wibble')
+    end
 
-        foo.bar
+    context "passing arguments" do
+      let(:selector) { :bar }
+      let(:options) { {passed: true} }
+      let(:block_param) { Proc.new {} }
 
-        br_mock.assert_with(:bar).with('wibble')
+      before do
+        br_mock.assert_with(:bar, options, &block_param)
 
-        foo.bar('wibble')
+        @expectation = RSpec::Mocks.proxy_for(foo).send(:method_doubles)[0][:expectations][0]
       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
+      after do
+        foo.bar
+      end
 
-          br_mock.assert_with(:bar, passed: true, &block_param)
-        end
+      it "passes all arguments through to the mock_proxy" do
+        @expectation.message.should == :bar
+        @expectation.implementation.inner_action.should == block_param
+        @expectation.send(:error_generator).opts.should == options
+      end
 
-        it "converts the selector to a symbol if necessary" 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
-          end
+      context "when the selector is a string" do
+        let(:selector) { "bar" }
 
-          br_mock.assert_with('bar', passed: true, &block_param)
+        it "converts the selector to a symbol" do
+          @expectation.message.should == selector.to_sym
         end
       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.assert_with(:bar)
-                foo.bar
-              }.to_not raise_error
-            end
-          end
+    context "on .any_instance" do
+      let(:br_mock) { BetterReceive::Mock.new(Foo.any_instance) }
 
-          context 'and the method is not called' do
-            it 'does raise an error' do
-              expect {
-                br_mock.assert_with(: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
+      context "when the method is defined" do
+        context "and the method is called" do
+          it 'does not raise an error' do
+            expect {
+              br_mock.assert_with(:bar)
+              foo.bar
+            }.to_not raise_error
           end
         end
 
-        context 'when the method is not defined' do
-          it 'raises an error' do
+        context 'and the method is not called' do
+          it 'does raise an error' do
             expect {
-              br_mock.assert_with(:baz)
-            }.to raise_error { |error|
-              error.message.should == "Expected instances of Foo to respond to :baz"
+              br_mock.assert_with(: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.assert_with(:baz)
+          }.to raise_error { |error|
+            error.message.should == "Expected instances of Foo to respond to :baz"
+          }
+        end
+      end
     end
   end
 
@@ -121,91 +117,77 @@ describe BetterReceive::Mock do
       }
     end
 
-    context "when mocking" do
-      let(:mock_proxy) { double(RSpec::Mocks::Proxy) }
+    it "returns an rspec message expectation" do
+      br_mock.assert_negative_with(:bar).should be_a RSpec::Mocks::MessageExpectation
 
-      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_negative_message_expectation)
+      expect {
+        foo.bar
+      }.to raise_error(RSpec::Mocks::MockExpectationError) { |error|
+        error.message.should include "received: 1 time"
+      }
+    end
 
-        br_mock.assert_negative_with :bar
-      end
+    it "responds to additional matchers(:with, :once...)" do
+      br_mock.assert_negative_with(:bar).with('wibble')
+      expect {
+        foo.bar('wibble')
+      }.to raise_error(RSpec::Mocks::MockExpectationError) { |error|
+        error.message.should include "received: 1 time"
+      }
+    end
 
-      it "returns an rspec message expectation(responds to additional matchers ('with', 'once'...))" do
-        foo.better_not_receive(:bar).should be_a RSpec::Mocks::NegativeMessageExpectation
+    context "passing arguments" do
+      let(:selector) { :bar }
+      let(:options) { {passed: true} }
+      let(:block_param) { Proc.new {} }
 
-        expect {
-          foo.bar
-        }.to raise_error(RSpec::Mocks::MockExpectationError) { |error|
-          error.message.should include "received: 1 time"
-        }
-
-        br_mock.assert_negative_with(:bar).with('wibble')
-        expect {
-          foo.bar('wibble')
-        }.to raise_error(RSpec::Mocks::MockExpectationError) { |error|
-          error.message.should include "received: 1 time"
-        }
+      before do
+        br_mock.assert_negative_with(:bar, options, &block_param)
 
+        @expectation = RSpec::Mocks.proxy_for(foo).send(:method_doubles)[0][:expectations][0]
       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_negative_message_expectation) do |*args, &block|
-            args[1].should == :bar
-            block.should == block_param
-          end
+      it "passes all arguments through to the mock_proxy" do
+        @expectation.message.should == :bar
+        @expectation.implementation.inner_action.should == block_param
+        @expectation.send(:error_generator).opts.should == options
+      end
 
-          br_mock.assert_negative_with(:bar, &block_param)
-        end
+      context "when the selector is a string" do
+        let(:selector) { "bar" }
 
         it "converts the selector to a symbol" do
-          foo.should_receive(:send).with(:__mock_proxy).and_return(mock_proxy)
-          mock_proxy.should_receive(:add_negative_message_expectation) do |*args, &block|
-            args[1].should == :bar
-          end
-
-          br_mock.assert_negative_with("bar", &block_param)
+          @expectation.message.should == selector.to_sym
         end
       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 'raises when called' do
-              expect {
-                br_mock.assert_negative_with(:bar)
-                foo.bar
-              }.to raise_error(RSpec::Mocks::MockExpectationError) { |error|
-                error.message.should include "received: 1 time"
-              }
-            end
-          end
+    context "on .any_instance" do
+      let(:br_mock) { BetterReceive::Mock.new(Foo.any_instance) }
 
-          context 'and the method is not called' do
-            it 'does not raise an error' do
-              expect {
-                br_mock.assert_negative_with(:bar)
-                RSpec::Mocks::space.verify_all
-              }.to_not raise_error
-            end
-          end
-        end
+      it 'raises when called' do
+        expect {
+          br_mock.assert_negative_with(:bar)
+          foo.bar
+        }.to raise_error(RSpec::Mocks::MockExpectationError) { |error|
+          error.message.should include "received: 1 time"
+        }
+      end
 
-        context 'when the method is not defined' do
-          it 'raises an error' do
-            expect {
-              br_mock.assert_negative_with(:baz)
-            }.to raise_error { |error|
-              error.message.should == "Expected instances of Foo to respond to :baz"
-            }
-          end
+      it 'does not raise an error if not called' do
+        expect {
+          br_mock.assert_negative_with(:bar)
+          RSpec::Mocks::space.verify_all
+        }.to_not raise_error
+      end
+
+      context 'when the method is not defined' do
+        it 'raises an error' do
+          expect {
+            br_mock.assert_negative_with(:baz)
+          }.to raise_error { |error|
+            error.message.should == "Expected instances of Foo to respond to :baz"
+          }
         end
       end
     end

data/spec/lib/better_receive/stub_spec.rb

@@ -11,67 +11,57 @@ describe BetterReceive::Stub do
     let(:br_stub) { BetterReceive::Stub.new(foo) }
 
     context "when passed a single selector" do
-      context "when checking responds to" do
-        it "determines whether an object responds to a method" do
-          foo.should_receive(:respond_to?).with(:bar).and_return(true)
+      it "determines whether an object responds to a method" do
+        foo.should_receive(:respond_to?).with(:bar).and_return(true)
 
-          br_stub.assert_with :bar
-
-          foo.bar
-        end
+        br_stub.assert_with :bar
 
-        it "raises an error if the method is not defined" do
-          expect {
-            br_stub.assert_with :bar_baz
-          }.to raise_error(RSpec::Expectations::ExpectationNotMetError) { |error|
-            error.message.should =~ /to respond to :bar_baz/
-          }
-        end
+        foo.bar
       end
 
-      context "when stubbing" do
-        let(:mock_proxy) { double(RSpec::Mocks::Proxy).as_null_object }
-        let(:block_param) { Proc.new {} }
-        let(:options) { {passed: true} }
+      it "raises an error if the method is not defined" do
+        expect {
+          br_stub.assert_with :bar_baz
+        }.to raise_error(RSpec::Expectations::ExpectationNotMetError) { |error|
+          error.message.should =~ /to respond to :bar_baz/
+        }
+      end
 
-        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_stub)
+      it "returns an rspec message expectation(responds to additional matchers ('with', 'once'...))" do
+        br_stub.assert_with(:bar).should be_a RSpec::Mocks::MessageExpectation
 
-          br_stub.assert_with :bar
-        end
+        br_stub.assert_with(:bar).with('wibble')
+      end
 
-        it "returns an rspec message expectation(responds to additional matchers ('with', 'once'...))" do
-          br_stub.assert_with(:bar).should be_a RSpec::Mocks::MessageExpectation
+      it "returns the value passed in the block" do
+        br_stub.assert_with(:bar) { :baz }
 
+        foo.bar.should == :baz
+      end
 
-          br_stub.assert_with(:bar).with('wibble')
-        end
+      context "when passing arguments" do
+        let(:selector) { :bar }
+        let(:options) { {passed: true} }
+        let(:block_param) { Proc.new {} }
 
-        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_stub) do |*args, &block|
-            args[1].should == :bar
-            args[2].should == options
-            block.should == block_param
-          end
+        before do
+          br_stub.assert_with(:bar, options, &block_param)
 
-          br_stub.assert_with(:bar, passed: true, &block_param)
+          @stub = RSpec::Mocks.proxy_for(foo).send(:method_doubles)[0][:stubs][0]
         end
 
-        it "converts the selector to a string" do
-          foo.should_receive(:send).with(:__mock_proxy).and_return(mock_proxy)
-          mock_proxy.should_receive(:add_stub) do |*args, &block|
-            args[1].should == :bar
-          end
-
-          br_stub.assert_with("bar", passed: true, &block_param)
+        it "creates a mock proxy and adds an expectation to it" do
+          @stub.message.should == :bar
+          @stub.implementation.inner_action.should == block_param
+          @stub.send(:error_generator).opts.should == options
         end
 
-        it "returns the value passed in the block" do
-          br_stub.assert_with(:bar) { :baz }
+        context "when the selector is a string" do
+          let(:selector) { "bar" }
 
-          foo.bar.should == :baz
+          it "converts the selector to a symbol" do
+            @stub.message.should == selector.to_sym
+          end
         end
       end
     end
@@ -122,6 +112,10 @@ describe BetterReceive::Stub do
 
           foo.bar.should == :whatever
         end
+
+        it "does not blow up if the method is not called" do
+          br_stub.assert_with(:bar)
+        end
       end
 
       context 'when the method is not defined' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: better_receive
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Steve Ellis
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-27 00:00:00.000000000 Z
+date: 2013-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -17,14 +17,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.14'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.14'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement