marnen-typhoeus 0.3.4

data/lib/typhoeus/service.rb

@@ -0,0 +1,20 @@
+module Typhoeus
+  class Service
+    def initialize(host, port)
+      @host = host
+      @port = port
+    end
+    
+    def get(resource, params)
+    end
+    
+    def put(resource, params)
+    end
+    
+    def post(resource, params)
+    end
+    
+    def delete(resource, params)
+    end
+  end
+end

data/lib/typhoeus/utils.rb

@@ -0,0 +1,74 @@
+require 'tempfile'
+
+module Typhoeus
+  module Utils
+    # Taken from Rack::Utils, 1.2.1 to remove Rack dependency.
+    def escape(s)
+      s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/u) {
+        '%'+$1.unpack('H2'*bytesize($1)).join('%').upcase
+      }.tr(' ', '+')
+    end
+    module_function :escape
+
+    # Params are NOT escaped.
+    def traverse_params_hash(hash, result = nil, current_key = nil)
+      result ||= { :files => [], :params => [] }
+
+      hash.keys.sort { |a, b| a.to_s <=> b.to_s }.collect do |key|
+        new_key = (current_key ? "#{current_key}[#{key}]" : key).to_s
+        current_value = hash[key]
+        process_value current_value, :result => result, :new_key => new_key
+      end
+      result
+    end
+    module_function :traverse_params_hash
+
+    def traversal_to_param_string(traversal, escape = true)
+      traversal[:params].collect { |param|
+        escape ? "#{Typhoeus::Utils.escape(param[0])}=#{Typhoeus::Utils.escape(param[1])}" : "#{param[0]}=#{param[1]}"
+      }.join('&')
+    end
+    module_function :traversal_to_param_string
+
+    # Return the bytesize of String; uses String#size under Ruby 1.8 and
+    # String#bytesize under 1.9.
+    if ''.respond_to?(:bytesize)
+      def bytesize(string)
+        string.bytesize
+      end
+    else
+      def bytesize(string)
+        string.size
+      end
+    end
+    module_function :bytesize
+
+    private
+
+    def process_value(current_value, options)
+      result = options[:result]
+      new_key = options[:new_key]
+
+      case current_value
+      when Hash
+        traverse_params_hash(current_value, result, new_key)
+      when Array
+        current_value.each do |v|
+          result[:params] << [new_key, v.to_s]
+        end
+      when File, Tempfile
+        filename = File.basename(current_value.path)
+        types = MIME::Types.type_for(filename)
+        result[:files] << [
+          new_key,
+          filename,
+          types.empty? ? 'application/octet-stream' : types[0].to_s,
+          File.expand_path(current_value.path)
+        ]
+      else
+        result[:params] << [new_key, current_value.to_s]
+      end
+    end
+    module_function :process_value
+  end
+end

data/lib/typhoeus/version.rb

@@ -0,0 +1,3 @@
+module Typhoeus
+  VERSION = '0.3.4'
+end

data/spec/fixtures/placeholder.txt

@@ -0,0 +1 @@
+This file is used to test uploading.

data/spec/fixtures/result_set.xml

@@ -0,0 +1,60 @@
+<result_set>
+  <ttl>20</ttl>
+  <result>
+    <id>1</id>
+    <name>hello</name>
+    <description>
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+    </description>
+  </result>
+  <result>
+    <id>2</id>
+    <name>hello</name>
+    <description>
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+    </description>
+  </result>
+  <result>
+    <id>3</id>
+    <name>hello</name>
+    <description>
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+      this is a long description for a text field of some kind.
+    </description>
+  </result>
+</result_set>

data/spec/servers/app.rb

@@ -0,0 +1,97 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'sinatra'
+require 'json'
+require 'zlib'
+
+set :logging, false
+
+@@fail_count = 0
+
+post '/file' do
+  {
+    'content-type' => params[:file][:type],
+    'filename' => params[:file][:filename],
+    'content' => params[:file][:tempfile].read,
+    'request-content-type' => request.env['CONTENT_TYPE']
+  }.to_json
+end
+
+get '/multiple-headers' do
+  [200, { 'Set-Cookie' => %w[ foo bar ], 'Content-Type' => 'text/plain' }, ['']]
+end
+
+get '/fail/:number' do
+  if @@fail_count >= params[:number].to_i
+    "ok"
+  else
+    @@fail_count += 1
+    error 500, "oh noes!"
+   end
+end
+
+get '/fail_forever' do
+  error 500, "oh noes!"
+end
+
+get '/redirect' do
+  redirect '/'
+end
+
+get '/bad_redirect' do
+  redirect '/bad_redirect'
+end
+
+get '/auth_basic/:username/:password' do
+  @auth ||=  Rack::Auth::Basic::Request.new(request.env)
+  # Check that we've got a basic auth, and that it's credentials match the ones
+  # provided in the request
+  if @auth.provided? && @auth.basic? && @auth.credentials == [ params[:username], params[:password] ]
+    # auth is valid - confirm it
+    true
+  else
+    # invalid auth - request the authentication
+    response['WWW-Authenticate'] = %(Basic realm="Testing HTTP Auth")
+    throw(:halt, [401, "Not authorized\n"])
+  end
+end
+
+get '/auth_ntlm' do
+  # we're just checking for the existence if NTLM auth header here. It's validation
+  # is too troublesome and really doesn't bother is much, it's up to libcurl to make
+  # it valid
+  response['WWW-Authenticate'] = 'NTLM'
+  is_ntlm_auth = /^NTLM/ =~ request.env['HTTP_AUTHORIZATION']
+  true if is_ntlm_auth
+  throw(:halt, [401, "Not authorized\n"]) if !is_ntlm_auth
+end
+
+get '/gzipped' do
+  req_env = request.env.to_json
+  z = Zlib::Deflate.new
+  gzipped_env = z.deflate(req_env, Zlib::FINISH)
+  z.close
+  response['Content-Encoding'] = 'gzip'
+  gzipped_env
+end
+
+get '/**' do
+  sleep params["delay"].to_i if params.has_key?("delay")
+  request.env.merge!(:body => request.body.read).to_json
+end
+
+head '/**' do
+  sleep params["delay"].to_i if params.has_key?("delay")
+end
+
+put '/**' do
+  request.env.merge!(:body => request.body.read).to_json
+end
+
+post '/**' do
+  request.env.merge!(:body => request.body.read).to_json
+end
+
+delete '/**' do
+  request.env.merge!(:body => request.body.read).to_json
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require "rubygems"
+require 'json'
+require "rspec"
+
+# gem install redgreen for colored test output
+begin require "redgreen" unless ENV['TM_CURRENT_LINE']; rescue LoadError; end
+
+path = File.expand_path(File.dirname(__FILE__) + "/../lib/")
+$LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
+
+require path + '/typhoeus'
+
+Dir['./spec/support/**/*.rb'].each { |f| require f }
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    TyphoeusLocalhostServer.start_servers!
+  end
+end

data/spec/support/typhoeus_localhost_server.rb

@@ -0,0 +1,58 @@
+require 'net/http'
+require 'uri'
+
+class TyphoeusLocalhostServer
+  class << self
+    attr_accessor :pid
+
+    def start_servers!
+      if self.pid = fork
+        start_parent
+        wait_for_servers_to_start
+      else
+        start_child
+      end
+    end
+
+  private
+
+    def start_parent
+      # Cleanup.
+      at_exit do
+        Process.kill('QUIT', self.pid) if self.pid
+      end
+    end
+
+    def start_child
+      exec('rake', 'start_test_servers')
+    end
+
+    def wait_for_servers_to_start
+      puts "Waiting for servers to start..."
+      ports = [3000, 3001, 3002]
+    
+      Timeout::timeout(10) do
+        loop do
+          up = 0
+          ports.each do |port|
+            url = "http://localhost:#{port}/"
+            begin
+              response = Net::HTTP.get_response(URI.parse(url))
+              if response.is_a?(Net::HTTPSuccess)
+                up += 1
+              end
+            rescue SystemCallError => error
+            end
+          end
+
+          if up == ports.size
+            puts "Servers are up!"
+            break
+          end
+        end
+      end
+    rescue Timeout::Error => error
+      abort "Servers never started!"
+    end
+  end
+end

data/spec/typhoeus/easy_spec.rb

@@ -0,0 +1,391 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+if defined?(Encoding)
+  Encoding.default_internal = 'utf-8'
+  Encoding.default_external = 'utf-8'
+end
+
+describe Typhoeus::Easy do
+  describe "ssl_version" do
+    before(:each) do
+      @easy = Typhoeus::Easy.new
+      @easy.url = "http://localhost:3000"
+      @easy.method = :get
+    end
+
+    it "should allow to set the SSL version to be used" do
+      Typhoeus::Easy::SSL_VERSIONS.each do |k, v|
+        @easy.ssl_version = k
+        @easy.perform
+        @easy.response_code.should == 200
+        @easy.ssl_version.should == k
+      end
+    end
+
+    it "complains when an incorrect SSL version is used" do
+      expect { @easy.ssl_version = 'bogus' }.to raise_error
+    end
+
+    it "uses the default SSL version if nothing is supplied" do
+      @easy.ssl_version.should == :default
+    end
+  end
+
+  describe "#supports_zlib" do
+    before(:each) do
+      @easy = Typhoeus::Easy.new
+    end
+
+    it "should return true if the version string has zlib" do
+      @easy.stub!(:curl_version).and_return("libcurl/7.20.0 OpenSSL/0.9.8l zlib/1.2.3 libidn/1.16")
+      @easy.supports_zlib?.should be_true
+    end
+
+    it "should return false if the version string doesn't have zlib" do
+      @easy.stub!(:curl_version).and_return("libcurl/7.20.0 OpenSSL/0.9.8l libidn/1.16")
+      @easy.supports_zlib?.should be_false
+    end
+  end
+
+  describe "curl errors" do
+    it "should provide the CURLE_OPERATION_TIMEDOUT return code when a request times out" do
+      e = Typhoeus::Easy.new
+      e.url = "http://localhost:3001/?delay=1"
+      e.method = :get
+      e.timeout = 100
+      e.perform
+      e.curl_return_code.should == 28
+      e.curl_error_message.should == "Timeout was reached"
+      e.response_code.should == 0
+    end
+
+    it "should provide the CURLE_COULDNT_CONNECT return code when trying to connect to a non existent port" do
+      e = Typhoeus::Easy.new
+      e.url = "http://localhost:3999"
+      e.method = :get
+      e.connect_timeout = 100
+      e.perform
+      e.curl_return_code.should == 7
+      e.curl_error_message.should == "Couldn't connect to server"
+      e.response_code.should == 0
+    end
+
+    it "should not return an error message on a successful easy operation" do
+      easy = Typhoeus::Easy.new
+      easy.url    = "http://localhost:3002"
+      easy.method = :get
+      easy.curl_error_message.should == nil
+      easy.perform
+      easy.response_code.should == 200
+      easy.curl_return_code.should == 0
+      easy.curl_error_message.should == "No error"
+    end
+
+  end
+
+  describe "options" do
+    it "should not follow redirects if not instructed to" do
+      e = Typhoeus::Easy.new
+      e.url = "http://localhost:3001/redirect"
+      e.method = :get
+      e.perform
+      e.response_code.should == 302
+    end
+
+    it "should allow for following redirects" do
+      e = Typhoeus::Easy.new
+      e.url = "http://localhost:3001/redirect"
+      e.method = :get
+      e.follow_location = true
+      e.perform
+      e.response_code.should == 200
+      JSON.parse(e.response_body)["REQUEST_METHOD"].should == "GET"
+    end
+
+    it "should allow you to set the user agent" do
+      e = Typhoeus::Easy.new
+      e.url    = "http://localhost:3002"
+      e.method = :get
+      e.headers['User-Agent'] = 'myapp'
+      e.perform
+      e.response_code.should == 200
+      JSON.parse(e.response_body)["HTTP_USER_AGENT"].should == "myapp"
+    end
+
+    it "should provide a timeout in milliseconds" do
+      e = Typhoeus::Easy.new
+      e.url = "http://localhost:3001/?delay=1"
+      e.method = :get
+      e.timeout = 10
+      e.perform
+      e.timed_out?.should == true
+    end
+
+    it "should allow the setting of the max redirects to follow" do
+      e = Typhoeus::Easy.new
+      e.url = "http://localhost:3001/redirect"
+      e.method = :get
+      e.follow_location = true
+      e.max_redirects = 5
+      e.perform
+      e.response_code.should == 200
+    end
+
+    it "should handle our bad redirect action, provided we've set max_redirects properly" do
+      e = Typhoeus::Easy.new
+      e.url = "http://localhost:3001/bad_redirect"
+      e.method = :get
+      e.follow_location = true
+      e.max_redirects = 5
+      e.perform
+      e.response_code.should == 302
+    end
+
+    it "should provide the primary IP address that was used to perform the HTTP request" do
+      e = Typhoeus::Easy.new
+      e.url    = "http://localhost:3002"
+      e.method = :get
+      e.perform
+      e.response_code.should == 200
+      e.primary_ip.should == "127.0.0.1"
+    end
+  end
+
+  describe "authentication" do
+    it "should allow to set username and password" do
+      e = Typhoeus::Easy.new
+      username, password = 'foo', 'bar'
+      e.auth = { :username => username, :password => password }
+      e.url = "http://localhost:3001/auth_basic/#{username}/#{password}"
+      e.method = :get
+      e.perform
+      e.response_code.should == 200
+    end
+
+    it "should allow to query auth methods support by the server" do
+      e = Typhoeus::Easy.new
+      e.url = "http://localhost:3001/auth_basic/foo/bar"
+      e.method = :get
+      e.perform
+      e.auth_methods.should == Typhoeus::Easy::AUTH_TYPES[:CURLAUTH_BASIC]
+    end
+
+    it "should allow to set authentication method" do
+      e = Typhoeus::Easy.new
+      e.auth = { :username => 'username', :password => 'password', :method => Typhoeus::Easy::AUTH_TYPES[:CURLAUTH_NTLM] }
+      e.url = "http://localhost:3001/auth_ntlm"
+      e.method = :get
+      e.perform
+      e.response_code.should == 200
+    end
+  end
+
+  describe "get" do
+    it "should perform a get" do
+      easy = Typhoeus::Easy.new
+      easy.url    = "http://localhost:3002"
+      easy.method = :get
+      easy.perform
+      easy.response_code.should == 200
+      JSON.parse(easy.response_body)["REQUEST_METHOD"].should == "GET"
+    end
+  end
+
+  describe "purge" do
+    it "should set custom request to purge" do
+      easy = Typhoeus::Easy.new
+      easy.should_receive(:set_option).with(Typhoeus::Easy::OPTION_VALUES[:CURLOPT_CUSTOMREQUEST], "PURGE").once
+      easy.method = :purge
+    end
+  end
+
+  describe "head" do
+    it "should perform a head" do
+      easy = Typhoeus::Easy.new
+      easy.url    = "http://localhost:3002"
+      easy.method = :head
+      easy.perform
+      easy.response_code.should == 200
+    end
+  end
+
+  describe "start_time" do
+    it "should be get/settable" do
+      time = Time.now
+      easy = Typhoeus::Easy.new
+      easy.start_time.should be_nil
+      easy.start_time = time
+      easy.start_time.should == time
+    end
+  end
+
+  describe "params=" do
+    it "should handle arrays of params" do
+      easy = Typhoeus::Easy.new
+      easy.url = "http://localhost:3002/index.html"
+      easy.method = :get
+      easy.request_body = "this is a body!"
+      easy.params = {
+        :foo => 'bar',
+        :username => ['dbalatero', 'dbalatero2']
+      }
+      easy.url.should =~ /\?.*foo=bar&username=dbalatero&username=dbalatero2/
+    end
+  end
+
+
+  describe "put" do
+    it "should perform a put" do
+      easy = Typhoeus::Easy.new
+      easy.url    = "http://localhost:3002"
+      easy.method = :put
+      easy.perform
+      easy.response_code.should == 200
+      JSON.parse(easy.response_body)["REQUEST_METHOD"].should == "PUT"
+    end
+
+    it "should send a request body" do
+      easy = Typhoeus::Easy.new
+      easy.url    = "http://localhost:3002"
+      easy.method = :put
+      easy.request_body = "this is a body!"
+      easy.perform
+      easy.response_code.should == 200
+      easy.response_body.should include("this is a body!")
+    end
+
+    it "should be able perform put with empty bodies on the same easy handle" do
+      easy = Typhoeus::Easy.new
+      easy.url    = "http://localhost:3002"
+      easy.method = :put
+      easy.perform
+      easy.response_code.should == 200
+      JSON.parse(easy.response_body)["REQUEST_METHOD"].should == "PUT"
+
+      easy.reset
+
+      easy.url    = "http://localhost:3002"
+      easy.method = :put
+      easy.perform
+      easy.response_code.should == 200
+      JSON.parse(easy.response_body)["REQUEST_METHOD"].should == "PUT"
+    end
+
+    it "should set content length correctly for a utf-8 string" do
+      body = "this is a body with utf-8 content: Motörhead!  WHÖÖ!"
+      easy = Typhoeus::Easy.new
+      easy.url    = "http://localhost:3002"
+      easy.method = :post
+      easy.should_receive(:set_option).with(Typhoeus::Easy::OPTION_VALUES[:CURLOPT_POSTFIELDSIZE], 55)
+      easy.should_receive(:set_option).with(Typhoeus::Easy::OPTION_VALUES[:CURLOPT_COPYPOSTFIELDS], body)
+      easy.request_body = body
+    end
+  end
+
+  describe "post" do
+    it "should perform a post" do
+      easy = Typhoeus::Easy.new
+      easy.url    = "http://localhost:3002"
+      easy.method = :post
+      easy.perform
+      easy.response_code.should == 200
+      JSON.parse(easy.response_body)["REQUEST_METHOD"].should == "POST"
+    end
+
+    it "should send a request body" do
+      easy = Typhoeus::Easy.new
+      easy.url    = "http://localhost:3002"
+      easy.method = :post
+      easy.request_body = "this is a body!"
+      easy.perform
+      easy.response_code.should == 200
+      easy.response_body.should include("this is a body!")
+    end
+
+    it "should handle params" do
+      easy = Typhoeus::Easy.new
+      easy.url    = "http://localhost:3002"
+      easy.method = :post
+      easy.params = {:foo => "bar"}
+      easy.perform
+      easy.response_code.should == 200
+      easy.response_body.should =~ /foo=bar/
+    end
+
+    it "should use Content-Type: application/x-www-form-urlencoded for normal posts" do
+      easy = Typhoeus::Easy.new
+      easy.url = "http://localhost:3002/normal_post"
+      easy.method = :post
+      easy.params = { :a => 'b', :c => 'd',
+                      :e => { :f => { :g => 'h' } } }
+      easy.perform
+
+      request = JSON.parse(easy.response_body)
+      request['CONTENT_TYPE'].should == 'application/x-www-form-urlencoded'
+      request['rack.request.form_vars'].should == 'a=b&c=d&e[f][g]=h'
+    end
+
+    it "should handle a file upload, as multipart" do
+      easy = Typhoeus::Easy.new
+      easy.url    = "http://localhost:3002/file"
+      easy.method = :post
+      easy.params = {:file => File.open(File.expand_path(File.dirname(__FILE__) + "/../fixtures/placeholder.txt"), "r")}
+      easy.perform
+      easy.response_code.should == 200
+      result = JSON.parse(easy.response_body)
+
+      { 'content-type' => 'text/plain',
+        'filename' => 'placeholder.txt',
+        'content' => 'This file is used to test uploading.'
+      }.each do |key, val|
+        result[key].should == val
+      end
+
+      result['request-content-type'].should =~ /multipart/
+    end
+  end
+
+  describe "delete" do
+    it "should perform a delete" do
+      easy = Typhoeus::Easy.new
+      easy.url    = "http://localhost:3002"
+      easy.method = :delete
+      easy.perform
+      easy.response_code.should == 200
+      JSON.parse(easy.response_body)["REQUEST_METHOD"].should == "DELETE"
+    end
+
+    it "should send a request body" do
+      easy = Typhoeus::Easy.new
+      easy.url    = "http://localhost:3002"
+      easy.method = :delete
+      easy.request_body = "this is a body!"
+      easy.perform
+      easy.response_code.should == 200
+      easy.response_body.should include("this is a body!")
+    end
+  end
+
+  describe "encoding/compression support" do
+
+    it "should send valid encoding headers and decode the response" do
+      easy = Typhoeus::Easy.new
+      easy.url = "http://localhost:3002/gzipped"
+      easy.method = :get
+      easy.perform
+      easy.response_code.should == 200
+      JSON.parse(easy.response_body)["HTTP_ACCEPT_ENCODING"].should == "deflate, gzip"
+    end
+
+    it "should send valid encoding headers and decode the response after reset" do
+      easy = Typhoeus::Easy.new
+      easy.reset
+      easy.url = "http://localhost:3002/gzipped"
+      easy.method = :get
+      easy.perform
+      easy.response_code.should == 200
+      JSON.parse(easy.response_body)["HTTP_ACCEPT_ENCODING"].should == "deflate, gzip"
+    end
+  end
+end