faraday 0.7.4 → 1.0.1

data/test/env_test.rb

@@ -1,158 +0,0 @@
-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_addressable_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 = Faraday::Request.create(method, &block)
-    request.to_env(connection)
-  end
-end
-
-class HeadersTest < Faraday::TestCase
-  def setup
-    @headers = Faraday::Utils::Headers.new
-  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

@@ -1,41 +0,0 @@
-require 'rubygems'
-require 'test/unit'
-
-if ENV['LEFTRIGHT']
-  begin
-    require 'leftright'
-  rescue LoadError
-    puts "Run `gem install leftright` to install leftright."
-  end
-end
-
-unless $LOAD_PATH.include? 'lib'
-  $LOAD_PATH.unshift(File.dirname(__FILE__))
-  $LOAD_PATH.unshift(File.join($LOAD_PATH.first, '..', 'lib'))
-end
-require 'faraday'
-
-begin
-  require 'ruby-debug'
-rescue LoadError
-  # ignore
-else
-  Debugger.start
-end
-
-module Faraday
-  class TestCase < Test::Unit::TestCase
-    LIVE_SERVER = case ENV['LIVE']
-      when /^http/ then ENV['LIVE']
-      when nil     then nil
-      else 'http://localhost:4567'
-    end
-
-    def test_default
-      assert true
-    end unless defined? ::MiniTest
-  end
-end
-
-require 'webmock/test_unit'
-WebMock.disable_net_connect!(:allow => Faraday::TestCase::LIVE_SERVER)

data/test/live_server.rb

@@ -1,45 +0,0 @@
-require 'sinatra'
-set :logging, false
-
-get '/hello_world' do
-  'hello world'
-end
-
-get '/json' do
-  content_type 'application/json'
-  "[1,2,3]"
-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, :post].each do |method|
-  send(method, '/hello') do
-    "hello #{params[:name]}"
-  end
-end
-
-%w[POST PUT PATCH].each do |http_method|
-  settings.send(:route, http_method, '/echo_name') do
-    params[:name].inspect
-  end
-end
-
-options '/options' do
-  'hi'
-end
-
-delete '/delete_with_json' do
-  %/{"deleted":true}/
-end
-
-get '/multi' do
-  [200, { 'Set-Cookie' => %w[ one two ] }, '']
-end

data/test/middleware_stack_test.rb

@@ -1,118 +0,0 @@
-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
-
-  def setup
-    @conn = Faraday::Connection.new
-    @builder = @conn.builder
-  end
-
-  def test_sets_default_adapter_if_none_set
-    default_middleware = Faraday::Request.lookup_module :url_encoded
-    default_adapter_klass = Faraday::Adapter.lookup_module 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
-
-  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) }
-
-      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
-end

data/test/request_middleware_test.rb

@@ -1,116 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
-require 'rack/utils'
-
-Faraday::CompositeReadIO.send :attr_reader, :ios
-
-class RequestMiddlewareTest < Faraday::TestCase
-  def setup
-    @conn = Faraday.new do |b|
-      b.request :multipart
-      b.request :url_encoded
-      b.request :json
-      b.adapter :test do |stub|
-        stub.post('/echo') do |env|
-          posted_as = env[:request_headers]['Content-Type']
-          [200, {'Content-Type' => posted_as}, env[:body]]
-        end
-      end
-    end
-  end
-
-  def test_does_nothing_without_payload
-    response = @conn.post('/echo')
-    assert_nil response.headers['Content-Type']
-    assert response.body.empty?
-  end
-
-  def test_ignores_custom_content_type
-    response = @conn.post('/echo', { :some => 'data' }, 'content-type' => 'application/x-foo')
-    assert_equal 'application/x-foo', response.headers['Content-Type']
-    assert_equal({ :some => 'data' }, response.body)
-  end
-
-  def test_json_encodes_hash
-    response = @conn.post('/echo', { :fruit => %w[apples oranges] }, 'content-type' => 'application/json')
-    assert_equal 'application/json', response.headers['Content-Type']
-    assert_equal '{"fruit":["apples","oranges"]}', response.body
-  end
-
-  def test_json_skips_encoding_for_strings
-    response = @conn.post('/echo', '{"a":"b"}', 'content-type' => 'application/json')
-    assert_equal 'application/json', response.headers['Content-Type']
-    assert_equal '{"a":"b"}', response.body
-  end
-
-  def test_json_fails_with_useful_message_when_no_json_adapter_available
-    without_json_adapter do
-      expected_msg = "No JSON adapter available. Install either activesupport or yajl-ruby."
-      # assert_raise doesn't work to check the message (at least on 1.8.7)
-      begin
-        @conn.post('/echo', { :fruit => %w[apples oranges] }, 'content-type' => 'application/json')
-        fail "Exception not raised"
-      rescue Faraday::Error::MissingDependency => e
-        assert_equal expected_msg, e.message
-      end
-    end
-  end
-
-  def test_url_encoded_does_not_fail_when_no_json_adapter_available
-    without_json_adapter do
-      assert_nothing_raised {
-        @conn.post('/echo', { :fruit => %w[apples oranges] })
-      }
-    end
-  end
-
-  def without_json_adapter
-    original_adapter = Faraday::Request::JSON.adapter
-    Faraday::Request::JSON.adapter = nil
-    begin
-      yield
-    ensure
-      Faraday::Request::JSON.adapter = original_adapter
-    end
-  end
-
-  def test_url_encoded_no_header
-    response = @conn.post('/echo', { :fruit => %w[apples oranges] })
-    assert_equal 'application/x-www-form-urlencoded', response.headers['Content-Type']
-    assert_equal 'fruit[]=apples&fruit[]=oranges', response.body
-  end
-
-  def test_url_encoded_with_header
-    response = @conn.post('/echo', {'a'=>123}, 'content-type' => 'application/x-www-form-urlencoded')
-    assert_equal 'application/x-www-form-urlencoded', response.headers['Content-Type']
-    assert_equal 'a=123', response.body
-  end
-
-  def test_url_encoded_nested
-    response = @conn.post('/echo', { :user => {:name => 'Mislav', :web => 'mislav.net'} })
-    assert_equal 'application/x-www-form-urlencoded', response.headers['Content-Type']
-    expected = { 'user' => {'name' => 'Mislav', 'web' => 'mislav.net'} }
-    assert_equal expected, Rack::Utils.parse_nested_query(response.body)
-  end
-
-  def test_multipart
-    # assume params are out of order
-    regexes = [
-      /name\=\"a\"/,
-      /name=\"b\[c\]\"\; filename\=\"request_middleware_test\.rb\"/,
-      /name=\"b\[d\]\"/]
-
-    payload = {:a => 1, :b => {:c => Faraday::UploadIO.new(__FILE__, 'text/x-ruby'), :d => 2}}
-    response = @conn.post('/echo', payload)
-
-    assert_kind_of Faraday::CompositeReadIO, response.body
-    assert_equal "multipart/form-data;boundary=%s" % Faraday::Request::Multipart::DEFAULT_BOUNDARY,
-      response.headers['Content-Type']
-
-    response.body.send(:ios).map{|io| io.read}.each do |io|
-      if re = regexes.detect { |r| io =~ r }
-        regexes.delete re
-      end
-    end
-    assert_equal [], regexes
-  end
-end

data/test/response_middleware_test.rb

@@ -1,74 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
-
-class ResponseMiddlewareTest < Faraday::TestCase
-  def setup
-    @conn = Faraday.new do |b|
-      b.response :raise_error
-      b.adapter :test do |stub|
-        stub.get('ok')        { [200, {'Content-Type' => 'text/html'}, '<body></body>'] }
-        stub.get('not-found') { [404, {'X-Reason' => 'because'}, 'keep looking'] }
-        stub.get('error')     { [500, {'X-Error' => 'bailout'}, 'fail'] }
-      end
-    end
-  end
-
-  class ResponseUpcaser < Faraday::Response::Middleware
-    def parse(body)
-      body.upcase
-    end
-  end
-
-  def test_success
-    assert_nothing_raised do
-      @conn.get('ok')
-    end
-  end
-  
-  def test_raises_not_found
-    error = assert_raises Faraday::Error::ResourceNotFound do
-      @conn.get('not-found')
-    end
-    assert_equal 'the server responded with status 404', error.message
-    assert_equal 'because', error.response[:headers]['X-Reason']
-  end
-  
-  def test_raises_error
-    error = assert_raises Faraday::Error::ClientError do
-      @conn.get('error')
-    end
-    assert_equal 'the server responded with status 500', error.message
-    assert_equal 'bailout', error.response[:headers]['X-Error']
-  end
-  
-  def test_upcase
-    @conn.builder.insert(0, ResponseUpcaser)
-    assert_equal '<BODY></BODY>', @conn.get('ok').body
-  end
-end
-
-class ResponseNoBodyMiddleWareTest < Faraday::TestCase
-  def setup
-    @conn = Faraday.new do |b|
-      b.response :raise_error
-      b.adapter :test do |stub|
-        stub.get('not modified') { [304, nil, nil] }
-        stub.get('no content') { [204, nil, nil] }
-      end
-    end
-    @conn.builder.insert(0, NotCalled)
-  end
-
-  class NotCalled < Faraday::Response::Middleware
-    def parse(body)
-      raise "this should not be called"
-    end
-  end
-
-  def test_204
-    assert_equal nil, @conn.get('no content').body
-  end
-
-  def test_304
-    assert_equal nil, @conn.get('not modified').body
-  end
-end