elasticsearch-api 6.0.1 → 7.0.0

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

data/test/unit/indices/recovery_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class IndicesRecoveryTest < ::Test::Unit::TestCase
-
-      context "Indices: Recovery" 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/_recovery', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.recovery :index => 'foo'
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/indices/refresh_test.rb

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

data/test/unit/indices/rollover_test.rb

@@ -1,38 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class IndicesRolloverTest < ::Test::Unit::TestCase
-
-      context "Indices: Rollover" 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/_rollover', url
-            assert_equal Hash.new, params
-            assert_equal nil, body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.rollover :alias => 'foo'
-        end
-
-        should "customize the index" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'POST', method
-            assert_equal 'foo/_rollover/bar', url
-            assert_equal Hash.new, params
-            assert_equal nil, body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.rollover :alias => 'foo', :new_index => 'bar'
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/indices/seal_test.rb

@@ -1,25 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class IndicesSealTest < ::Test::Unit::TestCase
-
-      context "Indices: Seal" 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/_seal', url
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.seal :index => 'foo'
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/indices/segments_test.rb

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

data/test/unit/indices/shard_stores_test.rb

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

data/test/unit/indices/shrink_test.rb

@@ -1,33 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class IndicesShrinkTest < ::Test::Unit::TestCase
-
-      context "Indices: Shrink" 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 'foo/_shrink/bar', url
-            assert_equal nil, body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.shrink :index => 'foo', :target => 'bar'
-        end
-
-        should "not change the arguments" do
-          arguments = { :index => 'foo', :target => 'bar', :body => { :settings => {} } }
-          subject.indices.shrink arguments
-
-          assert_not_nil arguments[:index]
-          assert_not_nil arguments[:target]
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/indices/snapshot_index_test.rb

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

data/test/unit/indices/stats_test.rb

@@ -1,76 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class IndicesStatsTest < ::Test::Unit::TestCase
-
-      context "Indices: 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 '_stats', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.stats
-        end
-
-        should "perform request against an index" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/_stats', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.stats :index => 'foo'
-        end
-
-        should "perform request against multiple indices" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo,bar/_stats', url
-            true
-          end.returns(FakeResponse.new).twice
-
-          subject.indices.stats :index => ['foo','bar']
-          subject.indices.stats :index => 'foo,bar'
-        end
-
-        should "pass the URL parameters" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/_stats', url
-            assert_equal true, params[:expand_wildcards]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.stats :index => 'foo', :expand_wildcards => true
-        end
-
-        should "pass the fields parameter as a list" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/_stats/fielddata', url
-            assert_nil   params[:fielddata]
-            assert_equal 'foo,bar', params[:fields]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.stats :index => 'foo', :fielddata => true, :fields => ['foo', 'bar']
-        end
-
-        should "pass the groups parameter as a list" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal '_stats/search', url
-            assert_equal 'groupA,groupB', params[:groups]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.stats :search => true, :groups => ['groupA','groupB']
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/indices/status_test.rb

@@ -1,72 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class IndicesStatusTest < ::Test::Unit::TestCase
-
-      context "Indices: Status" 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 '_status', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.status
-        end
-
-        should "perform request against an index" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/_status', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.status :index => 'foo'
-        end
-
-        should "perform request against multiple indices" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo,bar/_status', url
-            true
-          end.returns(FakeResponse.new).twice
-
-          subject.indices.status :index => ['foo','bar']
-          subject.indices.status :index => 'foo,bar'
-        end
-
-        should "pass the URL parameters" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/_status', url
-            assert_equal true, params[:recovery]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.status :index => 'foo', :recovery => true
-        end
-
-        should "URL-escape the parts" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo%5Ebar/_status', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.status :index => 'foo^bar'
-        end
-
-        should "catch a NotFound exception with the ignore parameter" do
-          subject.expects(:perform_request).raises(NotFound)
-
-          assert_nothing_raised do
-            subject.indices.status :index => 'foo^bar', :ignore => 404
-          end
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/indices/update_aliases_test.rb

@@ -1,42 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class IndicesPutAliasesTest < ::Test::Unit::TestCase
-
-      context "Indices: Update aliases" do
-        subject { FakeClient.new }
-
-        should "require the :body argument" do
-          assert_raise ArgumentError do
-            subject.indices.update_aliases
-          end
-        end
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'POST', method
-            assert_equal '_aliases', url
-            assert_equal Hash.new, params
-            assert_equal [], body[:actions]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.update_aliases :body => { :actions => [] }
-        end
-
-        should "pass the URL parameters" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal '_aliases', url
-            assert_equal '1s', params[:timeout]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.update_aliases :body => {}, :timeout => '1s'
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/indices/upgrade_test.rb

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