webmock 3.7.1

data/lib/webmock/request_registry.rb

@@ -0,0 +1,35 @@
+module WebMock
+
+  class RequestRegistry
+    include Singleton
+
+    attr_accessor :requested_signatures
+
+    def initialize
+      reset!
+    end
+
+    def reset!
+      self.requested_signatures = Util::HashCounter.new
+    end
+
+    def times_executed(request_pattern)
+      self.requested_signatures.select do |request_signature|
+        request_pattern.matches?(request_signature)
+      end.inject(0) { |sum, (_, times_executed)| sum + times_executed }
+    end
+
+    def to_s
+      if requested_signatures.hash.empty?
+        "No requests were made."
+      else
+        text = "".dup
+        self.requested_signatures.each do |request_signature, times_executed|
+          text << "#{request_signature} was made #{times_executed} time#{times_executed == 1 ? '' : 's' }\n"
+        end
+        text
+      end
+    end
+
+  end
+end

data/lib/webmock/request_signature.rb

@@ -0,0 +1,54 @@
+module WebMock
+
+  class RequestSignature
+
+    attr_accessor :method, :uri, :body
+    attr_reader :headers
+
+    def initialize(method, uri, options = {})
+      self.method = method.to_sym
+      self.uri = uri.is_a?(Addressable::URI) ? uri : WebMock::Util::URI.normalize_uri(uri)
+      assign_options(options)
+    end
+
+    def to_s
+      string = "#{self.method.to_s.upcase}".dup
+      string << " #{WebMock::Util::URI.strip_default_port_from_uri_string(self.uri.to_s)}"
+      string << " with body '#{body.to_s}'" if body && body.to_s != ''
+      if headers && !headers.empty?
+        string << " with headers #{WebMock::Util::Headers.sorted_headers_string(headers)}"
+      end
+      string
+    end
+
+    def headers=(headers)
+      @headers = WebMock::Util::Headers.normalize_headers(headers)
+    end
+
+    def hash
+      self.to_s.hash
+    end
+
+    def eql?(other)
+      self.to_s == other.to_s
+    end
+    alias == eql?
+
+    def url_encoded?
+      !!(headers && headers['Content-Type'] == 'application/x-www-form-urlencoded')
+    end
+
+    def json_headers?
+      !!(headers && headers['Content-Type'] == 'application/json')
+    end
+
+    private
+
+    def assign_options(options)
+      self.body = options[:body] if options.has_key?(:body)
+      self.headers = options[:headers] if options.has_key?(:headers)
+    end
+
+  end
+
+end

data/lib/webmock/request_signature_snippet.rb

@@ -0,0 +1,61 @@
+require "pp"
+
+module WebMock
+  class RequestSignatureSnippet
+
+    attr_reader :request_signature, :request_stub
+
+    def initialize(request_signature)
+      @request_signature = request_signature
+      @request_stub = RequestStub.from_request_signature(request_signature)
+    end
+
+    def stubbing_instructions
+      return unless WebMock.show_stubbing_instructions?
+
+      "You can stub this request with the following snippet:\n\n" +
+        WebMock::StubRequestSnippet.new(request_stub).to_s
+    end
+
+    def request_stubs
+      return if WebMock::StubRegistry.instance.request_stubs.empty?
+
+      text = "registered request stubs:\n".dup
+      WebMock::StubRegistry.instance.request_stubs.each do |stub|
+        text << "\n#{WebMock::StubRequestSnippet.new(stub).to_s(false)}"
+        add_body_diff(stub, text) if WebMock.show_body_diff?
+      end
+      text
+    end
+
+    private
+
+    def add_body_diff(stub, text)
+      body_diff_str = signature_stub_body_diff(stub)
+      text << "\n\n#{body_diff_str}" unless body_diff_str.empty?
+    end
+
+    def signature_stub_body_diff(stub)
+      diff = RequestBodyDiff.new(request_signature, stub).body_diff
+      diff.empty? ? "" : "Body diff:\n #{pretty_print_to_string(diff)}"
+    end
+
+    def request_params
+      @request_params ||=
+        if request_signature.json_headers?
+          JSON.parse(request_signature.body)
+        else
+          ""
+        end
+    end
+
+    def pretty_print_to_string(string_to_print)
+      StringIO.open("".dup) do |stream|
+        PP.pp(string_to_print, stream)
+        stream.rewind
+        stream.read
+      end
+    end
+
+  end
+end

data/lib/webmock/request_stub.rb

@@ -0,0 +1,100 @@
+module WebMock
+  class RequestStub
+
+    attr_accessor :request_pattern
+
+    def initialize(method, uri)
+      @request_pattern = RequestPattern.new(method, uri)
+      @responses_sequences = []
+      self
+    end
+
+    def with(params = {}, &block)
+      @request_pattern.with(params, &block)
+      self
+    end
+
+    def to_return(*response_hashes, &block)
+      if block
+        @responses_sequences << ResponsesSequence.new([ResponseFactory.response_for(block)])
+      else
+        @responses_sequences << ResponsesSequence.new([*response_hashes].flatten.map {|r| ResponseFactory.response_for(r)})
+      end
+      self
+    end
+    alias_method :and_return, :to_return
+
+    def to_rack(app, options={})
+      @responses_sequences << ResponsesSequence.new([RackResponse.new(app)])
+    end
+
+    def to_raise(*exceptions)
+      @responses_sequences << ResponsesSequence.new([*exceptions].flatten.map {|e|
+        ResponseFactory.response_for(exception: e)
+      })
+      self
+    end
+    alias_method :and_raise, :to_raise
+
+    def to_timeout
+      @responses_sequences << ResponsesSequence.new([ResponseFactory.response_for(should_timeout: true)])
+      self
+    end
+    alias_method :and_timeout, :to_timeout
+
+    def response
+      if @responses_sequences.empty?
+        WebMock::Response.new
+      elsif @responses_sequences.length > 1
+        @responses_sequences.shift if @responses_sequences.first.end?
+        @responses_sequences.first.next_response
+      else
+        @responses_sequences[0].next_response
+      end
+    end
+
+    def has_responses?
+      !@responses_sequences.empty?
+    end
+
+    def then
+      self
+    end
+
+    def times(number)
+      raise "times(N) accepts integers >= 1 only" if !number.is_a?(Integer) || number < 1
+      if @responses_sequences.empty?
+        raise "Invalid WebMock stub declaration." +
+          " times(N) can be declared only after response declaration."
+      end
+      @responses_sequences.last.times_to_repeat += number-1
+      self
+    end
+
+    def matches?(request_signature)
+      self.request_pattern.matches?(request_signature)
+    end
+
+    def to_s
+      self.request_pattern.to_s
+    end
+
+    def self.from_request_signature(signature)
+      stub = self.new(signature.method.to_sym, signature.uri.to_s)
+
+      if signature.body.to_s != ''
+        body = if signature.url_encoded?
+          WebMock::Util::QueryMapper.query_to_values(signature.body, notation: Config.instance.query_values_notation)
+        else
+          signature.body
+        end
+        stub.with(body: body)
+      end
+
+      if (signature.headers && !signature.headers.empty?)
+        stub.with(headers: signature.headers)
+      end
+      stub
+    end
+  end
+end

data/lib/webmock/response.rb

@@ -0,0 +1,153 @@
+require "pathname"
+
+module WebMock
+
+  class ResponseFactory
+    def self.response_for(options)
+      if options.respond_to?(:call)
+        WebMock::DynamicResponse.new(options)
+      else
+        WebMock::Response.new(options)
+      end
+    end
+  end
+
+  class Response
+    def initialize(options = {})
+      if options.is_a?(IO) || options.is_a?(String)
+        self.options = read_raw_response(options)
+      else
+        self.options = options
+      end
+    end
+
+    def headers
+      @headers
+    end
+
+    def headers=(headers)
+      @headers = headers
+      if @headers && !@headers.is_a?(Proc)
+        @headers = Util::Headers.normalize_headers(@headers)
+      end
+    end
+
+    def body
+      @body || ''
+    end
+
+    def body=(body)
+      @body = body
+      assert_valid_body!
+      stringify_body!
+    end
+
+    def status
+      @status || [200, ""]
+    end
+
+    def status=(status)
+      @status = status.is_a?(Integer) ? [status, ""] : status
+    end
+
+    def exception
+      @exception
+    end
+
+    def exception=(exception)
+      @exception = case exception
+      when String then StandardError.new(exception)
+      when Class then exception.new('Exception from WebMock')
+      when Exception then exception
+      end
+    end
+
+    def raise_error_if_any
+      raise @exception if @exception
+    end
+
+    def should_timeout
+      @should_timeout == true
+    end
+
+    def options=(options)
+      options = WebMock::Util::HashKeysStringifier.stringify_keys!(options)
+      HashValidator.new(options).validate_keys('headers', 'status', 'body', 'exception', 'should_timeout')
+      self.headers = options['headers']
+      self.status = options['status']
+      self.body = options['body']
+      self.exception = options['exception']
+      @should_timeout = options['should_timeout']
+    end
+
+    def evaluate(request_signature)
+      self.body = @body.call(request_signature) if @body.is_a?(Proc)
+      self.headers = @headers.call(request_signature) if @headers.is_a?(Proc)
+      self.status = @status.call(request_signature) if @status.is_a?(Proc)
+      @should_timeout = @should_timeout.call(request_signature) if @should_timeout.is_a?(Proc)
+      @exception = @exception.call(request_signature) if @exception.is_a?(Proc)
+      self
+    end
+
+    def ==(other)
+      self.body == other.body &&
+      self.headers === other.headers &&
+      self.status == other.status &&
+      self.exception == other.exception &&
+      self.should_timeout == other.should_timeout
+    end
+
+    private
+
+    def stringify_body!
+      if @body.is_a?(IO) || @body.is_a?(Pathname)
+        io = @body
+        @body = io.read
+        io.close if io.respond_to?(:close)
+      end
+    end
+
+    def assert_valid_body!
+      valid_types = [Proc, IO, Pathname, String, Array]
+      return if @body.nil?
+      return if valid_types.any? { |c| @body.is_a?(c) }
+      raise InvalidBody, "must be one of: #{valid_types}. '#{@body.class}' given"
+    end
+
+    def read_raw_response(raw_response)
+      if raw_response.is_a?(IO)
+        string = raw_response.read
+        raw_response.close
+        raw_response = string
+      end
+      socket = ::Net::BufferedIO.new(raw_response)
+      response = ::Net::HTTPResponse.read_new(socket)
+      transfer_encoding = response.delete('transfer-encoding') #chunks were already read by curl
+      response.reading_body(socket, true) {}
+
+      options = {}
+      options[:headers] = {}
+      response.each_header {|name, value| options[:headers][name] = value}
+      options[:headers]['transfer-encoding'] = transfer_encoding if transfer_encoding
+      options[:body] = response.read_body
+      options[:status] = [response.code.to_i, response.message]
+      options
+    end
+
+    InvalidBody = Class.new(StandardError)
+
+  end
+
+  class DynamicResponse < Response
+    attr_accessor :responder
+
+    def initialize(responder)
+      @responder = responder
+    end
+
+    def evaluate(request_signature)
+      options = @responder.call(request_signature)
+      Response.new(options)
+    end
+  end
+end

data/lib/webmock/responses_sequence.rb

@@ -0,0 +1,40 @@
+module WebMock
+
+  class ResponsesSequence
+
+    attr_accessor :times_to_repeat
+
+    def initialize(responses)
+      @times_to_repeat = 1
+      @responses = responses
+      @current_position = 0
+    end
+
+    def end?
+      @times_to_repeat == 0
+    end
+
+    def next_response
+      if @times_to_repeat > 0
+        response = @responses[@current_position]
+        increase_position
+        response
+      else
+        @responses.last
+      end
+    end
+
+    private
+
+    def increase_position
+      if @current_position == (@responses.length - 1)
+        @current_position = 0
+        @times_to_repeat -= 1
+      else
+        @current_position += 1
+      end
+    end
+
+  end
+
+end