vagrant-unbundled 2.0.0.1 → 2.0.1.0

data/vendor/bundle/ruby/2.4.0/gems/webmock-2.3.2/spec/acceptance/typhoeus/typhoeus_hydra_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+require 'acceptance/webmock_shared'
+
+unless RUBY_PLATFORM =~ /java/
+  require 'acceptance/typhoeus/typhoeus_hydra_spec_helper'
+
+  describe "Typhoeus::Hydra" do
+    include TyphoeusHydraSpecHelper
+    let(:hydra) { Typhoeus::Hydra.new }
+
+    before do
+      Typhoeus::Expectation.clear
+    end
+
+    include_context "with WebMock"
+
+    describe "Typhoeus::Hydra features" do
+      before(:each) do
+        WebMock.disable_net_connect!
+        WebMock.reset!
+      end
+
+      describe "supposed response fields" do
+        it "present" do
+          stub_request(:get, "http://www.example.com").to_return(headers: {'X-Test' => '1'})
+          response = Typhoeus.get("http://www.example.com")
+          expect(response.code).not_to be_nil
+          expect(response.status_message).not_to be_nil
+          expect(response.body).not_to be_nil
+          expect(response.headers).not_to be_nil
+          expect(response.effective_url).not_to be_nil
+        end
+      end
+
+      describe "when params are used" do
+        it "should take into account params for POST request" do
+          stub_request(:post, "www.example.com/?hello=world").with(query: {hello: 'world'})
+          request = Typhoeus::Request.new("http://www.example.com", method: :post, params: {hello: 'world'})
+          hydra.queue(request)
+          hydra.run
+        end
+
+        it "should take into account body for POST request" do
+          stub_request(:post, "www.example.com").with(body: {hello: 'world'})
+          response = Typhoeus.post("http://www.example.com", method: :post, body: {hello: 'world'})
+          expect(response.code).to eq(200)
+        end
+
+        it "should take into account params for GET request" do
+          stub_request(:get, "http://www.example.com/?hello=world").to_return({})
+          request = Typhoeus::Request.new("http://www.example.com/?hello=world", method: :get)
+          hydra.queue(request)
+          hydra.run
+        end
+      end
+
+      describe "timeouts" do
+        it "should support native typhoeus timeouts" do
+          stub_request(:any, "example.com").to_timeout
+
+          request = Typhoeus::Request.new("http://example.com", method: :get)
+          hydra.queue(request)
+          hydra.run
+
+          expect(request.response).to be_timed_out
+        end
+      end
+
+      describe "callbacks" do
+        before(:each) do
+          @request = Typhoeus::Request.new("http://example.com")
+        end
+
+        it "should call on_complete with 2xx response" do
+          body = "on_success fired"
+          stub_request(:any, "example.com").to_return(body: body)
+
+          test = nil
+          Typhoeus.on_complete do |c|
+            test = c.body
+          end
+          hydra.queue @request
+          hydra.run
+          expect(test).to eq(body)
+        end
+
+        it "should call on_complete with 5xx response" do
+          response_code = 599
+          stub_request(:any, "example.com").to_return(status: [response_code, "Server On Fire"])
+
+          test = nil
+          Typhoeus.on_complete do |c|
+            test = c.code
+          end
+          hydra.queue @request
+          hydra.run
+          expect(test).to eq(response_code)
+        end
+
+        it "should call on_body with 2xx response" do
+          body = "on_body fired"
+          stub_request(:any, "example.com").to_return(body: body)
+
+          test_body = nil
+          test_complete = nil
+          skip("This test requires a newer version of Typhoeus") unless @request.respond_to?(:on_body)
+          @request.on_body do |body_chunk, response|
+            test_body = body_chunk
+          end
+          @request.on_complete do |response|
+            test_complete = response.body
+          end
+          hydra.queue @request
+          hydra.run
+          expect(test_body).to eq(body)
+          expect(test_complete).to eq("")
+        end
+
+        it "should call on_headers with 2xx response" do
+          body = "on_headers fired"
+          stub_request(:any, "example.com").to_return(body: body, headers: {'X-Test' => '1'})
+
+          test_headers = nil
+          skip("This test requires a newer version of Typhoeus") unless @request.respond_to?(:on_headers)
+          @request.on_headers do |response|
+            test_headers = response.headers
+          end
+          hydra.queue @request
+          hydra.run
+          expect(test_headers).to include('X-Test' => '1')
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/webmock-2.3.2/spec/acceptance/typhoeus/typhoeus_hydra_spec_helper.rb

@@ -0,0 +1,60 @@
+require 'ostruct'
+
+module TyphoeusHydraSpecHelper
+  class FakeTyphoeusHydraTimeoutError < StandardError; end
+  class FakeTyphoeusHydraConnectError < StandardError; end
+
+
+  def http_request(method, uri, options = {}, &block)
+    uri.gsub!(" ", "%20") #typhoeus doesn't like spaces in the uri
+    request_options =  {
+      method: method,
+      body: options[:body],
+      headers: options[:headers],
+      timeout: 25000
+    }
+    if options[:basic_auth]
+      request_options[:userpwd] = options[:basic_auth].join(':')
+    end
+    request = Typhoeus::Request.new(uri, request_options)
+
+    hydra = Typhoeus::Hydra.new
+    hydra.queue(request)
+    hydra.run
+
+    response = request.response
+    raise FakeTyphoeusHydraConnectError.new if response.return_code == :couldnt_connect
+    raise FakeTyphoeusHydraTimeoutError.new if response.timed_out?
+    OpenStruct.new({
+      body: response.body,
+      headers: WebMock::Util::Headers.normalize_headers(join_array_values(response.headers)),
+      status: response.code.to_s,
+      message: response.status_message
+    })
+  end
+
+  def join_array_values(hash)
+    joined = {}
+    if hash
+     hash.each do |k,v|
+       v = v.join(", ") if v.is_a?(Array)
+       joined[k] = v
+     end
+    end
+    joined
+  end
+
+
+  def client_timeout_exception_class
+    FakeTyphoeusHydraTimeoutError
+  end
+
+  def connection_refused_exception_class
+    FakeTyphoeusHydraConnectError
+  end
+
+  def http_library
+    :typhoeus
+  end
+
+end

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+require 'acceptance/shared/enabling_and_disabling_webmock'
+require 'acceptance/shared/returning_declared_responses'
+require 'acceptance/shared/callbacks'
+require 'acceptance/shared/request_expectations'
+require 'acceptance/shared/stubbing_requests'
+require 'acceptance/shared/allowing_and_disabling_net_connect'
+require 'acceptance/shared/precedence_of_stubs'
+require 'acceptance/shared/complex_cross_concern_behaviors'
+
+unless defined? SAMPLE_HEADERS
+  SAMPLE_HEADERS = { "Content-Length" => "8888", "Accept" => "application/json" }
+  ESCAPED_PARAMS = "x=ab%20c&z=%27Stop%21%27%20said%20Fred%20m"
+  NOT_ESCAPED_PARAMS = "z='Stop!' said Fred m&x=ab c"
+end
+
+shared_examples "with WebMock" do |*adapter_info|
+  describe "with WebMock" do
+    let(:webmock_server_url) {"http://#{WebMockServer.instance.host_with_port}/"}
+    before(:each) do
+      WebMock.disable_net_connect!
+      WebMock.reset!
+    end
+
+    include_context "allowing and disabling net connect", *adapter_info
+
+    include_context "stubbing requests", *adapter_info
+
+    include_context "declared responses", *adapter_info
+
+    include_context "precedence of stubs", *adapter_info
+
+    include_context "request expectations", *adapter_info
+
+    include_context "callbacks", *adapter_info
+
+    include_context "enabled and disabled webmock", *adapter_info
+
+    include_context "complex cross-concern behaviors", *adapter_info
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/webmock-2.3.2/spec/fixtures/test.txt

@@ -0,0 +1 @@
+test

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

@@ -0,0 +1,84 @@
+require "spec_helper"
+
+# Borrowed from Bundler
+# https://github.com/carlhuda/bundler/blob/1-0-stable/spec/quality_spec.rb
+# Portions copyright (c) 2010 Andre Arko
+# Portions copyright (c) 2009 Engine Yard
+
+# MIT License
+
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+describe "The library itself" do
+  def check_for_tab_characters(filename)
+    failing_lines = []
+    File.readlines(filename).each_with_index do |line,number|
+      failing_lines << number + 1 if line =~ /\t/
+    end
+
+    unless failing_lines.empty?
+      "#{filename} has tab characters on lines #{failing_lines.join(', ')}"
+    end
+  end
+
+  def check_for_extra_spaces(filename)
+    failing_lines = []
+    File.readlines(filename).each_with_index do |line,number|
+      next if line =~ /^\s+#.*\s+\n$/
+      failing_lines << number + 1 if line =~ /\s+\n$/
+    end
+
+    unless failing_lines.empty?
+      "#{filename} has spaces on the EOL on lines #{failing_lines.join(', ')}"
+    end
+  end
+
+  RSpec::Matchers.define :be_well_formed do
+    failure_message do |actual|
+      actual.join("\n")
+    end
+
+    match do |actual|
+      actual.empty?
+    end
+  end
+
+  it "has no malformed whitespace" do
+    error_messages = []
+    Dir.chdir(File.expand_path("../..", __FILE__)) do
+      `git ls-files`.split("\n").each do |filename|
+        next if filename =~ /\.gitmodules|fixtures/
+        error_messages << check_for_tab_characters(filename)
+        error_messages << check_for_extra_spaces(filename)
+      end
+    end
+    expect(error_messages.compact).to be_well_formed
+  end
+
+  it "can still be built" do
+    Dir.chdir(File.expand_path('../../', __FILE__)) do
+      `gem build webmock.gemspec`
+      expect($?).to eq(0)
+
+      # clean up the .gem generated
+      system("rm webmock-#{WebMock.version}.gem")
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'httpclient'
+unless RUBY_PLATFORM =~ /java/
+  require 'curb'
+  require 'patron'
+  require 'em-http'
+  require 'typhoeus'
+end
+if RUBY_PLATFORM =~ /java/
+  require 'manticore'
+end
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rspec'
+
+require 'webmock/rspec'
+
+require 'support/network_connection'
+require 'support/webmock_server'
+require 'support/my_rack_app'
+require 'support/failures'
+
+CURL_EXAMPLE_OUTPUT_PATH = File.expand_path('../support/example_curl_output.txt', __FILE__)
+
+RSpec.configure do |config|
+  no_network_connection = ENV["NO_CONNECTION"] || ! NetworkConnection.is_network_available?
+  if no_network_connection
+    warn("No network connectivity. Only examples which do not make real network connections will run.")
+    config.filter_run_excluding net_connect: true
+  end
+
+  config.filter_run_excluding without_webmock: true
+
+  config.before(:suite) do
+    WebMockServer.instance.start unless WebMockServer.instance.started
+  end
+
+  config.after(:suite) do
+    WebMockServer.instance.stop
+  end
+
+  config.filter_run focus: true
+  config.run_all_when_everything_filtered = true
+
+  config.include Failures
+end
+

data/vendor/bundle/ruby/2.4.0/gems/webmock-2.3.2/spec/support/example_curl_output.txt

@@ -0,0 +1,22 @@
+HTTP/1.1 202 OK
+Content-Type: text/html; charset=UTF-8
+Connection: Keep-Alive
+Date: Sat, 23 Jan 2010 01:01:05 GMT
+Content-Length: 419
+Accept: image/jpeg
+Accept: image/png
+
+<HTML>
+<HEAD>
+  <TITLE>Example Web Page</TITLE>
+</HEAD>
+<body>
+<p>You have reached this web page by typing &quot;example.com&quot;,
+&quot;example.net&quot;,
+  or &quot;example.org&quot; into your web browser.</p>
+<p>These domain names are reserved for use in documentation and are not available
+  for registration. See <a href="http://www.rfc-editor.org/rfc/rfc2606.txt">RFC
+  2606</a>, Section 3.</p>
+</BODY>
+</HTML>
+

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

@@ -0,0 +1,9 @@
+module Failures
+  def fail()
+  raise_error(RSpec::Expectations::ExpectationNotMetError)
+  end
+
+  def fail_with(message)
+    raise_error(RSpec::Expectations::ExpectationNotMetError, message)
+  end
+end

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

@@ -0,0 +1,53 @@
+require 'rack'
+
+class MyRackApp
+  class NonArrayResponse
+    # The rack response body need not implement #join,
+    # but it must implement #each.  It need not be an Array.
+    # ActionDispatch::Response, for example, exercises that fact.
+    # See: http://rack.rubyforge.org/doc/SPEC.html
+
+    def each(*args, &blk)
+      ["This is not in an array!"].each(*args, &blk)
+    end
+  end
+
+  def self.call(env)
+    case env.values_at('REQUEST_METHOD', 'PATH_INFO')
+      when ['GET', '/']
+        [200, {}, ["This is my root!"]]
+      when ['GET', '/greet']
+        name = env['QUERY_STRING'][/name=([^&]*)/, 1] || "World"
+        [200, {}, ["Hello, #{name}"]]
+      when ['GET', '/non_array_response']
+        [200, {}, NonArrayResponse.new]
+      when ['GET', '/locked']
+        [200, {}, ["Single threaded response."]]
+      when ['POST', '/greet']
+        name = env["rack.input"].read(env["CONTENT_LENGTH"])
+        name = name.force_encoding("UTF-8") if name.respond_to? :force_encoding
+        name = name[/name=([^&]*)/, 1] || "World"
+        [200, {}, ["Good to meet you, #{name}!"]]
+      when ['GET', '/compute']
+        if env['SERVER_PORT'] == 80 && env["SCRIPT_NAME"] == ""
+          [200, {}, [""]]
+        else
+          [401, {}, [""]]
+        end
+      when ['GET', '/error']
+        env['rack.errors'].puts('Error!')
+        [500, {}, ['']]
+      else
+        [404, {}, ['']]
+    end
+  end
+end
+
+class MyLockedRackApp
+  MUTEX = Mutex.new
+
+  def self.call(env)
+    lock = Rack::Lock.new(MyRackApp, MUTEX)
+    lock.call(env)
+  end
+end