elasticsearch-api 0.0.2

data/test/unit/create_document_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class IndexDocumentTest < ::Test::Unit::TestCase
+
+      context "Creating a document with the #create method" do
+        subject { FakeClient.new }
+
+        should "perform the create request" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'POST', method
+            assert_equal 'foo/bar', url
+            assert_equal({:op_type => 'create'}, params)
+            assert_equal({:foo => 'bar'}, body)
+            true
+          end.returns(FakeResponse.new)
+
+          subject.create :index => 'foo', :type => 'bar', :body => {:foo => 'bar'}
+        end
+
+        should "perform the create request with a specific ID" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'PUT', method
+            assert_equal 'foo/bar/123', url
+            assert_equal 'create', params[:op_type]
+            assert_nil   params[:id]
+            assert_equal({:foo => 'bar'}, body)
+            true
+          end.returns(FakeResponse.new)
+
+          subject.create :index => 'foo', :type => 'bar', :id => '123', :body => {:foo => 'bar'}
+        end
+      end
+
+    end
+  end
+end

data/test/unit/delete_by_query_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class DeleteByQueryTest < ::Test::Unit::TestCase
+
+      context "Delete by query" do
+        subject { FakeClient.new }
+
+        should "require the :index argument" do
+          assert_raise ArgumentError do
+            subject.delete_by_query :body => {}
+          end
+        end
+
+        should "perform correct request" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'DELETE', method
+            assert_equal 'foo/_query', url
+            assert_equal Hash.new, params
+            assert_equal Hash.new, body[:term]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.delete_by_query :index => 'foo', :body => { :term => {} }
+        end
+
+        should "pass the query in URL parameters" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo/_query', url
+            assert_equal 'foo:bar', params[:q]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.delete_by_query :index => 'foo', :q => 'foo:bar'
+        end
+
+      end
+
+    end
+  end
+end

data/test/unit/delete_document_test.rb

@@ -0,0 +1,62 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class DeleteTest < ::Test::Unit::TestCase
+
+      context "Delete document" do
+        subject { FakeClient.new }
+
+        should "require the :index argument" do
+          assert_raise ArgumentError do
+            subject.delete :type => 'bar', :id => '1'
+          end
+        end
+
+        should "require the :type argument" do
+          assert_raise ArgumentError do
+            subject.delete :index => 'foo', :id => '1'
+          end
+        end
+
+        should "require the :id argument" do
+          assert_raise ArgumentError do
+            subject.delete :index => 'foo', :type => 'bar'
+          end
+        end
+
+        should "perform correct request" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'DELETE', method
+            assert_equal 'foo/bar/1', url
+            assert_equal Hash.new, params
+            assert_nil   body
+            true
+          end.returns(FakeResponse.new)
+
+          subject.delete :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', url
+            assert_equal 'abc123', params[:routing]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.delete :index => 'foo', :type => 'bar', :id => '1', :routing => 'abc123'
+        end
+
+        should "catch a NotFound exception with the ignore parameter" do
+          subject.expects(:perform_request).raises(NotFound)
+
+          assert_nothing_raised do
+            subject.get :index => 'foo', :type => 'bar', :id => 'XXX', ignore: 404
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/test/unit/exists_document_test.rb

@@ -0,0 +1,76 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class ExistsTest < ::Test::Unit::TestCase
+
+      context "Exists document" do
+        subject { FakeClient.new }
+
+        should "require the :index argument" do
+          assert_raise ArgumentError do
+            subject.exists :type => 'bar', :id => '1'
+          end
+        end
+
+        should "NOT require the :type argument" do
+          assert_nothing_raised do
+            subject.exists :index => 'foo', :id => '1'
+          end
+        end
+
+        should "require the :id argument" do
+          assert_raise ArgumentError do
+            subject.exists :index => 'foo', :type => 'bar'
+          end
+        end
+
+        should "perform correct request" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'HEAD', method
+            assert_equal 'foo/bar/1', url
+            assert_equal Hash.new, params
+            assert_nil   body
+            true
+          end.returns(FakeResponse.new)
+
+          subject.exists :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', url
+            assert_equal 'abc123', params[:routing]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.exists :index => 'foo', :type => 'bar', :id => '1', :routing => 'abc123'
+        end
+
+        should "return true for successful response" do
+          subject.expects(:perform_request).returns(FakeResponse.new 200, 'OK')
+          assert_equal true, subject.exists(:index => 'foo', :type => 'bar', :id => '1')
+        end
+
+        should "return false for 404 response" do
+          subject.expects(:perform_request).returns(FakeResponse.new 404, 'Not Found')
+          assert_equal false, subject.exists(:index => 'foo', :type => 'bar', :id => '1')
+        end
+
+        should "return false on 'not found' exceptions" do
+          subject.expects(:perform_request).raises(StandardError.new '404 NotFound')
+          assert_equal false, subject.exists(:index => 'foo', :type => 'bar', :id => '1')
+        end
+
+        should "re-raise generic exceptions" do
+          subject.expects(:perform_request).raises(StandardError)
+          assert_raise(StandardError) do
+            assert_equal false, subject.exists(:index => 'foo', :type => 'bar', :id => '1')
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/test/unit/explain_document_test.rb

@@ -0,0 +1,64 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class ExplainTest < ::Test::Unit::TestCase
+
+      context "Explain document" do
+        subject { FakeClient.new }
+
+        should "require the :index argument" do
+          assert_raise ArgumentError do
+            subject.explain :type => 'bar', :id => '1'
+          end
+        end
+
+        should "require the :type argument" do
+          assert_raise ArgumentError do
+            subject.explain :index => 'foo', :id => '1'
+          end
+        end
+
+        should "require the :id argument" do
+          assert_raise ArgumentError do
+            subject.explain :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/_explain', url
+            assert_equal Hash.new, params
+            assert_equal Hash.new, body
+            true
+          end.returns(FakeResponse.new)
+
+          subject.explain :index => 'foo', :type => 'bar', :id => 1, :body => {}
+        end
+
+        should "pass the query in URL parameters" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo/bar/1/_explain', url
+            assert_equal 'foo', params[:q]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.explain :index => 'foo', :type => 'bar', :id => 1, :q => 'foo'
+        end
+
+        should "pass the request definition in the body" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo/bar/1/_explain', url
+            assert_equal Hash.new, body[:query][:match]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.explain :index => 'foo', :type => 'bar', :id => 1, :body => { :query => { :match => {} } }
+        end
+
+      end
+
+    end
+  end
+end

data/test/unit/get_document_source_test.rb

@@ -0,0 +1,62 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class GetSourceTest < ::Test::Unit::TestCase
+
+      context "Get document source" do
+        subject { FakeClient.new }
+
+        should "require the :index argument" do
+          assert_raise ArgumentError do
+            subject.get_source :type => 'bar', :id => '1'
+          end
+        end
+
+        should "NOT require the :type argument" do
+          assert_nothing_raised do
+            subject.get_source :index => 'foo', :id => '1'
+          end
+        end
+
+        should "require the :id argument" do
+          assert_raise ArgumentError do
+            subject.get_source :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/_source', url
+            assert_equal Hash.new, params
+            assert_nil   body
+            true
+          end.returns(FakeResponse.new)
+
+          subject.get_source :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/_source', url
+            assert_equal 'abc123', params[:routing]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.get_source :index => 'foo', :type => 'bar', :id => '1', :routing => 'abc123'
+        end
+
+        should "catch a NotFound exception with the ignore parameter" do
+          subject.expects(:perform_request).raises(NotFound)
+
+          assert_nothing_raised do
+            subject.get :index => 'foo', :type => 'bar', :id => 'XXX', ignore: 404
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/test/unit/get_document_test.rb

@@ -0,0 +1,62 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class GetTest < ::Test::Unit::TestCase
+
+      context "Get document" do
+        subject { FakeClient.new }
+
+        should "require the :index argument" do
+          assert_raise ArgumentError do
+            subject.get :type => 'bar', :id => '1'
+          end
+        end
+
+        should "NOT require the :type argument" do
+          assert_nothing_raised do
+            subject.get :index => 'foo', :id => '1'
+          end
+        end
+
+        should "require the :id argument" do
+          assert_raise ArgumentError do
+            subject.get :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', url
+            assert_equal Hash.new, params
+            assert_nil   body
+            true
+          end.returns(FakeResponse.new)
+
+          subject.get :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', url
+            assert_equal 'abc123', params[:routing]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.get :index => 'foo', :type => 'bar', :id => '1', :routing => 'abc123'
+        end
+
+        should "catch a NotFound exception with the ignore parameter" do
+          subject.expects(:perform_request).raises(NotFound)
+
+          assert_nothing_raised do
+            subject.get :index => 'foo', :type => 'bar', :id => 'XXX', ignore: 404
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/test/unit/hashie_test.rb

@@ -0,0 +1,78 @@
+require 'test_helper'
+
+require 'hashie'
+
+module Elasticsearch
+  module Test
+    class HashieTest < ::Test::Unit::TestCase
+
+      context "Hashie" do
+        subject { FakeClient.new }
+
+        should "wrap the response" do
+          json =<<-JSON
+            {
+              "took": 14,
+              "timed_out": false,
+              "_shards": {
+                "total": 1,
+                "successful": 1,
+                "failed": 0
+              },
+              "hits": {
+                "total": 5,
+                "max_score": 0.51104903,
+                "hits": [
+                  {
+                    "_index": "myindex",
+                    "_type": "mytype",
+                    "_id": "1",
+                    "_score": 0.51104903,
+                    "_source": {
+                      "title": "Test 1",
+                      "tags": [
+                        "y",
+                        "z"
+                      ],
+                      "published": true,
+                      "published_at": "2013-06-22T21:13:00Z",
+                      "counter": 1
+                    }
+                  }
+                ]
+              },
+              "facets": {
+                "tags": {
+                  "_type": "terms",
+                  "missing": 0,
+                  "total": 10,
+                  "other": 0,
+                  "terms": [
+                    {
+                      "term": "z",
+                      "count": 4
+                    },
+                    {
+                      "term": "y",
+                      "count": 3
+                    },
+                    {
+                      "term": "x",
+                      "count": 3
+                    }
+                  ]
+                }
+              }
+            }
+          JSON
+
+          response = Hashie::Mash.new MultiJson.load(json)
+
+          assert_equal 'Test 1', response.hits.hits.first._source.title
+          assert_equal 'z',      response.facets.tags.terms.first.term
+        end
+      end
+
+    end
+  end
+end