elasticsearch-transport 0.0.2

data/test/test_helper.rb

@@ -0,0 +1,58 @@
+RUBY_1_8 = defined?(RUBY_VERSION) && RUBY_VERSION < '1.9'
+
+if RUBY_1_8
+  require 'rubygems'
+  gem 'test-unit'
+end
+
+require 'rubygems' if RUBY_1_8
+
+require 'simplecov' and SimpleCov.start { add_filter "/test|test_/" } if ENV["COVERAGE"]
+
+# Register `at_exit` handler for integration tests shutdown.
+# MUST be called before requiring `test/unit`.
+at_exit { Elasticsearch::Test::IntegrationTestCase.__run_at_exit_hooks }
+
+require 'test/unit'
+require 'shoulda-context'
+require 'mocha/setup'
+require 'ansi/code'
+require 'turn' unless ENV["TM_FILEPATH"] || ENV["NOTURN"] || RUBY_1_8
+
+require 'test_extensions'
+
+require 'require-prof' if ENV["REQUIRE_PROF"]
+require 'elasticsearch-transport'
+require 'elasticsearch/transport/extensions/test_cluster'
+require 'logger'
+
+RequireProf.print_timing_infos if ENV["REQUIRE_PROF"]
+
+class Test::Unit::TestCase
+  def setup
+  end
+
+  def teardown
+  end
+end
+
+module Elasticsearch
+  module Test
+    class IntegrationTestCase < ::Test::Unit::TestCase
+      extend IntegrationTestStartupShutdown
+
+      shutdown { Elasticsearch::TestCluster.stop if ENV['SERVER'] && started? }
+      context "IntegrationTest" do; should "noop on Ruby 1.8" do; end; end if RUBY_1_8
+    end
+  end
+
+  module Test
+    class ProfilingTest < ::Test::Unit::TestCase
+      extend IntegrationTestStartupShutdown
+      extend ProfilingTestSupport
+
+      shutdown { Elasticsearch::TestCluster.stop if ENV['SERVER'] && started? }
+      context "IntegrationTest" do; should "noop on Ruby 1.8" do; end; end if RUBY_1_8
+    end
+  end
+end

data/test/unit/client_test.rb

@@ -0,0 +1,109 @@
+require 'test_helper'
+
+class Elasticsearch::Transport::ClientTest < Test::Unit::TestCase
+
+  class DummyTransport
+    def initialize(*); end
+  end
+
+  context "Client" do
+    setup do
+      Elasticsearch::Transport::Client::DEFAULT_TRANSPORT_CLASS.any_instance.stubs(:__build_connections)
+      @client = Elasticsearch::Transport::Client.new
+    end
+
+    should "be aliased as Elasticsearch::Client" do
+      assert_nothing_raised do
+        assert_instance_of(Elasticsearch::Transport::Client, Elasticsearch::Client.new)
+      end
+    end
+
+    should "have default transport" do
+      assert_instance_of Elasticsearch::Transport::Client::DEFAULT_TRANSPORT_CLASS, @client.transport
+    end
+
+    should "instantiate custom transport class" do
+      client = Elasticsearch::Transport::Client.new :transport_class => DummyTransport
+      assert_instance_of DummyTransport, client.transport
+    end
+
+    should "take custom transport instance" do
+      client = Elasticsearch::Transport::Client.new :transport => DummyTransport.new
+      assert_instance_of DummyTransport, client.transport
+    end
+
+    should "delegate performing requests to transport" do
+      assert_respond_to @client, :perform_request
+      @client.transport.expects(:perform_request)
+      @client.perform_request 'GET', '/'
+    end
+
+    should "have default logger for transport" do
+      client = Elasticsearch::Transport::Client.new :log => true
+      assert_respond_to client.transport.logger, :info
+    end
+
+    should "have default tracer for transport" do
+      client = Elasticsearch::Transport::Client.new :trace => true
+      assert_respond_to client.transport.tracer, :info
+    end
+
+    context "when passed hosts" do
+      should "have localhost by default" do
+        c = Elasticsearch::Transport::Client.new
+        assert_equal 'localhost', c.transport.hosts.first[:host]
+      end
+
+      should "take :hosts, :host or :url" do
+        c1 = Elasticsearch::Transport::Client.new :hosts => ['foobar']
+        c2 = Elasticsearch::Transport::Client.new :host  => 'foobar'
+        c3 = Elasticsearch::Transport::Client.new :url   => 'foobar'
+        assert_equal 'foobar', c1.transport.hosts.first[:host]
+        assert_equal 'foobar', c2.transport.hosts.first[:host]
+        assert_equal 'foobar', c3.transport.hosts.first[:host]
+      end
+    end
+
+    context "extracting hosts" do
+      should "handle defaults" do
+        assert_equal [ {:host => 'localhost', :port => nil} ], @client.__extract_hosts
+      end
+
+      should "extract from string" do
+        assert_equal [ {:host => 'myhost', :port => nil} ], @client.__extract_hosts( 'myhost' )
+      end
+
+      should "extract from array" do
+        assert_equal [ {:host => 'myhost', :port => nil} ], @client.__extract_hosts( ['myhost'] )
+      end
+
+      should "extract from array with multiple hosts" do
+        assert_equal [ {:host => 'host1', :port => nil}, {:host => 'host2', :port => nil} ],
+                     @client.__extract_hosts( ['host1', 'host2'] )
+      end
+
+      should "extract from array with ports" do
+        assert_equal [ {:host => 'host1', :port => '1000'}, {:host => 'host2', :port => '2000'} ],
+                     @client.__extract_hosts( ['host1:1000', 'host2:2000'] )
+      end
+
+      should "pass Hashes over" do
+        assert_equal [ {:host => 'myhost', :port => '1000'} ],
+                     @client.__extract_hosts( [{:host => 'myhost', :port => '1000'}] )
+      end
+
+      should "raise error for incompatible argument" do
+        assert_raise ArgumentError do
+          @client.__extract_hosts 123
+        end
+      end
+
+      should "randomize hosts" do
+        hosts = [ {:host => 'host1'}, {:host => 'host2'}, {:host => 'host3'}, {:host => 'host4'}, {:host => 'host5'}]
+        assert_not_equal     hosts, @client.__extract_hosts(hosts, :randomize_hosts => true)
+        assert_same_elements hosts, @client.__extract_hosts(hosts, :randomize_hosts => true)
+      end
+    end
+
+  end
+end

data/test/unit/connection_collection_test.rb

@@ -0,0 +1,83 @@
+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 "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,90 @@
+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 "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/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,146 @@
+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
+
+      hosts = @sniffer.hosts
+
+      assert_not_equal       ['Node 1', 'Node 2', 'Node 3', 'Node 4', 'Node 5'], hosts.map { |h| h['name'] }
+      assert_same_elements ['Node 1', 'Node 2', 'Node 3', 'Node 4', 'Node 5'], hosts.map { |h| h['name'] }
+    end
+
+  end
+
+end