elasticsearch-api 6.8.0 → 7.10.0

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

@@ -1,55 +0,0 @@
-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_template_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-
-describe 'client.indices#get_template' do
-
-  let(:expected_args) do
-    [
-        'GET',
-        url,
-        params,
-        nil,
-        nil
-    ]
-  end
-
-  let(:params) do
-    {}
-  end
-
-  let(:url) do
-    '_template/foo'
-  end
-
-  it 'performs the request' do
-    expect(client_double.indices.get_template(name: 'foo')).to eq({})
-  end
-
-  context 'when the path needs to be URL-escaped' do
-
-    let(:url) do
-      '_template/foo%5Ebar'
-    end
-
-    it 'performs the request' do
-      expect(client_double.indices.get_template(name: 'foo^bar')).to eq({})
-    end
-  end
-
-  context 'when a \'not found\' exception is raised with the ignore parameter' do
-
-    let(:client) do
-      Class.new { include Elasticsearch::API }.new.tap do |_client|
-        expect(_client).to receive(:perform_request).with(*expected_args).and_raise(NotFound)
-      end
-    end
-
-    let(:url) do
-      '_template'
-    end
-
-    let(:params) do
-      { ignore: 404 }
-    end
-
-    it 'returns false' do
-      skip
-      expect(client.indices.get_template(id: 'foo', ignore: 404)).to eq(false)
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-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

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

@@ -1,63 +0,0 @@
-require 'spec_helper'
-
-describe 'client.indices#optimize' do
-
-  let(:expected_args) do
-    [
-        'POST',
-        url,
-        params,
-        nil,
-        nil
-    ]
-  end
-
-  let(:params) do
-    {}
-  end
-
-  let(:url) do
-    '_optimize'
-  end
-
-  it 'performs the request' do
-    expect(client_double.indices.optimize).to eq({})
-  end
-
-  context 'when multiple indices are specified' do
-
-    let(:url) do
-      'foo,bar/_optimize'
-    end
-
-    it 'performs the request' do
-      expect(client_double.indices.optimize(index: ['foo', 'bar'])).to eq({})
-    end
-  end
-
-  context 'when parameters are specified' do
-
-    let(:params) do
-      { max_num_segments: 1 }
-    end
-
-    let(:url) do
-      'foo/_optimize'
-    end
-
-    it 'performs the request' do
-      expect(client_double.indices.optimize(index: 'foo', max_num_segments: 1)).to eq({})
-    end
-  end
-
-  context 'when the path must be URL-escaped' do
-
-    let(:url) do
-      'foo%5Ebar/_optimize'
-    end
-
-    it 'performs the request' do
-      expect(client_double.indices.optimize(index: 'foo^bar')).to eq({})
-    end
-  end
-end

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

@@ -1,101 +0,0 @@
-require 'spec_helper'
-
-describe 'client.cluster#put_warmer' do
-
-  let(:expected_args) do
-    [
-        'PUT',
-        url,
-        params,
-        body,
-        nil
-    ]
-  end
-
-  let(:url) do
-    'foo/_warmer/bar'
-  end
-
-  let(:body) do
-    { query: { match_all: {} } }
-  end
-
-  let(:params) do
-    {}
-  end
-
-  it 'performs the request' do
-    expect(client_double.indices.put_warmer(index: 'foo', name: 'bar', body: { query: { match_all: {} } })).to eq({})
-  end
-
-  context 'when there is no name specified' do
-
-    let(:client) do
-      Class.new { include Elasticsearch::API }.new
-    end
-
-    it 'raises an exception' do
-      expect {
-        client.indices.put_warmer(body: {})
-      }.to raise_exception(ArgumentError)
-    end
-  end
-
-  context 'when there is no body specified' do
-
-    let(:client) do
-      Class.new { include Elasticsearch::API }.new
-    end
-
-    it 'raises an exception' do
-      expect {
-        client.indices.put_warmer(name: 'foo')
-      }.to raise_exception(ArgumentError)
-    end
-  end
-
-  context 'when multiple indices are specified' do
-
-    let(:url) do
-      'foo,bar/_warmer/xul'
-    end
-
-    let(:body) do
-      {}
-    end
-
-    it 'performs the request' do
-      expect(client_double.indices.put_warmer(index: ['foo', 'bar'], name: 'xul', body: {})).to eq({})
-    end
-  end
-
-  context 'when a type is specified' do
-
-    let(:url) do
-      'foo/bar/_warmer/xul'
-    end
-
-    let(:body) do
-      {}
-    end
-
-    it 'performs the request' do
-      expect(client_double.indices.put_warmer(index: 'foo', type: 'bar', name: 'xul', body: {})).to eq({})
-    end
-  end
-
-  context 'when the path needs to be URL-escaped' do
-
-    let(:url) do
-      'foo%5Ebar/bar%2Fbam/_warmer/qu+uz'
-    end
-
-    let(:body) do
-      {}
-    end
-
-    it 'performs the request' do
-      expect(client_double.indices.put_warmer(index: 'foo^bar', type: 'bar/bam', name: 'qu uz', body: {})).to eq({})
-    end
-  end
-end

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

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-describe 'client.cluster#seal' do
-
-  let(:expected_args) do
-    [
-        'POST',
-        'foo/_seal',
-        {},
-        nil,
-        nil
-    ]
-  end
-
-  it 'performs the request' do
-    expect(client_double.indices.seal(index: 'foo')).to eq({})
-  end
-end

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

@@ -1,89 +0,0 @@
-require 'spec_helper'
-
-describe 'client.cluster#snapshot_index' do
-
-  let(:expected_args) do
-    [
-        'POST',
-        url,
-        params,
-        body,
-        nil
-    ]
-  end
-
-  let(:url) do
-    '_gateway/snapshot'
-  end
-
-  let(:body) do
-    nil
-  end
-
-  let(:params) do
-    {}
-  end
-
-  it 'performs the request' do
-    expect(client_double.indices.snapshot_index).to eq({})
-  end
-
-  context 'when an index is specified' do
-
-    let(:url) do
-      'foo/_gateway/snapshot'
-    end
-
-    it 'performs the request' do
-      expect(client_double.indices.snapshot_index(index: 'foo')).to eq({})
-    end
-  end
-
-  context 'when multiple indicies are specified as a list' do
-
-    let(:url) do
-      'foo,bar/_gateway/snapshot'
-    end
-
-    it 'performs the request' do
-      expect(client_double.indices.snapshot_index(index: ['foo', 'bar'])).to eq({})
-    end
-  end
-
-  context 'when multiple indicies are specified as a string' do
-
-    let(:url) do
-      'foo,bar/_gateway/snapshot'
-    end
-
-    it 'performs the request' do
-      expect(client_double.indices.snapshot_index(index: 'foo,bar')).to eq({})
-    end
-  end
-
-  context 'when parameters are specified' do
-
-    let(:params) do
-      { ignore_indices: 'missing' }
-    end
-
-    let(:url) do
-      'foo/_gateway/snapshot'
-    end
-
-    it 'performs the request' do
-      expect(client_double.indices.snapshot_index(index: 'foo', ignore_indices: 'missing')).to eq({})
-    end
-  end
-
-  context 'when the path needs to be URL-escaped' do
-
-    let(:url) do
-      'foo%5Ebar/_gateway/snapshot'
-    end
-
-    it 'performs the request' do
-      expect(client_double.indices.snapshot_index(index: 'foo^bar')).to eq({})
-    end
-  end
-end

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

@@ -1,92 +0,0 @@
-require 'spec_helper'
-
-describe 'client.cluster#status' do
-
-  let(:expected_args) do
-    [
-        'GET',
-        url,
-        params,
-        body,
-        nil
-    ]
-  end
-
-  let(:url) do
-    '_status'
-  end
-
-  let(:body) do
-    nil
-  end
-
-  let(:params) do
-    {}
-  end
-
-  it 'performs the request' do
-    expect(client_double.indices.status).to eq({})
-  end
-
-  context 'when an index is specified' do
-
-    let(:url) do
-      'foo/_status'
-    end
-
-    it 'performs the request' do
-      expect(client_double.indices.status(index: 'foo')).to eq({})
-    end
-  end
-
-  context 'when multiple indicies are specified as a list' do
-
-    let(:url) do
-      'foo,bar/_status'
-    end
-
-    it 'performs the request' do
-      expect(client_double.indices.status(index: ['foo', 'bar'])).to eq({})
-    end
-  end
-
-  context 'when multiple indicies are specified as a string' do
-
-
-    let(:url) do
-      'foo,bar/_status'
-    end
-
-    it 'performs the request' do
-      expect(client_double.indices.status(index: 'foo,bar')).to eq({})
-    end
-  end
-
-  context 'when parameters are specified' do
-
-    let(:params) do
-      { recovery: true }
-    end
-
-    let(:url) do
-      'foo/_status'
-    end
-
-    it 'performs the request' do
-      expect(client_double.indices.status(index: 'foo', recovery: true)).to eq({})
-    end
-  end
-
-  context 'when a \'not found\' exception is raised' do
-
-    let(:client) do
-      Class.new { include Elasticsearch::API }.new.tap do |_client|
-        expect(_client).to receive(:perform_request).and_raise(NotFound)
-      end
-    end
-
-    it 'does not raise the exception' do
-      expect(client.indices.status(index: 'foo', ignore: 404)).to eq(false)
-    end
-  end
-end

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

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

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

@@ -1,130 +0,0 @@
-module Elasticsearch
-  module API
-    module Actions
-
-      # Return documents similar to the specified one.
-      #
-      # Performs a `more_like_this` query with the specified document as the input.
-      #
-      # @example Search for similar documents using the `title` property of document `myindex/mytype/1`
-      #
-      #     # First, let's setup a synonym-aware analyzer ("quick" <=> "fast")
-      #     client.indices.create index: 'myindex', body: {
-      #       settings: {
-      #         analysis: {
-      #           filter: {
-      #             synonyms: {
-      #               type: 'synonym',
-      #               synonyms: [ "quick,fast" ]
-      #             }
-      #           },
-      #           analyzer: {
-      #             title_synonym: {
-      #               type: 'custom',
-      #               tokenizer: 'whitespace',
-      #               filter: ['lowercase', 'stop', 'snowball', 'synonyms']
-      #             }
-      #           }
-      #         }
-      #       },
-      #       mappings: {
-      #         mytype: {
-      #           properties: {
-      #             title: {
-      #               type: 'string',
-      #               analyzer: 'title_synonym'
-      #             }
-      #           }
-      #         }
-      #       }
-      #     }
-      #
-      #     # Index three documents
-      #     client.index index: 'myindex', type: 'mytype', id: 1, body: { title: 'Quick Brown Fox'   }
-      #     client.index index: 'myindex', type: 'mytype', id: 2, body: { title: 'Slow Black Dog'    }
-      #     client.index index: 'myindex', type: 'mytype', id: 3, body: { title: 'Fast White Rabbit' }
-      #     client.indices.refresh index: 'myindex'
-      #
-      #     client.mlt index: 'myindex', type: 'mytype', id: 1, mlt_fields: 'title', min_doc_freq: 1, min_term_freq: 1
-      #     # => { ... {"title"=>"Fast White Rabbit"}}]}}
-      #
-      # @option arguments [String] :id The document ID (*Required*)
-      # @option arguments [String] :index The name of the index (*Required*)
-      # @option arguments [String] :type The type of the document (use `_all` to fetch
-      #                                  the first document matching the ID across all types) (*Required*)
-      # @option arguments [Hash] :body A specific search request definition
-      # @option arguments [Number] :boost_terms The boost factor
-      # @option arguments [Number] :max_doc_freq The word occurrence frequency as count: words with higher occurrence
-      #                                          in the corpus will be ignored
-      # @option arguments [Number] :max_query_terms The maximum query terms to be included in the generated query
-      # @option arguments [Number] :max_word_len The minimum length of the word: longer words will be ignored
-      # @option arguments [Number] :min_doc_freq The word occurrence frequency as count: words with lower occurrence
-      #                                          in the corpus will be ignored
-      # @option arguments [Number] :min_term_freq The term frequency as percent: terms with lower occurence
-      #                                           in the source document will be ignored
-      # @option arguments [Number] :min_word_len The minimum length of the word: shorter words will be ignored
-      # @option arguments [List] :mlt_fields Specific fields to perform the query against
-      # @option arguments [Number] :percent_terms_to_match How many terms have to match in order to consider
-      #                                                    the document a match (default: 0.3)
-      # @option arguments [String] :routing Specific routing value
-      # @option arguments [Number] :search_from The offset from which to return results
-      # @option arguments [List] :search_indices A comma-separated list of indices to perform the query against
-      #                                          (default: the index containing the document)
-      # @option arguments [String] :search_query_hint The search query hint
-      # @option arguments [String] :search_scroll A scroll search request definition
-      # @option arguments [Number] :search_size The number of documents to return (default: 10)
-      # @option arguments [String] :search_source A specific search request definition (instead of using the request body)
-      # @option arguments [String] :search_type Specific search type (eg. `dfs_then_fetch`, `count`, etc)
-      # @option arguments [List] :search_types A comma-separated list of types to perform the query against
-      #                                        (default: the same type as the document)
-      # @option arguments [List] :stop_words A list of stop words to be ignored
-      #
-      # @see http://elasticsearch.org/guide/reference/api/more-like-this/
-      #
-      def mlt(arguments={})
-        raise ArgumentError, "Required argument 'index' missing" unless arguments[:index]
-        raise ArgumentError, "Required argument 'type' missing"  unless arguments[:type]
-        raise ArgumentError, "Required argument 'id' missing"    unless arguments[:id]
-        method = HTTP_GET
-        path   = Utils.__pathify Utils.__escape(arguments[:index]),
-                                 Utils.__escape(arguments[:type]),
-                                 Utils.__escape(arguments[:id]),
-                                 '_mlt'
-
-        params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
-
-        [:mlt_fields, :search_indices, :search_types, :stop_words].each do |name|
-          params[name] = Utils.__listify(params[name]) if params[name]
-        end
-
-        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(:mlt, [
-          :boost_terms,
-          :max_doc_freq,
-          :max_query_terms,
-          :max_word_len,
-          :min_doc_freq,
-          :min_term_freq,
-          :min_word_len,
-          :mlt_fields,
-          :percent_terms_to_match,
-          :routing,
-          :search_from,
-          :search_indices,
-          :search_query_hint,
-          :search_scroll,
-          :search_size,
-          :search_source,
-          :search_type,
-          :search_types,
-          :stop_words ].freeze)
-    end
-  end
-end