ultra-pure-gem 0.0.1

data/webmock-3.26.2/lib/webmock/matchers/hash_excluding_matcher.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module WebMock
+  module Matchers
+    # this is a based on RSpec::Mocks::ArgumentMatchers::HashExcludingMatcher
+    # https://github.com/rspec/rspec-mocks/blob/master/lib/rspec/mocks/argument_matchers.rb
+    class HashExcludingMatcher < HashArgumentMatcher
+      def ==(actual)
+        super { |key, value| !actual.key?(key) || value != actual[key] }
+      end
+
+      def inspect
+        "hash_excluding(#{@expected.inspect})"
+      end
+    end
+  end
+end

data/webmock-3.26.2/lib/webmock/matchers/hash_including_matcher.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module WebMock
+  module Matchers
+    # this is a based on RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher
+    # https://github.com/rspec/rspec-mocks/blob/master/lib/rspec/mocks/argument_matchers.rb
+    class HashIncludingMatcher < HashArgumentMatcher
+      def ==(actual)
+        super { |key, value| actual.key?(key) && value === actual[key] }
+      rescue NoMethodError
+        false
+      end
+
+      def inspect
+        "hash_including(#{@expected.inspect})"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+begin
+  require 'minitest/test'
+  test_class = Minitest::Test
+  assertions = "assertions"
+rescue LoadError
+  require "minitest/unit"
+  test_class = MiniTest::Unit::TestCase
+  assertions = "_assertions"
+end
+
+require 'webmock'
+
+WebMock.enable!
+
+test_class.class_eval do
+  include WebMock::API
+
+  alias_method :teardown_without_webmock, :teardown
+  def teardown_with_webmock
+    teardown_without_webmock
+    WebMock.reset!
+  end
+  alias_method :teardown, :teardown_with_webmock
+
+  [:assert_request_requested, :assert_request_not_requested].each do |name|
+    alias_method :"#{name}_without_assertions_count", name
+    define_method :"#{name}_with_assertions_count" do |*args|
+      self.send("#{assertions}=", self.send("#{assertions}") + 1)
+      send :"#{name}_without_assertions_count", *args
+    end
+    alias_method name, :"#{name}_with_assertions_count"
+  end
+end
+
+begin
+  error_class = MiniTest::Assertion
+rescue NameError
+  error_class = Minitest::Assertion
+end
+
+WebMock::AssertionFailure.error_class = error_class

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module WebMock
+  class RackResponse < Response
+    def initialize(app)
+      @app = app
+    end
+
+    def evaluate(request)
+      env = build_rack_env(request)
+
+      status, headers, response = @app.call(env)
+
+      Response.new(
+        body: body_from_rack_response(response),
+        headers: headers,
+        status: [status, Rack::Utils::HTTP_STATUS_CODES[status]]
+      )
+    end
+
+    def body_from_rack_response(response)
+      body = "".dup
+      response.each { |line| body << line }
+      response.close if response.respond_to?(:close)
+      return body
+    end
+
+    def build_rack_env(request)
+      uri = request.uri
+      headers = (request.headers || {}).dup
+      body = request.body || ''
+
+      env = {
+        # CGI variables specified by Rack
+        'REQUEST_METHOD' => request.method.to_s.upcase,
+        'CONTENT_TYPE'   => headers.delete('Content-Type'),
+        'CONTENT_LENGTH' => body.bytesize,
+        'PATH_INFO'      => uri.path,
+        'QUERY_STRING'   => uri.query || '',
+        'SERVER_NAME'    => uri.host,
+        'SERVER_PORT'    => uri.port,
+        'SCRIPT_NAME'    => ""
+      }
+
+      env['HTTP_AUTHORIZATION'] = 'Basic ' + [uri.userinfo].pack('m').delete("\r\n") if uri.userinfo
+
+      # Rack-specific variables
+      env['rack.input']      = StringIO.new(body)
+      env['rack.errors']     = $stderr
+      if !Rack.const_defined?(:RELEASE) || Rack::RELEASE < "3"
+        env['rack.version']    = Rack::VERSION
+      end
+      env['rack.url_scheme'] = uri.scheme
+      env['rack.run_once']   = true
+      env['rack.session']    = session
+      env['rack.session.options'] = session_options
+
+      headers.each do |k, v|
+        env["HTTP_#{k.tr('-','_').upcase}"] = v
+      end
+
+      env
+    end
+
+    def session
+      @session ||= {}
+    end
+
+    def session_options
+      @session_options ||= {}
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "hashdiff"
+require "json"
+
+module WebMock
+  class RequestBodyDiff
+
+    def initialize(request_signature, request_stub)
+      @request_signature = request_signature
+      @request_stub      = request_stub
+    end
+
+    def body_diff
+      return {} unless request_signature_diffable? && request_stub_diffable?
+
+      Hashdiff.diff(request_signature_body_hash, request_stub_body_hash)
+    end
+
+    attr_reader :request_signature, :request_stub
+    private :request_signature, :request_stub
+
+    private
+
+    def request_signature_diffable?
+      request_signature.json_headers? && request_signature_parseable_json?
+    end
+
+    def request_stub_diffable?
+      request_stub_body.is_a?(Hash) || request_stub_parseable_json?
+    end
+
+    def request_signature_body_hash
+      JSON.parse(request_signature.body)
+    end
+
+    def request_stub_body_hash
+      return request_stub_body if request_stub_body.is_a?(Hash)
+
+      JSON.parse(request_stub_body)
+    end
+
+    def request_stub_body
+      request_stub.request_pattern &&
+        request_stub.request_pattern.body_pattern &&
+        request_stub.request_pattern.body_pattern.pattern
+    end
+
+    def request_signature_parseable_json?
+      parseable_json?(request_signature.body)
+    end
+
+    def request_stub_parseable_json?
+      parseable_json?(request_stub_body)
+    end
+
+    def parseable_json?(body_pattern)
+      return false unless body_pattern.is_a?(String)
+
+      JSON.parse(body_pattern)
+      true
+    rescue JSON::ParserError
+      false
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module WebMock
+  class RequestExecutionVerifier
+
+    attr_accessor :request_pattern, :expected_times_executed, :times_executed, :at_least_times_executed, :at_most_times_executed
+
+    def initialize(request_pattern = nil, expected_times_executed = nil, at_least_times_executed = nil, at_most_times_executed = nil)
+      @request_pattern = request_pattern
+      @expected_times_executed = expected_times_executed
+      @at_least_times_executed = at_least_times_executed
+      @at_most_times_executed = at_most_times_executed
+    end
+
+    def matches?
+      @times_executed =
+        RequestRegistry.instance.times_executed(@request_pattern)
+
+      if @at_least_times_executed
+        @times_executed >= @at_least_times_executed
+      elsif @at_most_times_executed
+        @times_executed <= @at_most_times_executed
+      else
+        @times_executed == (@expected_times_executed || 1)
+      end
+    end
+
+    def does_not_match?
+      @times_executed =
+      RequestRegistry.instance.times_executed(@request_pattern)
+      if @expected_times_executed
+        @times_executed != @expected_times_executed
+      else
+        @times_executed == 0
+      end
+    end
+
+    def description
+      "request #{request_pattern} #{quantity_phrase.strip}"
+    end
+
+    def failure_message
+      failure_message_phrase(false)
+    end
+
+    def failure_message_when_negated
+      failure_message_phrase(true)
+    end
+
+    def self.executed_requests_message
+      "\n\nThe following requests were made:\n\n#{RequestRegistry.instance}\n" + "="*60
+    end
+
+    private
+
+    def failure_message_phrase(is_negated=false)
+      negation = is_negated ? "was not" : "was"
+      "The request #{request_pattern} #{negation} expected to execute #{quantity_phrase(is_negated)}but it executed #{times(times_executed)}" +
+        self.class.executed_requests_message
+    end
+
+    def quantity_phrase(is_negated=false)
+      if @at_least_times_executed
+        "at least #{times(@at_least_times_executed)} "
+      elsif @at_most_times_executed
+        "at most #{times(@at_most_times_executed)} "
+      elsif @expected_times_executed
+        "#{times(@expected_times_executed)} "
+      else
+        is_negated ? "" : "#{times(1)} "
+      end
+    end
+
+    def times(times)
+      "#{times} time#{ (times == 1) ? '' : 's'}"
+    end
+
+  end
+end