faraday 0.6.1 → 0.7.4

data/lib/faraday/request.rb

@@ -9,7 +9,7 @@ module Faraday
   #     req.body = 'abc'
   #   end
   #
-  class Request < Struct.new(:path, :params, :headers, :body)
+  class Request < Struct.new(:path, :params, :headers, :body, :options)
     extend AutoloadHelper
 
     autoload_all 'faraday/request',
@@ -22,16 +22,19 @@ module Faraday
       :url_encoded => :UrlEncoded,
       :multipart   => :Multipart
 
-    def self.run(connection, request_method)
-      req = create
-      yield req if block_given?
-      req.run(connection, request_method)
+    attr_reader :method
+
+    def self.create(request_method)
+      new(request_method).tap do |request|
+        yield request if block_given?
+      end
     end
 
-    def self.create
-      req = new(nil, {}, {}, nil)
-      yield req if block_given?
-      req
+    def initialize(request_method)
+      @method = request_method
+      self.params  = {}
+      self.headers = {}
+      self.options = {}
     end
 
     def url(path, params = {})
@@ -63,29 +66,19 @@ module Faraday
     #     :user       - Proxy server username
     #     :password   - Proxy server password
     # :ssl - Hash of options for configuring SSL requests.
-    def to_env_hash(connection, request_method)
-      env_headers = connection.headers.dup
-      env_params  = connection.params.dup
-      connection.merge_headers(env_headers, headers)
-      connection.merge_params(env_params,  params)
+    def to_env(connection)
+      env_params  = connection.params.merge(params)
+      env_headers = connection.headers.merge(headers)
+      request_options = Utils.deep_merge(connection.options, options)
+      Utils.deep_merge!(request_options, :proxy => connection.proxy)
 
-      { :method           => request_method,
+      { :method           => method,
         :body             => body,
         :url              => connection.build_url(path, env_params),
         :request_headers  => env_headers,
         :parallel_manager => connection.parallel_manager,
-        :request          => connection.options.merge(:proxy => connection.proxy),
+        :request          => request_options,
         :ssl              => connection.ssl}
     end
-
-    def run(connection, request_method)
-      app = lambda { |env|
-        response = Response.new
-        response.finish(env) unless env[:parallel_manager]
-        env[:response] = response
-      }
-      env = to_env_hash(connection, request_method)
-      connection.builder.to_app(app).call(env)
-    end
   end
 end

data/lib/faraday/response.rb

@@ -14,7 +14,7 @@ module Faraday
       # Calls the `parse` method if defined
       def on_complete(env)
         if respond_to? :parse
-          env[:body] = parse(env[:body])
+          env[:body] = parse(env[:body]) unless [204,304].index env[:status]
         end
       end
     end
@@ -72,7 +72,7 @@ module Faraday
     end
 
     def success?
-      status == 200
+      (200..299).include?(status)
     end
 
     # because @on_complete_callbacks cannot be marshalled

data/lib/faraday/utils.rb

@@ -1,4 +1,5 @@
 require 'rack/utils'
+
 module Faraday
   module Utils
     include Rack::Utils
@@ -17,7 +18,7 @@ module Faraday
         end
       end
       KeyMap[:etag] = "ETag"
-      
+
       def [](k)
         super(KeyMap[k])
       end
@@ -27,9 +28,9 @@ module Faraday
         v = v.to_ary.join(', ') if v.respond_to? :to_ary
         super(KeyMap[k], v)
       end
-      
+
       alias_method :update, :merge!
-      
+
       def parse(header_string)
         return unless header_string && !header_string.empty?
         header_string.split(/\r\n/).
@@ -44,8 +45,65 @@ module Faraday
       end
     end
 
-    # Make Rack::Utils build_query method public.
-    public :build_query
+    # hash with stringified keys
+    class ParamsHash < Hash
+      def [](key)
+        super(convert_key(key))
+      end
+
+      def []=(key, value)
+        super(convert_key(key), value)
+      end
+
+      def delete(key)
+        super(convert_key(key))
+      end
+
+      def include?(key)
+        super(convert_key(key))
+      end
+
+      alias_method :has_key?, :include?
+      alias_method :member?, :include?
+      alias_method :key?, :include?
+
+      def update(params)
+        params.each do |key, value|
+          self[key] = value
+        end
+        self
+      end
+      alias_method :merge!, :update
+
+      def merge(params)
+        dup.update(params)
+      end
+
+      def replace(other)
+        clear
+        update(other)
+      end
+
+      def merge_query(query)
+        if query && !query.empty?
+          update Utils.parse_query(query)
+        end
+        self
+      end
+
+      def to_query
+        Utils.build_query(self)
+      end
+
+      private
+
+      def convert_key(key)
+        key.to_s
+      end
+    end
+
+    # Make Rack::Utils methods public.
+    public :build_query, :parse_query
 
     # Override Rack's version since it doesn't handle non-String values
     def build_nested_query(value, prefix = nil)
@@ -72,24 +130,27 @@ module Faraday
       end
     end
 
-    # Turns param keys into strings
-    def merge_params(existing_params, new_params)
-      new_params.each do |key, value|
-        existing_params[key.to_s] = value
-      end
+    # Receives a URL and returns just the path with the query string sorted.
+    def normalize_path(url)
+      (url.path != "" ? url.path : "/") +
+      (url.query ? "?#{sort_query_params(url.query)}" : "")
     end
 
-    # Turns headers keys and values into strings
-    def merge_headers(existing_headers, new_headers)
-      new_headers.each do |key, value|
-        existing_headers[key] = value.to_s
+    # Recursive hash update
+    def deep_merge!(target, hash)
+      hash.each do |key, value|
+        if Hash === value and Hash === target[key]
+          target[key] = deep_merge(target[key], value)
+        else
+          target[key] = value
+        end
       end
+      target
     end
 
-    # Receives a URL and returns just the path with the query string sorted.
-    def normalize_path(url)
-      (url.path != "" ? url.path : "/") +
-      (url.query ? "?#{sort_query_params(url.query)}" : "")
+    # Recursive hash merge
+    def deep_merge(source, hash)
+      deep_merge!(source.dup, hash)
     end
 
     protected

data/lib/faraday.rb

@@ -1,5 +1,5 @@
 module Faraday
-  VERSION = "0.6.1"
+  VERSION = "0.7.4"
 
   class << self
     attr_accessor :default_adapter

data/test/adapters/live_test.rb

@@ -1,7 +1,7 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'helper'))
 
 if !Faraday::TestCase::LIVE_SERVER
-  warn "warning: test server is not up; skipping live server tests"
+  warn "warning: test server not specified; skipping live server tests"
 else
   module Adapters
     class LiveTest < Faraday::TestCase
@@ -67,8 +67,8 @@ else
           assert_equal "file live_test.rb text/x-ruby", resp.body
         end unless :default == adapter # isn't configured for multipart
 
-        # http://github.com/toland/patron/issues/#issue/9
-        if ENV['FORCE'] || adapter != Faraday::Adapter::Patron
+        # https://github.com/toland/patron/issues/9
+        if ENV['FORCE'] || %[Faraday::Adapter::Patron] != adapter.to_s
           define_method "test_#{adapter}_PUT_send_url_encoded_params" do
             resp = create_connection(adapter).put do |req|
               req.url 'echo_name'
@@ -84,12 +84,31 @@ else
             end
             assert_equal %({"first"=>"zack"}), resp.body
           end
+        end
 
+        # https://github.com/toland/patron/issues/9
+        # https://github.com/dbalatero/typhoeus/issues/84
+        if ENV['FORCE'] || !%w[Faraday::Adapter::Patron Faraday::Adapter::Typhoeus].include?(adapter.to_s)
           define_method "test_#{adapter}_PUT_retrieves_the_response_headers" do
             assert_match /text\/html/, create_connection(adapter).put('echo_name').headers['content-type']
           end
         end
 
+        # https://github.com/toland/patron/issues/34
+        unless %w[Faraday::Adapter::Patron Faraday::Adapter::EMSynchrony].include? adapter.to_s
+          define_method "test_#{adapter}_PATCH_send_url_encoded_params" do
+            resp = create_connection(adapter).patch('echo_name', 'name' => 'zack')
+            assert_equal %("zack"), resp.body
+          end
+        end
+
+        unless %[Faraday::Adapter::EMSynchrony] == adapter.to_s
+          define_method "test_#{adapter}_OPTIONS" do
+            resp = create_connection(adapter).run_request(:options, '/options', nil, {})
+            assert_equal "hi", resp.body
+          end
+        end
+
         define_method "test_#{adapter}_HEAD_send_url_encoded_params" do
           resp = create_connection(adapter).head do |req|
             req.url 'hello', 'name' => 'zack'
@@ -158,19 +177,19 @@ else
 
       def create_connection(adapter)
         if adapter == :default
-          Faraday.default_connection.tap do |conn|
-            conn.url_prefix = LIVE_SERVER
-            conn.headers['X-Faraday-Adapter'] = adapter.to_s
-          end
+          builder_block = nil
         else
-          Faraday::Connection.new LIVE_SERVER, :headers => {'X-Faraday-Adapter' => adapter.to_s} do |b|
+          builder_block = Proc.new do |b|
             b.request :multipart
             b.request :url_encoded
             b.use adapter
           end
-        end.tap do |conn|
-          target = conn.builder.handlers.last
-          conn.builder.insert_before target, Faraday::Response::RaiseError
+        end
+        
+        Faraday::Connection.new(LIVE_SERVER, &builder_block).tap do |conn|
+          conn.headers['X-Faraday-Adapter'] = adapter.to_s
+          adapter_handler = conn.builder.handlers.last
+          conn.builder.insert_before adapter_handler, Faraday::Response::RaiseError
         end
       end
 

data/test/adapters/test_middleware_test.rb

@@ -27,6 +27,20 @@ module Adapters
       assert_equal 'hello', @conn.get("/hello").body
     end
 
+    def test_middleware_with_get_params
+      @stubs.get('/param?a=1') { [200, {}, 'a'] }
+      assert_equal 'a', @conn.get('/param?a=1').body
+    end
+
+    def test_middleware_ignores_unspecified_get_params
+      @stubs.get('/optional?a=1') { [200, {}, 'a'] }
+      assert_equal 'a', @conn.get('/optional?a=1&b=1').body
+      assert_equal 'a', @conn.get('/optional?a=1').body
+      assert_raise Faraday::Adapter::Test::Stubs::NotFound do
+        @conn.get('/optional')
+      end
+    end
+
     def test_middleware_allow_different_outcomes_for_the_same_request
       @stubs.get('/hello') { [200, {'Content-Type' => 'text/html'}, 'hello'] }
       @stubs.get('/hello') { [200, {'Content-Type' => 'text/html'}, 'world'] }
@@ -34,8 +48,21 @@ module Adapters
       assert_equal 'world', @conn.get("/hello").body
     end
 
+    def test_yields_env_to_stubs
+      @stubs.get '/hello' do |env|
+        assert_equal '/hello',     env[:url].path
+        assert_equal 'foo.com',    env[:url].host
+        assert_equal '1',          env[:params]['a']
+        assert_equal 'text/plain', env[:request_headers]['Accept']
+        [200, {}, 'a']
+      end
+
+      @conn.headers['Accept'] = 'text/plain'
+      assert_equal 'a', @conn.get('http://foo.com/hello?a=1').body
+    end
+
     def test_raises_an_error_if_no_stub_is_found_for_request
-      assert_raise RuntimeError do
+      assert_raise Faraday::Adapter::Test::Stubs::NotFound do
         @conn.get('/invalid'){ [200, {}, []] }
       end
     end

data/test/connection_test.rb

@@ -38,18 +38,22 @@ class TestConnection < Faraday::TestCase
 
   def test_initialize_stores_default_params_from_options
     conn = Faraday::Connection.new :params => {:a => 1}
-    assert_equal 1, conn.params['a']
+    assert_equal({'a' => 1}, conn.params)
   end
 
   def test_initialize_stores_default_params_from_uri
-    conn = Faraday::Connection.new "http://sushi.com/fish?a=1", :params => {'b' => '2'}
-    assert_equal '1', conn.params['a']
-    assert_equal '2', conn.params['b']
+    conn = Faraday::Connection.new "http://sushi.com/fish?a=1"
+    assert_equal({'a' => '1'}, conn.params)
+  end
+
+  def test_initialize_stores_default_params_from_uri_and_options
+    conn = Faraday::Connection.new "http://sushi.com/fish?a=1&b=2", :params => {'a' => 3}
+    assert_equal({'a' => 3, 'b' => '2'}, conn.params)
   end
 
   def test_initialize_stores_default_headers_from_options
-    conn = Faraday::Connection.new :headers => {:a => 1}
-    assert_equal '1', conn.headers['A']
+    conn = Faraday::Connection.new :headers => {:user_agent => 'Faraday'}
+    assert_equal 'Faraday', conn.headers['User-agent']
   end
 
   def test_basic_auth_sets_authorization_header
@@ -143,6 +147,13 @@ class TestConnection < Faraday::TestCase
     assert_equal '/sake.html', uri.path
   end
 
+  def test_build_url_doesnt_add_ending_slash
+    conn = Faraday::Connection.new
+    conn.url_prefix = "http://sushi.com/nigiri"
+    uri = conn.build_url(nil)
+    assert_equal "/nigiri", uri.path
+  end
+
   def test_build_url_parses_url_params_into_query
     conn = Faraday::Connection.new
     uri = conn.build_url("http://sushi.com/sake.html", 'a[b]' => '1 + 2')
@@ -152,21 +163,21 @@ class TestConnection < Faraday::TestCase
   def test_build_url_mashes_default_and_given_params_together
     conn = Faraday::Connection.new 'http://sushi.com/api?token=abc', :params => {'format' => 'json'}
     url = conn.build_url("nigiri?page=1", :limit => 5)
-    assert_match /limit=5/,      url.query
-    assert_match /page=1/,       url.query
-    assert_match /format=json/,  url.query
-    assert_match /token=abc/,    url.query
+    assert_equal %w[format=json limit=5 page=1 token=abc], url.query.split('&').sort
   end
 
   def test_build_url_overrides_default_params_with_given_params
     conn = Faraday::Connection.new 'http://sushi.com/api?token=abc', :params => {'format' => 'json'}
     url = conn.build_url("nigiri?page=1", :limit => 5, :token => 'def', :format => 'xml')
-    assert_match /limit=5/,        url.query
-    assert_match /page=1/,         url.query
-    assert_match /format=xml/,     url.query
-    assert_match /token=def/,      url.query
-    assert_no_match /format=json/, url.query
-    assert_no_match /token=abc/,   url.query
+    assert_equal %w[format=xml limit=5 page=1 token=def], url.query.split('&').sort
+  end
+
+  def test_default_params_hash_has_indifferent_access
+    conn = Faraday::Connection.new :params => {'format' => 'json'}
+    assert conn.params.has_key?(:format)
+    conn.params[:format] = 'xml'
+    url = conn.build_url("")
+    assert_equal %w[format=xml], url.query.split('&').sort
   end
 
   def test_build_url_parses_url
@@ -222,10 +233,8 @@ class TestConnection < Faraday::TestCase
 
   def test_params_to_query_converts_hash_of_params_to_uri_escaped_query_string
     conn = Faraday::Connection.new
-    class << conn
-      public :build_query
-    end
-    assert_equal "a%5Bb%5D=1%20%2B%202", conn.build_query('a[b]' => '1 + 2')
+    url = conn.build_url('', 'a[b]' => '1 + 2')
+    assert_equal "a%5Bb%5D=1%20%2B%202", url.query
   end
 
   def test_dups_connection_object

data/test/env_test.rb

@@ -2,55 +2,79 @@ 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'}
+    @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'
-    @input = { :body => 'abc' }
-    @env = env_for @conn do |req|
-      req.url 'foo.json', 'a' => 1
-      req['Server'] = 'Faraday'
-      req.body = @input[:body]
-    end
   end
 
   def test_request_create_stores_method
-    assert_equal :get, @env[:method]
+    env = make_env(:get)
+    assert_equal :get, env[:method]
   end
 
   def test_request_create_stores_addressable_uri
-    assert_equal 'http://sushi.com/api/foo.json?a=1', @env[:url].to_s
+    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
-    headers = @env[:request_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
-    assert_equal @input[:body], @env[:body]
+    env = make_env do |req|
+      req.body = 'hi'
+    end
+    assert_equal 'hi', env[:body]
   end
 
-  def test_request_create_stores_timeout_options
-    assert_equal 3, @env[:request][:timeout]
-    assert_equal 5, @env[:request][:open_timeout]
+  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
-    assert_equal false, @env[:ssl][:verify]
+    env = make_env
+    assert_equal false, env[:ssl][:verify]
   end
 
   def test_request_create_stores_proxy_options
-    assert_equal 'proxy.com', @env[:request][:proxy][:uri].host
+    env = make_env
+    assert_equal 'proxy.com', env[:request][:proxy][:uri].host
   end
 
-  def env_for(connection)
-    env_setup = Faraday::Request.create do |req|
-      yield req
-    end
-    env_setup.to_env_hash(connection, :get)
+  private
+
+  def make_env(method = :get, connection = @conn, &block)
+    request = Faraday::Request.create(method, &block)
+    request.to_env(connection)
   end
 end
 

data/test/helper.rb

@@ -1,12 +1,5 @@
+require 'rubygems'
 require 'test/unit'
-unless ENV['BUNDLE_GEMFILE']
-  require 'rubygems'
-  require 'bundler'
-  Bundler.setup
-end
-
-require 'webmock/test_unit'
-WebMock.disable_net_connect!(:allow_localhost => true)
 
 if ENV['LEFTRIGHT']
   begin
@@ -43,3 +36,6 @@ module Faraday
     end unless defined? ::MiniTest
   end
 end
+
+require 'webmock/test_unit'
+WebMock.disable_net_connect!(:allow => Faraday::TestCase::LIVE_SERVER)

data/test/live_server.rb

@@ -20,18 +20,22 @@ post '/file' do
   end
 end
 
-%w[get post].each do |method|
+[:get, :post].each do |method|
   send(method, '/hello') do
     "hello #{params[:name]}"
   end
 end
 
-%w[post put].each do |method|
-  send(method, '/echo_name') do
+%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

data/test/middleware_stack_test.rb

@@ -26,8 +26,6 @@ class MiddlewareStackTest < Faraday::TestCase
 
   def test_allows_rebuilding
     build_stack Apple
-    assert_handlers %w[Apple]
-
     build_stack Orange
     assert_handlers %w[Orange]
   end
@@ -67,6 +65,35 @@ class MiddlewareStackTest < Faraday::TestCase
     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