typhoeus 0.6.3 → 0.6.4

data/spec/rack/typhoeus/middleware/params_decoder_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe "Rack::Typhoeus::Middleware::ParamsDecoder" do
+
+  before(:all) do
+    require "rack/typhoeus"
+  end
+
+  let(:app) do
+    stub
+  end
+
+  let(:env) do
+    stub
+  end
+
+  let(:klass) do
+    Rack::Typhoeus::Middleware::ParamsDecoder
+  end
+
+  describe "#call" do
+  end
+
+  context "when requesting" do
+    let(:response) { Typhoeus.get("localhost:3001", :params => {:x => [:a]}) }
+
+    it "transforms parameters" do
+      expect(response.body).to include("query_hash\":{\"x\":[\"a\"]}")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,35 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require "bundler"
+Bundler.setup
+require "typhoeus"
+require "rspec"
+
+if defined? require_relative
+  require_relative 'support/localhost_server.rb'
+  require_relative 'support/server.rb'
+else
+  require 'support/localhost_server.rb'
+  require 'support/server.rb'
+end
+
+RSpec.configure do |config|
+  config.order = :rand
+
+  config.before(:suite) do
+    LocalhostServer.new(TESTSERVER.new, 3001)
+  end
+
+  config.after do
+    Typhoeus::Pool.clear
+    Typhoeus::Expectation.clear
+    Typhoeus.before.clear
+    Typhoeus.on_complete.clear
+    Typhoeus.on_success.clear
+    Typhoeus.on_failure.clear
+    Typhoeus::Config.verbose = false
+    Typhoeus::Config.block_connection = false
+    Typhoeus::Config.memoize = false
+  end
+end

data/spec/support/localhost_server.rb

@@ -0,0 +1,94 @@
+require 'rack'
+require 'rack/handler/webrick'
+require 'net/http'
+
+# The code for this is inspired by Capybara's server:
+#   http://github.com/jnicklas/capybara/blob/0.3.9/lib/capybara/server.rb
+class LocalhostServer
+  READY_MESSAGE = "Server ready"
+
+  class Identify
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      if env["PATH_INFO"] == "/__identify__"
+        [200, {}, [LocalhostServer::READY_MESSAGE]]
+      else
+        @app.call(env)
+      end
+    end
+  end
+
+  attr_reader :port
+
+  def initialize(rack_app, port = nil)
+    @port = port || find_available_port
+    @rack_app = rack_app
+    concurrently { boot }
+    wait_until(10, "Boot failed.") { booted? }
+  end
+
+  private
+
+  def find_available_port
+    server = TCPServer.new('127.0.0.1', 0)
+    server.addr[1]
+  ensure
+    server.close if server
+  end
+
+  def boot
+    # Use WEBrick since it's part of the ruby standard library and is available on all ruby interpreters.
+    options = { :Port => port }
+    options.merge!(:AccessLog => [], :Logger => WEBrick::BasicLog.new(StringIO.new)) unless ENV['VERBOSE_SERVER']
+    Rack::Handler::WEBrick.run(Identify.new(@rack_app), options)
+  end
+
+  def booted?
+    res = ::Net::HTTP.get_response("localhost", '/__identify__', port)
+    if res.is_a?(::Net::HTTPSuccess) or res.is_a?(::Net::HTTPRedirection)
+      return res.body == READY_MESSAGE
+    end
+  rescue Errno::ECONNREFUSED, Errno::EBADF
+    return false
+  end
+
+  def concurrently
+    if should_use_subprocess?
+      pid = Process.fork do
+        trap(:INT) { ::Rack::Handler::WEBrick.shutdown }
+        yield
+        exit # manually exit; otherwise this sub-process will re-run the specs that haven't run yet.
+      end
+
+      at_exit do
+        Process.kill('INT', pid)
+        begin
+          Process.wait(pid)
+        rescue Errno::ECHILD
+          # ignore this error...I think it means the child process has already exited.
+        end
+      end
+    else
+      Thread.new { yield }
+    end
+  end
+
+  def should_use_subprocess?
+    # !ENV['THREADED']
+    false
+  end
+
+  def wait_until(timeout, error_message, &block)
+    start_time = Time.now
+
+    while true
+      return if yield
+      raise TimeoutError.new(error_message) if (Time.now - start_time) > timeout
+      sleep(0.05)
+    end
+  end
+end
+

data/spec/support/server.rb

@@ -0,0 +1,108 @@
+#!/usr/bin/env ruby
+require 'json'
+require 'zlib'
+require 'sinatra/base'
+require 'rack/typhoeus'
+
+TESTSERVER = Sinatra.new do
+  set :logging, false
+  use Rack::Typhoeus::Middleware::ParamsDecoder
+
+  fail_count = 0
+
+  post '/file' do
+    {
+      'content-type' => params[:file][:type],
+      'filename' => params[:file][:filename],
+      'content' => params[:file][:tempfile].read,
+      'request-content-type' => request.env['CONTENT_TYPE']
+    }.to_json
+  end
+
+  get '/multiple-headers' do
+    [200, { 'Set-Cookie' => %w[ foo bar ], 'Content-Type' => 'text/plain' }, ['']]
+  end
+
+  get '/fail/:number' do
+    if fail_count >= params[:number].to_i
+      "ok"
+    else
+      fail_count += 1
+      error 500, "oh noes!"
+    end
+  end
+
+  get '/fail_forever' do
+    error 500, "oh noes!"
+  end
+
+  get '/redirect' do
+    redirect '/'
+  end
+
+  get '/bad_redirect' do
+    redirect '/bad_redirect'
+  end
+
+  get '/auth_basic/:username/:password' do
+    @auth ||=  Rack::Auth::Basic::Request.new(request.env)
+    # Check that we've got a basic auth, and that it's credentials match the ones
+    # provided in the request
+    if @auth.provided? && @auth.basic? && @auth.credentials == [ params[:username], params[:password] ]
+      # auth is valid - confirm it
+      true
+    else
+      # invalid auth - request the authentication
+      response['WWW-Authenticate'] = %(Basic realm="Testing HTTP Auth")
+      throw(:halt, [401, "Not authorized\n"])
+    end
+  end
+
+  get '/auth_ntlm' do
+    # we're just checking for the existence if NTLM auth header here. It's validation
+    # is too troublesome and really doesn't bother is much, it's up to libcurl to make
+    # it valid
+    response['WWW-Authenticate'] = 'NTLM'
+    is_ntlm_auth = /^NTLM/ =~ request.env['HTTP_AUTHORIZATION']
+    true if is_ntlm_auth
+    throw(:halt, [401, "Not authorized\n"]) if !is_ntlm_auth
+  end
+
+  get '/gzipped' do
+    req_env = request.env.to_json
+    z = Zlib::Deflate.new
+    gzipped_env = z.deflate(req_env, Zlib::FINISH)
+    z.close
+    response['Content-Encoding'] = 'gzip'
+    gzipped_env
+  end
+
+  get '/**' do
+    sleep params["delay"].to_i if params.has_key?("delay")
+    request.env.merge!(:body => request.body.read).to_json
+  end
+
+  head '/**' do
+    sleep params["delay"].to_i if params.has_key?("delay")
+  end
+
+  put '/**' do
+    request.env.merge!(:body => request.body.read).to_json
+  end
+
+  post '/**' do
+    request.env.merge!(:body => request.body.read).to_json
+  end
+
+  delete '/**' do
+    request.env.merge!(:body => request.body.read).to_json
+  end
+
+  patch '/**' do
+    request.env.merge!(:body => request.body.read).to_json
+  end
+
+  options '/**' do
+    request.env.merge!(:body => request.body.read).to_json
+  end
+end

data/spec/typhoeus/adapters/faraday_spec.rb

@@ -0,0 +1,245 @@
+require 'spec_helper'
+require 'typhoeus/adapters/faraday'
+
+describe Faraday::Adapter::Typhoeus do
+  let(:base_url) { "http://localhost:3001" }
+  let(:adapter) { described_class.new }
+  let(:request) { Typhoeus::Request.new(base_url) }
+  let(:conn) do
+    Faraday.new(:url => base_url) do |faraday|
+      faraday.adapter  :typhoeus
+    end
+  end
+  let(:response) { conn.get("/") }
+
+  context "when parallel" do
+    it "returns a faraday response" do
+      response = nil
+      conn.in_parallel { response = conn.get("/") }
+      expect(response).to be_a(Faraday::Response)
+    end
+
+    it "succeeds" do
+      response = nil
+      conn.in_parallel { response = conn.get("/") }
+      expect(response.status).to be(200)
+    end
+  end
+
+  context "when not parallel" do
+    it "returns a faraday response" do
+      expect(response).to be_a(Faraday::Response)
+    end
+
+    it "succeeds" do
+      expect(response.status).to be(200)
+    end
+  end
+
+  describe "#perform_request" do
+    let(:env) { {} }
+
+    context "when body" do
+      let(:env) { { :body => double(:read => "body") } }
+
+      it "reads body" do
+        expect(adapter.method(:read_body).call(env)).to eq("body")
+      end
+    end
+
+    context "parallel_manager" do
+      context "when given" do
+        let(:env) { { :parallel_manager => double(:queue => true), :ssl => {}, :request => {} } }
+
+        it "uses" do
+          adapter.method(:perform_request).call(env)
+        end
+      end
+
+      context "when not given" do
+        let(:env) { { :method => :get, :ssl => {}, :request => {} } }
+
+        it "falls back to single" do
+          Typhoeus::Request.should_receive(:new).and_return(double(:options => {}, :on_complete => [], :run => true))
+          adapter.method(:perform_request).call(env)
+        end
+      end
+    end
+  end
+
+  describe "#request" do
+    let(:env) do
+      { :url => "url", :method => :get, :body => "body", :request_headers => {}, :ssl => {}, :request => {} }
+    end
+
+    let(:request) { adapter.method(:request).call(env) }
+
+    it "returns request" do
+      expect(request).to be_a(Typhoeus::Request)
+    end
+
+    it "sets url" do
+      expect(request.base_url).to eq("url")
+    end
+
+    it "sets http method" do
+      expect(request.original_options[:method]).to eq(:get)
+    end
+
+    it "sets body" do
+      expect(request.original_options[:body]).to eq("body")
+    end
+
+    it "sets headers" do
+      expect(request.original_options[:headers]).to eq({})
+    end
+
+    it "sets on_complete callback" do
+      expect(request.on_complete).to have(1).items
+    end
+  end
+
+  describe "#configure_socket" do
+    let(:env) { { :request => { :bind => { :host => "interface" } } } }
+
+    before { adapter.method(:configure_socket).call(request, env) }
+
+    context "when host" do
+      it "sets interface" do
+        expect(request.options[:interface]).to eq("interface")
+      end
+    end
+  end
+
+  describe "#configure_timeout" do
+    before { adapter.method(:configure_timeout).call(request, env) }
+
+    context "when timeout" do
+      let(:env) { { :request => { :timeout => 1 } } }
+
+      it "sets timeout_ms" do
+        expect(request.options[:timeout_ms]).to eq(1000)
+      end
+    end
+
+    context "when open_timeout" do
+      let(:env) { { :request => { :open_timeout => 1 } } }
+
+      it "sets connecttimeout_ms" do
+        expect(request.options[:connecttimeout_ms]).to eq(1000)
+      end
+    end
+  end
+
+  describe "#configure_proxy" do
+    before { adapter.method(:configure_proxy).call(request, env) }
+
+    context "when proxy" do
+      let(:env) { { :request => { :proxy => { :uri => double(:host => "localhost", :port => "3001") } } } }
+
+      it "sets proxy" do
+        expect(request.options[:proxy]).to eq("localhost:3001")
+      end
+
+      context "when username and password" do
+        let(:env) do
+          { :request => { :proxy => {
+            :uri => double(:host => :a, :port => :b),
+            :username => "a",
+            :password => "b"
+          } } }
+        end
+
+        it "sets proxyuserpwd" do
+          expect(request.options[:proxyuserpwd]).to eq("a:b")
+        end
+      end
+    end
+  end
+
+  describe "#configure_ssl" do
+    before { adapter.method(:configure_ssl).call(request, env) }
+
+    context "when version" do
+      let(:env) { { :ssl => { :version => "a" } } }
+
+      it "sets sslversion" do
+        expect(request.options[:sslversion]).to eq("a")
+      end
+    end
+
+    context "when client_cert" do
+      let(:env) { { :ssl => { :client_cert => "a" } } }
+
+      it "sets sslcert" do
+        expect(request.options[:sslcert]).to eq("a")
+      end
+    end
+
+    context "when client_key"  do
+      let(:env) { { :ssl => { :client_key => "a" } } }
+
+      it "sets sslkey" do
+        expect(request.options[:sslkey]).to eq("a")
+      end
+    end
+
+    context "when ca_file"  do
+      let(:env) { { :ssl => { :ca_file => "a" } } }
+
+      it "sets cainfo" do
+        expect(request.options[:cainfo]).to eq("a")
+      end
+    end
+
+    context "when ca_path" do
+      let(:env) { { :ssl => { :ca_path => "a" } } }
+
+      it "sets capath" do
+        expect(request.options[:capath]).to eq("a")
+      end
+    end
+
+    context "when verify is false" do
+      let(:env) { { :ssl => { :verify => false } } }
+
+      it "sets ssl_verifyhost to 0" do
+        expect(request.options[:ssl_verifyhost]).to eq(0)
+      end
+
+      it "sets ssl_verifypeer to false" do
+        expect(request.options[:ssl_verifypeer]).to be_false
+      end
+    end
+
+    context "when verify is true" do
+      let(:env) { { :ssl => { :verify => true } } }
+
+      it "sets ssl_verifyhost to 2" do
+        expect(request.options[:ssl_verifyhost]).to eq(2)
+      end
+
+      it "sets ssl_verifypeer to true" do
+        expect(request.options[:ssl_verifypeer]).to be_true
+      end
+    end
+  end
+
+  describe "#parallel?" do
+    context "when parallel_manager" do
+      let(:env) { { :parallel_manager => true } }
+
+      it "returns true" do
+        expect(adapter.method(:parallel?).call(env)).to be_true
+      end
+    end
+
+    context "when no parallel_manager" do
+      let(:env) { { :parallel_manager => nil } }
+
+      it "returns false" do
+        expect(adapter.method(:parallel?).call(env)).to be_false
+      end
+    end
+  end
+end