elastomer-client 3.2.2 → 6.2.0

data/test/client/nodes_test.rb

@@ -1,55 +1,66 @@
+# frozen_string_literal: true
+
 require_relative "../test_helper"
 
-describe Elastomer::Client::Nodes do
+describe ElastomerClient::Client::Nodes do
 
   it "gets info for the node(s)" do
     h = $client.nodes.info
+
     assert h.key?("cluster_name"), "the cluster name is returned"
     assert_instance_of Hash, h["nodes"], "the node list is returned"
   end
 
   it "gets stats for the node(s)" do
     h = $client.nodes.stats
+
     assert_instance_of Hash, h["nodes"], "the node list is returned"
 
     node = h["nodes"].values.first
+
     assert node.key?("indices"), "indices stats are returned"
   end
 
   it "filters node info" do
-    h = $client.nodes.info(:info => "os")
+    h = $client.nodes.info(info: "os")
     node = h["nodes"].values.first
+
     assert node.key?("os"), "expected os info to be present"
-    assert !node.key?("jvm"), "expected jvm info to be absent"
+    refute node.key?("jvm"), "expected jvm info to be absent"
 
-    h = $client.nodes.info(:info => %w[jvm process])
+    h = $client.nodes.info(info: %w[jvm process])
     node = h["nodes"].values.first
+
     assert node.key?("jvm"), "expected jvm info to be present"
     assert node.key?("process"), "expected process info to be present"
-    assert !node.key?("network"), "expected network info to be absent"
+    refute node.key?("network"), "expected network info to be absent"
   end
 
   it "filters node stats" do
-    h = $client.nodes.stats(:stats => "http")
+    h = $client.nodes.stats(stats: "http")
     node = h["nodes"].values.first
+
     assert node.key?("http"), "expected http stats to be present"
-    assert !node.key?("indices"), "expected indices stats to be absent"
+    refute node.key?("indices"), "expected indices stats to be absent"
   end
 
   it "gets the hot threads for the node(s)" do
-    str = $client.nodes.hot_threads :read_timeout => 2
+    str = $client.nodes.hot_threads read_timeout: 2
+
     assert_instance_of String, str
-    assert !str.nil?, "expected response to not be nil"
-    assert !str.empty?, "expected response to not be empty"
+    refute_nil str, "expected response to not be nil"
+    refute_empty str, "expected response to not be empty"
   end
 
   it "can be scoped to a single node" do
     h = $client.nodes("node-with-no-name").info
+
     assert_empty h["nodes"]
   end
 
   it "can be scoped to multiple nodes" do
     h = $client.nodes(%w[node1 node2 node3]).info
+
     assert_empty h["nodes"]
   end
 

data/test/client/percolator_test.rb

@@ -1,8 +1,14 @@
+# frozen_string_literal: true
+
 require_relative "../test_helper"
 
-describe Elastomer::Client::Percolator do
+describe ElastomerClient::Client::Percolator do
 
   before do
+    if $client.version_support.es_version_8_plus?
+      skip "Percolate not supported in ES version #{$client.version}"
+    end
+
     @index = $client.index "elastomer-percolator-test"
     @index.delete if @index.exists?
     @docs = @index.docs("docs")
@@ -14,13 +20,7 @@ describe Elastomer::Client::Percolator do
 
   describe "when an index exists" do
     before do
-      # COMPATIBILITY
-      base_mappings =
-        if requires_percolator_mapping?
-          { :mappings => { :percolator => { :properties => { :query => { :type => "percolator" } } } } }
-        else
-          nil
-        end
+      base_mappings = { mappings: { percolator: { properties: { query: { type: "percolator" } } } } }
 
       @index.create(base_mappings)
       wait_for_index(@index.name)
@@ -28,29 +28,34 @@ describe Elastomer::Client::Percolator do
 
     it "creates a query" do
       percolator = @index.percolator "1"
-      response = percolator.create :query => { :match_all => { } }
+      response = percolator.create query: { match_all: { } }
+
       assert response["created"], "Couldn't create the percolator query"
     end
 
     it "gets a query" do
       percolator = @index.percolator "1"
-      percolator.create :query => { :match_all => { } }
+      percolator.create query: { match_all: { } }
       response = percolator.get
+
       assert response["found"], "Couldn't find the percolator query"
     end
 
     it "deletes a query" do
       percolator = @index.percolator "1"
-      percolator.create :query => { :match_all => { } }
+      percolator.create query: { match_all: { } }
       response = percolator.delete
+
       assert response["found"], "Couldn't find the percolator query"
     end
 
     it "checks for the existence of a query" do
       percolator = @index.percolator "1"
-      refute percolator.exists?, "Percolator query exists"
-      percolator.create :query => { :match_all => { } }
-      assert percolator.exists?, "Percolator query does not exist"
+
+      refute_predicate percolator, :exists?, "Percolator query exists"
+      percolator.create query: { match_all: { } }
+
+      assert_predicate percolator, :exists?, "Percolator query does not exist"
     end
 
     it "cannot delete all percolators by providing a nil id" do

data/test/client/reindex_test.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+describe ElastomerClient::Client::Reindex do
+  before do
+    @source_index = $client.index("source_index")
+    @dest_index = $client.index("dest_index")
+    @non_existent_index = $client.index("non_existent_index")
+    if @source_index.exists?
+      @source_index.delete
+    end
+    if @dest_index.exists?
+      @dest_index.delete
+    end
+    if @non_existent_index.exists?
+      @non_existent_index.delete
+    end
+    @source_index.create(default_index_settings)
+    @dest_index.create(default_index_settings)
+    wait_for_index(@source_index.name, "green")
+    wait_for_index(@dest_index.name, "green")
+
+    # Index a document in the source index
+    @source_index.docs.index(document_wrapper("book", { _id: 1, title: "Book 1" }))
+    @source_index.refresh
+  end
+
+  after do
+    @source_index.delete if @source_index.exists?
+    @dest_index.delete if @dest_index.exists?
+    @non_existent_index.delete if @non_existent_index.exists?
+  end
+
+  it "reindexes documents from one index to another" do
+    reindex = $client.reindex
+    body = {
+      source: { index: @source_index.name },
+      dest: { index: @dest_index.name }
+    }
+    reindex.reindex(body)
+
+    # Refresh the destination index to make sure the document is searchable
+    @dest_index.refresh
+
+    # Verify that the document has been reindexed
+    doc = @dest_index.docs.get(id: 1, type: "book")
+
+    assert_equal "Book 1", doc["_source"]["title"]
+  end
+
+  it "creates a new index when the destination index does not exist" do
+    reindex = $client.reindex
+    body = {
+      source: { index: @source_index.name },
+      dest: { index: "non_existent_index" }
+    }
+    reindex.reindex(body)
+    new_index = $client.index("non_existent_index")
+
+    assert_predicate(new_index, :exists?)
+  end
+
+  it "fails when the source index does not exist" do
+    reindex = $client.reindex
+    body = {
+      source: { index: "non_existent_index" },
+      dest: { index: @dest_index.name }
+    }
+
+    exception = assert_raises(ElastomerClient::Client::RequestError) do
+      response = reindex.reindex(body)
+    end
+    assert_equal(404, exception.status)
+  end
+end

data/test/client/repository_test.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require_relative "../test_helper"
 
-describe Elastomer::Client::Repository do
+describe ElastomerClient::Client::Repository do
   before do
     if !run_snapshot_tests?
       skip "To enable snapshot tests, add a path.repo setting to your elasticsearch.yml file."
@@ -11,28 +13,30 @@ describe Elastomer::Client::Repository do
   end
 
   it "determines if a repo exists" do
-    assert_equal false, @repo.exists?
-    assert_equal false, @repo.exist?
+    refute_predicate @repo, :exists?
+    refute_predicate @repo, :exist?
     with_tmp_repo(@name) do
-      assert_equal true, @repo.exists?
+      assert_predicate @repo, :exists?
     end
   end
 
   it "creates repos" do
     response = create_repo(@name)
-    assert_equal true, response["acknowledged"]
+
+    assert response["acknowledged"]
     delete_repo(@name)
   end
 
   it "cannot create a repo without a name" do
-    lambda {
+    _(lambda {
       create_repo(nil)
-    }.must_raise ArgumentError
+    }).must_raise ArgumentError
   end
 
   it "gets repos" do
     with_tmp_repo do |repo|
       response = repo.get
+
       refute_nil response[repo.name]
     end
   end
@@ -40,6 +44,7 @@ describe Elastomer::Client::Repository do
   it "gets all repos" do
     with_tmp_repo do |repo|
       response = $client.repository.get
+
       refute_nil response[repo.name]
     end
   end
@@ -47,59 +52,66 @@ describe Elastomer::Client::Repository do
   it "gets repo status" do
     with_tmp_repo do |repo|
       response = repo.status
-      assert_equal [], response["snapshots"]
+
+      assert_empty response["snapshots"]
     end
   end
 
   it "gets status of all repos" do
     response = $client.repository.status
-    assert_equal [], response["snapshots"]
+
+    assert_empty response["snapshots"]
   end
 
   it "updates repos" do
     with_tmp_repo do |repo|
       settings = repo.get[repo.name]["settings"]
-      response = repo.update(:type => "fs", :settings => settings.merge("compress" => true))
-      assert_equal true, response["acknowledged"]
+      response = repo.update(type: "fs", settings: settings.merge("compress" => true))
+
+      assert response["acknowledged"]
       assert_equal "true", repo.get[repo.name]["settings"]["compress"]
     end
   end
 
   it "cannot update a repo without a name" do
     with_tmp_repo do |repo|
-      lambda {
+      _(lambda {
         settings = repo.get[repo.name]["settings"]
-        $client.repository.update(:type => "fs", :settings => settings.merge("compress" => true))
-      }.must_raise ArgumentError
+        $client.repository.update(type: "fs", settings: settings.merge("compress" => true))
+      }).must_raise ArgumentError
     end
   end
 
   it "deletes repos" do
     with_tmp_repo do |repo|
       response = repo.delete
-      assert_equal true, response["acknowledged"]
-      assert_equal false, repo.exists?
+
+      assert response["acknowledged"]
+      refute_predicate repo, :exists?
     end
   end
 
   it "cannot delete a repo without a name" do
-    lambda {
+    _(lambda {
       $client.repository.delete
-    }.must_raise ArgumentError
+    }).must_raise ArgumentError
   end
 
   it "gets snapshots" do
     with_tmp_repo do |repo|
       response = repo.snapshots.get
-      assert_equal [], response["snapshots"]
+
+      assert_empty response["snapshots"]
 
       create_snapshot(repo, "test-snapshot")
       response = repo.snapshot.get
+
       assert_equal ["test-snapshot"], response["snapshots"].collect { |info| info["snapshot"] }
 
       create_snapshot(repo, "test-snapshot2")
       response  = repo.snapshots.get
       snapshot_names = response["snapshots"].collect { |info| info["snapshot"] }
+
       assert_includes snapshot_names, "test-snapshot"
       assert_includes snapshot_names, "test-snapshot2"
     end

data/test/client/rest_api_spec/api_spec_test.rb

@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 require_relative "../../test_helper"
 
-describe Elastomer::Client::RestApiSpec::ApiSpec do
+describe ElastomerClient::Client::RestApiSpec::ApiSpec do
   before do
-    @api_spec = Elastomer::Client::RestApiSpec.api_spec("5.6.4")
+    @api_spec = ElastomerClient::Client::RestApiSpec.api_spec("5.6.4")
   end
 
   it "selects valid path parts" do
-    parts  = {index: "test", "type" => "doc", foo: "bar"}
+    parts  = {:index => "test", "type" => "doc", :foo => "bar"}
     result = @api_spec.select_parts(api: "search", from: parts)
 
-    assert_equal({index: "test", "type" => "doc"}, result)
+    assert_equal({:index => "test", "type" => "doc"}, result)
   end
 
   it "identifies valid path parts" do
@@ -19,10 +21,10 @@ describe Elastomer::Client::RestApiSpec::ApiSpec do
   end
 
   it "selects valid request params" do
-    params = {explain: true, "preference" => "local", nope: "invalid"}
+    params = {:explain => true, "preference" => "local", :nope => "invalid"}
     result = @api_spec.select_params(api: "search", from: params)
 
-    assert_equal({explain: true, "preference" => "local"}, result)
+    assert_equal({:explain => true, "preference" => "local"}, result)
   end
 
   it "identifies valid request params" do
@@ -33,10 +35,10 @@ describe Elastomer::Client::RestApiSpec::ApiSpec do
   end
 
   it "selects common request params" do
-    params = {pretty: true, "human" => true, nope: "invalid"}
+    params = {:pretty => true, "human" => true, :nope => "invalid"}
     result = @api_spec.select_common_params(from: params)
 
-    assert_equal({pretty: true, "human" => true}, result)
+    assert_equal({:pretty => true, "human" => true}, result)
   end
 
   it "identifies common request params" do
@@ -47,9 +49,9 @@ describe Elastomer::Client::RestApiSpec::ApiSpec do
   end
 
   it "validates request params" do
-    assert_raises(Elastomer::Client::IllegalArgument, "'nope' is not a valid parameter for the 'search' API") {
-      params = {q: "*:*", pretty: true, "nope": false}
-      @api_spec.validate_params!(api: "search", params: params)
+    params = {q: "*:*", pretty: true, "nope": false}
+    assert_raises(ElastomerClient::Client::IllegalArgument, "'nope' is not a valid parameter for the 'search' API") {
+      @api_spec.validate_params!(api: "search", params:)
     }
   end
 end

data/test/client/rest_api_spec/rest_api_test.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require_relative "../../test_helper"
 
-describe Elastomer::Client::RestApiSpec::RestApi do
+describe ElastomerClient::Client::RestApiSpec::RestApi do
   before do
-    @rest_api = Elastomer::Client::RestApiSpec::RestApi.new \
+    @rest_api = ElastomerClient::Client::RestApiSpec::RestApi.new \
         documentation: "https://www.elastic.co/guide/en/elasticsearch/reference/5.x/cluster-state.html",
         methods: ["GET"],
         body: nil,
@@ -26,9 +28,9 @@ describe Elastomer::Client::RestApiSpec::RestApi do
 
   it "selects valid path parts" do
     hash = {
-      index: "test",
+      :index => "test",
       "metric" => "os",
-      nope: "not selected"
+      :nope => "not selected"
     }
     selected = @rest_api.select_parts(from: hash)
 
@@ -45,10 +47,10 @@ describe Elastomer::Client::RestApiSpec::RestApi do
 
   it "selects valid request params" do
     hash = {
-      local: true,
+      :local => true,
       "flat_settings" => true,
-      expand_wildcards: "all",
-      nope: "not selected"
+      :expand_wildcards => "all",
+      :nope => "not selected"
     }
     selected = @rest_api.select_params(from: hash)
 

data/test/client/scroller_test.rb

@@ -1,32 +1,25 @@
+# frozen_string_literal: true
+
 require_relative "../test_helper"
 
-describe Elastomer::Client::Scroller do
+describe ElastomerClient::Client::Scroller do
 
   before do
     @name  = "elastomer-scroller-test"
     @index = $client.index(@name)
+    @type =  $client.version_support.es_version_8_plus? ? "_doc" : "book"
 
     unless @index.exists?
       @index.create \
-        :settings => { "index.number_of_shards" => 1, "index.number_of_replicas" => 0 },
-        :mappings => {
-          :tweet => {
-            :_source => { :enabled => true }, :_all => { :enabled => false },
-            :properties => {
-              :message => $client.version_support.text(analyzer: "standard"),
-              :author  => $client.version_support.keyword,
-              :sorter  => { :type => "integer" }
-            }
-          },
-          :book => {
-            :_source => { :enabled => true }, :_all => { :enabled => false },
-            :properties => {
-              :title  => $client.version_support.text(analyzer: "standard"),
-              :author => $client.version_support.keyword,
-              :sorter  => { :type => "integer" }
-            }
+        settings: { "index.number_of_shards" => 1, "index.number_of_replicas" => 0 },
+        mappings: mappings_wrapper("book", {
+          _source: { enabled: true },
+          properties: {
+            title: { type: "text", analyzer: "standard" },
+            author: { type: "keyword" },
+            sorter: { type: "integer" }
           }
-        }
+        }, true)
 
       wait_for_index(@name)
       populate!
@@ -38,66 +31,53 @@ describe Elastomer::Client::Scroller do
   end
 
   it "scans over all documents in an index" do
-    scan = @index.scan '{"query":{"match_all":{}}}', :size => 10
-
-    counts = {"tweet" => 0, "book" => 0}
-    scan.each_document { |h| counts[h["_type"]] += 1 }
-
-    assert_equal 50, counts["tweet"]
-    assert_equal 25, counts["book"]
-  end
-
-  it "restricts the scan to a single document type" do
-    scan = @index.scan '{"query":{"match_all":{}}}', :type => "book"
+    scan = @index.scan '{"query":{"match_all":{}}}', size: 10
 
-    counts = {"tweet" => 0, "book" => 0}
-    scan.each_document { |h| counts[h["_type"]] += 1 }
+    count = 0
+    scan.each_document { |h| count += 1 }
 
-    assert_equal 0, counts["tweet"]
-    assert_equal 25, counts["book"]
+    assert_equal 25, count
   end
 
   it "limits results by query" do
-    scan = @index.scan :query => { :bool => { :should => [
-      {:match => {:author => "pea53"}},
-      {:match => {:title => "17"}}
+    scan = @index.scan query: { bool: { should: [
+      {match: {title: "17"}}
     ]}}
 
-    counts = {"tweet" => 0, "book" => 0}
-    scan.each_document { |h| counts[h["_type"]] += 1 }
+    count = 0
+    scan.each_document { |h| count += 1 }
 
-    assert_equal 50, counts["tweet"]
-    assert_equal 1, counts["book"]
+    assert_equal 1, count
   end
 
   it "scrolls and sorts over all documents" do
     scroll = @index.scroll({
-      :query => {:match_all => {}},
-      :sort => {:sorter => {:order => :asc}}
-    }, :type => "tweet")
+      query: {match_all: {}},
+      sort: {sorter: {order: :asc}}
+    }, type: @type)
+
+    books = []
+    scroll.each_document { |h| books << h["_id"].to_i }
 
-    tweets = []
-    scroll.each_document { |h| tweets << h["_id"].to_i }
+    expected = (0...25).to_a.reverse
 
-    expected = (0...50).to_a.reverse
-    assert_equal expected, tweets
+    assert_equal expected, books
   end
 
   it "propagates URL query strings" do
-    scan = @index.scan(nil, { :q => "author:pea53 || title:17" })
+    scan = @index.scan(nil, { q: "title:1 || title:17" })
 
-    counts = {"tweet" => 0, "book" => 0}
-    scan.each_document { |h| counts[h["_type"]] += 1 }
+    count = 0
+    scan.each_document { |h| count += 1 }
 
-    assert_equal 50, counts["tweet"]
-    assert_equal 1, counts["book"]
+    assert_equal 2, count
   end
 
   it "clears one or more scroll IDs" do
     h = $client.start_scroll \
       body: {query: {match_all: {}}},
       index: @index.name,
-      type: "tweet",
+      type: @type,
       scroll: "1m",
       size: 10
 
@@ -105,32 +85,26 @@ describe Elastomer::Client::Scroller do
 
     response = $client.clear_scroll(h["_scroll_id"])
 
-    if returns_cleared_scroll_id_info?
-      assert response["succeeded"]
-      assert_equal 1, response["num_freed"]
-    else
-      assert_empty response
-    end
+    assert response["succeeded"]
+    assert_equal 1, response["num_freed"]
   end
 
   it "raises an exception on existing sort in query" do
-    assert_raises(ArgumentError) { @index.scan :sort => [:_doc] , :query => {} }
+    assert_raises(ArgumentError) { @index.scan sort: [:_doc] , query: {} }
   end
 
   def populate!
-    h = @index.bulk do |b|
-      50.times { |num|
-        b.index %Q({"author":"pea53","message":"this is tweet number #{num}","sorter":#{50-num}}), :_id => num, :_type => "tweet"
-      }
-    end
-    h["items"].each {|item| assert_bulk_index(item) }
-
     h = @index.bulk do |b|
       25.times { |num|
-        b.index %Q({"author":"Pratchett","title":"DiscWorld Book #{num}","sorter":#{25-num}}), :_id => num, :_type => "book"
+        if $client.version_support.es_version_8_plus?
+          b.index %Q({"author":"Pratchett","title":"DiscWorld Book #{num}","sorter":#{25-num}}), _id: num
+        else
+          b.index %Q({"author":"Pratchett","title":"DiscWorld Book #{num}","sorter":#{25-num}}), _id: num, _type: "book"
+        end
       }
     end
-    h["items"].each {|item| assert_bulk_index(item) }
+
+    h["items"].each { |item| assert_bulk_index(item) }
 
     @index.refresh
   end