elasticsearch-api 0.0.2

data/test/unit/indices/snapshot_index_test.rb

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

data/test/unit/indices/stats_test.rb

@@ -0,0 +1,76 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class IndicesStatsTest < ::Test::Unit::TestCase
+
+      context "Indices: Stats" 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 '_stats', url
+            assert_equal Hash.new, params
+            assert_nil   body
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.stats
+        end
+
+        should "perform request against an index" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo/_stats', url
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.stats :index => 'foo'
+        end
+
+        should "perform request against multiple indices" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo,bar/_stats', url
+            true
+          end.returns(FakeResponse.new).twice
+
+          subject.indices.stats :index => ['foo','bar']
+          subject.indices.stats :index => 'foo,bar'
+        end
+
+        should "pass the URL parameters" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo/_stats', url
+            assert_equal true, params[:fielddata]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.stats :index => 'foo', :fielddata => true
+        end
+
+        should "pass the fields parameter as a list" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo/_stats', url
+            assert_equal true, params[:fielddata]
+            assert_equal 'foo,bar', params[:fields]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.stats :index => 'foo', :fielddata => true, :fields => ['foo', 'bar']
+        end
+
+        should "pass the groups parameter as a list" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal '_stats', url
+            assert_equal 'groupA,groupB', params[:groups]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.stats :search => true, :groups => ['groupA','groupB']
+        end
+
+      end
+
+    end
+  end
+end

data/test/unit/indices/status_test.rb

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

data/test/unit/indices/update_aliases_test.rb

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

data/test/unit/indices/validate_query_test.rb

@@ -0,0 +1,75 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class IndicesValidateQueryTest < ::Test::Unit::TestCase
+
+      context "Indices: Validate query" 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 '_validate/query', url
+            assert_equal Hash.new, params
+            assert_nil body
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.validate_query
+        end
+
+        should "perform request against an index" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo/_validate/query', url
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.validate_query :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/_validate/query', url
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.validate_query :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/_validate/query', url
+            true
+          end.returns(FakeResponse.new).twice
+
+          subject.indices.validate_query :index => ['foo', 'bar']
+          subject.indices.validate_query :index => 'foo,bar'
+        end
+
+        should "pass the URL parameters" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal '_validate/query', url
+            assert_equal true, params[:explain]
+            assert_equal 'foo', params[:q]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.validate_query :explain => true, :q => 'foo'
+        end
+
+        should "pass the query definition in body" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal '_validate/query', url
+            assert_equal Hash.new, body[:filtered]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.indices.validate_query :body => { :filtered => {} }
+        end
+
+      end
+
+    end
+  end
+end

data/test/unit/info_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class InfoTest < ::Test::Unit::TestCase
+
+      context "Info" 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 '', url
+            assert_equal Hash.new, params
+            assert_nil   body
+            true
+          end.returns(FakeResponse.new)
+
+          subject.info
+        end
+
+      end
+
+    end
+  end
+end

data/test/unit/json_builders_test.rb

@@ -0,0 +1,64 @@
+require 'test_helper'
+
+require 'jbuilder'
+require 'jsonify'
+
+module Elasticsearch
+  module Test
+    class JsonBuildersTest < ::Test::Unit::TestCase
+
+      context "JBuilder" do
+        subject { FakeClient.new }
+
+        should "build a JSON" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            json = MultiJson.load(body)
+
+            assert_instance_of String, body
+            assert_equal       'test', json['query']['match']['title']['query']
+            true
+          end.returns(FakeResponse.new)
+
+          json = Jbuilder.encode do |json|
+                   json.query do
+                     json.match do
+                       json.title do
+                         json.query    'test'
+                       end
+                     end
+                   end
+                 end
+
+          subject.search :body => json
+        end
+      end
+
+      context "Jsonify" do
+        subject { FakeClient.new }
+
+        should "build a JSON" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            json = MultiJson.load(body)
+
+            assert_instance_of String, body
+            assert_equal       'test', json['query']['match']['title']['query']
+            true
+          end.returns(FakeResponse.new)
+
+          json = Jsonify::Builder.compile do |json|
+                   json.query do
+                     json.match do
+                       json.title do
+                         json.query    'test'
+                       end
+                     end
+                   end
+                 end
+
+          subject.search :body => json
+        end
+      end
+
+    end
+  end
+end

data/test/unit/mget_test.rb

@@ -0,0 +1,70 @@
+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 "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