faraday 0.8.11 → 0.9.0.rc1

data/test/env_test.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require File.expand_path('../helper', __FILE__)
 
 class EnvTest < Faraday::TestCase
   def setup
@@ -6,29 +6,29 @@ class EnvTest < Faraday::TestCase
       :headers => {'Mime-Version' => '1.0'},
       :request => {:oauth => {:consumer_key => 'anonymous'}}
 
-    @conn.options[:timeout]      = 3
-    @conn.options[:open_timeout] = 5
-    @conn.ssl[:verify]           = false
+    @conn.options.timeout      = 3
+    @conn.options.open_timeout = 5
+    @conn.ssl.verify           = false
     @conn.proxy 'http://proxy.com'
   end
 
   def test_request_create_stores_method
     env = make_env(:get)
-    assert_equal :get, env[:method]
+    assert_equal :get, env.method
   end
 
   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
+    assert_equal 'http://sushi.com/api/foo.json?a=1', env.url.to_s
   end
 
   def test_request_create_stores_headers
     env = make_env do |req|
       req['Server'] = 'Faraday'
     end
-    headers = env[:request_headers]
+    headers = env.request_headers
     assert_equal '1.0', headers['mime-version']
     assert_equal 'Faraday', headers['server']
   end
@@ -37,37 +37,37 @@ class EnvTest < Faraday::TestCase
     env = make_env do |req|
       req.body = 'hi'
     end
-    assert_equal 'hi', env[:body]
+    assert_equal 'hi', env.body
   end
 
   def test_global_request_options
     env = make_env
-    assert_equal 3, env[:request][:timeout]
-    assert_equal 5, env[:request][:open_timeout]
+    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[:custom] = true
-      req.options[:oauth][:consumer_secret] = 'xyz'
+      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 true, env[:request][:custom]
+    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]
+    assert_equal oauth_expected, env.request.oauth
   end
 
   def test_request_create_stores_ssl_options
     env = make_env
-    assert_equal false, env[:ssl][:verify]
+    assert_equal false, env.ssl.verify
   end
 
   def test_request_create_stores_proxy_options
     env = make_env
-    assert_equal 'proxy.com', env[:request][:proxy][:uri].host
+    assert_equal 'proxy.com', env.request.proxy.host
   end
 
   private
@@ -131,10 +131,9 @@ 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
 
@@ -174,10 +173,20 @@ class ResponseTest < Faraday::TestCase
   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,14 +1,17 @@
-if RUBY_VERSION >= '1.9'
-  require 'simplecov'
+require 'rubygems'         # rubygems/version doesn't work by itself
+require 'rubygems/version' # for simplecov-html
+require 'simplecov'
+require 'coveralls'
 
-  SimpleCov.start do
-    add_filter '/bundle/'
-    add_filter '/test/'
-    minimum_coverage(88.74)
-  end
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start do
+  add_filter '/bundle/'
 end
 
-require 'test/unit'
+require 'minitest/autorun'
 
 if ENV['LEFTRIGHT']
   begin
@@ -19,6 +22,9 @@ if ENV['LEFTRIGHT']
 end
 
 require File.expand_path('../../lib/faraday', __FILE__)
+Dir[File.expand_path('../../lib/faraday/r*/*', __FILE__)].each do |file|
+  require file
+end
 
 require 'stringio'
 require 'uri'
@@ -44,7 +50,7 @@ module Faraday
     end
   end
 
-  class TestCase < Test::Unit::TestCase
+  class TestCase < MiniTest::Unit::TestCase
     extend LiveServerConfig
     self.live_server = ENV['LIVE']
 
@@ -70,10 +76,6 @@ module Faraday
       defined? RUBY_ENGINE and 'rbx' == RUBY_ENGINE
     end
 
-    def self.ruby_22_plus?
-      RUBY_VERSION > '2.2'
-    end
-
     def self.ssl_mode?
       ENV['SSL'] == 'yes'
     end

data/test/live_server.rb

@@ -25,11 +25,9 @@ class LiveServer < Sinatra::Base
 
   post '/file' do
     if params[:uploaded_file].respond_to? :each_key
-      "file %s %s %d" % [
+      "file %s %s" % [
         params[:uploaded_file][:filename],
-        params[:uploaded_file][:type],
-        params[:uploaded_file][:tempfile].size
-      ]
+        params[:uploaded_file][:type]]
     else
       status 400
     end
@@ -39,11 +37,19 @@ class LiveServer < Sinatra::Base
     [200, { 'Set-Cookie' => 'one, two' }, '']
   end
 
+  get '/who-am-i' do
+    request.env['REMOTE_ADDR']
+  end
+
   get '/slow' do
     sleep 10
     [200, {}, 'ok']
   end
 
+  get '/204' do
+    status 204 # no content
+  end
+
   get '/ssl' do
     request.secure?.to_s
   end

data/test/middleware/instrumentation_test.rb

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

@@ -1,56 +1,62 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "..", "helper"))
+require File.expand_path("../../helper", __FILE__)
 
 module Middleware
   class RetryTest < Faraday::TestCase
     def setup
-      @stubs = Faraday::Adapter::Test::Stubs.new
-      @conn = Faraday.new do |b|
-        b.request :retry, 2
-        b.use ContentValidator
-        b.adapter :test, @stubs
-      end
+      @times_called = 0
     end
 
-    ContentValidator = Struct.new(:app) do
-      def call(env)
-        response = app.call(env)
-        type = response[:content_type]
-        raise "wrong content-type: %p" % type unless type == "application/json"
+    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_retries
-      times_called = 0
-
-      @stubs.post("/echo") do
-        times_called += 1
-        [200, {}, "hello"]
-      end
+    def test_unhandled_error
+      @explode = lambda {|n| raise "boom!" }
+      assert_raises(RuntimeError) { conn.post("/unstable") }
+      assert_equal 1, @times_called
+    end
 
-      @conn.post("/echo") rescue nil
-      assert_equal times_called, 3
+    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_retry_with_body
-      times_called = 0
-      bodies_received = []
+    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
 
-      @stubs.post("/echo") do |env|
-        times_called += 1
-        bodies_received << env[:body]
-        if times_called < 2
-          [200, {"Content-type" => "text/plain"}, "hello"]
-        else
-          [200, {"Content-type" => "application/json"}, '{"message": "hello"}']
-        end
-      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
 
-      body = {:foo => "bar"}
-      @conn.post("/echo", body)
+    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.03
+    end
 
-      assert_equal times_called, 2
-      assert_same body, bodies_received[0]
-      assert_same body, bodies_received[1]
+    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

data/test/middleware_stack_test.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require File.expand_path('../helper', __FILE__)
 
 class MiddlewareStackTest < Faraday::TestCase
   # mock handler classes
@@ -75,7 +75,7 @@ class MiddlewareStackTest < Faraday::TestCase
     @conn.get('/')
     assert @builder.locked?
 
-    assert_raises Faraday::Builder::StackLocked do
+    assert_raises Faraday::RackBuilder::StackLocked do
       @conn.use Orange
     end
   end
@@ -95,16 +95,16 @@ class MiddlewareStackTest < Faraday::TestCase
     build_stack Apple
     assert_equal @builder.handlers.first, Apple
     assert_equal @builder.handlers[0,1], [Apple]
-    assert_equal @builder.handlers.first, Faraday::Builder::Handler.new(Apple)
+    assert_equal @builder.handlers.first, Faraday::RackBuilder::Handler.new(Apple)
   end
 
   def test_unregistered_symbol
-    err = assert_raise(RuntimeError) { build_stack :apple }
+    err = assert_raises(Faraday::Error){ build_stack :apple }
     assert_equal ":apple is not registered on Faraday::Middleware", err.message
   end
 
   def test_registered_symbol
-    Faraday.register_middleware :apple => Apple
+    Faraday::Middleware.register_middleware :apple => Apple
     begin
       build_stack :apple
       assert_handlers %w[Apple]
@@ -114,7 +114,7 @@ class MiddlewareStackTest < Faraday::TestCase
   end
 
   def test_registered_symbol_with_proc
-    Faraday.register_middleware :apple => lambda { Apple }
+    Faraday::Middleware.register_middleware :apple => lambda { Apple }
     begin
       build_stack :apple
       assert_handlers %w[Apple]
@@ -123,13 +123,14 @@ class MiddlewareStackTest < Faraday::TestCase
     end
   end
 
-  def test_registered_symbol_with_type
-    Faraday.register_middleware :request, :orange => Orange
+  def test_registered_symbol_with_array
+    Faraday::Middleware.register_middleware File.expand_path("..", __FILE__),
+      :strawberry => [lambda { Strawberry }, 'strawberry']
     begin
-      build_stack {|b| b.request :orange }
-      assert_handlers %w[Orange]
+      build_stack :strawberry
+      assert_handlers %w[Strawberry]
     ensure
-      unregister_middleware Faraday::Request, :orange
+      unregister_middleware Faraday::Middleware, :strawberry
     end
   end