elasticsearch-api 0.0.2

data/test/unit/indices/open_test.rb

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

data/test/unit/indices/optimize_test.rb

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

data/test/unit/indices/put_alias_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class IndicesPutAliasTest < ::Test::Unit::TestCase
+
+      context "Indices: Put alias" do
+        subject { FakeClient.new }
+
+        should "require the :index argument" do
+          assert_raise ArgumentError do
+            subject.indices.put_alias :name => 'bar'
+          end
+        end
+
+        should "require the :name argument" do
+          assert_raise ArgumentError do
+            subject.indices.put_alias :index => 'foo'
+          end
+        end
+
+        should "perform correct request" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'PUT', method
+            assert_equal 'foo/_alias/bar', url
+            assert_equal Hash.new, params
+            assert_nil   body
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.put_alias :index => 'foo', :name => 'bar'
+        end
+
+        should "send the alias settings in :body" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo', body[:filter]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.put_alias :index => 'foo', :name => 'bar', :body => { :filter => 'foo' }
+        end
+
+      end
+
+    end
+  end
+end

data/test/unit/indices/put_mapping_test.rb

@@ -0,0 +1,57 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class IndicesPutMappingTest < ::Test::Unit::TestCase
+
+      context "Indices: Put mapping" do
+        subject { FakeClient.new }
+
+        should "require the :index argument" do
+          assert_raise ArgumentError do
+            subject.indices.put_mapping :type => 'bar'
+          end
+        end
+
+        should "require the :type argument" do
+          assert_raise ArgumentError do
+            subject.indices.put_mapping :index => 'foo'
+          end
+        end
+
+        should "perform correct request" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'PUT', method
+            assert_equal 'foo/bar/_mapping', url
+            assert_equal Hash.new, params
+            assert_equal({ :foo => {} }, body)
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.put_mapping :index => 'foo', :type => 'bar', :body => { :foo => {} }
+        end
+
+        should "perform request against multiple indices" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo,bar/bam/_mapping', url
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.put_mapping :index => ['foo','bar'], :type => 'bam', :body => {}
+        end
+
+        should "pass the URL parameters" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo/bar/_mapping', url
+            assert_equal true, params[:ignore_conflicts]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.put_mapping :index => 'foo', :type => 'bar', :body => {}, :ignore_conflicts => true
+        end
+
+      end
+
+    end
+  end
+end

data/test/unit/indices/put_settings_test.rb

@@ -0,0 +1,50 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class IndicesPutSettingsTest < ::Test::Unit::TestCase
+
+      context "Indices: Put settings" do
+        subject { FakeClient.new }
+
+        should "require the :body argument" do
+          assert_raise ArgumentError do
+            subject.indices.put_settings
+          end
+        end
+
+        should "perform correct request" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'PUT', method
+            assert_equal '_settings', url
+            assert_equal Hash.new, params
+            assert_equal Hash.new, body
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.put_settings :body => {}
+        end
+
+        should "perform request against a specific indices" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo/_settings', url
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.put_settings :index => 'foo', :body => {}
+        end
+
+        should "perform request against multiple indices" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo,bar/_settings', url
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.put_settings :index => ['foo','bar'], :body => {}
+        end
+
+      end
+
+    end
+  end
+end

data/test/unit/indices/put_template_test.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class IndicesPutTemplateTest < ::Test::Unit::TestCase
+
+      context "Indices: Put template" do
+        subject { FakeClient.new }
+
+        should "require the :name argument" do
+          assert_raise ArgumentError do
+            subject.indices.put_template :body => {}
+          end
+        end
+
+        should "require the :body argument" do
+          assert_raise ArgumentError do
+            subject.indices.put_template :name => 'foo'
+          end
+        end
+
+        should "perform correct request" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'PUT', method
+            assert_equal '_template/foo', url
+            assert_equal Hash.new, params
+            assert_equal 'bar', body[:template]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.put_template :name => 'foo', :body => { :template => 'bar' }
+        end
+
+         should "pass the URL parameters" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal '_template/foo', url
+            assert_equal 3, params[:order]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.put_template :name => 'foo', :body => {}, :order => 3
+        end
+
+      end
+
+    end
+  end
+end

data/test/unit/indices/put_warmer_test.rb

@@ -0,0 +1,62 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class IndicesPutWarmerTest < ::Test::Unit::TestCase
+
+      context "Indices: Put warmer" do
+        subject { FakeClient.new }
+
+        should "require the :index argument" do
+          assert_raise ArgumentError do
+            subject.indices.put_warmer :name => 'foo', :body => {}
+          end
+        end
+
+        should "require the :name argument" do
+          assert_raise ArgumentError do
+            subject.indices.put_warmer :index => 'foo', :body => {}
+          end
+        end
+
+        should "require the :body argument" do
+          assert_raise ArgumentError do
+            subject.indices.put_warmer :index => 'foo', :name => 'bar'
+          end
+        end
+
+        should "perform correct request" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'PUT', method
+            assert_equal 'foo/_warmer/bar', url
+            assert_equal Hash.new, params
+            assert_equal :match_all, body[:query].keys.first
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.put_warmer :index => 'foo', :name => 'bar', :body => { :query => { :match_all => {} } }
+        end
+
+        should "perform request against multiple indices" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo,bar/_warmer/xul', url
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.put_warmer :index => ['foo','bar'], :name => 'xul', :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/_warmer/xul', url
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.put_warmer :index => 'foo', :type => 'bar', :name => 'xul', :body => {}
+        end
+
+      end
+
+    end
+  end
+end

data/test/unit/indices/refresh_test.rb

@@ -0,0 +1,55 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class IndicesRefreshTest < ::Test::Unit::TestCase
+
+      context "Indices: Refresh" 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 '_refresh', url
+            assert_equal Hash.new, params
+            assert_nil   body
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.refresh
+        end
+
+        should "perform request against an index" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo/_refresh', url
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.refresh :index => 'foo'
+        end
+
+        should "perform request against multiple indices" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo,bar/_refresh', url
+            true
+          end.returns(FakeResponse.new).twice
+
+          subject.indices.refresh :index => ['foo','bar']
+          subject.indices.refresh :index => 'foo,bar'
+        end
+
+        should "pass the URL parameters" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo,bar/_refresh', url
+            assert_equal 'missing', params[:ignore_indices]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.refresh :index => ['foo','bar'], :ignore_indices => 'missing'
+        end
+
+      end
+
+    end
+  end
+end

data/test/unit/indices/segments_test.rb

@@ -0,0 +1,55 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class IndicesSegmentsTest < ::Test::Unit::TestCase
+
+      context "Indices: Segments" 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 '_segments', url
+            assert_equal Hash.new, params
+            assert_nil   body
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.segments
+        end
+
+        should "perform request against an index" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo/_segments', url
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.segments :index => 'foo'
+        end
+
+        should "perform request against multiple indices" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo,bar/_segments', url
+            true
+          end.returns(FakeResponse.new).twice
+
+          subject.indices.segments :index => ['foo','bar']
+          subject.indices.segments :index => 'foo,bar'
+        end
+
+        should "pass the URL parameters" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo,bar/_segments', url
+            assert_equal 'missing', params[:ignore_indices]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.segments :index => ['foo','bar'], :ignore_indices => 'missing'
+        end
+
+      end
+
+    end
+  end
+end