avdi-faraday 0.8.1

data/test/env_test.rb

@@ -0,0 +1,183 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+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[:custom] = true
+      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]
+
+    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][:uri].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_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 = {
+      :status => 404, :body => 'yikes',
+      :response_headers => Faraday::Utils::Headers.new('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')
+
+    loaded = Marshal.load Marshal.dump(@response)
+    assert_nil loaded.env[:custom]
+    assert_equal %w[body response_headers status], loaded.env.keys.map { |k| k.to_s }.sort
+  end
+end

data/test/helper.rb

@@ -0,0 +1,75 @@
+unless ENV['CI']
+  begin
+    require 'simplecov'
+    SimpleCov.start do
+      add_filter 'test'
+    end
+  rescue LoadError
+  end
+end
+
+require 'test/unit'
+require 'webmock/test_unit'
+WebMock.disable_net_connect! :allow_localhost => true
+
+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__)
+
+begin
+  require 'ruby-debug'
+rescue LoadError
+  # ignore
+else
+  Debugger.start
+end
+
+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 < Test::Unit::TestCase
+    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
+  end
+end

data/test/live_server.rb

@@ -0,0 +1,57 @@
+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" % [
+        params[:uploaded_file][:filename],
+        params[:uploaded_file][:type]]
+    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
+
+  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/retry_test.rb

@@ -0,0 +1,62 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "helper"))
+
+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_raise(RuntimeError) { conn.post("/unstable") }
+      assert_equal 1, @times_called
+    end
+
+    def test_handled_error
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      assert_raise(Errno::ETIMEDOUT) { conn.post("/unstable") }
+      assert_equal 3, @times_called
+    end
+
+    def test_legacy_max_retries
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      assert_raise(Errno::ETIMEDOUT) { conn(1).post("/unstable") }
+      assert_equal 2, @times_called
+    end
+
+    def test_new_max_retries
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      assert_raise(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_raise(Errno::ETIMEDOUT) {
+        conn(:max => 2, :interval => 0.1).post("/unstable")
+      }
+      assert_in_delta 0.2, Time.now - started, 0.02
+    end
+
+    def test_custom_exceptions
+      @explode = lambda {|n| raise "boom!" }
+      assert_raise(RuntimeError) {
+        conn(:exceptions => StandardError).post("/unstable")
+      }
+      assert_equal 3, @times_called
+    end
+  end
+end

data/test/middleware_stack_test.rb

@@ -0,0 +1,203 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+class MiddlewareStackTest < Faraday::TestCase
+  # mock handler classes
+  class Handler < Struct.new(:app)
+    def call(env)
+      (env[:request_headers]['X-Middleware'] ||= '') << ":#{self.class.name.split('::').last}"
+      app.call(env)
+    end
+  end
+  class Apple < Handler; end
+  class Orange < Handler; end
+  class Banana < Handler; end
+  class TestAdapter < Handler
+    def self.adapter?; true; end
+  end
+
+  class Broken < Faraday::Middleware
+    dependency 'zomg/i_dont/exist'
+  end
+
+  def setup
+    @conn = Faraday::Connection.new
+    @builder = @conn.builder
+  end
+
+  def test_sets_default_adapter_if_none_set
+    default_middleware = Faraday::Request.lookup_middleware :url_encoded
+    default_adapter_klass = Faraday::Adapter.lookup_middleware Faraday.default_adapter
+    assert @builder[0] == default_middleware
+    assert @builder[1] == default_adapter_klass
+  end
+
+  def test_allows_rebuilding
+    build_stack Apple
+    build_stack Orange
+    assert_handlers %w[Orange]
+  end
+
+  def test_allows_extending
+    build_stack Apple
+    @conn.use Orange
+    assert_handlers %w[Apple Orange]
+  end
+
+  def test_builder_is_passed_to_new_faraday_connection
+    new_conn = Faraday::Connection.new :builder => @builder
+    assert_equal @builder, new_conn.builder
+  end
+
+  def test_insert_before
+    build_stack Apple, Orange
+    @builder.insert_before Apple, Banana
+    assert_handlers %w[Banana Apple Orange]
+  end
+
+  def test_insert_after
+    build_stack Apple, Orange
+    @builder.insert_after Apple, Banana
+    assert_handlers %w[Apple Banana Orange]
+  end
+
+  def test_swap_handlers
+    build_stack Apple, Orange
+    @builder.swap Apple, Banana
+    assert_handlers %w[Banana Orange]
+  end
+
+  def test_delete_handler
+    build_stack Apple, Orange
+    @builder.delete Apple
+    assert_handlers %w[Orange]
+  end
+
+  def test_stack_is_locked_after_making_requests
+    build_stack Apple
+    assert !@builder.locked?
+    @conn.get('/')
+    assert @builder.locked?
+
+    assert_raises Faraday::Builder::StackLocked do
+      @conn.use Orange
+    end
+  end
+
+  def test_duped_stack_is_unlocked
+    build_stack Apple
+    assert !@builder.locked?
+    @builder.lock!
+    assert @builder.locked?
+
+    duped_connection = @conn.dup
+    assert_equal @builder, duped_connection.builder
+    assert !duped_connection.builder.locked?
+  end
+
+  def test_handler_comparison
+    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)
+  end
+
+  def test_unregistered_symbol
+    err = assert_raise(RuntimeError) { build_stack :apple }
+    assert_equal ":apple is not registered on Faraday::Middleware", err.message
+  end
+
+  def test_registered_symbol
+    Faraday.register_middleware :apple => Apple
+    begin
+      build_stack :apple
+      assert_handlers %w[Apple]
+    ensure
+      unregister_middleware Faraday::Middleware, :apple
+    end
+  end
+
+  def test_registered_symbol_with_proc
+    Faraday.register_middleware :apple => lambda { Apple }
+    begin
+      build_stack :apple
+      assert_handlers %w[Apple]
+    ensure
+      unregister_middleware Faraday::Middleware, :apple
+    end
+  end
+
+  def test_registered_symbol_with_type
+    Faraday.register_middleware :request, :orange => Orange
+    begin
+      build_stack {|b| b.request :orange }
+      assert_handlers %w[Orange]
+    ensure
+      unregister_middleware Faraday::Request, :orange
+    end
+  end
+
+  def test_missing_dependencies
+    build_stack Broken
+    err = assert_raises RuntimeError do
+      @conn.get('/')
+    end
+    assert_match "missing dependency for MiddlewareStackTest::Broken: ", err.message
+    assert_match "zomg/i_dont/exist", err.message
+  end
+
+  def test_knows_when_contains_an_adapter
+    @builder.clear
+    assert !@builder.has_adapter?
+    assert !@conn.has_adapter?
+    @conn.use Apple
+    assert !@builder.has_adapter?
+    assert !@conn.has_adapter?
+    @conn.use TestAdapter
+    assert @builder.has_adapter?
+    assert @conn.has_adapter?
+  end
+
+  def test_replace_adapter
+    @builder.clear
+    @conn.use Apple
+    @conn.use TestAdapter
+    @conn.adapter = :test, :foo, :bar
+    assert_equal 'Faraday::Adapter::Test', @conn.adapter.name
+    assert_equal [:foo, :bar], @conn.adapter.args
+  end
+
+  def test_set_adapter_as_connection_option
+    conn = Faraday::Connection.new('http://example.org',
+                                   :adapter => [:test, :foo, :bar])
+    assert_equal 'Faraday::Adapter::Test', conn.adapter.name
+    assert_equal [:foo, :bar], conn.adapter.args
+  end
+
+  private
+
+  # make a stack with test adapter that reflects the order of middleware
+  def build_stack(*handlers)
+    @builder.build do |b|
+      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
+      end
+    end
+  end
+
+  def assert_handlers(list)
+    echoed_list = @conn.get('/').body.to_s.split(':')
+    echoed_list.shift if echoed_list.first == ''
+    assert_equal list, echoed_list
+  end
+
+  def unregister_middleware(component, key)
+    # TODO: unregister API?
+    component.instance_variable_get('@registered_middleware').delete(key)
+  end
+end