elasticsearch-api 6.0.1 → 7.0.0

data/test/unit/indices/delete_mapping_test.rb

@@ -1,56 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class IndicesDeleteMappingTest < ::Test::Unit::TestCase
-
-      context "Indices: Delete mapping" do
-        subject { FakeClient.new }
-
-        should "require the :index argument" do
-          assert_raise ArgumentError do
-            subject.indices.delete_mapping :type => 'bar'
-          end
-        end
-
-        should "require the :type argument" do
-          assert_raise ArgumentError do
-            subject.indices.delete_mapping :index => 'foo'
-          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', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.delete_mapping :index => 'foo', :type => 'bar'
-        end
-
-        should "perform request against multiple indices" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo,bar/baz', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.delete_mapping :index => ['foo','bar'], :type => 'baz'
-        end
-
-        should "URL-escape the parts" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo%5Ebar/bar%2Fbam', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.delete_mapping :index => 'foo^bar', :type => 'bar/bam'
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/indices/delete_template_test.rb

@@ -1,51 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class IndicesDeleteTemplateTest < ::Test::Unit::TestCase
-
-      context "Indices: 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 '_template/foo', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.delete_template :name => 'foo'
-        end
-
-        should "URL-escape the parts" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal '_template/foo%5Ebar', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.delete_template :name => 'foo^bar'
-        end
-
-        should "raise a NotFound exception" do
-          subject.expects(:perform_request).raises(NotFound)
-
-          assert_raise NotFound do
-            assert ! subject.indices.delete_template(:name => 'foo')
-          end
-        end
-
-        should "catch a NotFound exception with the ignore parameter" do
-          subject.expects(:perform_request).raises(NotFound)
-
-          assert_nothing_raised do
-            assert ! subject.indices.delete_template(:name => 'foo', :ignore => 404)
-          end
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/indices/delete_test.rb

@@ -1,69 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class IndicesDeleteTest < ::Test::Unit::TestCase
-
-      context "Indices: Delete" 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 'foo', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.delete :index => 'foo'
-        end
-
-        should "perform the request for more indices" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo,bar', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.delete :index => ['foo','bar']
-        end
-
-        should "pass the URL parameters" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo', url
-            assert_equal '1s', params[:timeout]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.delete :index => 'foo', :timeout => '1s'
-        end
-
-        should "URL-escape the parts" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo%5Ebar', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.delete :index => 'foo^bar'
-        end
-
-        should "raise a NotFound exception" do
-          subject.expects(:perform_request).raises(NotFound)
-
-          assert_raise NotFound do
-            subject.indices.delete :index => 'foo'
-          end
-        end
-
-        should "catch a NotFound exception with the ignore parameter" do
-          subject.expects(:perform_request).raises(NotFound)
-
-          assert_nothing_raised do
-            subject.indices.delete :index => 'foo', :ignore => 404
-          end
-        end
-      end
-
-    end
-  end
-end

data/test/unit/indices/delete_warmer_test.rb

@@ -1,68 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class IndicesDeleteWarmerTest < ::Test::Unit::TestCase
-
-      context "Indices: Delete warmer" do
-        subject { FakeClient.new }
-
-        should "require the :index argument" do
-          assert_raise ArgumentError do
-            subject.indices.delete_warmer
-          end
-        end
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'DELETE', method
-            assert_equal 'foo/_warmer', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.delete_warmer :index => 'foo'
-        end
-
-        should "perform request against multiple indices" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo,bar/_warmer', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.delete_warmer :index => ['foo','bar']
-        end
-
-        should "perform request against single warmer" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/_warmer/bar', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.delete_warmer :index => 'foo', :name => 'bar'
-        end
-
-        should "perform request against multiple warmers" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/_warmer/bar,baz', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.delete_warmer :index => 'foo', :name => ['bar', 'baz']
-        end
-
-        should "URL-escape the parts" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo%5Ebar/_warmer/bar%2Fbam', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.delete_warmer :index => 'foo^bar', :name => 'bar/bam'
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/indices/exists_alias_test.rb

@@ -1,73 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class IndicesExistsAliasTest < ::Test::Unit::TestCase
-
-      context "Indices: Exists alias" 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 '_alias/foo', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.exists_alias :name => 'foo'
-        end
-
-        should "perform request against multiple indices" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo,bar/_alias/bam', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.exists_alias :index => ['foo','bar'], :name => 'bam'
-        end
-
-        should "URL-escape the parts" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo%5Ebar/_alias/bar%2Fbam', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.exists_alias :index => 'foo^bar', :name => 'bar/bam'
-        end
-
-        should "return true for successful response" do
-          subject.expects(:perform_request).returns(FakeResponse.new 200, 'OK')
-          assert_equal true, subject.indices.exists_alias(:name => 'foo')
-        end
-
-        should "return false for 404 response" do
-          subject.expects(:perform_request).returns(FakeResponse.new 404, 'Not Found')
-          assert_equal false, subject.indices.exists_alias(:name => 'none')
-        end
-
-        should "return false on 'not found' exceptions" do
-          subject.expects(:perform_request).raises(StandardError.new '404 NotFound')
-          assert_nothing_raised do
-            assert_equal false, subject.indices.exists_alias(:name => 'none')
-          end
-        end
-
-        should "re-raise generic exceptions" do
-          subject.expects(:perform_request).raises(StandardError)
-          assert_raise(StandardError) do
-            assert_equal false, subject.indices.exists_alias(:name => 'none')
-          end
-        end
-
-        should "be aliased as predicate method" do
-          assert_nothing_raised do
-            subject.indices.exists_alias?(:name => 'foo') == subject.indices.exists_alias(:name => 'foo')
-          end
-        end
-      end
-
-    end
-  end
-end

data/test/unit/indices/exists_template_test.rb

@@ -1,59 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class IndicesExistsTemplateTest < ::Test::Unit::TestCase
-
-      context "Indices: Exists template" 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 '_template/foo', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.exists_template :name => 'foo'
-        end
-
-        should "URL-escape the parts" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal '_template/bar%2Fbam', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.exists_template :name => 'bar/bam'
-        end
-
-        should "return true for successful response" do
-          subject.expects(:perform_request).returns(FakeResponse.new 200, 'OK')
-          assert_equal true, subject.indices.exists_template(:name => 'bar')
-        end
-
-        should "return false for 404 response" do
-          subject.expects(:perform_request).returns(FakeResponse.new 404, 'Not Found')
-          assert_equal false, subject.indices.exists_template(:name => 'none')
-        end
-
-        should "return false on 'not found' exceptions" do
-          subject.expects(:perform_request).raises(StandardError.new '404 NotFound')
-          assert_nothing_raised do
-            assert_equal false, subject.indices.exists_template(:name => 'none')
-          end
-        end
-
-        should "re-raise generic exceptions" do
-          subject.expects(:perform_request).raises(StandardError)
-          assert_raise(StandardError) do
-            assert_equal false, subject.indices.exists_template(:name => 'none')
-          end
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/indices/exists_test.rb

@@ -1,71 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class IndicesExistsTest < ::Test::Unit::TestCase
-
-      context "Indices: Exists" 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 'foo', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.exists(:index => 'foo')
-        end
-
-        should "perform the request against multiple indices" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo,bar', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.exists(:index => ['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', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.exists :index => 'foo^bar,bar/bam'
-        end
-
-        should "return true for successful response" do
-          subject.expects(:perform_request).returns(FakeResponse.new 200, 'OK')
-          assert_equal true, subject.indices.exists(:index => 'foo')
-        end
-
-        should "return false for 404 response" do
-          subject.expects(:perform_request).returns(FakeResponse.new 404, 'Not Found')
-          assert_equal false, subject.indices.exists(:index => 'none')
-        end
-
-        should "return false on 'not found' exceptions" do
-          subject.expects(:perform_request).raises(StandardError.new '404 NotFound')
-          assert_equal false, subject.indices.exists(:index => 'none')
-        end
-
-        should "re-raise generic exceptions" do
-          subject.expects(:perform_request).raises(StandardError)
-          assert_raise(StandardError) do
-            assert_equal false, subject.indices.exists(:index => 'none')
-          end
-        end
-
-        should "be aliased as predicate method" do
-          assert_nothing_raised do
-            subject.indices.exists?(:index => 'foo') == subject.indices.exists(:index => 'foo')
-          end
-        end
-      end
-
-    end
-  end
-end

data/test/unit/indices/exists_type_test.rb

@@ -1,73 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class IndicesExistsTypeTest < ::Test::Unit::TestCase
-
-      context "Indices: Exists type" 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 'foo/_mapping/bar', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.exists_type :index => 'foo', :type => 'bar'
-        end
-
-        should "perform request against multiple indices" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo,bar/_mapping/bam', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.exists_type :index => ['foo','bar'], :type => 'bam'
-        end
-
-        should "URL-escape the parts" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo%5Ebar/_mapping/bar%2Fbam', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.exists_type :index => 'foo^bar', :type => 'bar/bam'
-        end
-
-        should "return true for successful response" do
-          subject.expects(:perform_request).returns(FakeResponse.new 200, 'OK')
-          assert_equal true, subject.indices.exists_type(:index => 'foo', :type => 'bar')
-        end
-
-        should "return false for 404 response" do
-          subject.expects(:perform_request).returns(FakeResponse.new 404, 'Not Found')
-          assert_equal false, subject.indices.exists_type(:index => 'foo', :type => 'none')
-        end
-
-        should "return false on 'not found' exceptions" do
-          subject.expects(:perform_request).raises(StandardError.new '404 NotFound')
-          assert_nothing_raised do
-            assert_equal false, subject.indices.exists_type(:index => 'foo', :type => 'none')
-          end
-        end
-
-        should "re-raise generic exceptions" do
-          subject.expects(:perform_request).raises(StandardError)
-          assert_raise(StandardError) do
-            assert_equal false, subject.indices.exists_type(:index => 'foo', :type => 'none')
-          end
-        end
-
-        should "be aliased as predicate method" do
-          assert_nothing_raised do
-            subject.indices.exists_type?(:index => 'foo', :type => 'bar') == subject.indices.exists_type(:index => 'foo', :type => 'bar')
-          end
-        end
-      end
-
-    end
-  end
-end

data/test/unit/indices/flush_synced_test.rb

@@ -1,41 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class IndicesFlushSyncedTest < ::Test::Unit::TestCase
-
-      context "Indices: Flush synced" 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 'foo/_flush/synced', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.flush_synced :index => 'foo'
-        end
-
-        should "raise a NotFound exception" do
-          subject.expects(:perform_request).raises(NotFound)
-
-          assert_raise NotFound do
-            subject.indices.flush_synced :index => 'foo'
-          end
-        end
-
-        should "catch a NotFound exception with the ignore parameter" do
-          subject.expects(:perform_request).raises(NotFound)
-
-          assert_nothing_raised do
-            subject.indices.flush_synced :index => 'foo', :ignore => 404
-          end
-        end
-      end
-
-    end
-  end
-end

data/test/unit/indices/flush_test.rb

@@ -1,54 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class IndicesFlushTest < ::Test::Unit::TestCase
-
-      context "Indices: Flush" 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 '_flush', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.flush
-        end
-
-        should "perform request against multiple indices" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo,bar/_flush', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.flush :index => ['foo','bar']
-        end
-
-        should "URL-escape the parts" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo%5Ebar/_flush', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.flush :index => 'foo^bar'
-        end
-
-        should "pass the URL parameters" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/_flush', url
-            assert_equal true, params[:ignore_unavailable]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.flush :index => 'foo', :ignore_unavailable => true
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/indices/forcemerge_test.rb

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

data/test/unit/indices/get_alias_test.rb

@@ -1,44 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class IndicesGetAliasTest < ::Test::Unit::TestCase
-
-      context "Indices: Get alias" 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 '_alias/foo', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.get_alias :name => 'foo'
-        end
-
-        should "perform request against multiple indices" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo,bar/_alias/bam', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.get_alias :index => ['foo','bar'], :name => 'bam'
-        end
-
-        should "URL-escape the parts" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo%5Ebar/_alias/bar%2Fbam', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.get_alias :index => 'foo^bar', :name => 'bar/bam'
-        end
-
-      end
-
-    end
-  end
-end