elasticsearch-transport 7.1.0 → 7.2.0

data/spec/spec_helper.rb

@@ -4,6 +4,12 @@ require 'logger'
 require 'ansi/code'
 require 'hashie/mash'
 require 'pry-nav'
+if defined?(JRUBY_VERSION)
+  require 'elasticsearch/transport/transport/http/manticore'
+else
+  require 'elasticsearch/transport/transport/http/curb'
+  require 'curb'
+end
 
 # The hosts to use for creating a elasticsearch client.
 #

data/test/unit/transport_curb_test.rb

@@ -57,7 +57,7 @@ else
       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.expects(:headers=).with({"Content-Type" => "application/x-ndjson"})
+        @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

data/test/unit/transport_manticore_test.rb

@@ -56,32 +56,42 @@ else
 
       should "set body for GET request" do
         @transport.connections.first.connection.expects(:get).
-          with('http://127.0.0.1:8080//', {:body => '{"foo":"bar"}'}).returns(stub_everything)
+          with('http://127.0.0.1:8080//', {:body => '{"foo":"bar"}',
+                                           :headers => {"Content-Type" => "application/json",
+                                                        "User-Agent" => @transport.send(:user_agent_header)}}).returns(stub_everything)
         @transport.perform_request 'GET', '/', {}, '{"foo":"bar"}'
       end
 
       should "set body for PUT request" do
         @transport.connections.first.connection.expects(:put).
-          with('http://127.0.0.1:8080//', {:body => '{"foo":"bar"}'}).returns(stub_everything)
+          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"}'}).returns(stub_everything)
+          with('http://127.0.0.1:8080//', {:body => '{"foo":"bar"}',
+                                           :headers => {"Content-Type" => "application/json",
+                                                        "User-Agent" => @transport.send(:user_agent_header)}}).returns(stub_everything)
         @transport.perform_request 'POST', '/', {}, {'foo' => 'bar'}
       end
 
       should "set custom headers for PUT request" do
         @transport.connections.first.connection.expects(:put).
-          with('http://127.0.0.1:8080//', {:body => '{"foo":"bar"}', :headers => {"Content-Type" => "application/x-ndjson"}})
+          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"}'}).returns(stub_everything)
+          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
@@ -93,7 +103,8 @@ else
 
         transport = Manticore.new :hosts => [ { :host => 'localhost', :port => 8080 } ], :options => options
 
-        transport.connections.first.connection.stub("http://localhost:8080//", :body => "\"\"", :headers => {"content-type" => "application/json"}, :code => 200 )
+        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
@@ -113,11 +124,16 @@ else
       end
 
       should "handle HTTP methods" do
-        @transport.connections.first.connection.expects(:delete).with('http://127.0.0.1:8080//', {}).returns(stub_everything)
-        @transport.connections.first.connection.expects(:head).with('http://127.0.0.1:8080//', {}).returns(stub_everything)
-        @transport.connections.first.connection.expects(:get).with('http://127.0.0.1:8080//', {}).returns(stub_everything)
-        @transport.connections.first.connection.expects(:put).with('http://127.0.0.1:8080//', {}).returns(stub_everything)
-        @transport.connections.first.connection.expects(:post).with('http://127.0.0.1:8080//', {}).returns(stub_everything)
+        @transport.connections.first.connection.expects(:delete).with('http://127.0.0.1:8080//', { headers: {"Content-Type" => "application/json",
+                                                                                                             "User-Agent" => @transport.send(:user_agent_header)}}).returns(stub_everything)
+        @transport.connections.first.connection.expects(:head).with('http://127.0.0.1:8080//', { headers: {"Content-Type" => "application/json",
+                                                                                                           "User-Agent" => @transport.send(:user_agent_header)}}).returns(stub_everything)
+        @transport.connections.first.connection.expects(:get).with('http://127.0.0.1:8080//', { headers: {"Content-Type" => "application/json",
+                                                                                                          "User-Agent" => @transport.send(:user_agent_header)}}).returns(stub_everything)
+        @transport.connections.first.connection.expects(:put).with('http://127.0.0.1:8080//', { headers: {"Content-Type" => "application/json",
+                                                                                                          "User-Agent" => @transport.send(:user_agent_header)}}).returns(stub_everything)
+        @transport.connections.first.connection.expects(:post).with('http://127.0.0.1:8080//', { headers: {"Content-Type" => "application/json",
+                                                                                                           "User-Agent" => @transport.send(:user_agent_header)}}).returns(stub_everything)
 
         %w| HEAD GET PUT POST DELETE |.each { |method| @transport.perform_request method, '/' }
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: elasticsearch-transport
 version: !ruby/object:Gem::Version
-  version: 7.1.0
+  version: 7.2.0
 platform: ruby
 authors:
 - Karel Minarik
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-22 00:00:00.000000000 Z
+date: 2019-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -192,6 +192,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: httpclient
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: hashie
   requirement: !ruby/object:Gem::Requirement
@@ -367,6 +381,8 @@ files:
 - lib/elasticsearch/transport/transport/serializer/multi_json.rb
 - lib/elasticsearch/transport/transport/sniffer.rb
 - lib/elasticsearch/transport/version.rb
+- spec/elasticsearch/connections/collection_spec.rb
+- spec/elasticsearch/connections/selector_spec.rb
 - spec/elasticsearch/transport/base_spec.rb
 - spec/elasticsearch/transport/client_spec.rb
 - spec/elasticsearch/transport/sniffer_spec.rb
@@ -374,8 +390,6 @@ files:
 - test/integration/transport_test.rb
 - test/profile/client_benchmark_test.rb
 - test/test_helper.rb
-- test/unit/connection_collection_test.rb
-- test/unit/connection_selector_test.rb
 - test/unit/connection_test.rb
 - test/unit/response_test.rb
 - test/unit/serializer_test.rb
@@ -408,6 +422,8 @@ signing_key:
 specification_version: 4
 summary: Ruby client for Elasticsearch.
 test_files:
+- spec/elasticsearch/connections/collection_spec.rb
+- spec/elasticsearch/connections/selector_spec.rb
 - spec/elasticsearch/transport/base_spec.rb
 - spec/elasticsearch/transport/client_spec.rb
 - spec/elasticsearch/transport/sniffer_spec.rb
@@ -415,8 +431,6 @@ test_files:
 - test/integration/transport_test.rb
 - test/profile/client_benchmark_test.rb
 - test/test_helper.rb
-- test/unit/connection_collection_test.rb
-- test/unit/connection_selector_test.rb
 - test/unit/connection_test.rb
 - test/unit/response_test.rb
 - test/unit/serializer_test.rb

data/test/unit/connection_collection_test.rb

@@ -1,147 +0,0 @@
-# Licensed to Elasticsearch B.V. under one or more contributor
-# license agreements. See the NOTICE file distributed with
-# this work for additional information regarding copyright
-# ownership. Elasticsearch B.V. licenses this file to you under
-# the Apache License, Version 2.0 (the "License"); you may
-# not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#	http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-require 'test_helper'
-
-class Elasticsearch::Transport::Transport::Connections::CollectionTest < Minitest::Test
-  include Elasticsearch::Transport::Transport::Connections
-
-  context "Connection collection" do
-
-    should "have empty array as default connections array" do
-      assert_equal [], Collection.new.connections
-    end
-
-    should "have default selector class" do
-      assert_not_nil Collection.new.selector
-    end
-
-    should "initialize a custom selector class" do
-      c = Collection.new :selector_class => Selector::Random
-      assert_instance_of Selector::Random, c.selector
-    end
-
-    should "take a custom selector instance" do
-      c = Collection.new :selector => Selector::Random.new
-      assert_instance_of Selector::Random, c.selector
-    end
-
-    should "get connection from selector" do
-      c = Collection.new
-      c.selector.expects(:select).returns('OK')
-      assert_equal 'OK', c.get_connection
-    end
-
-    should "return an array of hosts" do
-      c = Collection.new :connections => [ Connection.new(:host => 'foo'), Connection.new(:host => 'bar') ]
-      assert_equal ['foo', 'bar'], c.hosts
-    end
-
-    should "be enumerable" do
-      c = Collection.new :connections => [ Connection.new(:host => 'foo'), Connection.new(:host => 'bar') ]
-
-      assert_equal ['FOO', 'BAR'], c.map { |i| i.host.upcase }
-      assert_equal 'foo',          c[0].host
-      assert_equal 'bar',          c[1].host
-      assert_equal  2,             c.size
-    end
-
-    should "add connections" do
-      c = Collection.new :connections => [ Connection.new(:host => { :protocol => 'http', :host => 'foo', :port => 1}) ]
-      assert_equal 1, c.size
-
-      c.add([ Connection.new(:host => { :protocol => 'http', :host => 'bar', :port => 1 }),
-              Connection.new(:host => { :protocol => 'http', :host => 'bam', :port => 1 }) ])
-      assert_equal 3, c.size
-    end
-
-    should "add connection" do
-      c = Collection.new :connections => [ Connection.new(:host => { :protocol => 'http', :host => 'foo', :port => 1}) ]
-      assert_equal 1, c.size
-
-      c.add(Connection.new(:host => { :protocol => 'http', :host => 'bar', :port => 1 }))
-      assert_equal 2, c.size
-    end
-
-    should "remove connections" do
-      c = Collection.new :connections => [
-        Connection.new(:host => { :protocol => 'http', :host => 'foo', :port => 1 }),
-        Connection.new(:host => { :protocol => 'http', :host => 'bar', :port => 1 })
-      ]
-      assert_equal 2, c.size
-
-      c.remove([c.first])
-      assert_equal 1, c.size
-
-      c.remove(c)
-      assert_equal 0, c.size
-    end
-
-    should "remove connection" do
-      c = Collection.new :connections => [
-        Connection.new(:host => { :protocol => 'http', :host => 'foo', :port => 1 }),
-        Connection.new(:host => { :protocol => 'http', :host => 'bar', :port => 1 })
-      ]
-      assert_equal 2, c.size
-
-      c.remove(c.first)
-      assert_equal 1, c.size
-    end
-
-    context "with the dead pool" do
-      setup do
-        @collection = Collection.new :connections => [ Connection.new(:host => 'foo'), Connection.new(:host => 'bar') ]
-        @collection[1].dead!
-      end
-
-      should "not iterate over dead connections" do
-        assert_equal 1, @collection.size
-        assert_equal ['FOO'], @collection.map { |c| c.host.upcase }
-        assert_equal @collection.connections, @collection.alive
-      end
-
-      should "have dead connections collection" do
-        assert_equal 1, @collection.dead.size
-        assert_equal ['BAR'], @collection.dead.map { |c| c.host.upcase }
-      end
-
-      should "not return dead connections, when alive connections exist" do
-        assert_equal 1, @collection.size
-        @collection.all.size.times { refute @collection.get_connection.dead? }
-      end
-
-      should "resurrect dead connection with least failures when no alive is available" do
-        c1 = Connection.new(:host => { :protocol => 'http', :host => 'foo', :port => 123 }).dead!.dead!
-        c2 = Connection.new(:host => { :protocol => 'http', :host => 'bar', :port => 123 }).dead!
-
-        @collection = Collection.new :connections => [ c1, c2 ]
-
-        assert_equal 0, @collection.size
-        assert_not_nil @collection.get_connection
-        assert_equal 1, @collection.size
-        assert_equal c2, @collection.first
-      end
-
-      should "return all connections" do
-        assert_equal 2, @collection.all.size
-      end
-
-    end
-
-  end
-
-end

data/test/unit/connection_selector_test.rb

@@ -1,81 +0,0 @@
-# Licensed to Elasticsearch B.V. under one or more contributor
-# license agreements. See the NOTICE file distributed with
-# this work for additional information regarding copyright
-# ownership. Elasticsearch B.V. licenses this file to you under
-# the Apache License, Version 2.0 (the "License"); you may
-# not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#	http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-require 'test_helper'
-
-class Elasticsearch::Transport::Transport::Connections::SelectorTest < Minitest::Test
-  include Elasticsearch::Transport::Transport::Connections::Selector
-
-  class DummyStrategySelector
-    include Elasticsearch::Transport::Transport::Connections::Selector::Base
-  end
-
-  class BackupStrategySelector
-    include Elasticsearch::Transport::Transport::Connections::Selector::Base
-
-    def select(options={})
-      connections.reject do |c|
-        c.host[:attributes] && c.host[:attributes][:backup]
-      end.send( defined?(RUBY_VERSION) && RUBY_VERSION > '1.9' ? :sample : :choice)
-    end
-  end
-
-  context "Connection selector" do
-
-    should "be initialized with connections" do
-      assert_equal [1, 2], Random.new(:connections => [1, 2]).connections
-    end
-
-    should "have the abstract select method" do
-      assert_raise(NoMethodError) { DummyStrategySelector.new.select }
-    end
-
-    context "in random strategy" do
-      setup do
-        @selector = Random.new :connections => ['A', 'B', 'C']
-      end
-
-      should "pick a connection" do
-        assert_not_nil @selector.select
-      end
-    end
-
-    context "in round-robin strategy" do
-      setup do
-        @selector = RoundRobin.new :connections => ['A', 'B', 'C']
-      end
-
-      should "rotate over connections" do
-        assert_equal 'A', @selector.select
-        assert_equal 'B', @selector.select
-        assert_equal 'C', @selector.select
-        assert_equal 'A', @selector.select
-      end
-    end
-
-    context "with a custom strategy" do
-
-      should "return proper connection" do
-        selector = BackupStrategySelector.new :connections => [ stub(:host => { :hostname => 'host1' }),
-                                                                stub(:host => { :hostname => 'host2', :attributes => { :backup => true }}) ]
-        10.times { assert_equal 'host1', selector.select.host[:hostname] }
-      end
-
-    end
-
-  end
-end