logstash-filter-cache-redis 0.1.0 → 0.2.0

data/vendor/bundle/jruby/1.9/gems/elasticsearch-transport-5.0.4/test/unit/transport_curb_test.rb

@@ -0,0 +1,110 @@
+require 'test_helper'
+
+if JRUBY
+  puts "'#{File.basename(__FILE__)}' not supported on JRuby #{RUBY_VERSION}"
+else
+  require 'elasticsearch/transport/transport/http/curb'
+  require 'curb'
+
+  class Elasticsearch::Transport::Transport::HTTP::FaradayTest < Test::Unit::TestCase
+    include Elasticsearch::Transport::Transport::HTTP
+
+    context "Curb transport" do
+      setup do
+        @transport = Curb.new :hosts => [ { :host => 'foobar', :port => 1234 } ]
+      end
+
+      should "implement host_unreachable_exceptions" do
+        assert_instance_of Array, @transport.host_unreachable_exceptions
+      end
+
+      should "implement __build_connections" do
+        assert_equal 1, @transport.hosts.size
+        assert_equal 1, @transport.connections.size
+
+        assert_instance_of ::Curl::Easy,   @transport.connections.first.connection
+        assert_equal 'http://foobar:1234', @transport.connections.first.connection.url
+      end
+
+      should "perform the request" do
+        @transport.connections.first.connection.expects(:http).returns(stub_everything)
+        @transport.perform_request 'GET', '/'
+      end
+
+      should "set body for GET request" do
+        @transport.connections.first.connection.expects(:put_data=).with('{"foo":"bar"}')
+        @transport.connections.first.connection.expects(:http).with(:GET).returns(stub_everything)
+        @transport.perform_request 'GET', '/', {}, '{"foo":"bar"}'
+      end
+
+      should "set body for PUT request" do
+        @transport.connections.first.connection.expects(:put_data=)
+        @transport.connections.first.connection.expects(:http).with(:PUT).returns(stub_everything)
+        @transport.perform_request 'PUT', '/', {}, {:foo => 'bar'}
+      end
+
+      should "serialize the request body" do
+        @transport.connections.first.connection.expects(:http).with(:POST).returns(stub_everything)
+        @transport.serializer.expects(:dump)
+        @transport.perform_request 'POST', '/', {}, {:foo => 'bar'}
+      end
+
+      should "not serialize a String request body" do
+        @transport.connections.first.connection.expects(:http).with(:POST).returns(stub_everything)
+        @transport.serializer.expects(:dump).never
+        @transport.perform_request 'POST', '/', {}, '{"foo":"bar"}'
+      end
+
+      should "set application/json response header" do
+        @transport.connections.first.connection.expects(:http).with(:GET).returns(stub_everything)
+        @transport.connections.first.connection.expects(:body_str).returns('{"foo":"bar"}')
+        @transport.connections.first.connection.expects(:header_str).returns('HTTP/1.1 200 OK\r\nContent-Type: application/json; charset=UTF-8\r\nContent-Length: 311\r\n\r\n')
+
+        response = @transport.perform_request 'GET', '/'
+
+        assert_equal 'application/json', response.headers['content-type']
+      end
+
+      should "handle HTTP methods" do
+        @transport.connections.first.connection.expects(:http).with(:HEAD).returns(stub_everything)
+        @transport.connections.first.connection.expects(:http).with(:GET).returns(stub_everything)
+        @transport.connections.first.connection.expects(:http).with(:PUT).returns(stub_everything)
+        @transport.connections.first.connection.expects(:http).with(:POST).returns(stub_everything)
+        @transport.connections.first.connection.expects(:http).with(:DELETE).returns(stub_everything)
+
+        %w| HEAD GET PUT POST DELETE |.each { |method| @transport.perform_request method, '/' }
+
+        assert_raise(ArgumentError) { @transport.perform_request 'FOOBAR', '/' }
+      end
+
+      should "properly pass the Content-Type header option" do
+        transport = Curb.new :hosts => [ { :host => 'foobar', :port => 1234 } ], :options => { :transport_options => { :headers => { 'Content-Type' => 'foo/bar' } } }
+
+        assert_equal "foo/bar", transport.connections.first.connection.headers["Content-Type"]
+      end
+
+      should "allow to set options for Curb" do
+        transport = Curb.new :hosts => [ { :host => 'foobar', :port => 1234 } ] do |curl|
+          curl.headers["User-Agent"] = "myapp-0.0"
+        end
+
+        assert_equal "myapp-0.0", transport.connections.first.connection.headers["User-Agent"]
+      end
+
+      should "set the credentials if passed" do
+        transport = Curb.new :hosts => [ { :host => 'foobar', :port => 1234, :user => 'foo', :password => 'bar' } ]
+        assert_equal 'foo', transport.connections.first.connection.username
+        assert_equal 'bar', transport.connections.first.connection.password
+      end
+
+      should "use global http configuration" do
+        transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234 } ],
+                                :options => { :http => { :scheme => 'https', :user => 'U', :password => 'P' } }
+
+        assert_equal 'https://U:P@foobar:1234/', transport.connections.first.full_url('')
+      end
+    end
+
+  end
+
+end

data/vendor/bundle/jruby/1.9/gems/elasticsearch-transport-5.0.4/test/unit/transport_faraday_test.rb

@@ -0,0 +1,199 @@
+require 'test_helper'
+
+class Elasticsearch::Transport::Transport::HTTP::FaradayTest < Test::Unit::TestCase
+  include Elasticsearch::Transport::Transport::HTTP
+
+  context "Faraday transport" do
+    setup do
+      @transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234 } ]
+    end
+
+    should "implement host_unreachable_exceptions" do
+      assert_instance_of Array, @transport.host_unreachable_exceptions
+    end
+
+    should "implement __build_connections" do
+      assert_equal 1, @transport.hosts.size
+      assert_equal 1, @transport.connections.size
+
+      assert_instance_of ::Faraday::Connection, @transport.connections.first.connection
+      assert_equal 'http://foobar:1234/',       @transport.connections.first.connection.url_prefix.to_s
+    end
+
+    should "perform the request" do
+      @transport.connections.first.connection.expects(:run_request).returns(stub_everything)
+      @transport.perform_request 'GET', '/'
+    end
+
+    should "return a Response" do
+      @transport.connections.first.connection.expects(:run_request).returns(stub_everything)
+      response = @transport.perform_request 'GET', '/'
+      assert_instance_of Elasticsearch::Transport::Transport::Response, response
+    end
+
+    should "properly prepare the request" do
+      @transport.connections.first.connection.expects(:run_request).with do |method, url, body, headers|
+        assert_equal :post, method
+        assert_equal '{"foo":"bar"}', body
+        assert_nil   headers['Accept']
+        true
+      end.returns(stub_everything)
+
+      @transport.perform_request 'POST', '/', {}, {:foo => 'bar'}
+    end
+
+    should "properly pass the Content-Type header option" do
+      transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234 } ], :options => { :transport_options => { :headers => { 'Content-Type' => 'foo/bar' } } }
+
+      transport.connections.first.connection.expects(:run_request).with do |method, url, body, headers|
+        assert_equal 'foo/bar', headers['Content-Type']
+        true
+      end.returns(stub_everything)
+
+      transport.perform_request 'GET', '/'
+    end
+
+    should "serialize the request body" do
+      @transport.connections.first.connection.expects(:run_request).returns(stub_everything)
+      @transport.serializer.expects(:dump)
+      @transport.perform_request 'POST', '/', {}, {:foo => 'bar'}
+    end
+
+    should "not serialize a String request body" do
+      @transport.connections.first.connection.expects(:run_request).returns(stub_everything)
+      @transport.serializer.expects(:dump).never
+      @transport.perform_request 'POST', '/', {}, '{"foo":"bar"}'
+    end
+
+    should "pass the selector_class options to collection" do
+      @transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234 } ],
+                               :options => { :selector_class => Elasticsearch::Transport::Transport::Connections::Selector::Random }
+      assert_instance_of Elasticsearch::Transport::Transport::Connections::Selector::Random,
+                         @transport.connections.selector
+    end
+
+    should "pass the selector option to collection" do
+      @transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234 } ],
+                               :options => { :selector => Elasticsearch::Transport::Transport::Connections::Selector::Random.new }
+      assert_instance_of Elasticsearch::Transport::Transport::Connections::Selector::Random,
+                         @transport.connections.selector
+    end
+
+    should "pass a configuration block to the Faraday constructor" do
+      config_block = lambda do |f|
+        f.response :logger
+        f.path_prefix = '/moo'
+      end
+
+      transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234 } ], &config_block
+
+      handlers = transport.connections.first.connection.builder.handlers
+
+      assert_equal 1, handlers.size
+      assert handlers.include?(::Faraday::Response::Logger), "#{handlers.inspect} does not include <::Faraday::Adapter::Logger>"
+
+      assert_equal '/moo',                   transport.connections.first.connection.path_prefix
+      assert_equal 'http://foobar:1234/moo', transport.connections.first.connection.url_prefix.to_s
+    end
+
+    should "pass transport_options to the Faraday constructor" do
+      transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234 } ],
+                              :options => { :transport_options => {
+                                              :request => { :open_timeout => 1 },
+                                              :headers => { :foo_bar => 'bar'  },
+                                              :ssl     => { :verify => false }
+                                            }
+                                          }
+
+      assert_equal 1,     transport.connections.first.connection.options.open_timeout
+      assert_equal 'bar', transport.connections.first.connection.headers['Foo-Bar']
+      assert_equal false, transport.connections.first.connection.ssl.verify?
+    end
+
+    should "merge in parameters defined in the Faraday connection parameters" do
+      transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234 } ],
+                              :options => { :transport_options => {
+                                              :params => { :format => 'yaml' }
+                                            }
+                                          }
+      # transport.logger = Logger.new(STDERR)
+
+      transport.connections.first.connection.expects(:run_request).
+        with do |method, url, params, body|
+          assert_match /\?format=yaml/, url
+          true
+        end.
+        returns(stub_everything)
+
+      transport.perform_request 'GET', ''
+    end
+
+    should "not overwrite request parameters with the Faraday connection parameters" do
+      transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234 } ],
+                              :options => { :transport_options => {
+                                              :params => { :format => 'yaml' }
+                                            }
+                                          }
+      # transport.logger = Logger.new(STDERR)
+
+      transport.connections.first.connection.expects(:run_request).
+        with do |method, url, params, body|
+          assert_match /\?format=json/, url
+          true
+        end.
+        returns(stub_everything)
+
+      transport.perform_request 'GET', '', { :format => 'json' }
+    end
+
+    should "set the credentials if passed" do
+      transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234, :user => 'foo', :password => 'bar' } ]
+      assert_equal 'Basic Zm9vOmJhcg==', transport.connections.first.connection.headers['Authorization']
+    end
+
+    should "set the credentials if they exist in options" do
+      transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234 } ],
+                              :options => { :user => 'foo', :password => 'bar' }
+      assert_equal 'Basic Zm9vOmJhcg==', transport.connections.first.connection.headers['Authorization']
+    end
+
+    should "override options credentials if passed explicitly" do
+      transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234, :user => 'foo', :password => 'bar' },
+                                          { :host => 'foobar2', :port => 1234 } ],
+                              :options => { :user => 'foo2', :password => 'bar2' }
+      assert_equal 'Basic Zm9vOmJhcg==', transport.connections.first.connection.headers['Authorization']
+      assert_equal 'Basic Zm9vMjpiYXIy', transport.connections[1].connection.headers['Authorization']
+    end
+
+    should "set connection scheme to https if passed" do
+      transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234, :scheme => 'https' } ]
+
+      assert_instance_of ::Faraday::Connection, transport.connections.first.connection
+      assert_equal 'https://foobar:1234/',       transport.connections.first.connection.url_prefix.to_s
+    end
+
+    should "set connection scheme to https if it exist in options" do
+      transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234} ],
+                              :options => { :scheme => 'https' }
+
+      assert_instance_of ::Faraday::Connection, transport.connections.first.connection
+      assert_equal 'https://foobar:1234/',       transport.connections.first.connection.url_prefix.to_s
+    end
+
+    should "override options scheme if passed explicitly" do
+      transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234, :scheme => 'http'} ],
+                              :options => { :scheme => 'https' }
+
+      assert_instance_of ::Faraday::Connection, transport.connections.first.connection
+      assert_equal 'http://foobar:1234/',       transport.connections.first.connection.url_prefix.to_s
+    end
+
+    should "use global http configuration" do
+      transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234 } ],
+                              :options => { :http => { :scheme => 'https', :user => 'U', :password => 'P' } }
+
+      assert_equal 'https://U:P@foobar:1234/', transport.connections.first.full_url('')
+    end
+  end
+
+end

data/vendor/bundle/jruby/1.9/gems/elasticsearch-transport-5.0.4/test/unit/transport_manticore_test.rb

@@ -0,0 +1,137 @@
+require 'test_helper'
+
+unless JRUBY
+  version = ( defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'Ruby' ) + ' ' + RUBY_VERSION
+  puts "SKIP: '#{File.basename(__FILE__)}' only supported on JRuby (you're running #{version})"
+else
+  require 'elasticsearch/transport/transport/http/manticore'
+  require 'manticore'
+
+  class Elasticsearch::Transport::Transport::HTTP::ManticoreTest < Test::Unit::TestCase
+    include Elasticsearch::Transport::Transport::HTTP
+
+    context "Manticore transport" do
+      setup do
+        @transport = Manticore.new :hosts => [ { :host => '127.0.0.1', :port => 8080 } ]
+      end
+
+      should "implement host_unreachable_exceptions" do
+        assert_instance_of Array, @transport.host_unreachable_exceptions
+      end
+
+      should "implement __build_connections" do
+        assert_equal 1, @transport.hosts.size
+        assert_equal 1, @transport.connections.size
+
+        assert_instance_of ::Manticore::Client,   @transport.connections.first.connection
+      end
+
+      should "not close connections in __close_connections" do
+        assert_equal 1, @transport.connections.size
+        @transport.__close_connections
+        assert_equal 1, @transport.connections.size
+      end
+
+      should "perform the request" do
+        @transport.connections.first.connection.expects(:get).returns(stub_everything)
+        @transport.perform_request 'GET', '/'
+      end
+
+      should "set body for GET request" do
+        @transport.connections.first.connection.expects(:get).
+          with('http://127.0.0.1:8080//', {:body => '{"foo":"bar"}'}).returns(stub_everything)
+        @transport.perform_request 'GET', '/', {}, '{"foo":"bar"}'
+      end
+
+      should "set body for PUT request" do
+        @transport.connections.first.connection.expects(:put).
+          with('http://127.0.0.1:8080//', {:body => '{"foo":"bar"}'}).returns(stub_everything)
+        @transport.perform_request 'PUT', '/', {}, {:foo => 'bar'}
+      end
+
+      should "serialize the request body" do
+        @transport.connections.first.connection.expects(:post).
+          with('http://127.0.0.1:8080//', {:body => '{"foo":"bar"}'}).returns(stub_everything)
+        @transport.perform_request 'POST', '/', {}, {'foo' => 'bar'}
+      end
+
+      should "not serialize a String request body" do
+        @transport.connections.first.connection.expects(:post).
+          with('http://127.0.0.1:8080//', {:body => '{"foo":"bar"}'}).returns(stub_everything)
+        @transport.serializer.expects(:dump).never
+        @transport.perform_request 'POST', '/', {}, '{"foo":"bar"}'
+      end
+
+      should "set application/json header" do
+        options = {
+          :headers => { "content-type" => "application/json"}
+        }
+
+        transport = Manticore.new :hosts => [ { :host => 'localhost', :port => 8080 } ], :options => options
+
+        transport.connections.first.connection.stub("http://localhost:8080//", :body => "\"\"", :headers => {"content-type" => "application/json"}, :code => 200 )
+
+        response = transport.perform_request 'GET', '/', {}
+        assert_equal response.status, 200
+      end
+
+      should "set headers from 'transport_options'" do
+        options = {
+          :transport_options => {
+            :headers => { "Content-Type" => "foo/bar"}
+          }
+        }
+
+        transport = Manticore.new :hosts => [ { :host => 'localhost', :port => 8080 } ], :options => options
+
+        assert_equal('foo/bar', transport.connections.first.connection.instance_variable_get(:@options)[:headers]['Content-Type'])
+        # TODO: Needs to check @request_options
+      end
+
+      should "handle HTTP methods" do
+        @transport.connections.first.connection.expects(:delete).with('http://127.0.0.1:8080//', {}).returns(stub_everything)
+        @transport.connections.first.connection.expects(:head).with('http://127.0.0.1:8080//', {}).returns(stub_everything)
+        @transport.connections.first.connection.expects(:get).with('http://127.0.0.1:8080//', {}).returns(stub_everything)
+        @transport.connections.first.connection.expects(:put).with('http://127.0.0.1:8080//', {}).returns(stub_everything)
+        @transport.connections.first.connection.expects(:post).with('http://127.0.0.1:8080//', {}).returns(stub_everything)
+
+        %w| HEAD GET PUT POST DELETE |.each { |method| @transport.perform_request method, '/' }
+
+        assert_raise(ArgumentError) { @transport.perform_request 'FOOBAR', '/' }
+      end
+
+      should "allow to set options for Manticore" do
+        options = { :headers => {"User-Agent" => "myapp-0.0" }}
+        transport = Manticore.new :hosts => [ { :host => 'foobar', :port => 1234 } ], :options => options
+        transport.connections.first.connection.expects(:get).
+          with('http://foobar:1234//', options).returns(stub_everything)
+
+        transport.perform_request 'GET', '/', {}
+      end
+
+      should "allow to set ssl options for Manticore" do
+        options = {
+          :ssl => {
+            :truststore => "test.jks",
+            :truststore_password => "test",
+            :verify => false
+          }
+        }
+
+        ::Manticore::Client.expects(:new).with(options)
+        transport = Manticore.new :hosts => [ { :host => 'foobar', :port => 1234 } ], :options => options
+      end
+
+      should "pass :transport_options to Manticore::Client" do
+        options = {
+          :transport_options => { :potatoes => 1 }
+        }
+
+        ::Manticore::Client.expects(:new).with(:potatoes => 1, :ssl => {})
+        transport = Manticore.new :hosts => [ { :host => 'foobar', :port => 1234 } ], :options => options
+      end
+    end
+
+  end
+
+end

data/vendor/bundle/jruby/1.9/gems/faraday-0.12.1/LICENSE.md

@@ -0,0 +1,20 @@
+Copyright (c) 2009-2017 Rick Olson, Zack Hobson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.