elasticsearch-api 6.1.0 → 6.2.0

data/test/unit/indices/get_warmer_test.rb

@@ -1,44 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class IndicesGetWarmerTest < ::Test::Unit::TestCase
-
-      context "Indices: Get warmer" 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 '_all/_warmer', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.get_warmer :index => '_all'
-        end
-
-        should "return 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.get_warmer :index => 'foo', :name => 'bar'
-        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.get_warmer :index => 'foo^bar', :name => 'bar/bam'
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/indices/open_test.rb

@@ -1,51 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class IndicesOpenTest < ::Test::Unit::TestCase
-
-      context "Indices: Open" do
-        subject { FakeClient.new }
-
-        should "require the :index argument" do
-          assert_raise ArgumentError do
-            subject.indices.open
-          end
-        end
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'POST', method
-            assert_equal 'foo/_open', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.open :index => 'foo'
-        end
-
-        should "pass the URL parameters" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/_open', url
-            assert_equal '1s', params[:timeout]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.open :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/_open', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.open :index => 'foo^bar'
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/indices/optimize_test.rb

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

data/test/unit/indices/put_alias_test.rb

@@ -1,59 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class IndicesPutAliasTest < ::Test::Unit::TestCase
-
-      context "Indices: Put alias" do
-        subject { FakeClient.new }
-
-        should "require the :name argument" do
-          assert_raise ArgumentError do
-            subject.indices.put_alias :index => 'foo'
-          end
-        end
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'PUT', method
-            assert_equal 'foo/_alias/bar', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.put_alias :index => 'foo', :name => 'bar'
-        end
-
-        should "send the alias settings in :body" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo', body[:filter]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.put_alias :index => 'foo', :name => 'bar', :body => { :filter => 'foo' }
-        end
-
-        should "Listify indices" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo,bar/_alias/bar%2Fbam', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.put_alias :index => ['foo', 'bar'], :name => 'bar/bam', :body => {}
-        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.put_alias :index => 'foo^bar', :name => 'bar/bam', :body => {}
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/indices/put_mapping_test.rb

@@ -1,60 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class IndicesPutMappingTest < ::Test::Unit::TestCase
-
-      context "Indices: Put mapping" do
-        subject { FakeClient.new }
-
-        should "require the :type argument" do
-          assert_raise ArgumentError do
-            subject.indices.put_mapping :index => 'foo', :body => {}
-          end
-        end
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'PUT', method
-            assert_equal 'foo/_mapping/bar', url
-            assert_equal Hash.new, params
-            assert_equal({ :foo => {} }, body)
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.put_mapping :index => 'foo', :type => 'bar', :body => { :foo => {} }
-        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.put_mapping :index => ['foo','bar'], :type => 'bam', :body => {}
-        end
-
-        should "pass the URL parameters" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/_mapping/bar', url
-            assert_equal true, params[:ignore_conflicts]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.put_mapping :index => 'foo', :type => 'bar', :body => {}, :ignore_conflicts => true
-        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.put_mapping :index => 'foo^bar', :type => 'bar/bam', :body => {}
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/indices/put_settings_test.rb

@@ -1,68 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class IndicesPutSettingsTest < ::Test::Unit::TestCase
-
-      context "Indices: Put settings" do
-        subject { FakeClient.new }
-
-        should "require the :body argument" do
-          assert_raise ArgumentError do
-            subject.indices.put_settings
-          end
-        end
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'PUT', method
-            assert_equal '_settings', url
-            assert_equal Hash.new, params
-            assert_equal Hash.new, body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.put_settings :body => {}
-        end
-
-        should "perform request with parameters" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal true, params[:flat_settings]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.put_settings :index => 'foo', :flat_settings => true, :body => {}
-        end
-
-        should "perform request against a specific indices" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/_settings', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.put_settings :index => 'foo', :body => {}
-        end
-
-        should "perform request against multiple indices" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo,bar/_settings', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.put_settings :index => ['foo','bar'], :body => {}
-        end
-
-        should "URL-escape the parts" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo%5Ebar/_settings', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.put_settings :index => 'foo^bar', :body => {}
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/indices/put_template_test.rb

@@ -1,57 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class IndicesPutTemplateTest < ::Test::Unit::TestCase
-
-      context "Indices: Put template" do
-        subject { FakeClient.new }
-
-        should "require the :name argument" do
-          assert_raise ArgumentError do
-            subject.indices.put_template :body => {}
-          end
-        end
-
-        should "require the :body argument" do
-          assert_raise ArgumentError do
-            subject.indices.put_template :name => 'foo'
-          end
-        end
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'PUT', method
-            assert_equal '_template/foo', url
-            assert_equal Hash.new, params
-            assert_equal 'bar', body[:template]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.put_template :name => 'foo', :body => { :template => 'bar' }
-        end
-
-         should "pass the URL parameters" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal '_template/foo', url
-            assert_equal 3, params[:order]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.put_template :name => 'foo', :body => {}, :order => 3
-        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.put_template :name => 'foo^bar', :body => {}
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/indices/put_warmer_test.rb

@@ -1,65 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class IndicesPutWarmerTest < ::Test::Unit::TestCase
-
-      context "Indices: Put warmer" do
-        subject { FakeClient.new }
-
-        should "require the :name argument" do
-          assert_raise ArgumentError do
-            subject.indices.put_warmer :index => 'foo', :body => {}
-          end
-        end
-
-        should "require the :body argument" do
-          assert_raise ArgumentError do
-            subject.indices.put_warmer :index => 'foo', :name => 'bar'
-          end
-        end
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'PUT', method
-            assert_equal 'foo/_warmer/bar', url
-            assert_equal Hash.new, params
-            assert_equal :match_all, body[:query].keys.first
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.put_warmer :index => 'foo', :name => 'bar', :body => { :query => { :match_all => {} } }
-        end
-
-        should "perform request against multiple indices" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo,bar/_warmer/xul', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.put_warmer :index => ['foo','bar'], :name => 'xul', :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/_warmer/xul', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.put_warmer :index => 'foo', :type => 'bar', :name => 'xul', :body => {}
-        end
-
-        should "URL-escape the parts" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo%5Ebar/bar%2Fbam/_warmer/qu+uz', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.put_warmer :index => 'foo^bar', :type => 'bar/bam', :name => 'qu uz', :body => {}
-        end
-
-      end
-
-    end
-  end
-end