vagrant-unbundled 1.9.5.1 → 1.9.7.1

data/vendor/bundle/ruby/2.4.0/gems/rspec-mocks-2.14.6/spec/rspec/mocks/matchers/receive_spec.rb

@@ -1,342 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe Matchers::Receive do
-      include_context "with syntax", :expect
-
-      def verify_all
-        ::RSpec::Mocks.space.verify_all
-      end
-
-      def reset_all
-        ::RSpec::Mocks.space.reset_all
-      end
-
-      shared_examples_for "a receive matcher" do |*options|
-        it 'allows the caller to configure how the subject responds' do
-          wrapped.to receive(:foo).and_return(5)
-          expect(receiver.foo).to eq(5)
-        end
-
-        it 'allows the caller to constrain the received arguments' do
-          wrapped.to receive(:foo).with(:a)
-          receiver.foo(:a)
-
-          expect {
-            receiver.foo(:b)
-          }.to raise_error(/received :foo with unexpected arguments/)
-        end
-
-        it 'allows a `do...end` block implementation to be provided' do
-          wrapped.to receive(:foo) do
-            4
-          end
-
-          expect(receiver.foo).to eq(4)
-        end
-
-        it 'allows chaining off a `do...end` block implementation to be provided' do
-          wrapped.to receive(:foo) do
-            4
-          end.and_return(6)
-
-          expect(receiver.foo).to eq(6)
-        end
-
-        it 'allows a `{ ... }` block implementation to be provided' do
-          wrapped.to receive(:foo) { 5 }
-          expect(receiver.foo).to eq(5)
-        end
-
-        it 'gives precedence to a `{ ... }` block when both forms are provided ' +
-           'since that form actually binds to `receive`' do
-          wrapped.to receive(:foo) { :curly } do
-            :do_end
-          end
-
-          expect(receiver.foo).to eq(:curly)
-        end
-
-        it 'does not support other matchers', :unless => options.include?(:allow_other_matchers) do
-          expect {
-            wrapped.to eq(3)
-          }.to raise_error(UnsupportedMatcherError)
-        end
-      end
-
-      shared_examples_for "an expect syntax allowance" do |*options|
-        include_examples "a receive matcher", *options
-
-        it 'does not expect the message to be received' do
-          wrapped.to receive(:foo)
-          expect { verify_all }.not_to raise_error
-        end
-      end
-
-      shared_examples_for "an expect syntax negative allowance" do
-        it 'is disabled since this expression is confusing' do
-          expect {
-            wrapped.not_to receive(:foo)
-          }.to raise_error(/not_to receive` is not supported/)
-
-          expect {
-            wrapped.to_not receive(:foo)
-          }.to raise_error(/to_not receive` is not supported/)
-        end
-      end
-
-      shared_examples_for "an expect syntax expectation" do |*options|
-        include_examples "a receive matcher", *options
-
-        it 'sets up a message expectation that passes if the message is received' do
-          wrapped.to receive(:foo)
-          receiver.foo
-          verify_all
-        end
-
-        it 'sets up a message expectation that fails if the message is not received' do
-          wrapped.to receive(:foo)
-
-          expect {
-            verify_all
-          }.to raise_error(RSpec::Mocks::MockExpectationError)
-
-          reset_all
-        end
-
-        it "reports the line number of expectation of unreceived message", :pending => options.include?(:does_not_report_line_num) do
-          expected_error_line = __LINE__; wrapped.to receive(:foo)
-
-          expect {
-            verify_all
-          }.to raise_error { |e|
-            expect(e.backtrace.first).to match(/#{File.basename(__FILE__)}:#{expected_error_line}/)
-          }
-        end
-      end
-
-      shared_examples_for "an expect syntax negative expectation" do
-        it 'sets up a negaive message expectation that passes if the message is not received' do
-          wrapped.not_to receive(:foo)
-          verify_all
-        end
-
-        it 'sets up a negative message expectation that fails if the message is received' do
-          wrapped.not_to receive(:foo)
-
-          expect {
-            receiver.foo
-          }.to raise_error(/expected: 0 times.*received: 1 time/m)
-        end
-
-        it 'supports `to_not` as an alias for `not_to`' do
-          wrapped.to_not receive(:foo)
-
-          expect {
-            receiver.foo
-          }.to raise_error(/expected: 0 times.*received: 1 time/m)
-        end
-
-        it 'allows the caller to constrain the received arguments' do
-          wrapped.not_to receive(:foo).with(:a)
-          def receiver.method_missing(*a); end # a poor man's stub...
-
-          expect {
-            receiver.foo(:b)
-          }.not_to raise_error
-
-          expect {
-            receiver.foo(:a)
-          }.to raise_error(/expected: 0 times.*received: 1 time/m)
-        end
-
-        it 'prevents confusing double-negative expressions involving `never`' do
-          expect {
-            wrapped.not_to receive(:foo).never
-          }.to raise_error(/trying to negate it again/)
-
-          expect {
-            wrapped.to_not receive(:foo).never
-          }.to raise_error(/trying to negate it again/)
-        end
-      end
-
-      describe "allow(...).to receive" do
-        include_examples "an expect syntax allowance" do
-          let(:receiver) { double }
-          let(:wrapped)  { allow(receiver) }
-        end
-      end
-
-      describe "allow(...).not_to receive" do
-        include_examples "an expect syntax negative allowance" do
-          let(:wrapped) { allow(double) }
-        end
-      end
-
-      describe "allow_any_instance_of(...).to receive" do
-        include_examples "an expect syntax allowance" do
-          let(:klass)    { Class.new }
-          let(:wrapped)  { allow_any_instance_of(klass) }
-          let(:receiver) { klass.new }
-        end
-      end
-
-      describe "allow_any_instance_of(...).not_to receive" do
-        include_examples "an expect syntax negative allowance" do
-          let(:wrapped) { allow_any_instance_of(Class.new) }
-        end
-      end
-
-      describe "expect(...).to receive" do
-        include_examples "an expect syntax expectation", :allow_other_matchers do
-          let(:receiver) { double }
-          let(:wrapped)  { expect(receiver) }
-        end
-      end
-
-      describe "expect_any_instance_of(...).to receive" do
-        include_examples "an expect syntax expectation", :does_not_report_line_num do
-          let(:klass)    { Class.new }
-          let(:wrapped)  { expect_any_instance_of(klass) }
-          let(:receiver) { klass.new }
-        end
-      end
-
-      describe "expect(...).not_to receive" do
-        include_examples "an expect syntax negative expectation" do
-          let(:receiver) { double }
-          let(:wrapped)  { expect(receiver) }
-        end
-      end
-
-      describe "expect_any_instance_of(...).not_to receive" do
-        include_examples "an expect syntax negative expectation" do
-          let(:klass)    { Class.new }
-          let(:wrapped)  { expect_any_instance_of(klass) }
-          let(:receiver) { klass.new }
-        end
-      end
-
-      shared_examples "using rspec-mocks in another test framework" do
-        it 'can use the `expect` syntax' do
-          dbl = double
-
-          framework.new.instance_eval do
-            expect(dbl).to receive(:foo).and_return(3)
-          end
-
-          expect(dbl.foo).to eq(3)
-        end
-
-        it 'expects the method to be called when `expect` is used' do
-          dbl = double
-
-          framework.new.instance_eval do
-            expect(dbl).to receive(:foo)
-          end
-
-          expect { verify dbl }.to raise_error(RSpec::Mocks::MockExpectationError)
-        end
-
-        it 'supports `expect(...).not_to receive`' do
-          dbl = double
-
-          framework.new.instance_eval do
-            expect(dbl).not_to receive(:foo)
-          end
-
-          expect { dbl.foo }.to raise_error(RSpec::Mocks::MockExpectationError)
-        end
-
-        it 'supports `expect(...).to_not receive`' do
-          dbl = double
-
-          framework.new.instance_eval do
-            expect(dbl).to_not receive(:foo)
-          end
-
-          expect { dbl.foo }.to raise_error(RSpec::Mocks::MockExpectationError)
-        end
-      end
-
-      context "when used in a test framework without rspec-expectations" do
-        let(:framework) do
-          Class.new do
-            include RSpec::Mocks::ExampleMethods
-
-            def eq(value)
-              double("MyMatcher")
-            end
-          end
-        end
-
-        include_examples "using rspec-mocks in another test framework"
-
-        it 'cannot use `expect` with another matcher' do
-          expect {
-            framework.new.instance_eval do
-              expect(3).to eq(3)
-            end
-          }.to raise_error(/only the `receive` matcher is supported/)
-        end
-
-        it 'can toggle the available syntax' do
-          expect(framework.new).to respond_to(:expect)
-          RSpec::Mocks.configuration.syntax = :should
-          expect(framework.new).not_to respond_to(:expect)
-          RSpec::Mocks.configuration.syntax = :expect
-          expect(framework.new).to respond_to(:expect)
-        end
-
-        after { RSpec::Mocks.configuration.syntax = :expect }
-      end
-
-      context "when rspec-expectations is included in the test framework first" do
-        before do
-          # the examples here assume `expect` is define in RSpec::Matchers...
-          expect(RSpec::Matchers.method_defined?(:expect)).to be_true
-        end
-
-        let(:framework) do
-          Class.new do
-            include RSpec::Matchers
-            include RSpec::Mocks::ExampleMethods
-          end
-        end
-
-        include_examples "using rspec-mocks in another test framework"
-
-        it 'can use `expect` with any matcher' do
-          framework.new.instance_eval do
-            expect(3).to eq(3)
-          end
-        end
-      end
-
-      context "when rspec-expectations is included in the test framework last" do
-        before do
-          # the examples here assume `expect` is define in RSpec::Matchers...
-          expect(RSpec::Matchers.method_defined?(:expect)).to be_true
-        end
-
-        let(:framework) do
-          Class.new do
-            include RSpec::Mocks::ExampleMethods
-            include RSpec::Matchers
-          end
-        end
-
-        include_examples "using rspec-mocks in another test framework"
-
-        it 'can use `expect` with any matcher' do
-          framework.new.instance_eval do
-            expect(3).to eq(3)
-          end
-        end
-      end
-    end
-  end
-end
-

data/vendor/bundle/ruby/2.4.0/gems/rspec-mocks-2.14.6/spec/rspec/mocks/methods_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe "Methods added to every object" do
-      include_context "with syntax", :expect
-
-      def added_methods
-        host = Class.new
-        orig_instance_methods = host.instance_methods
-        Syntax.enable_should(host)
-        (host.instance_methods - orig_instance_methods).map(&:to_sym)
-      end
-
-      it 'limits the number of methods that get added to all objects' do
-        # If really necessary, you can add to this list, but long term,
-        # we are hoping to cut down on the number of methods added to all objects
-        expect(added_methods).to match_array([
-          :as_null_object, :null_object?,
-          :received_message?, :should_not_receive, :should_receive,
-          :stub, :stub!, :stub_chain, :unstub, :unstub!
-        ])
-      end
-    end
-  end
-end
-

data/vendor/bundle/ruby/2.4.0/gems/rspec-mocks-2.14.6/spec/rspec/mocks/mock_ordering_spec.rb

@@ -1,103 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-
-    describe "ordering" do
-      before { @double = double("test double") }
-      after  { reset @double }
-
-      it "passes when messages are received in order" do
-        @double.should_receive(:one).ordered
-        @double.should_receive(:two).ordered
-        @double.should_receive(:three).ordered
-        @double.one
-        @double.two
-        @double.three
-      end
-
-      it "passes when messages are received in order across objects" do
-        a = double("a")
-        b = double("b")
-        a.should_receive(:one).ordered
-        b.should_receive(:two).ordered
-        a.should_receive(:three).ordered
-        a.one
-        b.two
-        a.three
-      end
-
-      it "fails when messages are received out of order (2nd message 1st)" do
-        @double.should_receive(:one).ordered
-        @double.should_receive(:two).ordered
-        expect {
-          @double.two
-        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :two out of order")
-      end
-
-      it "fails when messages are received out of order (3rd message 1st)" do
-        @double.should_receive(:one).ordered
-        @double.should_receive(:two).ordered
-        @double.should_receive(:three).ordered
-        @double.one
-        expect {
-          @double.three
-        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :three out of order")
-      end
-
-      it "fails when messages are received out of order (3rd message 2nd)" do
-        @double.should_receive(:one).ordered
-        @double.should_receive(:two).ordered
-        @double.should_receive(:three).ordered
-        @double.one
-        expect {
-          @double.three
-        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :three out of order")
-      end
-
-      it "fails when messages are out of order across objects" do
-        a = double("test double")
-        b = double("another test double")
-        a.should_receive(:one).ordered
-        b.should_receive(:two).ordered
-        a.should_receive(:three).ordered
-        a.one
-        expect {
-          a.three
-        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :three out of order")
-        reset a
-        reset b
-      end
-
-      it "ignores order of non ordered messages" do
-        @double.should_receive(:ignored_0)
-        @double.should_receive(:ordered_1).ordered
-        @double.should_receive(:ignored_1)
-        @double.should_receive(:ordered_2).ordered
-        @double.should_receive(:ignored_2)
-        @double.should_receive(:ignored_3)
-        @double.should_receive(:ordered_3).ordered
-        @double.should_receive(:ignored_4)
-        @double.ignored_3
-        @double.ordered_1
-        @double.ignored_0
-        @double.ordered_2
-        @double.ignored_4
-        @double.ignored_2
-        @double.ordered_3
-        @double.ignored_1
-        verify @double
-      end
-
-      it "supports duplicate messages" do
-        @double.should_receive(:a).ordered
-        @double.should_receive(:b).ordered
-        @double.should_receive(:a).ordered
-
-        @double.a
-        @double.b
-        @double.a
-      end
-    end
-  end
-end