elastomer-client 3.2.2 → 6.2.0

data/test/client/snapshot_test.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require_relative "../test_helper"
 
-describe Elastomer::Client::Snapshot do
+describe ElastomerClient::Client::Snapshot do
   before do
     @index = nil
     @restored_index = nil
@@ -12,6 +14,9 @@ describe Elastomer::Client::Snapshot do
     @index_name = "elastomer-snapshot-test-index"
     @index = $client.index(@index_name)
     @name = "elastomer-test"
+    if $client.version_support.es_version_8_plus?
+      $client.cluster.update_settings persistent: { "ingest.geoip.downloader.enabled" => "false" }
+    end
   end
 
   after do
@@ -21,24 +26,28 @@ describe Elastomer::Client::Snapshot do
   it "determines if a snapshot exists" do
     with_tmp_repo do |repo|
       snapshot = repo.snapshot(@name)
-      assert_equal false, snapshot.exists?
-      assert_equal false, snapshot.exist?
-      snapshot.create({}, :wait_for_completion => true)
-      assert_equal true, snapshot.exist?
+
+      refute_predicate snapshot, :exists?
+      refute_predicate snapshot, :exist?
+      snapshot.create({}, wait_for_completion: true)
+
+      assert_predicate snapshot, :exist?
     end
   end
 
   it "creates snapshots" do
     with_tmp_repo do |repo|
-      response = repo.snapshot(@name).create({}, :wait_for_completion => true)
+      response = repo.snapshot(@name).create({}, wait_for_completion: true)
+
       assert_equal @name, response["snapshot"]["snapshot"]
     end
   end
 
   it "creates snapshots with options" do
-    @index.create(:number_of_shards => 1, :number_of_replicas => 0)
+    @index.create(settings: { number_of_shards: 1, number_of_replicas: 0 })
     with_tmp_repo do |repo|
-      response = repo.snapshot(@name).create({:indices => [@index_name]}, :wait_for_completion => true)
+      response = repo.snapshot(@name).create({ indices: [@index_name] }, wait_for_completion: true)
+
       assert_equal [@index_name], response["snapshot"]["indices"]
       assert_equal 1, response["snapshot"]["shards"]["total"]
     end
@@ -47,17 +56,20 @@ describe Elastomer::Client::Snapshot do
   it "gets snapshot info for one and all" do
     with_tmp_snapshot do |snapshot, repo|
       response = snapshot.get
+
       assert_equal snapshot.name, response["snapshots"][0]["snapshot"]
       response = repo.snapshots.get
+
       assert_equal snapshot.name, response["snapshots"][0]["snapshot"]
     end
   end
 
   it "gets snapshot status for one and all" do
-    @index.create(:number_of_shards => 1, :number_of_replicas => 0)
+    @index.create(settings: { number_of_shards: 1, number_of_replicas: 0 })
     with_tmp_repo do |repo|
-      repo.snapshot(@name).create({:indices => [@index_name]}, :wait_for_completion => true)
+      repo.snapshot(@name).create({indices: [@index_name]}, wait_for_completion: true)
       response = repo.snapshot(@name).status
+
       assert_equal 1, response["snapshots"][0]["shards_stats"]["total"]
     end
   end
@@ -67,9 +79,11 @@ describe Elastomer::Client::Snapshot do
     # check for an empty result instead
     with_tmp_repo do |repo|
       response = repo.snapshots.status
-      assert_equal [], response["snapshots"]
+
+      assert_empty response["snapshots"]
       response = $client.snapshot.status
-      assert_equal [], response["snapshots"]
+
+      assert_empty response["snapshots"]
     end
   end
 
@@ -81,18 +95,20 @@ describe Elastomer::Client::Snapshot do
   it "deletes snapshots" do
     with_tmp_snapshot do |snapshot|
       response = snapshot.delete
-      assert_equal true, response["acknowledged"]
+
+      assert response["acknowledged"]
     end
   end
 
   it "restores snapshots" do
-    @index.create(:number_of_shards => 1, :number_of_replicas => 0)
+    @index.create(settings: { number_of_shards: 1, number_of_replicas: 0 })
     wait_for_index(@index_name)
     with_tmp_repo do |repo|
       snapshot = repo.snapshot(@name)
-      snapshot.create({:indices => [@index_name]}, :wait_for_completion => true)
+      snapshot.create({ indices: [@index_name] }, wait_for_completion: true)
       @index.delete
-      response = snapshot.restore({}, :wait_for_completion => true)
+      response = snapshot.restore({}, wait_for_completion: true)
+
       assert_equal 1, response["snapshot"]["shards"]["total"]
     end
   end
@@ -108,15 +124,16 @@ describe Elastomer::Client::Snapshot do
     end
 
     it "restores snapshots with options" do
-      @index.create(:number_of_shards => 1, :number_of_replicas => 0)
+      @index.create(settings: { number_of_shards: 1, number_of_replicas: 0 })
       wait_for_index(@index_name)
       with_tmp_repo do |repo|
         snapshot = repo.snapshot(@name)
-        snapshot.create({:indices => [@index_name]}, :wait_for_completion => true)
+        snapshot.create({indices: [@index_name]}, wait_for_completion: true)
         response = snapshot.restore({
-          :rename_pattern => @index_name,
-          :rename_replacement => @restored_index_name
-        }, :wait_for_completion => true)
+          rename_pattern: @index_name,
+          rename_replacement: @restored_index_name
+        }, wait_for_completion: true)
+
         assert_equal [@restored_index_name], response["snapshot"]["indices"]
         assert_equal 1, response["snapshot"]["shards"]["total"]
       end

data/test/client/stubbed_client_test.rb

@@ -1,21 +1,24 @@
+# frozen_string_literal: true
+
 require_relative "../test_helper"
 
 describe "stubbed client tests" do
   before do
     @stubs  = Faraday::Adapter.lookup_middleware(:test)::Stubs.new
-    @client = Elastomer::Client.new :adapter => [:test, @stubs]
+    @client = ElastomerClient::Client.new adapter: [:test, @stubs]
     @client.instance_variable_set(:@version, "5.6.4")
   end
 
-  describe Elastomer::Client::Cluster do
+  describe ElastomerClient::Client::Cluster do
     it "reroutes shards" do
       @stubs.post "/_cluster/reroute?dry_run=true" do |env|
         assert_match %r/^\{"commands":\[\{"move":\{[^\{\}]+\}\}\]\}$/, env[:body]
         [200, {"Content-Type" => "application/json"}, '{"acknowledged" : true}']
       end
 
-      commands = { :move => { :index => "test", :shard => 0, :from_node => "node1", :to_node => "node2" }}
-      h = @client.cluster.reroute commands, :dry_run => true
+      commands = { move: { index: "test", shard: 0, from_node: "node1", to_node: "node2" }}
+      h = @client.cluster.reroute commands, dry_run: true
+
       assert_acknowledged h
     end
   end

data/test/client/tasks_test.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require_relative "../test_helper"
 
-describe Elastomer::Client::Tasks do
+describe ElastomerClient::Client::Tasks do
   before do
     @tasks = $client.tasks
 
@@ -15,20 +17,19 @@ describe Elastomer::Client::Tasks do
 
   it "list all in-flight tasks" do
     h = @tasks.get
-    assert h["nodes"].keys.size > 0
+
+    assert_operator h["nodes"].keys.size, :>, 0
 
     total_tasks = h["nodes"].map { |k, v| v["tasks"].keys.count }.sum
-    assert total_tasks > 0
+
+    assert_operator total_tasks, :>, 0
   end
 
   it "groups by parent->child relationships when get-all tasks API is grouped by 'parents'" do
-    unless $client.version_support.es_version_5_x?
-      skip "Tasks API is not supported in ES version #{$client.version}"
-    end
-
-    h = @tasks.get :group_by => "parents"
+    h = @tasks.get group_by: "parents"
     parent_id = h["tasks"].select { |k, v| v.key?("children") }.keys.first
     childs_parent_ref = h.dig("tasks", parent_id, "children").first["parent_task_id"]
+
     assert_equal parent_id, childs_parent_ref
   end
 
@@ -47,7 +48,7 @@ describe Elastomer::Client::Tasks do
 
   it "raises exception when get_by_id is called w/invalid node ID is supplied" do
     assert_raises(ArgumentError) do
-        @tasks.get_by_id nil, 42
+      @tasks.get_by_id nil, 42
     end
   end
 
@@ -64,7 +65,7 @@ describe Elastomer::Client::Tasks do
         begin
           resp = @tasks.wait_by_id t["node"], t["id"], "3s"
           success = !resp.key?("node_failures")
-        rescue Elastomer::Client::ServerError => e
+        rescue ElastomerClient::Client::ServerError => e
           # this means the timeout expired before the task finished, but it's a good thing!
           success = /Timed out waiting for completion/ =~ e.message
         end
@@ -90,13 +91,7 @@ describe Elastomer::Client::Tasks do
         t = ts.values.first
         resp = @tasks.get_by_id t["node"], t["id"]
 
-        # ES 5.x and 2.x responses are structured differently
-        if $client.version_support.tasks_new_response_format?
-          found_by_id = resp["task"]["node"] == t["node"] && resp["task"]["id"] == t["id"]
-        else
-          nid, tid = resp["nodes"][t["node"]]["tasks"].keys.first.split(":")
-          found_by_id = nid == t["node"] && tid.to_i == t["id"]
-        end
+        found_by_id = resp["task"]["node"] == t["node"] && resp["task"]["id"] == t["id"]
 
         break if found_by_id
       end

data/test/client/template_test.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require_relative "../test_helper"
 
-describe Elastomer::Client::Cluster do
+describe ElastomerClient::Client::Cluster do
 
   before do
     @name = "elastomer-template-test"
@@ -12,27 +14,46 @@ describe Elastomer::Client::Cluster do
   end
 
   it "lists templates in the cluster" do
-    @template.create({:template => "test-elastomer*"})
+    if $client.version_support.es_version_8_plus?
+      @template.create({index_patterns: ["test-elastomer*"]})
+    else
+      @template.create({template: "test-elastomer*"})
+    end
     templates = $client.cluster.templates
-    assert !templates.empty?, "expected to see a template"
+
+    refute_empty templates, "expected to see a template"
   end
 
   it "creates a template" do
-    assert !@template.exists?, "the template should not exist"
-
-    @template.create({
-      :template => "test-elastomer*",
-      :settings => { :number_of_shards => 3 },
-      :mappings => {
-        :doco => { :_source => { :enabled => false }}
-      }
+    refute_predicate @template, :exists?, "the template should not exist"
+
+    if $client.version_support.es_version_8_plus?
+      template_config = {index_patterns: ["test-elastomer*"]}
+    else
+      template_config = {template: "test-elastomer*"}
+    end
+
+    template_config.merge!({
+      settings: { number_of_shards: 3 },
+      mappings: mappings_wrapper("book", {
+        _source: { enabled: false }
+      })
     })
 
-    assert @template.exists?, " we now have a cluster-test template"
+    @template.create(template_config)
+
+    assert_predicate @template, :exists?, " we now have a cluster-test template"
 
     template = @template.get
+
     assert_equal [@name], template.keys
-    assert_equal "test-elastomer*", template[@name]["template"]
+
+    if $client.version_support.es_version_8_plus?
+      assert_equal "test-elastomer*", template[@name]["index_patterns"][0]
+    else
+      assert_equal "test-elastomer*", template[@name]["template"]
+    end
+
     assert_equal "3", template[@name]["settings"]["index"]["number_of_shards"]
   end
 end

data/test/client/update_by_query_test.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+describe ElastomerClient::Client::UpdateByQuery do
+  before do
+    @index = $client.index "elastomer-update-by-query-test"
+    @index.delete if @index.exists?
+    @docs = @index.docs("docs")
+  end
+
+  after do
+    @index.delete if @index.exists?
+  end
+
+  describe "when an index with documents exists" do
+    before do
+      @index.create(nil)
+      wait_for_index(@index.name)
+    end
+
+    it "updates by query" do
+      @docs.index({ _id: 0, name: "mittens" })
+      @docs.index({ _id: 1, name: "luna" })
+
+      @index.refresh
+
+      query = {
+        query: {
+          match: {
+            name: "mittens"
+          }
+        },
+        script: {
+          source: "ctx._source.name = 'mittens updated'"
+        }
+      }
+
+      response = @index.update_by_query(query)
+
+      refute_nil response["took"]
+      refute(response["timed_out"])
+      assert_equal(1, response["batches"])
+      assert_equal(1, response["total"])
+      assert_equal(1, response["updated"])
+      assert_empty(response["failures"])
+
+      @index.refresh
+      response = @docs.multi_get(ids: [0, 1])
+
+      assert_equal "mittens updated", response.fetch("docs")[0]["_source"]["name"]
+      assert_equal "luna", response.fetch("docs")[1]["_source"]["name"]
+    end
+
+    it "fails when internal version is 0" do
+      if $client.version_support.es_version_8_plus?
+        skip "Concurrency control with internal version is not supported in ES #{$client.version}"
+      end
+      @docs.index({_id: 0, name: "mittens"})
+      # Creating a document with external version 0 also sets the internal version to 0
+      # Otherwise you can't index a document with version 0.
+      @docs.index({_id: 1, _version: 0, _version_type: "external", name: "mittens"})
+      @index.refresh
+
+      query = {
+        query: {
+          match: {
+            name: "mittens"
+          }
+        }
+      }
+
+      assert_raises(ElastomerClient::Client::RequestError) do
+        @index.update_by_query(query)
+      end
+    end
+
+    it "fails when an unknown parameter is provided" do
+      assert_raises(ElastomerClient::Client::IllegalArgument) do
+        @index.update_by_query({}, foo: "bar")
+      end
+    end
+
+    it "updates by query when routing is specified" do
+      index = $client.index "elastomer-update-by-query-routing-test"
+      index.delete if index.exists?
+      type = "docs"
+      # default number of shards in ES8 is 1, so set it to 2 shards so routing to different shards can be tested
+      settings = $client.version_support.es_version_8_plus? ? { number_of_shards: 2 } : {}
+      index.create({
+        settings:,
+        mappings: mappings_wrapper(type, {
+          properties: {
+            name: { type: "text", analyzer: "standard" },
+          },
+          _routing: { required: true }
+        })
+      })
+      wait_for_index(@index.name)
+      docs = index.docs(type)
+
+      docs.index({ _id: 0, _routing: "cat", name: "mittens" })
+      docs.index({ _id: 1, _routing: "cat", name: "luna" })
+      docs.index({ _id: 2, _routing: "dog", name: "mittens" })
+
+      query = {
+        query: {
+          match: {
+            name: "mittens"
+          }
+        },
+        script: {
+          source: "ctx._source.name = 'mittens updated'"
+        }
+      }
+
+      index.refresh
+      response = index.update_by_query(query, routing: "cat")
+
+      assert_equal(1, response["updated"])
+
+      response = docs.multi_get({
+        docs: [
+          { _id: 0, routing: "cat" },
+          { _id: 1, routing: "cat" },
+          { _id: 2, routing: "dog" },
+        ]
+      })
+
+      assert_equal "mittens updated", response.fetch("docs")[0]["_source"]["name"]
+      assert_equal "luna", response.fetch("docs")[1]["_source"]["name"]
+      assert_equal "mittens", response.fetch("docs")[2]["_source"]["name"]
+
+      index.delete if index.exists?
+    end
+  end
+end