faraday 0.14.0 → 0.17.6

data/test/env_test.rb

@@ -0,0 +1,268 @@
+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_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'
+    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'
+      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
+  end
+
+  def test_request_create_stores_ssl_options
+    env = make_env
+    assert_equal false, env.ssl.verify
+  end
+
+  def test_custom_members_are_retained
+    env = make_env
+    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
+
+  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_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_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
+
+  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
+    @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_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
+    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

@@ -0,0 +1,75 @@
+require 'simplecov'
+require 'coveralls'
+
+SimpleCov.formatters = [SimpleCov::Formatter::HTMLFormatter, Coveralls::SimpleCov::Formatter]
+
+SimpleCov.start do
+  add_filter '/bundle/'
+  add_filter '/test/'
+  minimum_coverage(87)
+end
+
+gem 'minitest' if defined? Bundler
+require 'minitest/autorun'
+
+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.ruby_22_plus?
+      RUBY_VERSION > '2.2'
+    end
+
+    def self.ssl_mode?
+      ENV['SSL'] == 'yes'
+    end
+  end
+end

data/test/live_server.rb

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

@@ -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