elasticsearch-api 6.0.1 → 7.0.0

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

data/test/unit/get_template_test.rb

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

data/test/unit/index_document_test.rb

@@ -1,92 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class IndexDocumentTest < ::Test::Unit::TestCase
-
-      context "Indexing a document" do
-        subject { FakeClient.new }
-
-        should "require the :index argument" do
-          assert_raise ArgumentError do
-            subject.index :type => 'foo'
-          end
-        end
-
-        should "require the :type argument" do
-          assert_raise ArgumentError do
-            subject.index :index => 'foo'
-          end
-        end
-
-        should "perform the index request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'POST', method
-            assert_equal 'foo/bar', url
-            assert_equal({:foo => 'bar'}, body)
-            true
-          end.returns(FakeResponse.new)
-
-          subject.index :index => 'foo', :type => 'bar', :body => {:foo => 'bar'}
-        end
-
-        should "perform the index 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_nil   params[:id]
-            assert_equal({:foo => 'bar'}, body)
-            true
-          end.returns(FakeResponse.new)
-
-          subject.index :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.index :index => 'foo', :type => 'bar/bam', :id => '123', :body => {}
-        end
-
-        should "validate URL parameters" do
-          assert_raise ArgumentError do
-            subject.index :index => 'foo', :type => 'bar/bam', :id => '123', :body => {}, :qwertypoiuy => 'asdflkjhg'
-          end
-        end
-      end
-
-      context "Creating a document" do
-        subject { FakeClient.new }
-
-        should "perform the create request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'POST', method
-            assert_equal 'foo/bar', url
-            assert_equal({:op_type => 'create'}, params)
-            assert_equal({:foo => 'bar'}, body)
-            true
-          end.returns(FakeResponse.new)
-
-          subject.index :index => 'foo', :type => 'bar', :op_type => 'create', :body => {:foo => 'bar'}
-        end
-
-        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.index :index => 'foo', :type => 'bar', :id => '123', :op_type => 'create', :body => {:foo => 'bar'}
-        end
-      end
-
-    end
-  end
-end

data/test/unit/indices/analyze_test.rb

@@ -1,76 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class IndicesAnalyzeTest < ::Test::Unit::TestCase
-
-      context "Indices: Analyze" 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 '_analyze', url
-            assert_equal Hash.new, params
-            assert_nil body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.analyze
-        end
-
-        should "perform request against an index" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/_analyze', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.analyze :index => 'foo'
-        end
-
-        should "pass the URL parameters" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal '_analyze', url
-            assert_equal 'foo', params[:text]
-            assert_equal 'bar', params[:analyzer]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.analyze :text => 'foo', :analyzer => 'bar'
-        end
-
-        should "pass the text in body" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal '_analyze', url
-            assert_equal Hash.new, params
-            assert_equal 'foo', body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.analyze :body => 'foo'
-        end
-
-        should "pass the filters parameter as a list" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal '_analyze', url
-            assert_equal 'foo,bar', params[:filters]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.analyze :text => 'Test', :tokenizer => 'whitespace', :filters => ['foo,bar']
-        end
-
-        should "URL-escape the parts" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo%5Ebar/_analyze', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.analyze :index => 'foo^bar', :text => 'Test'
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/indices/clear_cache_test.rb

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

data/test/unit/indices/close_test.rb

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

data/test/unit/indices/create_test.rb

@@ -1,51 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class IndicesCreateTest < ::Test::Unit::TestCase
-
-      context "Indices: Create" do
-        subject { FakeClient.new }
-
-        should "require the :index argument" do
-          assert_raise ArgumentError do
-            subject.indices.create
-          end
-        end
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'PUT', method
-            assert_equal 'foo', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.create :index => 'foo'
-        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.create :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.create :index => 'foo^bar'
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/indices/delete_alias_test.rb

@@ -1,47 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class IndicesDeleteAliasTest < ::Test::Unit::TestCase
-
-      context "Indices: Delete alias" do
-        subject { FakeClient.new }
-
-        should "require the :index argument" do
-          assert_raise ArgumentError do
-            subject.indices.delete_alias :name => 'bar'
-          end
-        end
-
-        should "require the :name argument" do
-          assert_raise ArgumentError do
-            subject.indices.delete_alias :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/_alias/bar', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.delete_alias :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/_alias/bar%2Fbam', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.indices.delete_alias :index => 'foo^bar', :name => 'bar/bam'
-        end
-
-      end
-
-    end
-  end
-end