elasticsearch-api 6.0.1 → 7.0.0

data/test/unit/search_exists_test.rb

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

data/test/unit/search_shards_test.rb

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

data/test/unit/search_template_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class SearchTemplateTest < ::Test::Unit::TestCase
-
-      context "Search template" 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 'foo/_search/template', url
-            assert_equal Hash.new, params
-            assert_equal 'bar', body[:foo]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.search_template :index => 'foo', :body => { :foo => 'bar' }
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/search_test.rb

@@ -1,116 +0,0 @@
-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
-
-        should "validate URL parameters" do
-          assert_raise ArgumentError do
-            subject.search :search_type => 'count', :qwertypoiuy => 'asdflkjhg'
-          end
-        end
-
-        should "URL-escape the parts" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo%5Ebar/bar%2Fbam/_search', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.search :index => 'foo^bar', :type => 'bar/bam'
-        end
-
-        should "not URL-escape the fields parameters" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo^bar', params[:fields]
-            true
-          end.returns(FakeResponse.new)
-
-          subject.search :index => 'foo', :type => 'bar', :fields => 'foo^bar'
-        end
-      end
-
-    end
-  end
-end

data/test/unit/snapshot/create_repository_test.rb

@@ -1,38 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class SnapshotCreateRepositoryTest < ::Test::Unit::TestCase
-
-      context "Snapshot: Create repository" do
-        subject { FakeClient.new }
-
-        should "require the :repository argument" do
-          assert_raise ArgumentError do
-            subject.snapshot.create_repository :body => {}
-          end
-        end
-
-        should "require the :body argument" do
-          assert_raise ArgumentError do
-            subject.snapshot.create_repository :repository => 'foo'
-          end
-        end
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'PUT', method
-            assert_equal '_snapshot/foo', url
-            assert_equal Hash.new, params
-            assert_equal Hash.new, body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.snapshot.create_repository :repository => 'foo', :body => {}
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/snapshot/create_test.rb

@@ -1,38 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class SnapshotCreateTest < ::Test::Unit::TestCase
-
-      context "Snapshot: Create" do
-        subject { FakeClient.new }
-
-        should "require the :repository argument" do
-          assert_raise ArgumentError do
-            subject.snapshot.create :snapshot => 'bar', :body => {}
-          end
-        end
-
-        should "require the :snapshot argument" do
-          assert_raise ArgumentError do
-            subject.snapshot.create :repository => 'foo', :body => {}
-          end
-        end
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'PUT', method
-            assert_equal '_snapshot/foo/bar', url
-            assert_equal Hash.new, params
-            assert_equal Hash.new, body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.snapshot.create :repository => 'foo', :snapshot => 'bar', :body => {}
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/snapshot/delete_repository_test.rb

@@ -1,35 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class SnapshotDeleteRepositoryTest < ::Test::Unit::TestCase
-
-      context "Snapshot: Delete repository" 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 '_snapshot/foo', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.snapshot.delete_repository :repository => 'foo'
-        end
-
-        should "perform the request for more indices" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal '_snapshot/foo,bar', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.snapshot.delete_repository :repository => ['foo','bar']
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/snapshot/delete_test.rb

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

data/test/unit/snapshot/get_repository_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class SnapshotGetRepositoryTest < ::Test::Unit::TestCase
-
-      context "Snapshot: Get repository" 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 '_snapshot/foo', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.snapshot.get_repository :repository => 'foo'
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/snapshot/get_test.rb

@@ -1,38 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class SnapshotGetTest < ::Test::Unit::TestCase
-
-      context "Snapshot: Get" do
-        subject { FakeClient.new }
-
-        should "require the :repository argument" do
-          assert_raise ArgumentError do
-            subject.snapshot.get :snapshot => 'bar', :body => {}
-          end
-        end
-
-        should "require the :snapshot argument" do
-          assert_raise ArgumentError do
-            subject.snapshot.get :repository => '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 '_snapshot/foo/bar', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.snapshot.get :repository => 'foo', :snapshot => 'bar'
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/snapshot/restore_test.rb

@@ -1,38 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class SnapshotRestoreTest < ::Test::Unit::TestCase
-
-      context "Snapshot: Restore" do
-        subject { FakeClient.new }
-
-        should "require the :repository argument" do
-          assert_raise ArgumentError do
-            subject.snapshot.restore :snapshot => 'bar'
-          end
-        end
-
-        should "require the :snapshot argument" do
-          assert_raise ArgumentError do
-            subject.snapshot.restore :repository => 'foo'
-          end
-        end
-
-        should "perform correct request" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'POST', method
-            assert_equal '_snapshot/foo/bar/_restore', url
-            assert_equal Hash.new, params
-            assert_equal nil, body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.snapshot.restore :repository => 'foo', :snapshot => 'bar'
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/snapshot/status_test.rb

@@ -1,38 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class SnapshotStatusTest < ::Test::Unit::TestCase
-
-      context "Snapshot: 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 '_snapshot/_status', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.snapshot.status
-        end
-
-        should "encode repository and snapshot" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'GET', method
-            assert_equal '_snapshot/foo/bar/_status', url
-            assert_equal Hash.new, params
-            assert_equal nil, body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.snapshot.status :repository => 'foo', :snapshot => 'bar'
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/snapshot/verify_repository_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class SnapshotVerifyRepositoryTest < ::Test::Unit::TestCase
-
-      context "Snapshot: Verify repository" 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 '_snapshot/foo/_verify', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.snapshot.verify_repository :repository => 'foo'
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/suggest_test.rb

@@ -1,64 +0,0 @@
-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 "URL-escape the parts" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'foo%5Ebar/_suggest', url
-            true
-          end.returns(FakeResponse.new)
-
-          subject.suggest :index => 'foo^bar', :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

data/test/unit/tasks/cancel_test.rb

@@ -1,38 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class TasksCancelTest < ::Test::Unit::TestCase
-
-      context "Tasks: Cancel" 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 '_tasks/_cancel', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.tasks.cancel
-        end
-
-        should "perform correct request with a task_id" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'POST', method
-            assert_equal '_tasks/foo/_cancel', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.tasks.cancel :task_id => 'foo'
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/tasks/get_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class TasksGetTest < ::Test::Unit::TestCase
-
-      context "Tasks: Get" 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 '_tasks/foo1', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.tasks.get :task_id => 'foo1'
-        end
-
-      end
-
-    end
-  end
-end

data/test/unit/tasks/list_test.rb

@@ -1,38 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    class TasksListTest < ::Test::Unit::TestCase
-
-      context "Tasks: List" 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 '_tasks', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.tasks.list
-        end
-
-        should "perform correct request with :task_id" do
-          subject.expects(:perform_request).with do |method, url, params, body|
-            assert_equal 'GET', method
-            assert_equal '_tasks/foo', url
-            assert_equal Hash.new, params
-            assert_nil   body
-            true
-          end.returns(FakeResponse.new)
-
-          subject.tasks.list :task_id => 'foo'
-        end
-
-      end
-
-    end
-  end
-end