faraday 0.9.1 → 2.5.2

data/test/env_test.rb

@@ -1,218 +0,0 @@
-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'},
-      :request => {:oauth => {:consumer_key => 'anonymous'}}
-
-    @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
-  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
-  end
-
-  def test_request_create_stores_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
-    env = make_env do |req|
-      req.body = 'hi'
-    end
-    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
-  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
-    env = make_env
-    assert_equal false, env.ssl.verify
-  end
-
-  def test_request_create_stores_proxy_options
-    env = make_env
-    assert_equal 'proxy.com', env.request.proxy.host
-  end
-
-  private
-
-  def make_env(method = :get, connection = @conn, &block)
-    request = connection.build_request(method, &block)
-    request.to_env(connection)
-  end
-end
-
-class HeadersTest < Faraday::TestCase
-  def setup
-    @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
-  end
-
-  def test_parse_response_headers_parses_lower_cased_header_name_and_value
-    @headers.parse("HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n")
-    assert_equal 'text/html', @headers['content-type']
-  end
-
-  def test_parse_response_headers_parses_lower_cased_header_name_and_value_with_colon
-    @headers.parse("HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nLocation: http://sushi.com/\r\n\r\n")
-    assert_equal 'http://sushi.com/', @headers['location']
-  end
-
-  def test_parse_response_headers_parses_blank_lines
-    @headers.parse("HTTP/1.1 200 OK\r\n\r\nContent-Type: text/html\r\n\r\n")
-    assert_equal 'text/html', @headers['content-type']
-  end
-end
-
-class ResponseTest < Faraday::TestCase
-  def setup
-    @env = Faraday::Env.from \
-      :status => 404, :body => 'yikes',
-      :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_body_is_parsed_on_finish
-    response = Faraday::Response.new
-    response.on_complete { |env| env[:body] = env[:body].upcase }
-    response.finish(@env)
-
-    assert_equal "YIKES", response.body
-  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(:params => 'moo')
-
-    loaded = Marshal.load Marshal.dump(@response)
-    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,81 +0,0 @@
-if RUBY_VERSION >= '1.9'
-  require 'simplecov'
-  require 'coveralls'
-
-  SimpleCov.formatters = [SimpleCov::Formatter::HTMLFormatter, Coveralls::SimpleCov::Formatter]
-
-  SimpleCov.start do
-    add_filter '/bundle/'
-    add_filter '/test/'
-    minimum_coverage(87.27)
-  end
-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'
-require 'uri'
-
-module Faraday
-  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,67 +0,0 @@
-require 'sinatra/base'
-
-module Faraday
-class LiveServer < Sinatra::Base
-  set :environment, :test
-  disable :logging
-  disable :protection
-
-  [: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?
-
-      content_type 'text/plain'
-      return out
-    end
-  end
-
-  get '/echo_header' do
-    header = "HTTP_#{params[:name].tr('-', '_').upcase}"
-    request.env.fetch(header) { 'NONE' }
-  end
-
-  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
-
-  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
-
-if $0 == __FILE__
-  Faraday::LiveServer.run!
-end

data/test/middleware/instrumentation_test.rb

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

@@ -1,177 +0,0 @@
-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|
-          ['get', 'post'].each do |method|
-            stub.send(method, '/unstable') {
-              @times_called += 1
-              @explode.call @times_called
-            }
-          end
-        end
-      end
-    end
-
-    def test_unhandled_error
-      @explode = lambda {|n| raise "boom!" }
-      assert_raises(RuntimeError) { conn.get("/unstable") }
-      assert_equal 1, @times_called
-    end
-
-    def test_handled_error
-      @explode = lambda {|n| raise Errno::ETIMEDOUT }
-      assert_raises(Errno::ETIMEDOUT) { conn.get("/unstable") }
-      assert_equal 3, @times_called
-    end
-
-    def test_legacy_max_retries
-      @explode = lambda {|n| raise Errno::ETIMEDOUT }
-      assert_raises(Errno::ETIMEDOUT) { conn(1).get("/unstable") }
-      assert_equal 2, @times_called
-    end
-
-    def test_legacy_max_negative_retries
-      @explode = lambda {|n| raise Errno::ETIMEDOUT }
-      assert_raises(Errno::ETIMEDOUT) { conn(-9).get("/unstable") }
-      assert_equal 1, @times_called
-    end
-
-    def test_new_max_retries
-      @explode = lambda {|n| raise Errno::ETIMEDOUT }
-      assert_raises(Errno::ETIMEDOUT) { conn(:max => 3).get("/unstable") }
-      assert_equal 4, @times_called
-    end
-
-    def test_new_max_negative_retries
-      @explode = lambda { |n| raise Errno::ETIMEDOUT }
-      assert_raises(Errno::ETIMEDOUT) { conn(:max => -9).get("/unstable") }
-      assert_equal 1, @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).get("/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({:method => :get})
-      }
-
-      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).get("/unstable")
-      }
-      assert_equal 3, @times_called
-    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 }
-      assert_raises(Errno::ETIMEDOUT) {
-        conn(:retry_if => check).post("/unstable")
-      }
-      assert_equal 1, @times_called
-    end
-
-    def test_should_stop_retrying_if_block_returns_false_checking_exception
-      @explode = lambda {|n| raise Errno::ETIMEDOUT }
-      check = lambda { |env,exception| !exception.kind_of?(Errno::ETIMEDOUT) }
-      assert_raises(Errno::ETIMEDOUT) {
-        conn(:retry_if => check).post("/unstable")
-      }
-      assert_equal 1, @times_called
-    end
-
-    def test_should_not_call_retry_if_for_idempotent_methods_if_methods_unspecified
-      @explode = lambda {|n| raise Errno::ETIMEDOUT }
-      check = lambda { |env,exception| raise "this should have never been called" }
-      assert_raises(Errno::ETIMEDOUT) {
-        conn(:retry_if => check).get("/unstable")
-      }
-      assert_equal 3, @times_called
-    end
-
-    def test_should_not_retry_for_non_idempotent_method_if_methods_unspecified
-      @explode = lambda {|n| raise Errno::ETIMEDOUT }
-      assert_raises(Errno::ETIMEDOUT) {
-        conn.post("/unstable")
-      }
-      assert_equal 1, @times_called
-    end
-
-    def test_should_not_call_retry_if_for_specified_methods
-      @explode = lambda {|n| raise Errno::ETIMEDOUT }
-      check = lambda { |env,exception| raise "this should have never been called" }
-      assert_raises(Errno::ETIMEDOUT) {
-        conn(:retry_if => check, :methods => [:post]).post("/unstable")
-      }
-      assert_equal 3, @times_called
-    end
-
-    def test_should_call_retry_if_for_empty_method_list
-      @explode = lambda {|n| raise Errno::ETIMEDOUT }
-      check = lambda { |env,exception| @times_called < 2 }
-      assert_raises(Errno::ETIMEDOUT) {
-        conn(:retry_if => check, :methods => []).get("/unstable")
-      }
-      assert_equal 2, @times_called
-    end
-
-  end
-end