rspec-mocks 3.0.0.beta2 → 3.0.0.rc1

data/spec/rspec/mocks/array_including_matcher_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    module ArgumentMatchers
-      describe ArrayIncludingMatcher do
-        it "describes itself properly" do
-          expect(ArrayIncludingMatcher.new([1, 2, 3]).description).to eq "array_including(1,2,3)"
-        end
-
-        context "passing" do
-          it "matches the same array" do
-            expect(array_including(1, 2, 3)).to be === [1, 2, 3]
-          end
-
-          it "matches the same array,  specified without square brackets" do
-            expect(array_including(1, 2, 3)).to be === [1, 2, 3]
-          end
-
-          it "matches the same array,  which includes nested arrays" do
-            expect(array_including([1, 2], 3, 4)).to be === [[1, 2], 3, 4]
-          end
-
-          it "works with duplicates in expected" do
-            expect(array_including(1, 1, 2, 3)).to be === [1, 2, 3]
-          end
-
-          it "works with duplicates in actual" do
-            expect(array_including(1, 2, 3)).to be === [1, 1, 2, 3]
-          end
-        end
-
-        context "failing" do
-          it "fails when not all the entries in the expected are present" do
-            expect(array_including(1,2,3,4,5)).not_to be === [1,2]
-          end
-        end
-      end
-    end
-  end
-end

data/spec/rspec/mocks/at_least_spec.rb

@@ -1,123 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe "at_least" do
-      before(:each) { @double = double }
-
-      it "fails if method is never called" do
-        @double.should_receive(:do_something).at_least(4).times
-        expect {
-          verify @double
-        }.to raise_error(/expected: at least 4 times.*received: 0 times/m)
-      end
-
-      it "fails when called less than n times" do
-        @double.should_receive(:do_something).at_least(4).times
-        @double.do_something
-        @double.do_something
-        @double.do_something
-        expect {
-          verify @double
-        }.to raise_error(/expected: at least 4 times.*received: 3 times/m)
-      end
-
-      it "fails when at least once method is never called" do
-        @double.should_receive(:do_something).at_least(:once)
-        expect {
-          verify @double
-        }.to raise_error(/expected: at least 1 time.*received: 0 times/m)
-      end
-
-      it "fails when at least twice method is called once" do
-        @double.should_receive(:do_something).at_least(:twice)
-        @double.do_something
-        expect {
-          verify @double
-        }.to raise_error(/expected: at least 2 times.*received: 1 time/m)
-      end
-
-      it "fails when at least twice method is never called" do
-        @double.should_receive(:do_something).at_least(:twice)
-        expect {
-          verify @double
-        }.to raise_error(/expected: at least 2 times.*received: 0 times/m)
-      end
-
-      it "passes when at least n times method is called exactly n times" do
-        @double.should_receive(:do_something).at_least(4).times
-        @double.do_something
-        @double.do_something
-        @double.do_something
-        @double.do_something
-        verify @double
-      end
-
-      it "passes when at least n times method is called n plus 1 times" do
-        @double.should_receive(:do_something).at_least(4).times
-        @double.do_something
-        @double.do_something
-        @double.do_something
-        @double.do_something
-        @double.do_something
-        verify @double
-      end
-
-      it "passes when at least once method is called once" do
-        @double.should_receive(:do_something).at_least(:once)
-        @double.do_something
-        verify @double
-      end
-
-      it "passes when at least once method is called twice" do
-        @double.should_receive(:do_something).at_least(:once)
-        @double.do_something
-        @double.do_something
-        verify @double
-      end
-
-      it "passes when at least twice method is called three times" do
-        @double.should_receive(:do_something).at_least(:twice)
-        @double.do_something
-        @double.do_something
-        @double.do_something
-        verify @double
-      end
-
-      it "passes when at least twice method is called twice" do
-        @double.should_receive(:do_something).at_least(:twice)
-        @double.do_something
-        @double.do_something
-        verify @double
-      end
-
-      it "returns the value given by a block when the at least once method is called" do
-        @double.should_receive(:to_s).at_least(:once) { "testing" }
-        expect(@double.to_s).to eq "testing"
-        verify @double
-      end
-
-      context "when sent with 0" do
-        it "outputs a removal message" do
-          expect {
-            expect(@double).to receive(:do_something).at_least(0).times
-          }.to raise_error(/has been removed/)
-        end
-      end
-
-      it "uses a stub value if no value set" do
-        @double.stub(:do_something => 'foo')
-        @double.should_receive(:do_something).at_least(:once)
-        expect(@double.do_something).to eq 'foo'
-        expect(@double.do_something).to eq 'foo'
-      end
-
-      it "prefers its own return value over a stub" do
-        @double.stub(:do_something => 'foo')
-        @double.should_receive(:do_something).at_least(:once).and_return('bar')
-        expect(@double.do_something).to eq 'bar'
-        expect(@double.do_something).to eq 'bar'
-      end
-    end
-  end
-end

data/spec/rspec/mocks/at_most_spec.rb

@@ -1,90 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe "at_most" do
-      before(:each) do
-        @double = double
-      end
-
-      it "passes when at_most(n) is called exactly n times" do
-        @double.should_receive(:do_something).at_most(2).times
-        @double.do_something
-        @double.do_something
-        verify @double
-      end
-
-      it "passes when at_most(n) is called less than n times" do
-        @double.should_receive(:do_something).at_most(2).times
-        @double.do_something
-        verify @double
-      end
-
-      it "passes when at_most(n) is never called" do
-        @double.should_receive(:do_something).at_most(2).times
-        verify @double
-      end
-
-      it "passes when at_most(:once) is called once" do
-        @double.should_receive(:do_something).at_most(:once)
-        @double.do_something
-        verify @double
-      end
-
-      it "passes when at_most(:once) is never called" do
-        @double.should_receive(:do_something).at_most(:once)
-        verify @double
-      end
-
-      it "passes when at_most(:twice) is called once" do
-        @double.should_receive(:do_something).at_most(:twice)
-        @double.do_something
-        verify @double
-      end
-
-      it "passes when at_most(:twice) is called twice" do
-        @double.should_receive(:do_something).at_most(:twice)
-        @double.do_something
-        @double.do_something
-        verify @double
-      end
-
-      it "passes when at_most(:twice) is never called" do
-        @double.should_receive(:do_something).at_most(:twice)
-        verify @double
-      end
-
-      it "returns the value given by a block when at_most(:once) method is called" do
-        @double.should_receive(:to_s).at_most(:once) { "testing" }
-        expect(@double.to_s).to eq "testing"
-        verify @double
-      end
-
-      it "fails fast when at_most(n) times method is called n plus 1 times" do
-        @double.should_receive(:do_something).at_most(2).times
-        @double.do_something
-        @double.do_something
-        expect {
-          @double.do_something
-        }.to raise_error(/expected: at most 2 times.*received: 3 times/m)
-      end
-
-      it "fails fast when at_most(:once) and is called twice" do
-        @double.should_receive(:do_something).at_most(:once)
-        @double.do_something
-        expect {
-          @double.do_something
-        }.to raise_error(/expected: at most 1 time.*received: 2 times/m)
-      end
-
-      it "fails fast when at_most(:twice) and is called three times" do
-        @double.should_receive(:do_something).at_most(:twice)
-        @double.do_something
-        @double.do_something
-        expect {
-          @double.do_something
-        }.to raise_error(/expected: at most 2 times.*received: 3 times/m)
-      end
-    end
-  end
-end

data/spec/rspec/mocks/before_all_spec.rb

@@ -1,132 +0,0 @@
-require "spec_helper"
-
-describe "Using rspec-mocks features in before(:all) blocks" do
-  shared_examples_for "fails in a before(:all) block" do
-    the_error = nil
-    before(:all) do
-      begin
-        use_rspec_mocks
-      rescue
-        the_error = $!
-      end
-    end
-
-    it "raises an error with a useful message" do
-      expect(the_error).to be_a_kind_of(RSpec::Mocks::OutsideOfExampleError)
-
-      expect(the_error.message).to match(/The use of doubles or partial doubles from rspec-mocks outside of the per-test lifecycle is not supported./)
-    end
-  end
-
-  describe "#stub_const" do
-    include_examples "fails in a before(:all) block" do
-      def use_rspec_mocks
-        stub_const("SomeNewConst", Class.new)
-      end
-
-      it 'does not stub the const' do
-        expect(defined?(SomeNewConst)).to be_falsey
-      end
-    end
-  end
-
-  describe "#hide_const(for an undefined const)" do
-    include_examples "fails in a before(:all) block" do
-      def use_rspec_mocks
-        hide_const("Foo")
-      end
-    end
-  end
-
-  describe "#hide_const(for a defined const)" do
-    include_examples "fails in a before(:all) block" do
-      def use_rspec_mocks
-        hide_const("Float")
-      end
-
-      it 'does not hide the const' do
-        expect(defined?(Float)).to be_truthy
-      end
-    end
-  end
-
-  describe "#stub" do
-    include_examples "fails in a before(:all) block" do
-      def use_rspec_mocks
-        Object.stub(:foo)
-      end
-    end
-  end
-
-  describe "#unstub" do
-    include_examples "fails in a before(:all) block" do
-      def use_rspec_mocks
-        Object.unstub(:foo)
-      end
-    end
-  end
-
-  describe "#should_receive" do
-    include_examples "fails in a before(:all) block" do
-      def use_rspec_mocks
-        Object.should_receive(:foo)
-      end
-    end
-  end
-
-  describe "#should_not_receive" do
-    include_examples "fails in a before(:all) block" do
-      def use_rspec_mocks
-        Object.should_not_receive(:foo)
-      end
-    end
-  end
-
-  describe "#any_instance" do
-    include_examples "fails in a before(:all) block" do
-      def use_rspec_mocks
-        Object.any_instance.should_receive(:foo)
-      end
-    end
-  end
-
-  describe "#stub_chain" do
-    include_examples "fails in a before(:all) block" do
-      def use_rspec_mocks
-        Object.stub_chain(:foo)
-      end
-    end
-  end
-
-  describe "#expect(...).to receive" do
-    include_examples "fails in a before(:all) block" do
-      def use_rspec_mocks
-        expect(Object).to receive(:foo)
-      end
-    end
-  end
-
-  describe "#allow(...).to receive" do
-    include_examples "fails in a before(:all) block" do
-      def use_rspec_mocks
-        allow(Object).to receive(:foo)
-      end
-    end
-  end
-
-  describe "#expect_any_instance_of(...).to receive" do
-    include_examples "fails in a before(:all) block" do
-      def use_rspec_mocks
-        expect_any_instance_of(Object).to receive(:foo)
-      end
-    end
-  end
-
-  describe "#allow_any_instance_of(...).to receive" do
-    include_examples "fails in a before(:all) block" do
-      def use_rspec_mocks
-        allow_any_instance_of(Object).to receive(:foo)
-      end
-    end
-  end
-end

data/spec/rspec/mocks/block_return_value_spec.rb

@@ -1,70 +0,0 @@
-require "spec_helper"
-
-describe "a double declaration with a block handed to:" do
-  describe "should_receive" do
-    it "returns the value of executing the block" do
-      obj = Object.new
-      obj.should_receive(:foo) { 'bar' }
-      expect(obj.foo).to eq('bar')
-    end
-
-    it "works when a multi-return stub has already been set" do
-      obj = Object.new
-      return_value = Object.new
-      obj.stub(:foo).and_return(return_value, nil)
-      obj.should_receive(:foo) { return_value }
-      expect(obj.foo).to be(return_value)
-    end
-  end
-
-  describe "stub" do
-    it "returns the value of executing the block" do
-      obj = Object.new
-      obj.stub(:foo) { 'bar' }
-      expect(obj.foo).to eq('bar')
-    end
-
-    # The "receives a block" part is important: 1.8.7 has a bug that reports the
-    # wrong arity when a block receives a block.
-    it 'forwards all given args to the block, even when it receives a block' do
-      obj = Object.new
-      yielded_args = []
-      eval("obj.stub(:foo) { |*args, &bl| yielded_args << args }")
-      obj.foo(1, 2, 3)
-
-      expect(yielded_args).to eq([[1, 2, 3]])
-    end
-  end
-
-  describe "with" do
-    it "returns the value of executing the block" do
-      obj = Object.new
-      obj.stub(:foo).with('baz') { 'bar' }
-      expect(obj.foo('baz')).to eq('bar')
-    end
-
-    it "returns the value of executing the block with given argument" do
-      obj = Object.new
-      obj.stub(:foo).with('baz') {|x| 'bar' + x }
-      expect(obj.foo('baz')).to eq('barbaz')
-    end
-  end
-
-  %w[once twice ordered].each do |method|
-    describe method do
-      it "returns the value of executing the block" do
-        obj = Object.new
-        obj.stub(:foo).send(method) { 'bar' }
-        expect(obj.foo).to eq('bar')
-      end
-    end
-  end
-
-  describe "times" do
-    it "returns the value of executing the block" do
-      obj = Object.new
-      obj.stub(:foo).at_least(1).times { 'bar' }
-      expect(obj.foo('baz')).to eq('bar')
-    end
-  end
-end