elasticsearch-api 6.0.1 → 7.0.0

data/test/unit/msearch_test.rb

@@ -1,129 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class MsearchTest < ::Test::Unit::TestCase
-
-      context "Msearch" do
-        subject { FakeClient.new }
-
-        should "require the :body argument" do
-          assert_raise ArgumentError do
-            subject.msearch
-          end
-        end
-
-        should "post correct payload to the endpoint" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'GET', method
-            assert_equal '_msearch', url
-            assert_equal Hash.new, params
-            assert_equal <<-PAYLOAD.gsub(/^\s+/, ''), body
-            {"index":"foo"}
-            {"query":{"match_all":{}}}
-            {"index":"bar"}
-            {"query":{"match":{"foo":"bar"}}}
-            {"search_type":"count"}
-            {"facets":{"tags":{}}}
-            PAYLOAD
-            true
-          end.returns(FakeResponse.new)
-
-          subject.msearch :body => [
-            { :index => 'foo', :search => { :query => { :match_all => {}  } } },
-            { :index => 'bar', :search => { :query => { :match => { :foo => 'bar' } } } },
-            { :search_type => 'count', :search => { :facets => { :tags => {} } } }
-          ]
-        end
-
-        should "post a string payload intact" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal %Q|{"foo":"bar"}\n{"moo":"lam"}|, body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.msearch :body => %Q|{"foo":"bar"}\n{"moo":"lam"}|
-        end
-
-        should "serialize and post header/data pairs" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'GET', method
-            assert_equal '_msearch', url
-            assert_equal Hash.new, params
-            assert_equal <<-PAYLOAD.gsub(/^\s+/, ''), body
-            {"index":"foo"}
-            {"query":{"match_all":{}}}
-            {"index":"bar"}
-            {"query":{"match":{"foo":"bar"}}}
-            PAYLOAD
-            true
-          end.returns(FakeResponse.new)
-
-          subject.msearch :body => [
-            { :index => 'foo' },
-            { :query => { :match_all => {}  } },
-            { :index => 'bar' },
-            { :query => { :match => { :foo => 'bar' } } }
-          ]
-        end
-
-        should "perform request against an index" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/_msearch', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.msearch :index => 'foo', :body => []
-        end
-
-        should "perform request against an index and type" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/bar/_msearch', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.msearch :index => 'foo', :type => 'bar', :body => []
-        end
-
-        should "perform request against multiple indices" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo,bar/_msearch', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.msearch :index => ['foo', 'bar'], :body => []
-        end
-
-        should "perform request against multiple indices and types" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo,bar/lam,bam/_msearch', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.msearch :index => ['foo', 'bar'], :type => ['lam', 'bam'], :body => []
-        end
-
-        should "URL-escape the parts" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo%5Ebar/bar%2Fbam/_msearch', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.msearch :index => 'foo^bar', :type => 'bar/bam', :body => []
-        end
-
-        should "encode URL parameters" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal '_msearch', url
-            assert_equal 'scroll', params[:search_type]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.msearch :body => [], :search_type => 'scroll'
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/mtermvectors_test.rb

@@ -1,38 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class MtermvectorsTest < ::Test::Unit::TestCase
-
-      context "Mtermvectors" do
-        subject { FakeClient.new }
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'GET', method
-            assert_equal 'my-index/my-type/_mtermvectors', url
-            assert_equal Hash.new, params
-            assert_equal [1, 2, 3], body[:ids]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.mtermvectors :index => 'my-index', :type => 'my-type', :body => { :ids => [1, 2, 3] }
-        end
-
-        should "allow passing a list of IDs instead of the body" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'GET', method
-            assert_equal 'my-index/my-type/_mtermvectors', url
-            assert_equal Hash.new, params
-            assert_equal [1, 2, 3], body[:ids]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.mtermvectors :index => 'my-index', :type => 'my-type', :ids => [1, 2, 3]
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/nodes/hot_threads_test.rb

@@ -1,44 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class NodesHotThreadsTest < ::Test::Unit::TestCase
-
-      context "Nodes: Hot Threads" do
-        subject { FakeClient.new }
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'GET', method
-            assert_equal '_nodes/hot_threads', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.nodes.hot_threads
-        end
-
-        should "send :node_id correctly" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal '_nodes/foo/hot_threads', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.nodes.hot_threads :node_id => 'foo'
-        end
-
-        should "URL-escape the parts" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal '_nodes/foo%5Ebar/hot_threads', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.nodes.hot_threads :node_id => 'foo^bar'
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/nodes/info_test.rb

@@ -1,75 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class NodesInfoTest < ::Test::Unit::TestCase
-
-      context "Nodes: Info" do
-        subject { FakeClient.new }
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'GET', method
-            assert_equal '_nodes', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.nodes.info
-        end
-
-        should "send :node_id correctly" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal '_nodes/foo', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.nodes.info :node_id => 'foo'
-        end
-
-        should "send multiple :node_id-s correctly" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal '_nodes/A,B,C', url
-            true
-          end.returns(FakeResponse.new).twice
-
-          subject.nodes.info :node_id => 'A,B,C'
-          subject.nodes.info :node_id => ['A', 'B', 'C']
-        end
-
-        should "properly pass URL parts" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_same_elements ['http','jvm'], url.split('/').last.split(',')
-            assert_nil   params[:jvm]
-            assert_nil   params[:http]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.nodes.info :jvm => true, :http => true
-        end
-
-        should "properly pass URL parameters" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal '_nodes', url
-            assert_equal 'yaml',   params[:format]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.nodes.info :format => 'yaml'
-        end
-
-        should "encode metrics" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal '_nodes/http,network', url
-            assert_nil   params[:metric]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.nodes.info :metric => ['http', 'network']
-        end
-      end
-
-    end
-  end
-end

data/test/unit/nodes/shutdown_test.rb

@@ -1,45 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class NodesShutdownTest < ::Test::Unit::TestCase
-
-      context "Nodes: Shutdown" do
-        subject { FakeClient.new }
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'POST', method
-            assert_equal '_cluster/nodes/_shutdown', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.nodes.shutdown
-        end
-
-        should "send :node_id correctly" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal '_cluster/nodes/foo/_shutdown', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.nodes.shutdown :node_id => 'foo'
-        end
-
-        should "send multiple :node_id-s correctly" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal '_cluster/nodes/A,B,C/_shutdown', url
-            true
-          end.returns(FakeResponse.new).twice
-
-          subject.nodes.shutdown :node_id => 'A,B,C'
-          subject.nodes.shutdown :node_id => ['A', 'B', 'C']
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/nodes/stats_test.rb

@@ -1,65 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class NodesStatsTest < ::Test::Unit::TestCase
-
-      context "Nodes: Stats" do
-        subject { FakeClient.new }
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'GET', method
-            assert_equal '_nodes/stats', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.nodes.stats
-        end
-
-        should "send :node_id correctly" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal '_nodes/foo/stats', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.nodes.stats :node_id => 'foo'
-        end
-
-        should "get specific metric families" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal '_nodes/stats/http,fs', url
-            assert_equal( {}, params )
-            true
-          end.returns(FakeResponse.new)
-
-          subject.nodes.stats :metric => [:http, :fs]
-        end
-
-        should "get specific metric for the indices family" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal '_nodes/stats/indices/filter_cache', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.nodes.stats :metric => :indices, :index_metric => 'filter_cache'
-        end
-
-        should "get fielddata statistics for the indices family" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal '_nodes/stats/indices/fielddata', url
-            assert_equal( {:fields => 'foo,bar'}, params )
-            true
-          end.returns(FakeResponse.new).twice
-
-          subject.nodes.stats :metric => 'indices', :index_metric => 'fielddata', :fields => 'foo,bar'
-          subject.nodes.stats :metric => 'indices', :index_metric => 'fielddata', :fields => ['foo','bar']
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/percolate_test.rb

@@ -1,56 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class PercolateTest < ::Test::Unit::TestCase
-
-      context "Percolate" do
-        subject { FakeClient.new }
-
-        should "require the :index argument" do
-          assert_raise ArgumentError do
-            subject.percolate :type => 'bar', :body => {}
-          end
-        end
-
-        should "require the :type argument" do
-          assert_raise ArgumentError do
-            subject.percolate :index => 'bar', :body => {}
-          end
-        end
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'GET', method
-            assert_equal 'foo/bar/_percolate', url
-            assert_equal Hash.new, params
-            assert_equal 'bar', body[:doc][:foo]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.percolate :index => 'foo', :type => 'bar', :body => { :doc => { :foo => 'bar' } }
-        end
-
-        should "URL-escape the parts" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo%5Ebar/bar%2Fbam/_percolate', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.percolate :index => 'foo^bar', :type => 'bar/bam', :body => { :doc => { :foo => 'bar' } }
-        end
-
-        should "URL-escape the parts (including document id)" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo%5Ebar/bar%2Fbam/some%2Fid/_percolate', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.percolate :index => 'foo^bar', :type => 'bar/bam', :id => 'some/id'
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/ping_test.rb

@@ -1,53 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class PingTest < ::Test::Unit::TestCase
-
-      context "Ping" do
-        subject { FakeClient.new }
-
-         should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'HEAD', method
-            assert_equal '', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.ping
-        end
-
-        should "return true for successful response" do
-          subject.expects(:perform_request).returns(FakeResponse.new 200, 'OK')
-          assert_equal true, subject.ping
-        end
-
-        should "return false for 404 response" do
-          subject.expects(:perform_request).returns(FakeResponse.new 404, 'Not Found')
-          assert_equal false, subject.ping
-        end
-
-        should "return false on 'not found' exceptions" do
-          subject.expects(:perform_request).raises(StandardError.new '404 NotFound')
-          assert_equal false, subject.ping
-        end
-
-        should "return false on 'connection failed' exceptions" do
-          subject.expects(:perform_request).raises(StandardError.new 'ConnectionFailed')
-          assert_equal false, subject.ping
-        end
-
-        should "re-raise generic exceptions" do
-          subject.expects(:perform_request).raises(StandardError)
-          assert_raise(StandardError) do
-            assert_equal false, subject.ping
-          end
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/put_script_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class PutScriptTest < ::Test::Unit::TestCase
-
-      context "Put script" do
-        subject { FakeClient.new }
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'PUT', method
-            assert_equal '_scripts/groovy/foo', url
-            assert_equal Hash.new, params
-            assert_equal 'bar', body[:script]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.put_script :lang => 'groovy', :id => 'foo', :body => { :script => 'bar' }
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/put_template_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class PutTemplateTest < ::Test::Unit::TestCase
-
-      context "Put template" do
-        subject { FakeClient.new }
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'PUT', method
-            assert_equal '_search/template/foo', url
-            assert_equal Hash.new, params
-            assert_equal Hash.new, body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.put_template :id => 'foo', :body => {}
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/reindex_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class ReindexTest < ::Test::Unit::TestCase
-
-      context "Reindex" do
-        subject { FakeClient.new }
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'POST', method
-            assert_equal '_reindex', url
-            assert_equal Hash.new, params
-            assert_equal Hash.new, body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.reindex :body => {}
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/remote/info_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class RemoteInfoTest < ::Test::Unit::TestCase
-
-      context "Remote: Info" do
-        subject { FakeClient.new }
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'GET', method
-            assert_equal '_remote/info', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.remote.info
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/render_search_template_test.rb

@@ -1,25 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class RenderSearchTemplateTest < ::Test::Unit::TestCase
-
-      context "Render search template" do
-        subject { FakeClient.new }
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'GET', method
-            assert_equal '_render/template', url
-            assert_equal({ :id => 'foo' }, params)
-            assert_equal({ :foo => 'bar' }, body)
-            true
-          end.returns(FakeResponse.new)
-
-          subject.render_search_template :id => 'foo', :body => { :foo => 'bar' }
-        end
-      end
-
-    end
-  end
-end

data/test/unit/scroll_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class ScrollTest < ::Test::Unit::TestCase
-
-      context "Scroll" do
-        subject { FakeClient.new }
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'GET', method
-            assert_equal '_search/scroll', url
-            assert_equal 'cXVlcn...', params[:scroll_id]
-            assert_equal nil, body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.scroll :scroll_id => 'cXVlcn...'
-        end
-
-      end
-
-    end
-  end
-end