elasticsearch-api 6.1.0 → 6.2.0

data/test/unit/list_benchmarks_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class ListBenchmarksTest < ::Test::Unit::TestCase
-
-      context "List benchmarks" do
-        subject { FakeClient.new }
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'GET', method
-            assert_equal '_bench', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.list_benchmarks
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/mget_test.rb

@@ -1,79 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class MgetTest < ::Test::Unit::TestCase
-
-      context "Mget" do
-        subject { FakeClient.new }
-
-        should "require the :body argument" do
-          assert_raise ArgumentError do
-            subject.mget
-          end
-        end
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'GET', method
-            assert_equal '_mget', url
-            assert_equal Hash.new, params
-            assert_equal [], body[:docs]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.mget :body => { :docs => [] }
-        end
-
-        should "perform request against an index" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/_mget', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.mget :index => 'foo', :body => {}
-        end
-
-        should "perform request against an index and type" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/bar/_mget', url
-            assert_equal ['1', '2'], body[:ids]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.mget :index => 'foo', :type => 'bar', :body => { :ids => ['1','2'] }
-        end
-
-        should "pass the URL parameters" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal '_mget', url
-            assert_equal true, params[:refresh]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.mget :body => {}, :refresh => true
-        end
-
-        should "URL-escape the parts" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo%5Ebar/bar%2Fbam/_mget', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.mget :index => 'foo^bar', :type => 'bar/bam', :body => { :ids => ['1','2'] }
-        end
-
-        should "pass the fields parameter as a list" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo,bar', params[:fields]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.mget :body => {}, :fields => ['foo', 'bar']
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/mlt_test.rb

@@ -1,89 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class MltTest < ::Test::Unit::TestCase
-
-      context "More Like This" do
-        subject { FakeClient.new }
-
-        should "require the :index argument" do
-          assert_raise ArgumentError do
-            subject.mlt :type => 'bar', :id => '1'
-          end
-        end
-
-        should "require the :type argument" do
-          assert_raise ArgumentError do
-            subject.mlt :index => 'foo', :id => '1'
-          end
-        end
-
-        should "require the :id argument" do
-          assert_raise ArgumentError do
-            subject.mlt :index => 'foo', :type => 'bar'
-          end
-        end
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'GET', method
-            assert_equal 'foo/bar/1/_mlt', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.mlt :index => 'foo', :type => 'bar', :id => '1'
-        end
-
-        should "pass the URL parameters" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/bar/1/_mlt', url
-            assert_equal 1, params[:max_doc_freq]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.mlt :index => 'foo', :type => 'bar', :id => '1', :max_doc_freq => 1
-        end
-
-        should "URL-escape the parts" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo%5Ebar/bar%2Fbam/1/_mlt', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.mlt :index => 'foo^bar', :type => 'bar/bam', :id => '1'
-        end
-
-        should "pass the specific parameters as a list" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo,bar', params[:mlt_fields]
-            assert_equal 'A,B',     params[:search_indices]
-            assert_equal 'X,Y',     params[:search_types]
-            assert_equal 'lam,bam', params[:stop_words]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.mlt :index => 'foo', :type => 'bar', :id => '1',
-                      :mlt_fields     => ['foo', 'bar'],
-                      :search_indices => ['A', 'B'],
-                      :search_types   => ['X', 'Y'],
-                      :stop_words     => ['lam','bam']
-        end
-
-        should "pass a specific search definition in body" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/bar/1/_mlt', url
-            assert_equal Hash.new, body[:query]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.mlt :index => 'foo', :type => 'bar', :id => '1', :body => { :query => {} }
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/mpercolate_test.rb

@@ -1,51 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class MpercolateTest < ::Test::Unit::TestCase
-
-      context "Mpercolate" do
-        subject { FakeClient.new }
-
-        should "require the :body argument" do
-          assert_raise ArgumentError do
-            subject.mpercolate
-          end
-        end
-
-        should "post correct payload to the endpoint" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'GET', method
-            assert_equal '_mpercolate', url
-            assert_equal Hash.new, params
-
-            lines = body.split("\n")
-            assert_match /\{"percolate"/, lines[0]
-            assert_match /\{"doc"/,       lines[1]
-            assert_match /\{"percolate"/, lines[2]
-            assert_match /\{\}/,          lines[3]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.mpercolate :body => [
-            { :percolate => { :index => "my-index", :type => "my-type" } },
-            { :doc => { :message => "foo bar" } },
-            { :percolate => { :index => "my-other-index", :type => "my-other-type", :id => "1" } },
-            { }
-          ]
-        end
-
-        should "post a string payload intact" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal %Q|{"foo":"bar"}\n{"moo":"lam"}|, body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.mpercolate :body => %Q|{"foo":"bar"}\n{"moo":"lam"}|
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/msearch_template_test.rb

@@ -1,61 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class MsearchTemplateTest < ::Test::Unit::TestCase
-
-      context "Msearch Template" do
-        subject { FakeClient.new }
-
-        should "require the :body argument" do
-          assert_raise ArgumentError do
-            subject.msearch
-          end
-        end
-
-        should "serialize and post header/data pairs" do
-          subject.expects(:perform_request).with do |method, url, params, body, headers|
-            assert_equal 'GET', method
-            assert_equal '_msearch/template', url
-            assert_equal Hash.new, params
-            assert_equal <<-PAYLOAD.gsub(/^\s+/, ''), body
-            {"index":"foo"}
-            {"inline":{"query":{"match":{"foo":"{{q}}"}}},"params":{"q":"foo"}}
-            {"index":"bar"}
-            {"id":"query_foo","params":{"q":"foo"}}
-            PAYLOAD
-            assert_equal 'application/x-ndjson', headers["Content-Type"]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.msearch_template :body => [
-            { :index => 'foo' },
-            { :inline => { :query => { :match => { :foo => '{{q}}' } } }, :params => { :q => 'foo' } },
-            { :index => 'bar' },
-            { :id => 'query_foo', :params => { :q => 'foo' } }
-          ]
-        end
-
-        should "post a string payload intact" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal %Q|{"foo":"bar"}\n{"moo":"lam"}|, body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.msearch_template :body => %Q|{"foo":"bar"}\n{"moo":"lam"}|
-        end
-
-        should "perform request against an index" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/_msearch/template', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.msearch_template :index => 'foo', :body => []
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/msearch_test.rb

@@ -1,130 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class MsearchTest < ::Test::Unit::TestCase
-
-      context "Msearch" do
-        subject { FakeClient.new }
-
-        should "require the :body argument" do
-          assert_raise ArgumentError do
-            subject.msearch
-          end
-        end
-
-        should "post correct payload to the endpoint" do
-          subject.expects(:perform_request).with do |method, url, params, body, headers|
-            assert_equal 'GET', method
-            assert_equal '_msearch', url
-            assert_equal Hash.new, params
-            assert_equal <<-PAYLOAD.gsub(/^\s+/, ''), body
-            {"index":"foo"}
-            {"query":{"match_all":{}}}
-            {"index":"bar"}
-            {"query":{"match":{"foo":"bar"}}}
-            {"search_type":"count"}
-            {"facets":{"tags":{}}}
-            PAYLOAD
-            assert_equal 'application/x-ndjson', headers["Content-Type"]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.msearch :body => [
-            { :index => 'foo', :search => { :query => { :match_all => {}  } } },
-            { :index => 'bar', :search => { :query => { :match => { :foo => 'bar' } } } },
-            { :search_type => 'count', :search => { :facets => { :tags => {} } } }
-          ]
-        end
-
-        should "post a string payload intact" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal %Q|{"foo":"bar"}\n{"moo":"lam"}|, body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.msearch :body => %Q|{"foo":"bar"}\n{"moo":"lam"}|
-        end
-
-        should "serialize and post header/data pairs" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'GET', method
-            assert_equal '_msearch', url
-            assert_equal Hash.new, params
-            assert_equal <<-PAYLOAD.gsub(/^\s+/, ''), body
-            {"index":"foo"}
-            {"query":{"match_all":{}}}
-            {"index":"bar"}
-            {"query":{"match":{"foo":"bar"}}}
-            PAYLOAD
-            true
-          end.returns(FakeResponse.new)
-
-          subject.msearch :body => [
-            { :index => 'foo' },
-            { :query => { :match_all => {}  } },
-            { :index => 'bar' },
-            { :query => { :match => { :foo => 'bar' } } }
-          ]
-        end
-
-        should "perform request against an index" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/_msearch', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.msearch :index => 'foo', :body => []
-        end
-
-        should "perform request against an index and type" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo/bar/_msearch', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.msearch :index => 'foo', :type => 'bar', :body => []
-        end
-
-        should "perform request against multiple indices" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo,bar/_msearch', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.msearch :index => ['foo', 'bar'], :body => []
-        end
-
-        should "perform request against multiple indices and types" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo,bar/lam,bam/_msearch', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.msearch :index => ['foo', 'bar'], :type => ['lam', 'bam'], :body => []
-        end
-
-        should "URL-escape the parts" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo%5Ebar/bar%2Fbam/_msearch', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.msearch :index => 'foo^bar', :type => 'bar/bam', :body => []
-        end
-
-        should "encode URL parameters" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal '_msearch', url
-            assert_equal 'scroll', params[:search_type]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.msearch :body => [], :search_type => 'scroll'
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/mtermvectors_test.rb

@@ -1,38 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class MtermvectorsTest < ::Test::Unit::TestCase
-
-      context "Mtermvectors" do
-        subject { FakeClient.new }
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'GET', method
-            assert_equal 'my-index/my-type/_mtermvectors', url
-            assert_equal Hash.new, params
-            assert_equal [1, 2, 3], body[:ids]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.mtermvectors :index => 'my-index', :type => 'my-type', :body => { :ids => [1, 2, 3] }
-        end
-
-        should "allow passing a list of IDs instead of the body" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'GET', method
-            assert_equal 'my-index/my-type/_mtermvectors', url
-            assert_equal Hash.new, params
-            assert_equal [1, 2, 3], body[:ids]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.mtermvectors :index => 'my-index', :type => 'my-type', :ids => [1, 2, 3]
-        end
-
-      end
-
-    end
-  end
-end