elasticsearch-api 6.0.1 → 7.0.0

data/test/unit/cluster/pending_tasks_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class ClusterPendingTasksTest < ::Test::Unit::TestCase
-
-      context "Cluster: Pending tasks" 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 '_cluster/pending_tasks', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.cluster.pending_tasks
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/cluster/put_settings_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class ClusterPutSettingsTest < ::Test::Unit::TestCase
-
-      context "Cluster: Put settings" 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 '_cluster/settings', url
-            assert_equal Hash.new, params
-            assert_equal Hash.new, body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.cluster.put_settings
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/cluster/remote_info_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class ClusterRemoteInfoTest < ::Test::Unit::TestCase
-
-      context "Cluster: 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.cluster.remote_info
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/cluster/reroute_test.rb

@@ -1,38 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class ClusterRerouteTest < ::Test::Unit::TestCase
-
-      context "Cluster: Reroute" 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/reroute', url
-            assert_equal Hash.new, params
-            assert_equal Hash.new, body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.cluster.reroute
-        end
-
-        should "send the body" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'POST', method
-            assert_equal '_cluster/reroute', url
-            assert_equal Hash.new, params
-            assert_equal({:commands => [ :move => { :index => 'myindex', :shard => 0 } ]}, body)
-            true
-          end.returns(FakeResponse.new)
-
-          subject.cluster.reroute :body => { :commands => [ :move => { :index => 'myindex', :shard => 0 } ] }
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/cluster/state_test.rb

@@ -1,46 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class ClusterStateTest < ::Test::Unit::TestCase
-
-      context "Cluster: State" 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 '_cluster/state', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.cluster.state
-        end
-
-        should "build the correct path" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal '_cluster/state/foo,bar', url
-            assert_equal({}, params)
-            true
-          end.returns(FakeResponse.new)
-
-          subject.cluster.state :metric => ['foo', 'bar']
-        end
-
-        should "send the API parameters" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal '_cluster/state', url
-            assert_equal({:index_templates => 'foo,bar'}, params)
-            true
-          end.returns(FakeResponse.new)
-
-          subject.cluster.state :index_templates => ['foo', 'bar']
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/cluster/stats_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class ClusterStatsTest < ::Test::Unit::TestCase
-
-      context "Cluster: 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 '_cluster/stats', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.cluster.stats
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/count_percolate_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class CountPercolateTest < ::Test::Unit::TestCase
-
-      context "Count percolate" 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 'foo/bar/_percolate/count', url
-            assert_equal Hash.new, params
-            assert_equal 'bar', body[:doc][:foo]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.count_percolate :index => 'foo', :type => 'bar', :body => { :doc => { :foo => 'bar' } }
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/count_test.rb

@@ -1,46 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class CountTest < ::Test::Unit::TestCase
-
-      context "Count" 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 '_count', url
-            assert_equal Hash.new, params
-            assert_nil body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.count
-        end
-
-        should "encode indices and types" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'GET', method
-            assert_equal 'foo,bar/t1,t2/_count', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.count :index => ['foo','bar'], :type => ['t1','t2']
-        end
-
-        should "take the query" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'GET', method
-            assert_equal( {:match => {:foo => 'bar'}}, body)
-            true
-          end.returns(FakeResponse.new)
-
-          subject.count :body => { :match => { :foo => 'bar' } }
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/create_document_test.rb

@@ -1,56 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class IndexDocumentTest < ::Test::Unit::TestCase
-
-      context "Creating a document with the #create method" do
-        subject { FakeClient.new }
-
-        should "perform the create request with a specific ID" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'PUT', method
-            assert_equal 'foo/bar/123', url
-            assert_equal 'create', params[:op_type]
-            assert_nil   params[:id]
-            assert_equal({:foo => 'bar'}, body)
-            true
-          end.returns(FakeResponse.new)
-
-          subject.create :index => 'foo', :type => 'bar', :id => '123', :body => {:foo => 'bar'}
-        end
-
-        should "URL-escape the parts" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/bar%2Fbam/123', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.create :index => 'foo', :type => 'bar/bam', :id => '123', :body => {}
-        end
-
-        should "update the arguments with `op_type` when the `:id` argument is present" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/bar/1', url
-            assert_not_nil params[:op_type]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.create :index => 'foo', :type => 'bar', :id => 1, :body => { :foo => 'bar' }
-        end
-
-        should "pass the arguments when the `:id` argument is missing" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/bar', url
-            assert_nil params[:op_type]
-            assert_nil params[:id]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.create :index => 'foo', :type => 'bar', :body => { :foo => 'bar' }
-        end
-      end
-
-    end
-  end
-end

data/test/unit/delete_by_query_test.rb

@@ -1,51 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class DeleteByQueryTest < ::Test::Unit::TestCase
-
-      context "Delete by query" do
-        subject { FakeClient.new }
-
-        should "require the :index argument" do
-          assert_raise ArgumentError do
-            subject.delete_by_query :body => {}
-          end
-        end
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'POST', method
-            assert_equal 'foo/_delete_by_query', url
-            assert_equal Hash.new, params
-            assert_equal Hash.new, body[:term]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.delete_by_query :index => 'foo', :body => { :term => {} }
-        end
-
-        should "optionally take the :type argument" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/tweet,post/_delete_by_query', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.delete_by_query :index => 'foo', :type => ['tweet', 'post'], :body => { :term => {} }
-        end
-
-        should "pass the query in URL parameters" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/_delete_by_query', url
-            assert_equal 'foo:bar', params[:q]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.delete_by_query :index => 'foo', :q => 'foo:bar'
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/delete_document_test.rb

@@ -1,85 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class DeleteTest < ::Test::Unit::TestCase
-
-      context "Delete document" do
-        subject { FakeClient.new }
-
-        should "require the :index argument" do
-          assert_raise ArgumentError do
-            subject.delete :type => 'bar', :id => '1'
-          end
-        end
-
-        should "require the :type argument" do
-          assert_raise ArgumentError do
-            subject.delete :index => 'foo', :id => '1'
-          end
-        end
-
-        should "require the :id argument" do
-          assert_raise ArgumentError do
-            subject.delete :index => 'foo', :type => 'bar'
-          end
-        end
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'DELETE', method
-            assert_equal 'foo/bar/1', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.delete :index => 'foo', :type => 'bar', :id => '1'
-        end
-
-        should "pass the URL parameters" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/bar/1', url
-            assert_equal 'abc123', params[:routing]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.delete :index => 'foo', :type => 'bar', :id => '1', :routing => 'abc123'
-        end
-
-        should "validate URL parameters" do
-          assert_raise ArgumentError do
-            subject.delete :index => 'foo', :type => 'bar', :id => '1', :qwertypoiuy => 'asdflkjhg'
-          end
-        end
-
-        should "URL-escape the parts" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo%5Ebar/bar%2Fbam/1', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.delete :index => 'foo^bar', :type => 'bar/bam', :id => 1
-        end
-
-        should "raise a NotFound exception" do
-          subject.expects(:perform_request).raises(NotFound)
-
-          assert_raise NotFound do
-            subject.delete :index => 'foo', :type => 'bar', :id => 'XXX'
-          end
-        end
-
-        should "catch a NotFound exception with the ignore parameter" do
-          subject.expects(:perform_request).raises(NotFound)
-
-          assert_nothing_raised do
-            subject.delete :index => 'foo', :type => 'bar', :id => 'XXX', :ignore => 404
-          end
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/delete_script_test.rb

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

data/test/unit/delete_template_test.rb

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

data/test/unit/exists_document_test.rb

@@ -1,90 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class ExistsTest < ::Test::Unit::TestCase
-
-      context "Exists document" do
-        subject { FakeClient.new }
-
-        should "require the :index argument" do
-          assert_raise ArgumentError do
-            subject.exists :type => 'bar', :id => '1'
-          end
-        end
-
-        should "NOT require the :type argument" do
-          assert_nothing_raised do
-            subject.exists :index => 'foo', :id => '1'
-          end
-        end
-
-        should "require the :id argument" do
-          assert_raise ArgumentError do
-            subject.exists :index => 'foo', :type => 'bar'
-          end
-        end
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'HEAD', method
-            assert_equal 'foo/bar/1', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.exists :index => 'foo', :type => 'bar', :id => '1'
-        end
-
-        should "pass the URL parameters" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/bar/1', url
-            assert_equal 'abc123', params[:routing]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.exists :index => 'foo', :type => 'bar', :id => '1', :routing => 'abc123'
-        end
-
-        should "URL-escape the parts" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/bar%2Fbam/1', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.exists :index => 'foo', :type => 'bar/bam', :id => '1'
-        end
-
-        should "return true for successful response" do
-          subject.expects(:perform_request).returns(FakeResponse.new 200, 'OK')
-          assert_equal true, subject.exists(:index => 'foo', :type => 'bar', :id => '1')
-        end
-
-        should "return false for 404 response" do
-          subject.expects(:perform_request).returns(FakeResponse.new 404, 'Not Found')
-          assert_equal false, subject.exists(:index => 'foo', :type => 'bar', :id => '1')
-        end
-
-        should "return false on 'not found' exceptions" do
-          subject.expects(:perform_request).raises(StandardError.new '404 NotFound')
-          assert_equal false, subject.exists(:index => 'foo', :type => 'bar', :id => '1')
-        end
-
-        should "re-raise generic exceptions" do
-          subject.expects(:perform_request).raises(StandardError)
-          assert_raise(StandardError) do
-            assert_equal false, subject.exists(:index => 'foo', :type => 'bar', :id => '1')
-          end
-        end
-
-        should "be aliased as predicate method" do
-          assert_nothing_raised do
-            subject.exists?(:index => 'foo', :type => 'bar', :id => '1') == subject.exists(:index => 'foo', :type => 'bar', :id => '1')
-          end
-        end
-      end
-
-    end
-  end
-end

data/test/unit/explain_document_test.rb

@@ -1,73 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class ExplainTest < ::Test::Unit::TestCase
-
-      context "Explain document" do
-        subject { FakeClient.new }
-
-        should "require the :index argument" do
-          assert_raise ArgumentError do
-            subject.explain :type => 'bar', :id => '1'
-          end
-        end
-
-        should "require the :type argument" do
-          assert_raise ArgumentError do
-            subject.explain :index => 'foo', :id => '1'
-          end
-        end
-
-        should "require the :id argument" do
-          assert_raise ArgumentError do
-            subject.explain :index => 'foo', :type => 'bar'
-          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/1/_explain', url
-            assert_equal Hash.new, params
-            assert_equal Hash.new, body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.explain :index => 'foo', :type => 'bar', :id => 1, :body => {}
-        end
-
-        should "pass the query in URL parameters" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/bar/1/_explain', url
-            assert_equal 'foo', params[:q]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.explain :index => 'foo', :type => 'bar', :id => 1, :q => 'foo'
-        end
-
-        should "pass the request definition in the body" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/bar/1/_explain', url
-            assert_equal Hash.new, body[:query][:match]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.explain :index => 'foo', :type => 'bar', :id => 1, :body => { :query => { :match => {} } }
-        end
-
-        should "URL-escape the parts" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo%5Ebar/bar%2Fbam/1/_explain', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.explain :index => 'foo^bar', :type => 'bar/bam', :id => '1', :body => {}
-        end
-
-      end
-
-    end
-  end
-end