vagrant-unbundled 2.0.0.1 → 2.0.1.0

data/vendor/bundle/ruby/2.4.0/gems/webmock-2.3.2/spec/acceptance/net_http/net_http_spec_helper.rb

@@ -0,0 +1,64 @@
+module NetHTTPSpecHelper
+  def http_request(method, uri, options = {}, &block)
+    begin
+      uri = URI.parse(uri)
+    rescue
+      uri = Addressable::URI.heuristic_parse(uri)
+    end
+    response = nil
+    clazz = Net::HTTP.const_get("#{method.to_s.capitalize}")
+    req = clazz.new("#{uri.path}#{uri.query ? '?' : ''}#{uri.query}", nil)
+    options[:headers].each do |k,v|
+      if v.is_a?(Array)
+        v.each_with_index do |e,i|
+          i == 0 ? (req[k] = e) : req.add_field(k, e)
+        end
+      else
+        req[k] = v
+      end
+    end if options[:headers]
+
+    if options[:basic_auth]
+      req.basic_auth(options[:basic_auth][0], options[:basic_auth][1])
+    end
+
+    http = Net::HTTP.new(uri.host, uri.port)
+    if uri.scheme == "https"
+      http.use_ssl = true
+      #1.9.1 has a bug with ssl_timeout
+      http.ssl_timeout = 20 unless RUBY_PLATFORM =~ /java/
+      http.open_timeout = 60
+      http.read_timeout = 60
+    end
+    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    response = http.start {|open_http|
+      open_http.request(req, options[:body], &block)
+    }
+    headers = {}
+    response.each_header {|name, value| headers[name] = value}
+    OpenStruct.new({
+      body: response.body,
+      headers: WebMock::Util::Headers.normalize_headers(headers),
+      status: response.code,
+      message: response.message
+    })
+  end
+
+  def client_timeout_exception_class
+    if defined?(Net::OpenTimeout)
+      Net::OpenTimeout
+    elsif defined?(Net::HTTP::OpenTimeout)
+      Net::HTTP::OpenTimeout
+    else
+      Timeout::Error
+    end
+  end
+
+  def connection_refused_exception_class
+    Errno::ECONNREFUSED
+  end
+
+  def http_library
+    :net_http
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/webmock-2.3.2/spec/acceptance/net_http/real_net_http_spec.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'rspec'
+require 'net/http'
+require 'net/https'
+require 'stringio'
+require 'acceptance/net_http/net_http_shared'
+require 'support/webmock_server'
+
+describe "Real Net:HTTP without webmock", without_webmock: true do
+  before(:all) do
+    raise "WebMock has no access here!!!" if defined?(WebMock::NetHTTPUtility)
+    WebMockServer.instance.start
+  end
+
+  after(:all) do
+    WebMockServer.instance.stop
+  end
+
+  it_should_behave_like "Net::HTTP"
+end

data/vendor/bundle/ruby/2.4.0/gems/webmock-2.3.2/spec/acceptance/patron/patron_spec.rb

@@ -0,0 +1,118 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'acceptance/webmock_shared'
+
+unless RUBY_PLATFORM =~ /java/
+  require 'acceptance/patron/patron_spec_helper'
+  require 'tmpdir'
+  require 'fileutils'
+
+  describe "Patron" do
+    include PatronSpecHelper
+
+    include_examples "with WebMock"
+
+    describe "when custom functionality is used" do
+      before(:each) do
+        @sess = Patron::Session.new
+        @sess.base_url = "http://www.example.com"
+      end
+
+      describe "file requests" do
+
+        before(:each) do
+          @dir_path = Dir.mktmpdir('webmock-')
+          @file_path = File.join(@dir_path, "webmock_temp_test_file")
+          FileUtils.rm_rf(@file_path) if File.exist?(@file_path)
+        end
+
+        after(:each) do
+          FileUtils.rm_rf(@dir_path) if File.exist?(@dir_path)
+        end
+
+        it "should work with get_file" do
+          stub_request(:get, "www.example.com").to_return(body: "abc")
+          @sess.get_file("/", @file_path)
+          expect(File.read(@file_path)).to eq("abc")
+        end
+
+        it "should raise same error as Patron if file is not readable for get request" do
+          stub_request(:get, "www.example.com")
+          File.open("/tmp/read_only_file", "w") do |tmpfile|
+            tmpfile.chmod(0400)
+          end
+          begin
+            expect {
+              @sess.get_file("/", "/tmp/read_only_file")
+            }.to raise_error(ArgumentError, "Unable to open specified file.")
+          ensure
+            File.unlink("/tmp/read_only_file")
+          end
+        end
+
+        it "should work with put_file" do
+          File.open(@file_path, "w") {|f| f.write "abc"}
+          stub_request(:put, "www.example.com").with(body: "abc")
+          @sess.put_file("/", @file_path)
+        end
+
+        it "should work with post_file" do
+          File.open(@file_path, "w") {|f| f.write "abc"}
+          stub_request(:post, "www.example.com").with(body: "abc")
+          @sess.post_file("/", @file_path)
+        end
+
+        it "should raise same error as Patron if file is not readable for post request" do
+          stub_request(:post, "www.example.com").with(body: "abc")
+          expect {
+            @sess.post_file("/", "/path/to/non/existing/file")
+          }.to raise_error(ArgumentError, "Unable to open specified file.")
+        end
+
+      end
+
+      describe "handling errors same way as patron" do
+        it "should raise error if put request has neither upload_data nor file_name" do
+          stub_request(:post, "www.example.com")
+          expect {
+            @sess.post("/", nil)
+          }.to raise_error(ArgumentError, "Must provide either data or a filename when doing a PUT or POST")
+        end
+      end
+
+      it "should work with WebDAV copy request" do
+        stub_request(:copy, "www.example.com/abc").with(headers: {'Destination' => "/def"})
+        @sess.copy("/abc", "/def")
+      end
+
+      if /^1\.9/ === RUBY_VERSION
+        describe "handling encoding same way as patron" do
+          around(:each) do |example|
+            @encoding = Encoding.default_internal
+            Encoding.default_internal = "UTF-8"
+            example.run
+            Encoding.default_internal = @encoding
+          end
+
+          it "should not encode body with default encoding" do
+            stub_request(:get, "www.example.com").
+              to_return(body: "Øl")
+
+            expect(@sess.get("").body.encoding).to eq(Encoding::ASCII_8BIT)
+            expect(@sess.get("").inspectable_body.encoding).to eq(Encoding::UTF_8)
+          end
+
+          it "should not encode body to default internal" do
+            stub_request(:get, "www.example.com").
+              to_return(headers: {'Content-Type' => 'text/html; charset=iso-8859-1'},
+                        body: "Øl".encode("iso-8859-1"))
+
+            expect(@sess.get("").body.encoding).to eq(Encoding::ASCII_8BIT)
+            expect(@sess.get("").decoded_body.encoding).to eq(Encoding.default_internal)
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/webmock-2.3.2/spec/acceptance/patron/patron_spec_helper.rb

@@ -0,0 +1,54 @@
+require 'ostruct'
+
+module PatronSpecHelper
+  def http_request(method, uri, options = {}, &block)
+    method = method.to_sym
+    uri = Addressable::URI.heuristic_parse(uri)
+    sess = Patron::Session.new
+    sess.base_url = "#{uri.omit(:path, :query).normalize.to_s}".gsub(/\/$/,"")
+
+    if options[:basic_auth]
+      sess.username = options[:basic_auth][0]
+      sess.password = options[:basic_auth][1]
+    end
+
+    sess.connect_timeout = 30
+    sess.timeout = 30
+    sess.max_redirects = 0
+    uri = "#{uri.path}#{uri.query ? '?' : ''}#{uri.query}"
+    uri.gsub!(' ','%20')
+    response = sess.request(method, uri, options[:headers] || {}, {
+      data: options[:body]
+    })
+    headers = {}
+    if response.headers
+      response.headers.each do |k,v|
+        v = v.join(", ") if v.is_a?(Array)
+        headers[k] = v
+      end
+    end
+
+    status_line_pattern = %r(\AHTTP/(\d+\.\d+)\s+(\d\d\d)\s*([^\r\n]+)?)
+    message = response.status_line.match(status_line_pattern)[3] || ""
+
+    OpenStruct.new({
+      body: response.body,
+      headers: WebMock::Util::Headers.normalize_headers(headers),
+      status: response.status.to_s,
+      message: message
+    })
+  end
+
+  def client_timeout_exception_class
+    Patron::TimeoutError
+  end
+
+  def connection_refused_exception_class
+    Patron::ConnectionFailed
+  end
+
+  def http_library
+    :patron
+  end
+
+end

data/vendor/bundle/ruby/2.4.0/gems/webmock-2.3.2/spec/acceptance/shared/allowing_and_disabling_net_connect.rb

@@ -0,0 +1,313 @@
+shared_context "allowing and disabling net connect" do |*adapter_info|
+  describe "when net connect" do
+    describe "is allowed", net_connect: true do
+      before(:each) do
+        WebMock.allow_net_connect!
+      end
+
+      it "should make a real web request if request is not stubbed" do
+        expect(http_request(:get, webmock_server_url).status).to eq("200")
+      end
+
+      it "should make a real https request if request is not stubbed" do
+        unless http_library == :httpclient
+          result = http_request(:get, "https://www.google.com/").body
+          if result.respond_to? :encode
+            result = result.encode(
+              'UTF-8',
+              'binary',
+              invalid: :replace,
+              undef: :replace,
+              replace: ''
+            )
+          end
+          expect(result).to match(/.*google.*/)
+        end
+      end
+
+      it "should return stubbed response if request was stubbed" do
+        stub_request(:get, "www.example.com").to_return(body: "abc")
+        expect(http_request(:get, "http://www.example.com/").body).to eq("abc")
+      end
+    end
+
+    describe "is not allowed" do
+      before(:each) do
+        WebMock.disable_net_connect!
+      end
+
+      it "should return stubbed response if request was stubbed" do
+        stub_request(:get, "www.example.com").to_return(body: "abc")
+        expect(http_request(:get, "http://www.example.com/").body).to eq("abc")
+      end
+
+      it "should return stubbed response if request with path was stubbed" do
+        stub_request(:get, "www.example.com/hello_world").to_return(body: "abc")
+        expect(http_request(:get, "http://www.example.com/hello_world").body).to eq("abc")
+      end
+
+      it "should raise exception if request was not stubbed" do
+        expect {
+          http_request(:get, "http://www.example.com/")
+        }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
+      end
+    end
+
+    describe "is not allowed with exception for localhost" do
+      before(:each) do
+        WebMock.disable_net_connect!(allow_localhost: true)
+      end
+
+      it "should return stubbed response if request was stubbed" do
+        stub_request(:get, "www.example.com").to_return(body: "abc")
+        expect(http_request(:get, "http://www.example.com/").body).to eq("abc")
+      end
+
+      it "should raise exception if request was not stubbed" do
+        expect {
+          http_request(:get, "http://www.example.com/")
+        }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
+      end
+
+      it "should make a real request to localhost" do
+        expect {
+          http_request(:get, "http://localhost:12345/")
+        }.to raise_error(connection_refused_exception_class)
+      end
+
+      it "should make a real request to 127.0.0.1" do
+        expect {
+          http_request(:get, "http://127.0.0.1:12345/")
+        }.to raise_error(connection_refused_exception_class)
+      end
+
+      it "should make a real request to 0.0.0.0" do
+        expect {
+          http_request(:get, "http://0.0.0.0:12345/")
+        }.to raise_error(connection_refused_exception_class)
+      end
+    end
+
+    describe "is not allowed, with exceptions" do
+      describe "allowing by host string" do
+        before :each do
+          WebMock.disable_net_connect!(allow: 'httpstat.us')
+        end
+
+        context "when the host is not allowed" do
+          it "should return stubbed response if request was stubbed" do
+            stub_request(:get, 'disallowed.example.com/foo').to_return(body: "abc")
+            expect(http_request(:get, 'http://disallowed.example.com/foo').body).to eq("abc")
+          end
+
+          it "should raise exception if request was not stubbed" do
+            expect {
+              http_request(:get, 'http://disallowed.example.com/')
+            }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://disallowed.example.com))
+          end
+        end
+
+        context "when the host is allowed" do
+          it "should return stubbed response if request was stubbed" do
+            stub_request(:get, 'httpstat.us/200').to_return(body: "abc")
+            expect(http_request(:get, "http://httpstat.us/200").body).to eq("abc")
+          end
+
+          # WARNING: this makes a real HTTP request!
+          it "should make a real request to allowed host", net_connect: true do
+            expect(http_request(:get, "http://httpstat.us/200").status).to eq('200')
+          end
+        end
+      end
+
+      describe "allowing by host:port string" do
+        def replace_with_different_port(uri)
+          uri.sub(%r{:(\d+)}){|m0, m1| ':' + ($~[1].to_i + 1).to_s }
+        end
+
+        let(:allowed_host_with_port) { WebMockServer.instance.host_with_port }
+        let(:disallowed_host_with_port) { replace_with_different_port(allowed_host_with_port) }
+
+        before :each do
+          WebMock.disable_net_connect!(allow: allowed_host_with_port)
+        end
+
+        context "when the host is not allowed" do
+          it "should return stubbed response if request was stubbed" do
+            request_url = "http://#{disallowed_host_with_port}/foo"
+            stub_request(:get, request_url).to_return(body: "abc")
+            expect(http_request(:get, request_url).body).to eq("abc")
+          end
+
+          it "should raise exception if request was not stubbed" do
+            request_url = "http://#{disallowed_host_with_port}/foo"
+            expect {
+              http_request(:get, request_url)
+            }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET #{request_url}))
+          end
+        end
+
+        context "when the host is allowed" do
+          it "should return stubbed response if request was stubbed" do
+            request_url = "http://#{allowed_host_with_port}/foo"
+            stub_request(:get, request_url).to_return(body: "abc")
+            expect(http_request(:get, request_url).body).to eq('abc')
+          end
+
+          it "should make a real request to allowed host", net_connect: true do
+            request_url = "http://#{allowed_host_with_port}/foo"
+            expect(http_request(:get, request_url).status).to eq('200')
+          end
+        end
+      end
+
+      describe "allowing by scheme:host string" do
+        before :each do
+          WebMock.disable_net_connect!(allow: 'https://www.google.pl')
+        end
+
+        context "when the host and scheme is not allowed" do
+          it "should return stubbed response if request was stubbed" do
+            stub_request(:get, 'https://disallowed.example.com/foo').to_return(body: "abc")
+            expect(http_request(:get, 'https://disallowed.example.com/foo').body).to eq("abc")
+          end
+
+          it "should raise exception if request was not stubbed" do
+            expect {
+              http_request(:get, 'https://disallowed.example.com/')
+            }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET https://disallowed.example.com))
+          end
+
+          it "should raise exception if request was made to different port" do
+            expect {
+              http_request(:get, 'https://www.google.pl:80/')
+            }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET https://www.google.pl:80))
+          end
+
+          it "should raise exception if request was made to different scheme" do
+            expect {
+              http_request(:get, 'http://www.google.pl/')
+            }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.google.pl))
+          end
+        end
+
+        context "when the host is allowed" do
+          it "should return stubbed response if request was stubbed" do
+            stub_request(:get, 'https://www.google.pl').to_return(body: "abc")
+            expect(http_request(:get, "https://www.google.pl/").body).to eq("abc")
+          end
+
+          it "should make a real request to allowed host with scheme", net_connect: true do
+            method = http_library == :httpclient ? :head : :get #https://github.com/nahi/httpclient/issues/299
+            expect(http_request(method, "https://www.google.pl/").status).to eq('200')
+          end
+
+          it "should make a real request to allowed host with scheme and port", net_connect: true do
+            method = http_library == :httpclient ? :head : :get
+            expect(http_request(method, "https://www.google.pl:443/").status).to eq('200')
+          end
+        end
+      end
+
+      describe "allowing by regular expression" do
+        before :each do
+          WebMock.disable_net_connect!(allow: %r{httpstat})
+        end
+
+        context "when the host is not allowed" do
+          it "should return stubbed response if request was stubbed" do
+            stub_request(:get, 'disallowed.example.com/foo').to_return(body: "abc")
+            expect(http_request(:get, 'http://disallowed.example.com/foo').body).to eq("abc")
+          end
+
+          it "should raise exception if request was not stubbed" do
+            expect {
+              http_request(:get, 'http://disallowed.example.com/')
+            }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://disallowed.example.com))
+          end
+        end
+
+        context "when the host is allowed" do
+          it "should return stubbed response if request was stubbed" do
+            stub_request(:get, 'httpstat.us/200').to_return(body: "abc")
+            expect(http_request(:get, "http://httpstat.us/200").body).to eq("abc")
+          end
+
+          # WARNING: this makes a real HTTP request!
+          it "should make a real request to allowed host", net_connect: true do
+            expect(http_request(:get, "http://httpstat.us/200").status).to eq('200')
+          end
+
+          it "should make a real request if request is allowed by path regexp and url contains default port", net_connect: true do
+            WebMock.disable_net_connect!(allow: %r{www.google.pl/webhp})
+            method = http_library == :httpclient ? :head : :get
+            expect(http_request(method, 'https://www.google.pl:443/webhp').status).to eq('200')
+          end
+        end
+      end
+
+      describe "allowing by a callable" do
+        before :each do
+          WebMock.disable_net_connect!(allow: lambda{|url| url.to_str.include?('httpstat') })
+        end
+
+        context "when the host is not allowed" do
+          it "should return stubbed response if request was stubbed" do
+            stub_request(:get, 'disallowed.example.com/foo').to_return(body: "abc")
+            expect(http_request(:get, 'http://disallowed.example.com/foo').body).to eq("abc")
+          end
+
+          it "should raise exception if request was not stubbed" do
+            expect {
+              http_request(:get, 'http://disallowed.example.com/')
+            }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://disallowed.example.com))
+          end
+        end
+
+        context "when the host is allowed" do
+          it "should return stubbed response if request was stubbed" do
+            stub_request(:get, 'httpstat.us/200').to_return(body: "abc")
+            expect(http_request(:get, "http://httpstat.us/200").body).to eq("abc")
+          end
+
+          # WARNING: this makes a real HTTP request!
+          it "should make a real request to allowed host", net_connect: true do
+            expect(http_request(:get, "http://httpstat.us/200").status).to eq('200')
+          end
+        end
+      end
+
+      describe "allowing by a list of the above" do
+        before :each do
+          WebMock.disable_net_connect!(allow: [lambda{|_| false }, %r{foobar}, 'httpstat.us'])
+        end
+
+        context "when the host is not allowed" do
+          it "should return stubbed response if request was stubbed" do
+            stub_request(:get, 'disallowed.example.com/foo').to_return(body: "abc")
+            expect(http_request(:get, 'http://disallowed.example.com/foo').body).to eq("abc")
+          end
+
+          it "should raise exception if request was not stubbed" do
+            expect {
+              http_request(:get, 'http://disallowed.example.com/')
+            }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://disallowed.example.com))
+          end
+        end
+
+        context "when the host is allowed" do
+          it "should return stubbed response if request was stubbed" do
+            stub_request(:get, 'httpstat.us/200').to_return(body: "abc")
+            expect(http_request(:get, "http://httpstat.us/200").body).to eq("abc")
+          end
+
+          # WARNING: this makes a real HTTP request!
+          it "should make a real request to allowed host", net_connect: true do
+            expect(http_request(:get, "http://httpstat.us/200").status).to eq('200')
+          end
+        end
+      end
+
+    end
+  end
+end