elasticsearch-api 6.2.0 → 6.3.0

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

@@ -1,68 +0,0 @@
-require 'spec_helper'
-
-describe 'client.indices#unfreeze' do
-
-  let(:expected_args) do
-    [
-        'POST',
-        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.unfreeze
-      }.to raise_exception(ArgumentError)
-    end
-  end
-
-  context 'when an index is specified' do
-
-    let(:url) do
-      'foo/_unfreeze'
-    end
-
-    it 'performs the request' do
-      expect(client_double.indices.unfreeze(index: 'foo')).to eq({})
-    end
-  end
-
-  context 'when params are specified' do
-
-    let(:params) do
-      { timeout: '1s' }
-    end
-
-    let(:url) do
-      'foo/_unfreeze'
-    end
-
-    it 'performs the request' do
-      expect(client_double.indices.unfreeze(index: 'foo', timeout: '1s')).to eq({})
-    end
-  end
-
-  context 'when the path must be URL-escaped' do
-
-    let(:url) do
-      'foo%5Ebar/_unfreeze'
-    end
-
-    it 'performs the request' do
-      expect(client_double.indices.unfreeze(index: 'foo^bar')).to eq({})
-    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,117 +0,0 @@
-require 'spec_helper'
-
-describe 'client#mlt' do
-
-  let(:expected_args) do
-    [
-        'GET',
-        url,
-        params,
-        body
-    ]
-  end
-
-  let(:body) do
-    nil
-  end
-
-  let(:params) do
-    {}
-  end
-
-  let(:client) do
-    Class.new { include Elasticsearch::API }.new
-  end
-
-  it 'requires the :index argument' do
-    expect {
-      client.mlt(type: 'bar', id: '1')
-    }.to raise_exception(ArgumentError)
-  end
-
-  it 'requires the :id argument' do
-    expect {
-      client.mlt(index: 'foo', type: 'bar')
-    }.to raise_exception(ArgumentError)
-  end
-
-  it 'requires the :type argument' do
-    expect {
-      client.mlt(index: 'foo', id: '1')
-    }.to raise_exception(ArgumentError)
-  end
-
-  context 'when an index is specified' do
-
-    let(:url) do
-      'foo/bar/1/_mlt'
-    end
-
-    it 'performs the request' do
-      expect(client_double.mlt(index: 'foo', type: 'bar', id: '1')).to eq({})
-    end
-  end
-
-  context 'when url parameters are provided' do
-
-    let(:url) do
-      'foo/bar/1/_mlt'
-    end
-
-    let(:params) do
-      { max_doc_freq: 1 }
-    end
-
-    it 'performs the request' do
-      expect(client_double.mlt(index: 'foo', type: 'bar', id: '1', max_doc_freq: 1)).to eq({})
-    end
-  end
-
-  context 'when url parameters as lists are provided' do
-
-    let(:url) do
-      'foo/bar/1/_mlt'
-    end
-
-    let(:params) do
-      { mlt_fields: 'foo,bar',
-        search_indices: 'A,B',
-        search_types: 'X,Y',
-        stop_words: 'lam,bam' }
-    end
-
-    it 'performs the request' do
-      expect(client_double.mlt( index: 'foo', type: 'bar', id: '1',
-                                mlt_fields: ['foo', 'bar'],
-                                search_indices: ['A', 'B'],
-                                search_types: ['X', 'Y'],
-                                stop_words: ['lam','bam'])).to eq({})
-    end
-  end
-
-  context 'when the request needs to be URL-escaped' do
-
-    let(:url) do
-      'foo%5Ebar/bar%2Fbam/1/_mlt'
-    end
-
-    it 'performs the request' do
-      expect(client_double.mlt(index: 'foo^bar', type: 'bar/bam', id: '1')).to eq({})
-    end
-  end
-
-  context 'when a search criteria is provided' do
-
-    let(:url) do
-      'foo/bar/1/_mlt'
-    end
-
-    let(:body) do
-      { query: {} }
-    end
-
-    it 'passes the search definition in the body' do
-      expect(client_double.mlt(index: 'foo', type: 'bar', id: '1', body: { query: {} })).to eq({})
-    end
-  end
-end

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/nodes/shutdown_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-
-describe 'client.nodes#shutdown' do
-
-  let(:expected_args) do
-    [
-        'POST',
-        url,
-        params,
-        nil,
-        nil
-    ]
-  end
-
-  let(:url) do
-    '_cluster/nodes/_shutdown'
-  end
-
-  it 'performs the request' do
-    expect(client_double.nodes.shutdown).to eq({})
-  end
-
-  let(:params) do
-    {}
-  end
-
-  context 'when the node id is specified' do
-
-    let(:url) do
-      '_cluster/nodes/foo/_shutdown'
-    end
-
-    it 'performs the request' do
-      expect(client_double.nodes.shutdown(node_id: 'foo')).to eq({})
-    end
-  end
-
-  context 'when multiple node ids are specified as a list' do
-
-    let(:url) do
-      '_cluster/nodes/A,B,C/_shutdown'
-    end
-
-    it 'performs the request' do
-      expect(client_double.nodes.shutdown(node_id: ['A', 'B', 'C'])).to eq({})
-    end
-  end
-
-  context 'when multiple node ids are specified as a String' do
-
-    let(:url) do
-      '_cluster/nodes/A,B,C/_shutdown'
-    end
-
-    it 'performs the request' do
-      expect(client_double.nodes.shutdown(node_id: 'A,B,C')).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/remote/info_spec.rb

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

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

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-describe 'client#search_exists' do
-
-  let(:expected_args) do
-    [
-        'POST',
-        '_search/exists',
-        { q: 'foo' },
-        nil
-    ]
-  end
-
-  it 'performs the request' do
-    expect(client_double.search_exists(q: 'foo')).to eq({})
-  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