gravis-typhoeus 0.1.29

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/multi_spec.rb

@@ -0,0 +1,74 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Typhoeus::Easy do
+  it "should save easy handles that get added" do
+    multi = Typhoeus::Multi.new
+    easy = Typhoeus::Easy.new
+    easy.url = "http://localhost:3002"
+    easy.method = :get
+
+    multi.add(easy)
+    multi.easy_handles.should == [easy]
+    multi.perform
+    multi.easy_handles.should == []
+  end
+  
+  it "should be reusable" do
+    easy = Typhoeus::Easy.new
+    easy.url = "http://localhost:3002"
+    easy.method = :get
+    
+    multi = Typhoeus::Multi.new
+    multi.add(easy)
+    multi.perform
+    easy.response_code.should == 200
+    JSON.parse(easy.response_body)["REQUEST_METHOD"].should == "GET"
+    
+    e2 = Typhoeus::Easy.new
+    e2.url = "http://localhost:3002"
+    e2.method = :post
+    multi.add(e2)
+    multi.perform
+    
+    e2.response_code.should == 200
+    JSON.parse(e2.response_body)["REQUEST_METHOD"].should == "POST"
+  end
+  
+  it "should perform easy handles added after the first one runs" do
+    easy = Typhoeus::Easy.new
+    easy.url = "http://localhost:3002"
+    easy.method = :get
+    multi = Typhoeus::Multi.new
+    multi.add(easy)
+
+    e2 = Typhoeus::Easy.new
+    e2.url = "http://localhost:3002"
+    e2.method = :post
+    easy.on_success do |e|
+      multi.add(e2)
+    end
+    
+    multi.perform
+    easy.response_code.should == 200
+    JSON.parse(easy.response_body)["REQUEST_METHOD"].should == "GET"
+    e2.response_code.should == 200
+    JSON.parse(e2.response_body)["REQUEST_METHOD"].should == "POST"
+  end
+  
+  # it "should do multiple gets" do
+    # multi = Typhoeus::Multi.new
+    # 
+    # handles = []
+    # 5.times do |i|
+    #   easy = Typhoeus::Easy.new
+    #   easy.url = "http://localhost:3002"
+    #   easy.method = :get
+    #   easy.on_success {|e| puts "get #{i} succeeded"}
+    #   easy.on_failure {|e| puts "get #{i} failed with #{e.response_code}"}
+    #   handles << easy
+    #   multi.add(easy)
+    # end
+    # 
+    # multi.perform
+  # end
+end

data/spec/typhoeus/remote_method_spec.rb

@@ -0,0 +1,141 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Typhoeus::RemoteMethod do
+  it "should take options" do
+    Typhoeus::RemoteMethod.new(:body => "foo")
+  end
+  
+  describe "http_method" do
+    it "should return the http method" do
+      m = Typhoeus::RemoteMethod.new(:method => :put)
+      m.http_method.should == :put
+    end
+    
+    it "should default to :get" do
+      m = Typhoeus::RemoteMethod.new
+      m.http_method.should == :get
+    end
+  end
+  
+  it "should return the options" do
+    m = Typhoeus::RemoteMethod.new(:body => "foo")
+    m.options.should == {:body => "foo"}
+  end
+  
+  it "should pull uri out of the options hash" do
+    m = Typhoeus::RemoteMethod.new(:base_uri => "http://pauldix.net")
+    m.base_uri.should == "http://pauldix.net"
+    m.options.should_not have_key(:base_uri)
+  end
+  
+  describe "on_success" do
+    it "should return the block" do
+      m = Typhoeus::RemoteMethod.new(:on_success => lambda {:foo})
+      m.on_success.call.should == :foo
+    end
+  end
+  
+  describe "on_failure" do
+    it "should return method name" do
+      m = Typhoeus::RemoteMethod.new(:on_failure => lambda {:bar})
+      m.on_failure.call.should == :bar
+    end
+  end
+  
+  describe "path" do
+    it "should pull path out of the options hash" do
+      m = Typhoeus::RemoteMethod.new(:path => "foo")
+      m.path.should == "foo"
+      m.options.should_not have_key(:path)
+    end
+    
+    it "should output argument names from the symbols in the path" do
+      m = Typhoeus::RemoteMethod.new(:path => "/posts/:post_id/comments/:comment_id")
+      m.argument_names.should == [:post_id, :comment_id]
+    end
+    
+    it "should output an empty string when there are no arguments in path" do
+      m = Typhoeus::RemoteMethod.new(:path => "/default.html")
+      m.argument_names.should == []
+    end
+    
+    it "should output and empty string when there is no path specified" do
+      m = Typhoeus::RemoteMethod.new
+      m.argument_names.should == []
+    end
+    
+    it "should interpolate a path with arguments" do
+      m = Typhoeus::RemoteMethod.new(:path => "/posts/:post_id/comments/:comment_id")
+      m.interpolate_path_with_arguments(:post_id => 1, :comment_id => "asdf").should == "/posts/1/comments/asdf"
+    end
+    
+    it "should provide the path when interpolated called and there is nothing to interpolate" do
+      m = Typhoeus::RemoteMethod.new(:path => "/posts/123")
+      m.interpolate_path_with_arguments(:foo => :bar).should == "/posts/123"
+    end
+  end
+  
+  describe "#merge_options" do
+    it "should keep the passed in options first" do
+      m = Typhoeus::RemoteMethod.new("User-Agent" => "whatev", :foo => :bar)
+      m.merge_options({"User-Agent" => "http-machine"}).should == {"User-Agent" => "http-machine", :foo => :bar}
+    end
+    
+    it "should combine the params" do
+      m = Typhoeus::RemoteMethod.new(:foo => :bar, :params => {:id => :asdf})
+      m.merge_options({:params => {:desc => :jkl}}).should == {:foo => :bar, :params => {:id => :asdf, :desc => :jkl}}
+    end
+  end
+  
+  describe "memoize_reponses" do
+    before(:each) do
+      @m = Typhoeus::RemoteMethod.new(:memoize_responses => true)
+      @args    = ["foo", "bar"]
+      @options = {:asdf => {:jkl => :bar}}
+    end
+    
+    it "should store if responses should be memoized" do
+      @m.memoize_responses?.should be_true
+      @m.options.should == {}
+    end
+    
+    it "should tell when a method is already called" do
+      @m.already_called?(@args, @options).should be_false
+      @m.calling(@args, @options)
+      @m.already_called?(@args, @options).should be_true
+      @m.already_called?([], {}).should be_false
+    end
+    
+    it "should call response blocks and clear the methods that have been called" do
+      response_block_called = mock('response_block')
+      response_block_called.should_receive(:call).exactly(1).times
+      
+      @m.add_response_block(lambda {|res| res.should == :foo; response_block_called.call}, @args, @options)
+      @m.calling(@args, @options)
+      @m.call_response_blocks(:foo, @args, @options)
+      @m.already_called?(@args, @options).should be_false
+      @m.call_response_blocks(:asdf, @args, @options) #just to make sure it doesn't actually call that block again
+    end
+  end
+  
+  describe "cache_reponses" do
+    before(:each) do
+      @m = Typhoeus::RemoteMethod.new(:cache_responses => true)
+      @args    = ["foo", "bar"]
+      @options = {:asdf => {:jkl => :bar}}
+    end
+    
+    it "should store if responses should be cached" do
+      @m.cache_responses?.should be_true
+      @m.options.should == {}
+    end
+    
+    it "should force memoization if caching is enabled" do
+      @m.memoize_responses?.should be_true
+    end
+    
+    it "should store cache ttl" do
+      Typhoeus::RemoteMethod.new(:cache_responses => 30).cache_ttl.should == 30
+    end
+  end
+end

data/spec/typhoeus/remote_proxy_object_spec.rb

@@ -0,0 +1,65 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Typhoeus::RemoteProxyObject do
+  before(:each) do
+    @easy = Typhoeus::Easy.new
+    @easy.method = :get
+    @easy.url    = "http://localhost:3001"
+  end
+  
+  it "should take a caller and call the clear_memoized_proxy_objects" do
+    clear_proxy = lambda {}
+    clear_proxy.should_receive(:call)
+    response = Typhoeus::RemoteProxyObject.new(clear_proxy, @easy)
+    response.code.should == 200
+  end
+
+  it "should take an easy object and return the body when requested" do
+    response = Typhoeus::RemoteProxyObject.new(lambda {}, @easy)
+    @easy.response_code.should == 0
+    response.code.should == 200
+  end
+  
+  it "should perform requests only on the first access" do
+    response = Typhoeus::RemoteProxyObject.new(lambda {}, @easy)
+    response.code.should == 200
+    Typhoeus.should_receive(:perform_easy_requests).exactly(0).times
+    response.code.should == 200
+  end
+
+  it "should set the requested_url and requested_http_method on the response" do
+    response = Typhoeus::RemoteProxyObject.new(lambda {}, @easy)
+    response.requested_url.should == "http://localhost:3001"
+    response.requested_http_method.should == :get
+  end
+  
+  it "should call the on_success method with an easy object and proxy to the result of on_success" do
+    klass = Class.new do
+      def initialize(r)
+        @response = r
+      end
+      
+      def blah
+        @response.code
+      end
+    end
+    
+    k = Typhoeus::RemoteProxyObject.new(lambda {}, @easy, :on_success => lambda {|e| klass.new(e)})
+    k.blah.should == 200
+  end
+  
+  it "should call the on_failure method with an easy object and proxy to the result of on_failure" do
+    klass = Class.new do
+      def initialize(r)
+        @response = r
+      end
+      
+      def blah
+        @response.code
+      end
+    end
+    @easy.url = "http://localhost:3005" #bad port
+    k = Typhoeus::RemoteProxyObject.new(lambda {}, @easy, :on_failure => lambda {|e| klass.new(e)})
+    k.blah.should == 0
+  end
+end