elasticsearch-api 8.18.0 → 9.0.1

data/Gemfile

@@ -1,35 +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'
-
-# Specify your gem's dependencies in elasticsearch-api.gemspec
-gemspec
-
-if File.exist? File.expand_path('../elasticsearch/elasticsearch.gemspec', __dir__)
-  gem 'elasticsearch', path: File.expand_path('../elasticsearch', __dir__), require: false
-end
-
-group :development do
-  gem 'rspec'
-  gem 'rspec_junit_formatter'
-  if defined?(JRUBY_VERSION)
-    gem 'pry-nav'
-  else
-    gem 'debug'
-  end
-end

data/Rakefile

@@ -1,98 +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 'bundler/gem_tasks'
-require 'json'
-
-task(:default) { system 'rake --tasks' }
-task test: 'test:unit'
-require 'rake/testtask'
-require 'rspec/core/rake_task'
-
-# Test Tasks
-
-namespace :test do
-  desc 'Wait for Elasticsearch to be in a green state'
-  task :wait_for_green do
-    sh '../scripts/wait-cluster.sh'
-  end
-
-  desc 'Run unit tests'
-  task unit: :spec
-  RSpec::Core::RakeTask.new(:spec) do |t|
-    t.pattern = 'spec/elasticsearch/api/**/*_spec.rb'
-    t.exclude_pattern = 'spec/platinum/**/*_spec.rb'
-  end
-
-  desc 'Run Rest API Spec tests'
-  RSpec::Core::RakeTask.new(:rest_api) do |t|
-    test_dir = Rake.application.original_dir
-    t.pattern = "#{test_dir}/spec/rest_api/rest_api_yaml_spec.rb"
-  end
-
-  desc 'Run unit and integration tests'
-  task :all do
-    Rake::Task['test:unit'].invoke
-    Rake::Task['test:integration'].invoke
-  end
-
-  desc 'Run tests with yaml runner'
-  task :yaml do
-    ruby './spec/yaml-test-runner/run.rb'
-  end
-
-  namespace :platinum do
-    desc 'Run Platinum Rest API Spec tests'
-    RSpec::Core::RakeTask.new(:api) do
-      ENV['TEST_SUITE'] = 'platinum'
-      Rake::Task['test:rest_api'].invoke
-    end
-
-    desc 'Run Platinum Unit tests - DEPRECATED: Will be migrated to RSpec'
-    Rake::TestTask.new(:unit) do |test|
-      test.libs << 'spec/platinum/unit'
-      test.test_files = FileList['spec/platinum/unit/**/*_test.rb']
-      test.verbose = false
-      test.warning = false
-    end
-
-    desc 'Run Platinum Integration Specs'
-    RSpec::Core::RakeTask.new(:integration) do |t|
-      t.pattern = if ENV['TEST_SUITE'] == 'platinum'
-                    'spec/platinum/integration/**/*_spec.rb'
-                  else
-                    'spec/free/integration/**/*_spec.rb'
-                  end
-      t.ruby_opts = '-W0'
-    end
-  end
-end
-
-# Documentation tasks
-
-require 'yard'
-YARD::Rake::YardocTask.new(:doc) do |t|
-  t.options = %w| --embed-mixins --markup=markdown |
-end
-
-# Code analysis tasks
-
-require 'cane/rake_task'
-Cane::RakeTask.new(:quality) do |cane|
-  cane.abc_max = 15
-  cane.no_style = true
-end

data/api-spec-testing/README.md

@@ -1,118 +0,0 @@
-# Rest API YAML Test Runner
-
-The specs in `elasticsearch-api` automatically run the tests from [Elasticsearch's REST API Spec tests](https://github.com/elastic/elasticsearch/tree/main/rest-api-spec/src/main/resources/rest-api-spec/test#test-suite). The test runner is defined in the `spec` folder, starting with the `rest_api_yaml_spec.rb` file.
-
-You can run the tests with Rake. The main task is `rake test:rest_api`. This task will evaluate the `TEST_SUITE` environment variable. It will run either the `free` or `platinum` tests suites depending on the value of `TEST_SUITE`. If you don't set this value, the task will run the `free` test suite by default. To run the `platinum` test suite use:
-```
-TEST_SUITE=platinum rake test:rest_api
-```
-
-Or the shortcut:
-```
-rake test:platinum:api
-```
-
-## REST API YAML Spec
-
-The file that traverses the yaml files and loads a **TestFile** object per each of them:
-`elasticsearch-api/spec/elasticsearch/api/rest_api_yaml_spec.rb`
-
-You can use the SINGLE_TEST env variable to run just one test or one test directory. E.g.:
-```
-$ cd elasticsearch-api && SINGLE_TEST=indices.resolve_index/10_basic_resolve_index.yml TEST_ES_SERVER='http://localhost:9200' be rake test:rest_api
-```
-And:
-```
-$ cd elasticsearch-api && SINGLE_TEST=indices.resolve_index TEST_ES_SERVER='http://localhost:9200' be rake test:rest_api
-```
-
-## Skipped tests
-
-We sometimes skip tests, generally due to limitations on how we run the CI server or for stuff that hasn't been completely implemented on the client yet. Skipped tests are located in `elasticsearch-api/spec/skipped_tests.yml`. You can run just the tests which are currently being skipped by running:
-```
-$ cd elasticsearch-api && TEST_SUITE=(free|platinum) RUN_SKIPPED_TESTS=true TEST_ES_SERVER='http://localhost:9200' be rake test:rest_api
-```
-
-## TestFile
-Class representing a single test file. Contains setup, teardown and tests.   
-`../api-spec-testing/test_file.rb`
-
-## Test
-Every single test in the test file is represented in the Test object.   
-`../api-spec-testing/test_file/test.rb`
-
-## TaskGroup
-
-Tests are ordered in task groups, an array of TaskGroup objects.  
-`../api-spec-testing/test_file/task_group.rb`
-
-Task Groups are a representation of a block of actions consisting of 'do' actions and their verifications. e.g.: 
-```yaml
- - do:
-      index:
-          index:  test-index
-          id:     1
-          body:   { foo: bar }
-
- - match:   { _index:   test-index }
- - match:   { _id:      "1"}
- - match:   { _version: 1}
-```
-
-**Before** each test, the spec runner runs `clear_data` on the test_file. This clears indices, index templates, snapshots and repositories. For platinum it also clears roles, users, privileges, datafeeds, ml_jobs and more.
-
-**After** each test, it runs the test file teardown and `clear_data` again.
-
-For each TaskGroup, it sees what's in the task group definition and runs an expectation test.
-
-## Action
-
-This file is where the action is executed, where we call the client with the method from the test and save the response which is then used in the task group.
-
-## Rest YAML tests Helper
-
-`elasticsearch-api/spec/rest_yaml_tests_helper.rb`
-
-- `ADMIN_CLIENT` is defined here.
-- `SINGLE_TEST` is defined here.
-- Skipped tests are listed here
-
-## Spec Helper
-
-- `DEFAULT_CLIENT` is defined here
-
-## Enable Logging
-
-To enable logging, set the environment `QUIET` to false before running the tests. In CI, this is located in the [Dockerfile](https://github.com/elastic/elasticsearch-ruby/blob/main/.ci/Dockerfile). The environment variable is evaluated in the Rest YAML tests Helper file.
-
-# Features
-
-## RSpec Matchers
-
-The tests use custom [RSpec Matchers](https://www.rubydoc.info/gems/rspec-expectations/RSpec/Matchers) defined in `api-spec-testing/rspec_matchers.rb`.
-
-From the [Rest API test docs](https://github.com/elastic/elasticsearch/tree/main/rest-api-spec/src/main/resources/rest-api-spec/test#do):
-
-## `catch`
-
-> If the arguments to `do` include `catch`, then we are expecting an error, which should be caught and tested.
-
-In `rest_api_yaml_spec`, there's a check for `catch_exception?` per task_group. This checks if the `do` definitions have any `catch` definitions. If there is a `catch`, it'll send the request and use the `match_error` RSpec custom matcher to validate the expected error.
-
-## `warnings`
-
->If the arguments to `do` include `warnings` then we are expecting a Warning header to come back from the request. If the arguments don’t include a warnings argument then we don’t expect the response to include a Warning header. The warnings must match exactly. Using it looks like this:
-
-```
-- do:
-    warnings:
-        - '[index] is deprecated'
-        - quotes are not required because yaml
-        - but this argument is always a list, never a single string
-        - no matter how many warnings you expect
-    get:
-        index:    test
-        type:    test
-        id:        1
-```
-

data/api-spec-testing/custom_cleanup.rb

@@ -1,32 +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.
-
-module Elasticsearch
-  module RestAPIYAMLTests
-    # Custom functions for wipe cluster
-    module CustomCleanup
-      class << self
-        def wipe_calendars(client)
-          calendars = client.ml.get_calendars(calendar_id: '_all').body['calendars']
-          calendars.each do |calendar|
-            client.ml.delete_calendar(calendar_id: calendar['calendar_id'])
-          end
-        end
-      end
-    end
-  end
-end

data/api-spec-testing/logging.rb

@@ -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.
-
-require 'logger'
-
-module Elasticsearch
-  module RestAPIYAMLTests
-    module Logging
-      def logger
-        @logger ||= Logger.new($stdout)
-      end
-    end
-  end
-end

data/api-spec-testing/rspec_matchers.rb

@@ -1,344 +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.
-
-# Match the `length` of a field.
-RSpec::Matchers.define :match_response_field_length do |expected_pairs, test|
-  match do |response|
-    expected_pairs.all? do |expected_key, expected_value|
-      # ssl test returns results at '$body' key. See ssl/10_basic.yml
-      expected_pairs = expected_pairs['$body'] if expected_pairs['$body']
-
-      split_key = TestFile::Test.split_and_parse_key(expected_key).collect do |k|
-        test.get_cached_value(k)
-      end
-
-      actual_value = split_key.inject(response) do |_response, key|
-        # If the key is an index, indicating element of a list
-        if _response.empty? && key == '$body'
-          _response
-        else
-          _response[key] || _response[key.to_s]
-        end
-      end
-      actual_value.size == expected_value
-    end
-  end
-end
-
-# Validate that a field is `true`.
-RSpec::Matchers.define :match_true_field do |field, test|
-  match do |response|
-    # TODO: Refactor! split_key for is_true
-    if (match = field.match(/(^\$[a-z]+)/))
-      keys = field.split('.')
-      keys.delete(match[1])
-      dynamic_key = test.cached_values[match[1].gsub('$', '')]
-      return !!dynamic_key.dig(*keys)
-    end
-
-    # Handle is_true: ''
-    return !!response if field == ''
-
-    split_key = TestFile::Test.split_and_parse_key(field).collect do |k|
-      test.get_cached_value(k)
-    end
-    !!TestFile::Test.find_value_in_document(split_key, response)
-  end
-
-  failure_message do |response|
-    "the response `#{response}` does not have `true` in the field `#{field}`"
-  end
-end
-
-# Validate that a field is `false`.
-RSpec::Matchers.define :match_false_field do |field, test|
-  match do |response|
-    # Handle is_false: ''
-    return !response if field == ''
-    split_key = TestFile::Test.split_and_parse_key(field).collect do |k|
-      test.get_cached_value(k)
-    end
-    value_in_doc = TestFile::Test.find_value_in_document(split_key, response)
-    value_in_doc == 0 || !value_in_doc
-  end
-
-  failure_message do |response|
-    "the response `#{response}` does not have `false` in the field `#{field}`"
-  end
-end
-
-# Validate that a field is `gte` than a given value.
-RSpec::Matchers.define :match_gte_field do |expected_pairs, test|
-  match do |response|
-    expected_pairs.all? do |expected_key, expected_value|
-      split_key = TestFile::Test.split_and_parse_key(expected_key).collect do |k|
-        test.get_cached_value(k)
-      end
-
-      actual_value = split_key.inject(response) do |_response, key|
-        # If the key is an index, indicating element of a list
-        if _response.empty? && key == '$body'
-          _response
-        else
-          _response[key] || _response[key.to_s]
-        end
-      end
-      actual_value >= test.get_cached_value(expected_value)
-    end
-  end
-end
-
-# Validate that a field is `gt` than a given value.
-RSpec::Matchers.define :match_gt_field do |expected_pairs, test|
-  match do |response|
-    expected_pairs.all? do |expected_key, expected_value|
-      split_key = TestFile::Test.split_and_parse_key(expected_key).collect do |k|
-        test.get_cached_value(k)
-      end
-
-      actual_value = split_key.inject(response) do |_response, key|
-        # If the key is an index, indicating element of a list
-        if _response.empty? && key == '$body'
-          _response
-        else
-          _response[key] || _response[key.to_s]
-        end
-      end
-      actual_value > test.get_cached_value(expected_value)
-    end
-  end
-end
-
-# Validate that a field is `lte` than a given value.
-RSpec::Matchers.define :match_lte_field do |expected_pairs, test|
-  match do |response|
-    expected_pairs.all? do |expected_key, expected_value|
-      split_key = TestFile::Test.split_and_parse_key(expected_key).collect do |k|
-        test.get_cached_value(k)
-      end
-
-      actual_value = split_key.inject(response) do |_response, key|
-        # If the key is an index, indicating element of a list
-        if _response.empty? && key == '$body'
-          _response
-        else
-          _response[key] || _response[key.to_s]
-        end
-      end
-      actual_value <= test.get_cached_value(expected_value)
-    end
-  end
-end
-
-# Validate that a field is `lt` than a given value.
-RSpec::Matchers.define :match_lt_field do |expected_pairs, test|
-  match do |response|
-    expected_pairs.all? do |expected_key, expected_value|
-      split_key = TestFile::Test.split_and_parse_key(expected_key).collect do |k|
-        test.get_cached_value(k)
-      end
-
-      actual_value = split_key.inject(response) do |_response, key|
-        # If the key is an index, indicating element of a list
-        if _response.empty? && key == '$body'
-          _response
-        else
-          _response[key] || _response[key.to_s]
-        end
-      end
-      actual_value < test.get_cached_value(expected_value)
-    end
-  end
-end
-
-# Match an arbitrary field of a response to a given value.
-RSpec::Matchers.define :match_response do |pairs, test|
-  match do |response|
-    pairs = sanitize_pairs(pairs)
-    compare_pairs(pairs, response, test).empty?
-  end
-
-  failure_message do |response|
-    "the expected response pair/value(s) #{@mismatched_pairs}" +
-      " does not match the pair/value(s) in the response #{response}"
-  end
-
-  def sanitize_pairs(expected_pairs)
-    # sql test returns results at '$body' key. See sql/translate.yml
-    @pairs ||= expected_pairs['$body'] ? expected_pairs['$body'] : expected_pairs
-  end
-
-  def compare_pairs(expected_pairs, response, test)
-    @mismatched_pairs = {}
-    if expected_pairs.is_a?(String)
-      @mismatched_pairs = expected_pairs unless compare_string_response(expected_pairs, response)
-    else
-      compare_hash(expected_pairs, response, test)
-    end
-    @mismatched_pairs
-  end
-
-  def compare_hash(expected_pairs, actual_hash, test)
-    expected_pairs.each do |expected_key, expected_value|
-      # TODO: Refactor! split_key
-      if (match = expected_key.match(/(^\$[a-z]+)/))
-        keys = expected_key.split('.')
-        keys.delete(match[1])
-        dynamic_key = test.cached_values[match[1].gsub('$', '')]
-        value = dynamic_key.dig(*keys)
-
-        if expected_pairs.values.first.is_a?(String) && expected_pairs.values.first.match?(/^\$/)
-          return test.cached_values[expected_pairs.values.first.gsub('$','')] == value
-        else
-          return expected_pairs.values.first == value
-        end
-
-      else
-        split_key = TestFile::Test.split_and_parse_key(expected_key).collect do |k|
-          # Sometimes the expected *key* is a cached value from a previous request.
-          test.get_cached_value(k)
-        end
-      end
-      # We now accept 'nested.keys' so let's try the previous implementation and if that doesn't
-      # work, try with the nested key, otherwise, raise exception.
-      begin
-        actual_value = TestFile::Test.find_value_in_document(split_key, actual_hash)
-      rescue TypeError => e
-        actual_value = TestFile::Test.find_value_in_document(expected_key, actual_hash)
-      rescue StandardError => e
-        raise e
-      end
-      # When the expected_key is ''
-      actual_value = actual_hash if split_key.empty?
-      # Sometimes the key includes dots. See watcher/put_watch/60_put_watch_with_action_condition.yml
-      actual_value = TestFile::Test.find_value_in_document(expected_key, actual_hash) if actual_value.nil?
-
-      # Sometimes the expected *value* is a cached value from a previous request.
-      # See test api_key/10_basic.yml
-      expected_value = test.get_cached_value(expected_value)
-
-      case expected_value
-      when Hash
-        compare_hash(expected_value, actual_value, test)
-      when Array
-        begin
-          unless compare_array(expected_value.sort, actual_value.sort, test, actual_hash)
-            @mismatched_pairs.merge!(expected_key => expected_value)
-          end
-        rescue TypeError, ArgumentError
-          unless compare_array(expected_value, actual_value, test, actual_hash)
-            @mismatched_pairs.merge!(expected_key => expected_value)
-          end
-        end
-      when String
-        unless compare_string(expected_value, actual_value, test, actual_hash)
-          @mismatched_pairs.merge!(expected_key => expected_value)
-        end
-      when Time
-        compare_string(expected_value.to_s, Time.new(actual_value).to_s, test, actual_hash)
-      else
-        unless expected_value == actual_value
-          @mismatched_pairs.merge!(expected_key => expected_value)
-        end
-      end
-    end
-  end
-
-  def compare_string(expected, actual_value, test, response)
-    # When you must match a regex. For example:
-    #   match: {task: '/.+:\d+/'}
-    if expected[0] == '/' && expected[-1] == '/'
-      parsed = expected
-      expected.scan(/\$\{([a-z_0-9]+)\}/) do |match|
-        parsed = parsed.gsub(/\$\{?#{match.first}\}?/, test.cached_values[match.first])
-      end
-      /#{parsed.tr("/", "")}/ =~ actual_value
-    elsif !!(expected.match?(/^-?[0-9]{1}\.[0-9]+E[0-9]+/))
-      # When the value in the yaml test is a big number, the format is
-      # different from what Ruby uses, so we try different options:
-      actual_value.to_s == expected.gsub('E', 'e+') || # transform  X.XXXXEXX to X.XXXXXe+XX to compare thme
-        actual_value == expected || # compare the actual values
-        expected.to_f.to_s == actual_value.to_f.to_s # transform both to Float and compare them
-    elsif expected == '' && actual_value != ''
-      actual_value == response
-    else
-      expected == actual_value
-    end
-  end
-
-  def compare_array(expected, actual, test, response)
-    expected.each_with_index do |value, i|
-      case value
-      when Hash
-        return false unless compare_hash(value, actual[i], test)
-      when Array
-        return false unless compare_array(value, actual[i], test, response)
-      when String
-        return false unless compare_string(value, actual[i], test, response)
-      else
-        true
-      end
-    end
-  end
-
-  def compare_string_response(expected_string, response)
-    regexp = Regexp.new(expected_string.strip[1..-2], Regexp::EXTENDED|Regexp::MULTILINE)
-    regexp =~ response
-  end
-end
-
-# Match that a request returned a given error.
-RSpec::Matchers.define :match_error do |expected_error|
-  match do |actual_error|
-    # Remove surrounding '/' in string representing Regex
-    expected_error = expected_error.chomp("/")
-    expected_error = expected_error[1..-1] if expected_error =~ /^\//
-
-    message = actual_error.message.tr('\\', '')
-
-    case expected_error
-    when 'request_timeout'
-      message =~ /\[408\]/
-    when 'missing'
-      message =~ /\[404\]/
-    when 'conflict'
-      message =~ /\[409\]/
-    when 'request'
-      message =~ /\[500\]/
-    when 'bad_request'
-      message =~ /\[400\]/
-    when 'param'
-      message =~ /\[400\]/ ||
-        actual_error.is_a?(ArgumentError)
-    when 'unauthorized'
-      actual_error.is_a?(Elastic::Transport::Transport::Errors::Unauthorized)
-    when 'forbidden'
-      actual_error.is_a?(Elastic::Transport::Transport::Errors::Forbidden)
-    when /error parsing field/, /illegal_argument_exception/
-      message =~ /\[400\]/ ||
-        actual_error.is_a?(Elastic::Transport::Transport::Errors::BadRequest)
-    when /NullPointerException/
-      message =~ /\[400\]/
-    else
-      message =~ /#{expected_error}/
-    end
-  end
-
-  failure_message do |actual_error|
-    "the error `#{actual_error}` does not match the expected error `#{expected_error}`"
-  end
-end