elasticsearch-api 6.0.1 → 7.0.0

data/test/unit/termvectors_test.rb

@@ -1,47 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class TermvectorsTest < ::Test::Unit::TestCase
-
-      context "Termvectors" do
-        subject { FakeClient.new }
-
-        should "require the :index argument" do
-          assert_raise ArgumentError do
-            subject.termvectors :type => 'bar', :id => '1'
-          end
-        end
-
-        should "require the :type argument" do
-          assert_raise ArgumentError do
-            subject.termvectors :index => 'foo', :id => '1'
-          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/123/_termvectors', url
-            assert_equal Hash.new, params
-            assert_equal Hash.new, body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.termvectors :index => 'foo', :type => 'bar', :id => '123', :body => {}
-        end
-
-        should "be aliased to singular for older versions" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/bar/123/_termvector', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.termvector :index => 'foo', :type => 'bar', :id => '123'
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/update_by_query_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class UpdateByQueryTest < ::Test::Unit::TestCase
-
-      context "Update by query" 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/_update_by_query', url
-            assert_equal Hash.new, params
-            assert_equal nil, body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.update_by_query :index => 'foo'
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/update_document_test.rb

@@ -1,85 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class UpdateTest < ::Test::Unit::TestCase
-
-      context "Update document" do
-        subject { FakeClient.new }
-
-        should "require the :index argument" do
-          assert_raise ArgumentError do
-            subject.update :type => 'bar', :id => '1'
-          end
-        end
-
-        should "require the :type argument" do
-          assert_raise ArgumentError do
-            subject.update :index => 'foo', :id => '1'
-          end
-        end
-
-        should "require the :id argument" do
-          assert_raise ArgumentError do
-            subject.update :index => 'foo', :type => 'bar'
-          end
-        end
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'POST', method
-            assert_equal 'foo/bar/1/_update', url
-            assert_equal Hash.new, params
-            assert_equal Hash.new, body[:doc]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.update :index => 'foo', :type => 'bar', :id => '1', :body => { :doc => {} }
-        end
-
-        should "pass the URL parameters" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/bar/1/_update', url
-            assert_equal 100, params[:version]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.update :index => 'foo', :type => 'bar', :id => '1', :version => 100, :body => {}
-        end
-
-        should "validate URL parameters" do
-          assert_raise ArgumentError do
-            subject.update :index => 'foo', :type => 'bar', :id => '1', :body => { :doc => {} }, :qwertypoiuy => 'asdflkjhg'
-          end
-        end
-
-        should "URL-escape the parts" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo%5Ebar/bar%2Fbam/1/_update', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.update :index => 'foo^bar', :type => 'bar/bam', :id => '1', :body => {}
-        end
-
-        should "raise a NotFound exception" do
-          subject.expects(:perform_request).raises(NotFound)
-
-          assert_raise NotFound do
-            subject.update :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.update :index => 'foo', :type => 'bar', :id => 'XXX', :ignore => 404
-          end
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/utils_test.rb

@@ -1,310 +0,0 @@
-# encoding: UTF-8
-
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class UtilsTest < ::Test::Unit::TestCase
-      include Elasticsearch::API::Utils
-
-      context "Utils" do
-
-        context "__escape" do
-
-          should "encode Unicode characters" do
-            assert_equal '%E4%B8%AD%E6%96%87', __escape('中文')
-          end
-
-          should "encode special characters" do
-            assert_equal 'foo+bar',   __escape('foo bar')
-            assert_equal 'foo%2Fbar', __escape('foo/bar')
-            assert_equal 'foo%5Ebar', __escape('foo^bar')
-          end
-
-          should "not encode asterisks" do
-            assert_equal '*', __escape('*')
-          end
-
-          should "use CGI.escape by default" do
-            CGI.expects(:escape)
-            __escape('foo bar')
-          end
-
-          should "use the escape_utils gem when available" do
-            require 'escape_utils'
-            CGI.expects(:escape).never
-            EscapeUtils.expects(:escape_url)
-            __escape('foo bar')
-          end unless RUBY_1_8 || JRUBY
-
-        end
-
-        context "__listify" do
-
-          should "create a list from single value" do
-            assert_equal 'foo', __listify('foo')
-          end
-
-          should "create a list from an array" do
-            assert_equal 'foo,bar', __listify(['foo', 'bar'])
-          end
-
-          should "create a list from multiple arguments" do
-            assert_equal 'foo,bar', __listify('foo', 'bar')
-          end
-
-          should "ignore nil values" do
-            assert_equal 'foo,bar', __listify(['foo', nil, 'bar'])
-          end
-
-          should "encode special characters" do
-            assert_equal 'foo,bar%5Ebam', __listify(['foo', 'bar^bam'])
-          end
-
-          should "not encode special characters when the :escape option is set" do
-            assert_equal 'foo,bar^bam', __listify(['foo', 'bar^bam'], :escape => false)
-          end
-
-        end
-
-        context "__pathify" do
-
-          should "create a path from single value" do
-            assert_equal 'foo', __pathify('foo')
-          end
-
-          should "create a path from an array" do
-            assert_equal 'foo/bar', __pathify(['foo', 'bar'])
-          end
-
-          should "ignore nil values" do
-            assert_equal 'foo/bar', __pathify(['foo', nil, 'bar'])
-          end
-
-          should "ignore empty string values" do
-            assert_equal 'foo/bar', __pathify(['foo', '', 'bar'])
-          end
-
-        end
-
-        context "__bulkify" do
-
-          should "serialize array of hashes" do
-            result = Elasticsearch::API::Utils.__bulkify [
-              { :index =>  { :_index => 'myindexA', :_type => 'mytype', :_id => '1', :data => { :title => 'Test' } } },
-              { :update => { :_index => 'myindexB', :_type => 'mytype', :_id => '2', :data => { :doc => { :title => 'Update' } } } },
-              { :delete => { :_index => 'myindexC', :_type => 'mytypeC', :_id => '3' } }
-            ]
-
-            if RUBY_1_8
-              lines = result.split("\n")
-
-              assert_equal 5, lines.size
-              assert_match /\{"index"\:\{/, lines[0]
-              assert_match /\{"title"\:"Test"/, lines[1]
-              assert_match /\{"update"\:\{/, lines[2]
-              assert_match /\{"doc"\:\{"title"/, lines[3]
-            else
-              assert_equal <<-PAYLOAD.gsub(/^\s+/, ''), result
-                {"index":{"_index":"myindexA","_type":"mytype","_id":"1"}}
-                {"title":"Test"}
-                {"update":{"_index":"myindexB","_type":"mytype","_id":"2"}}
-                {"doc":{"title":"Update"}}
-                {"delete":{"_index":"myindexC","_type":"mytypeC","_id":"3"}}
-              PAYLOAD
-            end
-          end
-
-          should "serialize arrays of strings" do
-            result = Elasticsearch::API::Utils.__bulkify ['{"foo":"bar"}','{"moo":"bam"}']
-            assert_equal <<-PAYLOAD.gsub(/^\s+/, ''), result
-              {"foo":"bar"}
-              {"moo":"bam"}
-            PAYLOAD
-          end
-
-          should "serialize arrays of header/data pairs" do
-            result = Elasticsearch::API::Utils.__bulkify [{:foo => "bar"},{:moo => "bam"},{:foo => "baz"}]
-            assert_equal <<-PAYLOAD.gsub(/^\s+/, ''), result
-              {"foo":"bar"}
-              {"moo":"bam"}
-              {"foo":"baz"}
-            PAYLOAD
-          end
-
-          should "not modify the original payload with the data option" do
-            original = [ { :index => {:foo => 'bar', :data => {:moo => 'bam'} } } ]
-            result = Elasticsearch::API::Utils.__bulkify original
-            assert_not_nil original.first[:index][:data], "Deleted :data from #{original}"
-            assert_equal <<-PAYLOAD.gsub(/^\s+/, ''), result
-              {"index":{"foo":"bar"}}
-              {"moo":"bam"}
-            PAYLOAD
-          end
-
-          should "not modify the original payload with meta/data pairs" do
-            original = [ { :index => {:foo => 'bar'} }, { :data => {:a => 'b', :data => {:c => 'd'} } } ]
-            result = Elasticsearch::API::Utils.__bulkify original
-
-            assert_not_nil original.last[:data], "Deleted :data from #{original}"
-            assert_not_nil original.last[:data][:data], "Deleted :data from #{original}"
-
-            lines = result.split("\n")
-            assert_equal 2, lines.size
-
-            header = MultiJson.load(lines.first)
-            data   = MultiJson.load(lines.last)
-
-            assert_equal 'bar', header['index']['foo']
-            assert_equal 'b',   data['data']['a']
-            assert_equal 'd',   data['data']['data']['c']
-          end
-        end
-
-        context "__validate_and_extract_params" do
-          teardown do
-            Elasticsearch::API.settings.clear
-          end
-
-          should "extract valid params from a Hash" do
-            assert_equal( {:foo => 'qux'},
-                         __validate_and_extract_params({ :foo => 'qux' }, [:foo, :bar]) )
-          end
-
-          should "raise an exception when invalid keys present" do
-            assert_raise ArgumentError do
-              __validate_and_extract_params({ :foo => 'qux', :bam => 'mux' }, [:foo, :bar])
-            end
-          end
-
-          should "not raise an exception for COMMON_PARAMS" do
-            assert_nothing_raised do
-              __validate_and_extract_params({ :index => 'foo'}, [:foo])
-            end
-          end
-
-          should "extract COMMON_QUERY_PARAMS" do
-            assert_equal( { :format => 'yaml' },
-                          __validate_and_extract_params( { :format => 'yaml' } ) )
-          end
-
-          should "not validate parameters when the option is set" do
-            assert_nothing_raised do
-              result = __validate_and_extract_params( { :foo => 'q', :bam => 'm' }, [:foo, :bar], { :skip_parameter_validation => true } )
-              assert_equal( { :foo => 'q', :bam => 'm' }, result )
-            end
-          end
-
-          should "not validate parameters when the module setting is set" do
-            assert_nothing_raised do
-              Elasticsearch::API.settings[:skip_parameter_validation] = true
-              result = __validate_and_extract_params( { :foo => 'q', :bam => 'm' }, [:foo, :bar] )
-              assert_equal( { :foo => 'q', :bam => 'm' }, result )
-            end
-          end
-
-          should "listify Arrays" do
-            result = __validate_and_extract_params( { :foo => ['a', 'b'] }, [:foo] )
-            assert_equal( { :foo => 'a,b'}, result )
-          end
-
-          should "not escape the parameters" do
-            result = __validate_and_extract_params( { :foo => ['a.*', 'b.*'] }, [:foo] )
-            assert_equal( { :foo => 'a.*,b.*'}, result )
-          end
-        end
-
-        context "__extract_parts" do
-
-          should "extract parts with true value from a Hash" do
-            assert_equal( ['foo'], __extract_parts({ :foo => true, :moo => 'blah' }, [:foo, :bar]) )
-          end
-
-          should "extract parts with string value from a Hash" do
-            assert_equal( ['qux'], __extract_parts({ :foo => 'qux', :moo => 'blah' }, [:foo, :bar]) )
-          end
-
-        end
-
-        context "__rescue_from_not_found" do
-
-          should "return false if exception class name contains 'NotFound'" do
-            assert_equal( false, __rescue_from_not_found { raise NotFound })
-          end
-
-          should "return false if exception message contains 'Not Found'" do
-            assert_equal( false, __rescue_from_not_found { raise StandardError.new "Not Found" })
-            assert_equal( false, __rescue_from_not_found { raise StandardError.new "NotFound" })
-          end
-
-          should "raise exception if exception class name and message do not contain NotFound/404" do
-            assert_raise StandardError do
-              __rescue_from_not_found { raise StandardError.new "Any other exception" }
-            end
-          end
-
-        end
-
-        context "__report_unsupported_parameters" do
-          should "print used unsupported parameters passed as Symbols" do
-            arguments = { :foo => 'bar', :moo => 'bam', :baz => 'qux' }
-            unsupported_params = [:foo, :moo]
-
-            Kernel.expects(:warn).with do |message|
-              assert_equal 2, message.split("\n").reject { |l| l.include? 'Suppress this warning' }.size
-              true
-            end
-
-            __report_unsupported_parameters(arguments, unsupported_params)
-          end
-
-          should "print used unsupported parameters passed as Hashes" do
-            arguments = { :foo => 'bar', :moo => 'bam', :baz => 'qux' }
-            unsupported_params = [ { :foo => { :explanation => 'NOT_SUPPORTED' } } ]
-
-            Kernel.expects(:warn).with do |message|
-              assert_match /NOT_SUPPORTED/, message
-              assert_equal 1, message.split("\n").reject { |l| l.include? 'Suppress this warning' }.size
-              true
-            end
-
-            __report_unsupported_parameters(arguments, unsupported_params)
-          end
-
-          should "print used unsupported parameters passed as a mix of Symbols and Hashes" do
-            arguments = { :foo => 'bar', :moo => 'bam', :baz => 'qux' }
-            unsupported_params = [ { :foo => { :explanation => 'NOT_SUPPORTED'} }, :moo ]
-
-            Kernel.expects(:warn).with do |message|
-              assert_match /NOT_SUPPORTED/, message
-              assert_equal 2, message.split("\n").reject { |l| l.include? 'Suppress this warning' }.size
-              true
-            end
-
-            __report_unsupported_parameters(arguments, unsupported_params)
-          end
-
-          should "not print unused unsupported parameters" do
-            arguments = { :moo => 'bam', :baz => 'qux' }
-            unsupported_params = [:foo]
-
-            Kernel.expects(:warn).never
-
-            __report_unsupported_parameters(arguments, unsupported_params)
-          end
-        end
-
-        context "__report_unsupported_method" do
-          should "print the warning" do
-            Kernel.expects(:warn).with do |message|
-              assert_match /foo/, message
-              true
-            end
-
-            __report_unsupported_method(:foo)
-          end
-        end
-      end
-    end
-  end
-end