typhoeus 0.3.3 → 0.4.0

data/ext/typhoeus/typhoeus_multi.h

@@ -1,16 +0,0 @@
-#ifndef TYPHOEUS_MULTI
-#define TYPHOEUS_MULTI
-
-#include <native.h>
-#include <typhoeus_easy.h>
-
-VALUE cTyphoeusMulti;
-typedef struct {
-  int running;
-  int active;
-  CURLM *multi;
-} CurlMulti;
-
-void init_typhoeus_multi();
-
-#endif

data/lib/typhoeus/.gitignore

@@ -1 +0,0 @@
-native.bundle

data/lib/typhoeus/service.rb

@@ -1,20 +0,0 @@
-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/spec/fixtures/placeholder.txt

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

data/spec/fixtures/result_set.xml

@@ -1,60 +0,0 @@
-<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

@@ -1,97 +0,0 @@
-#!/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

@@ -1,19 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,391 +0,0 @@
-# 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