vagrant-unbundled 2.0.0.1 → 2.0.1.0

data/vendor/bundle/ruby/2.4.0/gems/webmock-2.3.2/spec/support/network_connection.rb

@@ -0,0 +1,19 @@
+require 'timeout'
+require 'socket'
+
+module NetworkConnection
+  def self.connect_to(host, port, timeout=10)
+    Timeout.timeout(timeout) do
+      TCPSocket.new(host, port)
+    end
+  end
+
+  def self.is_network_available?
+    begin
+      self.connect_to("8.8.8.8", 53, 5)
+      true
+    rescue
+      false
+    end
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/webmock-2.3.2/spec/support/webmock_server.rb

@@ -0,0 +1,69 @@
+require 'webrick'
+require 'logger'
+require 'singleton'
+
+class WebMockServer
+  include Singleton
+
+  attr_reader :port, :started
+
+  def host_with_port
+    "localhost:#{port}"
+  end
+
+  def concurrent
+    unless RUBY_PLATFORM =~ /java/
+      @pid = Process.fork do
+        yield
+      end
+    else
+      Thread.new { yield }
+    end
+  end
+
+  def start
+    @started = true
+    server = WEBrick::GenericServer.new(Port: 0, Logger: Logger.new("/dev/null"))
+    server.logger.level = 0
+    @port = server.config[:Port]
+
+    concurrent do
+      ['TERM', 'INT'].each do |signal|
+        trap(signal) do
+          Thread.new do
+            server.shutdown
+          end
+        end
+      end
+      server.start do |socket|
+        socket.puts <<-EOT.gsub(/^\s+\|/, '')
+          |HTTP/1.1 200 OK\r
+          |Date: Fri, 31 Dec 1999 23:59:59 GMT\r
+          |Content-Type: text/html\r
+          |Content-Length: 11\r
+          |Set-Cookie: bar\r
+          |Set-Cookie: foo\r
+          |\r
+          |hello world
+        EOT
+      end
+    end
+
+
+    loop do
+      begin
+        TCPSocket.new("localhost", port)
+        sleep 0.1
+        break
+      rescue Errno::ECONNREFUSED
+        sleep 0.1
+      end
+    end
+  end
+
+  def stop
+    if @pid
+      Process.kill('INT', @pid)
+    end
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/webmock-2.3.2/spec/unit/api_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe WebMock::API do
+  describe '#hash_including' do
+
+    subject { klass.new.hash_including(args) }
+    let(:args) { {data: :one} }
+
+    context 'when mixed into a class that does not define `hash_including`' do
+      let(:klass) do
+        Class.new do
+          include WebMock::API
+        end
+      end
+
+      it 'uses WebMock::Matchers::HashIncludingMatcher' do
+        expect(subject).to be_a(WebMock::Matchers::HashIncludingMatcher)
+      end
+
+      #  by testing equality for HashIncludingMatcher (which stringifies the passed hash) we are
+      #  testing HashIncludingMatcher.initialize behavior as well
+      context "when args correspond to an hash" do
+        it "creates 'HashIncludingMatcher'" do
+          expect(subject).to eq("data" => :one)
+        end
+      end
+
+      context "when args are one or many keys" do
+        subject {klass.new.hash_including(:foo, :bar)}
+        let(:anything) { WebMock::Matchers::AnyArgMatcher.new(nil) }
+
+        it "creates 'HashIncludingMatcher' with keys anythingized" do
+          expect(subject).to eq("foo" => anything, "bar" => anything )
+        end
+      end
+
+      context "when args are both keys and key/value pairs" do
+        subject {klass.new.hash_including(:foo, :bar, data: :one)}
+        let(:anything) { WebMock::Matchers::AnyArgMatcher.new(nil) }
+
+        it "creates 'HashIncludingMatcher' with keys anythingized" do
+          expect(subject).to eq("foo" => anything, "bar" => anything, "data" => :one)
+        end
+      end
+
+      context "when args are an empty hash" do
+        subject {klass.new.hash_including({})}
+
+        it "creates 'HashIncludingMatcher' with an empty hash" do
+          expect(subject).to eq({})
+        end
+      end
+    end
+
+
+    context 'when mixed into a class with a parent that defines `hash_including`' do
+      subject {klass.new.hash_including(*args)}
+      let(:args) { %w(:foo, :bar, {:data => :one}) }
+      let(:klass) do
+        Class.new(
+          Class.new do
+            def hash_including(*args)
+              args
+            end
+          end
+        ) { include WebMock::API }
+      end
+
+      it 'uses super and passes the args untampered' do
+        expect(subject).to eq(args)
+      end
+    end
+
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/webmock-2.3.2/spec/unit/errors_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+describe "errors" do
+  describe WebMock::NetConnectNotAllowedError do
+    describe "message" do
+      it "should have message with request signature and snippet" do
+        allow(WebMock::RequestStub).to receive(:from_request_signature).and_return(request_stub)
+        allow(WebMock::StubRequestSnippet).to receive(:new).
+           with(request_stub).and_return(stub_result)
+
+        expected =  \
+          "Real HTTP connections are disabled. Unregistered request: #{request_signature}" \
+          "\n\nYou can stub this request with the following snippet:" \
+          "\n\n#{stub_result}" \
+          "\n\n============================================================"
+        expect(WebMock::NetConnectNotAllowedError.new(request_signature).message).to eq(expected)
+      end
+
+      it "should have message with registered stubs if available" do
+        allow(WebMock::StubRegistry.instance).to receive(:request_stubs).and_return([request_stub])
+        allow(WebMock::RequestStub).to receive(:from_request_signature).and_return(request_stub)
+        allow(WebMock::StubRequestSnippet).to receive(:new).
+           with(request_stub).and_return(stub_result)
+        allow_any_instance_of(WebMock::RequestBodyDiff).to receive(:body_diff).and_return({})
+
+        expected =  \
+          "Real HTTP connections are disabled. Unregistered request: #{request_signature}" \
+          "\n\nYou can stub this request with the following snippet:" \
+          "\n\n#{stub_result}" \
+          "\n\nregistered request stubs:" \
+          "\n\n#{stub_result}" \
+          "\n\n============================================================"
+        expect(WebMock::NetConnectNotAllowedError.new(request_signature).message).to eq(expected)
+      end
+
+      it "should not be caught by a rescue block without arguments" do
+        allow(WebMock::RequestStub).to receive(:from_request_signature).and_return(request_stub)
+        allow(WebMock::StubRequestSnippet).to receive(:new).
+          with(request_stub).and_return(stub_result)
+
+        exception = WebMock::NetConnectNotAllowedError.new(request_signature)
+
+        expect do
+          begin
+            raise exception
+          rescue
+            raise "exception should not be caught"
+          end
+        end.to raise_exception exception
+      end
+
+      it "should print body diff if available" do
+        allow(WebMock::StubRegistry.instance).to receive(:request_stubs).and_return([request_stub])
+        allow(WebMock::RequestStub).to receive(:from_request_signature).and_return(request_stub)
+        allow(WebMock::StubRequestSnippet).to receive(:new).
+           with(request_stub).and_return(stub_result)
+        allow_any_instance_of(WebMock::RequestBodyDiff).to receive(:body_diff).and_return(body_diff)
+        expected =  \
+          "Real HTTP connections are disabled. Unregistered request: #{request_signature}" \
+          "\n\nYou can stub this request with the following snippet:" \
+          "\n\n#{stub_result}" \
+          "\n\nregistered request stubs:" \
+          "\n\n#{stub_result}" \
+          "\n\nBody diff:\n [[\"+\", \"test\", \"test2\"], [\"-\", \"test3\"], [\"~\", \"test5\", \"test6\"]]" \
+          "\n\n\n============================================================"
+        expect(WebMock::NetConnectNotAllowedError.new(request_signature).message).to eq(expected)
+      end
+
+      context "WebMock.show_body_diff? is false" do
+        before do
+          WebMock.hide_body_diff!
+        end
+        it "should not show body diff" do
+          allow(WebMock::StubRegistry.instance).to receive(:request_stubs).and_return([request_stub])
+          allow(WebMock::RequestStub).to receive(:from_request_signature).and_return(request_stub)
+          allow(WebMock::StubRequestSnippet).to receive(:new).
+             with(request_stub).and_return(stub_result)
+          expect_any_instance_of(WebMock::RequestBodyDiff).to_not receive(:body_diff)
+          expected =  \
+            "Real HTTP connections are disabled. Unregistered request: #{request_signature}" \
+            "\n\nYou can stub this request with the following snippet:" \
+            "\n\n#{stub_result}" \
+            "\n\nregistered request stubs:" \
+            "\n\n#{stub_result}" \
+            "\n\n============================================================"
+          expect(WebMock::NetConnectNotAllowedError.new(request_signature).message).to eq(expected)
+        end
+      end
+
+      context "WebMock.show_stubbing_instructions? is false" do
+        before do
+          WebMock.hide_stubbing_instructions!
+        end
+
+        it "should have message with request signature and snippet" do
+          allow(WebMock::RequestStub).to receive(:from_request_signature).and_return(request_stub)
+          allow(WebMock::StubRequestSnippet).to receive(:new).
+            with(request_stub).and_return(stub_result)
+
+          expected =  \
+            "Real HTTP connections are disabled. Unregistered request: #{request_signature}" \
+            "\n\n============================================================"
+          expect(WebMock::NetConnectNotAllowedError.new(request_signature).message).to eq(expected)
+        end
+
+        it "should have message with registered stubs if available" do
+          allow(WebMock::StubRegistry.instance).to receive(:request_stubs).and_return([request_stub])
+          allow(WebMock::RequestStub).to receive(:from_request_signature).and_return(request_stub)
+          allow(WebMock::StubRequestSnippet).to receive(:new).
+            with(request_stub).and_return(stub_result)
+          allow(request_stub).to receive(:request_pattern).and_return(body_pattern)
+
+          expected =  \
+            "Real HTTP connections are disabled. Unregistered request: #{request_signature}" \
+            "\n\nregistered request stubs:" \
+            "\n\n#{stub_result}" \
+            "\n\n============================================================"
+          expect(WebMock::NetConnectNotAllowedError.new(request_signature).message).to eq(expected)
+        end
+      end
+    end
+
+    let(:request_signature) { double(:request_signature, to_s: rand(10**20).to_s) }
+    let(:stub_result)       { double(:stub_result, to_s: rand(10**20).to_s) }
+    let(:request_stub)      { double(:request_stub) }
+    let(:body_pattern)      { double(:body_pattern, body_pattern: nil)}
+    let(:body_diff)         { [["+", "test", "test2"], ["-", "test3"], ["~", "test5", "test6"]] }
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/webmock-2.3.2/spec/unit/http_lib_adapters/http_lib_adapter_registry_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe WebMock::HttpLibAdapterRegistry do
+  describe "each_adapter" do
+    it "should yield block over each adapter" do
+      class MyAdapter < WebMock::HttpLibAdapter; end
+      WebMock::HttpLibAdapterRegistry.instance.register(:my_lib, MyAdapter)
+      adapters = []
+      WebMock::HttpLibAdapterRegistry.instance.each_adapter {|n,a|
+        adapters << [n, a]
+      }
+      expect(adapters).to include([:my_lib, MyAdapter])
+      WebMock::HttpLibAdapterRegistry.instance.
+        http_lib_adapters.delete(:my_lib)
+    end
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/webmock-2.3.2/spec/unit/http_lib_adapters/http_lib_adapter_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe WebMock::HttpLibAdapter do
+  describe "adapter_for" do
+    it "should add adapter to adapter registry" do
+      class MyAdapter < WebMock::HttpLibAdapter; end
+      expect(WebMock::HttpLibAdapterRegistry.instance).
+        to receive(:register).with(:my_lib, MyAdapter)
+      MyAdapter.adapter_for(:my_lib)
+    end
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/webmock-2.3.2/spec/unit/matchers/hash_including_matcher_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+module WebMock
+  module Matchers
+
+    describe HashIncludingMatcher do
+
+      it "stringifies the given hash keys" do
+        expect(HashIncludingMatcher.new(a: 1, b: 2)).to eq("a" => 1, "b" => 2)
+      end
+
+      it "sorts elements in the hash" do
+        expect(HashIncludingMatcher.new(b: 2, a: 1)).to eq("a" => 1, "b" => 2)
+      end
+
+      it "describes itself properly" do
+        expect(HashIncludingMatcher.new(a: 1).inspect).to eq "hash_including({\"a\"=>1})"
+      end
+
+      describe "success" do
+        it "matches the same hash" do
+          expect(HashIncludingMatcher.new("a" => 1, "b" => 2)).to eq("a" => 1, "b" => 2)
+        end
+
+        it "matches a hash with extra stuff" do
+          expect(HashIncludingMatcher.new(a: 1)).to eq("a" => 1, "b" => 2)
+        end
+
+        describe "when matching anythingized keys" do
+          let(:anything) { WebMock::Matchers::AnyArgMatcher.new(nil) }
+
+          it "matches an int against anything()" do
+            expect(HashIncludingMatcher.new(a: anything, b: 2)).to eq({'a' => 1, 'b' => 2})
+          end
+
+          it "matches a string against anything()" do
+            expect(HashIncludingMatcher.new(a: anything, b: 2)).to eq({'a' => "1", 'b' => 2})
+          end
+
+          it "matches if the key is present" do
+            expect(HashIncludingMatcher.new(a: anything)).to eq({'a' => 1, 'b' => 2})
+          end
+
+          it "matches if more keys are present" do
+            expect(HashIncludingMatcher.new(a: anything, b: anything)).to eq({'a' => 1, 'b' => 2, 'c' => 3})
+          end
+
+          it "matches if passed many keys and many key/value pairs" do
+            expect(HashIncludingMatcher.new(a: anything, b: anything, c: 3, e: 5)).to eq({'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5})
+          end
+        end
+
+        describe "when matching an empty hash" do
+          it "matches against any hash" do
+            expect(HashIncludingMatcher.new({})).to eq({a: 1, b: 2, c: 3})
+          end
+        end
+      end
+
+      describe "failing" do
+        it "does not match a non-hash" do
+          expect(HashIncludingMatcher.new(a: 1)).not_to eq 1
+        end
+
+        it "does not match a hash with a missing key" do
+          expect(HashIncludingMatcher.new(a: 1)).not_to eq('b' => 2)
+        end
+
+        it "does not match an empty hash with a given key" do
+          expect(HashIncludingMatcher.new(a: 1)).not_to eq({})
+        end
+
+        it "does not match a hash with a missing key when one pair is matching" do
+          expect(HashIncludingMatcher.new(a: 1, b: 2)).not_to eq('b' => 2)
+        end
+
+        it "does not match a hash with an incorrect value" do
+          expect(HashIncludingMatcher.new(a: 1, b: 2)).not_to eq('a' => 1, 'b' => 3)
+        end
+
+        it "does not match when values are nil but keys are different" do
+          expect(HashIncludingMatcher.new(a: nil)).not_to eq('b' => nil)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/webmock-2.3.2/spec/unit/rack_response_spec.rb

@@ -0,0 +1,112 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe WebMock::RackResponse do
+  before :each do
+    @rack_response = WebMock::RackResponse.new(MyRackApp)
+  end
+
+  it "should hook up to a rack appliance" do
+    request = WebMock::RequestSignature.new(:get, 'www.example.com')
+    response = @rack_response.evaluate(request)
+
+    expect(response.status.first).to eq(200)
+    expect(response.body).to include('This is my root!')
+  end
+
+  it "should set the reason phrase based on the status code" do
+    request = WebMock::RequestSignature.new(:get, 'www.example.com')
+    response = @rack_response.evaluate(request)
+    expect(response.status).to eq([200, "OK"])
+
+    request = WebMock::RequestSignature.new(:get, 'www.example.com/error')
+    response = @rack_response.evaluate(request)
+    expect(response.status).to eq([500, "Internal Server Error"])
+  end
+
+  it "should behave correctly when the rack response is not a simple array of strings" do
+    request = WebMock::RequestSignature.new(:get, 'www.example.com/non_array_response')
+    response = @rack_response.evaluate(request)
+
+    expect(response.status.first).to eq(200)
+    expect(response.body).to include('This is not in an array!')
+  end
+
+  it "should shouldn't blow up when hitting a locked resource twice" do
+    @locked_rack_response = WebMock::RackResponse.new(MyLockedRackApp)
+    request = WebMock::RequestSignature.new(:get, 'www.example.com/locked')
+    @locked_rack_response.evaluate(request)
+    response2 = @locked_rack_response.evaluate(request)
+
+    expect(response2.body).to include('Single threaded response.')
+    expect(response2.status.first).to eq(200)
+  end
+
+  it "should send along params" do
+    request = WebMock::RequestSignature.new(:get, 'www.example.com/greet?name=Johnny')
+
+    response = @rack_response.evaluate(request)
+
+    expect(response.status.first).to eq(200)
+    expect(response.body).to include('Hello, Johnny')
+  end
+
+  it "should send along POST params" do
+    request = WebMock::RequestSignature.new(:post, 'www.example.com/greet',
+      body: 'name=Jimmy'
+    )
+
+    response = @rack_response.evaluate(request)
+    expect(response.body).to include('Good to meet you, Jimmy!')
+  end
+
+  it "should send params with proper content length if params have non-ascii symbols" do
+    request = WebMock::RequestSignature.new(:post, 'www.example.com/greet',
+      body: 'name=Олег'
+    )
+
+    response = @rack_response.evaluate(request)
+    expect(response.body).to include('Good to meet you, Олег!')
+  end
+
+  describe 'rack error output' do
+    before :each do
+      @original_stderr = $stderr
+      $stderr = StringIO.new
+    end
+
+    after :each do
+      $stderr = @original_stderr
+    end
+
+    it 'should behave correctly when an app uses rack.errors' do
+      request = WebMock::RequestSignature.new(:get, 'www.example.com/error')
+
+      expect { @rack_response.evaluate(request) }.to_not raise_error
+      expect($stderr.length).to_not eq 0
+    end
+  end
+
+  describe 'basic auth request' do
+    before :each do
+      @rack_response_with_basic_auth = WebMock::RackResponse.new(
+        Rack::Auth::Basic.new(MyRackApp) do |username, password|
+          username == 'username' && password == 'password'
+        end
+      )
+    end
+    it 'should be failure when wrong credentials' do
+      request = WebMock::RequestSignature.new(:get, 'foo:bar@www.example.com')
+      response = @rack_response_with_basic_auth.evaluate(request)
+      expect(response.status.first).to eq(401)
+      expect(response.body).not_to include('This is my root!')
+    end
+
+    it 'should be success when valid credentials' do
+      request = WebMock::RequestSignature.new(:get, 'username:password@www.example.com')
+      response = @rack_response_with_basic_auth.evaluate(request)
+      expect(response.status.first).to eq(200)
+      expect(response.body).to include('This is my root!')
+    end
+  end
+end