elasticsearch-api 6.8.0 → 7.10.0

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

@@ -1,49 +0,0 @@
-require 'spec_helper'
-
-describe 'client#mpercolate' do
-
-  let(:expected_args) do
-    [
-        'GET',
-        '_mpercolate',
-        params,
-        body
-    ]
-  end
-
-  let(:body) do
-    nil
-  end
-
-  let(:params) do
-    {}
-  end
-
-  context 'when a body is provided as a document' do
-
-    let(:body) do
-      "{\"percolate\":{\"index\":\"my-index\",\"type\":\"my-type\"}}\n{\"doc\":{\"message\":\"foo bar\"}}\n" +
-          "{\"percolate\":{\"index\":\"my-other-index\",\"type\":\"my-other-type\",\"id\":\"1\"}}\n{}\n"
-    end
-
-    it 'performs the request' do
-      expect(client_double.mpercolate(body: [
-          { percolate: { index: "my-index", type: "my-type" } },
-          { doc: { message: "foo bar" } },
-          { percolate: { index: "my-other-index", type: "my-other-type", id: "1" } },
-          { }
-      ])).to eq({})
-    end
-  end
-
-  context 'when a body is provided as a string' do
-
-    let(:body) do
-      %Q|{"foo":"bar"}\n{"moo":"lam"}|
-    end
-
-    it 'performs the request' do
-      expect(client_double.mpercolate(body: %Q|{"foo":"bar"}\n{"moo":"lam"}|)).to eq({})
-    end
-  end
-end

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

@@ -1,67 +0,0 @@
-require 'spec_helper'
-
-describe 'client#percolate' do
-
-  let(:expected_args) do
-    [
-        'GET',
-        url,
-        { },
-        body
-    ]
-  end
-
-  let(:body) do
-    { doc: { foo: 'bar' }}
-  end
-
-  let(:url) do
-    'foo/bar/_percolate'
-  end
-
-  let(:client) do
-    Class.new { include Elasticsearch::API }.new
-  end
-
-  it 'requires the :index argument' do
-    expect {
-      client.percolate(type: 'bar', body: {})
-    }.to raise_exception(ArgumentError)
-  end
-
-  it 'requires the :type argument' do
-    expect {
-      client.percolate(index: 'foo', body: {})
-    }.to raise_exception(ArgumentError)
-  end
-
-  it 'performs the request' do
-    expect(client_double.percolate(index: 'foo', type: 'bar', body: { doc: { foo: 'bar' } })).to eq({})
-  end
-
-  context 'when the request needs to be URL-escaped' do
-
-    let(:url) do
-      'foo%5Ebar/bar%2Fbam/_percolate'
-    end
-
-    it 'URL-escapes the parts' do
-      expect(client_double.percolate(index: 'foo^bar', type: 'bar/bam', body: { doc: { foo: 'bar' } })).to eq({})
-    end
-  end
-
-  context 'when the document id needs to be URL-escaped' do
-
-    let(:url) do
-      'foo%5Ebar/bar%2Fbam/some%2Fid/_percolate'
-    end
-
-    let(:body) do
-      nil
-    end
-
-    it 'URL-escapes the id' do
-      expect(client_double.percolate(index: 'foo^bar', type: 'bar/bam', id: 'some/id')).to eq({})
-    end
-  end
-end

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

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

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

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

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

@@ -1,63 +0,0 @@
-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/spec/elasticsearch/api/actions/suggest_spec.rb

@@ -1,77 +0,0 @@
-require 'spec_helper'
-
-describe 'client#suggest' do
-
-  let(:expected_args) do
-    [
-        'POST',
-        url,
-        params,
-        body
-    ]
-  end
-
-  let(:url) do
-    '_suggest'
-  end
-
-  let(:params) do
-    {}
-  end
-
-  let(:body) do
-    {}
-  end
-
-  it 'performs the request' do
-    expect(client_double.suggest(body: {})).to eq({})
-  end
-
-  context 'when an index is specified' do
-
-    let(:url) do
-      'foo/_suggest'
-    end
-
-    it 'performs the request' do
-      expect(client_double.suggest(index: 'foo', body: {}))
-    end
-  end
-
-  context 'when there are URL params specified' do
-
-    let(:url) do
-      'foo/_suggest'
-    end
-
-    let(:params) do
-      { routing: 'abc123' }
-    end
-
-    it 'performs the request' do
-      expect(client_double.suggest(index: 'foo', routing: 'abc123', body: {}))
-    end
-  end
-
-  context 'when the request must be URL-escaped' do
-
-    let(:url) do
-      'foo%5Ebar/_suggest'
-    end
-
-    it 'performs the request' do
-      expect(client_double.suggest(index: 'foo^bar', body: {}))
-    end
-  end
-
-  context 'when the request definition is specified in the body' do
-
-    let(:body) do
-      { my_suggest: { text: 'test' } }
-    end
-
-    it 'performs the request' do
-      expect(client_double.suggest(body: { my_suggest: { text: 'test' } } ))
-    end
-  end
-end