webmock 3.7.1

data/lib/webmock/rspec.rb

@@ -0,0 +1,41 @@
+require 'webmock'
+
+# RSpec 1.x and 2.x compatibility
+if defined?(RSpec::Expectations::ExpectationNotMetError)
+  RSPEC_NAMESPACE = RSPEC_CONFIGURER = RSpec
+elsif defined?(Spec) && defined?(Spec.configure)
+  RSPEC_NAMESPACE = Spec
+  RSPEC_CONFIGURER = Spec::Runner
+else
+  begin
+    require 'rspec/core'
+    require 'rspec/expectations'
+    RSPEC_NAMESPACE = RSPEC_CONFIGURER = RSpec
+  rescue LoadError
+    require 'spec'
+    RSPEC_NAMESPACE = Spec
+    RSPEC_CONFIGURER = Spec::Runner
+  end
+end
+
+require 'webmock/rspec/matchers'
+
+RSPEC_CONFIGURER.configure { |config|
+
+  config.include WebMock::API
+  config.include WebMock::Matchers
+
+  config.before(:suite) do
+    WebMock.enable!
+  end
+
+  config.after(:suite) do
+    WebMock.disable!
+  end
+
+  config.after(:each) do
+    WebMock.reset!
+  end
+}
+
+WebMock::AssertionFailure.error_class = RSPEC_NAMESPACE::Expectations::ExpectationNotMetError

data/lib/webmock/rspec/matchers.rb

@@ -0,0 +1,27 @@
+require 'webmock'
+require 'webmock/rspec/matchers/request_pattern_matcher'
+require 'webmock/rspec/matchers/webmock_matcher'
+
+module WebMock
+  module Matchers
+    def have_been_made
+      WebMock::RequestPatternMatcher.new
+    end
+
+    def have_been_requested
+      WebMock::RequestPatternMatcher.new
+    end
+
+    def have_not_been_made
+      WebMock::RequestPatternMatcher.new.times(0)
+    end
+
+    def have_requested(method, uri)
+      WebMock::WebMockMatcher.new(method, uri)
+    end
+
+    def have_not_requested(method, uri)
+      WebMock::WebMockMatcher.new(method, uri).times(0)
+    end
+  end
+end

data/lib/webmock/rspec/matchers/request_pattern_matcher.rb

@@ -0,0 +1,78 @@
+module WebMock
+  class RequestPatternMatcher
+
+    def initialize
+      @request_execution_verifier = RequestExecutionVerifier.new
+    end
+
+    def once
+      @request_execution_verifier.expected_times_executed = 1
+      self
+    end
+
+    def twice
+      @request_execution_verifier.expected_times_executed = 2
+      self
+    end
+
+    def times(times)
+      @request_execution_verifier.expected_times_executed = times.to_i
+      self
+    end
+
+    def at_least_once
+      @request_execution_verifier.at_least_times_executed = 1
+      self
+    end
+
+    def at_least_twice
+      @request_execution_verifier.at_least_times_executed = 2
+      self
+    end
+
+    def at_least_times(times)
+      @request_execution_verifier.at_least_times_executed = times.to_i
+      self
+    end
+
+    def at_most_once
+      @request_execution_verifier.at_most_times_executed = 1
+      self
+    end
+
+    def at_most_twice
+      @request_execution_verifier.at_most_times_executed = 2
+      self
+    end
+
+    def at_most_times(times)
+      @request_execution_verifier.at_most_times_executed = times.to_i
+      self
+    end
+
+    def matches?(request_pattern)
+      @request_execution_verifier.request_pattern = request_pattern
+      @request_execution_verifier.matches?
+    end
+
+    def does_not_match?(request_pattern)
+      @request_execution_verifier.request_pattern = request_pattern
+      @request_execution_verifier.does_not_match?
+    end
+
+    def failure_message
+      @request_execution_verifier.failure_message
+    end
+
+    def failure_message_when_negated
+      @request_execution_verifier.failure_message_when_negated
+    end
+
+    def description
+      @request_execution_verifier.description
+    end
+
+    # RSpec 2 compatibility:
+    alias_method :negative_failure_message, :failure_message_when_negated
+  end
+end

data/lib/webmock/rspec/matchers/webmock_matcher.rb

@@ -0,0 +1,67 @@
+module WebMock
+  class WebMockMatcher
+
+    def initialize(method, uri)
+      @request_execution_verifier = RequestExecutionVerifier.new
+      @request_execution_verifier.request_pattern = RequestPattern.new(method, uri)
+    end
+
+    def once
+      @request_execution_verifier.expected_times_executed = 1
+      self
+    end
+
+    def twice
+      @request_execution_verifier.expected_times_executed = 2
+      self
+    end
+
+    def at_least_once
+      @request_execution_verifier.at_least_times_executed = 1
+      self
+    end
+
+    def at_least_twice
+      @request_execution_verifier.at_least_times_executed = 2
+      self
+    end
+
+    def at_least_times(times)
+      @request_execution_verifier.at_least_times_executed = times
+      self
+    end
+
+    def with(options = {}, &block)
+      @request_execution_verifier.request_pattern.with(options, &block)
+      self
+    end
+
+    def times(times)
+      @request_execution_verifier.expected_times_executed = times.to_i
+      self
+    end
+
+    def matches?(webmock)
+      @request_execution_verifier.matches?
+    end
+
+    def does_not_match?(webmock)
+      @request_execution_verifier.does_not_match?
+    end
+
+    def failure_message
+      @request_execution_verifier.failure_message
+    end
+
+    def failure_message_when_negated
+      @request_execution_verifier.failure_message_when_negated
+    end
+
+    def description
+      @request_execution_verifier.description
+    end
+
+    # RSpec 2 compatibility:
+    alias_method :negative_failure_message, :failure_message_when_negated
+  end
+end

data/lib/webmock/stub_registry.rb

@@ -0,0 +1,67 @@
+module WebMock
+
+  class StubRegistry
+    include Singleton
+
+    attr_accessor :request_stubs
+
+    def initialize
+      reset!
+    end
+
+    def global_stubs
+      @global_stubs ||= []
+    end
+
+    def reset!
+      self.request_stubs = []
+    end
+
+    def register_global_stub(&block)
+      # This hash contains the responses returned by the block,
+      # keyed by the exact request (using the object_id).
+      # That way, there's no race condition in case #to_return
+      # doesn't run immediately after stub.with.
+      responses = {}
+
+      stub = ::WebMock::RequestStub.new(:any, /.*/).with { |request|
+        responses[request.object_id] = yield(request)
+      }.to_return(lambda { |request| responses.delete(request.object_id) })
+
+      global_stubs.push stub
+    end
+
+    def register_request_stub(stub)
+      request_stubs.insert(0, stub)
+      stub
+    end
+
+    def remove_request_stub(stub)
+      if not request_stubs.delete(stub)
+        raise "Request stub \n\n #{stub.to_s} \n\n is not registered."
+      end
+    end
+
+    def registered_request?(request_signature)
+      request_stub_for(request_signature)
+    end
+
+    def response_for_request(request_signature)
+      stub = request_stub_for(request_signature)
+      stub ? evaluate_response_for_request(stub.response, request_signature) : nil
+    end
+
+    private
+
+    def request_stub_for(request_signature)
+      (global_stubs + request_stubs).detect { |registered_request_stub|
+        registered_request_stub.request_pattern.matches?(request_signature)
+      }
+    end
+
+    def evaluate_response_for_request(response, request_signature)
+      response.dup.evaluate(request_signature)
+    end
+
+  end
+end

data/lib/webmock/stub_request_snippet.rb

@@ -0,0 +1,38 @@
+module WebMock
+  class StubRequestSnippet
+    def initialize(request_stub)
+      @request_stub = request_stub
+    end
+
+    def body_pattern
+      request_pattern.body_pattern
+    end
+
+    def to_s(with_response = true)
+      request_pattern = @request_stub.request_pattern
+      string = "stub_request(:#{request_pattern.method_pattern.to_s},".dup
+      string << " \"#{request_pattern.uri_pattern.to_s}\")"
+
+      with = "".dup
+
+      if (request_pattern.body_pattern)
+        with << "\n    body: #{request_pattern.body_pattern.to_s}"
+      end
+
+      if (request_pattern.headers_pattern)
+        with << "," unless with.empty?
+
+        with << "\n    headers: #{request_pattern.headers_pattern.pp_to_s}"
+      end
+      string << ".\n  with(#{with})" unless with.empty?
+      if with_response
+        if request_pattern.headers_pattern && request_pattern.headers_pattern.matches?({ 'Accept' => "application/json" })
+          string << ".\n  to_return(status: 200, body: \"{}\", headers: {})"
+        else
+          string << ".\n  to_return(status: 200, body: \"\", headers: {})"
+        end
+      end
+      string
+    end
+  end
+end

data/lib/webmock/test_unit.rb

@@ -0,0 +1,22 @@
+require 'test/unit'
+require 'webmock'
+
+WebMock.enable!
+
+module Test
+  module Unit
+    class TestCase
+      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
+
+    end
+  end
+end
+
+WebMock::AssertionFailure.error_class = Test::Unit::AssertionFailedError

data/lib/webmock/util/hash_counter.rb

@@ -0,0 +1,39 @@
+require 'thread'
+
+module WebMock
+  module Util
+    class HashCounter
+      attr_accessor :hash
+      def initialize
+        self.hash = {}
+        @order = {}
+        @max = 0
+        @lock = ::Mutex.new
+      end
+      def put key, num=1
+        @lock.synchronize do
+          hash[key] = (hash[key] || 0) + num
+          @order[key] = @max = @max + 1
+        end
+      end
+      def get key
+        @lock.synchronize do
+          hash[key] || 0
+        end
+      end
+
+      def select(&block)
+        return unless block_given?
+        @lock.synchronize do
+          hash.select(&block)
+        end
+      end
+
+      def each(&block)
+        @order.to_a.sort_by { |a| a[1] }.each do |a|
+          yield(a[0], hash[a[0]])
+        end
+      end
+    end
+  end
+end

data/lib/webmock/util/hash_keys_stringifier.rb

@@ -0,0 +1,25 @@
+module WebMock
+  module Util
+    class HashKeysStringifier
+
+      def self.stringify_keys!(arg, options = {})
+        case arg
+        when Array
+          arg.map { |elem|
+            options[:deep] ? stringify_keys!(elem, options) : elem
+          }
+        when Hash
+          Hash[
+            *arg.map { |key, value|
+              k = key.is_a?(Symbol) ? key.to_s : key
+              v = (options[:deep] ? stringify_keys!(value, options) : value)
+              [k,v]
+            }.inject([]) {|r,x| r + x}]
+        else
+          arg
+        end
+      end
+
+    end
+  end
+end

data/lib/webmock/util/hash_validator.rb

@@ -0,0 +1,17 @@
+module WebMock
+  class HashValidator
+    def initialize(hash)
+      @hash = hash
+    end
+
+    #This code is based on https://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/hash/keys.rb
+    def validate_keys(*valid_keys)
+      valid_keys.flatten!
+      @hash.each_key do |k|
+        unless valid_keys.include?(k)
+          raise ArgumentError.new("Unknown key: #{k.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}")
+        end
+      end
+    end
+  end
+end

data/lib/webmock/util/headers.rb

@@ -0,0 +1,64 @@
+require 'base64'
+
+module WebMock
+
+  module Util
+
+    class Headers
+
+      def self.normalize_headers(headers)
+        return nil unless headers
+        array = headers.map { |name, value|
+          [name.to_s.split(/_|-/).map { |segment| segment.capitalize }.join("-"),
+           case value
+            when Regexp then value
+            when Array then (value.size == 1) ? value.first.to_s : value.map {|v| v.to_s}.sort
+            else value.to_s
+           end
+          ]
+        }
+        Hash[*array.inject([]) {|r,x| r + x}]
+      end
+
+      def self.sorted_headers_string(headers)
+        headers = WebMock::Util::Headers.normalize_headers(headers)
+        str = '{'.dup
+        str << headers.map do |k,v|
+          v = case v
+            when Regexp then v.inspect
+            when Array then "["+v.map{|w| "'#{w.to_s}'"}.join(", ")+"]"
+            else "'#{v.to_s}'"
+          end
+          "'#{k}'=>#{v}"
+        end.sort.join(", ")
+        str << '}'
+      end
+
+      def self.pp_headers_string(headers)
+        headers = WebMock::Util::Headers.normalize_headers(headers)
+        seperator = "\n\t "
+        str = "{#{seperator} ".dup
+        str << headers.map do |k,v|
+          v = case v
+            when Regexp then v.inspect
+            when Array then "["+v.map{|w| "'#{w.to_s}'"}.join(", ")+"]"
+            else "'#{v.to_s}'"
+          end
+          "'#{k}'=>#{v}"
+        end.sort.join(",#{seperator} ")
+        str << "\n    }"
+      end
+
+      def self.decode_userinfo_from_header(header)
+        header.sub(/^Basic /, "").unpack("m").first
+      end
+
+      def self.basic_auth_header(*credentials)
+        "Basic #{Base64.strict_encode64(credentials.join(':')).chomp}"
+      end
+
+    end
+
+  end
+
+end