better_receive 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7dba7386ed326d7d13c41a1b901255f356d9547c
-  data.tar.gz: 8d01d997bf38eadbb9945e3f79284d6689baf4d3
+  metadata.gz: a0347a73bcd68f76e9652ea502dada80b1d6cdeb
+  data.tar.gz: 331cf56b59b2cf34ca9da2ed3a1e84a162a8b11a
 SHA512:
-  metadata.gz: 8d2fc544f91d3a9ae0af34325406dfb7951c97b26bb406ec232e7b79a104bdc106050ca38d0c1ec770921cfe2f1e33e6b071188231d9cb13511250ecf4d27482
-  data.tar.gz: aa613a45884efc818abcefcbf5d44cd05663bd141f0c3eeeac3bb90b1a920f15ac11906190039923f2a82bd9e06e036c2d2d5888c95dc203b2ec605a8ae1db04
+  metadata.gz: a2e01b49c979194ddc5d5a936445219647b9e7f00cfda1288c544c65982b26b68847532adbca1e4aa54eb772a7b264f4620e98e0a850d4f377389a73eb353e50
+  data.tar.gz: ef8e3f26a9d94e4c81880d841e11030b502bab9eceb03d3465eae346811c1e680514391a8d056f4907019341bccd4f87e34c55775b40acc035c1735811dfc591

data/better_receive.gemspec

@@ -16,6 +16,7 @@ Gem::Specification.new do |gem|
   gem.version       = BetterReceive::BETTER_VERSION
 
   gem.add_dependency("rspec", "~> 2.14")
+  gem.add_dependency("rspec-core", "~> 2.14.6")
   gem.add_development_dependency("rake", ">= 0")
   gem.add_development_dependency("pry", ">= 0")
 end

data/lib/better_receive.rb

@@ -4,16 +4,16 @@ require "better_receive/mock"
 require "better_receive/stub"
 
 module BetterReceive
-  def better_receive(*args, &block)
-    Mock.new(self).assert_with(*args, &block)
+  def better_receive(selector, options={}, &block)
+    Mock.new(self, selector, options, &block).assert
   end
 
-  def better_not_receive(*args, &block)
-    Mock.new(self).assert_negative_with(*args, &block)
+  def better_not_receive(selector, options={}, &block)
+    Mock.new(self, selector, options, &block).assert_negative
   end
 
-  def better_stub(*args, &block)
-    Stub.new(self).assert_with(*args, &block)
+  def better_stub(selector, options={}, &block)
+    Stub.new(self, selector, options, &block).assert
   end
 end
 

data/lib/better_receive/base.rb

@@ -1,14 +1,21 @@
 module BetterReceive
   class Base
 
-    def initialize(subject)
+    def initialize(subject, message, options={}, &block)
       @subject = subject
+      @selector = message.is_a?(Hash) ? message : message.to_sym
+      @options = options
+      @block = block
+    end
+
+    def method_missing(*args)
+      expectation.send(*args)
     end
 
 
     private
 
-    attr_reader :subject
+    attr_reader :subject, :selector, :options, :block, :expectation
 
     def subject_is_any_instance?
       defined?(RSpec::Mocks::AnyInstance) && subject.is_a?(RSpec::Mocks::AnyInstance::Recorder)
@@ -20,12 +27,12 @@ module BetterReceive
 
     def any_instance_better_expect(selector, options, &block)
       any_instance_should_respond_to selector
-      any_instance_add_expectation selector, &block
+      any_instance_add_expectation(selector, &block)
     end
 
     def any_instance_better_not_expect(selector, options, &block)
       any_instance_should_respond_to selector
-      any_instance_add_negative_expectation selector, &block
+      any_instance_add_negative_expectation(selector, &block)
     end
 
     def any_instance_should_respond_to(selector)
@@ -38,13 +45,15 @@ module BetterReceive
     def any_instance_add_expectation(selector, &block)
       subject.send(:observe!, selector)
 
-      subject.message_chains.add(selector, expectation_chain(selector, &block))
+      chain = expectation_chain(selector, &block)
+      @expectation = subject.message_chains.add(selector, chain)
     end
 
     def any_instance_add_negative_expectation(selector, &block)
       subject.send(:observe!, selector)
 
-      subject.message_chains.add(selector, expectation_chain(selector, &block)).never
+      chain = expectation_chain(selector, &block)
+      @expectation = subject.message_chains.add(selector, chain).never
     end
 
   end

data/lib/better_receive/mock.rb

@@ -1,8 +1,7 @@
 module BetterReceive
   class Mock < Base
 
-    def assert_with(selector, options={}, &block)
-      selector = selector.to_sym
+    def assert
       if subject_is_any_instance?
         subject.instance_variable_set(:@expectation_set, true)
         any_instance_better_expect(selector, options, &block)
@@ -10,10 +9,10 @@ module BetterReceive
         subject.should respond_to selector
         mock_subject_method(selector, options, &block)
       end
+      self
     end
 
-    def assert_negative_with(selector, options={}, &block)
-      selector = selector.to_sym
+    def assert_negative
       if subject_is_any_instance?
         subject.instance_variable_set(:@expectation_set, true)
         any_instance_better_not_expect(selector, options, &block)
@@ -21,6 +20,7 @@ module BetterReceive
         subject.should respond_to selector
         negative_mock_subject_method(selector, options, &block)
       end
+      self
     end
 
 
@@ -32,16 +32,16 @@ module BetterReceive
 
     def mock_subject_method(selector, options, &block)
       location = options[:expected_from] || caller(1)[2]
-      subject_mock_proxy.add_message_expectation(location, selector, options, &block)
+      @expectation = subject_mock_proxy.add_message_expectation(location, selector, options, &block)
     end
 
     def negative_mock_subject_method(selector, options, &block)
       location = options[:expected_from] || caller(1)[2]
-      subject_mock_proxy.add_message_expectation(location, selector, options, &block).never
+      @expectation = subject_mock_proxy.add_message_expectation(location, selector, options, &block).never
     end
 
     def expectation_chain(*args)
-      RSpec::Mocks::AnyInstance::PositiveExpectationChain.new(*args)
+      RSpec::Mocks::AnyInstance::PositiveExpectationChain.new(subject, *args)
     end
   end
 end

data/lib/better_receive/stub.rb

@@ -1,14 +1,16 @@
 module BetterReceive
   class Stub < Base
 
-    def assert_with(selector_or_hash, options={}, &block)
-      if selector_or_hash.is_a?(Hash)
-        selector_or_hash.each do |selector, value|
-          better_stub_method(selector, options, &block).and_return(value)
+    def assert
+      if selector.is_a?(Hash)
+        selector.each do |single_selector, value|
+          better_stub_method(single_selector.to_sym, options, &block)
+            .and_return(value)
         end
       else
-        better_stub_method(selector_or_hash, options, &block)
+        better_stub_method(selector, options, &block)
       end
+      self
     end
 
 
@@ -20,12 +22,12 @@ module BetterReceive
         any_instance_better_expect(selector, options, &block)
       else
         subject.should respond_to selector
-        subject.stub(selector, options, &block)
+        @expectation = subject.stub(selector, options, &block)
       end
     end
 
     def expectation_chain(*args)
-      RSpec::Mocks::AnyInstance::StubChain.new(*args)
+      RSpec::Mocks::AnyInstance::StubChain.new(subject, *args)
     end
   end
 end

data/lib/better_receive/version.rb

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

data/spec/lib/better_receive/mock_spec.rb

@@ -6,34 +6,39 @@ describe BetterReceive::Mock do
     end
   end
 
-  describe "#assert_with" do
+  describe "#assert" do
     let(:foo) { Foo.new }
-    let(:br_mock) { BetterReceive::Mock.new(foo) }
+    let(:selector) { :bar }
+    let(:br_mock) { BetterReceive::Mock.new(foo, selector) }
 
     it "determines whether an object responds to a method" do
       foo.should_receive(:respond_to?).with(:bar).and_return(true)
 
-      br_mock.assert_with :bar
+      br_mock.assert
 
       foo.bar
     end
 
-    it "raises an error if the method is not defined" do
-      expect {
-        br_mock.assert_with :bar_baz
-      }.to raise_error(RSpec::Expectations::ExpectationNotMetError) { |error|
-        error.message.should =~ /to respond to :bar_baz/
-      }
+    context "when the method is not defined" do
+      let(:selector) { :bar_baz }
+
+      it "raises an error if the method is not defined" do
+        expect {
+          br_mock.assert
+        }.to raise_error(RSpec::Expectations::ExpectationNotMetError) { |error|
+          error.message.should =~ /to respond to :bar_baz/
+        }
+      end
     end
 
     it "returns an rspec message expectation" do
-      foo.better_receive(:bar).should be_a RSpec::Mocks::MessageExpectation
+      foo.better_receive(:bar).should be_a BetterReceive::Mock
 
       foo.bar
     end
 
     it "responds to additional matchers(:with, :once...)" do
-      br_mock.assert_with(:bar).with('wibble')
+      br_mock.assert.with('wibble')
 
       foo.bar('wibble')
     end
@@ -42,9 +47,10 @@ describe BetterReceive::Mock do
       let(:selector) { :bar }
       let(:options) { {passed: true} }
       let(:block_param) { Proc.new {} }
+      let(:br_mock) { BetterReceive::Mock.new(foo, selector, options, &block_param) }
 
       before do
-        br_mock.assert_with(:bar, options, &block_param)
+        br_mock.assert
 
         @expectation = RSpec::Mocks.proxy_for(foo).send(:method_doubles)[0][:expectations][0]
       end
@@ -69,13 +75,14 @@ describe BetterReceive::Mock do
     end
 
     context "on .any_instance" do
-      let(:br_mock) { BetterReceive::Mock.new(Foo.any_instance) }
+      let(:selector) { :bar }
+      let(:br_mock) { BetterReceive::Mock.new(Foo.any_instance, selector) }
 
       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)
+              br_mock.assert
               foo.bar
             }.to_not raise_error
           end
@@ -84,19 +91,27 @@ describe BetterReceive::Mock do
         context 'and the method is not called' do
           it 'does raise an error' do
             expect {
-              br_mock.assert_with(:bar)
+              br_mock.assert
               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
+
+        it 'responds to additional matchers' do
+          br_mock.assert.with(1).and_return(2)
+
+          foo.bar(1).should == 2
+        end
       end
 
       context 'when the method is not defined' do
+        let(:selector) { :baz }
+
         it 'raises an error' do
           expect {
-            br_mock.assert_with(:baz)
+            br_mock.assert
           }.to raise_error { |error|
             error.message.should == "Expected instances of Foo to respond to :baz"
           }
@@ -105,20 +120,24 @@ describe BetterReceive::Mock do
     end
   end
 
-  describe "#assert_negative_with" do
+  describe "#assert_negative" do
     let(:foo) { Foo.new }
-    let(:br_mock) { BetterReceive::Mock.new(foo) }
+    let(:selector) { :bar }
+    let(:br_mock) { BetterReceive::Mock.new(foo, selector) }
 
-    it "raises an error if the method is not defined" do
-      expect {
-        br_mock.assert_negative_with :bar_baz
-      }.to raise_error(RSpec::Expectations::ExpectationNotMetError) { |error|
-        error.message.should =~ /to respond to :bar_baz/
-      }
+    context "when the method is not defined" do
+      let(:selector) { :bar_baz }
+      it "raises an error" do
+        expect {
+          br_mock.assert_negative
+        }.to raise_error(RSpec::Expectations::ExpectationNotMetError) { |error|
+          error.message.should =~ /to respond to :bar_baz/
+        }
+      end
     end
 
     it "returns an rspec message expectation" do
-      br_mock.assert_negative_with(:bar).should be_a RSpec::Mocks::MessageExpectation
+      br_mock.assert_negative.should be_a BetterReceive::Mock
 
       expect {
         foo.bar
@@ -128,7 +147,7 @@ describe BetterReceive::Mock do
     end
 
     it "responds to additional matchers(:with, :once...)" do
-      br_mock.assert_negative_with(:bar).with('wibble')
+      br_mock.assert_negative.with('wibble')
       expect {
         foo.bar('wibble')
       }.to raise_error(RSpec::Mocks::MockExpectationError) { |error|
@@ -140,9 +159,10 @@ describe BetterReceive::Mock do
       let(:selector) { :bar }
       let(:options) { {passed: true} }
       let(:block_param) { Proc.new {} }
+      let(:br_mock) { BetterReceive::Mock.new(foo, selector, options, &block_param) }
 
       before do
-        br_mock.assert_negative_with(:bar, options, &block_param)
+        br_mock.assert_negative
 
         @expectation = RSpec::Mocks.proxy_for(foo).send(:method_doubles)[0][:expectations][0]
       end
@@ -163,11 +183,12 @@ describe BetterReceive::Mock do
     end
 
     context "on .any_instance" do
-      let(:br_mock) { BetterReceive::Mock.new(Foo.any_instance) }
+      let(:selector) { :bar }
+      let(:br_mock) { BetterReceive::Mock.new(Foo.any_instance, selector) }
 
       it 'raises when called' do
         expect {
-          br_mock.assert_negative_with(:bar)
+          br_mock.assert_negative
           foo.bar
         }.to raise_error(RSpec::Mocks::MockExpectationError) { |error|
           error.message.should include "received: 1 time"
@@ -176,15 +197,16 @@ describe BetterReceive::Mock do
 
       it 'does not raise an error if not called' do
         expect {
-          br_mock.assert_negative_with(:bar)
+          br_mock.assert_negative
           RSpec::Mocks::space.verify_all
         }.to_not raise_error
       end
 
       context 'when the method is not defined' do
+        let(:selector) { :baz }
         it 'raises an error' do
           expect {
-            br_mock.assert_negative_with(:baz)
+            br_mock.assert_negative
           }.to raise_error { |error|
             error.message.should == "Expected instances of Foo to respond to :baz"
           }

data/spec/lib/better_receive/stub_spec.rb

@@ -6,46 +6,45 @@ describe BetterReceive::Stub do
     end
   end
 
-  describe "#assert_with" do
+  describe "#assert" do
     let(:foo) { Foo.new }
-    let(:br_stub) { BetterReceive::Stub.new(foo) }
+    let(:selector) { :bar }
+    let(:br_stub) { BetterReceive::Stub.new(foo, selector) }
 
     context "when passed a single selector" do
       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
+        br_stub.assert
 
         foo.bar
       end
 
-      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/
-        }
+      context "when the method is not defined" do
+        let(:selector) { :bar_baz }
+        it "raises an error" do
+          expect {
+            br_stub.assert
+          }.to raise_error(RSpec::Expectations::ExpectationNotMetError) { |error|
+            error.message.should =~ /to respond to :bar_baz/
+          }
+        end
       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
-
-        br_stub.assert_with(:bar).with('wibble')
-      end
+        br_stub.assert.should be_a BetterReceive::Stub
 
-      it "returns the value passed in the block" do
-        br_stub.assert_with(:bar) { :baz }
-
-        foo.bar.should == :baz
+        br_stub.assert.with('wibble')
       end
 
       context "when passing arguments" do
         let(:selector) { :bar }
         let(:options) { {passed: true} }
-        let(:block_param) { Proc.new {} }
+        let(:block_param) { Proc.new { "returned value" } }
+        let(:br_stub) { BetterReceive::Stub.new(foo, selector, options, &block_param) }
 
         before do
-          br_stub.assert_with(:bar, options, &block_param)
+          br_stub.assert
 
           @stub = RSpec::Mocks.proxy_for(foo).send(:method_doubles)[0][:stubs][0]
         end
@@ -56,6 +55,12 @@ describe BetterReceive::Stub do
           @stub.send(:error_generator).opts.should == options
         end
 
+        it "returns the value passed in the block" do
+          br_stub.assert
+
+          foo.bar.should == block_param.call
+        end
+
         context "when the selector is a string" do
           let(:selector) { "bar" }
 
@@ -71,31 +76,29 @@ describe BetterReceive::Stub do
         def extra; end
       end
 
-      context "and checking responds to" do
-        it "determines whether an object responds to a method" do
-          params = {bar: '1', extra: '2'}
+      it "determines whether an object responds to a method" do
+        br_stub = BetterReceive::Stub.new(foo, {bar: '1', extra: '2'})
 
-          foo.should_receive(:respond_to?).with(:bar).and_return(true)
-          foo.should_receive(:respond_to?).with(:extra).and_return(true)
+        foo.should_receive(:respond_to?).with(:bar).and_return(true)
+        foo.should_receive(:respond_to?).with(:extra).and_return(true)
 
-          br_stub.assert_with params
-        end
+        br_stub.assert
+      end
 
-        it "raises an error if the method is not defined" do
-          params = {bar: '1', baz: '2'}
+      it "raises an error if the method is not defined" do
+        br_stub = BetterReceive::Stub.new(foo, {bar: '1', baz: '2'})
 
-          expect{
-            br_stub.assert_with params
-          }.to raise_error(RSpec::Expectations::ExpectationNotMetError) { |error|
-            error.message.should =~ /to respond to :baz/
-          }
-        end
+        expect{
+          br_stub.assert
+        }.to raise_error(RSpec::Expectations::ExpectationNotMetError) { |error|
+          error.message.should =~ /to respond to :baz/
+        }
       end
 
       context "and stubbing" do
         it 'stubs out each method' do
-          params = {bar: '1', extra: '2'}
-          br_stub.assert_with params
+          br_stub = BetterReceive::Stub.new(foo, {bar: '1', extra: '2'})
+          br_stub.assert
 
           foo.bar.should == '1'
           foo.extra.should == '2'
@@ -104,24 +107,27 @@ describe BetterReceive::Stub do
     end
 
     context "on .any_instance" do
-      let(:br_stub) { BetterReceive::Stub.new(Foo.any_instance) }
+      let(:selector) { :bar }
+      let(:br_stub) { BetterReceive::Stub.new(Foo.any_instance, selector) }
 
       context "when the method is defined" do
         it 'stubs the method out' do
-          br_stub.assert_with(:bar).and_return(:whatever)
+          br_stub.assert.and_return(:whatever)
 
           foo.bar.should == :whatever
         end
 
         it "does not blow up if the method is not called" do
-          br_stub.assert_with(:bar)
+          br_stub.assert
         end
       end
 
       context 'when the method is not defined' do
+        let(:selector) { :baz }
+
         it 'raises an error' do
           expect {
-            br_stub.assert_with(:baz)
+            br_stub.assert
           }.to raise_error { |error|
             error.message.should == "Expected instances of Foo to respond to :baz"
           }

data/spec/lib/better_receive_spec.rb

@@ -10,21 +10,21 @@ describe BetterReceive do
     let(:br_instance) { double(BetterReceive::Mock).as_null_object }
 
     it "passes the object being mocked into a new BetterReceive::Mock instance" do
-      BetterReceive::Mock.should_receive(:new).with(foo).and_return(br_instance)
+      BetterReceive::Mock.should_receive(:new).with(foo, :bar, {}).and_return(br_instance)
 
       foo.better_receive(:bar)
     end
 
     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)
+      BetterReceive::Mock.stub(:new).with(foo, :bar, {}).and_return(br_instance)
 
-      br_instance.should_receive(:assert_with).with(:bar)
+      br_instance.should_receive(:assert)
 
       foo.better_receive(:bar)
     end
 
     it "returns an RSpec expectation object" do
-      foo.better_receive(:bar).should be_a RSpec::Mocks::MessageExpectation
+      foo.better_receive(:bar).should be_a BetterReceive::Mock
 
       foo.bar
 
@@ -46,21 +46,21 @@ describe BetterReceive do
     let(:br_instance) { double(BetterReceive::Stub).as_null_object }
 
     it "passes the object being stubbed into a new BetterReceive::Stub instance" do
-      BetterReceive::Stub.should_receive(:new).with(foo).and_return(br_instance)
+      BetterReceive::Stub.should_receive(:new).with(foo, :bar, {}).and_return(br_instance)
 
       foo.better_stub(:bar)
     end
 
     it "checks that the object responds to the method and that the method is called" do
-      BetterReceive::Stub.stub(:new).with(foo).and_return(br_instance)
+      BetterReceive::Stub.stub(:new).with(foo, :bar, {}).and_return(br_instance)
 
-      br_instance.should_receive(:assert_with).with(:bar)
+      br_instance.should_receive(:assert)
 
       foo.better_stub(:bar)
     end
 
     it "returns an RSpec expectation object" do
-      foo.better_stub(:bar).should be_a RSpec::Mocks::MessageExpectation
+      foo.better_stub(:bar).should be_a BetterReceive::Stub
 
       foo.bar
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: better_receive
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Steve Ellis
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-31 00:00:00.000000000 Z
+date: 2013-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -25,6 +25,20 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: rspec-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.6
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -97,7 +111,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.0
+rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: A more assertive mock.