elasticsearch-api 7.17.9 → 8.0.0.pre1

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

@@ -0,0 +1,168 @@
+# 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
+      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)|
+          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 |_client, _method|
+              _client.send(_method)
+            end
+          end
+
+          _method = chain[-1]
+          case _method
+          when 'headers'
+            headers = prepare_arguments(args, test)
+            # TODO: Remove Authorization headers while x_pack_rest_user is fixed
+            if headers[:Authorization] == 'Basic eF9wYWNrX3Jlc3RfdXNlcjp4LXBhY2stdGVzdC1wYXNzd29yZA=='
+              headers.delete(:Authorization)
+            end
+            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
+              raise e unless e.message.match 'resource_already_exists_exception'
+
+              client.delete(index: args['index'])
+              @response = client.send(_method, prepare_arguments(args, test))
+            end
+            client
+          else
+            @response = client.send(_method, prepare_arguments(args, test))
+            client
+          end
+        end
+      end
+
+      def yaml_response?
+        @definition['headers'] && @definition['headers']['Accept'] == 'application/yaml'
+      end
+
+      private
+
+      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

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

@@ -0,0 +1,340 @@
+# 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 TestFile
+      class Test
+        # Representation of a block of actions consisting of some 'do' actions and their verifications.
+        #
+        # For example, this is a task group:
+        #
+        #   - do:
+        #       xpack.security.get_role:
+        #         name: "admin_role"
+        #   - match: { admin_role.cluster.0:  "all" }
+        #   - match: { admin_role.metadata.key1:  "val1" }
+        #   - match: { admin_role.metadata.key2:  "val2" }
+        #
+        # @since 6.2.0
+        class TaskGroup
+          attr_reader :exception, :response, :test
+
+          # Initialize a TaskGroup object.
+          #
+          # @example Create a TaskGroup
+          #   TaskGroup.new(test)
+          #
+          # @param [ Test ] test The test this task group is part of.
+          #
+          # @since 6.2.0
+          def initialize(test)
+            @actions = []
+            @exception = nil
+            @response = nil
+            @variables = {}
+            @test = test
+          end
+
+          # Add an action to the task group definition.
+          #
+          # @example Add an action
+          #   task_group.add_action(action)
+          #
+          # @param [ Hash ] action The hash representation of an action.
+          #
+          # @return [ self ]
+          #
+          # @since 6.2.0
+          def add_action(action)
+            @actions << action if ACTIONS.any? { |a| action[a] }
+            self
+          end
+
+          # Run the actions in the task group.
+          #
+          # @example Run the actions
+          #   task_group.run(client)
+          #
+          # @param [ Elasticsearch::Client ] client The client to use to run the actions.
+          #
+          # @return [ self ]
+          #
+          # @since 6.2.0
+          def run(client)
+            # Allow the actions to be execute only once.
+            return if @executed
+            @executed = true
+
+            do_actions.inject(client) do |_client, action|
+              action.execute(_client, test)
+              # Cache the result of the action, if a set action is defined.
+              set_variable(action)
+              transform_and_set_variable(action)
+              _client
+            end
+            self
+          rescue => ex
+            raise ex unless catch_exception?
+            # Cache the exception raised as a result of the operation, if the task group has a 'catch' defined.
+            @exception = ex
+          end
+
+          # Consider the response of interest the one resulting from the last action.
+          #
+          # @return [ Hash ] The response from the last action.
+          #
+          # @since 6.2.0
+          def response
+            @response ||= begin
+              if do_actions.any? { |a| a.yaml_response? }
+                YAML.load(do_actions[-1].response)
+              else
+                do_actions[-1].response
+              end
+            end
+          end
+
+          # Does this task group expect to raise an exception for an action?
+          #
+          # @return [ true, false ] If the task group contains an action expected to raise an exception.
+          #
+          # @since 6.2.0
+          def catch_exception?
+            !!expected_exception_message
+          end
+
+          # Does this task group have match clauses.
+          #
+          # @return [ true, false ] If the task group has match clauses.
+          #
+          # @since 6.2.0
+          def has_match_clauses?
+            !!match_clauses
+          end
+
+          # Does this task group have match clauses on field value length.
+          #
+          # @return [ true, false ] If the task group has match clauses on field value length.
+          #
+          # @since 6.2.0
+          def has_length_match_clauses?
+            !!length_match_clauses
+          end
+
+          # Does this task group have match clauses on a field value being true.
+          #
+          # @return [ true, false ] If the task group has match clauses on a field value being true.
+          #
+          # @since 6.2.0
+          def has_true_clauses?
+            !!true_clauses
+          end
+
+          # Does this task group have match clauses on a field value being false.
+          #
+          # @return [ true, false ] If the task group has match clauses on a field value being false.
+          #
+          # @since 6.2.0
+          def has_false_clauses?
+            !!false_clauses
+          end
+
+          # Does this task group have clauses on a field value being gte.
+          #
+          # @return [ true, false ] If the task group has clauses on a field value being gte.
+          #
+          # @since 6.2.0
+          def has_gte_clauses?
+            !!gte_clauses
+          end
+
+          # Does this task group have clauses on a field value being gt.
+          #
+          # @return [ true, false ] If the task group has clauses on a field value being gt.
+          #
+          # @since 6.2.0
+          def has_gt_clauses?
+            !!gt_clauses
+          end
+
+          # Does this task group have clauses on a field value being lte.
+          #
+          # @return [ true, false ] If the task group has clauses on a field value being lte.
+          #
+          # @since 6.2.0
+          def has_lte_clauses?
+            !!lte_clauses
+          end
+
+          # Does this task group have clauses on a field value being lt.
+          #
+          # @return [ true, false ] If the task group has clauses on a field value being lt.
+          #
+          # @since 6.2.0
+          def has_lt_clauses?
+            !!lt_clauses
+          end
+
+          # The expected exception message.
+          #
+          # @return [ String ] The expected exception message.
+          #
+          # @since 6.2.0
+          def expected_exception_message
+            @expected_exception_message ||= begin
+              if do_definitions =  @actions.group_by { |a| a.keys.first }['do']
+                if catch_exception = do_definitions.find { |a| a['do']['catch'] }
+                  catch_exception['do']['catch']
+                end
+              end
+            end
+          end
+
+          # The match clauses.
+          #
+          # @return [ Array<Hash> ] The match clauses.
+          #
+          # @since 6.2.0
+          def match_clauses
+            @match_actions ||= @actions.group_by { |a| a.keys.first }['match']
+          end
+
+          # The true match clauses.
+          #
+          # @return [ Array<Hash> ] The true match clauses.
+          #
+          # @since 6.2.0
+          def true_clauses
+            @true_clauses ||= @actions.group_by { |a| a.keys.first }['is_true']
+          end
+
+          # The false match clauses.
+          #
+          # @return [ Array<Hash> ] The false match clauses.
+          #
+          # @since 6.2.0
+          def false_clauses
+            @false_clauses ||= @actions.group_by { |a| a.keys.first }['is_false']
+          end
+
+          # The gte clauses.
+          #
+          # @return [ Array<Hash> ] The gte clauses.
+          #
+          # @since 6.2.0
+          def gte_clauses
+            @gte_clauses ||= @actions.group_by { |a| a.keys.first }['gte']
+          end
+
+          # The gt clauses.
+          #
+          # @return [ Array<Hash> ] The gt clauses.
+          #
+          # @since 6.2.0
+          def gt_clauses
+            @gt_clauses ||= @actions.group_by { |a| a.keys.first }['gt']
+          end
+
+          # The lte clauses.
+          #
+          # @return [ Array<Hash> ] The lte clauses.
+          #
+          # @since 6.2.0
+          def lte_clauses
+            @lte_clauses ||= @actions.group_by { |a| a.keys.first }['lte']
+          end
+
+          # The lt clauses.
+          #
+          # @return [ Array<Hash> ] The lt clauses.
+          #
+          # @since 6.2.0
+          def lt_clauses
+            @lt_clauses ||= @actions.group_by { |a| a.keys.first }['lt']
+          end
+
+          # The field length match clauses.
+          #
+          # @return [ Array<Hash> ] The field length match clauses.
+          #
+          # @since 6.2.0
+          def length_match_clauses
+            @match_length ||= @actions.group_by { |a| a.keys.first }['length']
+          end
+
+          private
+
+          ACTIONS = (Test::GROUP_TERMINATORS + ['do']).freeze
+
+          def do_actions
+            @do_actions ||= @actions.group_by { |a| a.keys.first }['do'].map { |definition| Action.new(definition['do']) }
+          end
+
+          def variables_to_set
+            @variables_to_set ||= (@actions.group_by { |a| a.keys.first }['set'] || [])
+          end
+
+          def variables_to_transform_and_set
+            @variables_to_transform_and_set ||= (@actions.group_by { |a| a.keys.first }['transform_and_set'] || [])
+          end
+
+          def transform_and_set_variable(action)
+            variables_to_transform_and_set.each do |set_definition|
+              set_definition['transform_and_set'].each do |response_key, transform_description|
+                match_base_64_transform = /(\#base64EncodeCredentials\()(\S*)\)/
+                matches = match_base_64_transform.match(transform_description)
+                fields = matches[2].split(',') if matches.length > 0
+
+                values_to_encode = action.response.select do |key|
+                  fields.include?(key)
+                end.values if fields
+
+                to_set = Base64.strict_encode64(values_to_encode.join(':'))
+                @test.cache_value(response_key, to_set)
+              end
+            end
+          end
+
+          def set_variable(action)
+            variables_to_set.each do |set_definition|
+              set_definition['set'].each do |response_key, variable_name|
+                nested_key_chain = response_key.split('.').map do |key|
+                  # If there's a variable in the set key, get the value:
+                  key.gsub!(key, @test.cached_values[key.gsub('$', '')]) if key.match?(/\$.+/)
+
+                  (key =~ /\A[-+]?[0-9]+\z/) ? key.to_i: key
+                end
+
+                if to_set = find_value(nested_key_chain, action.response)
+                  @test.cache_value(variable_name, to_set)
+                end
+              end
+            end
+          end
+
+          def find_value(chain, document)
+            # Return the first key if an 'arbitrary key' should be returned
+            return document.keys[0] if chain[0] == '_arbitrary_key_'
+            return document[chain[0]] unless chain.size > 1
+            find_value(chain[1..-1], document[chain[0]]) if document[chain[0]]
+          end
+        end
+      end
+    end
+  end
+end