elasticsearch-transport 7.13.3 → 7.16.0

data/test/test_helper.rb

@@ -20,30 +20,17 @@ ELASTICSEARCH_HOSTS = if hosts = ENV['TEST_ES_SERVER'] || ENV['ELASTICSEARCH_HOS
                         hosts.split(',').map do |host|
                           /(http\:\/\/)?(\S+)/.match(host)[2]
                         end
+                      else
+                        ['localhost:9200']
                       end.freeze
 
 TEST_HOST, TEST_PORT = ELASTICSEARCH_HOSTS.first.split(':') if ELASTICSEARCH_HOSTS
 
-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
+if ENV['COVERAGE']
   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_" }
+  SimpleCov.start { add_filter %r{^/test/} }
 end
 
 # Register `at_exit` handler for integration tests shutdown.
@@ -52,7 +39,6 @@ if defined?(RUBY_VERSION) && RUBY_VERSION > '1.9'
   at_exit { Elasticsearch::Test::IntegrationTestCase.__run_at_exit_hooks }
 end
 
-require 'test/unit' if RUBY_1_8
 require 'minitest/autorun'
 require 'minitest/reporters'
 require 'shoulda/context'
@@ -119,8 +105,7 @@ module Elasticsearch
       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
   end
 
   module Test
@@ -129,7 +114,6 @@ module Elasticsearch
       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 unless JRUBY
   end
 end

data/test/unit/response_test.rb

@@ -26,7 +26,7 @@ class Elasticsearch::Transport::Transport::ResponseTest < Minitest::Test
 
       response = Elasticsearch::Transport::Transport::Response.new 200, body
       assert_equal 'UTF-8', response.body.encoding.name
-    end unless RUBY_1_8
+    end
 
   end
 end

data/test/unit/transport_base_test.rb

@@ -263,6 +263,15 @@ class Elasticsearch::Transport::Transport::BaseTest < Minitest::Test
       end
     end
 
+    should 'raise TooManyRequestsError on 429' do
+      @transport.expects(:get_connection).returns(stub_everything :failures => 1)
+      assert_raise Elasticsearch::Transport::Transport::Errors::TooManyRequests do
+        @transport.perform_request 'GET', '/' do
+          Elasticsearch::Transport::Transport::Response.new 429, 'ERROR'
+        end
+      end
+    end
+
     should "not raise an error when the :ignore argument has been passed" do
       @transport.stubs(:get_connection).returns(stub_everything :failures => 1)
 
@@ -310,7 +319,7 @@ class Elasticsearch::Transport::Transport::BaseTest < Minitest::Test
       @transport.perform_request('GET', '/', &@block)
       assert_equal 2, @transport.counter
     end
-  end unless RUBY_1_8
+  end
 
   context "performing a request with retry on connection failures" do
     setup do
@@ -344,7 +353,7 @@ class Elasticsearch::Transport::Transport::BaseTest < Minitest::Test
         @transport.perform_request('GET', '/', &@block)
       end
     end
-  end unless RUBY_1_8
+  end
 
   context "performing a request with retry on status" do
     setup do
@@ -391,7 +400,7 @@ class Elasticsearch::Transport::Transport::BaseTest < Minitest::Test
         @transport.perform_request('GET', '/', &@block)
       end
     end
-  end  unless RUBY_1_8
+  end
 
   context "logging" do
     setup do
@@ -447,7 +456,7 @@ class Elasticsearch::Transport::Transport::BaseTest < Minitest::Test
       assert_raise Elasticsearch::Transport::Transport::Errors::InternalServerError do
         @transport.perform_request('POST', '_search', &@block)
       end
-    end unless RUBY_1_8
+    end
 
     should "not log a failed Elasticsearch request as fatal" do
       @block = Proc.new { |c, u| puts "ERROR" }
@@ -458,7 +467,7 @@ class Elasticsearch::Transport::Transport::BaseTest < Minitest::Test
 
       # No `BadRequest` error
       @transport.perform_request('POST', '_search', :ignore => 500, &@block)
-    end unless RUBY_1_8
+    end
 
     should "log and re-raise a Ruby exception" do
       @block = Proc.new { |c, u| puts "ERROR" }
@@ -468,7 +477,7 @@ class Elasticsearch::Transport::Transport::BaseTest < Minitest::Test
       @transport.logger.expects(:fatal)
 
       assert_raise(Exception) { @transport.perform_request('POST', '_search', &@block) }
-    end unless RUBY_1_8
+    end
   end
 
   context "tracing" do
@@ -522,7 +531,7 @@ class Elasticsearch::Transport::Transport::BaseTest < Minitest::Test
       assert_raise Elasticsearch::Transport::Transport::Errors::InternalServerError do
         @transport.perform_request('POST', '_search', &@block)
       end
-    end unless RUBY_1_8
+    end
 
   end
 

data/test/unit/transport_curb_test.rb

@@ -84,7 +84,6 @@ else
         @transport.connections.first.connection.expects(:http).with(:GET).returns(stub_everything)
         @transport.connections.first.connection.expects(:body_str).returns('{"foo":"bar"}')
         @transport.connections.first.connection.expects(:header_str).returns('HTTP/1.1 200 OK\r\nContent-Type: application/json; charset=UTF-8\r\nContent-Length: 311\r\n\r\n')
-
         response = @transport.perform_request 'GET', '/'
 
         assert_equal 'application/json', response.headers['content-type']

data/test/unit/transport_manticore_test.rb

@@ -17,166 +17,235 @@
 
 require 'test_helper'
 
-unless JRUBY
-  version = ( defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'Ruby' ) + ' ' + RUBY_VERSION
-  puts "SKIP: '#{File.basename(__FILE__)}' only supported on JRuby (you're running #{version})"
-else
+if JRUBY
   require 'elasticsearch/transport/transport/http/manticore'
   require 'manticore'
 
-  class Elasticsearch::Transport::Transport::HTTP::ManticoreTest < Minitest::Test
-    include Elasticsearch::Transport::Transport::HTTP
-
-    context "Manticore transport" do
-      setup do
-        @transport = Manticore.new :hosts => [ { :host => '127.0.0.1', :port => 8080 } ]
-      end
-
-      should "implement host_unreachable_exceptions" do
-        assert_instance_of Array, @transport.host_unreachable_exceptions
-      end
-
-      should "implement __build_connections" do
-        assert_equal 1, @transport.hosts.size
-        assert_equal 1, @transport.connections.size
-
-        assert_instance_of ::Manticore::Client,   @transport.connections.first.connection
-      end
-
-      should "not close connections in __close_connections" do
-        assert_equal 1, @transport.connections.size
-        @transport.__close_connections
-        assert_equal 1, @transport.connections.size
-      end
-
-      should "perform the request" do
-        @transport.connections.first.connection.expects(:get).returns(stub_everything)
-        @transport.perform_request 'GET', '/'
-      end
-
-      should "set body for GET request" do
-        @transport.connections.first.connection.expects(:get).
-          with('http://127.0.0.1:8080/', {:body => '{"foo":"bar"}',
-                                           :headers => {"Content-Type" => "application/json",
-                                                        "User-Agent" => @transport.send(:user_agent_header)}}).returns(stub_everything)
-        @transport.perform_request 'GET', '/', {}, '{"foo":"bar"}'
-      end
-
-      should "set body for PUT request" do
-        @transport.connections.first.connection.expects(:put).
-          with('http://127.0.0.1:8080/', {:body => '{"foo":"bar"}',
-                                           :headers => {"Content-Type" => "application/json",
-                                                        "User-Agent" => @transport.send(:user_agent_header)}}).returns(stub_everything)
-        @transport.perform_request 'PUT', '/', {}, {:foo => 'bar'}
-      end
-
-      should "serialize the request body" do
-        @transport.connections.first.connection.expects(:post).
-          with('http://127.0.0.1:8080/', {:body => '{"foo":"bar"}',
-                                           :headers => {"Content-Type" => "application/json",
-                                                        "User-Agent" => @transport.send(:user_agent_header)}}).returns(stub_everything)
-        @transport.perform_request 'POST', '/', {}, {'foo' => 'bar'}
-      end
-
-      should "set custom headers for PUT request" do
-        @transport.connections.first.connection.expects(:put).
-          with('http://127.0.0.1:8080/', {:body => '{"foo":"bar"}',
-                                           :headers => {"Content-Type" => "application/json",
-                                                        "User-Agent" => @transport.send(:user_agent_header)}})
-          .returns(stub_everything)
-        @transport.perform_request 'PUT', '/', {}, '{"foo":"bar"}', {"Content-Type" => "application/x-ndjson"}
-      end
-
-      should "not serialize a String request body" do
-        @transport.connections.first.connection.expects(:post).
-          with('http://127.0.0.1:8080/', {:body => '{"foo":"bar"}',
-                                           :headers => {"Content-Type" => "application/json",
-                                                        "User-Agent" => @transport.send(:user_agent_header)}}).returns(stub_everything)
-        @transport.serializer.expects(:dump).never
-        @transport.perform_request 'POST', '/', {}, '{"foo":"bar"}'
-      end
-
-      should "set application/json header" do
-        options = {
-          :headers => { "content-type" => "application/json"}
-        }
-
-        transport = Manticore.new :hosts => [ { :host => 'localhost', :port => 8080 } ], :options => options
-
-        transport.connections.first.connection.stub("http://localhost:8080/", :body => "\"\"", :headers => {"Content-Type" => "application/x-ndjson",
-                                                                                                             "User-Agent" => @transport.send(:user_agent_header)}, :code => 200 )
-
-        response = transport.perform_request 'GET', '/', {}
-        assert_equal response.status, 200
-      end
-
-      should "set headers from 'transport_options'" do
-        options = {
-          :transport_options => {
-            :headers => { "Content-Type" => "foo/bar"}
-          }
-        }
-
-        transport = Manticore.new :hosts => [ { :host => 'localhost', :port => 8080 } ], :options => options
-
-        assert_equal('foo/bar', transport.connections.first.connection.instance_variable_get(:@options)[:headers]['Content-Type'])
-        # TODO: Needs to check @request_options
-      end
-
-      should "handle HTTP methods" do
-        @transport.connections.first.connection.expects(:delete).with('http://127.0.0.1:8080/', { headers: {"Content-Type" => "application/json",
-                                                                                                             "User-Agent" => @transport.send(:user_agent_header)}}).returns(stub_everything)
-        @transport.connections.first.connection.expects(:head).with('http://127.0.0.1:8080/', { headers: {"Content-Type" => "application/json",
-                                                                                                           "User-Agent" => @transport.send(:user_agent_header)}}).returns(stub_everything)
-        @transport.connections.first.connection.expects(:get).with('http://127.0.0.1:8080/', { headers: {"Content-Type" => "application/json",
-                                                                                                          "User-Agent" => @transport.send(:user_agent_header)}}).returns(stub_everything)
-        @transport.connections.first.connection.expects(:put).with('http://127.0.0.1:8080/', { headers: {"Content-Type" => "application/json",
-                                                                                                          "User-Agent" => @transport.send(:user_agent_header)}}).returns(stub_everything)
-        @transport.connections.first.connection.expects(:post).with('http://127.0.0.1:8080/', { headers: {"Content-Type" => "application/json",
-                                                                                                           "User-Agent" => @transport.send(:user_agent_header)}}).returns(stub_everything)
-
-        %w| HEAD GET PUT POST DELETE |.each { |method| @transport.perform_request method, '/' }
-
-        assert_raise(ArgumentError) { @transport.perform_request 'FOOBAR', '/' }
-      end
-
-      should "allow to set options for Manticore" do
-        options = { :headers => {"User-Agent" => "myapp-0.0" }}
-        transport = Manticore.new :hosts => [ { :host => 'foobar', :port => 1234 } ], :options => options
-        transport.connections.first.connection
-          .expects(:get)
-          .with do |host, _options|
-            assert_equal 'myapp-0.0', _options[:headers]['User-Agent']
-            true
+  module Elasticsearch
+    module Transport
+      module Transport
+        module HTTP
+          class ManticoreTest < Minitest::Test
+            include Elasticsearch::Transport::Transport::HTTP
+
+            def common_headers
+              {
+                'Content-Type' => 'application/json',
+                'User-Agent' => @transport.send(:user_agent_header)
+              }
+            end
+
+            context 'Manticore transport' do
+              setup do
+                @transport = Manticore.new(hosts: [{ host: '127.0.0.1', port: 8080 }])
+              end
+
+              should 'implement host_unreachable_exceptions' do
+                assert_instance_of Array, @transport.host_unreachable_exceptions
+              end
+
+              should 'implement __build_connections' do
+                assert_equal 1, @transport.hosts.size
+                assert_equal 1, @transport.connections.size
+
+                assert_instance_of(::Manticore::Client, @transport.connections.first.connection)
+              end
+
+              should 'not close connections in __close_connections' do
+                assert_equal 1, @transport.connections.size
+                @transport.__close_connections
+                assert_equal 1, @transport.connections.size
+              end
+
+              should 'perform the request' do
+                @transport.connections.first.connection.expects(:get).returns(stub_everything)
+                response = @transport.perform_request('GET', '/')
+              end
+
+              should 'set body for GET request' do
+                @transport.connections.first.connection.expects(:get)
+                  .with(
+                    'http://127.0.0.1:8080/',
+                    {
+                      body: '{"foo":"bar"}',
+                      headers: common_headers
+                    }
+                  ).returns(stub_everything)
+                @transport.perform_request 'GET', '/', {}, '{"foo":"bar"}'
+              end
+
+              should 'set body for PUT request' do
+                @transport.connections.first.connection.expects(:put)
+                  .with(
+                    'http://127.0.0.1:8080/',
+                    {
+                      body: '{"foo":"bar"}',
+                      headers: {
+                        'Content-Type' => 'application/json',
+                        'User-Agent' => @transport.send(:user_agent_header)
+                      }
+                    }
+                  ).returns(stub_everything)
+                @transport.perform_request 'PUT', '/', {}, { foo: 'bar' }
+              end
+
+              should 'serialize the request body' do
+                @transport.connections.first.connection.expects(:post)
+                  .with(
+                    'http://127.0.0.1:8080/',
+                    {
+                      body: '{"foo":"bar"}',
+                      headers: {
+                        'Content-Type' => 'application/json',
+                        'User-Agent' => @transport.send(:user_agent_header)
+                      }
+                    }
+                  ).returns(stub_everything)
+                @transport.perform_request 'POST', '/', {}, { 'foo' => 'bar' }
+              end
+
+              should 'set custom headers for PUT request' do
+                @transport.connections.first.connection.expects(:put)
+                  .with(
+                    'http://127.0.0.1:8080/',
+                    {
+                      body: '{"foo":"bar"}',
+                      headers: {
+                        'Content-Type' => 'application/json',
+                        'User-Agent' => @transport.send(:user_agent_header)
+                      }
+                    }
+                  ).returns(stub_everything)
+                @transport.perform_request 'PUT', '/', {}, '{"foo":"bar"}', { 'Content-Type' => 'application/x-ndjson' }
+              end
+
+              should 'not serialize a String request body' do
+                @transport.connections.first.connection.expects(:post)
+                  .with(
+                    'http://127.0.0.1:8080/',
+                    {
+                      body: '{"foo":"bar"}',
+                      headers: {
+                        'Content-Type' => 'application/json',
+                        'User-Agent' => @transport.send(:user_agent_header)
+                      }
+                    }
+                  ).returns(stub_everything)
+                @transport.serializer.expects(:dump).never
+                @transport.perform_request 'POST', '/', {}, '{"foo":"bar"}'
+              end
+
+              should 'set application/json header' do
+                options = {
+                  headers: { 'content-type' => 'application/json' }
+                }
+
+                transport = Manticore.new(hosts: [{ host: 'localhost', port: 8080 }], options: options)
+                transport.connections.first.connection.stub(
+                  'http://localhost:8080/',
+                  body: '""',
+                  headers: {
+                    'Content-Type' => 'application/x-ndjson',
+                    'User-Agent' => @transport.send(:user_agent_header)
+                  },
+                  code: 200
+                )
+                response = transport.perform_request('GET', '/', {})
+                assert_equal response.status, 200
+              end
+
+              should "set headers from 'transport_options'" do
+                options = {
+                  transport_options: {
+                    headers: { 'Content-Type' => 'foo/bar' }
+                  }
+                }
+
+                transport = Manticore.new(hosts: [{ host: 'localhost', port: 8080 }], options: options)
+
+                assert_equal(
+                  'foo/bar',
+                  transport.connections.first.connection.instance_variable_get(:@options)[:headers]['Content-Type']
+                )
+                # TODO: Needs to check @request_options
+              end
+
+              should 'handle HTTP methods' do
+                @transport.connections.first.connection.expects(:delete).with('http://127.0.0.1:8080/', { headers: common_headers }).returns(stub_everything)
+                @transport.connections.first.connection.expects(:head).with('http://127.0.0.1:8080/', { headers: common_headers }).returns(stub_everything)
+                @transport.connections.first.connection.expects(:get).with('http://127.0.0.1:8080/', { headers: common_headers }).returns(stub_everything)
+                @transport.connections.first.connection.expects(:put).with('http://127.0.0.1:8080/', { headers: common_headers }).returns(stub_everything)
+                @transport.connections.first.connection.expects(:post).with('http://127.0.0.1:8080/', { headers: common_headers }).returns(stub_everything)
+
+                %w[HEAD GET PUT POST DELETE].each { |method| @transport.perform_request method, '/' }
+
+                assert_raise(ArgumentError) { @transport.perform_request 'FOOBAR', '/' }
+              end
+
+              should 'allow to set options for Manticore' do
+                options = { headers: { 'User-Agent' => 'myapp-0.0' } }
+                transport = Manticore.new(hosts: [{ host: 'foobar', port: 1234 }], options: options)
+                transport.connections.first.connection
+                  .expects(:get)
+                  .with do |_host, _options|
+                  assert_equal 'myapp-0.0', _options[:headers]['User-Agent']
+                  true
+                end
+                  .returns(stub_everything)
+
+                transport.perform_request 'GET', '/', {}
+              end
+
+              should 'allow to set ssl options for Manticore' do
+                options = {
+                  ssl: {
+                    truststore: 'test.jks',
+                    truststore_password: 'test',
+                    verify: false
+                  }
+                }
+
+                ::Manticore::Client.expects(:new).with(options)
+                transport = Manticore.new hosts: [{ host: 'foobar', port: 1234 }], options: options
+              end
+
+              should 'allow custom headers' do
+                transport_options = { headers: { 'Authorization' => 'Basic token' } }
+                transport = Manticore.new(
+                  hosts: [{ host: 'foobar', port: 1234 }],
+                  transport_options: transport_options
+                )
+
+                assert_equal(
+                  transport.instance_variable_get(:@request_options)[:headers]['Authorization'],
+                  'Basic token'
+                )
+                transport.connections.first.connection
+                  .expects(:get)
+                  .with do |_host, _options|
+                  assert_equal('Basic token', _options[:headers]['Authorization'])
+                  true
+                end
+                  .returns(stub_everything)
+
+                transport.perform_request('GET', '/', {})
+              end
+
+              should 'pass :transport_options to Manticore::Client' do
+                options = {
+                  transport_options: { potatoes: 1 }
+                }
+
+                ::Manticore::Client.expects(:new).with(potatoes: 1, ssl: {})
+                transport = Manticore.new(hosts: [{ host: 'foobar', port: 1234 }], options: options)
+              end
+            end
           end
-          .returns(stub_everything)
-
-        transport.perform_request 'GET', '/', {}
-      end
-
-      should "allow to set ssl options for Manticore" do
-        options = {
-          :ssl => {
-            :truststore => "test.jks",
-            :truststore_password => "test",
-            :verify => false
-          }
-        }
-
-        ::Manticore::Client.expects(:new).with(options)
-        transport = Manticore.new :hosts => [ { :host => 'foobar', :port => 1234 } ], :options => options
-      end
-
-      should "pass :transport_options to Manticore::Client" do
-        options = {
-          :transport_options => { :potatoes => 1 }
-        }
-
-        ::Manticore::Client.expects(:new).with(:potatoes => 1, :ssl => {})
-        transport = Manticore.new :hosts => [ { :host => 'foobar', :port => 1234 } ], :options => options
+        end
       end
     end
-
   end
-
+else
+  version = "#{defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'Ruby'} #{RUBY_VERSION}"
+  puts "SKIP: '#{File.basename(__FILE__)}' only supported on JRuby (you're running #{version})"
 end