webmock 3.18.1 → 3.19.0

data/spec/acceptance/typhoeus/typhoeus_hydra_spec.rb

@@ -1,135 +0,0 @@
-require 'spec_helper'
-require 'acceptance/webmock_shared'
-
-unless RUBY_PLATFORM =~ /java/
-  require 'acceptance/typhoeus/typhoeus_hydra_spec_helper'
-
-  describe "Typhoeus::Hydra" do
-    include TyphoeusHydraSpecHelper
-    let(:hydra) { Typhoeus::Hydra.new }
-
-    before do
-      Typhoeus::Expectation.clear
-    end
-
-    include_context "with WebMock"
-
-    describe "Typhoeus::Hydra features" do
-      before(:each) do
-        WebMock.disable_net_connect!
-        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/?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").to_return({})
-          request = Typhoeus::Request.new("http://www.example.com/?hello=world", method: :get)
-          hydra.queue(request)
-          hydra.run
-        end
-      end
-
-      describe "timeouts" do
-        it "should support native typhoeus timeouts" do
-          stub_request(:any, "example.com").to_timeout
-
-          request = Typhoeus::Request.new("http://example.com", method: :get)
-          hydra.queue(request)
-          hydra.run
-
-          expect(request.response).to be_timed_out
-        end
-      end
-
-      describe "callbacks" do
-        before(:each) do
-          @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)
-
-          test = nil
-          Typhoeus.on_complete do |c|
-            test = c.body
-          end
-          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"])
-
-          test = nil
-          Typhoeus.on_complete do |c|
-            test = c.code
-          end
-          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
-  end
-end

data/spec/acceptance/typhoeus/typhoeus_hydra_spec_helper.rb

@@ -1,60 +0,0 @@
-require 'ostruct'
-
-module TyphoeusHydraSpecHelper
-  class FakeTyphoeusHydraTimeoutError < StandardError; end
-  class FakeTyphoeusHydraConnectError < StandardError; end
-
-
-  def http_request(method, uri, options = {}, &block)
-    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?
-    OpenStruct.new({
-      body: response.body,
-      headers: WebMock::Util::Headers.normalize_headers(join_array_values(response.headers)),
-      status: response.code.to_s,
-      message: response.status_message
-    })
-  end
-
-  def join_array_values(hash)
-    joined = {}
-    if hash
-     hash.each do |k,v|
-       v = v.join(", ") if v.is_a?(Array)
-       joined[k] = v
-     end
-    end
-    joined
-  end
-
-
-  def client_timeout_exception_class
-    FakeTyphoeusHydraTimeoutError
-  end
-
-  def connection_refused_exception_class
-    FakeTyphoeusHydraConnectError
-  end
-
-  def http_library
-    :typhoeus
-  end
-
-end

data/spec/acceptance/webmock_shared.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-require 'acceptance/shared/enabling_and_disabling_webmock'
-require 'acceptance/shared/returning_declared_responses'
-require 'acceptance/shared/callbacks'
-require 'acceptance/shared/request_expectations'
-require 'acceptance/shared/stubbing_requests'
-require 'acceptance/shared/allowing_and_disabling_net_connect'
-require 'acceptance/shared/precedence_of_stubs'
-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%20m"
-  NOT_ESCAPED_PARAMS = "z='Stop!' said Fred m&x=ab c"
-end
-
-shared_examples "with WebMock" do |*adapter_info|
-  describe "with WebMock" do
-    let(:webmock_server_url) {"http://#{WebMockServer.instance.host_with_port}/"}
-    before(:each) do
-      WebMock.disable_net_connect!
-      WebMock.reset!
-    end
-
-    include_context "allowing and disabling net connect", *adapter_info
-
-    include_context "stubbing requests", *adapter_info
-
-    include_context "declared responses", *adapter_info
-
-    include_context "precedence of stubs", *adapter_info
-
-    include_context "request expectations", *adapter_info
-
-    include_context "callbacks", *adapter_info
-
-    include_context "enabled and disabled webmock", *adapter_info
-
-    include_context "complex cross-concern behaviors", *adapter_info
-  end
-end

data/spec/fixtures/test.txt

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

data/spec/quality_spec.rb

@@ -1,84 +0,0 @@
-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 = []
-    File.readlines(filename).each_with_index do |line,number|
-      failing_lines << number + 1 if line =~ /\t/
-    end
-
-    unless failing_lines.empty?
-      "#{filename} has tab characters on lines #{failing_lines.join(', ')}"
-    end
-  end
-
-  def check_for_extra_spaces(filename)
-    failing_lines = []
-    File.readlines(filename).each_with_index do |line,number|
-      next if line =~ /^\s+#.*\s+\n$/
-      failing_lines << number + 1 if line =~ /\s+\n$/
-    end
-
-    unless failing_lines.empty?
-      "#{filename} has spaces on the EOL on lines #{failing_lines.join(', ')}"
-    end
-  end
-
-  RSpec::Matchers.define :be_well_formed do
-    failure_message do |actual|
-      actual.join("\n")
-    end
-
-    match do |actual|
-      actual.empty?
-    end
-  end
-
-  it "has no malformed whitespace" do
-    error_messages = []
-    Dir.chdir(File.expand_path("../..", __FILE__)) do
-      `git ls-files`.split("\n").each do |filename|
-        next if filename =~ /\.gitmodules|fixtures/
-        error_messages << check_for_tab_characters(filename)
-        error_messages << check_for_extra_spaces(filename)
-      end
-    end
-    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`
-      expect($?).to eq(0)
-
-      # clean up the .gem generated
-      system("rm webmock-#{WebMock.version}.gem")
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,48 +0,0 @@
-require 'rubygems'
-require 'httpclient'
-unless RUBY_PLATFORM =~ /java/
-  require 'curb'
-  require 'patron'
-  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'))
-require 'rspec'
-
-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('../support/example_curl_output.txt', __FILE__)
-
-RSpec.configure do |config|
-  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.")
-    config.filter_run_excluding net_connect: true
-  end
-
-  config.filter_run_excluding without_webmock: true
-
-  config.before(:suite) do
-    WebMockServer.instance.start unless WebMockServer.instance.started
-  end
-
-  config.after(:suite) do
-    WebMockServer.instance.stop
-  end
-
-  config.filter_run focus: true
-  config.run_all_when_everything_filtered = true
-
-  config.include Failures
-end
-

data/spec/support/example_curl_output.txt

@@ -1,22 +0,0 @@
-HTTP/1.1 202 OK
-Content-Type: text/html; charset=UTF-8
-Connection: Keep-Alive
-Date: Sat, 23 Jan 2010 01:01:05 GMT
-Content-Length: 419
-Accept: image/jpeg
-Accept: image/png
-
-<HTML>
-<HEAD>
-  <TITLE>Example Web Page</TITLE>
-</HEAD>
-<body>
-<p>You have reached this web page by typing &quot;example.com&quot;,
-&quot;example.net&quot;,
-  or &quot;example.org&quot; into your web browser.</p>
-<p>These domain names are reserved for use in documentation and are not available
-  for registration. See <a href="http://www.rfc-editor.org/rfc/rfc2606.txt">RFC
-  2606</a>, Section 3.</p>
-</BODY>
-</HTML>
-

data/spec/support/failures.rb

@@ -1,9 +0,0 @@
-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

@@ -1,53 +0,0 @@
-require 'rack'
-
-class MyRackApp
-  class NonArrayResponse
-    # 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
-
-    def each(*args, &blk)
-      ["This is not in an array!"].each(*args, &blk)
-    end
-  end
-
-  def self.call(env)
-    case env.values_at('REQUEST_METHOD', 'PATH_INFO')
-      when ['GET', '/']
-        [200, {}, ["This is my root!"]]
-      when ['GET', '/greet']
-        name = env['QUERY_STRING'][/name=([^&]*)/, 1] || "World"
-        [200, {}, ["Hello, #{name}"]]
-      when ['GET', '/non_array_response']
-        [200, {}, NonArrayResponse.new]
-      when ['GET', '/locked']
-        [200, {}, ["Single threaded response."]]
-      when ['POST', '/greet']
-        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 && env["SCRIPT_NAME"] == ""
-          [200, {}, [""]]
-        else
-          [401, {}, [""]]
-        end
-      when ['GET', '/error']
-        env['rack.errors'].puts('Error!')
-        [500, {}, ['']]
-      else
-        [404, {}, ['']]
-    end
-  end
-end
-
-class MyLockedRackApp
-  MUTEX = Mutex.new
-
-  def self.call(env)
-    lock = Rack::Lock.new(MyRackApp, MUTEX)
-    lock.call(env)
-  end
-end

data/spec/support/network_connection.rb

@@ -1,19 +0,0 @@
-require 'timeout'
-require 'socket'
-
-module NetworkConnection
-  def self.connect_to(host, port, timeout=10)
-    Timeout.timeout(timeout) do
-      TCPSocket.new(host, port)
-    end
-  end
-
-  def self.is_network_available?
-    begin
-      self.connect_to("8.8.8.8", 53, 5)
-      true
-    rescue
-      false
-    end
-  end
-end

data/spec/support/webmock_server.rb

@@ -1,70 +0,0 @@
-require 'webrick'
-require 'logger'
-require 'singleton'
-
-class WebMockServer
-  include Singleton
-
-  attr_reader :port, :started
-
-  def host_with_port
-    "localhost:#{port}"
-  end
-
-  def concurrent
-    unless RUBY_PLATFORM =~ /java/
-      @pid = Process.fork do
-        yield
-      end
-    else
-      Thread.new { yield }
-    end
-  end
-
-  def start
-    @started = true
-    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) 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
-          |Content-Type: text/html\r
-          |Content-Length: 11\r
-          |Set-Cookie: bar\r
-          |Set-Cookie: foo\r
-          |\r
-          |hello world
-        EOT
-      end
-    end
-
-
-    loop do
-      begin
-        TCPSocket.new("localhost", port)
-        sleep 0.1
-        break
-      rescue Errno::ECONNREFUSED
-        sleep 0.1
-      end
-    end
-  end
-
-  def stop
-    if @pid
-      Process.kill('INT', @pid)
-    end
-  end
-end