elasticsearch-api 7.14.0 → 8.0.0.pre1

data/spec/elasticsearch/api/actions/update_document_spec.rb

@@ -18,14 +18,13 @@
 require 'spec_helper'
 
 describe 'client#update' do
-
   let(:expected_args) do
     [
-        'POST',
-        url,
-        params,
-        body,
-        {}
+      'POST',
+      url,
+      params,
+      body,
+      {}
     ]
   end
 
@@ -58,11 +57,10 @@ describe 'client#update' do
   end
 
   it 'performs the request' do
-    expect(client_double.update(index: 'foo', type: 'bar', id: '1', body: { doc: {} })).to eq({})
+    expect(client_double.update(index: 'foo', type: 'bar', id: '1', body: { doc: {} })).to be_a Elasticsearch::API::Response
   end
 
   context 'when URL parameters are provided' do
-
     let(:url) do
       'foo/bar/1/_update'
     end
@@ -76,17 +74,7 @@ describe 'client#update' do
     end
   end
 
-  context 'when invalid parameters are specified' do
-
-    it 'raises an ArgumentError' do
-      expect {
-        client.update(index: 'foo', type: 'bar', id: '1', body: { doc: {} }, qwertypoiuy: 'asdflkjhg')
-      }.to raise_exception(ArgumentError)
-    end
-  end
-
   context 'when the request needs to be URL-escaped' do
-
     let(:url) do
       'foo%5Ebar/bar%2Fbam/1/_update'
     end
@@ -101,7 +89,6 @@ describe 'client#update' do
   end
 
   context 'when a NotFound exception is raised' do
-
     before do
       allow(client).to receive(:perform_request).and_raise(NotFound)
     end
@@ -113,7 +100,6 @@ describe 'client#update' do
     end
 
     context 'when the :ignore parameter is specified' do
-
       it 'does not raise the error to the user' do
         expect(client.update(index: 'foo', type: 'bar', id: 'XXX', body: {}, ignore: 404)).to eq(false)
       end

data/spec/elasticsearch/api/api_response_spec.rb

@@ -0,0 +1,64 @@
+# 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::Response do
+  let(:response_body) do
+    {
+      'name' => 'instance',
+      'cluster_name' => 'elasticsearch-8-0-0',
+      'version' => {
+        'number' => '8.0.0',
+        'build_flavor' => 'default'
+      },
+      'tagline' => 'You Know, for Search'
+    }
+  end
+  let(:headers) do
+    { 'Content-Type' => 'application/json'}
+  end
+  let(:es_response) do
+    Elastic::Transport::Transport::Response.new(
+      200,
+      response_body,
+      headers
+    )
+  end
+  let(:response) { described_class.new(es_response) }
+
+  it 'behaves like a Hash' do
+    expect(response['name']).to eq 'instance'
+    expect(response['version']).to eq({ 'number' => '8.0.0', 'build_flavor' => 'default' })
+    expect(response.keys).to eq ['name', 'cluster_name', 'version', 'tagline']
+    expect(response.respond_to?('map')).to be(true)
+    expect(response.respond_to?('each')).to be(true)
+    expect(response.respond_to?('size')).to be(true)
+  end
+
+  it 'returns a status' do
+    expect(response.status).to eq 200
+  end
+
+  it 'returns the headers' do
+    expect(response.headers).to eq headers
+  end
+
+  it 'returns the body which' do
+    expect(response.body).to eq response_body
+  end
+end

data/spec/elasticsearch/api/api_spec.rb

@@ -18,9 +18,7 @@
 require 'spec_helper'
 
 describe Elasticsearch::API do
-
   describe '#settings' do
-
     it 'allows access to settings' do
       expect(described_class.settings).not_to be_nil
     end
@@ -30,7 +28,6 @@ describe Elasticsearch::API do
     end
 
     context 'when settings are changed' do
-
       before do
         Elasticsearch::API.settings[:foo] = 'bar'
       end

data/spec/elasticsearch/api/client_spec.rb

@@ -18,27 +18,23 @@
 require 'spec_helper'
 
 describe 'API Client' do
-
   let(:client) do
     Class.new { include Elasticsearch::API }.new
   end
 
   describe '#cluster' do
-
     it 'responds to the method' do
       expect(client.respond_to?(:cluster)).to be(true)
     end
   end
 
   describe '#indices' do
-
     it 'responds to the method' do
       expect(client.respond_to?(:indices)).to be(true)
     end
   end
 
   describe '#bulk' do
-
     it 'responds to the method' do
       expect(client.respond_to?(:bulk)).to be(true)
     end

data/spec/elasticsearch/api/rest_api_yaml_spec.rb

@@ -16,13 +16,13 @@
 # under the License.
 
 require 'spec_helper'
-require 'rest_yaml_tests_helper'
+require 'rest_api_tests_helper'
 
 describe 'Rest API YAML tests' do
+  LOGGER = Logger.new($stdout)
   if REST_API_YAML_FILES.empty?
-    logger = Logger.new($stdout)
-    logger.error 'No test files found!'
-    logger.info 'Use rake rake elasticsearch:download_artifacts in the root directory of the project to download the test artifacts.'
+    LOGGER.error 'No test files found!'
+    LOGGER.info 'Use rake rake elasticsearch:download_artifacts in the root directory of the project to download the test artifacts.'
     exit 1
   end
 
@@ -33,121 +33,115 @@ describe 'Rest API YAML tests' do
     rescue SkipTestsException => _e
       # If the test file has a `skip` at the top level that applies to this
       # version of Elasticsearch, continue with the next text.
-      logger = Logger.new($stdout)
-      logger.info "Skipping #{file} due to 'skip all'."
+      LOGGER.info "Skipping #{file} due to 'skip all'."
       next
     end
 
-    context "#{file.gsub("#{YAML_FILES_DIRECTORY}/", '')}" do
+    ctx = file.gsub("#{YAML_FILES_DIRECTORY}/", '')
+    context ctx do
+      let(:client) { DEFAULT_CLIENT }
+
       test_file.tests.each do |test|
-        context "#{test.description}" do
+        context test.description do
           if test.skip_test?(ADMIN_CLIENT)
             skip 'Test contains feature(s) not yet supported or version is not satisfied'
-          else
-            let(:client) do
-              DEFAULT_CLIENT
-            end
+            next
+          end
 
-            # Runs once before each test in a test file
-            before(:all) do
-              Elasticsearch::RestAPIYAMLTests::TestFile.wipe_cluster(ADMIN_CLIENT)
-              test_file.setup
-            end
+          before(:all) { test_file.setup }
+          after(:all) do
+            test_file.teardown
+            Elasticsearch::RestAPIYAMLTests::WipeCluster.run(ADMIN_CLIENT)
+          end
 
-            after(:all) do
-              test_file.teardown
-              Elasticsearch::RestAPIYAMLTests::TestFile.wipe_cluster(ADMIN_CLIENT)
+          test.task_groups.each do |task_group|
+            before do
+              task_group.run(client)
             end
 
-            test.task_groups.each do |task_group|
-              before do
-                task_group.run(client)
+            # 'catch' is in the task group definition
+            if task_group.catch_exception?
+              it 'sends the request and throws the expected error' do
+                expect(task_group.exception).to match_error(task_group.expected_exception_message)
               end
 
-              # 'catch' is in the task group definition
-              if task_group.catch_exception?
-                it 'sends the request and throws the expected error' do
-                  expect(task_group.exception).to match_error(task_group.expected_exception_message)
-                end
-
-                # 'match' on error description is in the task group definition
-                if task_group.has_match_clauses?
-                  task_group.match_clauses.each do |match|
-                    it 'contains the expected error in the request response' do
-                      expect(task_group.exception.message).to match(Regexp.new(Regexp.escape(match['match'].values.first.to_s)))
-                    end
+              # 'match' on error description is in the task group definition
+              if task_group.has_match_clauses?
+                task_group.match_clauses.each do |match|
+                  it 'contains the expected error in the request response' do
+                    expect(task_group.exception.message).to match(Regexp.new(Regexp.escape(match['match'].values.first.to_s)))
                   end
                 end
-              else
-                # 'match' is in the task group definition
-                if task_group.has_match_clauses?
-                  task_group.match_clauses.each do |match|
-                    it "has the expected value (#{match['match'].values.join(',')}) in the response field (#{match['match'].keys.join(',')})" do
-                      expect(task_group.response).to match_response(match['match'], test)
-                    end
+              end
+            else
+              # 'match' is in the task group definition
+              if task_group.has_match_clauses?
+                task_group.match_clauses.each do |match|
+                  it "has the expected value (#{match['match'].values.join(',')}) in the response field (#{match['match'].keys.join(',')})" do
+                    expect(task_group.response).to match_response(match['match'], test)
                   end
                 end
+              end
 
-                # 'length' is in the task group definition
-                if task_group.has_length_match_clauses?
-                  task_group.length_match_clauses.each do |match|
-                    it "the '#{match['length'].keys.join(',')}' field have the expected length" do
-                      expect(task_group.response).to match_response_field_length(match['length'], test)
-                    end
+              # 'length' is in the task group definition
+              if task_group.has_length_match_clauses?
+                task_group.length_match_clauses.each do |match|
+                  it "the '#{match['length'].keys.join(',')}' field have the expected length" do
+                    expect(task_group.response).to match_response_field_length(match['length'], test)
                   end
                 end
+              end
 
-                # 'is_true' is in the task group definition
-                if task_group.has_true_clauses?
-                  task_group.true_clauses.each do |match|
-                    it "sends the request and the '#{match['is_true']}' field is set to true" do
-                      expect(task_group.response).to match_true_field(match['is_true'], test)
-                    end
+              # 'is_true' is in the task group definition
+              if task_group.has_true_clauses?
+                task_group.true_clauses.each do |match|
+                  it "sends the request and the '#{match['is_true']}' field is set to true" do
+                    expect(task_group.response).to match_true_field(match['is_true'], test)
                   end
                 end
+              end
 
-                # 'is_false' is in the task group definition
-                if task_group.has_false_clauses?
-                  task_group.false_clauses.each do |match|
-                    it "sends the request and the '#{match['is_false']}' field is set to true" do
-                      expect(task_group.response).to match_false_field(match['is_false'], test)
-                    end
+              # 'is_false' is in the task group definition
+              if task_group.has_false_clauses?
+                task_group.false_clauses.each do |match|
+                  it "sends the request and the '#{match['is_false']}' field is set to true" do
+                    expect(task_group.response).to match_false_field(match['is_false'], test)
                   end
                 end
+              end
 
-                # 'gte' is in the task group definition
-                if task_group.has_gte_clauses?
-                  task_group.gte_clauses.each do |match|
-                    it "sends the request and the '#{match['gte']}' field is greater than or equal to the expected value" do
-                      expect(task_group.response).to match_gte_field(match['gte'], test)
-                    end
+              # 'gte' is in the task group definition
+              if task_group.has_gte_clauses?
+                task_group.gte_clauses.each do |match|
+                  it "sends the request and the '#{match['gte']}' field is greater than or equal to the expected value" do
+                    expect(task_group.response).to match_gte_field(match['gte'], test)
                   end
                 end
+              end
 
-                # 'gt' is in the task group definition
-                if task_group.has_gt_clauses?
-                  task_group.gt_clauses.each do |match|
-                    it "sends the request and the '#{match['gt']}' field is greater than the expected value" do
-                      expect(task_group.response).to match_gt_field(match['gt'], test)
-                    end
+              # 'gt' is in the task group definition
+              if task_group.has_gt_clauses?
+                task_group.gt_clauses.each do |match|
+                  it "sends the request and the '#{match['gt']}' field is greater than the expected value" do
+                    expect(task_group.response).to match_gt_field(match['gt'], test)
                   end
                 end
+              end
 
-                # 'lte' is in the task group definition
-                if task_group.has_lte_clauses?
-                  task_group.lte_clauses.each do |match|
-                    it "sends the request and the '#{match['lte']}' field is less than or equal to the expected value" do
-                      expect(task_group.response).to match_lte_field(match['lte'], test)
-                    end
+              # 'lte' is in the task group definition
+              if task_group.has_lte_clauses?
+                task_group.lte_clauses.each do |match|
+                  it "sends the request and the '#{match['lte']}' field is less than or equal to the expected value" do
+                    expect(task_group.response).to match_lte_field(match['lte'], test)
                   end
                 end
+              end
 
-                # 'lt' is in the task group definition
-                if task_group.has_lt_clauses?
-                  task_group.lt_clauses.each do |match|
-                    it "sends the request and the '#{match['lt']}' field is less than the expected value" do
-                      expect(task_group.response).to match_lt_field(match['lt'], test)
-                    end
+              # 'lt' is in the task group definition
+              if task_group.has_lt_clauses?
+                task_group.lt_clauses.each do |match|
+                  it "sends the request and the '#{match['lt']}' field is less than the expected value" do
+                    expect(task_group.response).to match_lt_field(match['lt'], test)
                   end
                 end
               end

data/spec/elasticsearch/api/utils_spec.rb

@@ -18,13 +18,11 @@
 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
@@ -53,7 +51,6 @@ describe Elasticsearch::API::Utils do
   end
 
   describe '#__listify' do
-
     it 'creates a list from a single value' do
       expect(utils.__listify('foo')).to eq('foo')
     end
@@ -75,7 +72,6 @@ describe Elasticsearch::API::Utils do
     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
@@ -83,7 +79,6 @@ describe Elasticsearch::API::Utils do
   end
 
   describe '#__pathify' do
-
     it 'creates a path from a single value' do
       expect(utils.__pathify('foo')).to eq('foo')
     end
@@ -102,9 +97,7 @@ describe Elasticsearch::API::Utils do
   end
 
   describe '#__bulkify' do
-
     context 'when the input is an array of hashes' do
-
       let(:result) do
         utils.__bulkify [
           { :index =>  { :_index => 'myindexA', :_type => 'mytype', :_id => '1', :data => { :title => 'Test' } } },
@@ -192,7 +185,6 @@ describe Elasticsearch::API::Utils do
     end
 
     context 'when the payload has nested :data options' do
-
       let(:data) do
         { data: { a: 'b', data: { c: 'd' } } }
       end
@@ -226,83 +218,28 @@ describe Elasticsearch::API::Utils do
   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')
+      expect(utils.process_params({ foo: ['a', 'b'] })).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.*')
+      expect(utils.process_params({ foo: ['a.*', 'b.*'] })).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')
+        expect(utils.process_params({ foo: 'qux' })).to eq(foo: 'qux')
       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'])
+      expect(utils.__extract_parts({ foo: true, moo: 'blah' })).to eq(['foo', 'blah'])
     end
 
     it 'extracts parts with string value from a Hash' do
-      expect(utils.__extract_parts({ foo: 'qux', moo: 'blah' }, [:foo, :bar])).to eq(['qux'])
+      expect(utils.__extract_parts({ foo: 'qux', moo: 'blah' })).to eq(['qux', 'blah'])
     end
   end
 

data/spec/{rest_yaml_tests_helper.rb → rest_api_tests_helper.rb}

@@ -15,55 +15,65 @@
 # 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/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__), '..')
+host = ENV['TEST_ES_SERVER'] || 'http://localhost:9200'
+raise URI::InvalidURIError unless host =~ /\A#{URI::DEFAULT_PARSER.make_regexp}\z/
 
-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
+test_suite = ENV['TEST_SUITE'] || 'free'
+password = ENV['ELASTIC_PASSWORD'] || 'changeme'
+uri = URI.parse(host)
+
+if 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
-  TEST_HOST, TEST_PORT = 'localhost', '9200'
+  host = "http://elastic:#{password}@#{uri.host}:#{uri.port}".freeze
+  transport_options = {}
 end
-require 'byebug'; byebug
 
-if defined?(TEST_HOST) && defined?(TEST_PORT)
-  URL = "http://#{TEST_HOST}:#{TEST_PORT}"
+ADMIN_CLIENT = Elasticsearch::Client.new(host: host, transport_options: transport_options)
 
-  ADMIN_CLIENT = Elasticsearch::Client.new(host: URL, 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)
-  else
-    DEFAULT_CLIENT = Elasticsearch::Client.new(host: URL,
-                                               transport_options: TRANSPORT_OPTIONS,
-                                               tracer: Logger.new($stdout))
-  end
+unless ADMIN_CLIENT.ping
+  raise('Couldn\'t connect to Elasticsearch cluster')
+  exit
 end
 
-YAML_FILES_DIRECTORY = "#{PROJECT_PATH}/../tmp/rest-api-spec/test/free"
+YAML_FILES_DIRECTORY = "#{PROJECT_PATH}/../tmp/rest-api-spec/test/#{test_suite}".freeze
 
 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}"]
+                  ["#{PROJECT_PATH}/../tmp/rest-api-spec/test/#{test_suite}/#{test_target}"]
                 else
                   Dir.glob(
-                    ["#{PROJECT_PATH}/../tmp/rest-api-spec/test/free/#{test_target}/*.yml"]
+                    ["#{PROJECT_PATH}/../tmp/rest-api-spec/test/#{test_suite}/#{test_target}/*.yml"]
                   )
                 end
               end
 
 # Skipped tests
-file = File.expand_path("#{__dir__}/skipped_tests.yml")
+file = File.expand_path("#{__dir__}/skipped_tests_#{test_suite}.yml")
 skipped_tests = YAML.load_file(file)
 
 # The directory of rest api YAML files.

data/spec/{skipped_tests.yml → skipped_tests_free.yml}

@@ -8,11 +8,6 @@
   :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'
@@ -20,10 +15,10 @@
 
 # Figure out how to match response when there is an error
 -
-  :file:        'delete/70_mix_typeless_typeful.yml'
+  :file:        'cat.templates/10_basic.yml'
   :description: '*'
 
-# Figure out how to match response when there is an error
+# https://github.com/elastic/elasticsearch-ruby/issues/1469
 -
-  :file:        'cat.templates/10_basic.yml'
-  :description: '*'
+  :file:        'indices.get_alias/10_basic.yml'
+  :description: 'Get alias against closed indices'