vagrant-unbundled 2.0.0.1 → 2.0.1.0

data/vendor/bundle/ruby/2.4.0/gems/webmock-2.3.2/Rakefile

@@ -0,0 +1,30 @@
+#!/usr/bin/env rake
+
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = ["-c", "-f progress", "-r ./spec/spec_helper.rb"]
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+RSpec::Core::RakeTask.new(:spec_http_without_webmock) do |t|
+  t.rspec_opts = ["-c", "-f progress", "-r ./spec/acceptance/net_http/real_net_http_spec.rb"]
+  t.pattern = 'spec/acceptance/net_http/real_net_http_spec.rb'
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.test_files = FileList["test/**/*.rb"].exclude("test/test_helper.rb")
+  test.verbose = false
+  test.warning = false
+end
+
+Rake::TestTask.new(:minitest) do |test|
+  test.test_files = FileList["minitest/**/*.rb"].exclude("test/test_helper.rb")
+  test.verbose = false
+  test.warning = false
+end
+
+task default: [:spec, :spec_http_without_webmock, :test, :minitest]

data/vendor/bundle/ruby/2.4.0/gems/webmock-2.3.2/lib/webmock/api.rb

@@ -0,0 +1,97 @@
+module WebMock
+  module API
+    extend self
+
+    def stub_request(method, uri)
+      WebMock::StubRegistry.instance.
+        register_request_stub(WebMock::RequestStub.new(method, uri))
+    end
+
+    alias_method :stub_http_request, :stub_request
+
+    def a_request(method, uri)
+      WebMock::RequestPattern.new(method, uri)
+    end
+
+    class << self
+      alias :request :a_request
+    end
+
+    def assert_requested(*args, &block)
+      if not args[0].is_a?(WebMock::RequestStub)
+        args = convert_uri_method_and_options_to_request_and_options(args[0], args[1], args[2], &block)
+      elsif block
+        raise ArgumentError, "assert_requested with a stub object, doesn't accept blocks"
+      end
+      assert_request_requested(*args)
+    end
+
+    def assert_not_requested(*args, &block)
+      if not args[0].is_a?(WebMock::RequestStub)
+        args = convert_uri_method_and_options_to_request_and_options(args[0], args[1], args[2], &block)
+      elsif block
+        raise ArgumentError, "assert_not_requested with a stub object, doesn't accept blocks"
+      end
+      assert_request_not_requested(*args)
+    end
+    alias refute_requested assert_not_requested
+
+    # Similar to RSpec::Mocks::ArgumentMatchers#hash_including()
+    #
+    # Matches a hash that includes the specified key(s) or key/value pairs.
+    # Ignores any additional keys.
+    #
+    # @example
+    #
+    #   object.should_receive(:message).with(hash_including(:key => val))
+    #   object.should_receive(:message).with(hash_including(:key))
+    #   object.should_receive(:message).with(hash_including(:key, :key2 => val2))
+    def hash_including(*args)
+      if defined?(super)
+        super
+      else
+        WebMock::Matchers::HashIncludingMatcher.new(anythingize_lonely_keys(*args))
+      end
+    end
+
+    def remove_request_stub(stub)
+      WebMock::StubRegistry.instance.remove_request_stub(stub)
+    end
+
+    private
+
+    def convert_uri_method_and_options_to_request_and_options(method, uri, options, &block)
+      options ||= {}
+      options_for_pattern = options.dup
+      [:times, :at_least_times, :at_most_times].each { |key| options_for_pattern.delete(key) }
+      request = WebMock::RequestPattern.new(method, uri, options_for_pattern)
+      request = request.with(&block) if block
+      [request, options]
+    end
+
+    def assert_request_requested(request, options = {})
+      times = options.delete(:times)
+      at_least_times = options.delete(:at_least_times)
+      at_most_times  = options.delete(:at_most_times)
+      times = 1 if times.nil? && at_least_times.nil? && at_most_times.nil?
+      verifier = WebMock::RequestExecutionVerifier.new(request, times, at_least_times, at_most_times)
+      WebMock::AssertionFailure.failure(verifier.failure_message) unless verifier.matches?
+    end
+
+    def assert_request_not_requested(request, options = {})
+      times = options.delete(:times)
+      at_least_times = options.delete(:at_least_times)
+      at_most_times  = options.delete(:at_most_times)
+      verifier = WebMock::RequestExecutionVerifier.new(request, times, at_least_times, at_most_times)
+      WebMock::AssertionFailure.failure(verifier.failure_message_when_negated) unless verifier.does_not_match?
+    end
+
+    #this is a based on RSpec::Mocks::ArgumentMatchers#anythingize_lonely_keys
+    def anythingize_lonely_keys(*args)
+      hash = args.last.class == Hash ? args.delete_at(-1) : {}
+      args.each { | arg | hash[arg] =  WebMock::Matchers::AnyArgMatcher.new(nil) }
+      hash
+    end
+
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/webmock-2.3.2/lib/webmock/assertion_failure.rb

@@ -0,0 +1,11 @@
+module WebMock
+  class AssertionFailure
+    @error_class = RuntimeError
+    class << self
+      attr_accessor :error_class
+      def failure(message)
+        raise @error_class.new(message)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/webmock-2.3.2/lib/webmock/callback_registry.rb

@@ -0,0 +1,35 @@
+module WebMock
+  class CallbackRegistry
+    @@callbacks = []
+
+    def self.add_callback(options, block)
+      @@callbacks << {options: options, block: block}
+    end
+
+    def self.callbacks
+      @@callbacks
+    end
+
+    def self.invoke_callbacks(options, request_signature, response)
+      return if @@callbacks.empty?
+      CallbackRegistry.callbacks.each do |callback|
+        except = callback[:options][:except]
+        real_only = callback[:options][:real_requests_only]
+        unless except && except.include?(options[:lib])
+          if !real_only || options[:real_request]
+            callback[:block].call(request_signature, response)
+          end
+        end
+      end
+    end
+
+    def self.reset
+      @@callbacks = []
+    end
+
+    def self.any_callbacks?
+      !@@callbacks.empty?
+    end
+
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/webmock-2.3.2/lib/webmock/config.rb

@@ -0,0 +1,18 @@
+module WebMock
+  class Config
+    include Singleton
+
+    def initialize
+      @show_stubbing_instructions = true
+      @show_body_diff = true
+    end
+
+    attr_accessor :allow_net_connect
+    attr_accessor :allow_localhost
+    attr_accessor :allow
+    attr_accessor :net_http_connect_on_start
+    attr_accessor :show_stubbing_instructions
+    attr_accessor :query_values_notation
+    attr_accessor :show_body_diff
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/webmock-2.3.2/lib/webmock/cucumber.rb

@@ -0,0 +1,10 @@
+require 'webmock'
+require 'webmock/rspec/matchers'
+
+WebMock.enable!
+
+World(WebMock::API, WebMock::Matchers)
+
+After do
+  WebMock.reset!
+end

data/vendor/bundle/ruby/2.4.0/gems/webmock-2.3.2/lib/webmock/deprecation.rb

@@ -0,0 +1,9 @@
+module WebMock
+  class Deprecation
+    class << self
+      def warning(message)
+        warn "WebMock deprecation warning: #{message}"
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/webmock-2.3.2/lib/webmock/errors.rb

@@ -0,0 +1,17 @@
+module WebMock
+
+  class NetConnectNotAllowedError < Exception
+    def initialize(request_signature)
+      request_signature_snippet = RequestSignatureSnippet.new(request_signature)
+      text = [
+        "Real HTTP connections are disabled. Unregistered request: #{request_signature}",
+        request_signature_snippet.stubbing_instructions,
+        request_signature_snippet.request_stubs,
+        "="*60
+      ].compact.join("\n\n")
+      super(text)
+    end
+
+  end
+
+end

data/vendor/bundle/ruby/2.4.0/gems/webmock-2.3.2/lib/webmock/http_lib_adapters/curb_adapter.rb

@@ -0,0 +1,337 @@
+begin
+  require 'curb'
+rescue LoadError
+  # curb not found
+end
+
+if defined?(Curl)
+  WebMock::VersionChecker.new('Curb', Curl::CURB_VERSION, '0.7.16', '0.9.1', ['0.8.7']).check_version!
+
+  module WebMock
+    module HttpLibAdapters
+      class CurbAdapter < HttpLibAdapter
+        adapter_for :curb
+
+        OriginalCurlEasy = Curl::Easy unless const_defined?(:OriginalCurlEasy)
+
+        def self.enable!
+          Curl.send(:remove_const, :Easy)
+          Curl.send(:const_set, :Easy, Curl::WebMockCurlEasy)
+        end
+
+        def self.disable!
+          Curl.send(:remove_const, :Easy)
+          Curl.send(:const_set, :Easy, OriginalCurlEasy)
+        end
+
+        # Borrowed from Patron:
+        # http://github.com/toland/patron/blob/master/lib/patron/response.rb
+        def self.parse_header_string(header_string)
+          status, headers = nil, {}
+
+          header_string.split(/\r\n/).each do |header|
+            if header =~ %r|^HTTP/1.[01] \d\d\d (.*)|
+              status = $1
+            else
+              parts = header.split(':', 2)
+              unless parts.empty?
+                parts[1].strip! unless parts[1].nil?
+                if headers.has_key?(parts[0])
+                  headers[parts[0]] = [headers[parts[0]]] unless headers[parts[0]].kind_of? Array
+                  headers[parts[0]] << parts[1]
+                else
+                  headers[parts[0]] = parts[1]
+                end
+              end
+            end
+          end
+
+          return status, headers
+        end
+      end
+    end
+  end
+
+  module Curl
+    class WebMockCurlEasy < Curl::Easy
+
+      def curb_or_webmock
+        request_signature = build_request_signature
+        WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
+
+        if webmock_response = WebMock::StubRegistry.instance.response_for_request(request_signature)
+          build_curb_response(webmock_response)
+          WebMock::CallbackRegistry.invoke_callbacks(
+            {lib: :curb}, request_signature, webmock_response)
+          invoke_curb_callbacks
+          true
+        elsif WebMock.net_connect_allowed?(request_signature.uri)
+          res = yield
+          if WebMock::CallbackRegistry.any_callbacks?
+            webmock_response = build_webmock_response
+            WebMock::CallbackRegistry.invoke_callbacks(
+              {lib: :curb, real_request: true}, request_signature,
+                webmock_response)
+          end
+          res
+        else
+          raise WebMock::NetConnectNotAllowedError.new(request_signature)
+        end
+      end
+
+      def build_request_signature
+        method = @webmock_method.to_s.downcase.to_sym
+
+        uri = WebMock::Util::URI.heuristic_parse(self.url)
+        uri.path = uri.normalized_path.gsub("[^:]//","/")
+
+        headers = headers_as_hash(self.headers).merge(basic_auth_headers)
+
+        request_body = case method
+        when :post, :patch
+          self.post_body || @post_body
+        when :put
+          @put_data
+        else
+          nil
+        end
+
+        if defined?( @on_debug )
+          @on_debug.call("Trying 127.0.0.1...\r\n", 0)
+          @on_debug.call('Connected to ' + uri.hostname + "\r\n", 0)
+          @debug_method = method.upcase
+          @debug_path = uri.path
+          @debug_host = uri.hostname
+          http_request = ["#{@debug_method} #{@debug_path} HTTP/1.1"]
+          http_request << "Host: #{uri.hostname}"
+          headers.each do |name, value|
+            http_request << "#{name}: #{value}"
+          end
+          @on_debug.call(http_request.join("\r\n") + "\r\n\r\n", 2)
+          if request_body
+            @on_debug.call(request_body + "\r\n", 4)
+            @on_debug.call(
+              "upload completely sent off: #{request_body.bytesize}"\
+              " out of #{request_body.bytesize} bytes\r\n", 0
+            )
+          end
+        end
+
+        request_signature = WebMock::RequestSignature.new(
+          method,
+          uri.to_s,
+          body: request_body,
+          headers: headers
+        )
+        request_signature
+      end
+
+      def headers_as_hash(headers)
+        if headers.is_a?(Array)
+          headers.inject({}) {|hash, header|
+            name, value = header.split(":").map(&:strip)
+            hash[name] = value
+            hash
+          }
+        else
+          headers
+        end
+      end
+
+      def basic_auth_headers
+        if self.username
+          {'Authorization' => WebMock::Util::Headers.basic_auth_header(self.username, self.password)}
+        else
+          {}
+        end
+      end
+
+      def build_curb_response(webmock_response)
+        raise Curl::Err::TimeoutError if webmock_response.should_timeout
+        webmock_response.raise_error_if_any
+
+        @body_str = webmock_response.body
+        @response_code = webmock_response.status[0]
+
+        @header_str = "HTTP/1.1 #{webmock_response.status[0]} #{webmock_response.status[1]}\r\n"
+
+        @on_debug.call(@header_str, 1) if defined?( @on_debug )
+
+        if webmock_response.headers
+          @header_str << webmock_response.headers.map do |k,v|
+            header = "#{k}: #{v.is_a?(Array) ? v.join(", ") : v}"
+            @on_debug.call(header + "\r\n", 1) if defined?( @on_debug )
+            header
+          end.join("\r\n")
+          @on_debug.call("\r\n", 1) if defined?( @on_debug )
+
+          location = webmock_response.headers['Location']
+          if self.follow_location? && location
+            @last_effective_url = location
+            webmock_follow_location(location)
+          end
+
+          @content_type = webmock_response.headers["Content-Type"]
+          @transfer_encoding = webmock_response.headers["Transfer-Encoding"]
+        end
+
+        @last_effective_url ||= self.url
+      end
+
+      def webmock_follow_location(location)
+        first_url = self.url
+        self.url = location
+
+        curb_or_webmock do
+          send( "http_#{@webmock_method}_without_webmock" )
+        end
+
+        self.url = first_url
+      end
+
+      def invoke_curb_callbacks
+        @on_progress.call(0.0,1.0,0.0,1.0) if defined?( @on_progress )
+        self.header_str.lines.each { |header_line| @on_header.call header_line } if defined?( @on_header )
+        if defined?( @on_body )
+          if chunked_response?
+            self.body_str.each do |chunk|
+              @on_body.call(chunk)
+            end
+          else
+            @on_body.call(self.body_str)
+          end
+        end
+        @on_complete.call(self) if defined?( @on_complete )
+
+        case response_code
+        when 200..299
+          @on_success.call(self) if defined?( @on_success )
+        when 400..499
+          @on_missing.call(self, self.response_code) if defined?( @on_missing )
+        when 500..599
+          @on_failure.call(self, self.response_code) if defined?( @on_failure )
+        end
+      end
+
+      def chunked_response?
+        defined?( @transfer_encoding ) && @transfer_encoding == 'chunked' && self.body_str.respond_to?(:each)
+      end
+
+      def build_webmock_response
+        status, headers =
+         WebMock::HttpLibAdapters::CurbAdapter.parse_header_string(self.header_str)
+
+        if defined?( @on_debug )
+          http_response = ["HTTP/1.0 #{@debug_method} #{@debug_path}"]
+          headers.each do |name, value|
+            http_response << "#{name}: #{value}"
+          end
+          http_response << self.body_str
+          @on_debug.call(http_response.join("\r\n") + "\r\n", 3)
+          @on_debug.call("Connection #0 to host #{@debug_host} left intact\r\n", 0)
+        end
+
+        webmock_response = WebMock::Response.new
+        webmock_response.status = [self.response_code, status]
+        webmock_response.body = self.body_str
+        webmock_response.headers = headers
+        webmock_response
+      end
+
+      ###
+      ### Mocks of Curl::Easy methods below here.
+      ###
+
+      def http(method)
+        @webmock_method = method
+        super
+      end
+
+      %w[ get head delete ].each do |verb|
+        define_method "http_#{verb}" do
+          @webmock_method = verb
+          super()
+        end
+      end
+
+      def http_put data = nil
+        @webmock_method = :put
+        @put_data = data if data
+        super
+      end
+      alias put http_put
+
+      def http_post *data
+        @webmock_method = :post
+        @post_body = data.join('&') if data && !data.empty?
+        super
+      end
+      alias post http_post
+
+      def perform
+        @webmock_method ||= :get
+        curb_or_webmock { super }
+      end
+
+      def put_data= data
+        @webmock_method = :put
+        @put_data = data
+        super
+      end
+
+      def post_body= data
+        @webmock_method = :post
+        super
+      end
+
+      def delete= value
+        @webmock_method = :delete if value
+        super
+      end
+
+      def head= value
+        @webmock_method = :head if value
+        super
+      end
+
+      def verbose=(verbose)
+        @verbose = verbose
+      end
+
+      def verbose?
+        @verbose ||= false
+      end
+
+      def body_str
+        @body_str ||= super
+      end
+      alias body body_str
+
+      def response_code
+        @response_code ||= super
+      end
+
+      def header_str
+        @header_str ||= super
+      end
+      alias head header_str
+
+      def last_effective_url
+        @last_effective_url ||= super
+      end
+
+      def content_type
+        @content_type ||= super
+      end
+
+      %w[ success failure missing header body complete progress debug ].each do |callback|
+        class_eval <<-METHOD, __FILE__, __LINE__
+          def on_#{callback} &block
+            @on_#{callback} = block
+            super
+          end
+        METHOD
+      end
+    end
+  end
+end