koala 1.1.0 → 1.2.0beta1

data/lib/koala/http_services.rb

@@ -1,46 +0,0 @@
-module Koala
-  class Response
-    attr_reader :status, :body, :headers
-    def initialize(status, body, headers)
-      @status = status
-      @body = body
-      @headers = headers
-    end
-  end
-
-  module HTTPService
-    # common functionality for all HTTP services
-    def self.included(base)
-      base.class_eval do
-        class << self
-          attr_accessor :always_use_ssl, :proxy, :timeout
-        end
-
-        def self.server(options = {})
-          server = "#{options[:rest_api] ? Facebook::REST_SERVER : Facebook::GRAPH_SERVER}"
-          server.gsub!(/\.facebook/, "-video.facebook") if options[:video]
-          "#{options[:beta] ? "beta." : ""}#{server}"
-        end
-        
-        def self.encode_params(param_hash)
-          # unfortunately, we can't use to_query because that's Rails, not Ruby
-          # if no hash (e.g. no auth token) return empty string
-          ((param_hash || {}).collect do |key_and_value|
-            key_and_value[1] = MultiJson.encode(key_and_value[1]) unless key_and_value[1].is_a? String
-            "#{key_and_value[0].to_s}=#{CGI.escape key_and_value[1]}"
-          end).join("&")
-        end
-                                      
-        protected
-        
-        def self.params_require_multipart?(param_hash)
-          param_hash.any? { |key, value| value.kind_of?(Koala::UploadableIO) }
-        end
-    
-        def self.multipart_requires_content_type?
-          true
-        end
-      end
-    end
-  end
-end

data/lib/koala/http_services/net_http_service.rb

@@ -1,92 +0,0 @@
-require "net/http" unless defined?(Net::HTTP)
-require "net/https"
-require "net/http/post/multipart"
-
-module Koala
-  module NetHTTPService
-    # this service uses Net::HTTP to send requests to the graph
-    include Koala::HTTPService
-
-    # Net::HTTP-specific values
-    class << self
-      attr_accessor :ca_file, :ca_path, :verify_mode
-    end
-    
-    def self.make_request(path, args, verb, options = {})
-      # We translate args to a valid query string. If post is specified,
-      # we send a POST request to the given path with the given arguments.
-
-      # by default, we use SSL only for private requests
-      # this makes public requests faster
-      private_request = args["access_token"] || @always_use_ssl || options[:use_ssl]
-
-      # if the verb isn't get or post, send it as a post argument
-      args.merge!({:method => verb}) && verb = "post" if verb != "get" && verb != "post"
-
-      http = create_http(server(options), private_request, options)
-
-      response = http.start do |http|
-        if verb == "post"
-          if params_require_multipart? args
-            http.request Net::HTTP::Post::Multipart.new path, encode_multipart_params(args)
-          else
-            http.post(path, encode_params(args))
-          end
-        else
-          http.get("#{path}?#{encode_params(args)}")
-        end
-      end
-
-      Koala::Response.new(response.code.to_i, response.body, response)
-    end
-
-    protected
-    def self.encode_params(param_hash)
-      # unfortunately, we can't use to_query because that's Rails, not Ruby
-      # if no hash (e.g. no auth token) return empty string
-      ((param_hash || {}).collect do |key_and_value|
-        key_and_value[1] = MultiJson.encode(key_and_value[1]) if key_and_value[1].class != String
-        "#{key_and_value[0].to_s}=#{CGI.escape key_and_value[1]}"
-      end).join("&")
-    end
-
-    def self.encode_multipart_params(param_hash)
-      Hash[*param_hash.collect do |key, value|
-        [key, value.kind_of?(Koala::UploadableIO) ? value.to_upload_io : value]
-      end.flatten]
-    end
-
-    def self.create_http(server, private_request, options)
-      if proxy_server = options[:proxy] || proxy
-        proxy = URI.parse(proxy_server)
-        http  = Net::HTTP.new(server, private_request ? 443 : nil,
-                              proxy.host, proxy.port, proxy.user, proxy.password)
-      else
-        http  = Net::HTTP.new(server, private_request ? 443 : nil)
-      end
-
-      if timeout_value = options[:timeout] || timeout
-        http.open_timeout = timeout_value
-        http.read_timeout = timeout_value
-      end
-
-      # For HTTPS requests, set the proper CA certificates
-      if private_request
-        http.use_ssl = true  
-        http.verify_mode = options[:verify_mode] || verify_mode || OpenSSL::SSL::VERIFY_PEER
-        
-        if cert_file = options[:ca_file] || ca_file
-          raise Errno::ENOENT, "Certificate file #{cert_file.inspect} does not exist!" unless File.exists?(cert_file)
-          http.ca_file = cert_file 
-        end
-        
-        if cert_path = options[:ca_path] || ca_path
-          raise Errno::ENOENT, "Certificate path #{cert_path.inspect} does not exist!" unless File.directory?(cert_path)
-          http.ca_path = cert_path
-        end
-      end
-
-      http
-    end
-  end
-end

data/lib/koala/http_services/typhoeus_service.rb

@@ -1,37 +0,0 @@
-require "typhoeus" unless defined?(Typhoeus)
-
-module Koala
-  module TyphoeusService
-    # this service uses Typhoeus to send requests to the graph
-    include Typhoeus
-    include Koala::HTTPService
-
-    def self.make_request(path, args, verb, options = {})
-      # if the verb isn't get or post, send it as a post argument
-      args.merge!({:method => verb}) && verb = "post" if verb != "get" && verb != "post"
-
-      # switch any UploadableIOs to the files Typhoeus expects
-      args.each_pair {|key, value| args[key] = value.to_file if value.is_a?(UploadableIO)}
-
-      # you can pass arguments directly to Typhoeus using the :typhoeus_options key
-      typhoeus_options = {:params => args}.merge(options[:typhoeus_options] || {})
-
-      # if proxy/timeout options aren't passed, check if defaults are set
-      typhoeus_options[:proxy] ||= proxy
-      typhoeus_options[:timeout] ||= timeout
-
-      # by default, we use SSL only for private requests (e.g. with access token)
-      # this makes public requests faster
-      prefix = (args["access_token"] || @always_use_ssl || options[:use_ssl]) ? "https" : "http"
-
-      response = Typhoeus::Request.send(verb, "#{prefix}://#{server(options)}#{path}", typhoeus_options)
-      Koala::Response.new(response.code, response.body, response.headers_hash)
-    end
-
-    protected
-
-    def self.multipart_requires_content_type?
-      false # Typhoeus handles multipart file types, we don't have to require it
-    end
-  end
-end

data/spec/cases/http_services/http_service_spec.rb

@@ -1,129 +0,0 @@
-require 'spec_helper'
-
-
-class Bear
-  include Koala::HTTPService
-end
-
-describe "Koala::HTTPService" do
-
-  describe "common methods" do
-    describe "always_use_ssl accessor" do
-      it "should be added" do
-        # in Ruby 1.8, .methods returns strings
-        # in Ruby 1.9, .method returns symbols 
-        Bear.methods.collect {|m| m.to_sym}.should include(:always_use_ssl)
-        Bear.methods.collect {|m| m.to_sym}.should include(:always_use_ssl=)
-      end
-    end
-    
-    describe "proxy accessor" do
-      it "should be added" do
-        # in Ruby 1.8, .methods returns strings
-        # in Ruby 1.9, .method returns symbols 
-        Bear.methods.collect {|m| m.to_sym}.should include(:proxy)
-        Bear.methods.collect {|m| m.to_sym}.should include(:proxy=)
-      end
-    end
-    
-    describe "timeout accessor" do
-      it "should be added" do
-        # in Ruby 1.8, .methods returns strings
-        # in Ruby 1.9, .method returns symbols 
-        Bear.methods.collect {|m| m.to_sym}.should include(:timeout)
-        Bear.methods.collect {|m| m.to_sym}.should include(:timeout=)
-      end
-    end
-    
-    describe "server" do
-      describe "with no options" do
-        it "returns the REST server if options[:rest_api]" do
-          Bear.server(:rest_api => true).should == Koala::Facebook::REST_SERVER
-        end
-
-        it "returns the graph server if !options[:rest_api]" do
-          Bear.server(:rest_api => false).should == Koala::Facebook::GRAPH_SERVER
-          Bear.server({}).should == Koala::Facebook::GRAPH_SERVER
-        end
-      end
-
-      describe "with options[:beta]" do
-        before :each do
-          @options = {:beta => true}
-        end
-        
-        it "returns the beta REST server if options[:rest_api]" do
-          server = Bear.server(@options.merge(:rest_api => true))
-          server.should =~ Regexp.new("beta.#{Koala::Facebook::REST_SERVER}")
-        end
-
-        it "returns the beta rest server if !options[:rest_api]" do
-          server = Bear.server(@options)
-          server.should =~ Regexp.new("beta.#{Koala::Facebook::GRAPH_SERVER}")
-        end
-      end
-      
-      describe "with options[:video]" do
-        before :each do
-          @options = {:video => true}
-        end
-        
-        it "should return the REST video server if options[:rest_api]" do
-          server = Bear.server(@options.merge(:rest_api => true))
-          server.should =~ Regexp.new(Koala::Facebook::REST_SERVER.gsub(/\.facebook/, "-video.facebook"))
-        end
-
-        it "should return the graph video server if !options[:rest_api]" do
-          server = Bear.server(@options)
-          server.should =~ Regexp.new(Koala::Facebook::GRAPH_SERVER.gsub(/\.facebook/, "-video.facebook"))
-        end
-      end
-    end
-
-    describe "#encode_params" do
-      it "should return an empty string if param_hash evaluates to false" do
-        Bear.encode_params(nil).should == ''
-      end
-
-      it "should convert values to JSON if the value is not a String" do
-        val = 'json_value'
-        not_a_string = 'not_a_string'
-        not_a_string.stub(:is_a?).and_return(false)
-        MultiJson.should_receive(:encode).with(not_a_string).and_return(val)
-
-        string = "hi"
-
-        args = {
-          not_a_string => not_a_string,
-          string => string
-        }
-
-        result = Bear.encode_params(args)
-        result.split('&').find do |key_and_val|
-          key_and_val.match("#{not_a_string}=#{val}")
-        end.should be_true
-      end
-
-      it "should escape all values" do
-        args = Hash[*(1..4).map {|i| [i.to_s, "Value #{i}($"]}.flatten]
-
-        result = Bear.encode_params(args)
-        result.split('&').each do |key_val|
-          key, val = key_val.split('=')
-          val.should == CGI.escape(args[key])
-        end
-      end
-
-      it "should convert all keys to Strings" do
-        args = Hash[*(1..4).map {|i| [i, "val#{i}"]}.flatten]
-
-        result = Bear.encode_params(args)
-        result.split('&').each do |key_val|
-          key, val = key_val.split('=')
-          key.should == args.find{|key_val_arr| key_val_arr.last == val}.first.to_s
-        end
-      end
-    end
-  end
-
-end

data/spec/cases/http_services/net_http_service_spec.rb

@@ -1,532 +0,0 @@
-require 'spec_helper'
-
-
-Horse = Koala::NetHTTPService
-
-describe "NetHTTPService module holder class Horse" do
-  before :each do
-    # reset global settings
-    Horse.always_use_ssl = Horse.proxy = Horse.timeout = nil
-  end
-
-  it "has a ca_file accessor" do
-    Horse.methods.collect {|m| m.to_sym}.should include(:ca_file)
-    Horse.methods.collect {|m| m.to_sym}.should include(:ca_file=)
-  end
-
-  it "has a ca_path accessor" do
-    Horse.methods.collect {|m| m.to_sym}.should include(:ca_path)
-    Horse.methods.collect {|m| m.to_sym}.should include(:ca_path=)
-  end
-
-  it "has a verify_mode accessor" do
-    Horse.methods.collect {|m| m.to_sym}.should include(:verify_mode)
-    Horse.methods.collect {|m| m.to_sym}.should include(:verify_mode=)
-  end
-
-  it "should define a make_request static module method" do
-    Horse.respond_to?(:make_request).should be_true
-  end
-
-  it "should include the Koala::HTTPService module defining common features" do
-    Horse.included_modules.include?(Koala::HTTPService).should be_true
-  end
-
-  describe "when making a request" do
-    before(:each) do
-      # Setup stubs for make_request to execute without exceptions
-      @mock_body = stub('Net::HTTPResponse body')
-      @mock_http_response = stub('Net::HTTPResponse', :code => 1, :body => @mock_body)
-
-      @http_yield_mock = mock('Net::HTTP start yielded object')
-
-      @http_yield_mock.stub(:post).and_return(@mock_http_response)
-      @http_yield_mock.stub(:get).and_return(@mock_http_response)
-
-      @http_mock = stub('Net::HTTP object', 'use_ssl=' => true, 'verify_mode=' => true)
-      @http_mock.stub(:start).and_yield(@http_yield_mock)
-      @http_mock.stub(:ca_path=)
-      @http_mock.stub(:ca_file=)
-      @http_mock.stub(:verify_mode=)
-
-      Net::HTTP.stub(:new).and_return(@http_mock)
-    end
-
-    describe "the connection" do
-      it "should use POST if verb is not GET" do
-        @http_yield_mock.should_receive(:post).and_return(@mock_http_response)
-        @http_mock.should_receive(:start).and_yield(@http_yield_mock)
-
-        Horse.make_request('anything', {}, 'anything')
-      end
-
-      it "should use GET if that verb is specified" do
-        @http_yield_mock.should_receive(:get).and_return(@mock_http_response)
-        @http_mock.should_receive(:start).and_yield(@http_yield_mock)
-
-        Horse.make_request('anything', {}, 'get')
-      end
-
-      it "should add the method to the arguments if it's not get or post" do
-        args = {}
-        method = "telekenesis"
-        # since the arguments get encoded later, we'll test for merge!
-        # even though that's somewhat testing internal implementation
-        args.should_receive(:merge!).with(:method => method)
-
-        Horse.make_request('anything', args, method)
-      end
-    end
-
-    describe "if the request has an access token" do
-      before :each do
-        @args = {"access_token" => "123"}
-      end
-
-      it "should use SSL" do
-        @http_mock.should_receive('use_ssl=').with(true)
-
-        Horse.make_request('anything', @args, 'anything')
-      end
-
-      it "should set the port to 443" do
-        Net::HTTP.should_receive(:new).with(anything, 443).and_return(@http_mock)
-
-        Horse.make_request('anything', @args, 'anything')
-      end
-    end
-
-    describe "if always_use_ssl is true" do
-      before :each do
-        Horse.always_use_ssl = true
-      end
-
-      it "should use SSL" do
-        @http_mock.should_receive('use_ssl=').with(true)
-
-        Horse.make_request('anything', {}, 'anything')
-      end
-
-      it "should set the port to 443" do
-        Net::HTTP.should_receive(:new).with(anything, 443).and_return(@http_mock)
-
-        Horse.make_request('anything', {}, 'anything')
-      end
-    end
-
-    describe "if the use_ssl option is provided" do
-      it "should use SSL" do
-        @http_mock.should_receive('use_ssl=').with(true)
-
-        Horse.make_request('anything', {}, 'anything', :use_ssl => true)
-      end
-
-      it "should set the port to 443" do
-        Net::HTTP.should_receive(:new).with(anything, 443).and_return(@http_mock)
-
-        Horse.make_request('anything', {}, 'anything', :use_ssl => true)
-      end
-    end
-
-    describe "if there's no token and always_use_ssl isn't true" do
-      it "should not use SSL" do
-        @http_mock.should_not_receive('use_ssl=')
-        Horse.make_request('anything', {}, 'anything')
-      end
-
-      it "should not set the port" do
-        Net::HTTP.should_receive(:new).with(anything, nil).and_return(@http_mock)
-        Horse.make_request('anything', {}, 'anything')
-      end
-    end
-
-    describe "proxy options" do
-      before :each do
-        Horse.proxy = "http://defaultproxy"
-      end
-      after :all do
-        Horse.proxy = nil
-      end
-
-      it "should use passed proxy option if provided" do
-        Net::HTTP.should_receive(:new).with(Koala::Facebook::GRAPH_SERVER, anything, "passedproxy", 80, nil, nil).and_return(@http_mock)
-        Horse.make_request('anything', {} , 'anything', {:proxy => "http://passedproxy"})
-      end
-
-      it "should use default proxy if default is provided and NO proxy option passed" do
-        Net::HTTP.should_receive(:new).with(Koala::Facebook::GRAPH_SERVER, anything, "defaultproxy", 80, nil, nil).and_return(@http_mock)
-        Horse.make_request('anything', {} , 'anything', {})
-      end
-
-      it "should NOT use a proxy if default is NOT provided and NO proxy option passed" do
-        Horse.proxy = nil
-        Net::HTTP.should_receive(:new).with(Koala::Facebook::GRAPH_SERVER, anything).and_return(@http_mock)
-        Horse.make_request('anything', {} , 'anything', {})
-      end
-    end
-
-    describe "timeout options" do
-      before :each do
-        Horse.timeout = 20 # seconds
-      end
-      after :all do
-        Horse.timeout = nil # seconds
-      end
-
-      it "should use passed timeout option if provided" do
-        @http_mock.should_receive('open_timeout=').with(10)
-        @http_mock.should_receive('read_timeout=').with(10)
-        Horse.make_request('anything', {} , 'anything', {:timeout => 10})
-      end
-
-      it "should use default timout if default is provided and NO timeout option passed" do
-        @http_mock.should_receive('open_timeout=').with(20)
-        @http_mock.should_receive('read_timeout=').with(20)
-        Horse.make_request('anything', {} , 'anything', {})
-      end
-
-      it "should NOT use a timeout if default is NOT provided and NO timeout option passed" do
-        Horse.timeout = nil # seconds
-        @http_mock.should_not_receive('open_timeout=')
-        @http_mock.should_not_receive('read_timeout=')
-        Horse.make_request('anything', {} , 'anything', {})
-      end
-    end
-
-    describe "ca_file options" do
-      after :each do
-        Horse.always_use_ssl = nil
-        Horse.ca_file = nil
-      end
-
-      it "should not use a ca_file if the request is not via SSL" do
-        Horse.always_use_ssl = false
-        @http_mock.should_not_receive(:ca_file=)
-        Horse.make_request('anything', {} , 'anything', {:ca_file => '/no/file'})
-      end
-
-      describe "when via SSL" do
-        before :each do
-          Horse.always_use_ssl = true
-          @global_ca_file_path = '/global/ca/file/path'
-        end
-
-        context "if the file doesn't exist" do
-          it "raises Errno::ENOENT if the default ca_file does not exist" do
-            Horse.ca_file = @global_ca_file_path
-
-            File.should_receive(:exists?).with(@global_ca_file_path).and_return(false)
-            expect { Horse.make_request('anything', {} , 'anything', {}) }.to raise_exception(Errno::ENOENT)
-          end
-
-          it "raises Errno::ENOENT if options[:ca_file] does not exist" do
-            File.should_receive(:exists?).with(@global_ca_file_path).and_return(false)
-            expect { Horse.make_request('anything', {} , 'anything', {:ca_file => @global_ca_file_path}) }.to raise_exception(Errno::ENOENT)
-          end
-        end
-
-        context "if the file exists" do
-          before :each do
-            File.stub(:exists?).and_return(true)
-          end
-
-          it "should use options[:ca_file] if provided" do
-            given_ca_file = '/ca/file'
-
-            Horse.ca_file = @global_ca_file_path
-            @http_mock.should_not_receive(:ca_file=).with(@global_ca_file_path)
-            @http_mock.should_receive(:ca_file=).with(given_ca_file)
-
-            Horse.make_request('anything', {} , 'anything', {:ca_file => given_ca_file})
-          end
-
-          it "should use default ca_file if default is provided and NO ca_file option is passed" do
-            Horse.ca_file = @global_ca_file_path
-            @http_mock.should_receive(:ca_file=).with(@global_ca_file_path)
-
-            Horse.make_request('anything', {} , 'anything', {})
-          end
-
-          it "should NOT use a ca_file if default is NOT provided and NO ca_file option is passed" do
-            @http_mock.should_not_receive(:ca_file=)
-
-            Horse.make_request('anything', {} , 'anything', {})
-          end
-        end
-      end
-    end
-
-    describe "ca_path options" do
-      after :each do
-        Horse.always_use_ssl = nil
-        Horse.ca_path = nil
-      end
-
-      it "should not use a ca_path if the request is not via SSL" do
-        Horse.always_use_ssl = false
-        @http_mock.should_not_receive('ca_path=')
-        Horse.make_request('anything', {} , 'anything', {:ca_file => '/no/file'})
-      end
-
-      describe "when via SSL" do
-        before :each do
-          Horse.always_use_ssl = true
-          @global_ca_path = '/global/ca/path'
-        end
-
-        context "if the directory doesn't exist" do
-          it "should not use a default ca_path if the default ca_path does not exist" do
-            Horse.ca_path = @global_ca_path
-
-            File.should_receive(:directory?).with(@global_ca_path).and_return(false)
-            expect { Horse.make_request('anything', {} , 'anything', {}) }.to raise_exception(Errno::ENOENT)
-          end
-
-          it "should not use a default ca_path if the default ca_path does not exist" do
-            File.should_receive(:directory?).with(@global_ca_path).and_return(false)
-            expect { Horse.make_request('anything', {} , 'anything', {:ca_path => @global_ca_path}) }.to raise_exception(Errno::ENOENT)
-          end
-        end
-
-        context "if the directory exists" do
-          before :each do
-            File.stub(:directory?).and_return(true)
-          end
-
-          it "should use passed ca_path options if provided" do
-            given_ca_path = '/ca/path'
-
-            Horse.ca_path = @global_ca_path
-            @http_mock.should_not_receive(:ca_ath=).with(@global_ca_path)
-            @http_mock.should_receive(:ca_path=).with(given_ca_path)
-
-            Horse.make_request('anything', {} , 'anything', {:ca_path => given_ca_path})
-          end
-
-          it "should use default ca_path if default is provided and NO ca_path option is passed" do
-            Horse.ca_path = @global_ca_path
-            @http_mock.should_receive(:ca_path=).with(@global_ca_path)
-
-            Horse.make_request('anything', {} , 'anything', {})
-          end
-
-          it "should NOT use a ca_path if default is NOT provided and NO ca_path option is passed" do
-            @http_mock.should_not_receive(:ca_path=)
-
-            Horse.make_request('anything', {} , 'anything', {})
-          end
-        end
-      end
-    end
-
-    describe "verify_mode options" do
-      after :each do
-        Horse.always_use_ssl = nil
-        Horse.verify_mode = nil
-      end
-
-      it "does not set verify mode if it's not SSL" do
-        Horse.always_use_ssl = nil
-        @http_mock.should_not_receive(:verify_mode=)
-        Horse.make_request('anything', {} , 'anything', {:verify_mode => "abc"})
-      end
-
-      context "when making an SSL request" do
-        before :each do
-          Horse.always_use_ssl = true
-        end
-
-        it "sets verify mode if provided in the options" do
-          mode = "foo"
-          @http_mock.should_receive(:verify_mode=).with(mode)
-          Horse.make_request('anything', {} , 'anything', {:verify_mode => mode})
-        end
-
-        it "sets verify mode to the default if provided (and none set in options)" do
-          Horse.verify_mode = "foo"
-          @http_mock.should_receive(:verify_mode=).with(Horse.verify_mode)
-          Horse.make_request('anything', {} , 'anything', {})
-        end
-
-        it "sets verify mode to the default if provided (and none set in options)" do
-          mode = "bar"
-          Horse.verify_mode = "foo"
-          @http_mock.should_receive(:verify_mode=).with(mode)
-          Horse.make_request('anything', {} , 'anything', {:verify_mode => mode})
-        end
-
-        it "sets verify mode to OpenSSL::SSL::VERIFY_PEER if no default or option is provided" do
-          @http_mock.should_receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_PEER)
-          Horse.make_request('anything', {} , 'anything', {})
-        end
-      end
-    end
-
-    it "should use the graph server by default" do
-      Net::HTTP.should_receive(:new).with(Koala::Facebook::GRAPH_SERVER, anything).and_return(@http_mock)
-      Horse.make_request('anything', {}, 'anything')
-    end
-
-    it "should use the REST server if the :rest_api option is true" do
-      Net::HTTP.should_receive(:new).with(Koala::Facebook::REST_SERVER, anything).and_return(@http_mock)
-      Horse.make_request('anything', {}, 'anything', :rest_api => true)
-    end
-
-    it "should start an HTTP connection" do
-      @http_mock.should_receive(:start).and_yield(@http_yield_mock)
-      Horse.make_request('anything', {}, 'anything')
-    end
-
-    it 'creates a HTTP Proxy object when options contain a proxy' do
-      Net::HTTP.should_receive(:new).with(anything, anything, 'proxy', 1234, 'user', 'pass').and_return(@http_mock)
-      Horse.make_request('anything', {}, 'anything', {:proxy => 'http://user:pass@proxy:1234'})
-    end
-
-    it 'sets both timeouts when options contains a timeout' do
-      @http_mock.should_receive(:open_timeout=).with(10)
-      @http_mock.should_receive(:read_timeout=).with(10)
-      Horse.make_request('anything', {}, 'anything', {:timeout => 10})
-    end
-
-    describe "via POST" do
-      it "should use Net::HTTP to make a POST request" do
-        @http_yield_mock.should_receive(:post).and_return(@mock_http_response)
-
-        Horse.make_request('anything', {}, 'post')
-      end
-
-      it "should go to the specified path adding a / if it doesn't exist" do
-        path = mock('Path')
-        @http_yield_mock.should_receive(:post).with(path, anything).and_return(@mock_http_response)
-
-        Horse.make_request(path, {}, 'post')
-      end
-
-      it "should use encoded parameters" do
-        args = {}
-        params = mock('Encoded parameters')
-        Horse.should_receive(:encode_params).with(args).and_return(params)
-
-        @http_yield_mock.should_receive(:post).with(anything, params).and_return(@mock_http_response)
-
-        Horse.make_request('anything', args, 'post')
-      end
-
-      describe "with multipart/form-data" do
-        before(:each) do
-          Horse.stub(:encode_multipart_params)
-          Horse.stub("params_require_multipart?").and_return(true)
-
-          @multipart_request_stub = stub('Stub Multipart Request')
-          Net::HTTP::Post::Multipart.stub(:new).and_return(@multipart_request_stub)
-
-          @file_stub = stub('fake File', "kind_of?" => true, "path" => 'anypath.jpg')
-
-          @http_yield_mock.stub(:request).with(@multipart_request_stub).and_return(@mock_http_response)
-        end
-
-        it "should use multipart/form-data if any parameter is a valid file hash" do
-          @http_yield_mock.should_receive(:request).with(@multipart_request_stub).and_return(@mock_http_response)
-
-          Horse.make_request('anything', {}, 'post')
-        end
-
-        it "should use the given request path for the request" do
-          args = {"file" => @file_stub}
-          expected_path = 'expected/path'
-
-          Net::HTTP::Post::Multipart.should_receive(:new).with(expected_path, anything).and_return(@multipart_request_stub)
-
-          Horse.make_request(expected_path, {}, 'post')
-        end
-
-        it "should use multipart encoded arguments for the request" do
-          args = {"file" => @file_stub}
-          expected_params = stub('Stub Multipart Params')
-
-          Horse.should_receive(:encode_multipart_params).with(args).and_return(expected_params)
-          Net::HTTP::Post::Multipart.should_receive(:new).with(anything, expected_params).and_return(@multipart_request_stub)
-
-          Horse.make_request('anything', args, 'post')
-        end
-      end
-    end
-
-    describe "via GET" do
-      it "should use Net::HTTP to make a GET request" do
-        @http_yield_mock.should_receive(:get).and_return(@mock_http_response)
-
-        Horse.make_request('anything', {}, 'get')
-      end
-
-      it "should use the correct path, including arguments" do
-        path = mock('Path')
-        params = mock('Encoded parameters')
-        args = {}
-
-        Horse.should_receive(:encode_params).with(args).and_return(params)
-        @http_yield_mock.should_receive(:get).with("#{path}?#{params}").and_return(@mock_http_response)
-
-        Horse.make_request(path, args, 'get')
-      end
-    end
-
-    describe "the returned value" do
-      before(:each) do
-        @response = Horse.make_request('anything', {}, 'anything')
-      end
-
-      it "should return a Koala::Response object" do
-        @response.class.should == Koala::Response
-      end
-
-      it "should return a Koala::Response with the right status" do
-        @response.status.should == @mock_http_response.code
-      end
-
-      it "should reutrn a Koala::Response with the right body" do
-        @response.body.should == @mock_body
-      end
-
-      it "should return a Koala::Response with the Net::HTTPResponse object as headers" do
-        @response.headers.should == @mock_http_response
-      end
-    end # describe return value
-  end # describe when making a request
-
-  describe "when detecting if multipart posting is needed" do
-    it "should be true if any parameter value requires multipart post" do
-      koala_io = mock("Koala::IO")
-      koala_io.should_receive(:kind_of?).with(Koala::UploadableIO).and_return(true)
-
-      args = {
-        "key1" => "val",
-        "key2" => "val",
-        "key3" => koala_io,
-        "key4" => "val"
-      }
-
-      Horse.params_require_multipart?(args).should be_true
-    end
-
-    describe "when encoding multipart/form-data params" do
-      it "should replace Koala::UploadableIO values with UploadIO values" do
-        upload_io = UploadIO.new(__FILE__, "fake type")
-
-        uploadable_io = stub('Koala::UploadableIO')
-        uploadable_io.should_receive(:kind_of?).with(Koala::UploadableIO).and_return(true)
-        uploadable_io.should_receive(:to_upload_io).and_return(upload_io)
-        args = {
-          "not_a_file" => "not a file",
-          "file" => uploadable_io
-        }
-
-        result = Horse.encode_multipart_params(args)
-
-        result["not_a_file"] == args["not_a_file"]
-        result["file"] == upload_io
-      end
-    end
-
-  end
-end