logstash-filter-cache-redis 0.1.0 → 0.2.0

data/vendor/bundle/jruby/1.9/gems/elasticsearch-api-5.0.4/test/unit/list_benchmarks_test.rb

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

data/vendor/bundle/jruby/1.9/gems/elasticsearch-api-5.0.4/test/unit/mget_test.rb

@@ -0,0 +1,79 @@
+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 "URL-escape the parts" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo%5Ebar/bar%2Fbam/_mget', url
+            true
+          end.returns(FakeResponse.new)
+
+          subject.mget :index => 'foo^bar', :type => 'bar/bam', :body => { :ids => ['1','2'] }
+        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

data/vendor/bundle/jruby/1.9/gems/elasticsearch-api-5.0.4/test/unit/mlt_test.rb

@@ -0,0 +1,89 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class MltTest < ::Test::Unit::TestCase
+
+      context "More Like This" do
+        subject { FakeClient.new }
+
+        should "require the :index argument" do
+          assert_raise ArgumentError do
+            subject.mlt :type => 'bar', :id => '1'
+          end
+        end
+
+        should "require the :type argument" do
+          assert_raise ArgumentError do
+            subject.mlt :index => 'foo', :id => '1'
+          end
+        end
+
+        should "require the :id argument" do
+          assert_raise ArgumentError do
+            subject.mlt :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/_mlt', url
+            assert_equal Hash.new, params
+            assert_nil   body
+            true
+          end.returns(FakeResponse.new)
+
+          subject.mlt :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/_mlt', url
+            assert_equal 1, params[:max_doc_freq]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.mlt :index => 'foo', :type => 'bar', :id => '1', :max_doc_freq => 1
+        end
+
+        should "URL-escape the parts" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo%5Ebar/bar%2Fbam/1/_mlt', url
+            true
+          end.returns(FakeResponse.new)
+
+          subject.mlt :index => 'foo^bar', :type => 'bar/bam', :id => '1'
+        end
+
+        should "pass the specific parameters as a list" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo,bar', params[:mlt_fields]
+            assert_equal 'A,B',     params[:search_indices]
+            assert_equal 'X,Y',     params[:search_types]
+            assert_equal 'lam,bam', params[:stop_words]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.mlt :index => 'foo', :type => 'bar', :id => '1',
+                      :mlt_fields     => ['foo', 'bar'],
+                      :search_indices => ['A', 'B'],
+                      :search_types   => ['X', 'Y'],
+                      :stop_words     => ['lam','bam']
+        end
+
+        should "pass a specific search definition in body" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo/bar/1/_mlt', url
+            assert_equal Hash.new, body[:query]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.mlt :index => 'foo', :type => 'bar', :id => '1', :body => { :query => {} }
+        end
+
+      end
+
+    end
+  end
+end

data/vendor/bundle/jruby/1.9/gems/elasticsearch-api-5.0.4/test/unit/mpercolate_test.rb

@@ -0,0 +1,51 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class MpercolateTest < ::Test::Unit::TestCase
+
+      context "Mpercolate" do
+        subject { FakeClient.new }
+
+        should "require the :body argument" do
+          assert_raise ArgumentError do
+            subject.mpercolate
+          end
+        end
+
+        should "post correct payload to the endpoint" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'GET', method
+            assert_equal '_mpercolate', url
+            assert_equal Hash.new, params
+
+            lines = body.split("\n")
+            assert_match /\{"percolate"/, lines[0]
+            assert_match /\{"doc"/,       lines[1]
+            assert_match /\{"percolate"/, lines[2]
+            assert_match /\{\}/,          lines[3]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.mpercolate :body => [
+            { :percolate => { :index => "my-index", :type => "my-type" } },
+            { :doc => { :message => "foo bar" } },
+            { :percolate => { :index => "my-other-index", :type => "my-other-type", :id => "1" } },
+            { }
+          ]
+        end
+
+        should "post a string payload intact" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal %Q|{"foo":"bar"}\n{"moo":"lam"}|, body
+            true
+          end.returns(FakeResponse.new)
+
+          subject.mpercolate :body => %Q|{"foo":"bar"}\n{"moo":"lam"}|
+        end
+
+      end
+
+    end
+  end
+end

data/vendor/bundle/jruby/1.9/gems/elasticsearch-api-5.0.4/test/unit/msearch_test.rb

@@ -0,0 +1,129 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class MsearchTest < ::Test::Unit::TestCase
+
+      context "Msearch" do
+        subject { FakeClient.new }
+
+        should "require the :body argument" do
+          assert_raise ArgumentError do
+            subject.msearch
+          end
+        end
+
+        should "post correct payload to the endpoint" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'GET', method
+            assert_equal '_msearch', url
+            assert_equal Hash.new, params
+            assert_equal <<-PAYLOAD.gsub(/^\s+/, ''), body
+            {"index":"foo"}
+            {"query":{"match_all":{}}}
+            {"index":"bar"}
+            {"query":{"match":{"foo":"bar"}}}
+            {"search_type":"count"}
+            {"facets":{"tags":{}}}
+            PAYLOAD
+            true
+          end.returns(FakeResponse.new)
+
+          subject.msearch :body => [
+            { :index => 'foo', :search => { :query => { :match_all => {}  } } },
+            { :index => 'bar', :search => { :query => { :match => { :foo => 'bar' } } } },
+            { :search_type => 'count', :search => { :facets => { :tags => {} } } }
+          ]
+        end
+
+        should "post a string payload intact" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal %Q|{"foo":"bar"}\n{"moo":"lam"}|, body
+            true
+          end.returns(FakeResponse.new)
+
+          subject.msearch :body => %Q|{"foo":"bar"}\n{"moo":"lam"}|
+        end
+
+        should "serialize and post header/data pairs" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'GET', method
+            assert_equal '_msearch', url
+            assert_equal Hash.new, params
+            assert_equal <<-PAYLOAD.gsub(/^\s+/, ''), body
+            {"index":"foo"}
+            {"query":{"match_all":{}}}
+            {"index":"bar"}
+            {"query":{"match":{"foo":"bar"}}}
+            PAYLOAD
+            true
+          end.returns(FakeResponse.new)
+
+          subject.msearch :body => [
+            { :index => 'foo' },
+            { :query => { :match_all => {}  } },
+            { :index => 'bar' },
+            { :query => { :match => { :foo => 'bar' } } }
+          ]
+        end
+
+        should "perform request against an index" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo/_msearch', url
+            true
+          end.returns(FakeResponse.new)
+
+          subject.msearch :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/_msearch', url
+            true
+          end.returns(FakeResponse.new)
+
+          subject.msearch :index => 'foo', :type => 'bar', :body => []
+        end
+
+        should "perform request against multiple indices" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo,bar/_msearch', url
+            true
+          end.returns(FakeResponse.new)
+
+          subject.msearch :index => ['foo', 'bar'], :body => []
+        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/_msearch', url
+            true
+          end.returns(FakeResponse.new)
+
+          subject.msearch :index => ['foo', 'bar'], :type => ['lam', 'bam'], :body => []
+        end
+
+        should "URL-escape the parts" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'foo%5Ebar/bar%2Fbam/_msearch', url
+            true
+          end.returns(FakeResponse.new)
+
+          subject.msearch :index => 'foo^bar', :type => 'bar/bam', :body => []
+        end
+
+        should "encode URL parameters" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal '_msearch', url
+            assert_equal 'scroll', params[:search_type]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.msearch :body => [], :search_type => 'scroll'
+        end
+
+      end
+
+    end
+  end
+end

data/vendor/bundle/jruby/1.9/gems/elasticsearch-api-5.0.4/test/unit/mtermvectors_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class MtermvectorsTest < ::Test::Unit::TestCase
+
+      context "Mtermvectors" 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 'my-index/my-type/_mtermvectors', url
+            assert_equal Hash.new, params
+            assert_equal [1, 2, 3], body[:ids]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.mtermvectors :index => 'my-index', :type => 'my-type', :body => { :ids => [1, 2, 3] }
+        end
+
+        should "allow passing a list of IDs instead of the body" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal 'GET', method
+            assert_equal 'my-index/my-type/_mtermvectors', url
+            assert_equal Hash.new, params
+            assert_equal [1, 2, 3], body[:ids]
+            true
+          end.returns(FakeResponse.new)
+
+          subject.mtermvectors :index => 'my-index', :type => 'my-type', :ids => [1, 2, 3]
+        end
+
+      end
+
+    end
+  end
+end

data/vendor/bundle/jruby/1.9/gems/elasticsearch-api-5.0.4/test/unit/nodes/hot_threads_test.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class NodesHotThreadsTest < ::Test::Unit::TestCase
+
+      context "Nodes: Hot Threads" 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 '_nodes/hot_threads', url
+            assert_equal Hash.new, params
+            assert_nil   body
+            true
+          end.returns(FakeResponse.new)
+
+          subject.nodes.hot_threads
+        end
+
+        should "send :node_id correctly" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal '_nodes/foo/hot_threads', url
+            true
+          end.returns(FakeResponse.new)
+
+          subject.nodes.hot_threads :node_id => 'foo'
+        end
+
+        should "URL-escape the parts" do
+          subject.expects(:perform_request).with do |method, url, params, body|
+            assert_equal '_nodes/foo%5Ebar/hot_threads', url
+            true
+          end.returns(FakeResponse.new)
+
+          subject.nodes.hot_threads :node_id => 'foo^bar'
+        end
+
+      end
+
+    end
+  end
+end