webmock 1.21.0 → 1.22.1

data/lib/webmock/request_execution_verifier.rb

@@ -33,32 +33,16 @@ module WebMock
       end
     end
 
+    def description
+      "request #{request_pattern.to_s} #{quantity_phrase.strip}"
+    end
 
     def failure_message
-      expected_times_executed = @expected_times_executed || 1
-      text = if @at_least_times_executed
-        %Q(The request #{request_pattern.to_s} was expected to execute at least #{times(@at_least_times_executed)} but it executed #{times(times_executed)})
-      elsif @at_most_times_executed
-        %Q(The request #{request_pattern.to_s} was expected to execute at most #{times(@at_most_times_executed)} but it executed #{times(times_executed)})
-      else
-        %Q(The request #{request_pattern.to_s} was expected to execute #{times(expected_times_executed)} but it executed #{times(times_executed)})
-      end
-      text << self.class.executed_requests_message
-      text
+      failure_message_phrase(is_negated=false)
     end
 
     def failure_message_when_negated
-      text = if @at_least_times_executed
-        %Q(The request #{request_pattern.to_s} was not expected to execute at least #{times(@at_least_times_executed)} but it executed #{times(times_executed)})
-      elsif @at_most_times_executed
-        %Q(The request #{request_pattern.to_s} was not expected to execute at most #{times(@at_most_times_executed)} but it executed #{times(times_executed)})
-      elsif @expected_times_executed
-        %Q(The request #{request_pattern.to_s} was not expected to execute #{times(expected_times_executed)} but it executed #{times(times_executed)})
-      else
-        %Q(The request #{request_pattern.to_s} was expected to execute 0 times but it executed #{times(times_executed)})
-      end
-      text << self.class.executed_requests_message
-      text
+      failure_message_phrase(is_negated=true)
     end
 
     def self.executed_requests_message
@@ -67,6 +51,25 @@ module WebMock
 
     private
 
+    def failure_message_phrase(is_negated=false)
+      negation = is_negated ? "was not" : "was"
+      text = "The request #{request_pattern.to_s} #{negation} expected to execute #{quantity_phrase(is_negated)}but it executed #{times(times_executed)}"
+      text << self.class.executed_requests_message
+      text
+    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

data/lib/webmock/request_pattern.rb

@@ -200,6 +200,8 @@ module WebMock
       'text/plain'             => :plain
     }
 
+    attr_reader :pattern
+
     def initialize(pattern)
       @pattern = if pattern.is_a?(Hash)
         normalize_hash(pattern)

data/lib/webmock/request_signature.rb

@@ -35,7 +35,11 @@ module WebMock
     alias == eql?
 
     def url_encoded?
-      headers && headers['Content-Type'] == 'application/x-www-form-urlencoded'
+      !!(headers && headers['Content-Type'] == 'application/x-www-form-urlencoded')
+    end
+
+    def json_headers?
+      !!(headers && headers['Content-Type'] == 'application/json')
     end
 
     private

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?
+
+      text = "You can stub this request with the following snippet:\n\n"
+      text << WebMock::StubRequestSnippet.new(request_stub).to_s
+    end
+
+    def request_stubs
+      return if WebMock::StubRegistry.instance.request_stubs.empty?
+
+      text = "registered request stubs:\n"
+      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("") do |stream|
+        PP.pp(string_to_print, stream)
+        stream.rewind
+        stream.read
+      end
+    end
+
+  end
+end

data/lib/webmock/rspec/matchers.rb

@@ -12,7 +12,6 @@ module WebMock
       WebMock::RequestPatternMatcher.new
     end
 
-
     def have_not_been_made
       WebMock::RequestPatternMatcher.new.times(0)
     end

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

@@ -68,6 +68,10 @@ module WebMock
       @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

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

@@ -42,6 +42,10 @@ module WebMock
       @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

data/lib/webmock/stub_request_snippet.rb

@@ -4,6 +4,10 @@ module WebMock
       @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},"

data/lib/webmock/util/json.rb

@@ -8,10 +8,13 @@
 module WebMock
   module Util
     class JSON
+      class ParseError < StandardError; end
+
       def self.parse(json)
-        YAML.load(unescape(convert_json_to_yaml(json)))
-      rescue ArgumentError
-        raise ParseError, "Invalid JSON string"
+        yaml = unescape(convert_json_to_yaml(json))
+        YAML.load(yaml)
+      rescue ArgumentError => e
+        raise ParseError, "Invalid JSON string: #{yaml}, Error: #{e.inspect}"
       end
 
       protected
@@ -42,11 +45,27 @@ module WebMock
           json.gsub(/\\\//, '/')
         else
           left_pos  = [-1].push(*marks)
-          right_pos = marks << json.length
+          right_pos = marks << json.bytesize
           output    = []
-          left_pos.each_with_index do |left, i|
-            output << json[left.succ..right_pos[i]]
+
+          if RUBY_VERSION != "1.9.2"
+            left_pos.each_with_index do |left, i|
+              if json.respond_to?(:byteslice)
+                output << json.byteslice(left.succ..right_pos[i])
+              else
+                output << json[left.succ..right_pos[i]]
+              end
+            end
+          else
+            json_as_binary = json.force_encoding("binary")
+            left_pos.each_with_index do |left, i|
+              output << json_as_binary[left.succ..right_pos[i]]
+            end
+            output.map! do |binary_str|
+              binary_str.force_encoding("UTF-8")
+            end
           end
+
           output = output * " "
 
           times.each { |i| output[i-1] = ' ' }

data/lib/webmock/util/query_mapper.rb

@@ -196,7 +196,11 @@ module WebMock::Util
           end
           # Useful default for OAuth and caching.
           # Only to be used for non-Array inputs. Arrays should preserve order.
-          new_query_values.sort!
+          begin
+            new_query_values.sort! # may raise for non-comparable values
+          rescue NoMethodError, ArgumentError
+            # ignore
+          end
         end
 
         buffer = ''
@@ -241,7 +245,7 @@ module WebMock::Util
         when ::Hash
           value = value.map do |key, val|
             [
-              ::Addressable::URI.encode_component(key.dup, ::Addressable::URI::CharacterClasses::UNRESERVED),
+              ::Addressable::URI.encode_component(key.to_s.dup, ::Addressable::URI::CharacterClasses::UNRESERVED),
               val
             ]
           end
@@ -259,8 +263,6 @@ module WebMock::Util
             buffer << "#{to_query(new_parent, val, options)}&"
           end
           buffer.chop
-        when TrueClass
-          parent
         else
           encoded_value = Addressable::URI.encode_component(
             value.to_s.dup, Addressable::URI::CharacterClasses::UNRESERVED

data/lib/webmock/version.rb

@@ -1,3 +1,3 @@
 module WebMock
-  VERSION = '1.21.0' unless defined?(::WebMock::VERSION)
+  VERSION = '1.22.1' unless defined?(::WebMock::VERSION)
 end

data/lib/webmock/webmock.rb

@@ -75,6 +75,18 @@ module WebMock
     end
   end
 
+  def self.show_body_diff!
+    Config.instance.show_body_diff = true
+  end
+
+  def self.hide_body_diff!
+    Config.instance.show_body_diff = false
+  end
+
+  def self.show_body_diff?
+    Config.instance.show_body_diff
+  end
+
   def self.hide_stubbing_instructions!
     Config.instance.show_stubbing_instructions = false
   end

data/spec/acceptance/em_http_request/em_http_request_spec.rb

@@ -229,6 +229,66 @@ unless RUBY_PLATFORM =~ /java/
       expect(http_request(:post, "http://www.example.com").body.bytesize).to eq(body.bytesize)
     end
 
+    it "should work with multiple requests to the same connection" do
+      stub_request(:get, "www.example.com/foo").to_return(:body => "bar")
+      stub_request(:get, "www.example.com/baz").to_return(:body => "wombat")
+      err1  = nil
+      err2  = nil
+      body1 = nil
+      body2 = nil
+      i = 0
+
+      EM.run do
+        conn = EM::HttpRequest.new("http://www.example.com")
+        conn.get(:path => "/foo").callback do |resp|
+          body1 = resp.response
+          i += 1; EM.stop if i == 2
+        end.errback do |resp|
+          err1  = resp.error
+          i += 1; EM.stop if i == 2
+        end
+
+        conn.get(:path => "/baz").callback do |resp|
+          body2 = resp.response
+          i += 1; EM.stop if i == 2
+        end.errback do |resp|
+          err2  = resp.error
+          i += 1; EM.stop if i == 2
+        end
+      end
+
+      expect(err1).to be(nil)
+      expect(err2).to be(nil)
+      expect(body1).to eq("bar")
+      expect(body2).to eq("wombat")
+    end
+
+    it "should work with multiple requests to the same connection when the first request times out" do
+      stub_request(:get, "www.example.com/foo").to_timeout.then.to_return(:status => 200, :body => "wombat")
+      err  = nil
+      body = nil
+
+      EM.run do
+        conn = EM::HttpRequest.new("http://www.example.com")
+        conn.get(:path => "/foo").callback do |resp|
+          err = :success_from_timeout
+          EM.stop
+        end.errback do |resp|
+          conn.get(:path => "/foo").callback do |resp|
+            expect(resp.response_header.status).to eq(200)
+            body = resp.response
+            EM.stop
+          end.errback do |resp|
+            err = resp.error
+            EM.stop
+          end
+        end
+      end
+
+      expect(err).to be(nil)
+      expect(body).to eq("wombat")
+    end
+
     describe "mocking EM::HttpClient API" do
       let(:uri) { "http://www.example.com/" }
 

data/spec/acceptance/http_rb/http_rb_spec.rb

@@ -49,11 +49,11 @@ describe "HTTP.rb" do
   end
 
   it "restores request uri on replayed response object" do
-    uri = URI "http://example.com/foo"
+    uri = Addressable::URI.parse "http://example.com/foo"
 
     stub_request :get, "example.com/foo"
     response = HTTP.get uri
 
-    expect(response.uri).to eq uri
+    expect(response.uri.to_s).to eq uri.to_s
   end
 end

data/spec/acceptance/http_rb/http_rb_spec_helper.rb

@@ -7,7 +7,7 @@ module HttpRbSpecHelper
     OpenStruct.new({
       :body       => response.body.to_s,
       :headers    => normalize_headers(response.headers.to_h),
-      :status     => response.status.to_s,
+      :status     => response.code.to_s,
       :message    => response.reason
     })
   end

data/spec/acceptance/httpclient/httpclient_spec.rb

@@ -113,13 +113,14 @@ describe "HTTPClient" do
         nil # to let the request be made for real
       end
 
-      # To make two requests that have the same request signature, the headers must match.
-      # Since the webmock server has a Set-Cookie header, the 2nd request will automatically
-      # include a Cookie header (due to how httpclient works), so we have to set the header
-      # manually on the first request but not on the 2nd request.
-      http_request(:get, webmock_server_url, :client => client,
-                         :headers => { "Cookie" => "bar=; foo=" })
-      http_request(:get, webmock_server_url, :client => client)
+      http_request(:get, webmock_server_url, :client => client, :headers => { "Cookie" => "bar=; foo=" })
+
+      if defined? HTTP::CookieJar
+        http_request(:get, webmock_server_url, :client => client, :headers => { "Cookie" => "bar=; foo=" })
+      else
+        # If http-cookie is not present, then the cookie headers will saved between requests
+        http_request(:get, webmock_server_url, :client => client)
+      end
 
       expect(request_signatures.size).to eq(2)
       # Verify the request signatures were identical as needed by this example

data/spec/acceptance/manticore/manticore_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+require 'acceptance/webmock_shared'
+
+if RUBY_PLATFORM =~ /java/
+  require 'acceptance/manticore/manticore_spec_helper'
+
+  describe "Manticore" do
+    include ManticoreSpecHelper
+
+    include_context "with WebMock", :no_status_message
+
+    context "calling http methods on Manticore directly using Manticore's facade" do
+      it "handles GET" do
+        stub_request(:get, "http://example-foo.com").to_return(:status => 301)
+        response = Manticore.get("http://example-foo.com")
+        expect(response.code).to eq(301)
+      end
+
+      it "handles POST" do
+        stub_request(:post, "http://example-foo.com").to_return(:status => 201)
+        response = Manticore.post("http://example-foo.com", {:hello => "world"})
+        expect(response.code).to eq(201)
+      end
+
+      it "handles PUT" do
+        stub_request(:put, "http://example-foo.com").to_return(:status => 409)
+        response = Manticore.put("http://example-foo.com", {:hello => "world"})
+        expect(response.code).to eq(409)
+      end
+
+      it "handles PATCH" do
+        stub_request(:patch, "http://example-foo.com").to_return(:status => 409)
+        response = Manticore.patch("http://example-foo.com", {:hello => "world"})
+        expect(response.code).to eq(409)
+      end
+
+      it "handles DELETE" do
+        stub_request(:delete, "http://example-foo.com").to_return(:status => 204)
+        response = Manticore.delete("http://example-foo.com", {:id => 1})
+        expect(response.code).to eq(204)
+      end
+
+      it "handles OPTIONS" do
+        stub_request(:options, "http://example-foo.com").to_return(:status => 200)
+        response = Manticore.options("http://example-foo.com")
+        expect(response.code).to eq(200)
+      end
+
+      it "handles HEAD" do
+        stub_request(:head, "http://example-foo.com").to_return(:status => 204)
+        response = Manticore.head("http://example-foo.com")
+        expect(response.code).to eq(204)
+      end
+    end
+  end
+end