elasticsearch-transport-pixlee 1.0.13

data/test/profile/client_benchmark_test.rb

@@ -0,0 +1,125 @@
+require 'test_helper'
+
+class Elasticsearch::Transport::ClientProfilingTest < Elasticsearch::Test::ProfilingTest
+  startup do
+    Elasticsearch::Extensions::Test::Cluster.start if ENV['SERVER'] and not Elasticsearch::Extensions::Test::Cluster.running?
+  end
+
+  context "Elasticsearch client benchmark" do
+    setup do
+      @port = (ENV['TEST_CLUSTER_PORT'] || 9250).to_i
+      client = Elasticsearch::Client.new host: "localhost:#{@port}", adapter: ::Faraday.default_adapter
+      client.perform_request 'DELETE', '/ruby_test_benchmark/' rescue nil
+      client.perform_request 'POST',   '/ruby_test_benchmark/', {index: {number_of_shards: 1, number_of_replicas: 0}}
+      100.times do client.perform_request 'POST',   '/ruby_test_benchmark_search/test/', {}, {foo: 'bar'}; end
+      client.perform_request 'POST',   '/ruby_test_benchmark_search/_refresh'
+    end
+    teardown do
+      client = Elasticsearch::Client.new host: "localhost:#{@port}"
+      client.perform_request 'DELETE', '/ruby_test_benchmark/'
+      client.perform_request 'DELETE', '/ruby_test_benchmark_search/'
+    end
+
+    context "with a single-node cluster and the default adapter" do
+      setup do
+        @client = Elasticsearch::Client.new hosts: "localhost:#{@port}", adapter: ::Faraday.default_adapter
+      end
+
+      measure "get the cluster info", count: 1_000 do
+        @client.perform_request 'GET', ''
+      end
+
+      measure "index a document" do
+        @client.perform_request 'POST', '/ruby_test_benchmark/test/', {}, {foo: 'bar'}
+      end
+
+      measure "search" do
+        @client.perform_request 'POST', '/ruby_test_benchmark_search/test/_search', {}, {query: {match: {foo: 'bar'}}}
+      end
+    end
+
+    context "with a two-node cluster and the default adapter" do
+      setup do
+        @client = Elasticsearch::Client.new hosts: ["localhost:#{@port}", "localhost:#{@port+1}"], adapter: ::Faraday.default_adapter
+      end
+
+      measure "get the cluster info", count: 1_000 do
+        @client.perform_request 'GET', ''
+      end
+
+      measure "index a document"do
+        @client.perform_request 'POST', '/ruby_test_benchmark/test/', {}, {foo: 'bar'}
+      end
+
+      measure "search" do
+        @client.perform_request 'POST', '/ruby_test_benchmark_search/test/_search', {}, {query: {match: {foo: 'bar'}}}
+      end
+    end
+
+    context "with a single-node cluster and the Curb client" do
+      setup do
+        require 'curb'
+        require 'elasticsearch/transport/transport/http/curb'
+        @client = Elasticsearch::Client.new host: "localhost:#{@port}",
+                                            transport_class: Elasticsearch::Transport::Transport::HTTP::Curb
+      end
+
+      measure "get the cluster info", count: 1_000 do
+        @client.perform_request 'GET', ''
+      end
+
+      measure "index a document" do
+        @client.perform_request 'POST', '/ruby_test_benchmark/test/', {}, {foo: 'bar'}
+      end
+
+      measure "search" do
+        @client.perform_request 'POST', '/ruby_test_benchmark_search/test/_search', {}, {query: {match: {foo: 'bar'}}}
+      end
+    end
+
+    context "with a single-node cluster and the Typhoeus client" do
+      require 'typhoeus'
+      require 'typhoeus/adapters/faraday'
+
+      setup do
+        transport = Elasticsearch::Transport::Transport::HTTP::Faraday.new \
+          :hosts => [ { :host => 'localhost', :port => @port } ] do |f|
+            f.adapter  :typhoeus
+          end
+
+        @client = Elasticsearch::Client.new transport: transport
+      end
+
+      measure "get the cluster info", count: 1_000 do
+        @client.perform_request 'GET', ''
+      end
+
+      measure "index a document" do
+        @client.perform_request 'POST', '/ruby_test_benchmark/test/', {}, {foo: 'bar'}
+      end
+
+      measure "search" do
+        @client.perform_request 'POST', '/ruby_test_benchmark_search/test/_search', {}, {query: {match: {foo: 'bar'}}}
+      end
+    end
+
+    context "with a single-node cluster and the Patron adapter" do
+      setup do
+        require 'patron'
+        @client = Elasticsearch::Client.new host: "localhost:#{@port}", adapter: :patron
+      end
+
+      measure "get the cluster info", count: 1_000 do
+        @client.perform_request 'GET', ''
+      end
+
+      measure "index a document" do
+        @client.perform_request 'POST', '/ruby_test_benchmark/test/', {}, {foo: 'bar'}
+      end
+
+      measure "search" do
+        @client.perform_request 'POST', '/ruby_test_benchmark_search/test/_search', {}, {query: {match: {foo: 'bar'}}}
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,76 @@
+RUBY_1_8 = defined?(RUBY_VERSION) && RUBY_VERSION < '1.9'
+JRUBY    = defined?(JRUBY_VERSION)
+
+if RUBY_1_8 and not ENV['BUNDLE_GEMFILE']
+  require 'rubygems'
+  gem 'test-unit'
+end
+
+require 'rubygems' if RUBY_1_8
+
+if ENV['COVERAGE'] && ENV['CI'].nil? && !RUBY_1_8
+  require 'simplecov'
+  SimpleCov.start { add_filter "/test|test_/" }
+end
+
+if ENV['CI'] && !RUBY_1_8
+  require 'simplecov'
+  require 'simplecov-rcov'
+  SimpleCov.formatter = SimpleCov::Formatter::RcovFormatter
+  SimpleCov.start { add_filter "/test|test_" }
+end
+
+# Register `at_exit` handler for integration tests shutdown.
+# MUST be called before requiring `test/unit`.
+if defined?(RUBY_VERSION) && RUBY_VERSION > '1.9'
+  at_exit { Elasticsearch::Test::IntegrationTestCase.__run_at_exit_hooks }
+end
+
+require 'test/unit'
+require 'shoulda-context'
+require 'mocha/setup'
+require 'ansi/code'
+require 'turn' unless ENV["TM_FILEPATH"] || ENV["NOTURN"] || RUBY_1_8
+
+require 'require-prof' if ENV["REQUIRE_PROF"]
+require 'elasticsearch-transport'
+require 'logger'
+
+require 'hashie'
+
+RequireProf.print_timing_infos if ENV["REQUIRE_PROF"]
+
+if defined?(RUBY_VERSION) && RUBY_VERSION > '1.9'
+  require 'elasticsearch/extensions/test/cluster'
+  require 'elasticsearch/extensions/test/startup_shutdown'
+  require 'elasticsearch/extensions/test/profiling' unless JRUBY
+end
+
+class Test::Unit::TestCase
+  def setup
+  end
+
+  def teardown
+  end
+end
+
+module Elasticsearch
+  module Test
+    class IntegrationTestCase < ::Test::Unit::TestCase
+      extend Elasticsearch::Extensions::Test::StartupShutdown
+
+      shutdown { Elasticsearch::Extensions::Test::Cluster.stop if ENV['SERVER'] && started? && Elasticsearch::Extensions::Test::Cluster.running? }
+      context "IntegrationTest" do; should "noop on Ruby 1.8" do; end; end if RUBY_1_8
+    end if defined?(RUBY_VERSION) && RUBY_VERSION > '1.9'
+  end
+
+  module Test
+    class ProfilingTest < ::Test::Unit::TestCase
+      extend Elasticsearch::Extensions::Test::StartupShutdown
+      extend Elasticsearch::Extensions::Test::Profiling
+
+      shutdown { Elasticsearch::Extensions::Test::Cluster.stop if ENV['SERVER'] && started? && Elasticsearch::Extensions::Test::Cluster.running? }
+      context "IntegrationTest" do; should "noop on Ruby 1.8" do; end; end if RUBY_1_8
+    end unless RUBY_1_8 || JRUBY
+  end
+end

data/test/unit/client_test.rb

@@ -0,0 +1,274 @@
+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 "send GET request as POST with the send_get_body_as option" do
+      transport = DummyTransport.new
+      client = Elasticsearch::Transport::Client.new :transport => transport, :send_get_body_as => 'POST'
+      transport.expects(:perform_request).with 'POST', '/', {}, '{"foo":"bar"}'
+      client.perform_request 'GET', '/', {}, '{"foo":"bar"}'
+    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
+
+    should "initialize the default transport class" do
+      Elasticsearch::Transport::Client::DEFAULT_TRANSPORT_CLASS.any_instance.
+        unstub(:__build_connections)
+
+      client = Elasticsearch::Client.new
+      assert_match /Faraday/, client.transport.connections.first.connection.headers['User-Agent']
+    end
+
+    should "pass options to the transport" do
+      client = Elasticsearch::Transport::Client.new :transport_options => { :foo => 'bar' }
+      assert_equal 'bar', client.transport.options[:transport_options][:foo]
+    end
+
+    should "merge request_timeout to the transport options" do
+      client = Elasticsearch::Transport::Client.new :request_timeout => 120
+      assert_equal 120, client.transport.options[:transport_options][:request][:timeout]
+    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, :url or :urls" do
+        c1 = Elasticsearch::Transport::Client.new :hosts => ['foobar']
+        c2 = Elasticsearch::Transport::Client.new :host  => 'foobar'
+        c3 = Elasticsearch::Transport::Client.new :url   => 'foobar'
+        c4 = Elasticsearch::Transport::Client.new :urls  => 'foo,bar'
+
+        assert_equal 'foobar', c1.transport.hosts[0][:host]
+        assert_equal 'foobar', c2.transport.hosts[0][:host]
+        assert_equal 'foobar', c3.transport.hosts[0][:host]
+        assert_equal 'foo',    c4.transport.hosts[0][:host]
+        assert_equal 'bar',    c4.transport.hosts[1][:host]
+      end
+
+    end
+
+    context "when the URL is set in the environment variable" do
+      setup    { ENV['ELASTICSEARCH_URL'] = 'foobar' }
+      teardown { ENV.delete('ELASTICSEARCH_URL')     }
+
+      should "use a single host" do
+        c = Elasticsearch::Transport::Client.new
+
+        assert_equal 1,     c.transport.hosts.size
+        assert_equal 'foobar', c.transport.hosts.first[:host]
+      end
+
+      should "use multiple hosts" do
+        ENV['ELASTICSEARCH_URL'] = 'foo, bar'
+        c = Elasticsearch::Transport::Client.new
+
+        assert_equal 2,     c.transport.hosts.size
+        assert_equal 'foo', c.transport.hosts[0][:host]
+        assert_equal 'bar', c.transport.hosts[1][:host]
+      end
+    end
+
+    context "extracting hosts" do
+      should "extract from string" do
+        hosts = @client.__extract_hosts 'myhost'
+
+        assert_equal 'myhost', hosts[0][:host]
+        assert_nil             hosts[0][:port]
+      end
+
+      should "extract from hash" do
+        hosts = @client.__extract_hosts( { :host => 'myhost', :scheme => 'https' } )
+        assert_equal 'myhost', hosts[0][:host]
+        assert_equal 'https',  hosts[0][:scheme]
+        assert_nil             hosts[0][:port]
+      end
+
+      should "extract from hash with a port passed as a string" do
+        hosts = @client.__extract_hosts( { :host => 'myhost', :scheme => 'https', :port => '443' } )
+        assert_equal 443, hosts[0][:port]
+      end
+
+      should "extract from hash with a port passed as an integer" do
+        hosts = @client.__extract_hosts( { :host => 'myhost', :scheme => 'https', :port => 443 } )
+        assert_equal 443, hosts[0][:port]
+      end
+
+      should "extract from Hashie::Mash" do
+        hosts = @client.__extract_hosts( Hashie::Mash.new(:host => 'myhost', :scheme => 'https') )
+        assert_equal 'myhost', hosts[0][:host]
+        assert_equal 'https',  hosts[0][:scheme]
+      end
+
+      should "extract from array" do
+        hosts = @client.__extract_hosts ['myhost']
+
+        assert_equal 'myhost', hosts[0][:host]
+      end
+
+      should "extract from array with multiple hosts" do
+        hosts = @client.__extract_hosts ['host1', 'host2']
+
+        assert_equal 'host1', hosts[0][:host]
+        assert_equal 'host2', hosts[1][:host]
+      end
+
+      should "extract from array with ports" do
+        hosts = @client.__extract_hosts ['host1:1000', 'host2:2000']
+
+        assert_equal 2, hosts.size
+
+        assert_equal 'host1', hosts[0][:host]
+        assert_equal 1000,    hosts[0][:port]
+
+        assert_equal 'host2', hosts[1][:host]
+        assert_equal 2000,    hosts[1][:port]
+      end
+
+      should "extract path" do
+        hosts = @client.__extract_hosts 'https://myhost:8080/api'
+
+        assert_equal '/api',  hosts[0][:path]
+      end
+
+      should "extract scheme (protocol)" do
+        hosts = @client.__extract_hosts 'https://myhost:8080'
+
+        assert_equal 'https',  hosts[0][:scheme]
+        assert_equal 'myhost', hosts[0][:host]
+        assert_equal 8080,     hosts[0][:port]
+      end
+
+      should "extract credentials" do
+        hosts = @client.__extract_hosts 'http://USERNAME:PASSWORD@myhost:8080'
+
+        assert_equal 'http',     hosts[0][:scheme]
+        assert_equal 'USERNAME', hosts[0][:user]
+        assert_equal 'PASSWORD', hosts[0][:password]
+        assert_equal 'myhost',   hosts[0][:host]
+        assert_equal 8080,       hosts[0][:port]
+      end
+
+      should "pass hashes over" do
+        hosts = @client.__extract_hosts [{:host => 'myhost', :port => '1000', :foo => 'bar'}]
+
+        assert_equal 'myhost', hosts[0][:host]
+        assert_equal 1000,     hosts[0][:port]
+        assert_equal 'bar',    hosts[0][:foo]
+      end
+
+      should "use URL instance" do
+        require 'uri'
+        hosts = @client.__extract_hosts URI.parse('https://USERNAME:PASSWORD@myhost:4430')
+
+        assert_equal 'https',    hosts[0][:scheme]
+        assert_equal 'USERNAME', hosts[0][:user]
+        assert_equal 'PASSWORD', hosts[0][:password]
+        assert_equal 'myhost',   hosts[0][:host]
+        assert_equal 4430,       hosts[0][:port]
+      end
+
+      should "split comma-separated URLs" do
+        hosts = @client.__extract_hosts 'foo, bar'
+
+        assert_equal 2, hosts.size
+
+        assert_equal 'foo', hosts[0][:host]
+        assert_equal 'bar', hosts[1][:host]
+      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'}]
+
+        Array.any_instance.expects(:shuffle!).twice
+
+        @client.__extract_hosts(hosts, :randomize_hosts => true)
+        assert_same_elements hosts, @client.__extract_hosts(hosts, :randomize_hosts => true)
+      end
+    end
+
+    context "detecting adapter for Faraday" do
+      setup do
+        Elasticsearch::Transport::Client::DEFAULT_TRANSPORT_CLASS.any_instance.unstub(:__build_connections)
+        begin; Object.send(:remove_const, :Typhoeus); rescue NameError; end
+        begin; Object.send(:remove_const, :Patron);   rescue NameError; end
+      end
+
+      should "use the default adapter" do
+        c = Elasticsearch::Transport::Client.new
+        handlers = c.transport.connections.all.first.connection.builder.handlers
+
+        assert_includes handlers, Faraday::Adapter::NetHttp
+      end
+
+      should "use the adapter from arguments" do
+        c = Elasticsearch::Transport::Client.new :adapter => :typhoeus
+        handlers = c.transport.connections.all.first.connection.builder.handlers
+
+        assert_includes handlers, Faraday::Adapter::Typhoeus
+      end
+
+      should "detect the adapter" do
+        require 'patron'; load 'patron.rb'
+
+        c = Elasticsearch::Transport::Client.new
+        handlers = c.transport.connections.all.first.connection.builder.handlers
+
+        assert_includes handlers, Faraday::Adapter::Patron
+      end unless JRUBY
+    end
+
+  end
+end