elasticsearch-api 0.0.2

data/test/unit/index_document_test.rb

@@ -0,0 +1,77 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class IndexDocumentTest < ::Test::Unit::TestCase
+
+      context "Indexing a document" do
+        subject { FakeClient.new }
+
+        should "require the :index argument" do
+          assert_raise ArgumentError do
+            subject.index :type => 'foo'
+          end
+        end
+
+        should "require the :type argument" do
+          assert_raise ArgumentError do
+            subject.index :index => 'foo'
+          end
+        end
+
+        should "perform the index request" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'POST', method
+            assert_equal 'foo/bar', url
+            assert_equal({:foo => 'bar'}, body)
+            true
+          end.returns(FakeResponse.new)
+
+          subject.index :index => 'foo', :type => 'bar', :body => {:foo => 'bar'}
+        end
+
+        should "perform the index 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_nil   params[:id]
+            assert_equal({:foo => 'bar'}, body)
+            true
+          end.returns(FakeResponse.new)
+
+          subject.index :index => 'foo', :type => 'bar', :id => '123', :body => {:foo => 'bar'}
+        end
+      end
+
+      context "Creating a document" 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.index :index => 'foo', :type => 'bar', :op_type => 'create', :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.index :index => 'foo', :type => 'bar', :id => '123', :op_type => 'create', :body => {:foo => 'bar'}
+        end
+      end
+
+    end
+  end
+end

data/test/unit/indices/analyze_test.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class IndicesAnalyzeTest < ::Test::Unit::TestCase
+
+      context "Indices: Analyze" 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 '_analyze', url
+            assert_equal Hash.new, params
+            assert_nil body
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.analyze
+        end
+
+        should "perform request against an index" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo/_analyze', url
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.analyze :index => 'foo'
+        end
+
+        should "pass the URL parameters" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal '_analyze', url
+            assert_equal 'foo', params[:text]
+            assert_equal 'bar', params[:analyzer]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.analyze :text => 'foo', :analyzer => 'bar'
+        end
+
+        should "pass the text in body" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal '_analyze', url
+            assert_equal Hash.new, params
+            assert_equal 'foo', body
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.analyze :body => 'foo'
+        end
+
+        should "pass the filters parameter as a list" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal '_analyze', url
+            assert_equal 'foo,bar', params[:filters]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.analyze :text => 'Test', :tokenizer => 'whitespace', :filters => ['foo,bar']
+        end
+
+      end
+
+    end
+  end
+end

data/test/unit/indices/clear_cache_test.rb

@@ -0,0 +1,45 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class IndicesClearCacheTest < ::Test::Unit::TestCase
+
+      context "Indices: Clear cache" 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 '_cache/clear', url
+            assert_equal Hash.new, params
+            assert_nil   body
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.clear_cache
+        end
+
+        should "perform request against an index" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo/_cache/clear', url
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.clear_cache :index => 'foo'
+        end
+
+        should "pass the URL parameters" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal '_cache/clear', url
+            assert_equal true, params[:field_data]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.clear_cache :field_data => true
+        end
+
+      end
+
+    end
+  end
+end

data/test/unit/indices/close_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class IndicesCloseTest < ::Test::Unit::TestCase
+
+      context "Indices: Close" do
+        subject { FakeClient.new }
+
+        should "require the :index argument" do
+          assert_raise ArgumentError do
+            subject.indices.close
+          end
+        end
+
+        should "perform correct request" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'POST', method
+            assert_equal 'foo/_close', url
+            assert_equal Hash.new, params
+            assert_nil   body
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.close :index => 'foo'
+        end
+
+        should "pass the URL parameters" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo/_close', url
+            assert_equal '1s', params[:timeout]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.close :index => 'foo', :timeout => '1s'
+        end
+
+      end
+
+    end
+  end
+end

data/test/unit/indices/create_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class IndicesCreateTest < ::Test::Unit::TestCase
+
+      context "Indices: Create" do
+        subject { FakeClient.new }
+
+        should "require the :index argument" do
+          assert_raise ArgumentError do
+            subject.indices.create
+          end
+        end
+
+        should "perform correct request" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'PUT', method
+            assert_equal 'foo', url
+            assert_equal Hash.new, params
+            assert_nil   body
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.create :index => 'foo'
+        end
+
+        should "pass the URL parameters" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo', url
+            assert_equal '1s', params[:timeout]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.create :index => 'foo', :timeout => '1s'
+        end
+
+      end
+
+    end
+  end
+end

data/test/unit/indices/delete_alias_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class IndicesDeleteAliasTest < ::Test::Unit::TestCase
+
+      context "Indices: Delete alias" do
+        subject { FakeClient.new }
+
+        should "require the :index argument" do
+          assert_raise ArgumentError do
+            subject.indices.delete_alias :name => 'bar'
+          end
+        end
+
+        should "require the :name argument" do
+          assert_raise ArgumentError do
+            subject.indices.delete_alias :index => 'foo'
+          end
+        end
+
+        should "perform correct request" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'DELETE', method
+            assert_equal 'foo/_alias/bar', url
+            assert_equal Hash.new, params
+            assert_nil   body
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.delete_alias :index => 'foo', :name => 'bar'
+        end
+
+      end
+
+    end
+  end
+end

data/test/unit/indices/delete_mapping_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class IndicesDeleteMappingTest < ::Test::Unit::TestCase
+
+      context "Indices: Delete mapping" do
+        subject { FakeClient.new }
+
+        should "require the :index argument" do
+          assert_raise ArgumentError do
+            subject.indices.delete_mapping :type => 'bar'
+          end
+        end
+
+        should "require the :type argument" do
+          assert_raise ArgumentError do
+            subject.indices.delete_mapping :index => 'foo'
+          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', url
+            assert_equal Hash.new, params
+            assert_nil   body
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.delete_mapping :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/baz', url
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.delete_mapping :index => ['foo','bar'], :type => 'baz'
+        end
+
+      end
+
+    end
+  end
+end

data/test/unit/indices/delete_template_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class IndicesDeleteTemplateTest < ::Test::Unit::TestCase
+
+      context "Indices: Delete template" do
+        subject { FakeClient.new }
+
+        should "perform correct request" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'DELETE', method
+            assert_equal '_template/foo', url
+            assert_equal Hash.new, params
+            assert_nil   body
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.delete_template :name => 'foo'
+        end
+
+      end
+
+    end
+  end
+end

data/test/unit/indices/delete_test.rb

@@ -0,0 +1,45 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class IndicesDeleteTest < ::Test::Unit::TestCase
+
+      context "Indices: Delete" do
+        subject { FakeClient.new }
+
+        should "perform correct request" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'DELETE', method
+            assert_equal 'foo', url
+            assert_equal Hash.new, params
+            assert_nil   body
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.delete :index => 'foo'
+        end
+
+        should "perform the request for more indices" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo,bar', url
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.delete :index => ['foo','bar']
+        end
+
+        should "pass the URL parameters" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo', url
+            assert_equal '1s', params[:timeout]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.delete :index => 'foo', :timeout => '1s'
+        end
+
+      end
+
+    end
+  end
+end

data/test/unit/indices/delete_warmer_test.rb

@@ -0,0 +1,59 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class IndicesDeleteWarmerTest < ::Test::Unit::TestCase
+
+      context "Indices: Delete warmer" do
+        subject { FakeClient.new }
+
+        should "require the :index argument" do
+          assert_raise ArgumentError do
+            subject.indices.delete_warmer
+          end
+        end
+
+        should "perform correct request" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'DELETE', method
+            assert_equal 'foo/_warmer', url
+            assert_equal Hash.new, params
+            assert_nil   body
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.delete_warmer :index => 'foo'
+        end
+
+        should "perform request against multiple indices" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo,bar/_warmer', url
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.delete_warmer :index => ['foo','bar']
+        end
+
+        should "perform request against single warmer" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo/_warmer/bar', url
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.delete_warmer :index => 'foo', :name => 'bar'
+        end
+
+        should "perform request against multiple warmers" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo/_warmer/bar,baz', url
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.delete_warmer :index => 'foo', :name => ['bar', 'baz']
+        end
+
+      end
+
+    end
+  end
+end