faraday 0.9.1 → 0.17.4

data/test/env_test.rb

@@ -9,7 +9,7 @@ class EnvTest < Faraday::TestCase
     @conn.options.timeout      = 3
     @conn.options.open_timeout = 5
     @conn.ssl.verify           = false
-    @conn.proxy 'http://proxy.com'
+    @conn.proxy = 'http://proxy.com'
   end
 
   def test_request_create_stores_method
@@ -24,6 +24,13 @@ class EnvTest < Faraday::TestCase
     assert_equal 'http://sushi.com/api/foo.json?a=1', env.url.to_s
   end
 
+  def test_request_create_stores_uri_with_anchor
+    env = make_env do |req|
+      req.url 'foo.json?b=2&a=1#qqq'
+    end
+    assert_equal 'http://sushi.com/api/foo.json?a=1&b=2', env.url.to_s
+  end
+
   def test_request_create_stores_headers
     env = make_env do |req|
       req['Server'] = 'Faraday'
@@ -51,10 +58,16 @@ class EnvTest < Faraday::TestCase
       req.options.timeout = 10
       req.options.boundary = 'boo'
       req.options.oauth[:consumer_secret] = 'xyz'
+      req.options.context = {
+          foo: 'foo',
+          bar: 'bar'
+      }
     end
+
     assert_equal 10, env.request.timeout
     assert_equal 5, env.request.open_timeout
     assert_equal 'boo', env.request.boundary
+    assert_equal env.request.context, { foo: 'foo', bar: 'bar' }
 
     oauth_expected = {:consumer_secret => 'xyz', :consumer_key => 'anonymous'}
     assert_equal oauth_expected, env.request.oauth
@@ -65,9 +78,15 @@ class EnvTest < Faraday::TestCase
     assert_equal false, env.ssl.verify
   end
 
-  def test_request_create_stores_proxy_options
+  def test_custom_members_are_retained
     env = make_env
-    assert_equal 'proxy.com', env.request.proxy.host
+    env[:foo] = "custom 1"
+    env[:bar] = :custom_2
+    env2 = Faraday::Env.from(env)
+    assert_equal "custom 1", env2[:foo]
+    assert_equal :custom_2,  env2[:bar]
+    env2[:baz] = "custom 3"
+    assert_nil env[:baz]
   end
 
   private
@@ -124,7 +143,7 @@ class HeadersTest < Faraday::TestCase
     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')
+    assert_nil @headers.delete('content-type')
   end
 
   def test_parse_response_headers_leaves_http_status_line_out
@@ -174,6 +193,23 @@ class ResponseTest < Faraday::TestCase
     assert_equal "YIKES", response.body
   end
 
+  def test_response_body_is_available_during_on_complete
+    response = Faraday::Response.new
+    response.on_complete { |env| env[:body] = response.body.upcase }
+    response.finish(@env)
+
+    assert_equal "YIKES", response.body
+  end
+
+  def test_env_in_on_complete_is_identical_to_response_env
+    response = Faraday::Response.new
+    callback_env = nil
+    response.on_complete { |env| callback_env = env }
+    response.finish({})
+
+    assert_same response.env, callback_env
+  end
+
   def test_not_success
     assert !@response.success?
   end
@@ -197,7 +233,7 @@ class ResponseTest < Faraday::TestCase
     assert_equal :post, @response.env[:method]
   end
 
-  def test_marshal
+  def test_marshal_response
     @response = Faraday::Response.new
     @response.on_complete { }
     @response.finish @env.merge(:params => 'moo')
@@ -207,6 +243,20 @@ class ResponseTest < Faraday::TestCase
     assert_equal %w[body response_headers status], loaded.env.keys.map { |k| k.to_s }.sort
   end
 
+  def test_marshal_request
+    @request = Faraday::Request.create(:post) do |request|
+      request.options      = Faraday::RequestOptions.new
+      request.params       = Faraday::Utils::ParamsHash.new({ 'a' => 'c' })
+      request.headers      = { 'b' => 'd' }
+      request.body         = 'hello, world!'
+      request.url 'http://localhost/foo'
+    end
+
+    loaded = Marshal.load(Marshal.dump(@request))
+
+    assert_equal @request, loaded
+  end
+
   def test_hash
     hash = @response.to_hash
     assert_kind_of Hash, hash

data/test/helper.rb

@@ -1,27 +1,17 @@
-if RUBY_VERSION >= '1.9'
-  require 'simplecov'
-  require 'coveralls'
+require 'simplecov'
+require 'coveralls'
 
-  SimpleCov.formatters = [SimpleCov::Formatter::HTMLFormatter, Coveralls::SimpleCov::Formatter]
+SimpleCov.formatters = [SimpleCov::Formatter::HTMLFormatter, Coveralls::SimpleCov::Formatter]
 
-  SimpleCov.start do
-    add_filter '/bundle/'
-    add_filter '/test/'
-    minimum_coverage(87.27)
-  end
+SimpleCov.start do
+  add_filter '/bundle/'
+  add_filter '/test/'
+  minimum_coverage(87)
 end
 
 gem 'minitest' if defined? Bundler
 require 'minitest/autorun'
 
-if ENV['LEFTRIGHT']
-  begin
-    require 'leftright'
-  rescue LoadError
-    puts "Run `gem install leftright` to install leftright."
-  end
-end
-
 require File.expand_path('../../lib/faraday', __FILE__)
 
 require 'stringio'
@@ -74,6 +64,10 @@ 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/middleware/retry_test.rb

@@ -4,17 +4,37 @@ module Middleware
   class RetryTest < Faraday::TestCase
     def setup
       @times_called = 0
+      @envs = []
     end
 
     def conn(*retry_args)
       Faraday.new do |b|
         b.request :retry, *retry_args
+
         b.adapter :test do |stub|
           ['get', 'post'].each do |method|
-            stub.send(method, '/unstable') {
+            stub.send(method, '/unstable') do |env|
               @times_called += 1
+              @envs << env.dup
+              env[:body] = nil # simulate blanking out response body
               @explode.call @times_called
-            }
+            end
+
+            stub.send(method, '/throttled') do |env|
+              @times_called += 1
+              @envs << env.dup
+
+              params = env[:params]
+
+              status = (params['status'] || 429).to_i
+              headers = {}
+
+              retry_after = params['retry_after']
+
+              headers['Retry-After'] = retry_after if retry_after
+
+              [status, headers, '']
+            end
           end
         end
       end
@@ -65,7 +85,7 @@ module Middleware
       assert_in_delta 0.2, Time.now - started, 0.04
     end
 
-    def test_calls_sleep_amount
+    def test_calls_calculate_sleep_amount
       explode_app = MiniTest::Mock.new
       explode_app.expect(:call, nil, [{:body=>nil}])
       def explode_app.call(env)
@@ -76,7 +96,7 @@ module Middleware
       class << retry_middleware
         attr_accessor :sleep_amount_retries
 
-        def sleep_amount(retries)
+        def calculate_sleep_amount(retries, env)
           self.sleep_amount_retries.delete(retries)
           0
         end
@@ -92,22 +112,30 @@ module Middleware
 
     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
+      assert_equal middleware.send(:calculate_retry_interval, 5), 0.1
+      assert_equal middleware.send(:calculate_retry_interval, 4), 0.2
+      assert_equal middleware.send(:calculate_retry_interval, 3), 0.4
+    end
+
+    def test_exponential_backoff_with_max_interval
+      middleware = Faraday::Request::Retry.new(nil, :max => 5, :interval => 1, :max_interval => 3, :backoff_factor => 2)
+      assert_equal middleware.send(:calculate_retry_interval, 5), 1
+      assert_equal middleware.send(:calculate_retry_interval, 4), 2
+      assert_equal middleware.send(:calculate_retry_interval, 3), 3
+      assert_equal middleware.send(:calculate_retry_interval, 2), 3
     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)
+      sleep_amount = middleware.send(:calculate_retry_interval, 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)
+      sleep_amount = middleware.send(:calculate_retry_interval, 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)
+      sleep_amount = middleware.send(:calculate_retry_interval, 2)
       assert_operator sleep_amount, :>=, 0.1
       assert_operator sleep_amount, :<=, 0.125
     end
@@ -120,6 +148,17 @@ module Middleware
       assert_equal 3, @times_called
     end
 
+    def test_should_retry_with_body_if_block_returns_true_for_non_idempotent_request
+      body = { :foo => :bar }
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      check = lambda { |env,exception| true }
+      assert_raises(Errno::ETIMEDOUT) {
+        conn(:retry_if => check).post("/unstable", body)
+      }
+      assert_equal 3, @times_called
+      assert @envs.all? { |env| env[:body] === body }
+    end
+
     def test_should_stop_retrying_if_block_returns_false_checking_env
       @explode = lambda {|n| raise Errno::ETIMEDOUT }
       check = lambda { |env,exception| env[:method] != :post }
@@ -173,5 +212,71 @@ module Middleware
       assert_equal 2, @times_called
     end
 
+    def test_should_rewind_files_on_retry
+      io = StringIO.new("Test data")
+      upload_io = Faraday::UploadIO.new(io, "application/octet/stream")
+
+      rewound = 0
+      rewind = lambda { rewound += 1 }
+
+      upload_io.stub :rewind, rewind do
+        @explode = lambda {|n| raise Errno::ETIMEDOUT }
+        check = lambda { |env,exception| true }
+        assert_raises(Errno::ETIMEDOUT) {
+          conn(:retry_if => check).post("/unstable", { :file => upload_io })
+        }
+      end
+      assert_equal 3, @times_called
+      assert_equal 2, rewound
+    end
+
+    def test_should_retry_retriable_response
+      params = { status: 429 }
+      response = conn(:max => 1, :retry_statuses => 429).get("/throttled", params)
+
+      assert_equal 2, @times_called
+      assert_equal 429, response.status
+    end
+
+    def test_should_not_retry_non_retriable_response
+      params = { status: 503 }
+      conn(:max => 1, :retry_statuses => 429).get("/throttled", params)
+
+      assert_equal 1, @times_called
+    end
+
+    def test_interval_if_retry_after_present
+      started = Time.now
+
+      params = { :retry_after => 0.5 }
+      conn(:max => 1, :interval => 0.1, :retry_statuses => [429]).get("/throttled", params)
+
+      assert Time.now - started > 0.5
+    end
+
+    def test_should_ignore_retry_after_if_less_then_calculated
+      started = Time.now
+
+      params = { :retry_after => 0.1 }
+      conn(:max => 1, :interval => 0.2, :retry_statuses => [429]).get("/throttled", params)
+
+      assert Time.now - started > 0.2
+    end
+
+    def test_interval_when_retry_after_is_timestamp
+      started = Time.now
+
+      params = { :retry_after => (Time.now.utc + 2).strftime('%a, %d %b %Y %H:%M:%S GMT') }
+      conn(:max => 1, :interval => 0.1, :retry_statuses => [429]).get("/throttled", params)
+
+      assert Time.now - started > 1
+    end
+
+    def test_should_not_retry_when_retry_after_greater_then_max_interval
+      params = { :retry_after => (Time.now.utc + 20).strftime('%a, %d %b %Y %H:%M:%S GMT') }
+      conn(:max => 2, :interval => 0.1, :retry_statuses => [429], max_interval: 5).get("/throttled", params)
+
+      assert_equal 1, @times_called
+    end
   end
 end

data/test/middleware_stack_test.rb

@@ -35,8 +35,9 @@ class MiddlewareStackTest < Faraday::TestCase
   end
 
   def test_allows_extending
-    build_stack Apple
-    @conn.use Orange
+    build_handlers_stack Apple
+    @builder.use Orange
+    @builder.adapter :test, &test_adapter
     assert_handlers %w[Apple Orange]
   end
 
@@ -46,20 +47,23 @@ class MiddlewareStackTest < Faraday::TestCase
   end
 
   def test_insert_before
-    build_stack Apple, Orange
+    build_handlers_stack Apple, Orange
     @builder.insert_before Apple, Banana
+    @builder.adapter :test, &test_adapter
     assert_handlers %w[Banana Apple Orange]
   end
 
   def test_insert_after
-    build_stack Apple, Orange
+    build_handlers_stack Apple, Orange
     @builder.insert_after Apple, Banana
+    @builder.adapter :test, &test_adapter
     assert_handlers %w[Apple Banana Orange]
   end
 
   def test_swap_handlers
-    build_stack Apple, Orange
+    build_handlers_stack Apple, Orange
     @builder.swap Apple, Banana
+    @builder.adapter :test, &test_adapter
     assert_handlers %w[Banana Orange]
   end
 
@@ -143,6 +147,15 @@ class MiddlewareStackTest < Faraday::TestCase
     assert_match "zomg/i_dont/exist", err.message
   end
 
+  def test_env_stored_on_middleware_response_has_reference_to_the_response
+    env = response = nil
+    build_stack Struct.new(:app) {
+      define_method(:call) { |e| env, response = e, app.call(e) }
+    }
+    @conn.get("/")
+    assert_same env.response, response.env.response
+  end
+
   private
 
   # make a stack with test adapter that reflects the order of middleware
@@ -151,11 +164,21 @@ class MiddlewareStackTest < Faraday::TestCase
       handlers.each { |handler| b.use(*handler) }
       yield(b) if block_given?
 
-      b.adapter :test do |stub|
-        stub.get '/' do |env|
-          # echo the "X-Middleware" request header in the body
-          [200, {}, env[:request_headers]['X-Middleware'].to_s]
-        end
+      @builder.adapter :test, &test_adapter
+    end
+  end
+
+  def build_handlers_stack(*handlers)
+    @builder.build do |b|
+      handlers.each { |handler| b.use(*handler) }
+    end
+  end
+
+  def test_adapter
+    Proc.new do |stub|
+      stub.get '/' do |env|
+        # echo the "X-Middleware" request header in the body
+        [200, {}, env[:request_headers]['X-Middleware'].to_s]
       end
     end
   end
@@ -171,3 +194,67 @@ class MiddlewareStackTest < Faraday::TestCase
     component.instance_variable_get('@registered_middleware').delete(key)
   end
 end
+
+class MiddlewareStackOrderTest < Faraday::TestCase
+  def test_adding_response_middleware_after_adapter
+    response_after_adapter = lambda do
+      Faraday::RackBuilder.new do |b|
+        b.adapter :test
+        b.response :raise_error
+      end
+    end
+
+    assert_output("", expected_middleware_warning, &response_after_adapter)
+  end
+
+  def test_adding_request_middleware_after_adapter
+    request_after_adapter = lambda do
+      Faraday::RackBuilder.new do |b|
+        b.adapter :test
+        b.request :multipart
+      end
+    end
+
+    assert_output("", expected_middleware_warning, &request_after_adapter)
+  end
+
+  def test_adding_request_middleware_after_adapter_via_use
+    use_after_adapter = lambda do
+      Faraday::RackBuilder.new do |b|
+        b.adapter :test
+        b.use Faraday::Request::Multipart
+      end
+    end
+
+    assert_output("", expected_middleware_warning, &use_after_adapter)
+  end
+
+  def test_adding_request_middleware_after_adapter_via_insert
+    insert_after_adapter = lambda do
+      Faraday::RackBuilder.new do |b|
+        b.adapter :test
+        b.insert(1, Faraday::Request::Multipart)
+      end
+    end
+
+    assert_output("", expected_middleware_warning, &insert_after_adapter)
+  end
+
+  def test_adding_request_middleware_before_adapter_via_insert_no_warning
+    builder = Faraday::RackBuilder.new do |b|
+      b.adapter :test
+    end
+
+    insert_before_adapter = lambda do
+      builder.insert(0, Faraday::Request::Multipart)
+    end
+
+    assert_output("", "", &insert_before_adapter)
+  end
+
+  private
+
+  def expected_middleware_warning
+    /Unexpected middleware set after the adapter/
+  end
+end

data/test/options_test.rb

@@ -1,11 +1,91 @@
 require File.expand_path('../helper', __FILE__)
 
 class OptionsTest < Faraday::TestCase
-  class SubOptions < Faraday::Options.new(:sub); end
+  SubOptions = Class.new(Faraday::Options.new(:sub_a, :sub_b))
   class ParentOptions < Faraday::Options.new(:a, :b, :c)
     options :c => SubOptions
   end
 
+  def test_deep_merge
+    sub_opts1 = SubOptions.from(sub_a: 3)
+    sub_opts2 = SubOptions.from(sub_b: 4)
+    opt1 = ParentOptions.from(a: 1, c: sub_opts1)
+    opt2 = ParentOptions.from(b: 2, c: sub_opts2)
+
+    merged = opt1.merge(opt2)
+
+    expected_sub_opts = SubOptions.from(sub_a: 3, sub_b: 4)
+    assert_equal merged, ParentOptions.from(a: 1, b: 2, c: expected_sub_opts)
+  end
+
+  def test_deep_merge_with_hash
+    sub_opts1 = SubOptions.from(sub_a: 3)
+    sub_opts2 = { sub_b: 4 }
+    opt1 = ParentOptions.from(a: 1, c: sub_opts1)
+    opt2 = { b: 2, c: sub_opts2 }
+
+    merged = opt1.merge(opt2)
+
+    expected_sub_opts = SubOptions.from(sub_a: 3, sub_b: 4)
+    assert_equal merged, ParentOptions.from(a: 1, b: 2, c: expected_sub_opts)
+  end
+
+  def test_deep_merge_with_nil
+    sub_opts = SubOptions.new(3, 4)
+    options = ParentOptions.new(1, 2, sub_opts)
+    assert_equal options.a, 1
+    assert_equal options.b, 2
+    assert_equal options.c.sub_a, 3
+    assert_equal options.c.sub_b, 4
+
+    options2 = ParentOptions.from(b: 5, c: nil)
+
+    merged = options.merge(options2)
+
+    assert_equal merged.b, 5
+    assert_equal merged.c, sub_opts
+  end
+
+  def test_deep_merge_with_sub_nil
+    options = ParentOptions.from(a: 1)
+
+    sub_opts = SubOptions.new(3, 4)
+    options2 = ParentOptions.from(b: 2, c: sub_opts)
+
+    assert_equal options.a, 1
+    assert_equal options2.b, 2
+    assert_equal options2.c.sub_a, 3
+    assert_equal options2.c.sub_b, 4
+
+    merged = options.merge(options2)
+
+    assert_equal merged.c, sub_opts
+  end
+
+  def test_dup_is_shallow
+    sub_opts = SubOptions.from(sub_a: 3)
+    opts = ParentOptions.from(b: 1, c: sub_opts)
+
+    duped = opts.dup
+    duped.b = 2
+    duped.c.sub_a = 4
+
+    assert_equal opts.b, 1
+    assert_equal opts.c.sub_a, 4
+  end
+
+  def test_deep_dup
+    sub_opts = SubOptions.from(sub_a: 3)
+    opts = ParentOptions.from(b: 1, c: sub_opts)
+
+    duped = opts.deep_dup
+    duped.b = 2
+    duped.c.sub_a = 4
+
+    assert_equal opts.b, 1
+    assert_equal opts.c.sub_a, 3
+  end
+
   def test_clear
     options = SubOptions.new(1)
     assert !options.empty?
@@ -16,9 +96,9 @@ class OptionsTest < Faraday::TestCase
   def test_empty
     options = SubOptions.new
     assert options.empty?
-    options.sub = 1
+    options.sub_a = 1
     assert !options.empty?
-    options.delete(:sub)
+    options.delete(:sub_a)
     assert options.empty?
   end
 
@@ -32,13 +112,9 @@ class OptionsTest < Faraday::TestCase
 
   def test_key?
     options = SubOptions.new
-    assert !options.key?(:sub)
-    options.sub = 1
-    if RUBY_VERSION >= '1.9'
-      assert options.key?(:sub)
-    else
-      assert options.key?("sub")
-    end
+    assert !options.key?(:sub_a)
+    options.sub_a = 1
+    assert options.key?(:sub_a)
   end
 
   def test_each_value
@@ -52,7 +128,7 @@ class OptionsTest < Faraday::TestCase
   def test_value?
     options = SubOptions.new
     assert !options.value?(1)
-    options.sub = 1
+    options.sub_a = 1
     assert options.value?(1)
   end
 
@@ -83,6 +159,11 @@ class OptionsTest < Faraday::TestCase
     assert_equal 'http', options.scheme
   end
 
+  def test_proxy_options_from_nil
+    options = Faraday::ProxyOptions.from nil
+    assert_kind_of Faraday::ProxyOptions, options
+  end
+
   def test_proxy_options_hash_access
     proxy = Faraday::ProxyOptions.from 'http://a%40b:pw%20d@example.org'
     assert_equal 'a@b', proxy[:user]
@@ -112,7 +193,7 @@ class OptionsTest < Faraday::TestCase
     assert_equal 1, options.a
     assert_nil options.b
     assert_kind_of SubOptions, options.c
-    assert_equal 1, options.c.sub
+    assert_equal 1, options.c.sub_a
   end
 
   def test_from_hash
@@ -123,19 +204,19 @@ class OptionsTest < Faraday::TestCase
   end
 
   def test_from_hash_with_sub_object
-    options = ParentOptions.from :a => 1, :c => {:sub => 1}
+    options = ParentOptions.from :a => 1, :c => {:sub_a => 1}
     assert_kind_of ParentOptions, options
     assert_equal 1, options.a
     assert_nil options.b
     assert_kind_of SubOptions, options.c
-    assert_equal 1, options.c.sub
+    assert_equal 1, options.c.sub_a
   end
 
   def test_inheritance
     subclass = Class.new(ParentOptions)
-    options = subclass.from(:c => {:sub => 'hello'})
+    options = subclass.from(:c => {:sub_a => 'hello'})
     assert_kind_of SubOptions, options.c
-    assert_equal 'hello', options.c.sub
+    assert_equal 'hello', options.c.sub_a
   end
 
   def test_from_deep_hash