elasticsearch-api 6.3.0 → 6.3.1

data/lib/elasticsearch/api/actions/search_exists.rb

@@ -0,0 +1,63 @@
+module Elasticsearch
+  module API
+    module Actions
+
+      # Return whether documents exists for a particular query
+      #
+      # @option arguments [List] :index A comma-separated list of indices to restrict the results
+      # @option arguments [List] :type A comma-separated list of types to restrict the results
+      # @option arguments [Hash] :body A query to restrict the results specified with the Query DSL (optional)
+      # @option arguments [Boolean] :ignore_unavailable Whether specified concrete indices should be ignored when
+      #                                                 unavailable (missing or closed)
+      # @option arguments [Boolean] :allow_no_indices Whether to ignore if a wildcard indices expression resolves
+      #                                               into no concrete indices.
+      # @option arguments [String] :expand_wildcards Whether to expand wildcard expression to concrete indices
+      #                                              that are open, closed or both.
+      #                                              (options: open, closed, none, all)
+      # @option arguments [Number] :min_score Include only documents with a specific `_score` value in the result
+      # @option arguments [String] :preference Specify the node or shard the operation should be performed on
+      #                                        (default: random)
+      # @option arguments [String] :routing Specific routing value
+      # @option arguments [String] :q Query in the Lucene query string syntax
+      # @option arguments [String] :analyzer The analyzer to use for the query string
+      # @option arguments [Boolean] :analyze_wildcard Specify whether wildcard and prefix queries should be
+      #                                               analyzed (default: false)
+      # @option arguments [String] :default_operator The default operator for query string query (AND or OR)
+      #                                              (options: AND, OR)
+      # @option arguments [String] :df The field to use as default where no field prefix is given
+      #                                in the query string
+      # @option arguments [Boolean] :lenient Specify whether format-based query failures
+      #                                      (such as providing text to a numeric field) should be ignored
+      # @option arguments [Boolean] :lowercase_expanded_terms Specify whether query terms should be lowercased
+      #
+      # @see http://www.elastic.co/guide/en/elasticsearch/reference/master/search-exists.html
+      #
+      def search_exists(arguments={})
+        method = 'POST'
+        path   = "_search/exists"
+        params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
+        body   = arguments[:body]
+
+        perform_request(method, path, params, body).body
+      end
+
+      # Register this action with its valid params when the module is loaded.
+      #
+      # @since 6.2.0
+      ParamsRegistry.register(:search_exists, [
+          :ignore_unavailable,
+          :allow_no_indices,
+          :expand_wildcards,
+          :min_score,
+          :preference,
+          :routing,
+          :q,
+          :analyzer,
+          :analyze_wildcard,
+          :default_operator,
+          :df,
+          :lenient,
+          :lowercase_expanded_terms ].freeze)
+    end
+  end
+end

data/lib/elasticsearch/api/actions/suggest.rb

@@ -0,0 +1,49 @@
+module Elasticsearch
+  module API
+    module Actions
+
+      # Return query terms suggestions based on provided text and configuration.
+      #
+      # Pass the request definition in the `:body` argument.
+      #
+      # @example Return query terms suggestions ("auto-correction")
+      #
+      #     client.suggest index: 'myindex',
+      #                    body: { my_suggest: { text: 'tset', term: { field: 'title' } } }
+      #     # => { ... "my_suggest"=>[ {"text"=>"tset", ... "options"=>[{"text"=>"test", "score"=>0.75, "freq"=>5}] }]}
+      #
+      # @option arguments [List] :index A comma-separated list of index names to restrict the operation;
+      #                                 use `_all` or empty string to perform the operation on all indices
+      # @option arguments [Hash] :body The request definition
+      # @option arguments [String] :ignore_indices When performed on multiple indices, allows to ignore `missing` ones
+      #                                            (options: none, missing)
+      # @option arguments [String] :preference Specify the node or shard the operation should be performed on
+      #                                        (default: random)
+      # @option arguments [String] :routing Specific routing value
+      # @option arguments [String] :source The URL-encoded request definition (instead of using request body)
+      #
+      # @since 0.90
+      #
+      # @see http://elasticsearch.org/guide/reference/api/search/suggest/
+      #
+      def suggest(arguments={})
+        method = HTTP_POST
+        path   = Utils.__pathify( Utils.__listify(arguments[:index]), '_suggest' )
+
+        params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
+        body   = arguments[:body]
+
+        perform_request(method, path, params, body).body
+      end
+
+      # Register this action with its valid params when the module is loaded.
+      #
+      # @since 6.2.0
+      ParamsRegistry.register(:suggest, [
+          :ignore_indices,
+          :preference,
+          :routing,
+          :source ].freeze)
+    end
+  end
+end

data/lib/elasticsearch/api/version.rb

@@ -1,5 +1,5 @@
 module Elasticsearch
   module API
-    VERSION = "6.3.0"
+    VERSION = "6.3.1"
   end
 end

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

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe 'client#delete_template' do
+
+  let(:expected_args) do
+    [
+        'DELETE',
+        '_search/template/foo',
+        {},
+        nil
+    ]
+  end
+
+  it 'performs the request' do
+    expect(client_double.delete_template(id: 'foo')).to eq({})
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe 'client#field_stats' do
+
+  let(:expected_args) do
+    [
+        'GET',
+        '_field_stats',
+        { },
+        nil
+    ]
+  end
+
+  it 'performs the request' do
+    expect(client_double.field_stats).to eq({})
+  end
+end

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

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe 'client#get_template' do
+
+  let(:expected_args) do
+    [
+        'GET',
+        url,
+        params,
+        nil
+    ]
+  end
+
+  let(:params) do
+    { }
+  end
+
+  let(:client) do
+    Class.new { include Elasticsearch::API }.new
+  end
+
+  context 'when the `lang` parameter is specified' do
+
+    let(:url) do
+      '_scripts/foo'
+    end
+
+    it 'performs the request' do
+      expect(client_double.get_template(id: 'foo')).to eq({})
+    end
+  end
+
+  context 'when the request raises a NotFound exception' do
+
+    before do
+      expect(client).to receive(:perform_request).and_raise(NotFound)
+    end
+
+    it 'raises the exception' do
+      expect {
+        client.get_template(id: 'foo')
+      }.to raise_exception(NotFound)
+    end
+
+    context 'when the ignore parameter is specified' do
+
+      it 'returns false' do
+        expect(client.get_template(id: 'foo', ignore: 404)).to eq(false)
+      end
+    end
+  end
+end

data/spec/elasticsearch/api/actions/indices/delete_mapping_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe 'client.indices#delete_mapping' do
+
+  let(:expected_args) do
+    [
+        'DELETE',
+        url,
+        params,
+        nil,
+        nil
+    ]
+  end
+
+  let(:params) do
+    {}
+  end
+
+  context 'when there is no index specified' do
+
+    let(:client) do
+      Class.new { include Elasticsearch::API }.new
+    end
+
+    it 'raises an exception' do
+      expect {
+        client.indices.delete_mapping(type: 'foo')
+      }.to raise_exception(ArgumentError)
+    end
+  end
+
+  context 'when there is no type specified' do
+
+    let(:client) do
+      Class.new { include Elasticsearch::API }.new
+    end
+
+    it 'raises an exception' do
+      expect {
+        client.indices.delete_mapping(index: 'foo')
+      }.to raise_exception(ArgumentError)
+    end
+  end
+
+  context 'when an index and type are specified' do
+
+    let(:url) do
+      'foo/bar'
+    end
+
+    it 'performs the request' do
+      expect(client_double.indices.delete_mapping(index: 'foo', type: 'bar')).to eq({})
+    end
+  end
+
+  context 'when multiple indices are specified' do
+
+    let(:url) do
+      'foo,bar/baz'
+    end
+
+    it 'performs the request' do
+      expect(client_double.indices.delete_mapping(index: ['foo','bar'], type: 'baz')).to eq({})
+    end
+  end
+
+  context 'when the path must be URL-escaped' do
+
+    let(:url) do
+      'foo%5Ebar/bar%2Fbam'
+    end
+
+    it 'performs the request' do
+      expect(client_double.indices.delete_mapping(index: 'foo^bar', type: 'bar/bam')).to eq({})
+    end
+  end
+end

data/spec/elasticsearch/api/actions/indices/delete_warmer_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe 'client.indices#delete_warmer' do
+
+  let(:expected_args) do
+    [
+        'DELETE',
+        url,
+        params,
+        nil,
+        nil
+    ]
+  end
+
+  let(:params) do
+    {}
+  end
+
+  context 'when an index is not specified' do
+
+    let(:client) do
+      Class.new { include Elasticsearch::API }.new
+    end
+
+    it 'raises an exception' do
+      expect {
+        client.indices.delete_warmer
+      }.to raise_exception(ArgumentError)
+    end
+  end
+
+  context 'when an index is specified' do
+
+    let(:url) do
+      'foo/_warmer'
+    end
+
+    it 'performs the request' do
+      expect(client_double.indices.delete_warmer(index: 'foo')).to eq({})
+    end
+  end
+
+  context 'when multiple indices are specified' do
+
+    let(:url) do
+      'foo,bar/_warmer'
+    end
+
+    it 'performs the request' do
+      expect(client_double.indices.delete_warmer(index: ['foo', 'bar'])).to eq({})
+    end
+  end
+
+  context 'when a single warmer is specified' do
+
+    let(:url) do
+      'foo/_warmer/bar'
+    end
+
+    it 'performs the request' do
+      expect(client_double.indices.delete_warmer(index: 'foo', name: 'bar')).to eq({})
+    end
+  end
+
+  context 'when a multiple warmers are specified' do
+
+    let(:url) do
+      'foo/_warmer/bar,baz'
+    end
+
+    it 'performs the request' do
+      expect(client_double.indices.delete_warmer(index: 'foo', name: ['bar', 'baz'])).to eq({})
+    end
+  end
+
+  context 'when the path needs to be URL-escaped' do
+
+    let(:url) do
+      'foo%5Ebar/_warmer/bar%2Fbam'
+    end
+
+    it 'performs the request' do
+      expect(client_double.indices.delete_warmer(index: 'foo^bar', name: 'bar/bam')).to eq({})
+    end
+  end
+end

data/spec/elasticsearch/api/actions/indices/get_aliases_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe 'client.cluster#get_aliases' do
+
+  let(:expected_args) do
+    [
+        'GET',
+        url,
+        {},
+        nil,
+        nil
+    ]
+  end
+
+  let(:url) do
+    '_aliases'
+  end
+
+  it 'performs the request' do
+    expect(client_double.indices.get_aliases).to eq({})
+  end
+
+  context 'when an index is specified' do
+
+    let(:url) do
+      'foo/_aliases'
+    end
+
+    it 'performs the request' do
+      expect(client_double.indices.get_aliases(index: 'foo')).to eq({})
+    end
+  end
+
+  context 'when a specified alias is specified' do
+
+    let(:url) do
+      'foo/_aliases/bar'
+    end
+
+    it 'performs the request' do
+      expect(client_double.indices.get_aliases(index: 'foo', name: 'bar')).to eq({})
+    end
+  end
+
+  context 'when the path needs to be URL-escaped' do
+
+    let(:url) do
+      'foo%5Ebar/_aliases'
+    end
+
+    it 'performs the request' do
+      expect(client_double.indices.get_aliases(index: 'foo^bar')).to eq({})
+    end
+  end
+end

data/spec/elasticsearch/api/actions/indices/get_warmer_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe 'client.indices#get_warmer' do
+
+  let(:expected_args) do
+    [
+        'GET',
+        url,
+        params,
+        nil,
+        nil
+    ]
+  end
+
+  let(:params) do
+    {}
+  end
+
+  let(:url) do
+    '_all/_warmer'
+  end
+
+  it 'performs the request' do
+    expect(client_double.indices.get_warmer(index: '_all')).to eq({})
+  end
+
+  context 'when a specified warmer is specified' do
+
+    let(:url) do
+      'foo/_warmer/bar'
+    end
+
+    it 'performs the request' do
+      expect(client_double.indices.get_warmer(index: 'foo', name: 'bar')).to eq({})
+    end
+  end
+
+  context 'when the path must be URL-escaped' do
+
+    let(:url) do
+      'foo%5Ebar/_warmer/bar%2Fbam'
+    end
+
+    it 'performs the request' do
+      expect(client_double.indices.get_warmer(index: 'foo^bar', name: 'bar/bam')).to eq({})
+    end
+  end
+end