webmock 1.8.6 → 3.14.0

data/spec/acceptance/typhoeus/typhoeus_hydra_spec.rb

@@ -6,6 +6,11 @@ unless RUBY_PLATFORM =~ /java/
 
   describe "Typhoeus::Hydra" do
     include TyphoeusHydraSpecHelper
+    let(:hydra) { Typhoeus::Hydra.new }
+
+    before do
+      Typhoeus::Expectation.clear
+    end
 
     include_context "with WebMock"
 
@@ -15,15 +20,37 @@ unless RUBY_PLATFORM =~ /java/
         WebMock.reset!
       end
 
+      describe "supposed response fields" do
+        it "present" do
+          stub_request(:get, "http://www.example.com").to_return(headers: {'X-Test' => '1'})
+          response = Typhoeus.get("http://www.example.com")
+          expect(response.code).not_to be_nil
+          expect(response.status_message).not_to be_nil
+          expect(response.body).not_to be_nil
+          expect(response.headers).not_to be_nil
+          expect(response.effective_url).not_to be_nil
+        end
+      end
+
       describe "when params are used" do
         it "should take into account params for POST request" do
-          stub_request(:post, "www.example.com").with(:body => {:hello => 'world'})
-          Typhoeus::Request.post("www.example.com", :params => {:hello => 'world'})
+          stub_request(:post, "www.example.com/?hello=world").with(query: {hello: 'world'})
+          request = Typhoeus::Request.new("http://www.example.com", method: :post, params: {hello: 'world'})
+          hydra.queue(request)
+          hydra.run
+        end
+
+        it "should take into account body for POST request" do
+          stub_request(:post, "www.example.com").with(body: {hello: 'world'})
+          response = Typhoeus.post("http://www.example.com", method: :post, body: {hello: 'world'})
+          expect(response.code).to eq(200)
         end
 
         it "should take into account params for GET request" do
-          stub_request(:get, "http://www.example.com/?hello=world")
-          Typhoeus::Request.get("www.example.com", :params => {:hello => 'world'})
+          stub_request(:get, "http://www.example.com/?hello=world").to_return({})
+          request = Typhoeus::Request.new("http://www.example.com/?hello=world", method: :get)
+          hydra.queue(request)
+          hydra.run
         end
       end
 
@@ -31,42 +58,76 @@ unless RUBY_PLATFORM =~ /java/
         it "should support native typhoeus timeouts" do
           stub_request(:any, "example.com").to_timeout
 
-          response = Typhoeus::Request.get("http://example.com")
+          request = Typhoeus::Request.new("http://example.com", method: :get)
+          hydra.queue(request)
+          hydra.run
 
-          response.should be_timed_out
+          expect(request.response).to be_timed_out
         end
       end
 
       describe "callbacks" do
         before(:each) do
-          @hydra = Typhoeus::Hydra.new
           @request = Typhoeus::Request.new("http://example.com")
         end
 
         it "should call on_complete with 2xx response" do
           body = "on_success fired"
-          stub_request(:any, "example.com").to_return(:body => body)
+          stub_request(:any, "example.com").to_return(body: body)
 
           test = nil
-          @hydra.on_complete do |c|
+          Typhoeus.on_complete do |c|
             test = c.body
           end
-          @hydra.queue @request
-          @hydra.run
-          test.should == body
+          hydra.queue @request
+          hydra.run
+          expect(test).to eq(body)
         end
 
         it "should call on_complete with 5xx response" do
           response_code = 599
-          stub_request(:any, "example.com").to_return(:status => [response_code, "Server On Fire"])
+          stub_request(:any, "example.com").to_return(status: [response_code, "Server On Fire"])
 
           test = nil
-          @hydra.on_complete do |c|
+          Typhoeus.on_complete do |c|
             test = c.code
           end
-          @hydra.queue @request
-          @hydra.run
-          test.should == response_code
+          hydra.queue @request
+          hydra.run
+          expect(test).to eq(response_code)
+        end
+
+        it "should call on_body with 2xx response" do
+          body = "on_body fired"
+          stub_request(:any, "example.com").to_return(body: body)
+
+          test_body = nil
+          test_complete = nil
+          skip("This test requires a newer version of Typhoeus") unless @request.respond_to?(:on_body)
+          @request.on_body do |body_chunk, response|
+            test_body = body_chunk
+          end
+          @request.on_complete do |response|
+            test_complete = response.body
+          end
+          hydra.queue @request
+          hydra.run
+          expect(test_body).to eq(body)
+          expect(test_complete).to eq("")
+        end
+
+        it "should call on_headers with 2xx response" do
+          body = "on_headers fired"
+          stub_request(:any, "example.com").to_return(body: body, headers: {'X-Test' => '1'})
+
+          test_headers = nil
+          skip("This test requires a newer version of Typhoeus") unless @request.respond_to?(:on_headers)
+          @request.on_headers do |response|
+            test_headers = response.headers
+          end
+          hydra.queue @request
+          hydra.run
+          expect(test_headers.to_h).to include('X-Test' => '1')
         end
       end
     end

data/spec/acceptance/typhoeus/typhoeus_hydra_spec_helper.rb

@@ -6,26 +6,30 @@ module TyphoeusHydraSpecHelper
 
 
   def http_request(method, uri, options = {}, &block)
-    uri.gsub!(" ", "%20") #typhoeus doesn't like spaces in the uri
-    request = Typhoeus::Request.new(uri,
-      {
-        :method  => method,
-        :body    => options[:body],
-        :headers => options[:headers],
-        :timeout => 25000
-      }
-    )
-    hydra = Typhoeus::Hydra.new(:initial_pool_size => 0)
+    uri = uri.gsub(" ", "%20") #typhoeus doesn't like spaces in the uri
+    request_options =  {
+      method: method,
+      body: options[:body],
+      headers: options[:headers],
+      timeout: 25000
+    }
+    if options[:basic_auth]
+      request_options[:userpwd] = options[:basic_auth].join(':')
+    end
+    request = Typhoeus::Request.new(uri, request_options)
+
+    hydra = Typhoeus::Hydra.new
     hydra.queue(request)
     hydra.run
+
     response = request.response
+    raise FakeTyphoeusHydraConnectError.new if response.return_code == :couldnt_connect
     raise FakeTyphoeusHydraTimeoutError.new if response.timed_out?
-    raise FakeTyphoeusHydraConnectError.new if response.code == 0
     OpenStruct.new({
-      :body => response.body,
-      :headers => WebMock::Util::Headers.normalize_headers(join_array_values(response.headers_hash)),
-      :status => response.code.to_s,
-      :message => response.status_message
+      body: response.body,
+      headers: WebMock::Util::Headers.normalize_headers(join_array_values(response.headers)),
+      status: response.code.to_s,
+      message: response.status_message
     })
   end
 

data/spec/acceptance/webmock_shared.rb

@@ -10,8 +10,8 @@ require 'acceptance/shared/complex_cross_concern_behaviors'
 
 unless defined? SAMPLE_HEADERS
   SAMPLE_HEADERS = { "Content-Length" => "8888", "Accept" => "application/json" }
-  ESCAPED_PARAMS = "x=ab%20c&z=%27Stop%21%27%20said%20Fred"
-  NOT_ESCAPED_PARAMS = "z='Stop!' said Fred&x=ab c"
+  ESCAPED_PARAMS = "x=ab%20c&z=%27Stop%21%27%20said%20Fred%20m"
+  NOT_ESCAPED_PARAMS = "z='Stop!' said Fred m&x=ab c"
 end
 
 shared_examples "with WebMock" do |*adapter_info|

data/spec/fixtures/test.txt

@@ -0,0 +1 @@
+test

data/spec/quality_spec.rb

@@ -2,6 +2,30 @@ require "spec_helper"
 
 # Borrowed from Bundler
 # https://github.com/carlhuda/bundler/blob/1-0-stable/spec/quality_spec.rb
+# Portions copyright (c) 2010 Andre Arko
+# Portions copyright (c) 2009 Engine Yard
+
+# MIT License
+
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
 describe "The library itself" do
   def check_for_tab_characters(filename)
     failing_lines = []
@@ -27,7 +51,7 @@ describe "The library itself" do
   end
 
   RSpec::Matchers.define :be_well_formed do
-    failure_message_for_should do |actual|
+    failure_message do |actual|
       actual.join("\n")
     end
 
@@ -45,13 +69,13 @@ describe "The library itself" do
         error_messages << check_for_extra_spaces(filename)
       end
     end
-    error_messages.compact.should be_well_formed
+    expect(error_messages.compact).to be_well_formed
   end
 
   it "can still be built" do
     Dir.chdir(File.expand_path('../../', __FILE__)) do
       `gem build webmock.gemspec`
-      $?.should == 0
+      expect($?).to eq(0)
 
       # clean up the .gem generated
       system("rm webmock-#{WebMock.version}.gem")

data/spec/spec_helper.rb

@@ -6,6 +6,9 @@ unless RUBY_PLATFORM =~ /java/
   require 'em-http'
   require 'typhoeus'
 end
+if RUBY_PLATFORM =~ /java/
+  require 'manticore'
+end
 
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
@@ -16,19 +19,18 @@ require 'webmock/rspec'
 require 'support/network_connection'
 require 'support/webmock_server'
 require 'support/my_rack_app'
+require 'support/failures'
 
-CURL_EXAMPLE_OUTPUT_PATH = File.expand_path(File.dirname(__FILE__)) + "/support/example_curl_output.txt" unless defined? CURL_EXAMPLE_OUTPUT_PATH
+CURL_EXAMPLE_OUTPUT_PATH = File.expand_path('../support/example_curl_output.txt', __FILE__)
 
 RSpec.configure do |config|
-  unless NetworkConnection.is_network_available?
+  no_network_connection = ENV["NO_CONNECTION"] || ! NetworkConnection.is_network_available?
+  if no_network_connection
     warn("No network connectivity. Only examples which do not make real network connections will run.")
-    no_network_connection = true
-  end
-  if ENV["NO_CONNECTION"] || no_network_connection
-    config.filter_run_excluding :net_connect => true
+    config.filter_run_excluding net_connect: true
   end
 
-  config.filter_run_excluding :without_webmock => true
+  config.filter_run_excluding without_webmock: true
 
   config.before(:suite) do
     WebMockServer.instance.start unless WebMockServer.instance.started
@@ -38,20 +40,9 @@ RSpec.configure do |config|
     WebMockServer.instance.stop
   end
 
-  config.filter_run :focus => true
+  config.filter_run focus: true
   config.run_all_when_everything_filtered = true
-end
 
-def fail()
-  raise_error(RSpec::Expectations::ExpectationNotMetError)
+  config.include Failures
 end
 
-def fail_with(message)
-  raise_error(RSpec::Expectations::ExpectationNotMetError, message)
-end
-
-class Proc
-  def should_pass
-    lambda { self.call }.should_not raise_error
-  end
-end

data/spec/support/failures.rb

@@ -0,0 +1,9 @@
+module Failures
+  def fail()
+  raise_error(RSpec::Expectations::ExpectationNotMetError)
+  end
+
+  def fail_with(message)
+    raise_error(RSpec::Expectations::ExpectationNotMetError, message)
+  end
+end

data/spec/support/my_rack_app.rb

@@ -2,7 +2,7 @@ require 'rack'
 
 class MyRackApp
   class NonArrayResponse
-    # The rack response body need not implement #join, 
+    # The rack response body need not implement #join,
     # but it must implement #each.  It need not be an Array.
     # ActionDispatch::Response, for example, exercises that fact.
     # See: http://rack.rubyforge.org/doc/SPEC.html
@@ -24,14 +24,19 @@ class MyRackApp
       when ['GET', '/locked']
         [200, {}, ["Single threaded response."]]
       when ['POST', '/greet']
-        name = env["rack.input"].read[/name=([^&]*)/, 1] || "World"
+        name = env["rack.input"].read(env["CONTENT_LENGTH"])
+        name = name.force_encoding("UTF-8") if name.respond_to? :force_encoding
+        name = name[/name=([^&]*)/, 1] || "World"
         [200, {}, ["Good to meet you, #{name}!"]]
       when ['GET', '/compute']
-        if env['SERVER_PORT'] == 80
+        if env['SERVER_PORT'] == 80 && env["SCRIPT_NAME"] == ""
           [200, {}, [""]]
         else
           [401, {}, [""]]
         end
+      when ['GET', '/error']
+        env['rack.errors'].puts('Error!')
+        [500, {}, ['']]
       else
         [404, {}, ['']]
     end

data/spec/support/network_connection.rb

@@ -1,22 +1,16 @@
-module NetworkConnection
-  def self.connect_to(host, port, timeout=nil)
-    addr = Socket.getaddrinfo(host, nil)
-    sock = Socket.new(Socket.const_get(addr[0][0]), Socket::SOCK_STREAM, 0)
+require 'timeout'
+require 'socket'
 
-    if timeout
-      secs = Integer(timeout)
-      usecs = Integer((timeout - secs) * 1_000_000)
-      optval = [secs, usecs].pack("l_2")
-      sock.setsockopt Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, optval
-      sock.setsockopt Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, optval
+module NetworkConnection
+  def self.connect_to(host, port, timeout=10)
+    Timeout.timeout(timeout) do
+      TCPSocket.new(host, port)
     end
-    sock.connect(Socket.pack_sockaddr_in(port, addr[0][3]))
-    sock
   end
 
   def self.is_network_available?
     begin
-      self.connect_to("192.0.32.10", 80, 5)
+      self.connect_to("8.8.8.8", 53, 5)
       true
     rescue
       false

data/spec/support/webmock_server.rb

@@ -23,15 +23,20 @@ class WebMockServer
 
   def start
     @started = true
-    server = WEBrick::GenericServer.new(:Port => 0, :Logger => Logger.new("/dev/null"))
+    server = WEBrick::GenericServer.new(Port: 0, Logger: Logger.new("/dev/null"))
     server.logger.level = 0
     @port = server.config[:Port]
 
     concurrent do
       ['TERM', 'INT'].each do |signal|
-        trap(signal){ server.shutdown }
+        trap(signal) do
+          Thread.new do
+            server.shutdown
+          end
+        end
       end
       server.start do |socket|
+        socket.read(1)
         socket.puts <<-EOT.gsub(/^\s+\|/, '')
           |HTTP/1.1 200 OK\r
           |Date: Fri, 31 Dec 1999 23:59:59 GMT\r
@@ -48,7 +53,7 @@ class WebMockServer
 
     loop do
       begin
-        s = TCPSocket.new("localhost", port)
+        TCPSocket.new("localhost", port)
         sleep 0.1
         break
       rescue Errno::ECONNREFUSED

data/spec/unit/api_spec.rb

@@ -0,0 +1,175 @@
+require 'spec_helper'
+
+describe WebMock::API do
+  describe '#hash_including' do
+    subject { klass.new.hash_including(args) }
+    let(:args) { { data: :one } }
+
+    context 'when mixed into a class that does not define `hash_including`' do
+      let(:klass) do
+        Class.new do
+          include WebMock::API
+        end
+      end
+
+      it 'uses WebMock::Matchers::HashIncludingMatcher' do
+        expect(subject).to be_a(WebMock::Matchers::HashIncludingMatcher)
+      end
+
+      #  by testing equality for HashIncludingMatcher (which stringifies the passed hash) we are
+      #  testing HashIncludingMatcher.initialize behavior as well
+      context "when args correspond to an hash" do
+        it "creates 'HashIncludingMatcher'" do
+          expect(subject).to eq("data" => :one)
+        end
+      end
+
+      context "when args are one or many keys" do
+        subject {klass.new.hash_including(:foo, :bar)}
+        let(:anything) { WebMock::Matchers::AnyArgMatcher.new(nil) }
+
+        it "creates 'HashIncludingMatcher' with keys anythingized" do
+          expect(subject).to eq("foo" => anything, "bar" => anything )
+        end
+      end
+
+      context "when args are both keys and key/value pairs" do
+        subject {klass.new.hash_including(:foo, :bar, data: :one)}
+        let(:anything) { WebMock::Matchers::AnyArgMatcher.new(nil) }
+
+        it "creates 'HashIncludingMatcher' with keys anythingized" do
+          expect(subject).to eq("foo" => anything, "bar" => anything, "data" => :one)
+        end
+      end
+
+      context "when args are an empty hash" do
+        subject {klass.new.hash_including({})}
+
+        it "creates 'HashIncludingMatcher' with an empty hash" do
+          expect(subject).to eq({})
+        end
+      end
+    end
+
+
+    context 'when mixed into a class with a parent that defines `hash_including`' do
+      subject { klass.new.hash_including(*args) }
+      let(:args) { %w(:foo, :bar, {:data => :one}) }
+      let(:klass) do
+        Class.new(
+          Class.new do
+            def hash_including(*args)
+              args
+            end
+          end
+        ) { include WebMock::API }
+      end
+
+      it 'uses super and passes the args untampered' do
+        expect(subject).to eq(args)
+      end
+    end
+  end
+
+  describe '#hash_excluding' do
+    subject { klass.new.hash_excluding(args) }
+    let(:args) { { data: :one } }
+
+    context 'when mixed into a class that does not define `hash_including`' do
+      let(:klass) do
+        Class.new do
+          include WebMock::API
+        end
+      end
+
+      it 'uses WebMock::Matchers::HashIncludingMatcher' do
+        expect(subject).to be_a(WebMock::Matchers::HashExcludingMatcher)
+      end
+
+      #  by testing equality for HashIncludingMatcher (which stringifies the passed hash) we are
+      #  testing HashIncludingMatcher.initialize behavior as well
+      context 'when args correspond to an hash' do
+        context 'creates "HashExcludingMatcher"' do
+          it 'equals hash with similar key but different value' do
+            expect(subject).to eq('data' => :two)
+          end
+
+          it 'equals hash with similar value but different key' do
+            expect(subject).to eq('data2' => :one)
+          end
+
+          it 'equals hash with defferent value and key' do
+            expect(subject).to eq('data2' => :two)
+          end
+
+          it 'not equals with similar value and key' do
+            expect(subject).not_to eq('data' => :one)
+          end
+        end
+      end
+
+      context 'when args are one or many keys' do
+        subject { klass.new.hash_excluding(:foo, :bar) }
+        let(:anything) { WebMock::Matchers::AnyArgMatcher.new(nil) }
+
+        it "creates 'HashExcludingMatcher' with keys anythingized" do
+          expect(subject).not_to eq('foo' => anything, 'bar' => anything )
+        end
+      end
+
+      context 'when args are both keys and key/value pairs' do
+        subject { klass.new.hash_excluding(:foo, :bar, data: :one) }
+        let(:anything) { WebMock::Matchers::AnyArgMatcher.new(nil) }
+
+        it 'creates "HashExcludingMatcher" with keys anythingized' do
+          expect(subject).not_to eq('foo' => anything, 'bar' => anything, 'data' => :one)
+        end
+      end
+
+      context 'when args are an empty hash' do
+        subject { klass.new.hash_excluding({}) }
+
+        it 'creates "HashExcludingMatcher" with an empty hash' do
+          expect(subject).to eq({})
+        end
+      end
+    end
+
+    context 'when mixed into a class with a parent that defines `hash_excluding`' do
+      subject { klass.new.hash_excluding(*args) }
+      let(:args) { %w(:foo, :bar, {:data => :one}) }
+      let(:klass) do
+        Class.new(
+          Class.new do
+            def hash_excluding(*args)
+              args
+            end
+          end
+        ) { include WebMock::API }
+      end
+
+      it 'uses super and passes the args untampered' do
+        expect(subject).to eq(args)
+      end
+    end
+  end
+
+  describe '#reset_executed_requests!' do
+    subject {  WebMock::API.reset_executed_requests! }
+
+    let(:request_signature) { WebMock::RequestSignature.new(:get, "www.example.com") }
+    let(:request_pattern)   { WebMock::RequestPattern.new(:get, "www.example.com") }
+
+    before do
+      WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
+    end
+
+    it 'resets request registry counter' do
+      expect{
+        subject
+      }.to change{
+        WebMock::RequestRegistry.instance.times_executed(request_pattern)
+      }.from(1).to(0)
+    end
+  end
+end