elastomer-client 0.7.0 → 0.8.1

data/test/client/cluster_test.rb

@@ -1,9 +1,9 @@
-require File.expand_path('../../test_helper', __FILE__)
+require File.expand_path("../../test_helper", __FILE__)
 
 describe Elastomer::Client::Cluster do
 
   before do
-    @name = 'elastomer-cluster-test'
+    @name = "elastomer-cluster-test"
     @index = $client.index @name
     @index.delete if @index.exists?
     @cluster = $client.cluster
@@ -13,49 +13,49 @@ describe Elastomer::Client::Cluster do
     @index.delete if @index.exists?
   end
 
-  it 'gets the cluster health' do
+  it "gets the cluster health" do
     h = @cluster.health
-    assert h.key?('cluster_name'), 'the cluster name is returned'
-    assert h.key?('status'), 'the cluster status is returned'
+    assert h.key?("cluster_name"), "the cluster name is returned"
+    assert h.key?("status"), "the cluster status is returned"
   end
 
-  it 'gets the cluster state' do
+  it "gets the cluster state" do
     h = @cluster.state
-    assert h.key?('cluster_name'), 'the cluster name is returned'
-    assert h.key?('master_node'), 'the master node is returned'
-    assert_instance_of Hash, h['nodes'], 'the node list is returned'
-    assert_instance_of Hash, h['metadata'], 'the metadata are returned'
+    assert h.key?("cluster_name"), "the cluster name is returned"
+    assert h.key?("master_node"), "the master node is returned"
+    assert_instance_of Hash, h["nodes"], "the node list is returned"
+    assert_instance_of Hash, h["metadata"], "the metadata are returned"
   end
 
   if es_version_1_x?
-    it 'filters cluster state by metrics' do
-      h = @cluster.state(:metrics => 'nodes')
-      refute h.key('metadata'), 'expected only nodes state'
-      h = @cluster.state(:metrics => 'metadata')
-      refute h.key('nodes'), 'expected only metadata state'
+    it "filters cluster state by metrics" do
+      h = @cluster.state(:metrics => "nodes")
+      refute h.key("metadata"), "expected only nodes state"
+      h = @cluster.state(:metrics => "metadata")
+      refute h.key("nodes"), "expected only metadata state"
     end
 
-    it 'filters cluster state by indices' do
+    it "filters cluster state by indices" do
       @index.create({}) unless @index.exists?
-      h = @cluster.state(:metrics => 'metadata', :indices => @name)
-      assert [@name], h['metadata']['indices'].keys
+      h = @cluster.state(:metrics => "metadata", :indices => @name)
+      assert [@name], h["metadata"]["indices"].keys
     end
   end
 
-  it 'gets the cluster settings' do
+  it "gets the cluster settings" do
     h = @cluster.get_settings
-    assert_instance_of Hash, h['persistent'], 'the persistent settings are returned'
-    assert_instance_of Hash, h['transient'], 'the transient settings are returned'
+    assert_instance_of Hash, h["persistent"], "the persistent settings are returned"
+    assert_instance_of Hash, h["transient"], "the transient settings are returned"
   end
 
-  it 'gets the cluster settings with .settings' do
+  it "gets the cluster settings with .settings" do
     h = @cluster.settings
-    assert_instance_of Hash, h['persistent'], 'the persistent settings are returned'
-    assert_instance_of Hash, h['transient'], 'the transient settings are returned'
+    assert_instance_of Hash, h["persistent"], "the persistent settings are returned"
+    assert_instance_of Hash, h["transient"], "the transient settings are returned"
   end
 
-  it 'updates the cluster settings' do
-    @cluster.update_settings :transient => { 'indices.ttl.interval' => "30" }
+  it "updates the cluster settings" do
+    @cluster.update_settings :transient => { "indices.ttl.interval" => "30" }
     h = @cluster.settings
 
     #COMPATIBILITY
@@ -65,43 +65,43 @@ describe Elastomer::Client::Cluster do
     # {"indices": {"ttl": {"interval":"30"}}}
 
     # To support both versions, we check for either return format.
-    value = h['transient']['indices.ttl.interval'] ||
-            h['transient']['indices']['ttl']['interval']
+    value = h["transient"]["indices.ttl.interval"] ||
+            h["transient"]["indices"]["ttl"]["interval"]
     assert_equal "30", value
 
-    @cluster.update_settings :transient => { 'indices.ttl.interval' => "60" }
+    @cluster.update_settings :transient => { "indices.ttl.interval" => "60" }
     h = @cluster.settings
 
-    value = h['transient']['indices.ttl.interval'] ||
-            h['transient']['indices']['ttl']['interval']
+    value = h["transient"]["indices.ttl.interval"] ||
+            h["transient"]["indices"]["ttl"]["interval"]
     assert_equal "60", value
   end
 
-  it 'returns cluster stats' do
+  it "returns cluster stats" do
     h = @cluster.stats
     assert_equal %w[cluster_name indices nodes status timestamp], h.keys.sort
   end
 
-  it 'returns a list of pending tasks' do
+  it "returns a list of pending tasks" do
     h = @cluster.pending_tasks
     assert_equal %w[tasks], h.keys.sort
-    assert h['tasks'].is_a?(Array), "the tasks lists is always an Array even if empty"
+    assert h["tasks"].is_a?(Array), "the tasks lists is always an Array even if empty"
   end
 
-  it 'returns the list of indices in the cluster' do
+  it "returns the list of indices in the cluster" do
     @index.create({}) unless @index.exists?
     indices = @cluster.indices
-    assert !indices.empty?, 'expected to see an index'
+    assert !indices.empty?, "expected to see an index"
   end
 
-  it 'returns the list of nodes in the cluster' do
+  it "returns the list of nodes in the cluster" do
     nodes = @cluster.nodes
-    assert !nodes.empty?, 'we have to have some nodes'
+    assert !nodes.empty?, "we have to have some nodes"
   end
 
-  describe 'when working with aliases' do
+  describe "when working with aliases" do
     before do
-      @name = 'elastomer-cluster-test'
+      @name = "elastomer-cluster-test"
       @index = $client.index @name
       @index.create({}) unless @index.exists?
       wait_for_index(@name)
@@ -111,56 +111,56 @@ describe Elastomer::Client::Cluster do
       @index.delete if @index.exists?
     end
 
-    it 'adds and gets an alias' do
+    it "adds and gets an alias" do
       hash = @cluster.get_aliases
       if es_version_always_returns_aliases?
-        assert_empty hash[@name]['aliases']
+        assert_empty hash[@name]["aliases"]
       end
 
       @cluster.update_aliases \
-        :add => {:index => @name, :alias => 'elastomer-test-unikitty'}
+        :add => {:index => @name, :alias => "elastomer-test-unikitty"}
 
       hash = @cluster.get_aliases
-      assert_equal ['elastomer-test-unikitty'], hash[@name]['aliases'].keys
+      assert_equal ["elastomer-test-unikitty"], hash[@name]["aliases"].keys
     end
 
-    it 'adds and gets an alias with .aliases' do
+    it "adds and gets an alias with .aliases" do
       hash = @cluster.aliases
       if es_version_always_returns_aliases?
-        assert_empty hash[@name]['aliases']
+        assert_empty hash[@name]["aliases"]
       end
 
       @cluster.update_aliases \
-        :add => {:index => @name, :alias => 'elastomer-test-unikitty'}
+        :add => {:index => @name, :alias => "elastomer-test-unikitty"}
 
       hash = @cluster.aliases
-      assert_equal ['elastomer-test-unikitty'], hash[@name]['aliases'].keys
+      assert_equal ["elastomer-test-unikitty"], hash[@name]["aliases"].keys
     end
 
-    it 'removes an alias' do
+    it "removes an alias" do
       @cluster.update_aliases \
-        :add => {:index => @name, :alias => 'elastomer-test-unikitty'}
+        :add => {:index => @name, :alias => "elastomer-test-unikitty"}
 
       hash = @cluster.get_aliases
-      assert_equal ['elastomer-test-unikitty'], hash[@name]['aliases'].keys
+      assert_equal ["elastomer-test-unikitty"], hash[@name]["aliases"].keys
 
       @cluster.update_aliases([
-        {:add    => {:index => @name, :alias => 'elastomer-test-SpongeBob-SquarePants'}},
-        {:remove => {:index => @name, :alias => 'elastomer-test-unikitty'}}
+        {:add    => {:index => @name, :alias => "elastomer-test-SpongeBob-SquarePants"}},
+        {:remove => {:index => @name, :alias => "elastomer-test-unikitty"}}
       ])
 
       hash = @cluster.get_aliases
-      assert_equal ['elastomer-test-SpongeBob-SquarePants'], hash[@name]['aliases'].keys
+      assert_equal ["elastomer-test-SpongeBob-SquarePants"], hash[@name]["aliases"].keys
     end
 
-    it 'accepts the full aliases actions hash' do
+    it "accepts the full aliases actions hash" do
       @cluster.update_aliases :actions => [
-        {:add => {:index => @name, :alias => 'elastomer-test-He-Man'}},
-        {:add => {:index => @name, :alias => 'elastomer-test-Skeletor'}}
+        {:add => {:index => @name, :alias => "elastomer-test-He-Man"}},
+        {:add => {:index => @name, :alias => "elastomer-test-Skeletor"}}
       ]
 
       hash = @cluster.get_aliases(:index => @name)
-      assert_equal %w[elastomer-test-He-Man elastomer-test-Skeletor], hash[@name]['aliases'].keys.sort
+      assert_equal %w[elastomer-test-He-Man elastomer-test-Skeletor], hash[@name]["aliases"].keys.sort
     end
   end
 

data/test/client/delete_by_query_test.rb

@@ -1,4 +1,4 @@
-require File.expand_path('../../test_helper', __FILE__)
+require File.expand_path("../../test_helper", __FILE__)
 
 describe Elastomer::Client::DeleteByQuery do
 
@@ -18,64 +18,64 @@ describe Elastomer::Client::DeleteByQuery do
       wait_for_index(@index_name)
     end
 
-    it 'deletes by query' do
+    it "deletes by query" do
       @docs.index({ :_id => 0, :name => "mittens" })
       @docs.index({ :_id => 1, :name => "luna" })
 
       @index.refresh
-      response = $client.delete_by_query(nil, :q => "name:mittens")
+      response = @index.delete_by_query(nil, :q => "name:mittens")
       assert_equal({
-        '_all' => {
-          'found' => 1,
-          'deleted' => 1,
-          'missing' => 0,
-          'failed' => 0,
+        "_all" => {
+          "found" => 1,
+          "deleted" => 1,
+          "missing" => 0,
+          "failed" => 0,
         },
         @index.name => {
-          'found' => 1,
-          'deleted' => 1,
-          'missing' => 0,
-          'failed' => 0,
+          "found" => 1,
+          "deleted" => 1,
+          "missing" => 0,
+          "failed" => 0,
         },
-      }, response['_indices'])
+      }, response["_indices"])
 
       @index.refresh
       response = @docs.multi_get :ids => [0, 1]
-      refute_found response['docs'][0]
-      assert_found response['docs'][1]
+      refute_found response["docs"][0]
+      assert_found response["docs"][1]
     end
 
-    it 'respects action_count' do
+    it "respects action_count" do
       @docs.index({ :_id => 0, :name => "mittens" })
       @docs.index({ :_id => 1, :name => "luna" })
       @index.refresh
 
-      response = $client.delete_by_query(nil, :action_count => 1)
+      response = @index.delete_by_query(nil, :action_count => 1)
 
       assert_requested(:post, /_bulk/, :times => 2)
 
       assert_equal({
-        '_all' => {
-          'found' => 2,
-          'deleted' => 2,
-          'missing' => 0,
-          'failed' => 0,
+        "_all" => {
+          "found" => 2,
+          "deleted" => 2,
+          "missing" => 0,
+          "failed" => 0,
         },
         @index.name => {
-          'found' => 2,
-          'deleted' => 2,
-          'missing' => 0,
-          'failed' => 0,
+          "found" => 2,
+          "deleted" => 2,
+          "missing" => 0,
+          "failed" => 0,
         },
-      }, response['_indices'])
+      }, response["_indices"])
 
       @index.refresh
       response = @docs.multi_get :ids => [0, 1]
-      refute_found response['docs'][0]
-      refute_found response['docs'][1]
+      refute_found response["docs"][0]
+      refute_found response["docs"][1]
     end
 
-    it 'counts missing documents' do
+    it "counts missing documents" do
       @docs.index({ :_id => 0 })
 
       stub_request(:post, /_bulk/).
@@ -95,24 +95,24 @@ describe Elastomer::Client::DeleteByQuery do
         end)
 
       @index.refresh
-      response = $client.delete_by_query(nil, :action_count => 1)
+      response = @index.delete_by_query(nil, :action_count => 1)
       assert_equal({
-        '_all' => {
-          'found' => 0,
-          'deleted' => 0,
-          'missing' => 1,
-          'failed' => 0,
+        "_all" => {
+          "found" => 0,
+          "deleted" => 0,
+          "missing" => 1,
+          "failed" => 0,
         },
         @index.name => {
-          'found' => 0,
-          'deleted' => 0,
-          'missing' => 1,
-          'failed' => 0,
+          "found" => 0,
+          "deleted" => 0,
+          "missing" => 1,
+          "failed" => 0,
         },
-      }, response['_indices'])
+      }, response["_indices"])
     end
 
-    it 'counts failed operations' do
+    it "counts failed operations" do
       @docs.index({ :_id => 0 })
 
       stub_request(:post, /_bulk/).
@@ -131,21 +131,21 @@ describe Elastomer::Client::DeleteByQuery do
         end)
 
       @index.refresh
-      response = $client.delete_by_query(nil, :action_count => 1)
+      response = @index.delete_by_query(nil, :action_count => 1)
       assert_equal({
-        '_all' => {
-          'found' => 1,
-          'deleted' => 0,
-          'missing' => 0,
-          'failed' => 1,
+        "_all" => {
+          "found" => 1,
+          "deleted" => 0,
+          "missing" => 0,
+          "failed" => 1,
         },
         @index.name => {
-          'found' => 1,
-          'deleted' => 0,
-          'missing' => 0,
-          'failed' => 1,
+          "found" => 1,
+          "deleted" => 0,
+          "missing" => 0,
+          "failed" => 1,
         },
-      }, response['_indices'])
+      }, response["_indices"])
     end
   end
 end

data/test/client/docs_test.rb

@@ -1,27 +1,27 @@
-require File.expand_path('../../test_helper', __FILE__)
+require File.expand_path("../../test_helper", __FILE__)
 
 describe Elastomer::Client::Docs do
 
   before do
-    @name  = 'elastomer-docs-test'
+    @name  = "elastomer-docs-test"
     @index = $client.index(@name)
 
     unless @index.exists?
       @index.create \
-        :settings => { 'index.number_of_shards' => 1, 'index.number_of_replicas' => 0 },
+        :settings => { "index.number_of_shards" => 1, "index.number_of_replicas" => 0 },
         :mappings => {
           :doc1 => {
             :_source => { :enabled => true }, :_all => { :enabled => false },
             :properties => {
-              :title  => { :type => 'string', :analyzer => 'standard' },
-              :author => { :type => 'string', :index => 'not_analyzed' }
+              :title  => { :type => "string", :analyzer => "standard" },
+              :author => { :type => "string", :index => "not_analyzed" }
             }
           },
           :doc2 => {
             :_source => { :enabled => true }, :_all => { :enabled => false },
             :properties => {
-              :title  => { :type => 'string', :analyzer => 'standard', :term_vector => 'with_positions_offsets' },
-              :author => { :type => 'string', :index => 'not_analyzed' }
+              :title  => { :type => "string", :analyzer => "standard", :term_vector => "with_positions_offsets" },
+              :author => { :type => "string", :index => "not_analyzed" }
             }
           }
         }
@@ -36,68 +36,68 @@ describe Elastomer::Client::Docs do
     @index.delete if @index.exists?
   end
 
-  it 'autogenerates IDs for documents' do
+  it "autogenerates IDs for documents" do
     h = @docs.index \
-          :_type  => 'doc2',
-          :title  => 'the author of logging',
-          :author => 'pea53'
+          :_type  => "doc2",
+          :title  => "the author of logging",
+          :author => "pea53"
 
     assert_created h
-    assert_match %r/^\S{20,22}$/, h['_id']
+    assert_match %r/^\S{20,22}$/, h["_id"]
 
     h = @docs.index \
           :_id    => nil,
-          :_type  => 'doc3',
-          :title  => 'the author of rubber-band',
-          :author => 'grantr'
+          :_type  => "doc3",
+          :title  => "the author of rubber-band",
+          :author => "grantr"
 
     assert_created h
-    assert_match %r/^\S{20,22}$/, h['_id']
+    assert_match %r/^\S{20,22}$/, h["_id"]
 
     h = @docs.index \
-          :_id    => '',
-          :_type  => 'doc4',
-          :title  => 'the author of toml',
-          :author => 'mojombo'
+          :_id    => "",
+          :_type  => "doc4",
+          :title  => "the author of toml",
+          :author => "mojombo"
 
     assert_created h
-    assert_match %r/^\S{20,22}$/, h['_id']
+    assert_match %r/^\S{20,22}$/, h["_id"]
   end
 
-  it 'uses the provided document ID' do
+  it "uses the provided document ID" do
     h = @docs.index \
-          :_id    => '42',
-          :_type  => 'doc2',
-          :title  => 'the author of logging',
-          :author => 'pea53'
+          :_id    => "42",
+          :_type  => "doc2",
+          :title  => "the author of logging",
+          :author => "pea53"
 
     assert_created h
-    assert_equal '42', h['_id']
+    assert_equal "42", h["_id"]
   end
 
-  it 'accepts JSON encoded document strings' do
+  it "accepts JSON encoded document strings" do
     h = @docs.index \
           '{"author":"pea53", "title":"the author of logging"}',
-          :id   => '42',
-          :type => 'doc2'
+          :id   => "42",
+          :type => "doc2"
 
     assert_created h
-    assert_equal '42', h['_id']
+    assert_equal "42", h["_id"]
 
     h = @docs.index \
           '{"author":"grantr", "title":"the author of rubber-band"}',
-          :type => 'doc2'
+          :type => "doc2"
 
     assert_created h
-    assert_match %r/^\S{20,22}$/, h['_id']
+    assert_match %r/^\S{20,22}$/, h["_id"]
   end
 
-  it 'extracts underscore attributes from the document' do
+  it "extracts underscore attributes from the document" do
     doc = {
-      :_id => '12',
-      :_type => 'doc2',
-      :_routing => 'author',
-      '_consistency' => 'all',
+      :_id => "12",
+      :_type => "doc2",
+      :_routing => "author",
+      "_consistency" => "all",
       :title => "The Adventures of Huckleberry Finn",
       :author => "Mark Twain",
       :_unknown => "unknown attribute"
@@ -105,133 +105,133 @@ describe Elastomer::Client::Docs do
 
     h = @docs.index doc
     assert_created h
-    assert_equal '12', h['_id']
+    assert_equal "12", h["_id"]
 
     refute doc.key?(:_id)
     refute doc.key?(:_type)
     refute doc.key?(:_routing)
-    refute doc.key?('_consistency')
+    refute doc.key?("_consistency")
     assert doc.key?(:_unknown)
   end
 
-  it 'gets documents from the search index' do
-    h = @docs.get :id => '1', :type => 'doc1'
+  it "gets documents from the search index" do
+    h = @docs.get :id => "1", :type => "doc1"
     refute_found h
 
     populate!
 
-    h = @docs.get :id => '1', :type => 'doc1'
+    h = @docs.get :id => "1", :type => "doc1"
     assert_found h
-    assert_equal 'mojombo', h['_source']['author']
+    assert_equal "mojombo", h["_source"]["author"]
   end
 
-  it 'checks if documents exist in the search index' do
-    refute @docs.exists?(:id => '1', :type => 'doc1')
+  it "checks if documents exist in the search index" do
+    refute @docs.exists?(:id => "1", :type => "doc1")
     populate!
-    assert @docs.exists?(:id => '1', :type => 'doc1')
+    assert @docs.exists?(:id => "1", :type => "doc1")
   end
 
-  it 'checks if documents exist in the search index with .exist?' do
-    refute @docs.exist?(:id => '1', :type => 'doc1')
+  it "checks if documents exist in the search index with .exist?" do
+    refute @docs.exist?(:id => "1", :type => "doc1")
     populate!
-    assert @docs.exist?(:id => '1', :type => 'doc1')
+    assert @docs.exist?(:id => "1", :type => "doc1")
   end
 
-  it 'gets multiple documents from the search index' do
+  it "gets multiple documents from the search index" do
     populate!
 
     h = @docs.multi_get :docs => [
-      { :_id => 1, :_type => 'doc1' },
-      { :_id => 1, :_type => 'doc2' }
+      { :_id => 1, :_type => "doc1" },
+      { :_id => 1, :_type => "doc2" }
     ]
-    authors = h['docs'].map { |d| d['_source']['author'] }
+    authors = h["docs"].map { |d| d["_source"]["author"] }
     assert_equal %w[mojombo pea53], authors
 
-    h = @docs.multi_get({:ids => [2, 1]}, :type => 'doc1')
-    authors = h['docs'].map { |d| d['_source']['author'] }
+    h = @docs.multi_get({:ids => [2, 1]}, :type => "doc1")
+    authors = h["docs"].map { |d| d["_source"]["author"] }
     assert_equal %w[defunkt mojombo], authors
 
-    h = @index.docs('doc1').multi_get :ids => [1, 2, 3, 4]
-    assert_found h['docs'][0]
-    assert_found h['docs'][1]
-    refute_found h['docs'][2]
-    refute_found h['docs'][3]
+    h = @index.docs("doc1").multi_get :ids => [1, 2, 3, 4]
+    assert_found h["docs"][0]
+    assert_found h["docs"][1]
+    refute_found h["docs"][2]
+    refute_found h["docs"][3]
   end
 
-  it 'gets multiple documents from the search index with .mget' do
+  it "gets multiple documents from the search index with .mget" do
     populate!
 
     h = @docs.mget :docs => [
-      { :_id => 1, :_type => 'doc1' },
-      { :_id => 1, :_type => 'doc2' }
+      { :_id => 1, :_type => "doc1" },
+      { :_id => 1, :_type => "doc2" }
     ]
-    authors = h['docs'].map { |d| d['_source']['author'] }
+    authors = h["docs"].map { |d| d["_source"]["author"] }
     assert_equal %w[mojombo pea53], authors
 
-    h = @docs.mget({:ids => [2, 1]}, :type => 'doc1')
-    authors = h['docs'].map { |d| d['_source']['author'] }
+    h = @docs.mget({:ids => [2, 1]}, :type => "doc1")
+    authors = h["docs"].map { |d| d["_source"]["author"] }
     assert_equal %w[defunkt mojombo], authors
 
-    h = @index.docs('doc1').mget :ids => [1, 2, 3, 4]
-    assert_found h['docs'][0]
-    assert_found h['docs'][1]
-    refute_found h['docs'][2]
-    refute_found h['docs'][3]
+    h = @index.docs("doc1").mget :ids => [1, 2, 3, 4]
+    assert_found h["docs"][0]
+    assert_found h["docs"][1]
+    refute_found h["docs"][2]
+    refute_found h["docs"][3]
   end
 
-  it 'deletes documents from the search index' do
+  it "deletes documents from the search index" do
     populate!
-    @docs = @index.docs('doc2')
+    @docs = @index.docs("doc2")
 
     h = @docs.multi_get :ids => [1, 2]
-    authors = h['docs'].map { |d| d['_source']['author'] }
+    authors = h["docs"].map { |d| d["_source"]["author"] }
     assert_equal %w[pea53 grantr], authors
 
     h = @docs.delete :id => 1
-    assert h['found'], "expected document to be found"
+    assert h["found"], "expected document to be found"
     h = @docs.multi_get :ids => [1, 2]
-    refute_found h['docs'][0]
-    assert_found h['docs'][1]
+    refute_found h["docs"][0]
+    assert_found h["docs"][1]
 
     assert_raises(ArgumentError) { @docs.delete :id => nil }
-    assert_raises(ArgumentError) { @docs.delete :id => '' }
+    assert_raises(ArgumentError) { @docs.delete :id => "" }
     assert_raises(ArgumentError) { @docs.delete :id => "\t" }
   end
 
-  it 'does not care if you delete a document that is not there' do
-    @docs = @index.docs('doc2')
+  it "does not care if you delete a document that is not there" do
+    @docs = @index.docs("doc2")
     h = @docs.delete :id => 42
 
-    refute h['found'], 'expected document to not be found'
+    refute h["found"], "expected document to not be found"
   end
 
-  it 'deletes documents by query' do
+  it "deletes documents by query" do
     populate!
-    @docs = @index.docs('doc2')
+    @docs = @index.docs("doc2")
 
     h = @docs.multi_get :ids => [1, 2]
-    authors = h['docs'].map { |d| d['_source']['author'] }
+    authors = h["docs"].map { |d| d["_source"]["author"] }
     assert_equal %w[pea53 grantr], authors
 
     h = @docs.delete_by_query(:q => "author:grantr")
-    assert_equal(h['_indices'], {
-      '_all' => {
-        'found' => 1,
-        'deleted' => 1,
-        'missing' => 0,
-        'failed' => 0,
+    assert_equal(h["_indices"], {
+      "_all" => {
+        "found" => 1,
+        "deleted" => 1,
+        "missing" => 0,
+        "failed" => 0,
       },
       @name => {
-        'found' => 1,
-        'deleted' => 1,
-        'missing' => 0,
-        'failed' => 0,
+        "found" => 1,
+        "deleted" => 1,
+        "missing" => 0,
+        "failed" => 0,
       },
     })
     @index.refresh
     h = @docs.multi_get :ids => [1, 2]
-    assert_found h['docs'][0]
-    refute_found h['docs'][1]
+    assert_found h["docs"][0]
+    refute_found h["docs"][1]
 
     #COMPATIBILITY
     # ES 1.0 normalized all search APIs to use a :query top level element.
@@ -243,42 +243,42 @@ describe Elastomer::Client::Docs do
             :query => {
               :filtered => {
                 :query => {:match_all => {}},
-                :filter => {:term => {:author => 'pea53'}}
+                :filter => {:term => {:author => "pea53"}}
               }
             }
           )
       @index.refresh
       h = @docs.multi_get :ids => [1, 2]
-      refute_found h['docs'][0]
-      refute_found h['docs'][1]
+      refute_found h["docs"][0]
+      refute_found h["docs"][1]
     end
   end
 
-  it 'searches for documents' do
-    h = @docs.search :q => '*:*'
-    assert_equal 0, h['hits']['total']
+  it "searches for documents" do
+    h = @docs.search :q => "*:*"
+    assert_equal 0, h["hits"]["total"]
 
     populate!
 
-    h = @docs.search :q => '*:*'
-    assert_equal 4, h['hits']['total']
+    h = @docs.search :q => "*:*"
+    assert_equal 4, h["hits"]["total"]
 
-    h = @docs.search :q => '*:*', :type => 'doc1'
-    assert_equal 2, h['hits']['total']
+    h = @docs.search :q => "*:*", :type => "doc1"
+    assert_equal 2, h["hits"]["total"]
 
     h = @docs.search({
       :query => {:match_all => {}},
-      :filter => {:term => {:author => 'defunkt'}}
+      :filter => {:term => {:author => "defunkt"}}
     }, :type => %w[doc1 doc2] )
-    assert_equal 1, h['hits']['total']
+    assert_equal 1, h["hits"]["total"]
 
-    hit = h['hits']['hits'].first
-    assert_equal 'the author of resque', hit['_source']['title']
+    hit = h["hits"]["hits"].first
+    assert_equal "the author of resque", hit["_source"]["title"]
   end
 
-  it 'supports the shards search API' do
+  it "supports the shards search API" do
     if es_version_supports_search_shards?
-      h = @docs.search_shards(:type => 'docs1')
+      h = @docs.search_shards(:type => "docs1")
 
       assert h.key?("nodes"), "response contains \"nodes\" information"
       assert h.key?("shards"), "response contains \"shards\" information"
@@ -286,20 +286,20 @@ describe Elastomer::Client::Docs do
     end
   end
 
-  it 'counts documents' do
-    h = @docs.count :q => '*:*'
-    assert_equal 0, h['count']
+  it "counts documents" do
+    h = @docs.count :q => "*:*"
+    assert_equal 0, h["count"]
 
     populate!
 
-    h = @docs.count :q => '*:*'
-    assert_equal 4, h['count']
+    h = @docs.count :q => "*:*"
+    assert_equal 4, h["count"]
 
-    h = @docs.count :q => '*:*', :type => 'doc1'
-    assert_equal 2, h['count']
+    h = @docs.count :q => "*:*", :type => "doc1"
+    assert_equal 2, h["count"]
 
-    h = @docs.count :q => '*:*', :type => 'doc1,doc2'
-    assert_equal 4, h['count']
+    h = @docs.count :q => "*:*", :type => "doc1,doc2"
+    assert_equal 4, h["count"]
 
     #COMPATIBILITY
     # ES 1.0 normalized all search APIs to use a :query top level element.
@@ -309,7 +309,7 @@ describe Elastomer::Client::Docs do
         :query => {
           :filtered => {
             :query => {:match_all => {}},
-            :filter => {:term => {:author => 'defunkt'}}
+            :filter => {:term => {:author => "defunkt"}}
           }
         }
       }, :type => %w[doc1 doc2] )
@@ -317,30 +317,30 @@ describe Elastomer::Client::Docs do
       h = @docs.count({
         :filtered => {
           :query => {:match_all => {}},
-          :filter => {:term => {:author => 'defunkt'}}
+          :filter => {:term => {:author => "defunkt"}}
         }
       }, :type => %w[doc1 doc2] )
     end
-    assert_equal 1, h['count']
+    assert_equal 1, h["count"]
   end
 
-  it 'searches for more like this' do
+  it "searches for more like this" do
     populate!
 
     # for some reason, if there's no document indexed here all the mlt
     # queries return zero results
     @docs.index \
       :_id    => 3,
-      :_type  => 'doc1',
-      :title  => 'the author of faraday',
-      :author => 'technoweenie'
+      :_type  => "doc1",
+      :title  => "the author of faraday",
+      :author => "technoweenie"
 
     @index.refresh
 
     h = @docs.more_like_this({
-      :type => 'doc1',
+      :type => "doc1",
       :id   => 1,
-      :mlt_fields    => 'title',
+      :mlt_fields    => "title",
       :min_term_freq => 1
     })
     assert_equal 2, h["hits"]["total"]
@@ -354,16 +354,16 @@ describe Elastomer::Client::Docs do
         }
       }
     }, {
-      :type => 'doc1',
+      :type => "doc1",
       :id   => 1,
-      :mlt_fields    => 'title,author',
+      :mlt_fields    => "title,author",
       :min_term_freq => 1
     })
     assert_equal 2, h["hits"]["total"]
     assert_equal 2, h["facets"]["author"]["total"]
   end
 
-  it 'explains scoring' do
+  it "explains scoring" do
     populate!
 
     h = @docs.explain({
@@ -372,17 +372,17 @@ describe Elastomer::Client::Docs do
           "author" => "defunkt"
         }
       }
-    }, :type => 'doc1', :id => 2)
+    }, :type => "doc1", :id => 2)
     assert_equal true, h["matched"]
 
-    h = @docs.explain(:type => 'doc2', :id => 2, :q => "pea53")
+    h = @docs.explain(:type => "doc2", :id => 2, :q => "pea53")
     assert_equal false, h["matched"]
   end
 
-  it 'validates queries' do
+  it "validates queries" do
     populate!
 
-    h = @docs.validate :q => '*:*'
+    h = @docs.validate :q => "*:*"
     assert_equal true, h["valid"]
 
     #COMPATIBILITY
@@ -393,7 +393,7 @@ describe Elastomer::Client::Docs do
         :query => {
           :filtered => {
             :query => {:match_all => {}},
-            :filter => {:term => {:author => 'defunkt'}}
+            :filter => {:term => {:author => "defunkt"}}
           }
         }
       }, :type => %w[doc1 doc2] )
@@ -401,122 +401,196 @@ describe Elastomer::Client::Docs do
       h = @docs.validate({
         :filtered => {
           :query => {:match_all => {}},
-          :filter => {:term => {:author => 'defunkt'}}
+          :filter => {:term => {:author => "defunkt"}}
         }
       }, :type => %w[doc1 doc2] )
     end
     assert_equal true, h["valid"]
   end
 
-  it 'updates documents' do
+  it "updates documents" do
     populate!
 
-    h = @docs.get :id => '1', :type => 'doc1'
+    h = @docs.get :id => "1", :type => "doc1"
     assert_found h
-    assert_equal 'mojombo', h['_source']['author']
+    assert_equal "mojombo", h["_source"]["author"]
 
     @docs.update({
-      :_id   => '1',
-      :_type => 'doc1',
-      :doc   => {:author => 'TwP'}
+      :_id   => "1",
+      :_type => "doc1",
+      :doc   => {:author => "TwP"}
     })
-    h = @docs.get :id => '1', :type => 'doc1'
+    h = @docs.get :id => "1", :type => "doc1"
     assert_found h
-    assert_equal 'TwP', h['_source']['author']
+    assert_equal "TwP", h["_source"]["author"]
 
     if $client.version >= "0.90"
       @docs.update({
-        :_id   => '42',
-        :_type => 'doc1',
+        :_id   => "42",
+        :_type => "doc1",
         :doc   => {
-          :author => 'TwP',
-          :title  => 'the ineffable beauty of search'
+          :author => "TwP",
+          :title  => "the ineffable beauty of search"
         },
         :doc_as_upsert => true
       })
 
-      h = @docs.get :id => '42', :type => 'doc1'
+      h = @docs.get :id => "42", :type => "doc1"
       assert_found h
-      assert_equal 'TwP', h['_source']['author']
-      assert_equal 'the ineffable beauty of search', h['_source']['title']
+      assert_equal "TwP", h["_source"]["author"]
+      assert_equal "the ineffable beauty of search", h["_source"]["title"]
     end
   end
 
-  it 'supports bulk operations with the same parameters as docs' do
+  it "supports bulk operations with the same parameters as docs" do
     response = @docs.bulk do |b|
       populate!(b)
     end
 
-    assert_instance_of Fixnum, response['took']
+    assert_instance_of Fixnum, response["took"]
 
-    response = @docs.get(:id => 1, :type => 'doc1')
+    response = @docs.get(:id => 1, :type => "doc1")
     assert_found response
-    assert_equal 'mojombo', response['_source']['author']
+    assert_equal "mojombo", response["_source"]["author"]
   end
 
   if es_version_1_x?
-    it 'provides access to term vector statistics' do
+    it "provides access to term vector statistics" do
       populate!
 
-      response = @docs.termvector :type => 'doc2', :id => 1, :fields => 'title'
+      response = @docs.termvector :type => "doc2", :id => 1, :fields => "title"
 
-      assert response['term_vectors']['title']
-      assert response['term_vectors']['title']['field_statistics']
-      assert response['term_vectors']['title']['terms']
-      assert_equal %w[author logging of the], response['term_vectors']['title']['terms'].keys
+      assert response["term_vectors"]["title"]
+      assert response["term_vectors"]["title"]["field_statistics"]
+      assert response["term_vectors"]["title"]["terms"]
+      assert_equal %w[author logging of the], response["term_vectors"]["title"]["terms"].keys
     end
 
-    it 'provides access to term vector statistics with .termvectors' do
+    it "provides access to term vector statistics with .termvectors" do
       populate!
 
-      response = @docs.termvectors :type => 'doc2', :id => 1, :fields => 'title'
+      response = @docs.termvectors :type => "doc2", :id => 1, :fields => "title"
 
-      assert response['term_vectors']['title']
-      assert response['term_vectors']['title']['field_statistics']
-      assert response['term_vectors']['title']['terms']
-      assert_equal %w[author logging of the], response['term_vectors']['title']['terms'].keys
+      assert response["term_vectors"]["title"]
+      assert response["term_vectors"]["title"]["field_statistics"]
+      assert response["term_vectors"]["title"]["terms"]
+      assert_equal %w[author logging of the], response["term_vectors"]["title"]["terms"].keys
     end
 
-    it 'provides access to term vector statistics with .term_vector' do
+    it "provides access to term vector statistics with .term_vector" do
       populate!
 
-      response = @docs.term_vector :type => 'doc2', :id => 1, :fields => 'title'
+      response = @docs.term_vector :type => "doc2", :id => 1, :fields => "title"
 
-      assert response['term_vectors']['title']
-      assert response['term_vectors']['title']['field_statistics']
-      assert response['term_vectors']['title']['terms']
-      assert_equal %w[author logging of the], response['term_vectors']['title']['terms'].keys
+      assert response["term_vectors"]["title"]
+      assert response["term_vectors"]["title"]["field_statistics"]
+      assert response["term_vectors"]["title"]["terms"]
+      assert_equal %w[author logging of the], response["term_vectors"]["title"]["terms"].keys
     end
 
-    it 'provides access to term vector statistics with .term_vectors' do
+    it "provides access to term vector statistics with .term_vectors" do
       populate!
 
-      response = @docs.term_vectors :type => 'doc2', :id => 1, :fields => 'title'
+      response = @docs.term_vectors :type => "doc2", :id => 1, :fields => "title"
 
-      assert response['term_vectors']['title']
-      assert response['term_vectors']['title']['field_statistics']
-      assert response['term_vectors']['title']['terms']
-      assert_equal %w[author logging of the], response['term_vectors']['title']['terms'].keys
+      assert response["term_vectors"]["title"]
+      assert response["term_vectors"]["title"]["field_statistics"]
+      assert response["term_vectors"]["title"]["terms"]
+      assert_equal %w[author logging of the], response["term_vectors"]["title"]["terms"].keys
     end
 
-    it 'provides access to multi term vector statistics' do
+    it "provides access to multi term vector statistics" do
       populate!
 
-      response = @docs.multi_termvectors({:ids => [1, 2]}, :type => 'doc2', :fields => 'title', :term_statistics => true)
-      docs = response['docs']
+      response = @docs.multi_termvectors({:ids => [1, 2]}, :type => "doc2", :fields => "title", :term_statistics => true)
+      docs = response["docs"]
 
       assert docs
-      assert_equal(%w[1 2], docs.map { |h| h['_id'] }.sort)
+      assert_equal(%w[1 2], docs.map { |h| h["_id"] }.sort)
     end
 
-    it 'provides access to multi term vector statistics with .multi_term_vectors' do
+    it "provides access to multi term vector statistics with .multi_term_vectors" do
       populate!
 
-      response = @docs.multi_term_vectors({:ids => [1, 2]}, :type => 'doc2', :fields => 'title', :term_statistics => true)
-      docs = response['docs']
+      response = @docs.multi_term_vectors({:ids => [1, 2]}, :type => "doc2", :fields => "title", :term_statistics => true)
+      docs = response["docs"]
 
       assert docs
-      assert_equal(%w[1 2], docs.map { |h| h['_id'] }.sort)
+      assert_equal(%w[1 2], docs.map { |h| h["_id"] }.sort)
+    end
+
+    it "percolates a given document" do
+      populate!
+
+      percolator1 = @index.percolator "1"
+      response = percolator1.create :query => { :match => { :author => "pea53" } }
+      assert response["created"], "Couldn't create the percolator query"
+      percolator2 = @index.percolator "2"
+      response = percolator2.create :query => { :match => { :author => "defunkt" } }
+      assert response["created"], "Couldn't create the percolator query"
+
+      response = @index.docs("doc1").percolate(:doc => { :author => "pea53" })
+      assert_equal 1, response["matches"].length
+      assert_equal "1", response["matches"][0]["_id"]
+    end
+
+    it "percolates an existing document" do
+      populate!
+
+      percolator1 = @index.percolator "1"
+      response = percolator1.create :query => { :match => { :author => "pea53" } }
+      assert response["created"], "Couldn't create the percolator query"
+      percolator2 = @index.percolator "2"
+      response = percolator2.create :query => { :match => { :author => "defunkt" } }
+      assert response["created"], "Couldn't create the percolator query"
+
+      response = @index.docs("doc2").percolate(nil, :id => "1")
+      assert_equal 1, response["matches"].length
+      assert_equal "1", response["matches"][0]["_id"]
+    end
+
+    it "counts the matches for percolating a given document" do
+      populate!
+
+      percolator1 = @index.percolator "1"
+      response = percolator1.create :query => { :match => { :author => "pea53" } }
+      assert response["created"], "Couldn't create the percolator query"
+      percolator2 = @index.percolator "2"
+      response = percolator2.create :query => { :match => { :author => "defunkt" } }
+      assert response["created"], "Couldn't create the percolator query"
+
+      count = @index.docs("doc1").percolate_count :doc => { :author => "pea53" }
+      assert_equal 1, count
+    end
+
+    it "counts the matches for percolating an existing document" do
+      populate!
+
+      percolator1 = @index.percolator "1"
+      response = percolator1.create :query => { :match => { :author => "pea53" } }
+      assert response["created"], "Couldn't create the percolator query"
+      percolator2 = @index.percolator "2"
+      response = percolator2.create :query => { :match => { :author => "defunkt" } }
+      assert response["created"], "Couldn't create the percolator query"
+
+      count = @index.docs("doc2").percolate_count(nil, :id => "1")
+      assert_equal 1, count
+    end
+
+    it "performs multi percolate queries" do
+      @index.percolator("1").create :query => { :match_all => { } }
+      @index.percolator("2").create :query => { :match => { :author => "pea53" } }
+
+      h = @index.docs("doc2").multi_percolate do |m|
+        m.percolate :author => "pea53"
+        m.percolate :author => "grantr"
+        m.count({}, { :author => "grantr" })
+      end
+
+      response1, response2, response3 = h["responses"]
+      assert_equal ["1", "2"], response1["matches"].map { |match| match["_id"] }.sort
+      assert_equal ["1"], response2["matches"].map { |match| match["_id"] }.sort
+      assert_equal 1, response3["total"]
     end
   end
 
@@ -524,32 +598,34 @@ describe Elastomer::Client::Docs do
   #
   # docs - An instance of Elastomer::Client::Docs or Elastomer::Client::Bulk. If
   #        nil uses the @docs instance variable.
+  # rubocop:disable Metrics/MethodLength
   def populate!(docs = @docs)
     docs.index \
       :_id    => 1,
-      :_type  => 'doc1',
-      :title  => 'the author of gravatar',
-      :author => 'mojombo'
+      :_type  => "doc1",
+      :title  => "the author of gravatar",
+      :author => "mojombo"
 
     docs.index \
       :_id    => 2,
-      :_type  => 'doc1',
-      :title  => 'the author of resque',
-      :author => 'defunkt'
+      :_type  => "doc1",
+      :title  => "the author of resque",
+      :author => "defunkt"
 
     docs.index \
       :_id    => 1,
-      :_type  => 'doc2',
-      :title  => 'the author of logging',
-      :author => 'pea53'
+      :_type  => "doc2",
+      :title  => "the author of logging",
+      :author => "pea53"
 
     docs.index \
       :_id    => 2,
-      :_type  => 'doc2',
-      :title  => 'the author of rubber-band',
-      :author => 'grantr'
+      :_type  => "doc2",
+      :title  => "the author of rubber-band",
+      :author => "grantr"
 
     @index.refresh
   end
+  # rubocop:enable Metrics/MethodLength
 
 end