elasticsearch-api 0.0.2

data/test/unit/mlt_test.rb

@@ -0,0 +1,80 @@
+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 "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/msearch_test.rb

@@ -0,0 +1,120 @@
+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|
+            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
+            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 "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/percolate_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class PercolateTest < ::Test::Unit::TestCase
+
+      context "Percolate" do
+        subject { FakeClient.new }
+
+        should "require the :index argument" do
+          assert_raise ArgumentError do
+            subject.percolate :type => 'bar', :body => {}
+          end
+        end
+
+        should "require the :body argument" do
+          assert_raise ArgumentError do
+            subject.percolate :index => 'bar'
+          end
+        end
+
+        should "have default document type" do
+          assert_nothing_raised do
+            subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo/document/_percolate', url
+            true
+          end.returns(FakeResponse.new)
+
+            subject.percolate :index => 'foo', :body => {}
+          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/_percolate', url
+            assert_equal Hash.new, params
+            assert_equal 'bar', body[:doc][:foo]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.percolate :index => 'foo', :type => 'bar', :body => { :doc => { :foo => 'bar' } }
+        end
+
+      end
+
+    end
+  end
+end

data/test/unit/ping_test.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class PingTest < ::Test::Unit::TestCase
+
+      context "Indices: Exists" do
+        subject { FakeClient.new }
+
+         should "perform correct request" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'HEAD', method
+            assert_equal '', url
+            assert_equal Hash.new, params
+            assert_nil   body
+            true
+          end.returns(FakeResponse.new)
+
+          subject.ping
+        end
+
+        should "return true for successful response" do
+          subject.expects(:perform_request).returns(FakeResponse.new 200, 'OK')
+          assert_equal true, subject.ping
+        end
+
+        should "return false for 404 response" do
+          subject.expects(:perform_request).returns(FakeResponse.new 404, 'Not Found')
+          assert_equal false, subject.ping
+        end
+
+        should "return false on 'not found' exceptions" do
+          subject.expects(:perform_request).raises(StandardError.new '404 NotFound')
+          assert_equal false, subject.ping
+        end
+
+        should "re-raise generic exceptions" do
+          subject.expects(:perform_request).raises(StandardError)
+          assert_raise(StandardError) do
+            assert_equal false, subject.ping
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/test/unit/scroll_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class ScrollTest < ::Test::Unit::TestCase
+
+      context "Scroll" 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 '_search/scroll', url
+            assert_equal 'cXVlcn...', params[:scroll_id]
+            assert_nil   body
+            true
+          end.returns(FakeResponse.new)
+
+          subject.scroll :scroll_id => 'cXVlcn...'
+        end
+
+      end
+
+    end
+  end
+end

data/test/unit/search_test.rb

@@ -0,0 +1,93 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class SearchTest < ::Test::Unit::TestCase
+
+      context "Search" 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 '_search', url
+            assert_equal Hash.new, params
+            assert_nil   body
+            true
+          end.returns(FakeResponse.new)
+
+          subject.search
+        end
+
+        should "have default value for index" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'GET', method
+            assert_equal '_all/foo/_search', url
+            true
+          end.returns(FakeResponse.new)
+
+          subject.search type: 'foo'
+        end
+
+        should "post a request definition in body" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal :match, body[:query].keys.first
+            true
+          end.returns(FakeResponse.new)
+
+          subject.search :body => { :query => { :match => {} } }
+        end
+
+        should "perform request against an index" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo/_search', url
+            true
+          end.returns(FakeResponse.new)
+
+          subject.search :index => 'foo'
+        end
+
+        should "perform request against an index and type" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo/bar/_search', url
+            true
+          end.returns(FakeResponse.new)
+
+          subject.search :index => 'foo', :type => 'bar'
+        end
+
+        should "perform request against multiple indices" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo,bar/_search', url
+            true
+          end.returns(FakeResponse.new).twice
+
+          subject.search :index => ['foo', 'bar']
+          subject.search :index => 'foo,bar'
+        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/_search', url
+            true
+          end.returns(FakeResponse.new).twice
+
+          subject.search :index => ['foo', 'bar'], :type => ['lam', 'bam']
+          subject.search :index => 'foo,bar', :type => 'lam,bam'
+        end
+
+        should "encode URL parameters" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal '_search', url
+            assert_equal 'count', params[:search_type]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.search :search_type => 'count'
+        end
+
+      end
+
+    end
+  end
+end

data/test/unit/suggest_test.rb

@@ -0,0 +1,55 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class SuggestTest < ::Test::Unit::TestCase
+
+      context "Suggest" do
+        subject { FakeClient.new }
+
+        should "perform correct request" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'POST', method
+            assert_equal '_suggest', url
+            assert_equal Hash.new, params
+            assert_equal Hash.new, body
+            true
+          end.returns(FakeResponse.new)
+
+          subject.suggest :body => {}
+        end
+
+        should "perform request against an index" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo/_suggest', url
+            true
+          end.returns(FakeResponse.new)
+
+          subject.suggest :index => 'foo', :body => {}
+        end
+
+        should "pass the URL parameters" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo/_suggest', url
+            assert_equal 'abc123', params[:routing]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.suggest :index => 'foo', :routing => 'abc123', :body => {}
+        end
+
+        should "pass the request definition in the body" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal '_suggest', url
+            assert_equal 'tset', body[:my_suggest][:text]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.suggest :body => { :my_suggest => { :text => 'tset' } }
+        end
+
+      end
+
+    end
+  end
+end