elasticsearch-transport 6.3.0 → 6.8.3

data/spec/elasticsearch/transport/client_spec.rb

@@ -1,3 +1,7 @@
+# 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
@@ -45,31 +49,99 @@ describe Elasticsearch::Transport::Client do
     expect(client.transport.hosts[0][:host]).to eq('localhost')
   end
 
-  describe 'adapter' do
+  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
 
-    context 'when no adapter is specified' do
+    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
 
+  describe 'adapter' do
+    context 'when no adapter is specified' 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)
+        expect(adapter).to eq Faraday::Adapter::NetHttp
+      end
+    end
+
+    context 'when the adapter is patron' do
+      let(:adapter) do
+        client.transport.connections.all.first.connection.builder.adapter
+      end
+
+      let(:client) do
+        described_class.new(adapter: :patron, enable_meta_header: false)
+      end
+
+      it 'uses Faraday with the adapter' do
+        expect(adapter).to eq Faraday::Adapter::Patron
       end
     end
 
-    context 'when the adapter is specified' do
+    context 'when the adapter is typhoeus' do
+      let(:adapter) do
+        client.transport.connections.all.first.connection.builder.adapter
+      end
+
+      let(:client) do
+        described_class.new(adapter: :typhoeus, enable_meta_header: false)
+      end
 
+      it 'uses Faraday with the adapter' do
+        expect(adapter).to eq Faraday::Adapter::Typhoeus
+      end
+    end
+
+    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' do
-        expect(adapter).to include(Faraday::Adapter::Typhoeus)
+      it 'uses Faraday with the adapter' do
+        expect(adapter).to eq Faraday::Adapter::Patron
       end
     end
 
@@ -81,11 +153,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
 
@@ -93,17 +165,21 @@ 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
@@ -154,7 +230,6 @@ describe Elasticsearch::Transport::Client do
       end
 
       context 'when credentials are specified' do
-
         let(:host) do
           'http://USERNAME:PASSWORD@myhost:8080'
         end
@@ -611,10 +686,43 @@ 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.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.search(opaque_id: 'opaque_id') }.not_to raise_error
+          expect(client).to have_received(:perform_request)
+            .with('GET', '_search', { opaque_id: 'opaque_id' }, nil)
+        end
+      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|
@@ -692,15 +800,14 @@ describe Elasticsearch::Transport::Client do
         end
 
         context 'when the Faraday adapter is set in the block' do
-
           let(:client) do
             Elasticsearch::Client.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
@@ -708,7 +815,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
@@ -758,7 +865,7 @@ 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
 
@@ -907,12 +1014,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

data/spec/elasticsearch/transport/meta_header_spec.rb

@@ -0,0 +1,214 @@
+# 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
+  context 'meta-header' do
+    let(:subject) { client.transport.connections.first.connection.headers }
+    let(:client) { described_class.new }
+    let(:regexp) { /^[a-z]{1,}=[a-z0-9.\-]{1,}(?:,[a-z]{1,}=[a-z0-9._\-]+)*$/ }
+    let(:adapter) { :net_http }
+    let(:adapter_code) { "nh=#{defined?(Net::HTTP::VERSION) ? Net::HTTP::VERSION : Net::HTTP::HTTPVersion}" }
+    let(:meta_header) do
+      if jruby?
+        "es=#{meta_version},rb=#{RUBY_VERSION},t=#{Elasticsearch::Transport::VERSION},jv=#{ENV_JAVA['java.version']},jr=#{JRUBY_VERSION},fd=#{Faraday::VERSION},#{adapter_code}"
+      else
+        "es=#{meta_version},rb=#{RUBY_VERSION},t=#{Elasticsearch::Transport::VERSION},fd=#{Faraday::VERSION},#{adapter_code}"
+      end
+    end
+
+    context 'client_meta_version_' do
+      let(:version) { ['7.1.0-alpha', '7.11.0.pre.1', '8.0.0-beta', '8.0.0.beta.2']}
+
+      it 'converts the version to X.X.Xp' do
+        expect(client.send(:client_meta_version, '7.0.0-alpha')).to eq('7.0.0p')
+        expect(client.send(:client_meta_version, '7.11.0.pre.1')).to eq('7.11.0p')
+        expect(client.send(:client_meta_version, '8.1.0-beta')).to eq('8.1.0p')
+        expect(client.send(:client_meta_version, '8.0.0.beta.2')).to eq('8.0.0p')
+        expect(client.send(:client_meta_version, '12.16.4.pre')).to eq('12.16.4p')
+      end
+    end
+
+    # We are testing this method in the previous block, so now using it inside the test to make the
+    # Elasticsearch version in the meta header string dynamic
+    def meta_version
+      client.send(:client_meta_version, Elasticsearch::VERSION)
+    end
+
+    context 'single use of meta header' do
+      let(:client) do
+        described_class.new(adapter: adapter).tap do |klient|
+          allow(klient).to receive(:__build_connections)
+        end
+      end
+
+      it 'x-elastic-client-header value matches regexp' do
+        expect(subject['x-elastic-client-meta']).to match(regexp)
+        expect(subject).to include('x-elastic-client-meta' => meta_header)
+      end
+    end
+
+    context 'when using user-agent headers' do
+      let(:client) do
+        transport_options = { headers: { user_agent: 'My Ruby App' } }
+        described_class.new(transport_options: transport_options, adapter: adapter).tap do |klient|
+          allow(klient).to receive(:__build_connections)
+        end
+      end
+
+      it 'is friendly to previously set headers' do
+        expect(subject).to include(user_agent: 'My Ruby App')
+        expect(subject['x-elastic-client-meta']).to match(regexp)
+        expect(subject).to include('x-elastic-client-meta' => meta_header)
+      end
+    end
+
+    context 'when using API Key' do
+      let(:client) do
+        described_class.new(api_key: 'an_api_key', adapter: adapter)
+      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')
+        expect(subject['x-elastic-client-meta']).to match(regexp)
+        expect(subject).to include('x-elastic-client-meta' => meta_header)
+      end
+    end
+
+    context 'adapters' do
+      let(:meta_header) do
+        if jruby?
+          "es=#{meta_version},rb=#{RUBY_VERSION},t=#{Elasticsearch::Transport::VERSION},jv=#{ENV_JAVA['java.version']},jr=#{JRUBY_VERSION},fd=#{Faraday::VERSION}"
+        else
+          "es=#{meta_version},rb=#{RUBY_VERSION},t=#{Elasticsearch::Transport::VERSION},fd=#{Faraday::VERSION}"
+        end
+      end
+      let(:client) { described_class.new(adapter: adapter) }
+      let(:headers) { client.transport.connections.first.connection.headers }
+
+      context 'using net/http/persistent' do
+        let(:adapter) { :net_http_persistent }
+
+        it 'sets adapter in the meta header' do
+          require 'net/http/persistent'
+          expect(headers['x-elastic-client-meta']).to match(regexp)
+          meta = "#{meta_header},np=#{Net::HTTP::Persistent::VERSION}"
+          expect(headers).to include('x-elastic-client-meta' => meta)
+        end
+      end
+
+      context 'using httpclient' do
+        let(:adapter) { :httpclient }
+
+        it 'sets adapter in the meta header' do
+          require 'httpclient'
+          expect(headers['x-elastic-client-meta']).to match(regexp)
+          meta = "#{meta_header},hc=#{HTTPClient::VERSION}"
+          expect(headers).to include('x-elastic-client-meta' => meta)
+        end
+      end
+
+      context 'using typhoeus' do
+        let(:adapter) { :typhoeus }
+
+        it 'sets adapter in the meta header' do
+          require 'typhoeus'
+          expect(headers['x-elastic-client-meta']).to match(regexp)
+          meta = "#{meta_header},ty=#{Typhoeus::VERSION}"
+          expect(headers).to include('x-elastic-client-meta' => meta)
+        end
+      end
+
+      unless defined?(JRUBY_VERSION)
+        let(:adapter) { :patron }
+
+        context 'using patron' do
+          it 'sets adapter in the meta header' do
+            require 'patron'
+            expect(headers['x-elastic-client-meta']).to match(regexp)
+            meta = "#{meta_header},pt=#{Patron::VERSION}"
+            expect(headers).to include('x-elastic-client-meta' => meta)
+          end
+        end
+      end
+    end
+
+    if defined?(JRUBY_VERSION)
+      context 'when using manticore' do
+        let(:client) do
+          Elasticsearch::Client.new(transport_class: Elasticsearch::Transport::Transport::HTTP::Manticore)
+        end
+        let(:subject) { client.transport.connections.first.connection.instance_variable_get("@options")[:headers]}
+
+        it 'sets manticore in the metaheader' do
+          expect(subject['x-elastic-client-meta']).to match(regexp)
+          expect(subject['x-elastic-client-meta']).to match(/mc=[0-9.]+/)
+        end
+      end
+    else
+      context 'when using curb' do
+        let(:client) do
+          Elasticsearch::Client.new(transport_class: Elasticsearch::Transport::Transport::HTTP::Curb)
+        end
+
+        it 'sets curb in the metaheader' do
+          expect(subject['x-elastic-client-meta']).to match(regexp)
+          expect(subject['x-elastic-client-meta']).to match(/cl=[0-9.]+/)
+        end
+      end
+    end
+
+    context 'when using custom transport implementation' do
+      class MyTransport
+        include Elasticsearch::Transport::Transport::Base
+        def initialize(args); end
+      end
+      let(:client) { Elasticsearch::Client.new(transport_class: MyTransport) }
+      let(:subject){ client.instance_variable_get("@arguments")[:transport_options][:headers] }
+      let(:meta_header) do
+        if jruby?
+          "es=#{meta_version},rb=#{RUBY_VERSION},t=#{Elasticsearch::Transport::VERSION},jv=#{ENV_JAVA['java.version']},jr=#{JRUBY_VERSION}"
+        else
+          "es=#{meta_version},rb=#{RUBY_VERSION},t=#{Elasticsearch::Transport::VERSION}"
+        end
+      end
+
+      it 'doesnae set any info about the implementation in the metaheader' do
+        expect(subject['x-elastic-client-meta']).to match(regexp)
+        expect(subject).to include('x-elastic-client-meta' => meta_header)
+      end
+    end
+
+    context 'when using a different service version' do
+      before do
+        stub_const("Elastic::META_HEADER_SERVICE_VERSION", [:ent, '8.0.0'])
+      end
+
+      let(:client) { Elasticsearch::Client.new }
+
+      it 'sets the service version in the metaheader' do
+        expect(subject['x-elastic-client-meta']).to match(regexp)
+        expect(subject['x-elastic-client-meta']).to start_with('ent=8.0.0')
+      end
+    end
+  end
+end