xenda-typhoeus 0.2.4

data/spec/typhoeus/hydra_spec.rb

@@ -0,0 +1,574 @@
+require File.expand_path(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
+
+  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 "runs queued requests in order of queuing" do
+    hydra  = Typhoeus::Hydra.new :max_concurrency => 1
+    first  = Typhoeus::Request.new("http://localhost:3000/first")
+    second = Typhoeus::Request.new("http://localhost:3001/second")
+    third = Typhoeus::Request.new("http://localhost:3001/third")
+    second.on_complete do |response|
+      first.response.should_not == nil
+      third.response.should == nil
+    end
+    third.on_complete do |response|
+      first.response.should_not == nil
+      second.response.should_not == nil
+    end
+
+    hydra.queue first
+    hydra.queue second
+    hydra.queue third
+    hydra.run
+    first.response.body.should include("first")
+    second.response.body.should include("second")
+    third.response.body.should include("third")
+  end
+
+  it "should store the curl return codes on the reponses" do
+    hydra  = Typhoeus::Hydra.new
+    first  = Typhoeus::Request.new("http://localhost:3001/?delay=1", :timeout => 100)
+    second = Typhoeus::Request.new("http://localhost:3999", :connect_timout => 100)
+    hydra.queue first
+    hydra.queue second
+    hydra.run
+    first.response.curl_return_code == 28
+    second.response.curl_return_code == 7
+  end
+
+  it "aborts a batch of requests" do
+    urls = [
+        'http://localhost:3000',
+        'http://localhost:3001',
+        'http://localhost:3002'
+    ]
+
+    # this will make testing easier
+    hydra     = Typhoeus::Hydra.new( :max_concurrency => 1 )
+    completed = 0
+
+    10.times {
+        |i|
+
+        req = Typhoeus::Request.new( urls[ i % urls.size], :params => { :cnt => i } )
+        req.on_complete {
+            |res|
+            completed += 1
+            hydra.abort if completed == 5
+        }
+
+        hydra.queue( req )
+    }
+
+    hydra.run
+
+    # technically this should be '== 6' but I don't trust it...
+    completed.should < 10
+  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 "continues queued requests after a queued cache hit" do
+    # Set max_concurrency to 1 so that the second and third requests will end
+    # up in the request queue.
+    hydra  = Typhoeus::Hydra.new :max_concurrency => 1
+    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", :params => {:delay => 1})
+    second = Typhoeus::Request.new("http://localhost:3000/second", :params => {:delay => 1})
+    third = Typhoeus::Request.new("http://localhost:3000/third", :params => {:delay => 1})
+    @cache.set(second.cache_key, "second", 60)
+    hydra.queue first
+    hydra.queue second
+    hydra.queue third
+    hydra.run
+
+    first.response.body.should include("first")
+    second.response.should == "second"
+    third.response.body.should include("third")
+  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
+
+describe Typhoeus::Hydra::Stubbing do
+  shared_examples_for "any stubbable target" do
+    before(:each) do
+      @on_complete_handler_called = nil
+      @request  = Typhoeus::Request.new("http://localhost:3000/foo",
+                                        :user_agent => 'test')
+      @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
+
+    after(:each) do
+      @stub_target.clear_stubs
+    end
+
+    it "should provide a stubs accessor" do
+      begin
+        @stub_target.stubs.should == []
+        @stub_target.stubs = [:foo]
+      ensure
+        @stub_target.clear_stubs
+      end
+    end
+
+    it "stubs requests to a specific URI" do
+      @stub_target.stub(:get, "http://localhost:3000/foo",
+                        :headers => { 'user-agent' => 'test'}).
+                        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
+      @stub_target.stub(:get, /foo/,
+                        :headers => { 'user-agent' => 'test' }).
+                        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
+      @stub_target.clear_stubs
+    end
+
+    it "clears out previously queued requests once they are called" do
+      @stub_target.stub(:get, "http://localhost:3000/asdf",
+                        :headers => { 'user-agent' => 'test' }).
+                        and_return(@response)
+
+      call_count = 0
+      request = Typhoeus::Request.new("http://localhost:3000/asdf", :user_agent => 'test')
+      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
+      @stub_target.stub(:get, "http://localhost:3000/asdf").and_return(@response)
+      @stub_target.stub(:get, "http://localhost:3000/bar").and_return(@response)
+
+      second_handler_called = false
+      request = Typhoeus::Request.new("http://localhost:3000/asdf")
+      request.on_complete do |response|
+        r = Typhoeus::Request.new("http://localhost:3000/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
+  end
+
+  describe "global (class-level) stubbing" do
+    before(:each) do
+      @hydra = Typhoeus::Hydra.new
+      @stub_target = Typhoeus::Hydra
+    end
+
+    it_should_behave_like "any stubbable target"
+  end
+
+  describe "instance stubbing" do
+    before(:each) do
+      @hydra = Typhoeus::Hydra.new
+      @stub_target = @hydra
+    end
+
+    it_should_behave_like "any stubbable target"
+  end
+end
+
+describe Typhoeus::Hydra::Callbacks do
+  before(:all) do
+    @klass = Typhoeus::Hydra
+  end
+
+  describe "#after_request_before_on_complete" do
+    it "should provide a global hook after a request" do
+      begin
+        http_method = nil
+        @klass.after_request_before_on_complete do |request|
+          http_method = request.method
+        end
+
+        hydra = @klass.new
+        request = Typhoeus::Request.new('http://localhost:3000',
+                                        :method => :get)
+        response = Typhoeus::Response.new(:code => 404,
+                                          :headers => "whatever",
+                                          :body => "not found",
+                                          :time => 0.1)
+        hydra.stub(:get, 'http://localhost:3000').
+          and_return(response)
+
+        hydra.queue(request)
+        hydra.run
+
+        http_method.should == :get
+      ensure
+        @klass.clear_global_hooks
+      end
+    end
+  end
+end
+
+describe Typhoeus::Hydra::ConnectOptions do
+  before(:all) do
+    @klass = Typhoeus::Hydra
+  end
+
+  let!(:old_net_connect) { @klass.allow_net_connect }
+  let!(:old_ignore_localhost) { @klass.ignore_localhost }
+  let(:hydra) { @klass.new }
+
+  after(:each) do
+    @klass.allow_net_connect = old_net_connect
+    @klass.ignore_localhost = old_ignore_localhost
+  end
+
+  def request_for(host)
+    Typhoeus::Request.new("http://#{host}:3000")
+  end
+
+  describe "#ignore_localhost" do
+    context "when set to true" do
+      before(:each) { @klass.ignore_localhost = true }
+
+      [true, false].each do |val|
+        it "allows localhost requests when allow_net_connect is #{val}" do
+          @klass.allow_net_connect = val
+          expect { hydra.queue(request_for('localhost')) }.to_not raise_error
+        end
+      end
+    end
+
+    context "when set to false" do
+      before(:each) { @klass.ignore_localhost = false }
+
+      it "allows localhost requests when allow_net_connect is true" do
+        @klass.allow_net_connect = true
+        expect { hydra.queue(request_for('localhost')) }.to_not raise_error
+      end
+
+      it "does not allow localhost requests when allow_net_connect is false" do
+        @klass.allow_net_connect = false
+        expect { hydra.queue(request_for('localhost')) }.to raise_error(Typhoeus::Hydra::NetConnectNotAllowedError)
+      end
+    end
+  end
+
+  describe "#ignore_hosts" do
+    context 'when allow_net_connect is set to false' do
+      before(:each) do
+        @klass.ignore_localhost = false
+        @klass.allow_net_connect = false
+      end
+
+      Typhoeus::Request::LOCALHOST_ALIASES.each do |disallowed_host|
+        ignore_hosts = Typhoeus::Request::LOCALHOST_ALIASES - [disallowed_host]
+
+        context "when set to #{ignore_hosts.join(' and ')}" do
+          before(:each) { @klass.ignore_hosts = ignore_hosts }
+
+          it "does not allow a request to #{disallowed_host}" do
+            expect { hydra.queue(request_for(disallowed_host)) }.to raise_error(Typhoeus::Hydra::NetConnectNotAllowedError)
+          end
+
+          ignore_hosts.each do |host|
+            it "allows a request to #{host}" do
+              expect { hydra.queue(request_for(host)) }.to_not raise_error
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe "#allow_net_connect" do
+    it "should be settable" do
+      @klass.allow_net_connect = true
+      @klass.allow_net_connect.should be_true
+    end
+
+    it "should default to true" do
+      @klass.allow_net_connect.should be_true
+    end
+
+    it "should raise an error if we queue a request while its false" do
+      @klass.allow_net_connect = false
+      @klass.ignore_localhost = false
+
+      expect {
+        hydra.queue(request_for('example.com'))
+      }.to raise_error(Typhoeus::Hydra::NetConnectNotAllowedError)
+    end
+  end
+
+  describe "#allow_net_connect?" do
+    it "should return true by default" do
+      @klass.allow_net_connect?.should be_true
+    end
+  end
+end