elastomer-client 3.2.2 → 6.2.0

data/test/client_test.rb

@@ -1,21 +1,39 @@
+# frozen_string_literal: true
+
 require File.expand_path("../test_helper", __FILE__)
-require "elastomer/notifications"
+require File.expand_path("../mock_response", __FILE__)
+require "elastomer_client/notifications"
 
-describe Elastomer::Client do
+describe ElastomerClient::Client do
 
   it "uses the adapter specified at creation" do
-    c = Elastomer::Client.new(:adapter => :test)
-    assert_includes c.connection.builder.handlers, Faraday::Adapter::Test
+    c = ElastomerClient::Client.new(adapter: :test)
+
+    assert_equal c.connection.builder.adapter, Faraday::Adapter::Test
+  end
+
+  it "allows configuring the Faraday when a block is given" do
+    assert ElastomerClient::Client.new.connection.builder.handlers.none? { |handler| handler.klass == FaradayMiddleware::Instrumentation }
+
+    c = ElastomerClient::Client.new do |connection|
+      assert_kind_of(Faraday::Connection, connection)
+
+      connection.use :instrumentation
+    end
+
+    assert c.connection.builder.handlers.any? { |handler| handler.klass == FaradayMiddleware::Instrumentation }
   end
 
   it "use Faraday's default adapter if none is specified" do
-    c = Elastomer::Client.new
+    c = ElastomerClient::Client.new
     adapter = Faraday::Adapter.lookup_middleware(Faraday.default_adapter)
-    assert_includes c.connection.builder.handlers, adapter
+
+    assert_equal c.connection.builder.adapter, adapter
   end
 
   it "uses the same connection for all requests" do
     c = $client.connection
+
     assert_same c, $client.connection
   end
 
@@ -26,8 +44,9 @@ describe Elastomer::Client do
   it "raises an error on 4XX responses with an `error` field" do
     begin
       $client.get "/non-existent-index/_search?q=*:*"
+
       assert false, "exception was not raised when it should have been"
-    rescue Elastomer::Client::Error => err
+    rescue ElastomerClient::Client::Error => err
       assert_equal 404, err.status
       assert_match %r/index_not_found_exception/, err.message
     end
@@ -51,8 +70,9 @@ describe Elastomer::Client do
 
     begin
       $client.post "/_bulk"
+
       assert false, "exception was not raised when it should have been"
-    rescue Elastomer::Client::RejectedExecutionError => err
+    rescue ElastomerClient::Client::RejectedExecutionError => err
       assert_match %r/es_rejected_execution_exception/, err.message
     end
   end
@@ -61,30 +81,45 @@ describe Elastomer::Client do
     error = Faraday::TimeoutError.new("it took too long")
     wrapped = $client.wrap_faraday_error(error, :get, "/_cat/indices")
 
-    assert_instance_of Elastomer::Client::TimeoutError, wrapped
+    assert_instance_of ElastomerClient::Client::TimeoutError, wrapped
     assert_equal "it took too long :: GET /_cat/indices", wrapped.message
   end
 
   it "handles path expansions" do
-    uri = $client.expand_path "/{foo}/{bar}", :foo => "_cluster", :bar => "health"
+    uri = $client.expand_path "/{foo}/{bar}", foo: "_cluster", bar: "health"
+
     assert_equal "/_cluster/health", uri
 
-    uri = $client.expand_path "{/foo}{/baz}{/bar}", :foo => "_cluster", :bar => "state"
+    uri = $client.expand_path "{/foo}{/baz}{/bar}", foo: "_cluster", bar: "state"
+
     assert_equal "/_cluster/state", uri
   end
 
   it "handles query parameters" do
-    uri = $client.expand_path "/_cluster/health", :level => "shards"
+    uri = $client.expand_path "/_cluster/health", level: "shards"
+
     assert_equal "/_cluster/health?level=shards", uri
   end
 
+  it "handles query parameters in path and arguments" do
+    uri = $client.expand_path "/index/_update_by_query?conflicts=proceed", routing: "1"
+
+    assert_equal "/index/_update_by_query?conflicts=proceed&routing=1", uri
+  end
+
+  it "overrides query parameters in path and with arguments" do
+    uri = $client.expand_path "/index/_update_by_query?conflicts=proceed&routing=2", routing: "1"
+
+    assert_equal "/index/_update_by_query?conflicts=proceed&routing=1", uri
+  end
+
   it "validates path expansions" do
     assert_raises(ArgumentError) {
-      $client.expand_path "/{foo}/{bar}", :foo => "_cluster", :bar => nil
+      $client.expand_path "/{foo}/{bar}", foo: "_cluster", bar: nil
     }
 
     assert_raises(ArgumentError) {
-      $client.expand_path "/{foo}/{bar}", :foo => "_cluster", :bar => ""
+      $client.expand_path "/{foo}/{bar}", foo: "_cluster", bar: ""
     }
   end
 
@@ -93,7 +128,8 @@ describe Elastomer::Client do
       username: "my_user",
       password: "my_secret_password"
     }, token_auth: "my_secret_token")
-    client = Elastomer::Client.new client_params
+    client = ElastomerClient::Client.new(**client_params)
+
     refute_match(/my_user/, client.inspect)
     refute_match(/my_secret_password/, client.inspect)
     refute_match(/my_secret_token/, client.inspect)
@@ -107,7 +143,7 @@ describe Elastomer::Client do
         username: "my_user",
         password: "my_secret_password"
       })
-      client = Elastomer::Client.new client_params
+      client = ElastomerClient::Client.new(**client_params)
 
       connection = Faraday::Connection.new
       basic_auth_spy = Spy.on(connection, :basic_auth).and_return(nil)
@@ -123,7 +159,7 @@ describe Elastomer::Client do
       client_params = $client_params.merge(basic_auth: {
         username: "my_user"
       })
-      client = Elastomer::Client.new client_params
+      client = ElastomerClient::Client.new(**client_params)
 
       connection = Faraday::Connection.new
       basic_auth_spy = Spy.on(connection, :basic_auth).and_return(nil)
@@ -132,14 +168,14 @@ describe Elastomer::Client do
         client.ping
       end
 
-      refute basic_auth_spy.has_been_called?
+      refute_predicate basic_auth_spy, :has_been_called?
     end
 
     it "ignores basic authentication if username is missing" do
       client_params = $client_params.merge(basic_auth: {
         password: "my_secret_password"
       })
-      client = Elastomer::Client.new client_params
+      client = ElastomerClient::Client.new(**client_params)
 
       connection = Faraday::Connection.new
       basic_auth_spy = Spy.on(connection, :basic_auth).and_return(nil)
@@ -148,12 +184,12 @@ describe Elastomer::Client do
         client.ping
       end
 
-      refute basic_auth_spy.has_been_called?
+      refute_predicate basic_auth_spy, :has_been_called?
     end
 
     it "can use token authentication" do
       client_params = $client_params.merge(token_auth: "my_secret_token")
-      client = Elastomer::Client.new client_params
+      client = ElastomerClient::Client.new(**client_params)
 
       connection = Faraday::Connection.new
       token_auth_spy = Spy.on(connection, :token_auth).and_return(nil)
@@ -170,7 +206,7 @@ describe Elastomer::Client do
         username: "my_user",
         password: "my_secret_password"
       }, token_auth: "my_secret_token")
-      client = Elastomer::Client.new client_params
+      client = ElastomerClient::Client.new(**client_params)
 
       connection = Faraday::Connection.new
       basic_auth_spy = Spy.on(connection, :basic_auth).and_return(nil)
@@ -180,60 +216,69 @@ describe Elastomer::Client do
         client.ping
       end
 
-      refute basic_auth_spy.has_been_called?
+      refute_predicate basic_auth_spy, :has_been_called?
       assert token_auth_spy.has_been_called_with?("my_secret_token")
     end
   end
 
   describe "when extracting and converting :body params" do
     it "deletes the :body from the params (or it gets the hose)" do
-      params = { :body => nil, :q => "what what?" }
+      params = { body: nil, q: "what what?" }
       body = $client.extract_body params
 
       assert_nil body
-      assert_equal({:q => "what what?"}, params)
+      assert_equal({q: "what what?"}, params)
     end
 
     it "leaves String values unchanged" do
-      body = $client.extract_body :body => '{"query":{"match_all":{}}}'
+      body = $client.extract_body body: '{"query":{"match_all":{}}}'
+
       assert_equal '{"query":{"match_all":{}}}', body
 
-      body = $client.extract_body :body => "not a JSON string, but who cares!"
+      body = $client.extract_body body: "not a JSON string, but who cares!"
+
       assert_equal "not a JSON string, but who cares!", body
     end
 
     it "joins Array values" do
-      body = $client.extract_body :body => %w[foo bar baz]
+      body = $client.extract_body body: %w[foo bar baz]
+
       assert_equal "foo\nbar\nbaz\n", body
 
-      body = $client.extract_body :body => [
+      body = $client.extract_body body: [
         "the first entry",
         "the second entry",
         nil
       ]
+
       assert_equal "the first entry\nthe second entry\n", body
     end
 
     it "converts values to JSON" do
-      body = $client.extract_body :body => true
+      body = $client.extract_body body: true
+
       assert_equal "true", body
 
-      body = $client.extract_body :body => {:query => {:match_all => {}}}
+      body = $client.extract_body body: {query: {match_all: {}}}
+
       assert_equal '{"query":{"match_all":{}}}', body
     end
 
     it "returns frozen strings" do
-      body = $client.extract_body :body => '{"query":{"match_all":{}}}'
+      body = $client.extract_body body: '{"query":{"match_all":{}}}'
+
       assert_equal '{"query":{"match_all":{}}}', body
-      assert body.frozen?, "the body string should be frozen"
+      assert_predicate body, :frozen?, "the body string should be frozen"
+
+      body = $client.extract_body body: %w[foo bar baz]
 
-      body = $client.extract_body :body => %w[foo bar baz]
       assert_equal "foo\nbar\nbaz\n", body
-      assert body.frozen?, "Array body strings should be frozen"
+      assert_predicate body, :frozen?, "Array body strings should be frozen"
+
+      body = $client.extract_body body: {query: {match_all: {}}}
 
-      body = $client.extract_body :body => {:query => {:match_all => {}}}
       assert_equal '{"query":{"match_all":{}}}', body
-      assert body.frozen?, "JSON encoded body strings should be frozen"
+      assert_predicate body, :frozen?, "JSON encoded body strings should be frozen"
     end
   end
 
@@ -277,12 +322,13 @@ describe Elastomer::Client do
 
   describe "top level actions" do
     it "pings the cluster" do
-      assert_equal true, $client.ping
-      assert_equal true, $client.available?
+      assert $client.ping
+      assert_predicate $client, :available?
     end
 
     it "gets cluster info" do
       h = $client.info
+
       assert h.key?("name"), "expected cluster name to be returned"
       assert h.key?("version"), "expected cluster version information to be returned"
       assert h["version"].key?("number"), "expected cluster version number to be returned"
@@ -295,7 +341,8 @@ describe Elastomer::Client do
     it "does not make an HTTP request for version if it is provided at create time" do
       request = stub_request(:get, "#{$client.url}/")
 
-      client = Elastomer::Client.new $client_params.merge(es_version: "5.6.6")
+      client = ElastomerClient::Client.new(**$client_params.merge(es_version: "5.6.6"))
+
       assert_equal "5.6.6", client.version
 
       assert_not_requested request
@@ -303,10 +350,51 @@ describe Elastomer::Client do
 
     it "gets semantic version" do
       version_string = $client.version
+
       assert_equal Semantic::Version.new(version_string), $client.semantic_version
     end
   end
 
+  describe "retry logic" do
+    it "defaults to no retries" do
+      stub_request(:get, $client.url+"/_cat/indices").
+        to_timeout.then.
+        to_return({
+          headers: {"Content-Type" => "text/plain; charset=UTF-8"},
+          body: "green open test-index 1 0 0 0 159b 159b"
+        })
+
+      assert_raises(ElastomerClient::Client::ConnectionFailed) {
+        $client.get("/_cat/indices")
+      }
+    end
+
+    it "adding retry logic retries up to 2 times" do
+      retry_count = 0
+
+      retry_options = {
+        max: 2,
+        interval: 0.05,
+        methods: [:get],
+        exceptions: Faraday::Request::Retry::DEFAULT_EXCEPTIONS + [Faraday::ConnectionFailed],
+        retry_block: proc { |env, options, retries, exc| retry_count += 1 }
+      }
+      retry_client = ElastomerClient::Client.new(port: 9205) do |connection|
+        connection.request :retry, retry_options
+      end
+
+      stub_request(:get, retry_client.url + "/").
+        to_timeout.then.
+        to_timeout.then.
+        to_return({body: %q/{"acknowledged": true}/})
+
+      response = retry_client.get("/")
+
+      assert_equal 2, retry_count
+      assert_equal({"acknowledged" => true}, response.body)
+    end
+  end
+
   describe "duplicating a client connection" do
     it "is configured the same" do
       client = $client.dup
@@ -328,72 +416,50 @@ describe Elastomer::Client do
     end
   end
 
-  describe "automatic retry of requests" do
-    before do
-      @events = []
-      @subscriber = ActiveSupport::Notifications.subscribe do |*args|
-        @events << ActiveSupport::Notifications::Event.new(*args)
+  describe "OpaqueIDError conditionals" do
+    it "does not throw OpaqueIdError for mocked response with empty opaque id" do
+      opts = $client_params.merge \
+        opaque_id: true
+      client = ElastomerClient::Client.new(**opts) do |connection|
+        connection.request(:mock_response) { |env| env.body = "{}" }
       end
-    end
 
-    after do
-      @events.clear
-      ActiveSupport::Notifications.unsubscribe(@subscriber)
-    end
-
-    it "defaults to no retries" do
-      stub_request(:get, $client.url+"/_cat/indices").
-        to_timeout.then.
-        to_return({
-          headers: {"Content-Type" => "text/plain; charset=UTF-8"},
-          body: "green open test-index 1 0 0 0 159b 159b"
-        })
+      response = client.get("/")
 
-      assert_raises(Elastomer::Client::ConnectionFailed) {
-        $client.get("/_cat/indices")
-      }
+      assert_equal "yes", response.headers["Fake"]
     end
 
-    it "retries up to `max_retries` times" do
-      stub_request(:get, $client.url+"/test-index/_settings").
-        to_timeout.then.
-        to_timeout.then.
-        to_return({body: %q/{"acknowledged": true}/})
+    it "throws OpaqueIdError on mismatched ID" do
+      client_params = $client_params.merge \
+        opaque_id: true
+      client = ElastomerClient::Client.new(**client_params)
 
-      response = $client.index("test-index").settings(max_retries: 2)
+      test_url = "#{client.url}/"
+      stub_request(:get, test_url).and_return(status: 200, headers: { "Content-Type" => "application/json", "X-Opaque-Id" => "foo" })
 
-      assert_equal 2, @events.first.payload[:retries]
-      assert_equal({"acknowledged" => true}, response)
+      assert_raises(ElastomerClient::Client::OpaqueIdError) { client.request :get, test_url, {} }
     end
 
-    it "does not retry on PUT requests" do
-      stub_request(:put, $client.url+"/test-index").
-        to_timeout.then.
-        to_return({body: %q/{"acknowledged": true}/})
+    it "throws OpaqueIdError on empty string ID" do
+      client_params = $client_params.merge \
+        opaque_id: true
+      client = ElastomerClient::Client.new(**client_params)
 
-      assert_raises(Elastomer::Client::ConnectionFailed) {
-        $client.index("test-index").create({}, max_retries: 1)
-      }
-    end
-
-    it "does not retry on POST requests" do
-      stub_request(:post, $client.url+"/test-index/_flush").
-        to_timeout.then.
-        to_return({body: %q/{"acknowledged": true}/})
+      test_url = "#{client.url}/"
+      stub_request(:get, test_url).and_return(status: 200, headers: { "Content-Type" => "application/json", "X-Opaque-Id" => "" })
 
-      assert_raises(Elastomer::Client::ConnectionFailed) {
-        $client.index("test-index").flush(max_retries: 1)
-      }
+      assert_raises(ElastomerClient::Client::OpaqueIdError) { client.request :get, test_url, {} }
     end
 
-    it "does not retry on DELETE requests" do
-      stub_request(:delete, $client.url+"/test-index").
-        to_timeout.then.
-        to_return({body: %q/{"acknowledged": true}/})
+    it "throws ServerError and not OpaqueIdError on 5xx response and nil ID" do
+      client_params = $client_params.merge \
+        opaque_id: true
+      client = ElastomerClient::Client.new(**client_params)
 
-      assert_raises(Elastomer::Client::ConnectionFailed) {
-        $client.index("test-index").delete(max_retries: 1)
-      }
+      test_url = "#{client.url}/"
+      stub_request(:get, test_url).and_return(status: 503, headers: { "Content-Type" => "application/json" })
+
+      assert_raises(ElastomerClient::Client::ServerError) { client.request :get, test_url, {} }
     end
   end
 end

data/test/core_ext/time_test.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 require File.expand_path("../../test_helper", __FILE__)
-require "elastomer/core_ext/time"
+require "elastomer_client/core_ext/time"
 
 describe "JSON conversions for Time" do
   before do
@@ -8,16 +10,14 @@ describe "JSON conversions for Time" do
 
     unless @index.exists?
       @index.create \
-        :settings => { "index.number_of_shards" => 1, "index.number_of_replicas" => 0 },
-        :mappings => {
-          :doc1 => {
-            :_source => { :enabled => true }, :_all => { :enabled => false },
-            :properties => {
-              :title      => $client.version_support.keyword,
-              :created_at => { :type => "date" }
-            }
+        settings: { "index.number_of_shards" => 1, "index.number_of_replicas" => 0 },
+        mappings: mappings_wrapper("book", {
+          _source: { enabled: true },
+          properties: {
+            title: { type: "keyword" },
+            created_at: { type: "date" }
           }
-        }
+        }, !$client.version_support.es_version_8_plus?)
 
       wait_for_index(@name)
     end
@@ -31,16 +31,18 @@ describe "JSON conversions for Time" do
 
   it "generates ISO8601 formatted time strings" do
     time = Time.utc(2013, 5, 3, 10, 1, 31)
+
     assert_equal '"2013-05-03T10:01:31.000Z"', MultiJson.encode(time)
   end
 
   it "indexes time fields" do
     time = Time.utc(2013, 5, 3, 10, 1, 31)
-    h = @docs.index({:title => "test document", :created_at => time}, :type => "doc1")
+    h = @docs.index(document_wrapper("book", {title: "Book 1", created_at: time}))
 
     assert_created(h)
 
-    doc = @docs.get(:type => "doc1", :id => h["_id"])
+    doc = $client.version_support.es_version_8_plus? ? @docs.get(id: h["_id"]) : @docs.get(type: "book", id: h["_id"])
+
     assert_equal "2013-05-03T10:01:31.000Z", doc["_source"]["created_at"]
   end
 end

data/test/middleware/encode_json_test.rb

@@ -1,61 +1,72 @@
+# frozen_string_literal: true
+
 require File.expand_path("../../test_helper", __FILE__)
 
-describe Elastomer::Middleware::EncodeJson do
-  let(:middleware) { Elastomer::Middleware::EncodeJson.new(lambda {|env| env})}
+describe ElastomerClient::Middleware::EncodeJson do
+  let(:middleware) { ElastomerClient::Middleware::EncodeJson.new(lambda { |env| env }) }
 
   def process(body, content_type: nil, method: :post)
-    env = { :body => body, :request_headers => Faraday::Utils::Headers.new, method: method }
+    env = { body:, request_headers: Faraday::Utils::Headers.new, method: }
     env[:request_headers]["content-type"] = content_type if content_type
     middleware.call(env)
   end
 
   it "handles no body" do
     result = process(nil)
+
     assert_nil result[:body]
     assert_equal "application/json", result[:request_headers]["content-type"]
 
     result = process(nil, method: :get)
+
     assert_nil result[:body]
     assert_nil result[:request_headers]["content-type"]
   end
 
   it "handles empty body" do
     result = process("")
+
     assert_empty result[:body]
     assert_equal "application/json", result[:request_headers]["content-type"]
 
     result = process("", method: :get)
+
     assert_empty result[:body]
     assert_nil result[:request_headers]["content-type"]
   end
 
   it "handles string body" do
     result = process('{"a":1}')
+
     assert_equal '{"a":1}', result[:body]
     assert_equal "application/json", result[:request_headers]["content-type"]
   end
 
   it "handles object body" do
-    result = process({:a => 1})
+    result = process({a: 1})
+
     assert_equal '{"a":1}', result[:body]
     assert_equal "application/json", result[:request_headers]["content-type"]
   end
 
   it "handles empty object body" do
     result = process({})
+
     assert_equal "{}", result[:body]
     assert_equal "application/json", result[:request_headers]["content-type"]
   end
 
   it "handles object body with json type" do
-    result = process({:a => 1}, content_type: "application/json; charset=utf-8")
+    result = process({a: 1}, content_type: "application/json; charset=utf-8")
+
     assert_equal '{"a":1}', result[:body]
     assert_equal "application/json; charset=utf-8", result[:request_headers]["content-type"]
   end
 
   it "handles object body with incompatible type" do
-    result = process({:a => 1}, content_type: "application/xml; charset=utf-8")
-    assert_equal({:a => 1}, result[:body])
+    result = process({a: 1}, content_type: "application/xml; charset=utf-8")
+
+    assert_equal({a: 1}, result[:body])
     assert_equal "application/xml; charset=utf-8", result[:request_headers]["content-type"]
   end
 end

data/test/middleware/opaque_id_test.rb

@@ -1,53 +1,56 @@
+# frozen_string_literal: true
+
 require File.expand_path("../../test_helper", __FILE__)
 
-describe Elastomer::Middleware::OpaqueId do
+describe ElastomerClient::Middleware::OpaqueId do
 
   before do
     stubs = Faraday::Adapter::Test::Stubs.new do |stub|
       stub.get("/_cluster/health") { |env|
-        [ 200,
+        [200,
 
           { "X-Opaque-Id"    => env[:request_headers]["X-Opaque-Id"],
             "Content-Type"   => "application/json; charset=UTF-8",
             "Content-Length" => "49" },
 
           %q[{"cluster_name":"elasticsearch","status":"green"}]
-        ]
+]
       }
 
       stub.get("/_cluster/state") { |env|
-        [ 200, {"X-Opaque-Id" => "00000000-0000-0000-0000-000000000000"}, %q[{"foo":"bar"}] ]
+        [200, {"X-Opaque-Id" => "00000000-0000-0000-0000-000000000000"}, %q[{"foo":"bar"}]]
       }
     end
 
     opts = $client_params.merge \
-        :opaque_id => true,
-        :adapter   => [:test, stubs]
+        opaque_id: true,
+        adapter: [:test, stubs]
 
-    @client = Elastomer::Client.new opts
+    @client = ElastomerClient::Client.new(**opts)
     @client.instance_variable_set(:@version, "5.6.4")
   end
 
   it 'generates an "X-Opaque-Id" header' do
     health = @client.cluster.health
+
     assert_equal({"cluster_name" => "elasticsearch", "status" => "green"}, health)
   end
 
   it "raises an exception on conflicting headers" do
-    assert_raises(Elastomer::Client::OpaqueIdError) { @client.cluster.state }
+    assert_raises(ElastomerClient::Client::OpaqueIdError) { @client.cluster.state }
   end
 
-  it 'generates a UUID per call' do
-    opaque_id = Elastomer::Middleware::OpaqueId.new
+  it "generates a UUID per call" do
+    opaque_id = ElastomerClient::Middleware::OpaqueId.new
 
     uuid1 = opaque_id.generate_uuid
     uuid2 = opaque_id.generate_uuid
 
-    assert uuid1 != uuid2, "UUIDs should be unique"
+    refute_equal uuid1, uuid2, "UUIDs should be unique"
   end
 
-  it 'generates a UUID per thread' do
-    opaque_id = Elastomer::Middleware::OpaqueId.new
+  it "generates a UUID per thread" do
+    opaque_id = ElastomerClient::Middleware::OpaqueId.new
     uuids = []
     threads = []
 
@@ -61,7 +64,8 @@ describe Elastomer::Middleware::OpaqueId do
     # each UUID has 16 random characters as the base ID
     uuids.each { |uuid| assert_match(%r/\A[a-zA-Z0-9_-]{16}0{8}\z/, uuid) }
 
-    bases = uuids.map { |uuid| uuid[0,16] }
+    bases = uuids.map { |uuid| uuid[0, 16] }
+
     assert_equal 3, bases.uniq.length, "each thread did not get a unique base ID"
   end
 end