elasticsearch-transport 7.9.0 → 7.17.10

data/test/unit/adapters_test.rb

@@ -0,0 +1,88 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+require 'test_helper'
+
+class Elasticsearch::Transport::Transport::ClientAdaptersUnitTest < Minitest::Test
+  context 'Adapters' do
+    setup do
+      begin
+        Object.send(:remove_const, :Patron)
+      rescue NameError
+      end
+    end
+
+    should 'use the default Faraday adapter' do
+      fork do
+        client = Elasticsearch::Transport::Client.new
+        assert_equal(client.transport.connections.first.connection.adapter, Faraday::Adapter::NetHttp)
+      end
+    end
+
+    should 'use Patron Faraday adapter' do
+      fork do
+        if is_faraday_v2?
+          require 'faraday/patron'
+        else
+          require 'patron'
+        end
+
+        client = Elasticsearch::Transport::Client.new
+        assert_equal(client.transport.connections.first.connection.adapter, Faraday::Adapter::Patron)
+      end
+    end
+
+    should 'use Typhoeus Faraday adapter' do
+      fork do
+        if is_faraday_v2?
+          require 'faraday/typhoeus'
+        else
+          require 'typhoeus'
+        end
+
+        client = Elasticsearch::Transport::Client.new
+        assert_equal(client.transport.connections.first.connection.adapter, Faraday::Adapter::Typhoeus)
+      end
+    end
+
+    should 'use NetHttpPersistent Faraday adapter' do
+      fork do
+        if is_faraday_v2?
+          require 'faraday/net_http_persistent'
+        else
+          require 'net/http/persistent'
+        end
+
+        client = Elasticsearch::Transport::Client.new
+        assert_equal(client.transport.connections.first.connection.adapter, Faraday::Adapter::NetHttpPersistent)
+      end
+    end
+
+    should 'use HTTPClient Faraday adapter' do
+      fork do
+        if is_faraday_v2?
+          require 'faraday/httpclient'
+        else
+          require 'httpclient'
+        end
+
+        client = Elasticsearch::Transport::Client.new
+        assert_equal(Faraday::Adapter::HTTPClient, client.transport.connections.first.connection.adapter)
+      end
+    end
+  end unless jruby?
+end

data/test/unit/connection_test.rb

@@ -57,10 +57,15 @@ class Elasticsearch::Transport::Transport::Connections::ConnectionTest < Minites
       assert_equal 'http://localhost:9200/foo/_search?foo=bar', c.full_url('_search', {:foo => 'bar'})
     end
 
+    should "return right full url with path when path starts with /" 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
+      assert_match(/host: x/, c.to_s)
+      assert_match(/alive/,   c.to_s)
     end
 
     should "not be dead by default" do

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
@@ -429,7 +438,7 @@ class Elasticsearch::Transport::Transport::BaseTest < Minitest::Test
       @transport.stubs(:get_connection).returns(fake_connection)
 
       @transport.logger.expects(:info).with do |message|
-        assert_match /http:\/\/user:\*{1,15}@localhost\:9200/, message
+        assert_match(/http:\/\/user:\*{1,15}@localhost\:9200/, message)
         true
       end
 
@@ -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_faraday_test.rb

@@ -149,7 +149,7 @@ class Elasticsearch::Transport::Transport::HTTP::FaradayTest < Minitest::Test
 
       transport.connections.first.connection.expects(:run_request).
         with do |method, url, params, body|
-          assert_match /\?format=yaml/, url
+          assert_match(/\?format=yaml/, url)
           true
         end.
         returns(stub_everything)
@@ -167,7 +167,7 @@ class Elasticsearch::Transport::Transport::HTTP::FaradayTest < Minitest::Test
 
       transport.connections.first.connection.expects(:run_request).
         with do |method, url, params, body|
-          assert_match /\?format=json/, url
+          assert_match(/\?format=json/, url)
           true
         end.
         returns(stub_everything)

data/test/unit/transport_manticore_test.rb

@@ -17,166 +17,253 @@
 
 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/x-ndjson',
+                        '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)
+                assert_equal(transport.options[:ssl][:truststore_password], 'test')
+              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)
+                assert_equal(transport.options[:transport_options][:potatoes], 1)
+              end
+
+              context 'custom headers' do
+                should 'allow authorization 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 'allow user agent headers' do
+                  transport_options = { headers: { 'User-Agent' => 'Custom UA' } }
+                  transport = Manticore.new(
+                    hosts: [{ host: 'localhost' }],
+                    transport_options: transport_options
+                  )
+                  transport.connections.first.connection.expects(:get).with do |_host, options|
+                    assert_equal('Custom UA', options[:headers]['User-Agent'])
+                    true
+                  end.returns(stub_everything)
+                  transport.perform_request('GET', '/', {})
+
+                  assert_equal(
+                    transport.instance_variable_get('@request_options')[:headers]['User-Agent'],
+                    'Custom UA'
+                  )
+                end
+              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