elasticsearch-api 6.1.0 → 6.2.0

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

data/test/unit/field_caps_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class FieldCapsTest < ::Test::Unit::TestCase
-
-      context "Field caps" 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/_field_caps', url
-            assert_equal 'bar', params[:fields]
-            assert_equal nil, body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.field_caps index: 'foo', fields: 'bar'
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/field_stats_test.rb

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

data/test/unit/get_document_source_test.rb

@@ -1,71 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class GetSourceTest < ::Test::Unit::TestCase
-
-      context "Get document source" do
-        subject { FakeClient.new }
-
-        should "require the :index argument" do
-          assert_raise ArgumentError do
-            subject.get_source :type => 'bar', :id => '1'
-          end
-        end
-
-        should "NOT require the :type argument" do
-          assert_nothing_raised do
-            subject.get_source :index => 'foo', :id => '1'
-          end
-        end
-
-        should "require the :id argument" do
-          assert_raise ArgumentError do
-            subject.get_source :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/_source', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.get_source :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/_source', url
-            assert_equal 'abc123', params[:routing]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.get_source :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%5Ebar/bar%2Fbam/1/_source', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.get_source :index => 'foo^bar', :type => 'bar/bam', :id => '1'
-        end
-
-        should "catch a NotFound exception with the ignore parameter" do
-          subject.expects(:perform_request).raises(NotFound)
-
-          assert_nothing_raised do
-            subject.get :index => 'foo', :type => 'bar', :id => 'XXX', :ignore => 404
-          end
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/get_document_test.rb

@@ -1,85 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class GetTest < ::Test::Unit::TestCase
-
-      context "Get document" do
-        subject { FakeClient.new }
-
-        should "require the :index argument" do
-          assert_raise ArgumentError do
-            subject.get :type => 'bar', :id => '1'
-          end
-        end
-
-        should "NOT require the :type argument" do
-          assert_nothing_raised do
-            subject.get :index => 'foo', :id => '1'
-          end
-        end
-
-        should "require the :id argument" do
-          assert_raise ArgumentError do
-            subject.get :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', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.get :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.get :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%5Ebar/bar%2Fbam/1', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.exists :index => 'foo^bar', :type => 'bar/bam', :id => '1'
-        end
-
-        should "validate URL parameters" do
-          assert_raise ArgumentError do
-            subject.get :index => 'foo', :type => 'bar', :id => '1', :qwertypoiuy => 'asdflkjhg'
-          end
-        end
-
-        should "raise a NotFound exception" do
-          subject.expects(:perform_request).raises(NotFound)
-
-          assert_raise NotFound do
-            subject.get :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.get :index => 'foo', :type => 'bar', :id => 'XXX', :ignore => 404
-          end
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/get_script_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class GetScriptTest < ::Test::Unit::TestCase
-
-      context "Get script" 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 '_scripts/groovy/foo', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.get_script :lang => "groovy", :id => 'foo'
-        end
-
-      end
-
-    end
-  end
-end