ultra-pure-gem 0.0.1

data/webmock-3.26.2/lib/webmock/api.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+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 hash_excluding(*args)
+      if defined?(super)
+        super
+      else
+        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(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/webmock-3.26.2/lib/webmock/assertion_failure.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+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/webmock-3.26.2/lib/webmock/callback_registry.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+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/webmock-3.26.2/lib/webmock/config.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+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/webmock-3.26.2/lib/webmock/cucumber.rb

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

data/webmock-3.26.2/lib/webmock/deprecation.rb

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

data/webmock-3.26.2/lib/webmock/errors.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+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/webmock-3.26.2/lib/webmock/http_lib_adapters/async_http_client_adapter.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+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)
+
+          @endpoint = endpoint
+          @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 socket_class
+          defined?(Async::IO::Socket) ? Async::IO::Socket : Socket
+        end
+
+        def create_connected_sockets
+          pair = begin
+            socket_class.pair(Socket::AF_UNIX, Socket::SOCK_STREAM)
+          rescue Errno::EAFNOSUPPORT
+            socket_class.pair(Socket::AF_INET, Socket::SOCK_STREAM)
+          end
+          pair.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] unless k.downcase == 'content-length' # async-http appends the exact content-length automatically
+              end
+            end
+
+            ::Protocol::HTTP::Response[
+              webmock_response.status[0],
+              headers,
+              webmock_response.body
+            ]
+          end
+        end
+      end
+    end
+  end
+end