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/bug_report_11545_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-class LiarLiarPantsOnFire
-  def respond_to?(message, incl_private=false)
-    true
-  end
-
-  def self.respond_to?(message, incl_private=false)
-    true
-  end
-end
-
-describe 'should_receive' do
-  before(:each) do
-    @liar = LiarLiarPantsOnFire.new
-  end
-
-  it "works when object lies about responding to a method" do
-    @liar.should_receive(:something)
-    @liar.something
-  end
-
-  it 'works when class lies about responding to a method' do
-    LiarLiarPantsOnFire.should_receive(:something)
-    LiarLiarPantsOnFire.something
-  end
-
-  it 'cleans up after itself' do
-    expect((class << LiarLiarPantsOnFire; self; end).instance_methods).not_to include("something")
-  end
-end
-

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

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-module BugReport496
-  describe "a message expectation on a base class object" do
-    class BaseClass
-    end
-
-    class SubClass < BaseClass
-    end
-
-    it "is received" do
-      BaseClass.should_receive(:new).once
-      SubClass.new
-    end
-  end
-end
-

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

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-module BugReport600
-  describe "stubbing a class method" do
-    class ExampleClass
-      def self.method_that_uses_define_method
-        define_method "defined_method" do |attributes|
-          load_address(address, attributes)
-        end
-      end
-    end
-
-    it "works" do
-      ExampleClass.should_receive(:define_method).with("defined_method")
-      ExampleClass.method_that_uses_define_method
-    end
-
-    it "restores the original method" do
-      ExampleClass.method_that_uses_define_method
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-require 'spec_helper'
-
-module Bug7611
-  describe "A Partial Mock" do
-    class Foo; end
-    class Bar < Foo; end
-
-    it "respects subclasses" do
-      Foo.stub(:new).and_return(Object.new)
-    end
-
-    it "should" do
-      expect(Bar.new.class).to eq Bar
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe "An object where respond_to? is true and does not have method" do
-  # When should_receive(message) is sent to any object, the Proxy sends
-  # respond_to?(message) to that object to see if the method should be proxied.
-  #
-  # If respond_to? itself is proxied, then when the Proxy sends respond_to?
-  # to the object, the proxy is invoked and responds yes (if so set in the spec).
-  # When the object does NOT actually respond to `message`, an exception is thrown
-  # when trying to proxy it.
-  #
-  # The fix was to keep track of whether `respond_to?` had been proxied and, if
-  # so, call the munged copy of `respond_to?` on the object.
-
-  it "does not raise an exception for Object" do
-    obj = Object.new
-    obj.should_receive(:respond_to?).with(:foobar).and_return(true)
-    obj.should_receive(:foobar).and_return(:baz)
-    expect(obj.respond_to?(:foobar)).to be_true
-    expect(obj.foobar).to eq :baz
-  end
-
-  it "does not raise an exception for mock" do
-    obj = double("obj")
-    obj.should_receive(:respond_to?).with(:foobar).and_return(true)
-    obj.should_receive(:foobar).and_return(:baz)
-    expect(obj.respond_to?(:foobar)).to be_true
-    expect(obj.foobar).to eq :baz
-  end
-
-end

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

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe 'Calling a method that catches StandardError' do
-      class Foo
-        def self.foo
-          bar
-        rescue StandardError
-        end
-      end
-
-      it 'still reports mock failures' do
-        Foo.should_not_receive :bar
-        expect {
-          Foo.foo
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe "stubbing a base class class method" do
-      before do
-        @base_class     = Class.new
-        @concrete_class = Class.new(@base_class)
-
-        @base_class.stub(:find).and_return "stubbed_value"
-      end
-
-      it "returns the value for the stub on the base class" do
-        expect(@base_class.find).to eq "stubbed_value"
-      end
-
-      it "returns the value for the descendent class" do
-        expect(@concrete_class.find).to eq "stubbed_value"
-      end
-    end
-  end
-end

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

@@ -1,205 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe "Combining implementation instructions" do
-      it 'can combine and_yield and and_return' do
-        dbl = double
-        dbl.stub(:foo).and_yield(5).and_return(3)
-
-        expect { |b|
-          expect(dbl.foo(&b)).to eq(3)
-        }.to yield_with_args(5)
-      end
-
-      describe "combining and_yield, a block implementation and and_return" do
-        def verify_combined_implementation
-          dbl = double
-          (yield dbl).and_yield(5).and_return(3)
-
-          expect { |b|
-            expect(dbl.foo(:arg, &b)).to eq(3)
-          }.to yield_with_args(5)
-
-          expect(@block_called).to be_true
-        end
-
-        it 'works when passing a block to `stub`' do
-          verify_combined_implementation do |dbl|
-            dbl.stub(:foo) { @block_called = true }
-          end
-        end
-
-        it 'works when passing a block to `with`' do
-          verify_combined_implementation do |dbl|
-            dbl.stub(:foo).with(:arg) { @block_called = true }
-          end
-        end
-
-        it 'works when passing a block to `exactly`' do
-          verify_combined_implementation do |dbl|
-            dbl.should_receive(:foo).exactly(:once) { @block_called = true }
-          end
-        end
-
-        it 'works when passing a block to `at_least`' do
-          verify_combined_implementation do |dbl|
-            dbl.should_receive(:foo).at_least(:once) { @block_called = true }
-          end
-        end
-
-        it 'works when passing a block to `at_most`' do
-          verify_combined_implementation do |dbl|
-            dbl.should_receive(:foo).at_most(:once) { @block_called = true }
-          end
-        end
-
-        it 'works when passing a block to `times`' do
-          verify_combined_implementation do |dbl|
-            dbl.should_receive(:foo).exactly(1).times { @block_called = true }
-          end
-        end
-
-        it 'works when passing a block to `any_number_of_times`' do
-          verify_combined_implementation do |dbl|
-            dbl.should_receive(:foo).any_number_of_times { @block_called = true }
-          end
-        end
-
-        it 'works when passing a block to `once`' do
-          verify_combined_implementation do |dbl|
-            dbl.should_receive(:foo).once { @block_called = true }
-          end
-        end
-
-        it 'works when passing a block to `twice`' do
-          the_double = nil
-
-          verify_combined_implementation do |dbl|
-            the_double = dbl
-            dbl.should_receive(:foo).twice { @block_called = true }
-          end
-
-          the_double.foo { |a| } # to ensure it is called twice
-        end
-
-        it 'works when passing a block to `ordered`' do
-          verify_combined_implementation do |dbl|
-            dbl.should_receive(:foo).ordered { @block_called = true }
-          end
-        end
-      end
-
-      it 'can combine and_yield and and_return with a block' do
-        dbl = double
-        dbl.stub(:foo).and_yield(5).and_return { :return }
-
-        expect { |b|
-          expect(dbl.foo(&b)).to eq(:return)
-        }.to yield_with_args(5)
-      end
-
-      it 'can combine and_yield and and_raise' do
-        dbl = double
-        dbl.stub(:foo).and_yield(5).and_raise("boom")
-
-        expect { |b|
-          expect { dbl.foo(&b) }.to raise_error("boom")
-        }.to yield_with_args(5)
-      end
-
-      it 'can combine and_yield, a block implementation and and_raise' do
-        dbl = double
-        block_called = false
-        dbl.stub(:foo) { block_called = true }.and_yield(5).and_raise("boom")
-
-        expect { |b|
-          expect { dbl.foo(&b) }.to raise_error("boom")
-        }.to yield_with_args(5)
-
-        expect(block_called).to be_true
-      end
-
-      it 'can combine and_yield and and_throw' do
-        dbl = double
-        dbl.stub(:foo).and_yield(5).and_throw(:bar)
-
-        expect { |b|
-          expect { dbl.foo(&b) }.to throw_symbol(:bar)
-        }.to yield_with_args(5)
-      end
-
-      it 'can combine and_yield, a block implementation and and_throw' do
-        dbl = double
-        block_called = false
-        dbl.stub(:foo) { block_called = true }.and_yield(5).and_throw(:bar)
-
-        expect { |b|
-          expect { dbl.foo(&b) }.to throw_symbol(:bar)
-        }.to yield_with_args(5)
-
-        expect(block_called).to be_true
-      end
-
-      it 'returns `nil` from all terminal actions to discourage further configuration' do
-        expect(double.stub(:foo).and_return(1)).to be_nil
-        expect(double.stub(:foo).and_raise("boom")).to be_nil
-        expect(double.stub(:foo).and_throw(:foo)).to be_nil
-      end
-
-      it 'allows the terminal action to be overriden' do
-        dbl = double
-        stubbed_double = dbl.stub(:foo)
-
-        stubbed_double.and_return(1)
-        expect(dbl.foo).to eq(1)
-
-        stubbed_double.and_return(3)
-        expect(dbl.foo).to eq(3)
-
-        stubbed_double.and_raise("boom")
-        expect { dbl.foo }.to raise_error("boom")
-
-        stubbed_double.and_throw(:bar)
-        expect { dbl.foo }.to throw_symbol(:bar)
-      end
-
-      it 'allows the inner implementation block to be overriden' do
-        dbl = double
-        stubbed_double = dbl.stub(:foo)
-
-        stubbed_double.with(:arg) { :with_block }
-        expect(dbl.foo(:arg)).to eq(:with_block)
-
-        stubbed_double.at_least(:once) { :at_least_block }
-        expect(dbl.foo(:arg)).to eq(:at_least_block)
-      end
-
-      it 'can combine and_call_original, with, and_return' do
-        obj = Struct.new(:value).new('original')
-        obj.stub(:value).and_call_original
-        obj.stub(:value).with(:arg).and_return('value')
-        expect(obj.value).to eq 'original'
-        expect(obj.value(:arg)).to eq 'value'
-      end
-
-      it 'raises an error if `and_call_original` is followed by any other instructions' do
-        dbl = [1, 2, 3]
-        stubbed = dbl.stub(:size)
-        stubbed.and_call_original
-
-        msg_fragment = /cannot be modified further/
-
-        expect { stubbed.and_yield }.to raise_error(msg_fragment)
-        expect { stubbed.and_return(1) }.to raise_error(msg_fragment)
-        expect { stubbed.and_raise("a") }.to raise_error(msg_fragment)
-        expect { stubbed.and_throw(:bar) }.to raise_error(msg_fragment)
-
-        expect { stubbed.once { } }.to raise_error(msg_fragment)
-
-        expect(dbl.size).to eq(3)
-      end
-    end
-  end
-end
-

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

@@ -1,150 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe Configuration do
-      let(:config) { Configuration.new }
-      let(:mod_1)  { Module.new }
-      let(:mod_2)  { Module.new }
-
-      def instance_methods_of(mod)
-        mod_1.instance_methods.map(&:to_sym)
-      end
-
-      it 'adds stub and should_receive to the given modules' do
-        expect(instance_methods_of(mod_1)).not_to include(:stub, :should_receive)
-        expect(instance_methods_of(mod_2)).not_to include(:stub, :should_receive)
-
-        config.add_stub_and_should_receive_to(mod_1, mod_2)
-
-        expect(instance_methods_of(mod_1)).to include(:stub, :should_receive)
-        expect(instance_methods_of(mod_2)).to include(:stub, :should_receive)
-      end
-
-      shared_examples_for "configuring the syntax" do
-        def sandboxed
-          orig_syntax = RSpec::Mocks.configuration.syntax
-          yield
-        ensure
-          configure_syntax(orig_syntax)
-        end
-
-        around(:each) { |ex| sandboxed(&ex) }
-        let(:dbl) { double }
-        let(:should_methods)       { [:should_receive, :stub, :should_not_receive] }
-        let(:should_class_methods) { [:any_instance] }
-        let(:expect_methods)      { [:receive, :allow, :expect_any_instance_of, :allow_any_instance_of] }
-
-        it 'defaults to enabling both the :should and :expect syntaxes' do
-          expect(dbl).to respond_to(*should_methods)
-          expect(self).to respond_to(*expect_methods)
-        end
-
-        context 'when configured to :expect' do
-          before { configure_syntax :expect }
-
-          it 'removes the should methods from every object' do
-            expect(dbl).not_to respond_to(*should_methods)
-          end
-
-          it 'removes `any_instance` from every class' do
-            expect(Class.new).not_to respond_to(*should_class_methods)
-          end
-
-          it 'adds the expect methods to the example group context' do
-            expect(self).to respond_to(*expect_methods)
-          end
-
-          it 'reports that the syntax is :expect' do
-            expect(configured_syntax).to eq([:expect])
-          end
-
-          it 'is a no-op when configured a second time' do
-            expect(Syntax.default_should_syntax_host).not_to receive(:method_undefined)
-            expect(::RSpec::Mocks::ExampleMethods).not_to receive(:method_added)
-            configure_syntax :expect
-          end
-        end
-
-        context 'when configured to :should' do
-          before { configure_syntax :should }
-
-          it 'adds the should methods to every object' do
-            expect(dbl).to respond_to(*should_methods)
-          end
-
-          it 'adds `any_instance` to every class' do
-            expect(Class.new).to respond_to(*should_class_methods)
-          end
-
-          it 'removes the expect methods from the example group context' do
-            expect(self).not_to respond_to(*expect_methods)
-          end
-
-          it 'reports that the syntax is :should' do
-            expect(configured_syntax).to eq([:should])
-          end
-
-          it 'is a no-op when configured a second time' do
-            Syntax.default_should_syntax_host.should_not_receive(:method_added)
-            ::RSpec::Mocks::ExampleMethods.should_not_receive(:method_undefined)
-            configure_syntax :should
-          end
-        end
-
-        context 'when configured to [:should, :expect]' do
-          before { configure_syntax [:should, :expect] }
-
-          it 'adds the should methods to every object' do
-            expect(dbl).to respond_to(*should_methods)
-          end
-
-          it 'adds `any_instance` to every class' do
-            expect(Class.new).to respond_to(*should_class_methods)
-          end
-
-          it 'adds the expect methods to the example group context' do
-            expect(self).to respond_to(*expect_methods)
-          end
-
-          it 'reports that both syntaxes are enabled' do
-            expect(configured_syntax).to eq([:should, :expect])
-          end
-        end
-      end
-
-      describe "configuring rspec-mocks directly" do
-        it_behaves_like "configuring the syntax" do
-          def configure_syntax(syntax)
-            RSpec::Mocks.configuration.syntax = syntax
-          end
-
-          def configured_syntax
-            RSpec::Mocks.configuration.syntax
-          end
-        end
-      end
-
-      describe "configuring using the rspec-core config API" do
-        it_behaves_like "configuring the syntax" do
-          def configure_syntax(syntax)
-            RSpec.configure do |rspec|
-              rspec.mock_with :rspec do |c|
-                c.syntax = syntax
-              end
-            end
-          end
-
-          def configured_syntax
-            RSpec.configure do |rspec|
-              rspec.mock_with :rspec do |c|
-                return c.syntax
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end
-