rspec-mocks 3.0.0.beta2 → 3.0.0.rc1

data/spec/rspec/mocks/matchers/have_received_spec.rb

@@ -1,347 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe Matchers::HaveReceived do
-      describe "expect(...).to have_received" do
-        it 'passes when the double has received the given message' do
-          dbl = double_with_met_expectation(:expected_method)
-          expect(dbl).to have_received(:expected_method)
-        end
-
-        it 'passes when a null object has received the given message' do
-          dbl = null_object_with_met_expectation(:expected_method)
-          expect(dbl).to have_received(:expected_method)
-        end
-
-        it 'fails when the double has not received the given message' do
-          dbl = double_with_unmet_expectation(:expected_method)
-
-          expect {
-            expect(dbl).to have_received(:expected_method)
-          }.to raise_error(/expected: 1 time/)
-        end
-
-        it 'fails when a null object has not received the given message' do
-          dbl = double.as_null_object
-
-          expect {
-            expect(dbl).to have_received(:expected_method)
-          }.to raise_error(/expected: 1 time/)
-        end
-
-        it 'fails when the method has not been previously stubbed' do
-          dbl = double
-
-          expect {
-            expect(dbl).to have_received(:expected_method)
-          }.to raise_error(/method has not been stubbed/)
-        end
-
-        it 'fails when the method has been mocked' do
-          dbl = double
-          dbl.should_receive(:expected_method)
-          dbl.expected_method
-
-          expect {
-            expect(dbl).to have_received(:expected_method)
-          }.to raise_error(/method has been mocked instead of stubbed/)
-        end
-
-        it "takes a curly-bracket block and yields the arguments given to the stubbed method call" do
-          dbl = double(:foo => nil)
-          yielded = []
-          dbl.foo(:a, :b, :c)
-          expect(dbl).to have_received(:foo) { |*args|
-            yielded << args
-          }
-          expect(yielded).to include([:a,:b,:c])
-        end
-
-        it "takes a do-end block and yields the arguments given to the stubbed method call" do
-          dbl = double(:foo => nil)
-          yielded = []
-          dbl.foo(:a, :b, :c)
-          expect(dbl).to have_received(:foo) do |*args|
-            yielded << args
-          end
-          expect(yielded).to include([:a,:b,:c])
-        end
-
-        it "passes if expectations against the yielded arguments pass" do
-          dbl = double(:foo => nil)
-          dbl.foo(42)
-          expect {
-            expect(dbl).to have_received(:foo) { |arg|
-              expect(arg).to eq(42)
-            }
-          }.to_not raise_error
-        end
-
-        it "fails if expectations against the yielded arguments fail" do
-          dbl = double(:foo => nil)
-          dbl.foo(43)
-          expect {
-            expect(dbl).to have_received(:foo) { |arg|
-              expect(arg).to eq(42)
-            }
-          }.to raise_error(RSpec::Expectations::ExpectationNotMetError)
-        end
-
-        it 'gives precedence to a `{ ... }` block when both forms are provided ' +
-           'since that form actually binds to `receive`' do
-          dbl = double(:foo => nil)
-          called = []
-          dbl.foo
-          expect(dbl).to have_received(:foo) { called << :curly } do
-            called << :do_end
-          end
-          expect(called).to include(:curly)
-          expect(called).not_to include(:do_end)
-        end
-
-        it 'resets expectations on class methods when mocks are reset' do
-          dbl = Object
-          dbl.stub(:expected_method)
-          dbl.expected_method
-          reset dbl
-          dbl.stub(:expected_method)
-
-          expect {
-            expect(dbl).to have_received(:expected_method)
-          }.to raise_error(/0 times/)
-        end
-
-        context "with" do
-          it 'passes when the given args match the args used with the message' do
-            dbl = double_with_met_expectation(:expected_method, :expected, :args)
-            expect(dbl).to have_received(:expected_method).with(:expected, :args)
-          end
-
-          it 'fails when the given args do not match the args used with the message' do
-            dbl = double_with_met_expectation(:expected_method, :expected, :args)
-
-            expect {
-              expect(dbl).to have_received(:expected_method).with(:unexpected, :args)
-            }.to raise_error(/with unexpected arguments/)
-          end
-        end
-
-        it 'generates a useful description' do
-          matcher = have_received(:expected_method).with(:expected_args).once
-          expect(matcher.description).to eq 'have received expected_method(:expected_args) 1 time'
-        end
-
-        it 'can generate a description after mocks have been torn down (e.g. when rspec-core requests it)' do
-          matcher = have_received(:expected_method).with(:expected_args).once
-          matcher.matches?(double(:expected_method => 1))
-          RSpec::Mocks.teardown
-          expect(matcher.description).to eq 'have received expected_method(:expected_args) 1 time'
-        end
-
-        context "counts" do
-          let(:dbl) { double(:expected_method => nil) }
-
-          before do
-            dbl.expected_method
-            dbl.expected_method
-            dbl.expected_method
-          end
-
-          context "exactly" do
-            it 'passes when the message was received the given number of times' do
-              expect(dbl).to have_received(:expected_method).exactly(3).times
-            end
-
-            it 'fails when the message was received more times' do
-              expect {
-                expect(dbl).to have_received(:expected_method).exactly(2).times
-              }.to raise_error(/expected: 2 times.*received: 3 times/m)
-            end
-
-            it 'fails when the message was received fewer times' do
-              expect {
-                expect(dbl).to have_received(:expected_method).exactly(4).times
-              }.to raise_error(/expected: 4 times.*received: 3 times/m)
-            end
-          end
-
-          context 'at_least' do
-            it 'passes when the message was received the given number of times' do
-              expect(dbl).to have_received(:expected_method).at_least(3).times
-            end
-
-            it 'passes when the message was received more times' do
-              expect(dbl).to have_received(:expected_method).at_least(2).times
-            end
-
-            it 'fails when the message was received fewer times' do
-              expect {
-                expect(dbl).to have_received(:expected_method).at_least(4).times
-              }.to raise_error(/expected: at least 4 times.*received: 3 times/m)
-            end
-          end
-
-          context 'at_most' do
-            it 'passes when the message was received the given number of times' do
-              expect(dbl).to have_received(:expected_method).at_most(3).times
-            end
-
-            it 'passes when the message was received fewer times' do
-              expect(dbl).to have_received(:expected_method).at_most(4).times
-            end
-
-            it 'fails when the message was received more times' do
-              expect {
-                expect(dbl).to have_received(:expected_method).at_most(2).times
-              }.to raise_error(/expected: at most 2 times.*received: 3 times/m)
-            end
-          end
-
-          context 'once' do
-            it 'passes when the message was received once' do
-              dbl = double(:expected_method => nil)
-              dbl.expected_method
-              expect(dbl).to have_received(:expected_method).once
-            end
-
-            it 'fails when the message was never received' do
-              dbl = double(:expected_method => nil)
-
-              expect {
-                expect(dbl).to have_received(:expected_method).once
-              }.to raise_error(/expected: 1 time.*received: 0 times/m)
-            end
-
-            it 'fails when the message was received twice' do
-              dbl = double(:expected_method => nil)
-              dbl.expected_method
-              dbl.expected_method
-
-              expect {
-                expect(dbl).to have_received(:expected_method).once
-              }.to raise_error(/expected: 1 time.*received: 2 times/m)
-            end
-          end
-
-          context 'twice' do
-            it 'passes when the message was received twice' do
-              dbl = double(:expected_method => nil)
-              dbl.expected_method
-              dbl.expected_method
-
-              expect(dbl).to have_received(:expected_method).twice
-            end
-
-            it 'fails when the message was received once' do
-              dbl = double(:expected_method => nil)
-              dbl.expected_method
-
-              expect {
-                expect(dbl).to have_received(:expected_method).twice
-              }.to raise_error(/expected: 2 times.*received: 1 time/m)
-            end
-
-            it 'fails when the message was received thrice' do
-              dbl = double(:expected_method => nil)
-              dbl.expected_method
-              dbl.expected_method
-              dbl.expected_method
-
-              expect {
-                expect(dbl).to have_received(:expected_method).twice
-              }.to raise_error(/expected: 2 times.*received: 3 times/m)
-            end
-          end
-        end
-
-        context 'ordered' do
-          let(:dbl) { double :one => 1, :two => 2 }
-
-          it 'passes when the messages were received in order' do
-            dbl.one
-            dbl.two
-
-            expect(dbl).to have_received(:one).ordered
-            expect(dbl).to have_received(:two).ordered
-          end
-
-          it 'fails when the messages are received out of order' do
-            dbl.two
-            dbl.one
-
-            expect {
-              expect(dbl).to have_received(:one).ordered
-              expect(dbl).to have_received(:two).ordered
-            }.to raise_error(/received :two out of order/m)
-          end
-        end
-      end
-
-      describe "expect(...).not_to have_received" do
-        it 'passes when the double has not received the given message' do
-          dbl = double_with_unmet_expectation(:expected_method)
-          expect(dbl).not_to have_received(:expected_method)
-        end
-
-        it 'fails when the double has received the given message' do
-          dbl = double_with_met_expectation(:expected_method)
-
-          expect {
-            expect(dbl).not_to have_received(:expected_method)
-          }.to raise_error(/expected: 0 times.*received: 1 time/m)
-        end
-
-        it 'fails when the method has not been previously stubbed' do
-          dbl = double
-
-          expect {
-            expect(dbl).not_to have_received(:expected_method)
-          }.to raise_error(/method has not been stubbed/)
-        end
-
-        context "with" do
-          it 'passes when the given args do not match the args used with the message' do
-            dbl = double_with_met_expectation(:expected_method, :expected, :args)
-            expect(dbl).not_to have_received(:expected_method).with(:unexpected, :args)
-          end
-
-          it 'fails when the given args match the args used with the message' do
-            dbl = double_with_met_expectation(:expected_method, :expected, :args)
-
-            expect {
-              expect(dbl).not_to have_received(:expected_method).with(:expected, :args)
-            }.to raise_error(/expected: 0 times.*received: 1 time/m) # TODO: better message
-          end
-        end
-
-        %w(exactly at_least at_most times once twice).each do |constraint|
-          it "does not allow #{constraint} to be used because it creates confusion" do
-            dbl = double_with_unmet_expectation(:expected_method)
-            expect {
-              expect(dbl).not_to have_received(:expected_method).send(constraint)
-            }.to raise_error(/can't use #{constraint} when negative/)
-          end
-        end
-      end
-
-      def double_with_met_expectation(method_name, *args)
-        double = double_with_unmet_expectation(method_name)
-        meet_expectation(double, method_name, *args)
-      end
-
-      def null_object_with_met_expectation(method_name, *args)
-        meet_expectation(double.as_null_object, method_name, *args)
-      end
-
-      def meet_expectation(double, method_name, *args)
-        double.send(method_name, *args)
-        double
-      end
-
-      def double_with_unmet_expectation(method_name)
-        double('double', method_name => true)
-      end
-    end
-  end
-end

data/spec/rspec/mocks/matchers/receive_message_chain_spec.rb

@@ -1,198 +0,0 @@
-require "spec_helper"
-
-
-module RSpec::Mocks::Matchers
-  describe "receive_message_chain" do
-    let(:object) { double(:object) }
-
-    context "with only the expect syntax enabled" do
-      include_context "with syntax", :expect
-
-      it "errors with a negative allowance" do
-        expect {
-          allow(object).not_to receive_message_chain(:to_a)
-        }.to raise_error(RSpec::Mocks::NegationUnsupportedError)
-      end
-
-      it "errors with a negative expectation" do
-        expect {
-          expect(object).not_to receive_message_chain(:to_a)
-        }.to raise_error(RSpec::Mocks::NegationUnsupportedError)
-      end
-
-      it "errors with a negative any_instance expectation" do
-        expect {
-          expect_any_instance_of(Object).not_to receive_message_chain(:to_a)
-        }.to raise_error(RSpec::Mocks::NegationUnsupportedError)
-      end
-
-      it "errors with a negative any_instance allowance" do
-        expect {
-          allow_any_instance_of(Object).not_to receive_message_chain(:to_a)
-        }.to raise_error(RSpec::Mocks::NegationUnsupportedError)
-      end
-
-      it "works with a do block" do
-        allow(object).to receive_message_chain(:to_a, :length) do
-          3
-        end
-
-        expect(object.to_a.length).to eq(3)
-      end
-
-      it "works with a {} block" do
-        allow(object).to receive_message_chain(:to_a, :length) { 3 }
-
-        expect(object.to_a.length).to eq(3)
-      end
-
-      it "gives the { } block prescedence over the do block" do
-        allow(object).to receive_message_chain(:to_a, :length) { 3 } do
-          4
-        end
-
-        expect(object.to_a.length).to eq(3)
-      end
-
-      it "works with and_return" do
-        allow(object).to receive_message_chain(:to_a, :length).and_return(3)
-
-        expect(object.to_a.length).to eq(3)
-      end
-
-      it "works with and_call_original", :pending => "See https://github.com/rspec/rspec-mocks/pull/467#issuecomment-28631621" do
-        list = [1, 2, 3]
-        expect(list).to receive_message_chain(:to_a, :length).and_call_original
-        expect(list.to_a.length).to eq(3)
-      end
-
-      it "fails with and_call_original when the entire chain is not called", :pending => "See https://github.com/rspec/rspec-mocks/pull/467#issuecomment-28631621" do
-        list = [1, 2, 3]
-        expect(list).to receive_message_chain(:to_a, :length).and_call_original
-        expect(list.to_a).to eq([1, 2, 3])
-      end
-
-      it "works with and_raise" do
-        allow(object).to receive_message_chain(:to_a, :length).and_raise(StandardError.new("hi"))
-
-        expect { object.to_a.length }.to raise_error(StandardError, "hi")
-      end
-
-      it "works with and_throw" do
-        allow(object).to receive_message_chain(:to_a, :length).and_throw(:nope)
-
-        expect { object.to_a.length }.to throw_symbol(:nope)
-      end
-
-      it "works with and_yield" do
-        allow(object).to receive_message_chain(:to_a, :length).and_yield(3)
-
-        expect { |blk| object.to_a.length(&blk) }.to yield_with_args(3)
-      end
-
-      it "works with a string of messages to chain" do
-        allow(object).to receive_message_chain("to_a.length").and_yield(3)
-
-        expect { |blk| object.to_a.length(&blk) }.to yield_with_args(3)
-      end
-
-      it "works with a hash return as the last argument in the chain" do
-        allow(object).to receive_message_chain(:to_a, :length => 3)
-
-        expect(object.to_a.length).to eq(3)
-      end
-
-      it "accepts any number of arguments to the stubbed messages" do
-        allow(object).to receive_message_chain(:msg1, :msg2).and_return(:return_value)
-
-        expect(object.msg1("nonsense", :value).msg2("another", :nonsense, 3.0, "value")).to eq(:return_value)
-      end
-
-      it "accepts any number of arguments to the stubbed messages with an inline hash return value" do
-        allow(object).to receive_message_chain(:msg1, :msg2 => :return_value)
-
-        expect(object.msg1("nonsense", :value).msg2("another", :nonsense, 3.0, "value")).to eq(:return_value)
-      end
-
-      it "raises when expect is used and the entire chain isn't called" do
-        expect {
-          expect(object).to receive_message_chain(:to_a, :farce, :length => 3)
-          object.to_a
-          verify_all
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "does not raise when expect is used and the entire chain is called" do
-        expect {
-          expect(object).to receive_message_chain(:to_a, :length => 3)
-          object.to_a.length
-          verify_all
-        }.not_to raise_error
-      end
-
-      it "works with allow_any_instance" do
-        o = Object.new
-
-        allow_any_instance_of(Object).to receive_message_chain(:to_a, :length => 3)
-
-        expect(o.to_a.length).to eq(3)
-      end
-
-      it "fails when with expect_any_instance_of is used and the entire chain is not called" do
-        expect {
-          expect_any_instance_of(Object).to receive_message_chain(:to_a, :length => 3)
-          verify_all
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "passes when with expect_any_instance_of is used and the entire chain is called" do
-        o = Object.new
-
-        expect_any_instance_of(Object).to receive_message_chain(:to_a, :length => 3)
-        o.to_a.length
-      end
-
-      it "works with expect where the first level of the chain is already expected" do
-        o = Object.new
-        expect(o).to receive(:foo).and_return(double)
-        expect(o).to receive_message_chain(:foo, :bar, :baz)
-
-        o.foo.bar.baz
-      end
-
-      it "works with allow where the first level of the chain is already expected" do
-        o = Object.new
-        expect(o).to receive(:foo).and_return(double)
-        allow(o).to receive_message_chain(:foo, :bar, :baz).and_return(3)
-
-        expect(o.foo.bar.baz).to eq(3)
-      end
-
-      it "works with expect where the first level of the chain is already stubbed" do
-        o = Object.new
-        allow(o).to receive(:foo).and_return(double)
-        expect(o).to receive_message_chain(:foo, :bar, :baz)
-
-        o.foo.bar.baz
-      end
-
-      it "works with allow where the first level of the chain is already stubbed" do
-        o = Object.new
-        allow(o).to receive(:foo).and_return(double)
-        allow(o).to receive_message_chain(:foo, :bar, :baz).and_return(3)
-
-        expect(o.foo.bar.baz).to eq(3)
-      end
-    end
-
-    context "when the expect and should syntaxes are enabled" do
-      include_context "with syntax", [:expect, :should]
-
-      it "stubs the message correctly" do
-        allow(object).to receive_message_chain(:to_a, :length)
-
-        expect { object.to_a.length }.not_to raise_error
-      end
-    end
-  end
-end