elastic-transport 8.0.0.pre1

data/test/unit/transport_curb_test.rb

@@ -0,0 +1,135 @@
+# 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'
+
+if JRUBY
+  puts "'#{File.basename(__FILE__)}' not supported on JRuby #{RUBY_VERSION}"
+else
+  require 'elastic/transport/transport/http/curb'
+  require 'curb'
+
+  class Elastic::Transport::Transport::HTTP::FaradayTest < Minitest::Test
+    include Elastic::Transport::Transport::HTTP
+
+    context "Curb transport" do
+      setup do
+        @transport = Curb.new :hosts => [ { :host => 'foobar', :port => 1234 } ]
+      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 ::Curl::Easy,   @transport.connections.first.connection
+        assert_equal 'http://foobar:1234', @transport.connections.first.connection.url
+      end
+
+      should "perform the request" do
+        @transport.connections.first.connection.expects(:http).returns(stub_everything)
+        @transport.perform_request 'GET', '/'
+      end
+
+      should "set body for GET request" do
+        @transport.connections.first.connection.expects(:put_data=).with('{"foo":"bar"}')
+        @transport.connections.first.connection.expects(:http).with(:GET).returns(stub_everything)
+        @transport.perform_request 'GET', '/', {}, '{"foo":"bar"}'
+      end
+
+      should "perform request with headers" do
+        @transport.connections.first.connection.expects(:put_data=).with('{"foo":"bar"}')
+        @transport.connections.first.connection.expects(:http).with(:POST).returns(stub_everything)
+        @transport.connections.first.connection.headers.expects(:merge!).with("Content-Type" => "application/x-ndjson")
+
+        @transport.perform_request 'POST', '/', {}, {:foo => 'bar'}, {"Content-Type" => "application/x-ndjson"}
+      end
+
+      should "set body for PUT request" do
+        @transport.connections.first.connection.expects(:put_data=)
+        @transport.connections.first.connection.expects(:http).with(:PUT).returns(stub_everything)
+        @transport.perform_request 'PUT', '/', {}, {:foo => 'bar'}
+      end
+
+      should "serialize the request body" do
+        @transport.connections.first.connection.expects(:http).with(:POST).returns(stub_everything)
+        @transport.serializer.expects(:dump)
+        @transport.perform_request 'POST', '/', {}, {:foo => 'bar'}
+      end
+
+      should "not serialize a String request body" do
+        @transport.connections.first.connection.expects(:http).with(:POST).returns(stub_everything)
+        @transport.serializer.expects(:dump).never
+        @transport.perform_request 'POST', '/', {}, '{"foo":"bar"}'
+      end
+
+      should "set application/json response header" do
+        @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']
+      end
+
+      should "handle HTTP methods" do
+        @transport.connections.first.connection.expects(:http).with(:HEAD).returns(stub_everything)
+        @transport.connections.first.connection.expects(:http).with(:GET).returns(stub_everything)
+        @transport.connections.first.connection.expects(:http).with(:PUT).returns(stub_everything)
+        @transport.connections.first.connection.expects(:http).with(:POST).returns(stub_everything)
+        @transport.connections.first.connection.expects(:http).with(:DELETE).returns(stub_everything)
+
+        %w| HEAD GET PUT POST DELETE |.each { |method| @transport.perform_request method, '/' }
+
+        assert_raise(ArgumentError) { @transport.perform_request 'FOOBAR', '/' }
+      end
+
+      should "properly pass the Content-Type header option" do
+        transport = Curb.new :hosts => [ { :host => 'foobar', :port => 1234 } ], :options => { :transport_options => { :headers => { 'Content-Type' => 'foo/bar' } } }
+
+        assert_equal "foo/bar", transport.connections.first.connection.headers["Content-Type"]
+      end
+
+      should "allow to set options for Curb" do
+        transport = Curb.new :hosts => [ { :host => 'foobar', :port => 1234 } ] do |curl|
+          curl.headers["User-Agent"] = "myapp-0.0"
+        end
+
+        assert_equal "myapp-0.0", transport.connections.first.connection.headers["User-Agent"]
+      end
+
+      should "set the credentials if passed" do
+        transport = Curb.new :hosts => [ { :host => 'foobar', :port => 1234, :user => 'foo', :password => 'bar' } ]
+        assert_equal 'foo', transport.connections.first.connection.username
+        assert_equal 'bar', transport.connections.first.connection.password
+      end
+
+      should "use global http configuration" do
+        transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234 } ],
+                                :options => { :http => { :scheme => 'https', :user => 'U', :password => 'P' } }
+
+        assert_equal 'https://U:P@foobar:1234/', transport.connections.first.full_url('')
+      end
+    end
+
+  end
+
+end

data/test/unit/transport_faraday_test.rb

@@ -0,0 +1,228 @@
+# 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 Elastic::Transport::Transport::HTTP::FaradayTest < Minitest::Test
+  include Elastic::Transport::Transport::HTTP
+
+  context "Faraday transport" do
+    setup do
+      @transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234 } ]
+    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 ::Faraday::Connection, @transport.connections.first.connection
+      assert_equal 'http://foobar:1234/',       @transport.connections.first.connection.url_prefix.to_s
+    end
+
+    should "perform the request" do
+      @transport.connections.first.connection.expects(:run_request).returns(stub_everything)
+      @transport.perform_request 'GET', '/'
+    end
+
+    should "return a Response" do
+      @transport.connections.first.connection.expects(:run_request).returns(stub_everything)
+      response = @transport.perform_request 'GET', '/'
+      assert_instance_of Elastic::Transport::Transport::Response, response
+    end
+
+    should "properly prepare the request" do
+      @transport.connections.first.connection.expects(:run_request).with do |method, url, body, headers|
+        assert_equal :post, method
+        assert_equal '{"foo":"bar"}', body
+        assert_nil   headers['Accept']
+        true
+      end.returns(stub_everything)
+
+      @transport.perform_request 'POST', '/', {}, {:foo => 'bar'}
+    end
+
+    should "properly prepare the request with custom headers" do
+      @transport.connections.first.connection.expects(:run_request).with do |method, url, body, headers|
+        assert_equal :post, method
+        assert_equal '{"foo":"bar"}', body
+        assert_nil   headers['Accept']
+        assert_equal "application/x-ndjson", headers['Content-Type']
+        true
+      end.returns(stub_everything)
+
+      @transport.perform_request 'POST', '/', {}, {:foo => 'bar'}, {"Content-Type" => "application/x-ndjson"}
+    end
+
+    should "properly pass the Content-Type header option" do
+      transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234 } ], :options => { :transport_options => { :headers => { 'Content-Type' => 'foo/bar' } } }
+
+      transport.connections.first.connection.expects(:run_request).with do |method, url, body, headers|
+        assert_equal 'foo/bar', headers['Content-Type']
+        true
+      end.returns(stub_everything)
+
+      transport.perform_request 'GET', '/'
+    end
+
+    should "serialize the request body" do
+      @transport.connections.first.connection.expects(:run_request).returns(stub_everything)
+      @transport.serializer.expects(:dump)
+      @transport.perform_request 'POST', '/', {}, {:foo => 'bar'}
+    end
+
+    should "not serialize a String request body" do
+      @transport.connections.first.connection.expects(:run_request).returns(stub_everything)
+      @transport.serializer.expects(:dump).never
+      @transport.perform_request 'POST', '/', {}, '{"foo":"bar"}'
+    end
+
+    should "pass the selector_class options to collection" do
+      @transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234 } ],
+                               :options => { :selector_class => Elastic::Transport::Transport::Connections::Selector::Random }
+      assert_instance_of Elastic::Transport::Transport::Connections::Selector::Random,
+                         @transport.connections.selector
+    end
+
+    should "pass the selector option to collection" do
+      @transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234 } ],
+                               :options => { :selector => Elastic::Transport::Transport::Connections::Selector::Random.new }
+      assert_instance_of Elastic::Transport::Transport::Connections::Selector::Random,
+                         @transport.connections.selector
+    end
+
+    should "pass a configuration block to the Faraday constructor" do
+      config_block = lambda do |f|
+        f.response :logger
+        f.path_prefix = '/moo'
+      end
+
+      transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234 } ], &config_block
+
+      handlers = transport.connections.first.connection.builder.handlers
+
+      assert_equal 1, handlers.size
+      assert handlers.include?(::Faraday::Response::Logger), "#{handlers.inspect} does not include <::Faraday::Adapter::Logger>"
+
+      assert_equal '/moo',                   transport.connections.first.connection.path_prefix
+      assert_equal 'http://foobar:1234/moo', transport.connections.first.connection.url_prefix.to_s
+    end
+
+    should "pass transport_options to the Faraday constructor" do
+      transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234 } ],
+                              :options => { :transport_options => {
+                                              :request => { :open_timeout => 1 },
+                                              :headers => { :foo_bar => 'bar'  },
+                                              :ssl     => { :verify => false }
+                                            }
+                                          }
+
+      assert_equal 1,     transport.connections.first.connection.options.open_timeout
+      assert_equal 'bar', transport.connections.first.connection.headers['Foo-Bar']
+      assert_equal false, transport.connections.first.connection.ssl.verify?
+    end
+
+    should "merge in parameters defined in the Faraday connection parameters" do
+      transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234 } ],
+                              :options => { :transport_options => {
+                                              :params => { :format => 'yaml' }
+                                            }
+                                          }
+      # transport.logger = Logger.new(STDERR)
+
+      transport.connections.first.connection.expects(:run_request).
+        with do |method, url, params, body|
+          assert_match(/\?format=yaml/, url)
+          true
+        end.
+        returns(stub_everything)
+
+      transport.perform_request 'GET', ''
+    end
+
+    should "not overwrite request parameters with the Faraday connection parameters" do
+      transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234 } ],
+                              :options => { :transport_options => {
+                                              :params => { :format => 'yaml' }
+                                            }
+                                          }
+      # transport.logger = Logger.new(STDERR)
+
+      transport.connections.first.connection.expects(:run_request).
+        with do |method, url, params, body|
+          assert_match(/\?format=json/, url)
+          true
+        end.
+        returns(stub_everything)
+
+      transport.perform_request 'GET', '', { :format => 'json' }
+    end
+
+    should "set the credentials if passed" do
+      transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234, :user => 'foo', :password => 'bar' } ]
+      assert_equal 'Basic Zm9vOmJhcg==', transport.connections.first.connection.headers['Authorization']
+    end
+
+    should "set the credentials if they exist in options" do
+      transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234 } ],
+                              :options => { :user => 'foo', :password => 'bar' }
+      assert_equal 'Basic Zm9vOmJhcg==', transport.connections.first.connection.headers['Authorization']
+    end
+
+    should "override options credentials if passed explicitly" do
+      transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234, :user => 'foo', :password => 'bar' },
+                                          { :host => 'foobar2', :port => 1234 } ],
+                              :options => { :user => 'foo2', :password => 'bar2' }
+      assert_equal 'Basic Zm9vOmJhcg==', transport.connections.first.connection.headers['Authorization']
+      assert_equal 'Basic Zm9vMjpiYXIy', transport.connections[1].connection.headers['Authorization']
+    end
+
+    should "set connection scheme to https if passed" do
+      transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234, :scheme => 'https' } ]
+
+      assert_instance_of ::Faraday::Connection, transport.connections.first.connection
+      assert_equal 'https://foobar:1234/',       transport.connections.first.connection.url_prefix.to_s
+    end
+
+    should "set connection scheme to https if it exist in options" do
+      transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234} ],
+                              :options => { :scheme => 'https' }
+
+      assert_instance_of ::Faraday::Connection, transport.connections.first.connection
+      assert_equal 'https://foobar:1234/',       transport.connections.first.connection.url_prefix.to_s
+    end
+
+    should "override options scheme if passed explicitly" do
+      transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234, :scheme => 'http'} ],
+                              :options => { :scheme => 'https' }
+
+      assert_instance_of ::Faraday::Connection, transport.connections.first.connection
+      assert_equal 'http://foobar:1234/',       transport.connections.first.connection.url_prefix.to_s
+    end
+
+    should "use global http configuration" do
+      transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234 } ],
+                              :options => { :http => { :scheme => 'https', :user => 'U', :password => 'P' } }
+
+      assert_equal 'https://U:P@foobar:1234/', transport.connections.first.full_url('')
+    end
+  end
+
+end

data/test/unit/transport_manticore_test.rb

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