typhoeus 0.1.24 → 0.1.31

data/spec/typhoeus/hydra_spec.rb

@@ -0,0 +1,311 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+# some of these tests assume that you have some local services running.
+# ruby spec/servers/app.rb -p 3000
+# ruby spec/servers/app.rb -p 3001
+# ruby spec/servers/app.rb -p 3002
+describe Typhoeus::Hydra do
+  before(:all) do
+    cache_class = Class.new do
+      def initialize
+        @cache = {}
+      end
+      def get(key)
+        @cache[key]
+      end
+      def set(key, object, timeout = 0)
+        @cache[key] = object
+      end
+    end
+    @cache = cache_class.new
+  end
+
+  it "has a singleton" do
+    Typhoeus::Hydra.hydra.should be_a Typhoeus::Hydra
+  end
+
+  it "has a setter for the singleton" do
+    Typhoeus::Hydra.hydra = :foo
+    Typhoeus::Hydra.hydra.should == :foo
+    Typhoeus::Hydra.hydra = Typhoeus::Hydra.new
+  end
+
+  context "#stub" do
+    before do
+      @hydra = Typhoeus::Hydra.new
+      @on_complete_handler_called = nil
+      @request  = Typhoeus::Request.new("http://localhost:3000/foo")
+      @request.on_complete do |response|
+        @on_complete_handler_called = true
+        response.code.should == 404
+        response.headers.should == "whatever"
+      end
+      @response = Typhoeus::Response.new(:code => 404, :headers => "whatever", :body => "not found", :time => 0.1)
+    end
+
+    it "stubs requests to a specific URI" do
+      @hydra.stub(:get, "http://localhost:3000/foo").and_return(@response)
+      @hydra.queue(@request)
+      @hydra.run
+      @on_complete_handler_called.should be_true
+      @response.request.should == @request
+    end
+
+    it "stubs requests to URIs matching a pattern" do
+      @hydra.stub(:get, /foo/).and_return(@response)
+      @hydra.queue(@request)
+      @hydra.run
+      @on_complete_handler_called.should be_true
+      @response.request.should == @request
+    end
+
+    it "can clear stubs" do
+      @hydra.clear_stubs
+    end
+    
+    it "clears out previously queued requests once they are called" do
+      @hydra.stub(:get, "asdf").and_return(@response)
+
+      call_count = 0
+      request = Typhoeus::Request.new("asdf")
+      request.on_complete do |response|
+        call_count += 1
+      end
+      @hydra.queue(request)
+      @hydra.run
+      call_count.should == 1
+      @hydra.run
+      call_count.should == 1
+    end
+    
+    it "calls stubs for requests that are queued up in the on_complete of a first stub" do
+      @hydra.stub(:get, "asdf").and_return(@response)
+      @hydra.stub(:get, "bar").and_return(@response)
+      
+      second_handler_called = false
+      request = Typhoeus::Request.new("asdf")
+      request.on_complete do |response|
+        r = Typhoeus::Request.new("bar")
+        r.on_complete do |res|
+          second_handler_called = true
+        end
+        @hydra.queue(r)
+      end
+      @hydra.queue(request)
+      @hydra.run
+      
+      second_handler_called.should be_true
+    end
+
+    it "matches a stub only when the HTTP method also matches"
+  end
+
+  it "queues a request" do
+    hydra = Typhoeus::Hydra.new
+    hydra.queue Typhoeus::Request.new("http://localhost:3000")
+  end
+
+  it "runs a batch of requests" do
+    hydra  = Typhoeus::Hydra.new
+    first  = Typhoeus::Request.new("http://localhost:3000/first")
+    second = Typhoeus::Request.new("http://localhost:3001/second")
+    hydra.queue first
+    hydra.queue second
+    hydra.run
+    first.response.body.should include("first")
+    second.response.body.should include("second")
+  end
+
+  it "has a cache_setter proc" do
+    hydra = Typhoeus::Hydra.new
+    hydra.cache_setter do |request|
+      # @cache.set(request.cache_key, request.response, request.cache_timeout)
+    end
+  end
+
+  it "has a cache_getter" do
+    hydra = Typhoeus::Hydra.new
+    hydra.cache_getter do |request|
+      # @cache.get(request.cache_key) rescue nil
+    end
+  end
+
+  it "memoizes GET reqeusts" do
+    hydra  = Typhoeus::Hydra.new
+    first  = Typhoeus::Request.new("http://localhost:3000/foo", :params => {:delay => 1})
+    second = Typhoeus::Request.new("http://localhost:3000/foo", :params => {:delay => 1})
+    hydra.queue first
+    hydra.queue second
+    start_time = Time.now
+    hydra.run
+    first.response.body.should include("foo")
+    first.handled_response.body.should include("foo")
+    first.response.should == second.response
+    first.handled_response.should == second.handled_response
+    (Time.now - start_time).should < 1.2 # if it had run twice it would be ~ 2 seconds
+  end
+
+  it "can turn off memoization for GET requests" do
+    hydra  = Typhoeus::Hydra.new
+    hydra.disable_memoization
+    first  = Typhoeus::Request.new("http://localhost:3000/foo")
+    second = Typhoeus::Request.new("http://localhost:3000/foo")
+    hydra.queue first
+    hydra.queue second
+    hydra.run
+    first.response.body.should include("foo")
+    first.response.object_id.should_not == second.response.object_id
+  end
+
+  it "pulls GETs from cache" do
+    hydra  = Typhoeus::Hydra.new
+    start_time = Time.now
+    hydra.cache_getter do |request|
+      @cache.get(request.cache_key) rescue nil
+    end
+    hydra.cache_setter do |request|
+      @cache.set(request.cache_key, request.response, request.cache_timeout)
+    end
+
+    first  = Typhoeus::Request.new("http://localhost:3000/foo", :params => {:delay => 1})
+    @cache.set(first.cache_key, :foo, 60)
+    hydra.queue first
+    hydra.run
+    (Time.now - start_time).should < 0.1
+    first.response.should == :foo
+  end
+
+  it "sets GET responses to cache when the request has a cache_timeout value" do
+    hydra  = Typhoeus::Hydra.new
+    hydra.cache_getter do |request|
+      @cache.get(request.cache_key) rescue nil
+    end
+    hydra.cache_setter do |request|
+      @cache.set(request.cache_key, request.response, request.cache_timeout)
+    end
+
+    first  = Typhoeus::Request.new("http://localhost:3000/first", :cache_timeout => 0)
+    second = Typhoeus::Request.new("http://localhost:3000/second")
+    hydra.queue first
+    hydra.queue second
+    hydra.run
+    first.response.body.should include("first")
+    @cache.get(first.cache_key).should == first.response
+    @cache.get(second.cache_key).should be_nil
+  end
+
+  it "has a global on_complete" do
+    foo = nil
+    hydra  = Typhoeus::Hydra.new
+    hydra.on_complete do |response|
+      foo = :called
+    end
+
+    first  = Typhoeus::Request.new("http://localhost:3000/first")
+    hydra.queue first
+    hydra.run
+    first.response.body.should include("first")
+    foo.should == :called
+  end
+
+  it "has a global on_complete setter" do
+    foo = nil
+    hydra  = Typhoeus::Hydra.new
+    proc = Proc.new {|response| foo = :called}
+    hydra.on_complete = proc
+
+    first  = Typhoeus::Request.new("http://localhost:3000/first")
+    hydra.queue first
+    hydra.run
+    first.response.body.should include("first")
+    foo.should == :called
+  end
+
+  it "should reuse connections from the pool for a host"
+
+  it "should queue up requests while others are running" do
+    hydra   = Typhoeus::Hydra.new
+
+    start_time = Time.now
+    @responses = []
+
+    request = Typhoeus::Request.new("http://localhost:3000/first", :params => {:delay => 1})
+    request.on_complete do |response|
+      @responses << response
+      response.body.should include("first")
+    end
+
+    request.after_complete do |object|
+      second_request = Typhoeus::Request.new("http://localhost:3001/second", :params => {:delay => 2})
+      second_request.on_complete do |response|
+        @responses << response
+        response.body.should include("second")
+      end
+      hydra.queue second_request
+    end
+    hydra.queue request
+
+    third_request = Typhoeus::Request.new("http://localhost:3002/third", :params => {:delay => 3})
+    third_request.on_complete do |response|
+      @responses << response
+      response.body.should include("third")
+    end
+    hydra.queue third_request
+
+    hydra.run
+    @responses.size.should == 3
+    (Time.now - start_time).should < 3.3
+  end
+
+  it "should fire and forget" do
+    # this test is totally hacky. I have no clue how to make it verify. I just look at the test servers
+    # to verify that stuff is running
+    hydra  = Typhoeus::Hydra.new
+    first  = Typhoeus::Request.new("http://localhost:3000/first?delay=1")
+    second = Typhoeus::Request.new("http://localhost:3001/second?delay=2")
+    hydra.queue first
+    hydra.queue second
+    hydra.fire_and_forget
+    third = Typhoeus::Request.new("http://localhost:3002/third?delay=3")
+    hydra.queue third
+    hydra.fire_and_forget
+    sleep 3 # have to do this or future tests may break.
+  end
+
+  it "should take the maximum number of concurrent requests as an argument" do
+    hydra = Typhoeus::Hydra.new(:max_concurrency => 2)
+    first  = Typhoeus::Request.new("http://localhost:3000/first?delay=1")
+    second = Typhoeus::Request.new("http://localhost:3001/second?delay=1")
+    third  = Typhoeus::Request.new("http://localhost:3002/third?delay=1")
+    hydra.queue first
+    hydra.queue second
+    hydra.queue third
+
+    start_time = Time.now
+    hydra.run
+    finish_time = Time.now
+
+    first.response.code.should == 200
+    second.response.code.should == 200
+    third.response.code.should == 200
+    (finish_time - start_time).should > 2.0
+  end
+
+  it "should respect the follow_location option when set on a request" do
+    hydra = Typhoeus::Hydra.new
+    request = Typhoeus::Request.new("http://localhost:3000/redirect", :follow_location => true)
+    hydra.queue request
+    hydra.run
+
+    request.response.code.should == 200
+  end
+
+  it "should pass through the max_redirects option when set on a request" do
+    hydra = Typhoeus::Hydra.new
+    request = Typhoeus::Request.new("http://localhost:3000/bad_redirect", :max_redirects => 5)
+    hydra.queue request
+    hydra.run
+
+    request.response.code.should == 302
+  end
+end

data/spec/typhoeus/remote_spec.rb

@@ -4,7 +4,7 @@ describe Typhoeus do
   it "should be deprecated" do
     fail "This entire interface is deprecated!"
   end
-  
+
   # before(:each) do
   #   @klass = Class.new do
   #     include Typhoeus

data/spec/typhoeus/request_spec.rb

@@ -0,0 +1,195 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Typhoeus::Request do
+  describe "#params_string" do
+    it "should dump a sorted string" do
+      request = Typhoeus::Request.new(
+        "http://google.com",
+        :params => {
+          'b' => 'fdsa',
+          'a' => 'jlk',
+          'c' => '789'
+        }
+      )
+
+      request.params_string.should == "a=jlk&b=fdsa&c=789"
+    end
+
+    it "should accept symboled keys" do
+      request = Typhoeus::Request.new('http://google.com',
+                                      :params => {
+                                        :b => 'fdsa',
+                                        :a => 'jlk',
+                                        :c => '789'
+                                      })
+      request.params_string.should == "a=jlk&b=fdsa&c=789"
+    end
+  end
+
+  describe "quick request methods" do
+    it "can run a GET synchronously" do
+      response = Typhoeus::Request.get("http://localhost:3000", :params => {:q => "hi"}, :headers => {:foo => "bar"})
+      response.code.should == 200
+      JSON.parse(response.body)["REQUEST_METHOD"].should == "GET"
+    end
+
+    it "can run a POST synchronously" do
+      response = Typhoeus::Request.post("http://localhost:3000", :params => {:q => "hi"}, :headers => {:foo => "bar"})
+      response.code.should == 200
+      json = JSON.parse(response.body)
+      json["REQUEST_METHOD"].should == "POST"
+      json["rack.request.query_hash"]["q"].should == "hi"
+    end
+
+    it "can run a PUT synchronously" do
+      response = Typhoeus::Request.put("http://localhost:3000", :params => {:q => "hi"}, :headers => {:foo => "bar"})
+      response.code.should == 200
+      JSON.parse(response.body)["REQUEST_METHOD"].should == "PUT"
+    end
+
+    it "can run a DELETE synchronously" do
+      response = Typhoeus::Request.delete("http://localhost:3000", :params => {:q => "hi"}, :headers => {:foo => "bar"})
+      response.code.should == 200
+      JSON.parse(response.body)["REQUEST_METHOD"].should == "DELETE"
+    end
+  end
+
+  it "takes url as the first argument" do
+    Typhoeus::Request.new("http://localhost:3000").url.should == "http://localhost:3000"
+  end
+
+  it "should parse the host from the url" do
+    Typhoeus::Request.new("http://localhost:3000/whatever?hi=foo").host.should == "http://localhost:3000"
+    Typhoeus::Request.new("http://localhost:3000?hi=foo").host.should == "http://localhost:3000"
+    Typhoeus::Request.new("http://localhost:3000").host.should == "http://localhost:3000"
+  end
+
+  it "takes method as an option" do
+    Typhoeus::Request.new("http://localhost:3000", :method => :get).method.should == :get
+  end
+
+  it "takes headers as an option" do
+    headers = {:foo => :bar}
+    request = Typhoeus::Request.new("http://localhost:3000", :headers => headers)
+    request.headers.should == headers
+  end
+
+  it "takes params as an option and adds them to the url" do
+    Typhoeus::Request.new("http://localhost:3000", :params => {:foo => "bar"}).url.should == "http://localhost:3000?foo=bar"
+  end
+
+  it "takes request body as an option" do
+    Typhoeus::Request.new("http://localhost:3000", :body => "whatever").body.should == "whatever"
+  end
+
+  it "takes timeout as an option" do
+    Typhoeus::Request.new("http://localhost:3000", :timeout => 10).timeout.should == 10
+  end
+
+  it "takes cache_timeout as an option" do
+    Typhoeus::Request.new("http://localhost:3000", :cache_timeout => 60).cache_timeout.should == 60
+  end
+
+  it "takes follow_location as an option" do
+    Typhoeus::Request.new("http://localhost:3000", :follow_location => true).follow_location.should == true
+  end
+
+  it "takes max_redirects as an option" do
+    Typhoeus::Request.new("http://localhost:3000", :max_redirects => 10).max_redirects.should == 10
+  end
+
+  it "has the associated response object" do
+    request = Typhoeus::Request.new("http://localhost:3000")
+    request.response = :foo
+    request.response.should == :foo
+  end
+
+  it "has an on_complete handler that is called when the request is completed" do
+    request = Typhoeus::Request.new("http://localhost:3000")
+    foo = nil
+    request.on_complete do |response|
+      foo = response
+    end
+    request.response = :bar
+    request.call_handlers
+    foo.should == :bar
+  end
+
+  it "has an on_complete setter" do
+    foo = nil
+    proc = Proc.new {|response| foo = response}
+    request = Typhoeus::Request.new("http://localhost:3000")
+    request.on_complete = proc
+    request.response = :bar
+    request.call_handlers
+    foo.should == :bar
+  end
+
+  it "stores the handled response that is the return value from the on_complete block" do
+    request = Typhoeus::Request.new("http://localhost:3000")
+    request.on_complete do |response|
+      "handled"
+    end
+    request.response = :bar
+    request.call_handlers
+    request.handled_response.should == "handled"
+  end
+
+  it "has an after_complete handler that recieves what on_complete returns" do
+    request = Typhoeus::Request.new("http://localhost:3000")
+    request.on_complete do |response|
+      "handled"
+    end
+    good = nil
+    request.after_complete do |object|
+      good = object == "handled"
+    end
+    request.call_handlers
+    good.should be_true
+  end
+
+  it "has an after_complete setter" do
+    request = Typhoeus::Request.new("http://localhost:3000")
+    request.on_complete do |response|
+      "handled"
+    end
+    good = nil
+    proc = Proc.new {|object| good = object == "handled"}
+    request.after_complete = proc
+
+    request.call_handlers
+    good.should be_true
+  end
+  
+  describe "authentication" do
+    
+    it "should allow to set username and password" do
+      auth = { :username => 'foo', :password => 'bar' }
+      e = Typhoeus::Request.get(
+        "http://localhost:3001/auth_basic/#{auth[:username]}/#{auth[:password]}",
+        auth
+      )
+      e.code.should == 200
+    end
+
+    it "should allow to set authentication method" do
+      auth = {
+        :username => 'username',
+        :password => 'password',
+        :auth_method => :ntlm
+      }
+      e = Typhoeus::Request.get(
+        "http://localhost:3001/auth_ntlm",
+        auth
+      )
+      e.code.should == 200
+    end
+
+  end
+
+  describe "retry" do
+    it "should take a retry option"
+    it "should count the number of times a request has failed"
+  end
+
+end

data/typhoeus.gemspec

@@ -0,0 +1,113 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{typhoeus}
+  s.version = "0.1.31"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Paul Dix"]
+  s.date = %q{2010-07-16}
+  s.description = %q{Like a modern code version of the mythical beast with 100 serpent heads, Typhoeus runs HTTP requests in parallel while cleanly encapsulating handling logic.}
+  s.email = %q{paul@pauldix.net}
+  s.extensions = ["ext/typhoeus/extconf.rb"]
+  s.extra_rdoc_files = [
+    "README.textile"
+  ]
+  s.files = [
+    ".gitignore",
+     "CHANGELOG.markdown",
+     "README.textile",
+     "Rakefile",
+     "VERSION",
+     "benchmarks/profile.rb",
+     "benchmarks/vs_nethttp.rb",
+     "examples/twitter.rb",
+     "ext/typhoeus/.gitignore",
+     "ext/typhoeus/Makefile",
+     "ext/typhoeus/extconf.rb",
+     "ext/typhoeus/native.c",
+     "ext/typhoeus/native.h",
+     "ext/typhoeus/typhoeus_easy.c",
+     "ext/typhoeus/typhoeus_easy.h",
+     "ext/typhoeus/typhoeus_multi.c",
+     "ext/typhoeus/typhoeus_multi.h",
+     "lib/typhoeus.rb",
+     "lib/typhoeus/.gitignore",
+     "lib/typhoeus/easy.rb",
+     "lib/typhoeus/filter.rb",
+     "lib/typhoeus/hydra.rb",
+     "lib/typhoeus/multi.rb",
+     "lib/typhoeus/remote.rb",
+     "lib/typhoeus/remote_method.rb",
+     "lib/typhoeus/remote_proxy_object.rb",
+     "lib/typhoeus/request.rb",
+     "lib/typhoeus/response.rb",
+     "lib/typhoeus/service.rb",
+     "profilers/valgrind.rb",
+     "spec/fixtures/result_set.xml",
+     "spec/servers/app.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb",
+     "spec/typhoeus/easy_spec.rb",
+     "spec/typhoeus/filter_spec.rb",
+     "spec/typhoeus/hydra_spec.rb",
+     "spec/typhoeus/multi_spec.rb",
+     "spec/typhoeus/remote_method_spec.rb",
+     "spec/typhoeus/remote_proxy_object_spec.rb",
+     "spec/typhoeus/remote_spec.rb",
+     "spec/typhoeus/request_spec.rb",
+     "spec/typhoeus/response_spec.rb",
+     "typhoeus.gemspec"
+  ]
+  s.homepage = %q{http://github.com/pauldix/typhoeus}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{A library for interacting with web services (and building SOAs) at blinding speed.}
+  s.test_files = [
+    "spec/servers/app.rb",
+     "spec/spec_helper.rb",
+     "spec/typhoeus/easy_spec.rb",
+     "spec/typhoeus/filter_spec.rb",
+     "spec/typhoeus/hydra_spec.rb",
+     "spec/typhoeus/multi_spec.rb",
+     "spec/typhoeus/remote_method_spec.rb",
+     "spec/typhoeus/remote_proxy_object_spec.rb",
+     "spec/typhoeus/remote_spec.rb",
+     "spec/typhoeus/request_spec.rb",
+     "spec/typhoeus/response_spec.rb",
+     "examples/twitter.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rack>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<diff-lcs>, [">= 0"])
+      s.add_development_dependency(%q<sinatra>, [">= 0"])
+      s.add_development_dependency(%q<json>, [">= 0"])
+    else
+      s.add_dependency(%q<rack>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<diff-lcs>, [">= 0"])
+      s.add_dependency(%q<sinatra>, [">= 0"])
+      s.add_dependency(%q<json>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rack>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<diff-lcs>, [">= 0"])
+    s.add_dependency(%q<sinatra>, [">= 0"])
+    s.add_dependency(%q<json>, [">= 0"])
+  end
+end
+