webmock 1.8.6 → 3.14.0

data/Rakefile

@@ -1,65 +1,38 @@
-#!/usr/bin/env rake
-
 require 'bundler'
 Bundler::GemHelper.install_tasks
 
-namespace :rvm do
-  desc 'Run specs against 1.8.6, REE, 1.8.7, 1.9.2 and jRuby'
-  task :specs do
-    # JCF: I'd love to be able to use RVM's `rvm {rubies} specs` command but
-    # the require tests in spec/other_net_http_libs_spec.rb break when doing
-    # so.
-    spec_files = Dir[File.dirname(__FILE__) + '/spec/**/*_spec.rb'].join(' ')
-    sh "rvm 1.8.6@webmock,ree@webmock,1.8.7@webmock,1.9.2@webmock,jruby@webmock exec rspec #{spec_files}"
-  end
-end
-
 require "rspec/core/rake_task"
 RSpec::Core::RakeTask.new(:spec) do |t|
-  t.rspec_opts = ["-c", "-f progress", "-r ./spec/spec_helper.rb"]
+  t.rspec_opts = %w[
+    --force-color
+    --format progress
+    --require ./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.rspec_opts = %w[
+    --force-color
+    --format progress
+    --require ./spec/acceptance/net_http/real_net_http_spec.rb
+  ]
   t.pattern = 'spec/acceptance/net_http/real_net_http_spec.rb'
 end
 
-
-task :em_http_request_0_x_spec do
-  sh "EM_HTTP_REQUEST_0_X=true bundle install && bundle exec rspec spec/acceptance/em_http_request/em_http_request_spec.rb" if RUBY_VERSION <= "1.8.7"
-end
-
 require 'rake/testtask'
 Rake::TestTask.new(:test) do |test|
   test.test_files = FileList["test/**/*.rb"].exclude("test/test_helper.rb")
+  test.options = "--use-color"
   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.options = "--pride"
   test.verbose = false
   test.warning = false
 end
 
-
-task :default => [:spec, :spec_http_without_webmock, :test, :minitest]
-
-require 'rdoc/task'
-RDoc::Task.new do |rdoc|
-  $:.push File.expand_path('../lib', __FILE__)
-  require 'webmock/version'
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "webmock #{WebMock::VERSION}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/webmock/webmock.rb')
-end
-
-
-task :require_ruby_18 do
-  raise "This must be run on Ruby 1.8" unless RUBY_VERSION =~ /^1\.8/
-end
-
-task :release => [:require_ruby_18]
+task default: [:spec, :spec_http_without_webmock, :test, :minitest]

data/lib/webmock/api.rb

@@ -17,46 +17,92 @@ module WebMock
       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, &block)
+        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, &block)
+      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, &block)
+        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
-      assert_request_not_requested(*args, &block)
     end
 
-    def hash_including(expected)
-      if defined?(::RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher)
-        RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new(expected)
-      elsif defined?(::Spec::Mocks::ArgumentMatchers::HashIncludingMatcher)
-        Spec::Mocks::ArgumentMatchers::HashIncludingMatcher.new(expected)
+    def hash_excluding(*args)
+      if defined?(super)
+        super
       else
-        WebMock::Matchers::HashIncludingMatcher.new(expected)
+        WebMock::Matchers::HashExcludingMatcher.new(anythingize_lonely_keys(*args))
       end
     end
 
+    def remove_request_stub(stub)
+      WebMock::StubRegistry.instance.remove_request_stub(stub)
+    end
+
+    def reset_executed_requests!
+      WebMock::RequestRegistry.instance.reset!
+    end
+
     private
 
-    def convert_uri_method_and_options_to_request_and_options(*args, &block)
-      request = WebMock::RequestPattern.new(*args).with(&block)
-      [request, args[2] || {}]
+    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 = {})
-      verifier = WebMock::RequestExecutionVerifier.new(request, options.delete(:times) || 1)
+      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 = {})
-      verifier = WebMock::RequestExecutionVerifier.new(request, options.delete(:times))
-      WebMock::AssertionFailure.failure(verifier.negative_failure_message) unless verifier.does_not_match?
+      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

data/lib/webmock/callback_registry.rb

@@ -3,7 +3,7 @@ module WebMock
     @@callbacks = []
 
     def self.add_callback(options, block)
-      @@callbacks << {:options => options, :block => block}
+      @@callbacks << {options: options, block: block}
     end
 
     def self.callbacks

data/lib/webmock/config.rb

@@ -2,9 +2,17 @@ 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/lib/webmock/cucumber.rb

@@ -1,6 +1,8 @@
 require 'webmock'
 require 'webmock/rspec/matchers'
 
+WebMock.enable!
+
 World(WebMock::API, WebMock::Matchers)
 
 After do

data/lib/webmock/errors.rb

@@ -1,33 +1,17 @@
 module WebMock
 
-  class NetConnectNotAllowedError < StandardError
+  class NetConnectNotAllowedError < Exception
     def initialize(request_signature)
-      text = "Real HTTP connections are disabled. Unregistered request: #{request_signature}"
-      text << "\n\n"
-      text << stubbing_instructions(request_signature)
-      text << request_stubs
-      text << "\n\n" + "="*60
+      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
 
-    private
-
-    def request_stubs
-      return "" if WebMock::StubRegistry.instance.request_stubs.empty?
-      text = "\n\nregistered request stubs:\n"
-      WebMock::StubRegistry.instance.request_stubs.each do |stub|
-        text << "\n#{WebMock::StubRequestSnippet.new(stub).to_s(false)}"
-      end
-      text
-    end
-
-    def stubbing_instructions(request_signature)
-      text = ""
-      request_stub = RequestStub.from_request_signature(request_signature)
-      text << "You can stub this request with the following snippet:\n\n"
-      text << WebMock::StubRequestSnippet.new(request_stub).to_s
-      text
-    end
   end
 
 end

data/lib/webmock/http_lib_adapters/async_http_client_adapter.rb

@@ -0,0 +1,216 @@
+begin
+  require 'async'
+  require 'async/http'
+rescue LoadError
+  # async-http not found
+end
+
+if defined?(Async::HTTP)
+  module WebMock
+    module HttpLibAdapters
+      class AsyncHttpClientAdapter < HttpLibAdapter
+        adapter_for :async_http_client
+
+        OriginalAsyncHttpClient = Async::HTTP::Client unless const_defined?(:OriginalAsyncHttpClient)
+
+        class << self
+          def enable!
+            Async::HTTP.send(:remove_const, :Client)
+            Async::HTTP.send(:const_set, :Client, Async::HTTP::WebMockClientWrapper)
+          end
+
+          def disable!
+            Async::HTTP.send(:remove_const, :Client)
+            Async::HTTP.send(:const_set, :Client, OriginalAsyncHttpClient)
+          end
+        end
+      end
+    end
+  end
+
+  module Async
+    module HTTP
+      class WebMockClientWrapper < Client
+        def initialize(
+          endpoint,
+          protocol = endpoint.protocol,
+          scheme = endpoint.scheme,
+          authority = endpoint.authority,
+          **options
+        )
+          webmock_endpoint = WebMockEndpoint.new(scheme, authority, protocol)
+
+          @network_client = WebMockClient.new(endpoint, **options)
+          @webmock_client = WebMockClient.new(webmock_endpoint, **options)
+
+          @scheme = scheme
+          @authority = authority
+        end
+
+        def call(request)
+          request.scheme ||= self.scheme
+          request.authority ||= self.authority
+
+          request_signature = build_request_signature(request)
+          WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
+          webmock_response = WebMock::StubRegistry.instance.response_for_request(request_signature)
+          net_connect_allowed = WebMock.net_connect_allowed?(request_signature.uri)
+          real_request = false
+
+          if webmock_response
+            webmock_response.raise_error_if_any
+            raise Async::TimeoutError, 'WebMock timeout error' if webmock_response.should_timeout
+            WebMockApplication.add_webmock_response(request, webmock_response)
+            response = @webmock_client.call(request)
+          elsif net_connect_allowed
+            response = @network_client.call(request)
+            real_request = true
+          else
+            raise WebMock::NetConnectNotAllowedError.new(request_signature) unless webmock_response
+          end
+
+          if WebMock::CallbackRegistry.any_callbacks?
+            webmock_response ||= build_webmock_response(response)
+            WebMock::CallbackRegistry.invoke_callbacks(
+              {
+                lib: :async_http_client,
+                real_request: real_request
+              },
+              request_signature,
+              webmock_response
+            )
+          end
+
+          response
+        end
+
+        def close
+          @network_client.close
+          @webmock_client.close
+        end
+
+        private
+
+        def build_request_signature(request)
+          body = request.read
+          request.body = ::Protocol::HTTP::Body::Buffered.wrap(body)
+          WebMock::RequestSignature.new(
+            request.method.downcase.to_sym,
+            "#{request.scheme}://#{request.authority}#{request.path}",
+            headers: request.headers.to_h,
+            body: body
+          )
+        end
+
+        def build_webmock_response(response)
+          body = response.read
+          response.body = ::Protocol::HTTP::Body::Buffered.wrap(body)
+
+          webmock_response = WebMock::Response.new
+          webmock_response.status = [
+            response.status,
+            ::Protocol::HTTP1::Reason::DESCRIPTIONS[response.status]
+          ]
+          webmock_response.headers = build_webmock_response_headers(response)
+          webmock_response.body = body
+          webmock_response
+        end
+
+        def build_webmock_response_headers(response)
+          response.headers.each.each_with_object({}) do |(k, v), o|
+            o[k] ||= []
+            o[k] << v
+          end
+        end
+      end
+
+      class WebMockClient < Client
+      end
+
+      class WebMockEndpoint
+        def initialize(scheme, authority, protocol)
+          @scheme = scheme
+          @authority = authority
+          @protocol = protocol
+        end
+
+        attr :scheme, :authority, :protocol
+
+        def connect
+          server_socket, client_socket = create_connected_sockets
+          Async(transient: true) do
+            accept_socket(server_socket)
+          end
+          client_socket
+        end
+
+        def inspect
+          "\#<#{self.class}> #{scheme}://#{authority} protocol=#{protocol}"
+        end
+
+        private
+
+        def create_connected_sockets
+          Async::IO::Socket.pair(Socket::AF_UNIX, Socket::SOCK_STREAM).tap do |sockets|
+            sockets.each do |socket|
+              socket.instance_variable_set :@alpn_protocol, nil
+              socket.instance_eval do
+                def alpn_protocol
+                  nil # means HTTP11 will be used for HTTPS
+                end
+              end
+            end
+          end
+        end
+
+        def accept_socket(socket)
+          server = Async::HTTP::Server.new(WebMockApplication, self)
+          server.accept(socket, socket.remote_address)
+        end
+      end
+
+      module WebMockApplication
+        WEBMOCK_REQUEST_ID_HEADER = 'x-webmock-request-id'.freeze
+
+        class << self
+          def call(request)
+            request.read
+            webmock_response = get_webmock_response(request)
+            build_response(webmock_response)
+          end
+
+          def add_webmock_response(request, webmock_response)
+            webmock_request_id = request.object_id.to_s
+            request.headers.add(WEBMOCK_REQUEST_ID_HEADER, webmock_request_id)
+            webmock_responses[webmock_request_id] = webmock_response
+          end
+
+          def get_webmock_response(request)
+            webmock_request_id = request.headers[WEBMOCK_REQUEST_ID_HEADER][0]
+            webmock_responses.fetch(webmock_request_id)
+          end
+
+          private
+
+          def webmock_responses
+            @webmock_responses ||= {}
+          end
+
+          def build_response(webmock_response)
+            headers = (webmock_response.headers || {}).each_with_object([]) do |(k, value), o|
+              Array(value).each do |v|
+                o.push [k, v]
+              end
+            end
+
+            ::Protocol::HTTP::Response[
+              webmock_response.status[0],
+              headers,
+              webmock_response.body
+            ]
+          end
+        end
+      end
+    end
+  end
+end