elasticsearch-transport-sinneduy 1.0.12

data/test/unit/connection_collection_test.rb

@@ -0,0 +1,88 @@
+require 'test_helper'
+
+class Elasticsearch::Transport::Transport::Connections::CollectionTest < Test::Unit::TestCase
+  include Elasticsearch::Transport::Transport::Connections
+
+  context "Connection collection" do
+
+    should "have empty array as default connections array" do
+      assert_equal [], Collection.new.connections
+    end
+
+    should "have default selector class" do
+      assert_not_nil Collection.new.selector
+    end
+
+    should "initialize a custom selector class" do
+      c = Collection.new :selector_class => Selector::Random
+      assert_instance_of Selector::Random, c.selector
+    end
+
+    should "take a custom selector instance" do
+      c = Collection.new :selector => Selector::Random.new
+      assert_instance_of Selector::Random, c.selector
+    end
+
+    should "get connection from selector" do
+      c = Collection.new
+      c.selector.expects(:select).returns('OK')
+      assert_equal 'OK', c.get_connection
+    end
+
+    should "return an array of hosts" do
+      c = Collection.new :connections => [ Connection.new(:host => 'foo'), Connection.new(:host => 'bar') ]
+      assert_equal ['foo', 'bar'], c.hosts
+    end
+
+    should "be enumerable" do
+      c = Collection.new :connections => [ Connection.new(:host => 'foo'), Connection.new(:host => 'bar') ]
+
+      assert_equal ['FOO', 'BAR'], c.map { |i| i.host.upcase }
+      assert_equal 'foo',          c[0].host
+      assert_equal 'bar',          c[1].host
+      assert_equal  2,             c.size
+    end
+
+    context "with the dead pool" do
+      setup do
+        @collection = Collection.new :connections => [ Connection.new(:host => 'foo'), Connection.new(:host => 'bar') ]
+        @collection[1].dead!
+      end
+
+      should "not iterate over dead connections" do
+        assert_equal 1, @collection.size
+        assert_equal ['FOO'], @collection.map { |c| c.host.upcase }
+        assert_equal @collection.connections, @collection.alive
+      end
+
+      should "have dead connections collection" do
+        assert_equal 1, @collection.dead.size
+        assert_equal ['BAR'], @collection.dead.map { |c| c.host.upcase }
+      end
+
+      should "not return dead connections, when alive connections exist" do
+        assert_equal 1, @collection.size
+        @collection.all.size.times { refute @collection.get_connection.dead? }
+      end
+
+      should "resurrect dead connection with least failures when no alive is available" do
+        c1 = Connection.new(:host => 'foo').dead!.dead!
+        c2 = Connection.new(:host => 'bar').dead!
+
+        @collection = Collection.new :connections => [ c1, c2 ]
+
+        assert_equal 0, @collection.size
+        assert_not_nil @collection.get_connection
+        assert_equal 1, @collection.size
+        assert_equal c2, @collection.first
+      end
+
+      should "return all connections" do
+        assert_equal 2, @collection.all.size
+      end
+
+    end
+
+  end
+
+end

data/test/unit/connection_selector_test.rb

@@ -0,0 +1,64 @@
+require 'test_helper'
+
+class Elasticsearch::Transport::Transport::Connections::SelectorTest < Test::Unit::TestCase
+  include Elasticsearch::Transport::Transport::Connections::Selector
+
+  class DummyStrategySelector
+    include Elasticsearch::Transport::Transport::Connections::Selector::Base
+  end
+
+  class BackupStrategySelector
+    include Elasticsearch::Transport::Transport::Connections::Selector::Base
+
+    def select(options={})
+      connections.reject do |c|
+        c.host[:attributes] && c.host[:attributes][:backup]
+      end.send( defined?(RUBY_VERSION) && RUBY_VERSION > '1.9' ? :sample : :choice)
+    end
+  end
+
+  context "Connection selector" do
+
+    should "be initialized with connections" do
+      assert_equal [1, 2], Random.new(:connections => [1, 2]).connections
+    end
+
+    should "have the abstract select method" do
+      assert_raise(NoMethodError) { DummyStrategySelector.new.select }
+    end
+
+    context "in random strategy" do
+      setup do
+        @selector = Random.new :connections => ['A', 'B', 'C']
+      end
+
+      should "pick a connection" do
+        assert_not_nil @selector.select
+      end
+    end
+
+    context "in round-robin strategy" do
+      setup do
+        @selector = RoundRobin.new :connections => ['A', 'B', 'C']
+      end
+
+      should "rotate over connections" do
+        assert_equal 'A', @selector.select
+        assert_equal 'B', @selector.select
+        assert_equal 'C', @selector.select
+        assert_equal 'A', @selector.select
+      end
+    end
+
+    context "with a custom strategy" do
+
+      should "return proper connection" do
+        selector = BackupStrategySelector.new :connections => [ stub(:host => { :hostname => 'host1' }),
+                                                                stub(:host => { :hostname => 'host2', :attributes => { :backup => true }}) ]
+        10.times { assert_equal 'host1', selector.select.host[:hostname] }
+      end
+
+    end
+
+  end
+end

data/test/unit/connection_test.rb

@@ -0,0 +1,100 @@
+require 'test_helper'
+
+class Elasticsearch::Transport::Transport::Connections::ConnectionTest < Test::Unit::TestCase
+  include Elasticsearch::Transport::Transport::Connections
+
+  context "Connection" do
+
+    should "be initialized with :host, :connection, and :options" do
+      c = Connection.new :host => 'x', :connection => 'y', :options => {}
+      assert_equal 'x', c.host
+      assert_equal 'y', c.connection
+      assert_instance_of Hash, c.options
+    end
+
+    should "return full path" do
+      c = Connection.new
+      assert_equal '_search', c.full_path('_search')
+      assert_equal '_search', c.full_path('_search', {})
+      assert_equal '_search?foo=bar', c.full_path('_search', {:foo => 'bar'})
+      assert_equal '_search?foo=bar+bam', c.full_path('_search', {:foo => 'bar bam'})
+    end
+
+    should "return full url" do
+      c = Connection.new :host => { :protocol => 'http', :host => 'localhost', :port => '9200' }
+      assert_equal 'http://localhost:9200/_search?foo=bar', c.full_url('_search', {:foo => 'bar'})
+    end
+
+    should "return full url with credentials" do
+      c = Connection.new :host => { :protocol => 'http', :user => 'U', :password => 'P', :host => 'localhost', :port => '9200' }
+      assert_equal 'http://U:P@localhost:9200/_search?foo=bar', c.full_url('_search', {:foo => 'bar'})
+    end
+
+    should "return full url with path" do
+      c = Connection.new :host => { :protocol => 'http', :host => 'localhost', :port => '9200', :path => '/foo' }
+      assert_equal 'http://localhost:9200/foo/_search?foo=bar', c.full_url('_search', {:foo => 'bar'})
+    end
+
+    should "have a string representation" do
+      c = Connection.new :host => 'x'
+      assert_match /host: x/, c.to_s
+      assert_match /alive/,   c.to_s
+    end
+
+    should "not be dead by default" do
+      c = Connection.new
+      assert ! c.dead?
+    end
+
+    should "be dead when marked" do
+      c = Connection.new.dead!
+      assert c.dead?
+      assert_equal 1, c.failures
+      assert_in_delta c.dead_since, Time.now, 1
+    end
+
+    should "be alive when marked" do
+      c = Connection.new.dead!
+      assert c.dead?
+      assert_equal 1, c.failures
+      assert_in_delta c.dead_since, Time.now, 1
+
+      c.alive!
+      assert ! c.dead?
+      assert_equal 1, c.failures
+    end
+
+    should "be healthy when marked" do
+      c = Connection.new.dead!
+      assert c.dead?
+      assert_equal 1, c.failures
+      assert_in_delta c.dead_since, Time.now, 1
+
+      c.healthy!
+      assert ! c.dead?
+      assert_equal 0, c.failures
+    end
+
+    should "be resurrected if timeout passed" do
+      c = Connection.new.dead!
+
+      now = Time.now + 60
+      Time.stubs(:now).returns(now)
+
+      assert   c.resurrect!, c.inspect
+      assert ! c.dead?,      c.inspect
+    end
+
+    should "be resurrected if timeout passed for multiple failures" do
+      c = Connection.new.dead!.dead!
+
+      now = Time.now + 60*2
+      Time.stubs(:now).returns(now)
+
+      assert   c.resurrect!, c.inspect
+      assert ! c.dead?,      c.inspect
+    end
+
+  end
+
+end

data/test/unit/response_test.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+
+class Elasticsearch::Transport::Transport::ResponseTest < Test::Unit::TestCase
+  context "Response" do
+
+    should "force-encode the body into UTF" do
+      body = "Hello Encoding!".encode(Encoding::ISO_8859_1)
+      assert_equal 'ISO-8859-1', body.encoding.name
+
+      response = Elasticsearch::Transport::Transport::Response.new 200, body
+      assert_equal 'UTF-8', response.body.encoding.name
+    end unless RUBY_1_8
+
+  end
+end

data/test/unit/serializer_test.rb

@@ -0,0 +1,16 @@
+require 'test_helper'
+
+class Elasticsearch::Transport::Transport::SerializerTest < Test::Unit::TestCase
+
+  context "Serializer" do
+
+    should "use MultiJson by default" do
+      ::MultiJson.expects(:load)
+      ::MultiJson.expects(:dump)
+      Elasticsearch::Transport::Transport::Serializer::MultiJson.new.load('{}')
+      Elasticsearch::Transport::Transport::Serializer::MultiJson.new.dump({})
+    end
+
+  end
+
+end

data/test/unit/sniffer_test.rb

@@ -0,0 +1,145 @@
+require 'test_helper'
+
+class Elasticsearch::Transport::Transport::SnifferTest < Test::Unit::TestCase
+
+  class DummyTransport
+    include Elasticsearch::Transport::Transport::Base
+    def __build_connections; hosts; end
+  end
+
+  def __nodes_info(json)
+    Elasticsearch::Transport::Transport::Response.new 200, MultiJson.load(json)
+  end
+
+  context "Sniffer" do
+    setup do
+      @transport = DummyTransport.new
+      @sniffer   = Elasticsearch::Transport::Transport::Sniffer.new @transport
+    end
+
+    should "be initialized with a transport instance" do
+      assert_equal @transport, @sniffer.transport
+    end
+
+    should "return an array of hosts as hashes" do
+      @transport.expects(:perform_request).returns __nodes_info <<-JSON
+        {
+          "ok" : true,
+          "cluster_name" : "elasticsearch_test",
+          "nodes" : {
+            "N1" : {
+              "name" : "Node 1",
+              "transport_address" : "inet[/192.168.1.23:9300]",
+              "hostname" : "testhost1",
+              "version" : "0.20.6",
+              "http_address" : "inet[/192.168.1.23:9200]",
+              "thrift_address" : "/192.168.1.23:9500",
+              "memcached_address" : "inet[/192.168.1.23:11211]"
+            }
+          }
+        }
+      JSON
+
+      hosts = @sniffer.hosts
+
+      assert_equal 1, hosts.size
+      assert_equal '192.168.1.23', hosts.first[:host]
+      assert_equal '9200',         hosts.first[:port]
+      assert_equal 'Node 1',       hosts.first['name']
+    end
+
+    should "skip hosts without a matching transport protocol" do
+      @transport = DummyTransport.new :options => { :protocol => 'memcached' }
+      @sniffer   = Elasticsearch::Transport::Transport::Sniffer.new @transport
+
+      @transport.expects(:perform_request).returns __nodes_info <<-JSON
+        {
+          "ok" : true,
+          "cluster_name" : "elasticsearch_test",
+          "nodes" : {
+            "N1" : {
+              "name" : "Memcached Node",
+              "http_address" : "inet[/192.168.1.23:9200]",
+              "memcached_address" : "inet[/192.168.1.23:11211]"
+            },
+            "N2" : {
+              "name" : "HTTP Node",
+              "http_address" : "inet[/192.168.1.23:9200]"
+            }
+          }
+        }
+      JSON
+
+      hosts = @sniffer.hosts
+
+      assert_equal 1, hosts.size
+      assert_equal '192.168.1.23',   hosts.first[:host]
+      assert_equal '11211',          hosts.first[:port]
+      assert_equal 'Memcached Node', hosts.first['name']
+    end
+
+    should "have configurable timeout" do
+      @transport = DummyTransport.new :options => { :sniffer_timeout => 0.001 }
+      @sniffer   = Elasticsearch::Transport::Transport::Sniffer.new @transport
+      assert_equal 0.001, @sniffer.timeout
+    end
+
+    should "have settable timeout" do
+      @transport = DummyTransport.new
+      @sniffer   = Elasticsearch::Transport::Transport::Sniffer.new @transport
+      assert_equal 1, @sniffer.timeout
+
+      @sniffer.timeout = 2
+      assert_equal 2, @sniffer.timeout
+    end
+
+    should "raise error on timeout" do
+      @transport.expects(:perform_request).raises(Elasticsearch::Transport::Transport::SnifferTimeoutError)
+
+      # TODO: Try to inject sleep into `perform_request` or make this test less ridiculous anyhow...
+      assert_raise Elasticsearch::Transport::Transport::SnifferTimeoutError do
+        @sniffer.hosts
+      end
+    end
+
+    should "randomize hosts" do
+      @transport = DummyTransport.new :options => { :randomize_hosts => true }
+      @sniffer   = Elasticsearch::Transport::Transport::Sniffer.new @transport
+
+      @transport.expects(:perform_request).returns __nodes_info <<-JSON
+        {
+          "ok" : true,
+          "cluster_name" : "elasticsearch_test",
+          "nodes" : {
+            "N1" : {
+              "name" : "Node 1",
+              "http_address" : "inet[/192.168.1.23:9200]"
+            },
+            "N2" : {
+              "name" : "Node 2",
+              "http_address" : "inet[/192.168.1.23:9201]"
+            },
+            "N3" : {
+              "name" : "Node 3",
+              "http_address" : "inet[/192.168.1.23:9202]"
+            },
+            "N4" : {
+              "name" : "Node 4",
+              "http_address" : "inet[/192.168.1.23:9203]"
+            },
+            "N5" : {
+              "name" : "Node 5",
+              "http_address" : "inet[/192.168.1.23:9204]"
+            }
+          }
+        }
+      JSON
+
+      Array.any_instance.expects(:shuffle!)
+
+      hosts = @sniffer.hosts
+    end
+
+  end
+
+end

data/test/unit/transport_base_test.rb

@@ -0,0 +1,478 @@
+require 'test_helper'
+
+class Elasticsearch::Transport::Transport::BaseTest < Test::Unit::TestCase
+
+  class EmptyTransport
+    include Elasticsearch::Transport::Transport::Base
+  end
+
+  class DummyTransport
+    include Elasticsearch::Transport::Transport::Base
+    def __build_connections; hosts; end
+  end
+
+  class DummyTransportPerformer < DummyTransport
+    def perform_request(method, path, params={}, body=nil, &block); super; end
+  end
+
+  class DummySerializer
+    def initialize(*); end
+  end
+
+  class DummySniffer
+    def initialize(*); end
+  end
+
+  context "Transport::Base" do
+    should "raise exception when it doesn't implement __build_connections" do
+      assert_raise NoMethodError do
+        EmptyTransport.new.__build_connections
+      end
+    end
+
+    should "build connections on initialization" do
+      DummyTransport.any_instance.expects(:__build_connections)
+      transport = DummyTransport.new
+    end
+
+    should "have default serializer" do
+      transport = DummyTransport.new
+      assert_instance_of Elasticsearch::Transport::Transport::Base::DEFAULT_SERIALIZER_CLASS, transport.serializer
+    end
+
+    should "have custom serializer" do
+      transport = DummyTransport.new :options => { :serializer_class => DummySerializer }
+      assert_instance_of DummySerializer, transport.serializer
+
+      transport = DummyTransport.new :options => { :serializer => DummySerializer.new }
+      assert_instance_of DummySerializer, transport.serializer
+    end
+
+    should "have default sniffer" do
+      transport = DummyTransport.new
+      assert_instance_of Elasticsearch::Transport::Transport::Sniffer, transport.sniffer
+    end
+
+    should "have custom sniffer" do
+      transport = DummyTransport.new :options => { :sniffer_class => DummySniffer }
+      assert_instance_of DummySniffer, transport.sniffer
+    end
+
+    context "when combining the URL" do
+      setup do
+        @transport   = DummyTransport.new
+        @basic_parts = { :protocol => 'http', :host => 'myhost', :port => 8080 }
+      end
+
+      should "combine basic parts" do
+        assert_equal 'http://myhost:8080', @transport.__full_url(@basic_parts)
+      end
+
+      should "combine path" do
+        assert_equal 'http://myhost:8080/api', @transport.__full_url(@basic_parts.merge :path => '/api')
+      end
+
+      should "combine authentication credentials" do
+        assert_equal 'http://U:P@myhost:8080', @transport.__full_url(@basic_parts.merge :user => 'U', :password => 'P')
+      end
+    end
+  end
+
+  context "getting a connection" do
+    setup do
+      @transport = DummyTransportPerformer.new :options => { :reload_connections => 5 }
+      @transport.stubs(:connections).returns(stub :get_connection => Object.new)
+      @transport.stubs(:sniffer).returns(stub :hosts => [])
+    end
+
+    should "get a connection" do
+      assert_not_nil @transport.get_connection
+    end
+
+    should "increment the counter" do
+      assert_equal 0, @transport.counter
+      3.times { @transport.get_connection }
+      assert_equal 3, @transport.counter
+    end
+
+    should "reload connections when it hits the threshold" do
+      @transport.expects(:reload_connections!).twice
+      12.times { @transport.get_connection }
+      assert_equal 12, @transport.counter
+    end
+
+    should "not reload connections by default" do
+      @transport = DummyTransportPerformer.new
+      @transport.stubs(:connections).returns(stub :get_connection => Object.new)
+      @transport.expects(:reload_connections!).never
+
+      10_010.times { @transport.get_connection }
+      assert_equal 10_010, @transport.counter
+    end
+
+    should "not reload connections when the option is set to false" do
+      @transport = DummyTransportPerformer.new :options => { :reload_connections => false }
+      @transport.stubs(:connections).returns(stub :get_connection => Object.new)
+      @transport.expects(:reload_connections!).never
+
+      10_010.times { @transport.get_connection }
+      assert_equal 10_010, @transport.counter
+    end
+  end
+
+  context "performing a request" do
+    setup do
+      @transport = DummyTransportPerformer.new
+    end
+
+    should "raise an error when no block is passed" do
+      assert_raise NoMethodError do
+        @transport.peform_request 'GET', '/'
+      end
+    end
+
+    should "get the connection" do
+      @transport.expects(:get_connection).returns(stub_everything :failures => 1)
+      @transport.perform_request 'GET', '/' do; Elasticsearch::Transport::Transport::Response.new 200, 'OK'; end
+    end
+
+    should "raise an error when no connection is available" do
+      @transport.expects(:get_connection).returns(nil)
+      assert_raise Elasticsearch::Transport::Transport::Error do
+        @transport.perform_request 'GET', '/' do; Elasticsearch::Transport::Transport::Response.new 200, 'OK'; end
+      end
+    end
+
+    should "call the passed block" do
+      x = 0
+      @transport.expects(:get_connection).returns(stub_everything :failures => 1)
+
+      @transport.perform_request 'GET', '/' do |connection, url|
+        x += 1
+        Elasticsearch::Transport::Transport::Response.new 200, 'OK'
+      end
+
+      assert_equal 1, x
+    end
+
+    should "deserialize a response JSON body" do
+      @transport.expects(:get_connection).returns(stub_everything :failures => 1)
+      @transport.serializer.expects(:load).returns({'foo' => 'bar'})
+
+      response = @transport.perform_request 'GET', '/' do
+                   Elasticsearch::Transport::Transport::Response.new 200, '{"foo":"bar"}', {"content-type" => 'application/json'}
+                 end
+
+      assert_instance_of Elasticsearch::Transport::Transport::Response, response
+      assert_equal 'bar', response.body['foo']
+    end
+
+    should "not deserialize a response string body" do
+      @transport.expects(:get_connection).returns(stub_everything :failures => 1)
+      @transport.serializer.expects(:load).never
+      response = @transport.perform_request 'GET', '/' do
+                   Elasticsearch::Transport::Transport::Response.new 200, 'FOOBAR', {"content-type" => 'text/plain'}
+                 end
+
+      assert_instance_of Elasticsearch::Transport::Transport::Response, response
+      assert_equal 'FOOBAR', response.body
+    end
+
+    should "serialize non-String objects" do
+      @transport.serializer.expects(:dump).times(3)
+      @transport.__convert_to_json({:foo => 'bar'})
+      @transport.__convert_to_json([1, 2, 3])
+      @transport.__convert_to_json(nil)
+    end
+
+    should "not serialize a String object" do
+      @transport.serializer.expects(:dump).never
+      @transport.__convert_to_json('{"foo":"bar"}')
+    end
+
+    should "raise an error for HTTP status 404" do
+      @transport.expects(:get_connection).returns(stub_everything :failures => 1)
+      assert_raise Elasticsearch::Transport::Transport::Errors::NotFound do
+        @transport.perform_request 'GET', '/' do
+          Elasticsearch::Transport::Transport::Response.new 404, 'NOT FOUND'
+        end
+      end
+    end
+
+    should "raise an error for HTTP status 404 with application/json content type" do
+      @transport.expects(:get_connection).returns(stub_everything :failures => 1)
+      assert_raise Elasticsearch::Transport::Transport::Errors::NotFound do
+        @transport.perform_request 'GET', '/' do
+          Elasticsearch::Transport::Transport::Response.new 404, 'NOT FOUND', {"content-type" => 'application/json'}
+        end
+      end
+    end
+
+    should "raise an error on server failure" do
+      @transport.expects(:get_connection).returns(stub_everything :failures => 1)
+      assert_raise Elasticsearch::Transport::Transport::Errors::InternalServerError do
+        @transport.perform_request 'GET', '/' do
+          Elasticsearch::Transport::Transport::Response.new 500, 'ERROR'
+        end
+      end
+    end
+
+    should "raise an error on connection failure" do
+      @transport.expects(:get_connection).returns(stub_everything :failures => 1)
+
+      # `block.expects(:call).raises(::Errno::ECONNREFUSED)` fails on Ruby 1.8
+      block = lambda { |a, b| raise ::Errno::ECONNREFUSED }
+
+      assert_raise ::Errno::ECONNREFUSED do
+        @transport.perform_request 'GET', '/', &block
+      end
+    end
+
+    should "mark the connection as dead on failure" do
+      c = stub_everything :failures => 1
+      @transport.expects(:get_connection).returns(c)
+
+      block = lambda { |a,b| raise ::Errno::ECONNREFUSED }
+
+      c.expects(:dead!)
+
+      assert_raise( ::Errno::ECONNREFUSED ) { @transport.perform_request 'GET', '/', &block }
+    end
+  end
+
+  context "performing a request with reload connections on connection failures" do
+    setup do
+      fake_collection = stub_everything :get_connection => stub_everything(:failures => 1),
+                                        :all            => stub_everything(:size => 2)
+      @transport = DummyTransportPerformer.new :options => { :reload_on_failure => 2 }
+      @transport.stubs(:connections).
+                 returns(fake_collection)
+      @block = lambda { |c, u| puts "UNREACHABLE" }
+    end
+
+    should "reload connections when host is unreachable" do
+      @block.expects(:call).times(2).
+            raises(Errno::ECONNREFUSED).
+            then.returns(stub_everything :failures => 1)
+
+      @transport.expects(:reload_connections!).returns([])
+
+      @transport.perform_request('GET', '/', &@block)
+      assert_equal 2, @transport.counter
+    end
+  end unless RUBY_1_8
+
+  context "performing a request with retry on connection failures" do
+    setup do
+      @transport = DummyTransportPerformer.new :options => { :retry_on_failure => true }
+      @transport.stubs(:connections).returns(stub :get_connection => stub_everything(:failures => 1))
+      @block = Proc.new { |c, u| puts "UNREACHABLE" }
+    end
+
+    should "retry DEFAULT_MAX_RETRIES when host is unreachable" do
+      @block.expects(:call).times(4).
+            raises(Errno::ECONNREFUSED).
+            then.raises(Errno::ECONNREFUSED).
+            then.raises(Errno::ECONNREFUSED).
+            then.returns(stub_everything :failures => 1)
+
+      assert_nothing_raised do
+        @transport.perform_request('GET', '/', &@block)
+        assert_equal 4, @transport.counter
+      end
+    end
+
+    should "raise an error after max tries" do
+      @block.expects(:call).times(4).
+            raises(Errno::ECONNREFUSED).
+            then.raises(Errno::ECONNREFUSED).
+            then.raises(Errno::ECONNREFUSED).
+            then.raises(Errno::ECONNREFUSED).
+            then.returns(stub_everything :failures => 1)
+
+      assert_raise Errno::ECONNREFUSED do
+        @transport.perform_request('GET', '/', &@block)
+      end
+    end
+  end unless RUBY_1_8
+
+  context "logging" do
+    setup do
+      @transport = DummyTransportPerformer.new :options => { :logger => Logger.new('/dev/null') }
+
+      fake_connection = stub :full_url => 'localhost:9200/_search?size=1',
+                             :host     => 'localhost',
+                             :connection => stub_everything,
+                             :failures => 0,
+                             :healthy! => true
+
+      @transport.stubs(:get_connection).returns(fake_connection)
+      @transport.serializer.stubs(:load).returns 'foo' => 'bar'
+      @transport.serializer.stubs(:dump).returns '{"foo":"bar"}'
+    end
+
+    should "log the request and response" do
+      @transport.logger.expects(:info).  with do |line|
+        line =~ %r|POST localhost\:9200/_search\?size=1 \[status\:200, request:.*s, query:n/a\]|
+      end
+      @transport.logger.expects(:debug). with '> {"foo":"bar"}'
+      @transport.logger.expects(:debug). with '< {"foo":"bar"}'
+
+      @transport.perform_request 'POST', '_search', {:size => 1}, {:foo => 'bar'} do
+                   Elasticsearch::Transport::Transport::Response.new 200, '{"foo":"bar"}'
+                 end
+    end
+
+    should "log a failed Elasticsearch request" do
+      @block = Proc.new { |c, u| puts "ERROR" }
+      @block.expects(:call).returns(Elasticsearch::Transport::Transport::Response.new 500, 'ERROR')
+
+      @transport.expects(:__log)
+      @transport.logger.expects(:fatal)
+
+      assert_raise Elasticsearch::Transport::Transport::Errors::InternalServerError do
+        @transport.perform_request('POST', '_search', &@block)
+      end
+    end unless RUBY_1_8
+
+    should "log and re-raise a Ruby exception" do
+      @block = Proc.new { |c, u| puts "ERROR" }
+      @block.expects(:call).raises(Exception)
+
+      @transport.expects(:__log).never
+      @transport.logger.expects(:fatal)
+
+      assert_raise(Exception) { @transport.perform_request('POST', '_search', &@block) }
+    end unless RUBY_1_8
+  end
+
+  context "tracing" do
+    setup do
+      @transport = DummyTransportPerformer.new :options => { :tracer => Logger.new('/dev/null') }
+
+      fake_connection = stub :full_url => 'localhost:9200/_search?size=1',
+                             :host     => 'localhost',
+                             :connection => stub_everything,
+                             :failures => 0,
+                             :healthy! => true
+
+      @transport.stubs(:get_connection).returns(fake_connection)
+      @transport.serializer.stubs(:load).returns 'foo' => 'bar'
+      @transport.serializer.stubs(:dump).returns <<-JSON.gsub(/^      /, '')
+      {
+        "foo" : {
+          "bar" : {
+            "bam" : true
+          }
+        }
+      }
+      JSON
+    end
+
+    should "trace the request" do
+      @transport.tracer.expects(:info).  with do |message|
+        message == <<-CURL.gsub(/^            /, '')
+            curl -X POST 'http://localhost:9200/_search?pretty&size=1' -d '{
+              "foo" : {
+                "bar" : {
+                  "bam" : true
+                }
+              }
+            }
+            '
+          CURL
+      end.once
+
+      @transport.perform_request 'POST', '_search', {:size => 1}, {:q => 'foo'} do
+                   Elasticsearch::Transport::Transport::Response.new 200, '{"foo":"bar"}'
+                 end
+    end
+
+    should "trace a failed Elasticsearch request" do
+      @block = Proc.new { |c, u| puts "ERROR" }
+      @block.expects(:call).returns(Elasticsearch::Transport::Transport::Response.new 500, 'ERROR')
+
+      @transport.expects(:__trace)
+
+      assert_raise Elasticsearch::Transport::Transport::Errors::InternalServerError do
+        @transport.perform_request('POST', '_search', &@block)
+      end
+    end unless RUBY_1_8
+
+  end
+
+  context "reloading connections" do
+    setup do
+      @transport = DummyTransport.new :options => { :logger => Logger.new('/dev/null') }
+    end
+
+    should "rebuild connections" do
+      @transport.sniffer.expects(:hosts).returns([])
+      @transport.expects(:__rebuild_connections)
+      @transport.reload_connections!
+    end
+
+    should "log error and continue when timing out while sniffing hosts" do
+      @transport.sniffer.expects(:hosts).raises(Elasticsearch::Transport::Transport::SnifferTimeoutError)
+      @transport.logger.expects(:error)
+      assert_nothing_raised do
+        @transport.reload_connections!
+      end
+    end
+  end
+
+  context "rebuilding connections" do
+    setup do
+      @transport = DummyTransport.new
+    end
+
+    should "should replace the connections" do
+      assert_equal [], @transport.connections
+      @transport.__rebuild_connections :hosts => ['foo', 'bar']
+      assert_equal ['foo', 'bar'], @transport.connections
+    end
+  end
+
+  context "resurrecting connections" do
+    setup do
+      @transport = DummyTransportPerformer.new
+    end
+
+    should "delegate to dead connections" do
+      @transport.connections.expects(:dead).returns([])
+      @transport.resurrect_dead_connections!
+    end
+
+    should "not resurrect connections until timeout" do
+      @transport.connections.expects(:get_connection).returns(stub_everything :failures => 1).times(5)
+      @transport.expects(:resurrect_dead_connections!).never
+      5.times { @transport.get_connection }
+    end
+
+    should "resurrect connections after timeout" do
+      @transport.connections.expects(:get_connection).returns(stub_everything :failures => 1).times(5)
+      @transport.expects(:resurrect_dead_connections!)
+
+      4.times { @transport.get_connection }
+
+      now = Time.now + 60*2
+      Time.stubs(:now).returns(now)
+
+      @transport.get_connection
+    end
+
+    should "mark connection healthy if it succeeds" do
+      c = stub_everything(:failures => 1)
+      @transport.expects(:get_connection).returns(c)
+      c.expects(:healthy!)
+
+      @transport.perform_request('GET', '/') { |connection, url| Elasticsearch::Transport::Transport::Response.new 200, 'OK' }
+    end
+  end
+
+  context "errors" do
+    should "raise highest-level Error exception for any ServerError" do
+      assert_kind_of Elasticsearch::Transport::Transport::Error, Elasticsearch::Transport::Transport::ServerError.new
+    end
+  end
+end