elasticsearch-api 7.17.11 → 9.0.2

data/spec/elasticsearch/api/utils_spec.rb

@@ -1,418 +0,0 @@
-# Licensed to Elasticsearch B.V. under one or more contributor
-# license agreements. See the NOTICE file distributed with
-# this work for additional information regarding copyright
-# ownership. Elasticsearch B.V. licenses this file to you under
-# the Apache License, Version 2.0 (the "License"); you may
-# not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-require 'spec_helper'
-
-describe Elasticsearch::API::Utils do
-
-  let(:utils) do
-    Class.new { include Elasticsearch::API::Utils }.new
-  end
-
-  describe '#__escape' do
-
-    it 'encodes Unicode characters' do
-      expect(utils.__escape('中文')).to eq('%E4%B8%AD%E6%96%87')
-    end
-
-    it 'encodes special characters' do
-      expect(utils.__escape('foo bar')).to eq('foo%20bar')
-      expect(utils.__escape('foo/bar')).to eq('foo%2Fbar')
-      expect(utils.__escape('foo^bar')).to eq('foo%5Ebar')
-    end
-
-    it 'does not encode asterisks' do
-      expect(utils.__escape('*')).to eq('*')
-    end
-  end
-
-  describe '#__listify' do
-
-    it 'creates a list from a single value' do
-      expect(utils.__listify('foo')).to eq('foo')
-    end
-
-    it 'creates a list from an array' do
-      expect(utils.__listify(['foo', 'bar'])).to eq('foo,bar')
-    end
-
-    it 'creates a list from multiple arguments' do
-      expect(utils.__listify('foo', 'bar')).to eq('foo,bar')
-    end
-
-    it 'ignores nil values' do
-      expect(utils.__listify(['foo', nil, 'bar'])).to eq('foo,bar')
-    end
-
-    it 'ignores special characters' do
-      expect(utils.__listify(['foo', 'bar^bam'])).to eq('foo,bar%5Ebam')
-    end
-
-    context 'when the escape option is set to false' do
-
-      it 'does not escape the characters' do
-        expect(utils.__listify(['foo', 'bar^bam'], escape: false)).to eq('foo,bar^bam')
-      end
-    end
-  end
-
-  describe '#__pathify' do
-
-    it 'creates a path from a single value' do
-      expect(utils.__pathify('foo')).to eq('foo')
-    end
-
-    it 'creates a path from an array' do
-      expect(utils.__pathify(['foo', 'bar'])).to eq('foo/bar')
-    end
-
-    it 'ignores nil values' do
-      expect(utils.__pathify(['foo', nil, 'bar'])).to eq('foo/bar')
-    end
-
-    it 'ignores empty string values' do
-      expect(utils.__pathify(['foo', '', 'bar'])).to eq('foo/bar')
-    end
-  end
-
-  describe '#__bulkify' do
-
-    context 'when the input is an array of hashes' do
-
-      let(:result) do
-        utils.__bulkify [
-          { index: { _index: 'myindexA', _id: '1', data: { title: 'Test' } } },
-          { update: { _index: 'myindexB', _id: '2', data: { doc: { title: 'Update' } } } },
-          { delete: { _index: 'myindexC', _id: '3' } }
-        ]
-      end
-
-      let(:expected_string) do
-        <<-PAYLOAD.gsub(/^\s+/, '')
-                {"index":{"_index":"myindexA","_id":"1"}}
-                {"title":"Test"}
-                {"update":{"_index":"myindexB","_id":"2"}}
-                {"doc":{"title":"Update"}}
-                {"delete":{"_index":"myindexC","_id":"3"}}
-        PAYLOAD
-      end
-
-      it 'serializes the hashes' do
-        expect(result).to eq(expected_string)
-      end
-    end
-
-    context 'when the input is an array of strings' do
-
-      let(:result) do
-        utils.__bulkify(['{"foo":"bar"}','{"moo":"bam"}'])
-      end
-
-      let(:expected_string) do
-        <<-PAYLOAD.gsub(/^\s+/, '')
-              {"foo":"bar"}
-              {"moo":"bam"}
-        PAYLOAD
-      end
-
-      it 'serializes the array of strings' do
-        expect(result).to eq(expected_string)
-      end
-    end
-
-    context 'when the input is an array of header/data pairs' do
-
-      let(:result) do
-        utils.__bulkify([{ foo: 'bar' }, { moo: 'bam' },{ foo: 'baz' }])
-      end
-
-      let(:expected_string) do
-        <<-PAYLOAD.gsub(/^\s+/, '')
-              {"foo":"bar"}
-              {"moo":"bam"}
-              {"foo":"baz"}
-        PAYLOAD
-      end
-
-      it 'serializes the array of strings' do
-        expect(result).to eq(expected_string)
-      end
-    end
-
-    context 'when the payload has the :data option' do
-
-      let(:input) do
-        { index: { foo: 'bar', data: { moo: 'bam' } } }
-      end
-
-      let(:result) do
-        utils.__bulkify([input])
-      end
-
-      let(:expected_string) do
-        <<-PAYLOAD.gsub(/^\s+/, '')
-              {"index":{"foo":"bar"}}
-              {"moo":"bam"}
-        PAYLOAD
-      end
-
-      it 'does not mutate the input' do
-        expect(input[:index][:data]).to eq(moo: 'bam')
-      end
-
-      it 'serializes the array of strings' do
-        expect(result).to eq(expected_string)
-      end
-    end
-
-    context 'when the payload has nested :data options' do
-
-      let(:data) do
-        { data: { a: 'b', data: { c: 'd' } } }
-      end
-
-      let(:result) do
-        utils.__bulkify([{ index: { foo: 'bar'} } , data])
-      end
-
-      let(:lines) do
-        result.split("\n")
-      end
-
-      let(:header) do
-        MultiJson.load(lines.first)
-      end
-
-      let(:data_string) do
-        MultiJson.load(lines.last)
-      end
-
-      it 'does not mutate the input' do
-        expect(data[:data]).to eq(a: 'b', data: { c: 'd' })
-      end
-
-      it 'serializes the array of strings' do
-        expect(header['index']['foo']).to eq('bar')
-        expect(data_string['data']['a']).to eq('b')
-        expect(data_string['data']['data']['c']).to eq('d')
-      end
-    end
-  end
-
-  context '#__validate_and_extract_params' do
-
-    it 'listify Arrays' do
-      expect(utils.__validate_and_extract_params({ foo: ['a', 'b'] }, [:foo] )).to eq(foo: 'a,b')
-    end
-
-    it 'does not escape the parameters' do
-      expect(utils.__validate_and_extract_params({ foo: ['a.*', 'b.*'] }, [:foo] )).to eq(foo: 'a.*,b.*')
-    end
-
-    context 'when the params are valid' do
-
-      it 'extracts the valid params from the hash' do
-        expect(utils.__validate_and_extract_params({ foo: 'qux' }, [:foo, :bar]) ).to eq(foo: 'qux')
-      end
-    end
-
-    context 'when the params are invalid' do
-
-      it 'raises an ArgumentError' do
-        expect {
-          utils.__validate_and_extract_params({ foo: 'qux', bam: 'mux' }, [:foo, :bar])
-        }.to raise_exception(ArgumentError)
-      end
-    end
-
-    context 'when COMMON_PARAMS are provided' do
-
-      it 'extracts the params' do
-        expect(utils.__validate_and_extract_params({ index: 'foo'}, [:foo])).to eq({})
-      end
-    end
-
-    context 'when COMMON_QUERY_PARAMS are provided' do
-
-      it 'extracts the params' do
-        expect(utils.__validate_and_extract_params(format: 'yaml')).to eq(format: 'yaml')
-      end
-    end
-
-    context 'when the :skip_paramter_validation option is set' do
-
-      let(:result) do
-        utils.__validate_and_extract_params( { foo: 'q', bam: 'm' }, [:foo, :bar], { skip_parameter_validation: true } )
-      end
-
-      it 'skips parameter validation' do
-        expect(result).to eq(foo: 'q', bam: 'm')
-      end
-    end
-
-    context 'when the module has the setting to skip parameter validation' do
-
-      around do |example|
-        original_value = Elasticsearch::API.settings[:skip_parameter_validation]
-        Elasticsearch::API.settings[:skip_parameter_validation] = true
-        example.run
-        Elasticsearch::API.settings[:skip_parameter_validation] = original_value
-      end
-
-      let(:result) do
-        utils.__validate_and_extract_params( { foo: 'q', bam: 'm' }, [:foo, :bar])
-      end
-
-      it 'applies the module setting' do
-        expect(result).to eq(foo: 'q', bam: 'm')
-      end
-    end
-  end
-
-  describe '#__extract_parts' do
-
-    it 'extracts parts with true value from a Hash' do
-      expect(utils.__extract_parts({ foo: true, moo: 'blah' }, [:foo, :bar])).to eq(['foo'])
-    end
-
-    it 'extracts parts with string value from a Hash' do
-      expect(utils.__extract_parts({ foo: 'qux', moo: 'blah' }, [:foo, :bar])).to eq(['qux'])
-    end
-  end
-
-  context '#__rescue_from_not_found' do
-
-    it 'returns false if exception class name contains \'NotFound\'' do
-      expect(utils.__rescue_from_not_found { raise NotFound }).to be(false)
-    end
-
-    it 'returns false if exception message contains \'Not Found\'' do
-      expect(utils.__rescue_from_not_found { raise StandardError.new "Not Found" }).to be(false)
-      expect(utils.__rescue_from_not_found { raise StandardError.new "NotFound" }).to be(false)
-    end
-
-    it 'raises the exception if the class name and message do not include \'NotFound\'' do
-      expect {
-        utils.__rescue_from_not_found { raise StandardError.new "Any other exception" }
-      }.to raise_exception(StandardError)
-    end
-  end
-
-  context '#__report_unsupported_parameters' do
-
-    context 'when the parameters are passed as Symbols' do
-
-      let(:arguments) do
-        { foo: 'bar', moo: 'bam', baz: 'qux' }
-      end
-
-      let(:unsupported_params) do
-        [ :foo, :moo]
-      end
-
-      let(:message) do
-        message = ''
-        expect(Kernel).to receive(:warn) { |msg| message = msg }
-        utils.__report_unsupported_parameters(arguments, unsupported_params)
-        message
-      end
-
-      it 'prints the unsupported parameters' do
-        expect(message).to match(/You are using unsupported parameter \[\:foo\]/)
-        expect(message).to match(/You are using unsupported parameter \[\:moo\]/)
-      end
-    end
-
-    context 'when the parameters are passed as Hashes' do
-
-      let(:arguments) do
-        { foo: 'bar', moo: 'bam', baz: 'qux' }
-      end
-
-      let(:unsupported_params) do
-        [ :foo, :moo]
-      end
-
-      let(:message) do
-        message = ''
-        expect(Kernel).to receive(:warn) { |msg| message = msg }
-        utils.__report_unsupported_parameters(arguments, unsupported_params)
-        message
-      end
-
-      it 'prints the unsupported parameters' do
-        expect(message).to match(/You are using unsupported parameter \[\:foo\]/)
-        expect(message).to match(/You are using unsupported parameter \[\:moo\]/)
-      end
-    end
-
-    context 'when the parameters are passed as a mix of Hashes and Symbols' do
-
-      let(:arguments) do
-        { foo: 'bar', moo: 'bam', baz: 'qux' }
-      end
-
-      let(:unsupported_params) do
-        [ { foo: { explanation: 'NOT_SUPPORTED'} }, :moo ]
-      end
-
-
-      let(:message) do
-        message = ''
-        expect(Kernel).to receive(:warn) { |msg| message = msg }
-        utils.__report_unsupported_parameters(arguments, unsupported_params)
-        message
-      end
-
-      it 'prints the unsupported parameters' do
-        expect(message).to match(/You are using unsupported parameter \[\:foo\]/)
-        expect(message).to match(/You are using unsupported parameter \[\:moo\]/)
-        expect(message).to match(/NOT_SUPPORTED/)
-      end
-    end
-
-    context 'when unsupported parameters are unused' do
-
-      let(:arguments) do
-        { moo: 'bam', baz: 'qux' }
-      end
-
-      let(:unsupported_params) do
-        [ :foo ]
-      end
-
-      it 'prints the unsupported parameters' do
-        expect(Kernel).not_to receive(:warn)
-        utils.__report_unsupported_parameters(arguments, unsupported_params)
-      end
-    end
-  end
-
-  describe '#__report_unsupported_method' do
-
-    let(:message) do
-      message = ''
-      expect(Kernel).to receive(:warn) { |msg| message = msg }
-      utils.__report_unsupported_method(:foo)
-      message
-    end
-
-    it 'prints a warning' do
-      expect(message).to match(/foo/)
-    end
-  end
-end

data/spec/rest_yaml_tests_helper.rb

@@ -1,135 +0,0 @@
-# Licensed to Elasticsearch B.V. under one or more contributor
-# license agreements. See the NOTICE file distributed with
-# this work for additional information regarding copyright
-# ownership. Elasticsearch B.V. licenses this file to you under
-# the Apache License, Version 2.0 (the "License"); you may
-# not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-require "#{File.expand_path(File.dirname('..'), '..')}/api-spec-testing/test_file"
-require "#{File.expand_path(File.dirname('..'), '..')}/api-spec-testing/rspec_matchers"
-require "#{File.expand_path(File.dirname('..'), '..')}/api-spec-testing/wipe_cluster"
-include Elasticsearch::RestAPIYAMLTests
-
-TRANSPORT_OPTIONS = {}
-PROJECT_PATH = File.join(File.dirname(__FILE__), '..')
-STACK_VERSION = ENV['STACK_VERSION']
-require 'elasticsearch/xpack'
-
-def testing_compatibility?
-  [1, true, 'true'].include?(ENV['ELASTIC_CLIENT_APIVERSIONING'])
-end
-
-if (hosts = ELASTICSEARCH_URL)
-  split_hosts = hosts.split(',').map do |host|
-    /(http\:\/\/)?\S+/.match(host)
-  end
-  uri = URI.parse(split_hosts.first[0])
-  TEST_HOST = uri.host
-  TEST_PORT = uri.port
-else
-  TEST_HOST, TEST_PORT = 'localhost', '9200'
-end
-
-test_suite = ENV['TEST_SUITE'] || 'free'
-password = ENV['ELASTIC_PASSWORD'] || 'changeme'
-user = ENV['ELASTIC_USER'] || 'elastic'
-
-if defined?(TEST_HOST) && defined?(TEST_PORT)
-  URL = "http://#{TEST_HOST}:#{TEST_PORT}".freeze
-
-  if STACK_VERSION.match?(/^8\./)
-    if ENV['TEST_SUITE'] == 'platinum'
-      raw_certificate = File.read(File.join(PROJECT_PATH, '../.ci/certs/testnode.crt'))
-      certificate = OpenSSL::X509::Certificate.new(raw_certificate)
-      raw_key = File.read(File.join(PROJECT_PATH, '../.ci/certs/testnode.key'))
-      key = OpenSSL::PKey::RSA.new(raw_key)
-      ca_file = File.expand_path(File.join(PROJECT_PATH, '/.ci/certs/ca.crt'))
-      host = "https://elastic:#{password}@#{uri.host}:#{uri.port}".freeze
-      transport_options = { ssl: { verify: false, client_cert: certificate, client_key: key, ca_file: ca_file } }
-    else
-      host = "http://elastic:#{password}@#{uri.host}:#{uri.port}".freeze
-      transport_options = {}
-    end
-
-    ADMIN_CLIENT = Elasticsearch::Client.new(host: host, transport_options: transport_options)
-
-    DEFAULT_CLIENT = if ENV['QUIET'] == 'true'
-                       Elasticsearch::Client.new(host: host, transport_options: transport_options)
-                     else
-                       Elasticsearch::Client.new(
-                         host: host,
-                         tracer: Logger.new($stdout),
-                         transport_options: transport_options
-                       )
-                     end
-
-    if ENV['QUIET'] == 'true'
-      DEFAULT_CLIENT = Elasticsearch::Client.new(
-        host: URL,
-        transport_options: TRANSPORT_OPTIONS,
-        user: user,
-        password: password
-      )
-    else
-      DEFAULT_CLIENT = Elasticsearch::Client.new(
-        host: URL,
-        transport_options: TRANSPORT_OPTIONS,
-        user: user,
-        password: password,
-        tracer: Logger.new($stdout)
-      )
-    end
-  else
-    ADMIN_CLIENT = Elasticsearch::Client.new(host: URL, transport_options: TRANSPORT_OPTIONS)
-
-    if ENV['QUIET'] == 'true'
-      DEFAULT_CLIENT = Elasticsearch::Client.new(host: URL, transport_options: TRANSPORT_OPTIONS)
-    else
-      DEFAULT_CLIENT = Elasticsearch::Client.new(host: URL,
-                                                 transport_options: TRANSPORT_OPTIONS,
-                                                 tracer: Logger.new($stdout))
-    end
-  end
-end
-
-YAML_FILES_DIRECTORY = "#{PROJECT_PATH}/../tmp/rest-api-spec/#{STACK_VERSION.match?(/^8\./) ? 'compatTest' : 'test'}/free"
-
-SINGLE_TEST = if ENV['SINGLE_TEST'] && !ENV['SINGLE_TEST'].empty?
-                test_target = ENV['SINGLE_TEST']
-
-                if test_target.match?(/\.yml$/)
-                  ["#{PROJECT_PATH}/../tmp/rest-api-spec/test/free/#{test_target}"]
-                else
-                  Dir.glob(
-                    ["#{PROJECT_PATH}/../tmp/rest-api-spec/test/free/#{test_target}/*.yml"]
-                  )
-                end
-              end
-
-# Skipped tests
-file = File.expand_path("#{__dir__}/skipped_tests.yml")
-skipped_tests = YAML.load_file(file)
-
-# The directory of rest api YAML files.
-REST_API_YAML_FILES = if ENV['RUN_SKIPPED_TESTS'] # only run the skipped tests if true
-                        SKIPPED_TESTS = []
-                        skipped_tests.map { |test| "#{YAML_FILES_DIRECTORY}/#{test[:file]}" }
-                      else
-                        # If not, define the skipped tests constant and try the single test or all
-                        # the tests
-                        SKIPPED_TESTS = skipped_tests
-                        SINGLE_TEST || Dir.glob("#{YAML_FILES_DIRECTORY}/**/*.yml")
-                      end
-
-# The features to skip
-REST_API_YAML_SKIP_FEATURES = ['warnings', 'node_selector'].freeze

data/spec/skipped_tests.yml

@@ -1,29 +0,0 @@
-# Response from Elasticsearch is just a String, so it's not possible to compare using headers.
--
-  :file:        'cat.aliases/20_headers.yml'
-  :description: 'Simple alias with yaml body through Accept header'
-
-# Check version skip logic
--
-  :file:        'create/15_without_id.yml'
-  :description: 'Create without ID'
-
-# No error is raised
--
-  :file:        'create/15_without_id_with_types.yml'
-  :description: 'Create without ID'
-
-# Error message doesn't match
--
-  :file:        'tasks.get/10_basic.yml'
-  :description: 'get task test'
-
-# Figure out how to match response when there is an error
--
-  :file:        'delete/70_mix_typeless_typeful.yml'
-  :description: '*'
-
-# Figure out how to match response when there is an error
--
-  :file:        'cat.templates/10_basic.yml'
-  :description: '*'

data/spec/spec_helper.rb

@@ -1,82 +0,0 @@
-# Licensed to Elasticsearch B.V. under one or more contributor
-# license agreements. See the NOTICE file distributed with
-# this work for additional information regarding copyright
-# ownership. Elasticsearch B.V. licenses this file to you under
-# the Apache License, Version 2.0 (the "License"); you may
-# not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-if ENV['COVERAGE'] && ENV['CI'].nil?
-  require 'simplecov'
-  SimpleCov.start { add_filter %r{^/test|spec/} }
-end
-
-if defined?(JRUBY_VERSION)
-  require 'pry-nav'
-else
-  require 'pry-byebug'
-end
-require 'ansi'
-require 'yaml'
-require 'active_support/isolated_execution_state' unless RUBY_VERSION < '2.7.0'
-require 'jbuilder'
-require 'jsonify'
-require 'elasticsearch'
-require 'elasticsearch-api'
-require 'elasticsearch-transport'
-require 'jbuilder'
-require 'jsonify'
-require 'yaml'
-
-tracer = ::Logger.new(STDERR)
-tracer.formatter = lambda { |s, d, p, m| "#{m.gsub(/^.*$/) { |n| '   ' + n }.ansi(:faint)}\n" }
-
-unless defined?(ELASTICSEARCH_URL)
-  ELASTICSEARCH_URL = ENV['ELASTICSEARCH_URL'] ||
-                        ENV['TEST_ES_SERVER'] ||
-                        "localhost:#{(ENV['TEST_CLUSTER_PORT'] || 9200)}"
-end
-
-DEFAULT_CLIENT = Elasticsearch::Client.new(host: ELASTICSEARCH_URL,
-                                           tracer: (tracer unless ENV['QUIET']))
-
-module HelperModule
-  def self.included(context)
-    context.let(:client_double) do
-      Class.new { include Elasticsearch::API }.new.tap do |client|
-        expect(client).to receive(:perform_request).with(*expected_args).and_return(response_double)
-      end
-    end
-
-    context.let(:client) do
-      Class.new { include Elasticsearch::API }.new.tap do |client|
-        expect(client).to receive(:perform_request).with(*expected_args).and_return(response_double)
-      end
-    end
-
-    context.let(:response_double) do
-      double('response', status: 200, body: {}, headers: {})
-    end
-  end
-end
-
-RSpec.configure do |config|
-  config.include(HelperModule)
-  config.formatter = 'documentation'
-  config.add_formatter('RspecJunitFormatter', 'tmp/elasticsearch-api-junit.xml')
-  config.add_formatter(
-    'RSpec::Core::Formatters::HtmlFormatter',
-    "tmp/elasticsearch-#{ENV['TEST_SUITE']}-#{RUBY_VERSION}-#{ENV['STACK_VERSION']}.html"
-  )
-  config.color_mode = :on
-end
-
-class NotFound < StandardError; end

data/utils/Gemfile

@@ -1,28 +0,0 @@
-# Licensed to Elasticsearch B.V. under one or more contributor
-# license agreements. See the NOTICE file distributed with
-# this work for additional information regarding copyright
-# ownership. Elasticsearch B.V. licenses this file to you under
-# the Apache License, Version 2.0 (the "License"); you may
-# not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-source 'https://rubygems.org'
-
-gem 'activesupport'
-gem 'byebug'
-gem 'coderay'
-gem 'json'
-gem 'multi_json'
-gem 'pry'
-gem 'rest-client'
-gem 'rubocop'
-gem 'thor'