elasticsearch-transport 7.5.0 → 7.17.10

data/spec/elasticsearch/transport/client_spec.rb

@@ -1,21 +1,29 @@
-# Licensed to Elasticsearch B.V under one or more agreements.
-# Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
-# See the LICENSE file in the project root for more information
+# 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 'spec_helper'
 
 describe Elasticsearch::Transport::Client do
-
   let(:client) do
     described_class.new.tap do |_client|
       allow(_client).to receive(:__build_connections)
     end
   end
 
-  it 'is aliased as Elasticsearch::Client' do
-    expect(Elasticsearch::Client.new).to be_a(described_class)
-  end
-
   it 'has a default transport' do
     expect(client.transport).to be_a(Elasticsearch::Transport::Client::DEFAULT_TRANSPORT_CLASS)
   end
@@ -49,7 +57,6 @@ describe Elasticsearch::Transport::Client do
   end
 
   context 'when a User-Agent header is specified as client option' do
-
     let(:client) do
       described_class.new(transport_options: { headers: { 'User-Agent' => 'testing' } })
     end
@@ -59,6 +66,49 @@ describe Elasticsearch::Transport::Client do
     end
   end
 
+  context 'when an encoded api_key is provided' do
+    let(:client) do
+      described_class.new(api_key: 'an_api_key')
+    end
+    let(:authorization_header) do
+      client.transport.connections.first.connection.headers['Authorization']
+    end
+
+    it 'Adds the ApiKey header to the connection' do
+      expect(authorization_header).to eq('ApiKey an_api_key')
+    end
+  end
+
+  context 'when an un-encoded api_key is provided' do
+    let(:client) do
+      described_class.new(api_key: { id: 'my_id', api_key: 'my_api_key' })
+    end
+    let(:authorization_header) do
+      client.transport.connections.first.connection.headers['Authorization']
+    end
+
+    it 'Adds the ApiKey header to the connection' do
+      expect(authorization_header).to eq("ApiKey #{Base64.strict_encode64('my_id:my_api_key')}")
+    end
+  end
+
+  context 'when basic auth and api_key are provided' do
+    let(:client) do
+      described_class.new(
+        api_key: { id: 'my_id', api_key: 'my_api_key' },
+        host: 'http://elastic:password@localhost:9200'
+      )
+    end
+    let(:authorization_header) do
+      client.transport.connections.first.connection.headers['Authorization']
+    end
+
+    it 'removes basic auth credentials' do
+      expect(authorization_header).not_to match(/^Basic/)
+      expect(authorization_header).to match(/^ApiKey/)
+    end
+  end
+
   context 'when a user-agent header is specified as client option in lower-case' do
 
     let(:client) do
@@ -176,47 +226,61 @@ describe Elasticsearch::Transport::Client do
   end
 
   describe 'adapter' do
-
     context 'when no adapter is specified' do
+      fork do
+        let(:client) { described_class.new }
+        let(:adapter) { client.transport.connections.all.first.connection.builder.adapter }
 
+        it 'uses Faraday NetHttp' do
+          expect(adapter).to eq Faraday::Adapter::NetHttp
+        end
+      end
+    end unless jruby?
+
+    context 'when the adapter is patron' do
       let(:adapter) do
-        client.transport.connections.all.first.connection.builder.handlers
+        client.transport.connections.all.first.connection.builder.adapter
       end
 
-      it 'uses Faraday NetHttp' do
-        expect(adapter).to include(Faraday::Adapter::NetHttp)
+      let(:client) do
+        described_class.new(adapter: :patron, enable_meta_header: false)
       end
-    end
 
-    context 'when the adapter is specified' do
+      it 'uses Faraday with the adapter' do
+        require 'faraday/patron'
+        expect(adapter).to eq Faraday::Adapter::Patron
+      end
+    end unless jruby?
 
+    context 'when the adapter is typhoeus' do
       let(:adapter) do
-        client.transport.connections.all.first.connection.builder.handlers
+        client.transport.connections.all.first.connection.builder.adapter
       end
 
       let(:client) do
-        described_class.new(adapter: :typhoeus)
+        require 'faraday/typhoeus' if is_faraday_v2?
+
+        described_class.new(adapter: :typhoeus, enable_meta_header: false)
       end
 
       it 'uses Faraday with the adapter' do
-        expect(adapter).to include(Faraday::Adapter::Typhoeus)
+        expect(adapter).to eq Faraday::Adapter::Typhoeus
       end
-    end
+    end unless jruby?
 
     context 'when the adapter is specified as a string key' do
-
       let(:adapter) do
-        client.transport.connections.all.first.connection.builder.handlers
+        client.transport.connections.all.first.connection.builder.adapter
       end
 
       let(:client) do
-        described_class.new('adapter' => :typhoeus)
+        described_class.new(adapter: :patron, enable_meta_header: false)
       end
 
       it 'uses Faraday with the adapter' do
-        expect(adapter).to include(Faraday::Adapter::Typhoeus)
+        expect(adapter).to eq Faraday::Adapter::Patron
       end
-    end
+    end unless jruby?
 
     context 'when the adapter can be detected', unless: jruby? do
 
@@ -226,11 +290,11 @@ describe Elasticsearch::Transport::Client do
       end
 
       let(:adapter) do
-        client.transport.connections.all.first.connection.builder.handlers
+        client.transport.connections.all.first.connection.builder.adapter
       end
 
       it 'uses the detected adapter' do
-        expect(adapter).to include(Faraday::Adapter::Patron)
+        expect(adapter).to eq Faraday::Adapter::Patron
       end
     end
 
@@ -238,29 +302,37 @@ describe Elasticsearch::Transport::Client do
 
       let(:client) do
         described_class.new do |faraday|
-          faraday.adapter :typhoeus
+          faraday.adapter :patron
           faraday.response :logger
         end
       end
 
+      let(:adapter) do
+        client.transport.connections.all.first.connection.builder.adapter
+      end
+
       let(:handlers) do
         client.transport.connections.all.first.connection.builder.handlers
       end
 
       it 'sets the adapter' do
-        expect(handlers).to include(Faraday::Adapter::Typhoeus)
+        expect(adapter).to eq Faraday::Adapter::Patron
       end
 
       it 'sets the logger' do
         expect(handlers).to include(Faraday::Response::Logger)
       end
-    end
+    end unless jruby?
   end
 
   context 'when cloud credentials are provided' do
 
     let(:client) do
-      described_class.new(cloud_id: 'name:bG9jYWxob3N0JGFiY2QkZWZnaA==', user: 'elastic', password: 'changeme')
+      described_class.new(
+        cloud_id: 'name:bG9jYWxob3N0JGFiY2QkZWZnaA==',
+        user: 'elastic',
+        password: 'changeme'
+      )
     end
 
     let(:hosts) do
@@ -272,17 +344,19 @@ describe Elasticsearch::Transport::Client do
       expect(hosts[0][:protocol]).to eq('https')
       expect(hosts[0][:user]).to eq('elastic')
       expect(hosts[0][:password]).to eq('changeme')
-      expect(hosts[0][:port]).to eq(9243)
+      expect(hosts[0][:port]).to eq(443)
     end
 
     it 'creates the correct full url' do
-      expect(client.transport.__full_url(client.transport.hosts[0])).to eq('https://elastic:changeme@abcd.localhost:9243')
+      expect(
+        client.transport.__full_url(client.transport.hosts[0])
+      ).to eq('https://elastic:changeme@abcd.localhost:443')
     end
 
     context 'when a port is specified' do
 
       let(:client) do
-        described_class.new(cloud_id: 'name:bG9jYWxob3N0JGFiY2QkZWZnaA==', user: 'elastic', password: 'changeme', port: 9200 )
+        described_class.new(cloud_id: 'name:bG9jYWxob3N0JGFiY2QkZWZnaA==', user: 'elastic', password: 'changeme', port: 9250)
       end
 
       it 'sets the specified port along with the cloud credentials' do
@@ -290,18 +364,22 @@ describe Elasticsearch::Transport::Client do
         expect(hosts[0][:protocol]).to eq('https')
         expect(hosts[0][:user]).to eq('elastic')
         expect(hosts[0][:password]).to eq('changeme')
-        expect(hosts[0][:port]).to eq(9200)
+        expect(hosts[0][:port]).to eq(9250)
       end
 
       it 'creates the correct full url' do
-        expect(client.transport.__full_url(client.transport.hosts[0])).to eq('https://elastic:changeme@abcd.localhost:9200')
+        expect(client.transport.__full_url(client.transport.hosts[0])).to eq('https://elastic:changeme@abcd.localhost:9250')
       end
     end
 
     context 'when the cluster has alternate names' do
 
       let(:client) do
-        described_class.new(cloud_id: 'myCluster:bG9jYWxob3N0JGFiY2QkZWZnaA==', user: 'elasticfantastic', password: 'tobechanged')
+        described_class.new(
+          cloud_id: 'myCluster:bG9jYWxob3N0JGFiY2QkZWZnaA==',
+          user: 'elasticfantastic',
+          password: 'tobechanged'
+        )
       end
 
       let(:hosts) do
@@ -313,124 +391,334 @@ describe Elasticsearch::Transport::Client do
         expect(hosts[0][:protocol]).to eq('https')
         expect(hosts[0][:user]).to eq('elasticfantastic')
         expect(hosts[0][:password]).to eq('tobechanged')
-        expect(hosts[0][:port]).to eq(9243)
+        expect(hosts[0][:port]).to eq(443)
       end
 
       it 'creates the correct full url' do
-        expect(client.transport.__full_url(client.transport.hosts[0])).to eq('https://elasticfantastic:tobechanged@abcd.localhost:9243')
+        expect(
+          client.transport.__full_url(client.transport.hosts[0])
+        ).to eq('https://elasticfantastic:tobechanged@abcd.localhost:443')
       end
-
     end
-  end
 
-  shared_examples_for 'a client that extracts hosts' do
+    context 'when decoded cloud id has a trailing dollar sign' do
+      let(:client) do
+        described_class.new(
+          cloud_id: 'a_cluster:bG9jYWxob3N0JGFiY2Qk',
+          user: 'elasticfantastic',
+          password: 'changeme'
+        )
+      end
 
-    context 'when the hosts are a String' do
+      let(:hosts) do
+        client.transport.hosts
+      end
 
-      let(:host) do
-        'myhost'
+      it 'extracts the cloud credentials' do
+        expect(hosts[0][:host]).to eq('abcd.localhost')
+        expect(hosts[0][:protocol]).to eq('https')
+        expect(hosts[0][:user]).to eq('elasticfantastic')
+        expect(hosts[0][:password]).to eq('changeme')
+        expect(hosts[0][:port]).to eq(443)
       end
 
-      it 'extracts the host' do
-        expect(hosts[0][:host]).to eq('myhost')
-        expect(hosts[0][:protocol]).to eq('http')
-        expect(hosts[0][:port]).to be(9200)
+      it 'creates the correct full url' do
+        expect(
+          client.transport.__full_url(client.transport.hosts[0])
+        ).to eq('https://elasticfantastic:changeme@abcd.localhost:443')
       end
+    end
 
-      context 'when IPv6 format is used' do
+    context 'when the cloud host provides a port' do
+      let(:client) do
+        described_class.new(
+          cloud_id: 'name:ZWxhc3RpY19zZXJ2ZXI6OTI0MyRlbGFzdGljX2lk',
+          user: 'elastic',
+          password: 'changeme'
+        )
+      end
 
-        around do |example|
-          original_setting = Faraday.ignore_env_proxy
-          Faraday.ignore_env_proxy = true
-          example.run
-          Faraday.ignore_env_proxy = original_setting
-        end
+      let(:hosts) do
+        client.transport.hosts
+      end
 
-        let(:host) do
-          'https://[2090:db8:85a3:9811::1f]:8080'
-        end
+      it 'creates the correct full url' do
+        expect(hosts[0][:host]).to eq('elastic_id.elastic_server')
+        expect(hosts[0][:protocol]).to eq('https')
+        expect(hosts[0][:user]).to eq('elastic')
+        expect(hosts[0][:password]).to eq('changeme')
+        expect(hosts[0][:port]).to eq(9243)
+      end
+    end
 
-        it 'extracts the host' do
-          expect(hosts[0][:host]).to eq('[2090:db8:85a3:9811::1f]')
-          expect(hosts[0][:scheme]).to eq('https')
-          expect(hosts[0][:port]).to be(8080)
-        end
+    context 'when the cloud host provides a port and the port is also specified' do
+      let(:client) do
+        described_class.new(
+          cloud_id: 'name:ZWxhc3RpY19zZXJ2ZXI6OTI0MyRlbGFzdGljX2lk',
+          user: 'elastic',
+          password: 'changeme',
+          port: 9200
+        )
+      end
 
-        it 'creates the correct full url' do
-          expect(client.transport.__full_url(client.transport.hosts[0])).to eq('https://[2090:db8:85a3:9811::1f]:8080')
-        end
+      let(:hosts) do
+        client.transport.hosts
+      end
+
+      it 'creates the correct full url' do
+        expect(hosts[0][:host]).to eq('elastic_id.elastic_server')
+        expect(hosts[0][:protocol]).to eq('https')
+        expect(hosts[0][:user]).to eq('elastic')
+        expect(hosts[0][:password]).to eq('changeme')
+        expect(hosts[0][:port]).to eq(9243)
       end
+    end
+  end
 
-      context 'when a path is specified' do
+  shared_examples_for 'a client that extracts hosts' do
 
-        let(:host) do
-          'https://myhost:8080/api'
-        end
+    context 'when the host is a String' do
 
-        it 'extracts the host' do
-          expect(hosts[0][:host]).to eq('myhost')
-          expect(hosts[0][:scheme]).to eq('https')
-          expect(hosts[0][:path]).to eq('/api')
-          expect(hosts[0][:port]).to be(8080)
-        end
-      end
+      context 'when there is a protocol specified' do
 
-      context 'when a scheme is specified' do
+        context 'when credentials are specified \'http://USERNAME:PASSWORD@myhost:8080\'' do
 
-        let(:host) do
-          'https://myhost:8080'
-        end
+          let(:host) do
+            'http://USERNAME:PASSWORD@myhost:8080'
+          end
 
-        it 'extracts the host' do
-          expect(hosts[0][:host]).to eq('myhost')
-          expect(hosts[0][:scheme]).to eq('https')
-          expect(hosts[0][:port]).to be(8080)
+          it 'extracts the credentials' do
+            expect(hosts[0][:user]).to eq('USERNAME')
+            expect(hosts[0][:password]).to eq('PASSWORD')
+          end
+
+          it 'extracts the host' do
+            expect(hosts[0][:host]).to eq('myhost')
+          end
+
+          it 'extracts the port' do
+            expect(hosts[0][:port]).to be(8080)
+          end
         end
-      end
 
-      context 'when credentials are specified' do
+        context 'when there is a trailing slash \'http://myhost/\'' do
 
-        let(:host) do
-          'http://USERNAME:PASSWORD@myhost:8080'
+          let(:host) do
+            'http://myhost/'
+          end
+
+          it 'extracts the host' do
+            expect(hosts[0][:host]).to eq('myhost')
+            expect(hosts[0][:scheme]).to eq('http')
+            expect(hosts[0][:path]).to eq('')
+          end
+
+          it 'extracts the scheme' do
+            expect(hosts[0][:scheme]).to eq('http')
+          end
+
+          it 'extracts the path' do
+            expect(hosts[0][:path]).to eq('')
+          end
         end
 
-        it 'extracts the host' do
-          expect(hosts[0][:host]).to eq('myhost')
-          expect(hosts[0][:scheme]).to eq('http')
-          expect(hosts[0][:user]).to eq('USERNAME')
-          expect(hosts[0][:password]).to eq('PASSWORD')
-          expect(hosts[0][:port]).to be(8080)
+        context 'when there is a trailing slash with a path \'http://myhost/foo/bar/\'' do
+
+          let(:host) do
+            'http://myhost/foo/bar/'
+          end
+
+          it 'extracts the host' do
+            expect(hosts[0][:host]).to eq('myhost')
+            expect(hosts[0][:scheme]).to eq('http')
+            expect(hosts[0][:path]).to eq('/foo/bar')
+          end
         end
-      end
 
-      context 'when there is a trailing slash' do
+        context 'when the protocol is http' do
 
-        let(:host) do
-          'http://myhost/'
+          context 'when there is no port specified \'http://myhost\'' do
+
+            let(:host) do
+              'http://myhost'
+            end
+
+            it 'extracts the host' do
+              expect(hosts[0][:host]).to eq('myhost')
+            end
+
+            it 'extracts the protocol' do
+              expect(hosts[0][:protocol]).to eq('http')
+            end
+
+            it 'defaults to port 9200' do
+              expect(hosts[0][:port]).to be(9200)
+            end
+          end
+
+          context 'when there is a port specified \'http://myhost:7101\'' do
+
+            let(:host) do
+              'http://myhost:7101'
+            end
+
+            it 'extracts the host' do
+              expect(hosts[0][:host]).to eq('myhost')
+            end
+
+            it 'extracts the protocol' do
+              expect(hosts[0][:protocol]).to eq('http')
+            end
+
+            it 'extracts the port' do
+              expect(hosts[0][:port]).to be(7101)
+            end
+
+            context 'when there is a path specified \'http://myhost:7101/api\'' do
+
+              let(:host) do
+                'http://myhost:7101/api'
+              end
+
+              it 'sets the path' do
+                expect(hosts[0][:host]).to eq('myhost')
+                expect(hosts[0][:protocol]).to eq('http')
+                expect(hosts[0][:path]).to eq('/api')
+                expect(hosts[0][:port]).to be(7101)
+              end
+
+              it 'extracts the host' do
+                expect(hosts[0][:host]).to eq('myhost')
+              end
+
+              it 'extracts the protocol' do
+                expect(hosts[0][:protocol]).to eq('http')
+              end
+
+              it 'extracts the port' do
+                expect(hosts[0][:port]).to be(7101)
+              end
+
+              it 'extracts the path' do
+                expect(hosts[0][:path]).to eq('/api')
+              end
+            end
+          end
         end
 
-        it 'extracts the host' do
-          expect(hosts[0][:host]).to eq('myhost')
-          expect(hosts[0][:scheme]).to eq('http')
-          expect(hosts[0][:path]).to eq('')
+        context 'when the protocol is https' do
+
+          context 'when there is no port specified \'https://myhost\'' do
+
+            let(:host) do
+              'https://myhost'
+            end
+
+            it 'extracts the host' do
+              expect(hosts[0][:host]).to eq('myhost')
+            end
+
+            it 'extracts the protocol' do
+              expect(hosts[0][:protocol]).to eq('https')
+            end
+
+            it 'defaults to port 443' do
+              expect(hosts[0][:port]).to be(443)
+            end
+          end
+
+          context 'when there is a port specified \'https://myhost:7101\'' do
+
+            let(:host) do
+              'https://myhost:7101'
+            end
+
+            it 'extracts the host' do
+              expect(hosts[0][:host]).to eq('myhost')
+            end
+
+            it 'extracts the protocol' do
+              expect(hosts[0][:protocol]).to eq('https')
+            end
+
+            it 'extracts the port' do
+              expect(hosts[0][:port]).to be(7101)
+            end
+
+            context 'when there is a path specified \'https://myhost:7101/api\'' do
+
+              let(:host) do
+                'https://myhost:7101/api'
+              end
+
+              it 'extracts the host' do
+                expect(hosts[0][:host]).to eq('myhost')
+              end
+
+              it 'extracts the protocol' do
+                expect(hosts[0][:protocol]).to eq('https')
+              end
+
+              it 'extracts the port' do
+                expect(hosts[0][:port]).to be(7101)
+              end
+
+              it 'extracts the path' do
+                expect(hosts[0][:path]).to eq('/api')
+              end
+            end
+          end
+
+          context 'when IPv6 format is used' do
+
+            around do |example|
+              original_setting = Faraday.ignore_env_proxy
+              Faraday.ignore_env_proxy = true
+              example.run
+              Faraday.ignore_env_proxy = original_setting
+            end
+
+            let(:host) do
+              'https://[2090:db8:85a3:9811::1f]:8080'
+            end
+
+            it 'extracts the host' do
+              expect(hosts[0][:host]).to eq('[2090:db8:85a3:9811::1f]')
+            end
+
+            it 'extracts the protocol' do
+              expect(hosts[0][:protocol]).to eq('https')
+            end
+
+            it 'extracts the port' do
+              expect(hosts[0][:port]).to be(8080)
+            end
+
+            it 'creates the correct full url' do
+              expect(client.transport.__full_url(client.transport.hosts[0])).to eq('https://[2090:db8:85a3:9811::1f]:8080')
+            end
+          end
         end
       end
 
-      context 'when there is a trailing slash with a path' do
+      context 'when no protocol is specified \'myhost\'' do
 
         let(:host) do
-          'http://myhost/foo/bar/'
+          'myhost'
         end
 
-        it 'extracts the host' do
+        it 'defaults to http' do
           expect(hosts[0][:host]).to eq('myhost')
-          expect(hosts[0][:scheme]).to eq('http')
-          expect(hosts[0][:path]).to eq('/foo/bar')
+          expect(hosts[0][:protocol]).to eq('http')
+        end
+
+        it 'uses port 9200' do
+          expect(hosts[0][:port]).to be(9200)
         end
       end
     end
 
-    context 'when the hosts are a Hash' do
+    context 'when the host is a Hash' do
 
       let(:host) do
         { :host => 'myhost', :scheme => 'https' }
@@ -438,7 +726,13 @@ describe Elasticsearch::Transport::Client do
 
       it 'extracts the host' do
         expect(hosts[0][:host]).to eq('myhost')
-        expect(hosts[0][:scheme]).to eq('https')
+      end
+
+      it 'extracts the protocol' do
+        expect(hosts[0][:protocol]).to eq('https')
+      end
+
+      it 'extracts the port' do
         expect(hosts[0][:port]).to be(9200)
       end
 
@@ -497,7 +791,13 @@ describe Elasticsearch::Transport::Client do
 
         it 'extracts the host' do
           expect(hosts[0][:host]).to eq('myhost')
+        end
+
+        it 'extracts the protocol' do
           expect(hosts[0][:scheme]).to eq('https')
+        end
+
+        it 'converts the port to an integer' do
           expect(hosts[0][:port]).to be(443)
         end
       end
@@ -510,7 +810,13 @@ describe Elasticsearch::Transport::Client do
 
         it 'extracts the host' do
           expect(hosts[0][:host]).to eq('myhost')
+        end
+
+        it 'extracts the protocol' do
           expect(hosts[0][:scheme]).to eq('https')
+        end
+
+        it 'extracts port as an integer' do
           expect(hosts[0][:port]).to be(443)
         end
       end
@@ -524,7 +830,13 @@ describe Elasticsearch::Transport::Client do
 
       it 'extracts the host' do
         expect(hosts[0][:host]).to eq('myhost')
+      end
+
+      it 'extracts the protocol' do
         expect(hosts[0][:scheme]).to eq('https')
+      end
+
+      it 'converts the port to an integer' do
         expect(hosts[0][:port]).to be(9200)
       end
 
@@ -536,7 +848,13 @@ describe Elasticsearch::Transport::Client do
 
         it 'extracts the host' do
           expect(hosts[0][:host]).to eq('myhost')
+        end
+
+        it 'extracts the protocol' do
           expect(hosts[0][:scheme]).to eq('https')
+        end
+
+        it 'converts the port to an integer' do
           expect(hosts[0][:port]).to be(443)
         end
       end
@@ -549,7 +867,13 @@ describe Elasticsearch::Transport::Client do
 
         it 'extracts the host' do
           expect(hosts[0][:host]).to eq('myhost')
+        end
+
+        it 'extracts the protocol' do
           expect(hosts[0][:scheme]).to eq('https')
+        end
+
+        it 'extracts port as an integer' do
           expect(hosts[0][:port]).to be(443)
         end
       end
@@ -565,7 +889,13 @@ describe Elasticsearch::Transport::Client do
 
         it 'extracts the host' do
           expect(hosts[0][:host]).to eq('myhost')
+        end
+
+        it 'extracts the protocol' do
           expect(hosts[0][:protocol]).to eq('http')
+        end
+
+        it 'defaults to port 9200' do
           expect(hosts[0][:port]).to be(9200)
         end
       end
@@ -578,20 +908,13 @@ describe Elasticsearch::Transport::Client do
 
         it 'extracts the host' do
           expect(hosts[0][:host]).to eq('myhost')
-          expect(hosts[0][:protocol]).to eq('http')
-          expect(hosts[0][:port]).to be(9200)
         end
-      end
-
-      context 'when there is one host with a protocol and no port' do
 
-        let(:host) do
-          ['http://myhost']
+        it 'extracts the protocol' do
+          expect(hosts[0][:scheme]).to eq('http')
         end
 
-        it 'extracts the host' do
-          expect(hosts[0][:host]).to eq('myhost')
-          expect(hosts[0][:protocol]).to eq('http')
+        it 'defaults to port 9200' do
           expect(hosts[0][:port]).to be(9200)
         end
       end
@@ -616,7 +939,7 @@ describe Elasticsearch::Transport::Client do
         end
       end
 
-      context 'when there is one host with a scheme, protocol and no port' do
+      context 'when there is one host with a protocol and no port' do
 
         let(:host) do
           ['https://myhost']
@@ -624,12 +947,18 @@ describe Elasticsearch::Transport::Client do
 
         it 'extracts the host' do
           expect(hosts[0][:host]).to eq('myhost')
-          expect(hosts[0][:protocol]).to eq('https')
-          expect(hosts[0][:port]).to be(9200)
+        end
+
+        it 'extracts the protocol' do
+          expect(hosts[0][:scheme]).to eq('https')
+        end
+
+        it 'defaults to port 443' do
+          expect(hosts[0][:port]).to be(443)
         end
       end
 
-      context 'when there is one host with a scheme, protocol, path, and no port' do
+      context 'when there is one host with a protocol, path, and no port' do
 
         let(:host) do
           ['http://myhost/foo/bar']
@@ -637,9 +966,18 @@ describe Elasticsearch::Transport::Client do
 
         it 'extracts the host' do
           expect(hosts[0][:host]).to eq('myhost')
-          expect(hosts[0][:protocol]).to eq('http')
+        end
+
+        it 'extracts the protocol' do
+          expect(hosts[0][:scheme]).to eq('http')
+        end
+
+        it 'defaults to port 9200' do
           expect(hosts[0][:port]).to be(9200)
-          expect(hosts[0][:path]).to eq("/foo/bar")
+        end
+
+        it 'extracts the path' do
+          expect(hosts[0][:path]).to eq('/foo/bar')
         end
       end
 
@@ -649,7 +987,7 @@ describe Elasticsearch::Transport::Client do
           ['host1', 'host2']
         end
 
-        it 'extracts the host' do
+        it 'extracts the hosts' do
           expect(hosts[0][:host]).to eq('host1')
           expect(hosts[0][:protocol]).to eq('http')
           expect(hosts[0][:port]).to be(9200)
@@ -665,7 +1003,7 @@ describe Elasticsearch::Transport::Client do
           ['host1:1000', 'host2:2000']
         end
 
-        it 'extracts the host' do
+        it 'extracts the hosts' do
           expect(hosts[0][:host]).to eq('host1')
           expect(hosts[0][:protocol]).to eq('http')
           expect(hosts[0][:port]).to be(1000)
@@ -1055,10 +1393,130 @@ describe Elasticsearch::Transport::Client do
         expect(request).to be(true)
       end
     end
+
+    context 'when x-opaque-id is set' do
+      let(:client) { described_class.new(host: hosts) }
+
+      it 'uses x-opaque-id on a request' do
+        expect(client.perform_request('GET', '/', { opaque_id: '12345' }).headers['x-opaque-id']).to eq('12345')
+      end
+    end
+
+    context 'when an x-opaque-id prefix is set on initialization' do
+      let(:prefix) { 'elastic_cloud' }
+      let(:client) do
+        described_class.new(host: hosts, opaque_id_prefix: prefix)
+      end
+
+      it 'uses x-opaque-id on a request' do
+        expect(client.perform_request('GET', '/', { opaque_id: '12345' }).headers['x-opaque-id']).to eq("#{prefix}12345")
+      end
+
+      context 'when using an API call' do
+        let(:client) { described_class.new(host: hosts) }
+
+        it 'doesnae raise an ArgumentError' do
+          expect { client.perform_request('GET', '_search', opaque_id: 'no_error') }.not_to raise_error
+        end
+
+        it 'uses X-Opaque-Id in the header' do
+          allow(client).to receive(:perform_request) { OpenStruct.new(body: '') }
+          expect { client.perform_request('GET', '_search', {}, nil, opaque_id: 'opaque_id') }.not_to raise_error
+          expect(client).to have_received(:perform_request)
+                              .with('GET', '_search', {}, nil, { opaque_id: 'opaque_id' })
+        end
+      end
+    end
+
+    context 'when using the API Compatibility Header' do
+      it 'sets the API compatibility headers' do
+        ENV['ELASTIC_CLIENT_APIVERSIONING'] = 'true'
+        client = described_class.new(host: hosts)
+        headers = client.transport.connections.first.connection.headers
+
+        expect(headers['Content-Type']).to eq('application/vnd.elasticsearch+json; compatible-with=7')
+        expect(headers['Accept']).to eq('application/vnd.elasticsearch+json; compatible-with=7')
+
+        ENV.delete('ELASTIC_CLIENT_APIVERSIONING')
+      end
+
+      it 'does not use API compatibility headers' do
+        val = ENV.delete('ELASTIC_CLIENT_APIVERSIONING')
+        client = described_class.new(host: hosts)
+        expect(client.transport.connections.first.connection.headers['Content-Type']).to eq('application/json')
+        ENV['ELASTIC_CLIENT_APIVERSIONING'] = val
+      end
+
+      it 'does not use API compatibility headers when it is set to unsupported values' do
+        val = ENV.delete('ELASTIC_CLIENT_APIVERSIONING')
+
+        ENV['ELASTIC_CLIENT_APIVERSIONING'] = 'test'
+        client = described_class.new(host: hosts)
+        expect(client.transport.connections.first.connection.headers['Content-Type']).to eq('application/json')
+
+        ENV['ELASTIC_CLIENT_APIVERSIONING'] = 'false'
+        client = described_class.new(host: hosts)
+        expect(client.transport.connections.first.connection.headers['Content-Type']).to eq('application/json')
+
+        ENV['ELASTIC_CLIENT_APIVERSIONING'] = '3'
+        client = described_class.new(host: hosts)
+        expect(client.transport.connections.first.connection.headers['Content-Type']).to eq('application/json')
+        ENV['ELASTIC_CLIENT_APIVERSIONING'] = val
+      end
+    end
+
+    context 'when Elasticsearch response includes a warning header' do
+      let(:logger) { double('logger', warn: '', warn?: '', info?: '', info: '', debug?: '', debug: '') }
+      let(:client) do
+        Elasticsearch::Transport::Client.new(hosts: hosts, logger: logger)
+      end
+
+      let(:warning) { 'Elasticsearch warning: "deprecation warning"' }
+
+      it 'prints a warning' do
+        expect_any_instance_of(Faraday::Connection).to receive(:run_request) do
+          Elasticsearch::Transport::Transport::Response.new(200, {}, { 'warning' => warning })
+        end
+        client.perform_request('GET', '/')
+        expect(logger).to have_received(:warn).with(warning)
+      end
+    end
+
+    context 'when a header is set on an endpoint request' do
+      let(:client) { described_class.new(host: hosts) }
+      let(:headers) { { 'user-agent' => 'my ruby app' } }
+
+      it 'performs the request with the header' do
+        allow(client).to receive(:perform_request) { OpenStruct.new(body: '') }
+        expect { client.perform_request('GET', '_search', {}, nil, headers) }.not_to raise_error
+        expect(client).to have_received(:perform_request)
+                            .with('GET', '_search', {}, nil, headers)
+      end
+    end
+
+    context 'when a header is set on an endpoint request and on initialization' do
+      let!(:client) do
+        described_class.new(
+          host: hosts,
+          transport_options: { headers: instance_headers }
+        )
+      end
+      let(:instance_headers) { { set_in_instantiation: 'header value' } }
+      let(:param_headers) { {'user-agent' => 'My Ruby Tests', 'set-on-method-call' => 'header value'} }
+
+      it 'performs the request with the header' do
+        expected_headers = client.transport.connections.connections.first.connection.headers.merge(param_headers)
+
+        expect_any_instance_of(Faraday::Connection)
+          .to receive(:run_request)
+                .with(:get, "http://#{hosts[0]}/_search", nil, expected_headers) { OpenStruct.new(body: '')}
+
+        client.perform_request('GET', '_search', {}, nil, param_headers)
+      end
+    end
   end
 
   context 'when the client connects to Elasticsearch' do
-
     let(:logger) do
       Logger.new(STDERR).tap do |logger|
         logger.formatter = proc do |severity, datetime, progname, msg|
@@ -1090,7 +1548,6 @@ describe Elasticsearch::Transport::Client do
     end
 
     context 'when a request is made' do
-
       let!(:response) do
         client.perform_request('GET', '_cluster/health')
       end
@@ -1101,9 +1558,7 @@ describe Elasticsearch::Transport::Client do
     end
 
     describe '#initialize' do
-
       context 'when options are specified' do
-
         let(:transport_options) do
           { headers: { accept: 'application/yaml', content_type: 'application/yaml' } }
         end
@@ -1119,9 +1574,8 @@ describe Elasticsearch::Transport::Client do
       end
 
       context 'when a block is provided' do
-
         let(:client) do
-          Elasticsearch::Client.new(host: ELASTICSEARCH_HOSTS.first, logger: logger) do |client|
+          described_class.new(host: ELASTICSEARCH_HOSTS.first, logger: logger) do |client|
             client.headers['Accept'] = 'application/yaml'
           end
         end
@@ -1136,15 +1590,16 @@ describe Elasticsearch::Transport::Client do
         end
 
         context 'when the Faraday adapter is set in the block' do
+          require 'faraday/net_http_persistent' if is_faraday_v2?
 
           let(:client) do
-            Elasticsearch::Client.new(host: ELASTICSEARCH_HOSTS.first, logger: logger) do |client|
+            described_class.new(host: ELASTICSEARCH_HOSTS.first, logger: logger) do |client|
               client.adapter(:net_http_persistent)
             end
           end
 
-          let(:connection_handler) do
-            client.transport.connections.first.connection.builder.handlers.first
+          let(:handler_name) do
+            client.transport.connections.first.connection.builder.adapter.name
           end
 
           let(:response) do
@@ -1152,7 +1607,7 @@ describe Elasticsearch::Transport::Client do
           end
 
           it 'sets the adapter' do
-            expect(connection_handler.name).to eq('Faraday::Adapter::NetHttpPersistent')
+            expect(handler_name).to eq('Faraday::Adapter::NetHttpPersistent')
           end
 
           it 'uses the adapter to connect' do
@@ -1202,7 +1657,30 @@ describe Elasticsearch::Transport::Client do
           expect(client.perform_request('GET', '_nodes/_local'))
           expect {
             client.perform_request('GET', '_nodes/_local')
-          }.to raise_exception(Faraday::Error::ConnectionFailed)
+          }.to raise_exception(Faraday::ConnectionFailed)
+        end
+      end
+
+      context 'when retry_on_failure is true and delay_on_retry is specified' do
+        context 'when a node is unreachable' do
+          let(:hosts) do
+            [ELASTICSEARCH_HOSTS.first, "foobar1", "foobar2"]
+          end
+
+          let(:options) do
+            { retry_on_failure: true, delay_on_retry: 3000 }
+          end
+
+          let(:responses) do
+            5.times.collect do
+              client.perform_request('GET', '_nodes/_local')
+            end
+          end
+
+          it 'retries on failure' do
+            allow_any_instance_of(Object).to receive(:sleep).with(3000 / 1000)
+            expect(responses.all? { true }).to be(true)
+          end
         end
       end
 
@@ -1265,7 +1743,7 @@ describe Elasticsearch::Transport::Client do
             end
 
             it 'sets the Accept-Encoding header' do
-              expect(client.transport.connections[0].connection.headers['Accept-Encoding'])
+              expect(client.transport.connections[0].connection.headers['Accept-Encoding']).to eq 'gzip'
             end
 
             it 'preserves the other headers' do
@@ -1274,9 +1752,10 @@ describe Elasticsearch::Transport::Client do
           end
 
           context 'when using the HTTPClient adapter' do
+            require 'faraday/httpclient'
 
             let(:client) do
-              described_class.new(hosts: ELASTICSEARCH_HOSTS, compression: true, adapter: :httpclient)
+              described_class.new(hosts: ELASTICSEARCH_HOSTS, compression: true, adapter: :httpclient, enable_meta_header: false)
             end
 
             it 'compresses the request and decompresses the response' do
@@ -1284,7 +1763,7 @@ describe Elasticsearch::Transport::Client do
             end
 
             it 'sets the Accept-Encoding header' do
-              expect(client.transport.connections[0].connection.headers['Accept-Encoding'])
+              expect(client.transport.connections[0].connection.headers['Accept-Encoding']).to eq 'gzip'
             end
 
             it 'preserves the other headers' do
@@ -1303,7 +1782,7 @@ describe Elasticsearch::Transport::Client do
             end
 
             it 'sets the Accept-Encoding header' do
-              expect(client.transport.connections[0].connection.headers['Accept-Encoding'])
+              expect(client.transport.connections[0].connection.headers['Accept-Encoding']).to eq 'gzip'
             end
 
             it 'preserves the other headers' do
@@ -1322,7 +1801,7 @@ describe Elasticsearch::Transport::Client do
             end
 
             it 'sets the Accept-Encoding header' do
-              expect(client.transport.connections[0].connection.headers['Accept-Encoding'])
+              expect(client.transport.connections[0].connection.headers['Accept-Encoding']).to eq 'gzip'
             end
 
             it 'preserves the other headers' do
@@ -1341,22 +1820,23 @@ describe Elasticsearch::Transport::Client do
             end
 
             it 'sets the Accept-Encoding header' do
-              expect(client.transport.connections[0].connection.headers['Accept-Encoding'])
+              expect(client.transport.connections[0].connection.headers['Accept-Encoding']).to eq 'gzip'
             end
 
             it 'preserves the other headers' do
               expect(client.transport.connections[0].connection.headers['User-Agent'])
             end
-          end
+          end unless jruby?
         end
       end
 
       context 'when using Curb as the transport', unless: jruby? do
-
         let(:client) do
-          described_class.new(hosts: ELASTICSEARCH_HOSTS,
-                              compression: true,
-                              transport_class: Elasticsearch::Transport::Transport::HTTP::Curb)
+          described_class.new(
+            hosts: ELASTICSEARCH_HOSTS,
+            compression: true,
+            transport_class: Elasticsearch::Transport::Transport::HTTP::Curb
+          )
         end
 
         it 'compresses the request and decompresses the response' do
@@ -1364,7 +1844,7 @@ describe Elasticsearch::Transport::Client do
         end
 
         it 'sets the Accept-Encoding header' do
-          expect(client.transport.connections[0].connection.headers['Accept-Encoding'])
+          expect(client.transport.connections[0].connection.headers['Accept-Encoding']).to eq 'gzip'
         end
 
         it 'preserves the other headers' do
@@ -1373,7 +1853,6 @@ describe Elasticsearch::Transport::Client do
       end
 
       context 'when using Manticore as the transport', if: jruby? do
-
         let(:client) do
           described_class.new(hosts: ELASTICSEARCH_HOSTS,
                               compression: true,
@@ -1387,9 +1866,7 @@ describe Elasticsearch::Transport::Client do
     end
 
     describe '#perform_request' do
-
       context 'when a request is made' do
-
         before do
           client.perform_request('DELETE', '_all')
           client.perform_request('DELETE', 'myindex') rescue
@@ -1412,7 +1889,6 @@ describe Elasticsearch::Transport::Client do
       end
 
       context 'when an invalid url is specified' do
-
         it 'raises an exception' do
           expect {
             client.perform_request('GET', 'myindex/mydoc/1?routing=FOOBARBAZ')
@@ -1421,7 +1897,6 @@ describe Elasticsearch::Transport::Client do
       end
 
       context 'when the \'ignore\' parameter is specified' do
-
         let(:response) do
           client.perform_request('PUT', '_foobar', ignore: 400)
         end
@@ -1437,7 +1912,6 @@ describe Elasticsearch::Transport::Client do
       end
 
       context 'when request headers are specified' do
-
         let(:response) do
           client.perform_request('GET', '/', {}, nil, { 'Content-Type' => 'application/yaml' })
         end
@@ -1448,9 +1922,7 @@ describe Elasticsearch::Transport::Client do
       end
 
       describe 'selector' do
-
         context 'when the round-robin selector is used' do
-
           let(:nodes) do
             3.times.collect do
               client.perform_request('GET', '_nodes/_local').body['nodes'].to_a[0][1]['name']
@@ -1458,7 +1930,7 @@ describe Elasticsearch::Transport::Client do
           end
 
           let(:node_names) do
-            client.nodes.stats['nodes'].collect do |name, stats|
+            client.perform_request('GET', '_nodes/stats').body('nodes').collect do |name, stats|
               stats['name']
             end
           end
@@ -1477,7 +1949,6 @@ describe Elasticsearch::Transport::Client do
       end
 
       context 'when patron is used as an adapter', unless: jruby? do
-
         before do
           require 'patron'
         end
@@ -1486,12 +1957,39 @@ describe Elasticsearch::Transport::Client do
           { adapter: :patron }
         end
 
-        let(:connection_handler) do
-          client.transport.connections.first.connection.builder.handlers.first
+        let(:adapter) do
+          client.transport.connections.first.connection.builder.adapter
+        end
+
+        it 'uses the patron connection handler' do
+          expect(adapter).to eq('Faraday::Adapter::Patron')
+        end
+
+        it 'keeps connections open' do
+          response = client.perform_request('GET', '_nodes/stats/http')
+          connections_before = response.body['nodes'].values.find { |n| n['name'] == node_names.first }['http']['total_opened']
+          client.transport.reload_connections!
+          response = client.perform_request('GET', '_nodes/stats/http')
+          connections_after = response.body['nodes'].values.find { |n| n['name'] == node_names.first }['http']['total_opened']
+          expect(connections_after).to be >= (connections_before)
+        end
+      end
+
+      context 'when typhoeus is used as an adapter', unless: jruby? do
+        before do
+          require 'typhoeus'
+        end
+
+        let(:options) do
+          { adapter: :typhoeus }
+        end
+
+        let(:adapter) do
+          client.transport.connections.first.connection.builder.adapter
         end
 
         it 'uses the patron connection handler' do
-          expect(connection_handler).to eq('Faraday::Adapter::Patron')
+          expect(adapter).to eq('Faraday::Adapter::Typhoeus')
         end
 
         it 'keeps connections open' do
@@ -1505,4 +2003,76 @@ describe Elasticsearch::Transport::Client do
       end
     end
   end
+
+  context 'CA Fingerprinting' do
+    context 'when setting a ca_fingerprint' do
+      after do
+        File.delete('./certificate.crt')
+        File.delete('./certificate.key')
+      end
+
+      let(:certificate) do
+        system(
+          'openssl req -new -newkey rsa:4096 -days 3650 -nodes -x509 -subj "/C=BE/O=Test/CN=Test"' \
+          ' -keyout certificate.key -out certificate.crt',
+          err: File::NULL
+        )
+        OpenSSL::X509::Certificate.new File.read('./certificate.crt')
+      end
+
+      let(:client) do
+        Elasticsearch::Transport::Client.new(
+          host: 'https://elastic:changeme@localhost:9200',
+          ca_fingerprint: OpenSSL::Digest::SHA256.hexdigest(certificate.to_der)
+        )
+      end
+
+      it 'validates CA fingerprints on perform request' do
+        expect(client.transport.connections.connections.map(&:verified).uniq).to eq [false]
+        allow(client.transport).to receive(:perform_request) { 'Hello' }
+
+        server = double('server').as_null_object
+        allow(TCPSocket).to receive(:new) { server }
+        socket = double('socket')
+        allow(OpenSSL::SSL::SSLSocket).to receive(:new) { socket }
+        allow(socket).to receive(:connect) { nil }
+        allow(socket).to receive(:peer_cert_chain) { [certificate] }
+
+        response = client.perform_request('GET', '/')
+        expect(client.transport.connections.connections.map(&:verified).uniq).to eq [true]
+        expect(response).to eq 'Hello'
+      end
+    end
+
+    context 'when using an http host' do
+      let(:client) do
+        Elasticsearch::Transport::Client.new(
+          host: 'http://elastic:changeme@localhost:9200',
+          ca_fingerprint: 'test'
+        )
+      end
+
+      it 'raises an error' do
+        expect do
+          client.perform_request('GET', '/')
+        end.to raise_exception(Elasticsearch::Transport::Transport::Error)
+      end
+    end
+
+    context 'when not setting a ca_fingerprint' do
+      let(:client) do
+        Elasticsearch::Transport::Client.new(
+          host: 'http://elastic:changeme@localhost:9200'
+        )
+      end
+
+      it 'has unvalidated connections' do
+        allow(client).to receive(:validate_ca_fingerprints) { nil }
+        allow(client.transport).to receive(:perform_request) { nil }
+
+        client.perform_request('GET', '/')
+        expect(client).to_not have_received(:validate_ca_fingerprints)
+      end
+    end
+  end
 end