faraday 0.6.0 → 0.9.0

data/test/env_test.rb

@@ -1,56 +1,80 @@
-require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require File.expand_path('../helper', __FILE__)
 
 class EnvTest < Faraday::TestCase
   def setup
-    @conn = Faraday.new :url => 'http://sushi.com/api', :headers => {'Mime-Version' => '1.0'}
-    @conn.options[:timeout]      = 3
-    @conn.options[:open_timeout] = 5
-    @conn.ssl[:verify]           = false
+    @conn = Faraday.new :url => 'http://sushi.com/api',
+      :headers => {'Mime-Version' => '1.0'},
+      :request => {:oauth => {:consumer_key => 'anonymous'}}
+
+    @conn.options.timeout      = 3
+    @conn.options.open_timeout = 5
+    @conn.ssl.verify           = false
     @conn.proxy 'http://proxy.com'
-    @input = { :body => 'abc' }
-    @env = env_for @conn do |req|
-      req.url 'foo.json', 'a' => 1
-      req['Server'] = 'Faraday'
-      req.body = @input[:body]
-    end
   end
 
   def test_request_create_stores_method
-    assert_equal :get, @env[:method]
+    env = make_env(:get)
+    assert_equal :get, env.method
   end
 
-  def test_request_create_stores_addressable_uri
-    assert_equal 'http://sushi.com/api/foo.json?a=1', @env[:url].to_s
+  def test_request_create_stores_uri
+    env = make_env do |req|
+      req.url 'foo.json', 'a' => 1
+    end
+    assert_equal 'http://sushi.com/api/foo.json?a=1', env.url.to_s
   end
 
   def test_request_create_stores_headers
-    headers = @env[:request_headers]
+    env = make_env do |req|
+      req['Server'] = 'Faraday'
+    end
+    headers = env.request_headers
     assert_equal '1.0', headers['mime-version']
     assert_equal 'Faraday', headers['server']
   end
 
   def test_request_create_stores_body
-    assert_equal @input[:body], @env[:body]
+    env = make_env do |req|
+      req.body = 'hi'
+    end
+    assert_equal 'hi', env.body
   end
 
-  def test_request_create_stores_timeout_options
-    assert_equal 3, @env[:request][:timeout]
-    assert_equal 5, @env[:request][:open_timeout]
+  def test_global_request_options
+    env = make_env
+    assert_equal 3, env.request.timeout
+    assert_equal 5, env.request.open_timeout
+  end
+
+  def test_per_request_options
+    env = make_env do |req|
+      req.options.timeout = 10
+      req.options.boundary = 'boo'
+      req.options.oauth[:consumer_secret] = 'xyz'
+    end
+    assert_equal 10, env.request.timeout
+    assert_equal 5, env.request.open_timeout
+    assert_equal 'boo', env.request.boundary
+
+    oauth_expected = {:consumer_secret => 'xyz', :consumer_key => 'anonymous'}
+    assert_equal oauth_expected, env.request.oauth
   end
 
   def test_request_create_stores_ssl_options
-    assert_equal false, @env[:ssl][:verify]
+    env = make_env
+    assert_equal false, env.ssl.verify
   end
 
   def test_request_create_stores_proxy_options
-    assert_equal 'proxy.com', @env[:request][:proxy][:uri].host
+    env = make_env
+    assert_equal 'proxy.com', env.request.proxy.host
   end
 
-  def env_for(connection)
-    env_setup = Faraday::Request.create do |req|
-      yield req
-    end
-    env_setup.to_env_hash(connection, :get)
+  private
+
+  def make_env(method = :get, connection = @conn, &block)
+    request = connection.build_request(method, &block)
+    request.to_env(connection)
   end
 end
 
@@ -59,6 +83,50 @@ class HeadersTest < Faraday::TestCase
     @headers = Faraday::Utils::Headers.new
   end
 
+  def test_normalizes_different_capitalizations
+    @headers['Content-Type'] = 'application/json'
+    assert_equal ['Content-Type'], @headers.keys
+    assert_equal 'application/json', @headers['Content-Type']
+    assert_equal 'application/json', @headers['CONTENT-TYPE']
+    assert_equal 'application/json', @headers['content-type']
+    assert @headers.include?('content-type')
+
+    @headers['content-type'] = 'application/xml'
+    assert_equal ['Content-Type'], @headers.keys
+    assert_equal 'application/xml', @headers['Content-Type']
+    assert_equal 'application/xml', @headers['CONTENT-TYPE']
+    assert_equal 'application/xml', @headers['content-type']
+  end
+
+  def test_fetch_key
+    @headers['Content-Type'] = 'application/json'
+    block_called = false
+    assert_equal 'application/json', @headers.fetch('content-type') { block_called = true }
+    assert_equal 'application/json', @headers.fetch('Content-Type')
+    assert_equal 'application/json', @headers.fetch('CONTENT-TYPE')
+    assert_equal 'application/json', @headers.fetch(:content_type)
+    assert_equal false, block_called
+
+    assert_equal 'default', @headers.fetch('invalid', 'default')
+    assert_equal false, @headers.fetch('invalid', false)
+    assert_nil   @headers.fetch('invalid', nil)
+
+    assert_equal 'Invalid key', @headers.fetch('Invalid') { |key| "#{key} key" }
+
+    expected_error = defined?(KeyError) ? KeyError : IndexError
+    assert_raises(expected_error) { @headers.fetch('invalid') }
+  end
+
+  def test_delete_key
+    @headers['Content-Type'] = 'application/json'
+    assert_equal 1, @headers.size
+    assert @headers.include?('content-type')
+    assert_equal 'application/json', @headers.delete('content-type')
+    assert_equal 0, @headers.size
+    assert !@headers.include?('content-type')
+    assert_equal nil, @headers.delete('content-type')
+  end
+
   def test_parse_response_headers_leaves_http_status_line_out
     @headers.parse("HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n")
     assert_equal %w(Content-Type), @headers.keys
@@ -82,53 +150,61 @@ end
 
 class ResponseTest < Faraday::TestCase
   def setup
-    @env = {
+    @env = Faraday::Env.from \
       :status => 404, :body => 'yikes',
-      :response_headers => Faraday::Utils::Headers.new('Content-Type' => 'text/plain')
-    }
+      :response_headers => {'Content-Type' => 'text/plain'}
     @response = Faraday::Response.new @env
   end
-  
+
   def test_finished
     assert @response.finished?
   end
-  
+
   def test_error_on_finish
     assert_raises RuntimeError do
       @response.finish({})
     end
   end
-  
+
   def test_not_success
     assert !@response.success?
   end
-  
+
   def test_status
     assert_equal 404, @response.status
   end
-  
+
   def test_body
     assert_equal 'yikes', @response.body
   end
-  
+
   def test_headers
     assert_equal 'text/plain', @response.headers['Content-Type']
     assert_equal 'text/plain', @response['content-type']
   end
-  
+
   def test_apply_request
     @response.apply_request :body => 'a=b', :method => :post
     assert_equal 'yikes', @response.body
     assert_equal :post, @response.env[:method]
   end
-  
+
   def test_marshal
     @response = Faraday::Response.new
     @response.on_complete { }
-    @response.finish @env.merge(:custom => 'moo')
-    
+    @response.finish @env.merge(:params => 'moo')
+
     loaded = Marshal.load Marshal.dump(@response)
-    assert_nil loaded.env[:custom]
+    assert_nil loaded.env[:params]
     assert_equal %w[body response_headers status], loaded.env.keys.map { |k| k.to_s }.sort
   end
+
+  def test_hash
+    hash = @response.to_hash
+    assert_kind_of Hash, hash
+    assert_equal @env.to_hash, hash
+    assert_equal hash[:status], @response.status
+    assert_equal hash[:response_headers], @response.headers
+    assert_equal hash[:body], @response.body
+  end
 end

data/test/helper.rb

@@ -1,12 +1,18 @@
-require 'test/unit'
-unless ENV['BUNDLE_GEMFILE']
-  require 'rubygems'
-  require 'bundler'
-  Bundler.setup
+require 'rubygems'         # rubygems/version doesn't work by itself
+require 'rubygems/version' # for simplecov-html
+require 'simplecov'
+require 'coveralls'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start do
+  add_filter '/bundle/'
 end
 
-require 'webmock/test_unit'
-WebMock.disable_net_connect!(:allow_localhost => true)
+gem 'minitest' if defined? Bundler
+require 'minitest/autorun'
 
 if ENV['LEFTRIGHT']
   begin
@@ -16,30 +22,60 @@ if ENV['LEFTRIGHT']
   end
 end
 
-unless $LOAD_PATH.include? 'lib'
-  $LOAD_PATH.unshift(File.dirname(__FILE__))
-  $LOAD_PATH.unshift(File.join($LOAD_PATH.first, '..', 'lib'))
-end
-require 'faraday'
-
-begin
-  require 'ruby-debug'
-rescue LoadError
-  # ignore
-else
-  Debugger.start
-end
+require File.expand_path('../../lib/faraday', __FILE__)
+
+require 'stringio'
+require 'uri'
 
 module Faraday
-  class TestCase < Test::Unit::TestCase
-    LIVE_SERVER = case ENV['LIVE']
-      when /^http/ then ENV['LIVE']
-      when nil     then nil
-      else 'http://localhost:4567'
+  module LiveServerConfig
+    def live_server=(value)
+      @@live_server = case value
+      when /^http/
+        URI(value)
+      when /./
+        URI('http://127.0.0.1:4567')
+      end
     end
 
+    def live_server?
+      defined? @@live_server
+    end
+
+    # Returns an object that responds to `host` and `port`.
+    def live_server
+      live_server? and @@live_server
+    end
+  end
+
+  class TestCase < MiniTest::Test
+    extend LiveServerConfig
+    self.live_server = ENV['LIVE']
+
     def test_default
       assert true
     end unless defined? ::MiniTest
+
+    def capture_warnings
+      old, $stderr = $stderr, StringIO.new
+      begin
+        yield
+        $stderr.string
+      ensure
+        $stderr = old
+      end
+    end
+
+    def self.jruby?
+      defined? RUBY_ENGINE and 'jruby' == RUBY_ENGINE
+    end
+
+    def self.rbx?
+      defined? RUBY_ENGINE and 'rbx' == RUBY_ENGINE
+    end
+
+    def self.ssl_mode?
+      ENV['SSL'] == 'yes'
+    end
   end
 end

data/test/live_server.rb

@@ -1,41 +1,67 @@
-require 'sinatra'
-set :logging, false
+require 'sinatra/base'
 
-get '/hello_world' do
-  'hello world'
-end
+module Faraday
+class LiveServer < Sinatra::Base
+  set :environment, :test
+  disable :logging
+  disable :protection
 
-get '/json' do
-  content_type 'application/json'
-  "[1,2,3]"
-end
+  [:get, :post, :put, :patch, :delete, :options].each do |method|
+    send(method, '/echo') do
+      kind = request.request_method.downcase
+      out = kind.dup
+      out << ' ?' << request.GET.inspect if request.GET.any?
+      out << ' ' << request.POST.inspect if request.POST.any?
 
-post '/file' do
-  if params[:uploaded_file].respond_to? :each_key
-    "file %s %s" % [
-      params[:uploaded_file][:filename],
-      params[:uploaded_file][:type]]
-  else
-    status 400
+      content_type 'text/plain'
+      return out
+    end
   end
-end
 
-%w[get post].each do |method|
-  send(method, '/hello') do
-    "hello #{params[:name]}"
+  get '/echo_header' do
+    header = "HTTP_#{params[:name].tr('-', '_').upcase}"
+    request.env.fetch(header) { 'NONE' }
   end
-end
 
-%w[post put].each do |method|
-  send(method, '/echo_name') do
-    params[:name].inspect
+  post '/file' do
+    if params[:uploaded_file].respond_to? :each_key
+      "file %s %s %d" % [
+        params[:uploaded_file][:filename],
+        params[:uploaded_file][:type],
+        params[:uploaded_file][:tempfile].size
+      ]
+    else
+      status 400
+    end
+  end
+
+  get '/multi' do
+    [200, { 'Set-Cookie' => 'one, two' }, '']
+  end
+
+  get '/who-am-i' do
+    request.env['REMOTE_ADDR']
   end
-end
 
-delete '/delete_with_json' do
-  %/{"deleted":true}/
+  get '/slow' do
+    sleep 10
+    [200, {}, 'ok']
+  end
+
+  get '/204' do
+    status 204 # no content
+  end
+
+  get '/ssl' do
+    request.secure?.to_s
+  end
+
+  error do |e|
+    "#{e.class}\n#{e.to_s}\n#{e.backtrace.join("\n")}"
+  end
+end
 end
 
-get '/multi' do
-  [200, { 'Set-Cookie' => %w[ one two ] }, '']
+if $0 == __FILE__
+  Faraday::LiveServer.run!
 end

data/test/middleware/instrumentation_test.rb

@@ -0,0 +1,88 @@
+require File.expand_path("../../helper", __FILE__)
+
+module Middleware
+  class InstrumentationTest < Faraday::TestCase
+    def setup
+      @instrumenter = FakeInstrumenter.new
+    end
+
+    def test_default_name
+      assert_equal 'request.faraday', options.name
+    end
+
+    def test_default_instrumenter
+      begin
+        instrumenter = options.instrumenter
+      rescue NameError => err
+        assert_match 'ActiveSupport', err.to_s
+      else
+        assert_equal ActiveSupport::Notifications, instrumenter
+      end
+    end
+
+    def test_name
+      assert_equal 'booya', options(:name => 'booya').name
+    end
+
+    def test_instrumenter
+      assert_equal :boom, options(:instrumenter => :boom).instrumenter
+    end
+
+    def test_instrumentation_with_default_name
+      assert_equal 0, @instrumenter.instrumentations.size
+
+      faraday = conn
+      res = faraday.get '/'
+      assert_equal 'ok', res.body
+
+      assert_equal 1, @instrumenter.instrumentations.size
+      name, env = @instrumenter.instrumentations.first
+      assert_equal 'request.faraday', name
+      assert_equal '/', env[:url].path
+    end
+
+    def test_instrumentation
+      assert_equal 0, @instrumenter.instrumentations.size
+
+      faraday = conn :name => 'booya'
+      res = faraday.get '/'
+      assert_equal 'ok', res.body
+
+      assert_equal 1, @instrumenter.instrumentations.size
+      name, env = @instrumenter.instrumentations.first
+      assert_equal 'booya', name
+      assert_equal '/', env[:url].path
+    end
+
+    class FakeInstrumenter
+      attr_reader :instrumentations
+
+      def initialize
+        @instrumentations = []
+      end
+
+      def instrument(name, env)
+        @instrumentations << [name, env]
+        yield
+      end
+    end
+
+    def options(hash = nil)
+      Faraday::Request::Instrumentation::Options.from hash
+    end
+
+    def conn(hash = nil)
+      hash ||= {}
+      hash[:instrumenter] = @instrumenter
+
+      Faraday.new do |f|
+        f.request :instrumentation, hash
+        f.adapter :test do |stub|
+          stub.get '/' do
+            [200, {}, 'ok']
+          end
+        end
+      end
+    end
+  end
+end

data/test/middleware/retry_test.rb

@@ -0,0 +1,109 @@
+require File.expand_path("../../helper", __FILE__)
+
+module Middleware
+  class RetryTest < Faraday::TestCase
+    def setup
+      @times_called = 0
+    end
+
+    def conn(*retry_args)
+      Faraday.new do |b|
+        b.request :retry, *retry_args
+        b.adapter :test do |stub|
+          stub.post('/unstable') {
+            @times_called += 1
+            @explode.call @times_called
+          }
+        end
+      end
+    end
+
+    def test_unhandled_error
+      @explode = lambda {|n| raise "boom!" }
+      assert_raises(RuntimeError) { conn.post("/unstable") }
+      assert_equal 1, @times_called
+    end
+
+    def test_handled_error
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      assert_raises(Errno::ETIMEDOUT) { conn.post("/unstable") }
+      assert_equal 3, @times_called
+    end
+
+    def test_legacy_max_retries
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      assert_raises(Errno::ETIMEDOUT) { conn(1).post("/unstable") }
+      assert_equal 2, @times_called
+    end
+
+    def test_new_max_retries
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      assert_raises(Errno::ETIMEDOUT) { conn(:max => 3).post("/unstable") }
+      assert_equal 4, @times_called
+    end
+
+    def test_interval
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      started  = Time.now
+      assert_raises(Errno::ETIMEDOUT) {
+        conn(:max => 2, :interval => 0.1).post("/unstable")
+      }
+      assert_in_delta 0.2, Time.now - started, 0.04
+    end
+
+    def test_calls_sleep_amount
+      explode_app = MiniTest::Mock.new
+      explode_app.expect(:call, nil, [{:body=>nil}])
+      def explode_app.call(env)
+        raise Errno::ETIMEDOUT
+      end
+
+      retry_middleware = Faraday::Request::Retry.new(explode_app)
+      class << retry_middleware
+        attr_accessor :sleep_amount_retries
+
+        def sleep_amount(retries)
+          self.sleep_amount_retries.delete(retries)
+          0
+        end
+      end
+      retry_middleware.sleep_amount_retries = [2, 1]
+
+      assert_raises(Errno::ETIMEDOUT) {
+        retry_middleware.call({})
+      }
+
+      assert_empty retry_middleware.sleep_amount_retries
+    end
+
+    def test_exponential_backoff
+      middleware = Faraday::Request::Retry.new(nil, :max => 5, :interval => 0.1, :backoff_factor => 2)
+      assert_equal middleware.sleep_amount(5), 0.1
+      assert_equal middleware.sleep_amount(4), 0.2
+      assert_equal middleware.sleep_amount(3), 0.4
+    end
+
+    def test_random_additional_interval_amount
+      middleware = Faraday::Request::Retry.new(nil, :max => 2, :interval => 0.1, :interval_randomness => 1.0)
+      sleep_amount = middleware.sleep_amount(2)
+      assert_operator sleep_amount, :>=, 0.1
+      assert_operator sleep_amount, :<=, 0.2
+      middleware = Faraday::Request::Retry.new(nil, :max => 2, :interval => 0.1, :interval_randomness => 0.5)
+      sleep_amount = middleware.sleep_amount(2)
+      assert_operator sleep_amount, :>=, 0.1
+      assert_operator sleep_amount, :<=, 0.15
+      middleware = Faraday::Request::Retry.new(nil, :max => 2, :interval => 0.1, :interval_randomness => 0.25)
+      sleep_amount = middleware.sleep_amount(2)
+      assert_operator sleep_amount, :>=, 0.1
+      assert_operator sleep_amount, :<=, 0.125
+    end
+
+    def test_custom_exceptions
+      @explode = lambda {|n| raise "boom!" }
+      assert_raises(RuntimeError) {
+        conn(:exceptions => StandardError).post("/unstable")
+      }
+      assert_equal 3, @times_called
+    end
+  end
+end