elasticsearch-api 7.13.3 → 8.14.0

data/api-spec-testing/rspec_matchers.rb

@@ -0,0 +1,338 @@
+# 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
+        unless compare_array(expected_value, actual_value, test, actual_hash)
+          @mismatched_pairs.merge!(expected_key => expected_value)
+        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)
+      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/
+      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

data/api-spec-testing/test_file/action.rb

@@ -0,0 +1,251 @@
+# 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
+    # Class representing a single action. An action is one of the following:
+    #
+    #   1. Applying header settings on a client.
+    #   2. Sending some request to Elasticsearch.
+    #   3. Sending some request to Elasticsearch, expecting an exception.
+    #
+    # @since 6.2.0
+    class Action
+      attr_reader :response
+
+      # Initialize an Action object.
+      #
+      # @example Create an action object:
+      #   Action.new("xpack.watcher.get_watch" => { "id" => "my_watch" })
+      #
+      # @param [ Hash ] definition The action definition.
+      #
+      # @since 6.2.0
+      def initialize(definition)
+        @definition = definition
+        @retries = 0
+      end
+
+      # Execute the action. The method returns the client, in case the action created a new client
+      #   with header settings.
+      #
+      # @example Execute the action.
+      #   action.execute(client, test)
+      #
+      # @param [ Elasticsearch::Client ] client The client to use to execute the action.
+      # @param [ Test ] test The test containing this action. Necessary for caching variables.
+      #
+      # @return [ Elasticsearch::Client ] The client. It will be a new one, not the one passed in,
+      #   if the action is to set headers.
+      #
+      # @since 6.2.0
+      def execute(client, test = nil)
+        @definition.each.inject(client) do |client, (method_chain, args)|
+          if method_chain.match?('_internal')
+            perform_internal(method_chain, args, client, test)
+          else
+            chain = method_chain.split('.')
+            # If we have a method nested in a namespace, client becomes the
+            # client/namespace. Eg for `indices.resolve_index`, `client =
+            # client.indices` and then we call `resolve_index` on `client`.
+            if chain.size > 1
+              client = chain[0...-1].inject(client) do |shadow_client, method|
+                shadow_client.send(method)
+              end
+            end
+            _method = chain[-1]
+
+            perform_action(_method, args, client, test)
+          end
+        end
+      end
+
+      def yaml_response?
+        @definition['headers'] && @definition['headers']['Accept'] == 'application/yaml'
+      end
+
+      private
+
+      # Executes operations not implemented by elasticsearch-api, such as _internal
+      def perform_internal(method, args, client, test)
+        es_version = test.cached_values['es_version'] unless test.nil?
+        case method
+        when '_internal.update_desired_nodes'
+          http = 'PUT'
+          if (history_id = args.delete('history_id')).match?(/\s+/)
+            require 'erb'
+            history_id = ERB::Util.url_encode(history_id)
+          end
+          path = "/_internal/desired_nodes/#{history_id}/#{args.delete('version')}"
+          body = args.delete('body')
+          # Replace $es_version with actual value:
+          body['nodes'].map do |node|
+            node['node_version']&.gsub!('$es_version', es_version) if node['node_version'] && es_version
+          end if body['nodes']
+        when '_internal.delete_desired_nodes'
+          http = 'DELETE'
+          path = '/_internal/desired_nodes/'
+          body = args.delete('body')
+        when /_internal\.get_([a-z_]+)/
+          http = 'GET'
+          path = case Regexp.last_match(1)
+                 when 'desired_nodes'
+                   '/_internal/desired_nodes/_latest'
+                 when 'desired_balance'
+                   '/_internal/desired_balance'
+                 end
+          body = nil
+        when '_internal.health'
+          path = if args['feature']
+                   "_internal/_health/#{args.delete('feature')}/"
+                 else
+                   '_internal/_health'
+                 end
+          http = 'GET'
+          body = args.delete('body')
+        when '_internal.prevalidate_node_removal'
+          path = '/_internal/prevalidate_node_removal'
+          http = 'POST'
+          body = args.delete('body')
+        end
+        args = prepare_arguments(args, test)
+        @response = Elasticsearch::API::Response.new(client.perform_request(http, path, args, body))
+        client
+      end
+
+      def perform_action(_method, args, client, test)
+        case _method
+        when 'bulk'
+          arguments = prepare_arguments(args, test)
+          arguments[:body].map! do |item|
+            if item.is_a?(Hash)
+              item
+            elsif item.is_a?(String)
+              symbolize_keys(JSON.parse(item))
+            end
+          end if arguments[:body].is_a? Array
+          @response = client.send(_method, arguments)
+          client
+        when 'headers'
+          headers = prepare_arguments(args, test)
+          host = client.transport.instance_variable_get('@hosts')
+          transport_options = client.transport.instance_variable_get('@options')&.dig(:transport_options) || {}
+          if ENV['QUIET'] == 'true'
+            # todo: create a method on Elasticsearch::Client that can clone the client with new options
+            Elasticsearch::Client.new(
+              host: host,
+              transport_options: transport_options.merge(headers: headers)
+            )
+          else
+            Elasticsearch::Client.new(
+              host: host,
+              tracer: Logger.new($stdout),
+              transport_options: transport_options.merge(headers: headers)
+            )
+          end
+        when 'catch', 'warnings', 'allowed_warnings', 'allowed_warnings_regex'
+          client
+        when 'put_trained_model_alias'
+          args.merge!('reassign' => true) unless args['reassign'] === false
+          @response = client.send(_method, prepare_arguments(args, test))
+          client
+        when 'create'
+          begin
+            @response = client.send(_method, prepare_arguments(args, test))
+          rescue Elastic::Transport::Transport::Errors::BadRequest => e
+            case e.message
+            when /resource_already_exists_exception/
+              client.delete(index: args['index'])
+            when /failed to parse date field/
+              body = args['body']
+              time_series = body['settings']['index']['time_series']
+              time_series.each { |k, v| time_series[k] = v.strftime("%FT%TZ") }
+              args['body'] = body
+            else
+              raise e
+            end
+            @response = client.send(_method, prepare_arguments(args, test))
+          end
+          client
+        when 'update_user_profile_data', 'get_user_profile', 'enable_user_profile', 'disable_user_profile'
+          args.each do |key, value|
+            args[key] = value.gsub(value, test.cached_values[value.gsub('$', '')]) if value.match?(/^\$/)
+          end
+          @response = client.send(_method, prepare_arguments(args, test))
+          client
+        else
+          @response = client.send(_method, prepare_arguments(args, test))
+          client
+        end
+      rescue Elastic::Transport::Transport::Error => e
+        if e.message.match(/Net::ReadTimeout/) && @retries <= 5
+          @retries += 1
+          perform_action(method, args, client, test)
+        else
+          raise e
+        end
+      end
+
+      def prepare_arguments(args, test)
+        symbolize_keys(args).tap do |args|
+          if test
+            if args.is_a?(Hash)
+              args.each do |key, value|
+                case value
+                when Hash
+                  args[key] = prepare_arguments(value, test)
+                when Array
+                  args[key] = value.collect { |v| prepare_arguments(v, test) }
+                when String
+                  # Find the cached values where the variable name is contained in the arguments.
+                  if(cached_values = test.cached_values.keys.select { |k| value =~ /\$\{?#{k}\}?/ })
+                    cached_values.each do |cached|
+                      # Arguments can be $variable, ${variable} or a Hash:
+                      retrieved = test.cached_values[cached]
+                      if retrieved.is_a?(Hash)
+                        value = retrieved
+                      else
+                        # Regex substitution to replace ${variable} or $variable for the value
+                        value.gsub!(/\$\{?#{cached}\}?/, retrieved.to_s)
+                      end
+                    end
+                    args[key] = value
+                  end
+                when Time
+                  # The YAML parser reads in dates as Time objects, reconvert to a format Elasticsearch accepts
+                  args[key] = (value.to_f * 1000).to_i
+                end
+              end
+            elsif args.is_a?(String)
+              if (cached_value = test.cached_values.find { |k, _v| args =~ /\$\{?#{k}\}?/ })
+                return cached_value[1]
+              end
+            end
+          end
+        end
+      end
+
+      def symbolize_keys(object)
+        if object.is_a? Hash
+          object.reduce({}) { |memo,(k,v)| memo[k.to_s.to_sym] = symbolize_keys(v); memo }
+        else
+          object
+        end
+      end
+    end
+  end
+end