logstash-filter-cache-redis 0.1.0 → 0.2.0

data/vendor/bundle/jruby/1.9/gems/manticore-0.6.1-java/lib/manticore/stubbed_response.rb

@@ -0,0 +1,102 @@
+module Manticore
+  # StubbedResponse is a special subclass of Response that may be used to test your code that uses Manticore
+  # without actually having Manticore make requests.
+  #
+  # @example Standard usage with Rspec
+  #
+  #   response = Manticore::StubbedResponse.stub(body: "body", code: 200).call
+  #   Manticore.should_receive(:get).with("http://www.google.com/").and_return(response)
+  #   response.body.should == "body"
+  #   response.code.should == 200
+  #
+  # @since 0.3.0
+  class StubbedResponse < Response
+
+    # Helper that instantiates a Response and stubs out its body, response code, etc
+    # @param  stubs [Hash] Hash of parameters to stub. See #stub.
+    # @return [Manticore::StubbedResponse]
+    def self.stub(stubs = {})
+      new.stub(stubs)
+    end
+
+    def initialize(client = nil, request = nil, context = nil)
+      super
+    end
+
+    # Stub out a Manticore::RequestStub.
+    #
+    # @param  stubs [Hash] Parameters to stub out
+    # @option stubs [String]                   body  The body that should be returned
+    # @option stubs [Integer]                  code  Response code to simulate
+    # @option stubs [Hash]                     headers  Response headers as a hash
+    # @option stubs [Array<Manticore::Cookie>] cookies
+    # @return [Manticore::StubbedResponse] self
+    def stub(stubs)
+      if stubs.key? :cookies
+        stubs[:cookies].keys.each {|key| stubs[:cookies][key] = Array(stubs[:cookies][key]) }
+      end
+      stubs[:code] ||= 200
+
+      stubs[:headers] ||= {}
+      stubs[:headers] = Hash[*stubs[:headers].flat_map {|k, v| [k.downcase, v] }]
+      stubs[:headers]["content-length"] ||= stubs[:body].length.to_s if stubs.key?(:body)
+
+      @stubs = stubs
+
+      self
+    end
+
+    # Used by Manticore::Client to invoke the request tied to this response
+    def call
+      @called = true
+      handleResponse @stubs
+    end
+
+    # Simulates the final URL of a redirected request. Returns the value of headers["location"]
+    #
+    # @return [String] The final URL
+    def final_url
+      call_once
+      @headers["location"] || @request.getURI.to_string
+    end
+
+    # Returns the stubbed body of this response.
+    def body(&block)
+      call_once
+      if block_given?
+        yield body
+      else
+        @body
+      end
+    end
+    alias_method :read_body, :body
+
+    # Returns the stubbed cookies of this response. This is the union of cookies from the `:cookies`
+    # option key and any `set-cookie` headers passed.
+    def cookies
+      call_once
+      @cookies
+    end
+
+    private
+
+    def handleResponse(response)
+      raise response[:raises] if response.key?(:raises)
+      @body    = response[:body]
+      @code    = response[:code]
+      @headers = response[:headers]
+      @cookies = response[:cookies]
+      Array(@headers["set-cookie"]).each do |cookie|
+        c = Cookie.from_set_cookie(cookie)
+        @cookies[c.name] ||= []
+        @cookies[c.name] << c
+      end
+      @callback_result = @handlers[:success].call(self)
+      self
+    end
+
+    def call_once
+      call unless @called
+    end
+  end
+end

data/vendor/bundle/jruby/1.9/gems/manticore-0.6.1-java/lib/manticore/version.rb

@@ -0,0 +1,3 @@
+module Manticore
+  VERSION = "0.6.1"
+end

data/vendor/bundle/jruby/1.9/gems/manticore-0.6.1-java/lib/manticore_jars.rb

@@ -0,0 +1,8 @@
+# this is a generated file, to avoid over-writing it just delete this comment
+require 'jar_dependencies'
+
+require_jar( 'commons-logging', 'commons-logging', '1.2' )
+require_jar( 'org.apache.httpcomponents', 'httpmime', '4.5.2' )
+require_jar( 'commons-codec', 'commons-codec', '1.10' )
+require_jar( 'org.apache.httpcomponents', 'httpclient', '4.5.2' )
+require_jar( 'org.apache.httpcomponents', 'httpcore', '4.4.4' )

data/vendor/bundle/jruby/1.9/gems/manticore-0.6.1-java/manticore.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'manticore/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "manticore"
+  spec.version       = Manticore::VERSION
+  spec.authors       = ["Chris Heald"]
+  spec.email         = ["cheald@mashable.com"]
+  spec.description   = %q{Manticore is an HTTP client built on the Apache HttpCore components}
+  spec.summary       = %q{Manticore is an HTTP client built on the Apache HttpCore components}
+  spec.homepage      = "https://github.com/cheald/manticore"
+  spec.license       = "MIT"
+  spec.platform      = 'java'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  private_key = File.expand_path("~/.gemcert/gem-private_key.pem")
+  if File.exists? private_key
+    spec.signing_key = private_key
+    spec.cert_chain  = ['gem-public_cert.pem']
+  end
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "jar-dependencies"
+
+  spec.requirements << "jar org.apache.httpcomponents:httpclient, '~> 4.5.0'"
+  spec.requirements << "jar org.apache.httpcomponents:httpmime,   '~> 4.5.0'"
+  spec.requirements << "jar commons-logging:commons-logging,      '~> 1.2'"
+  spec.requirements << "jar commons-codec:commons-codec,          '~> 1.9'"
+  spec.requirements << "jar org.apache.httpcomponents:httpcore,   '~> 4.4.4'"
+end

data/vendor/bundle/jruby/1.9/gems/manticore-0.6.1-java/spec/manticore/client_proxy_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+describe Manticore::Client do
+  let(:client) { Manticore::Client.new }
+
+  describe Manticore::Client::StubProxy do
+    describe "#respond_with" do
+      it "responds with a stubbed response" do
+        client.respond_with(body: "body", code: 200).get(local_server).on_success do |response|
+          expect(response).to be_a Manticore::StubbedResponse
+          expect(response.body).to eq "body"
+          expect(response.code).to eq 200
+        end
+      end
+
+      context "for synchronous requests" do
+        it "stubs the request" do
+          stub = client.respond_with(body: "body", code: 200)
+
+          stub.get(local_server) do |response|
+            expect(response).to be_a Manticore::StubbedResponse
+          end
+        end
+      end
+
+      context "for asynchronous requests" do
+        it "stubs all response made through the proxy" do
+          stub = client.respond_with(body: "body", code: 200)
+
+          stub.async.get(local_server)
+          stub.async.get(local_server)
+
+          expect( client.execute!.map(&:class) ).to eq [Manticore::StubbedResponse, Manticore::StubbedResponse]
+        end
+      end
+    end
+  end
+
+  describe Manticore::Client::AsyncProxy do
+    it "does not make a request until execute is called" do
+      anchor = Time.now.to_f
+      client.async.get("http://localhost:55441/?sleep=1.6")
+      expect(Time.now.to_f - anchor).to be < 1.0
+
+      anchor = Time.now.to_f
+      client.execute!
+      expect(Time.now.to_f - anchor).to be > 1.0
+    end
+
+    it "returns the response object, which may then have handlers attached" do
+      response = client.async.get("http://localhost:55441/")
+      success = false
+      response.on_success do
+        success = true
+      end
+
+      client.execute!
+      expect(success).to eq true
+    end
+
+    it "can chain handlers" do
+      client.async.get("http://localhost:55441/").on_success {|r| r.code }
+      expect(client.execute!.map(&:callback_result)).to eq [200]
+    end
+  end
+
+  describe Manticore::Client::BackgroundProxy do
+    it "does not block execution" do
+      anchor = Time.now.to_f
+      future = client.background.get("http://localhost:55441/?sleep=1.5").call
+      expect(Time.now.to_f - anchor).to be < 1.0
+
+      response = future.get
+      expect(Time.now.to_f - anchor).to be > 1.0
+      expect(response.body).to match(/sleep=1.5/)
+    end
+
+    it "returns a response proxy" do
+      response = client.background.get("http://localhost:55441/")
+      expect(response).to be_a Manticore::Response
+
+      success = false
+      response.on_success do
+        success = true
+      end
+
+      response.call.get
+      expect(success).to eq true
+    end
+
+    describe "#call" do
+      it "returns a future" do
+        response = client.background.get("http://localhost:55441/").call
+        expect(response).to be_a Java::JavaUtilConcurrent::FutureTask
+        response.get
+      end
+    end
+  end
+end

data/vendor/bundle/jruby/1.9/gems/manticore-0.6.1-java/spec/manticore/client_spec.rb

@@ -0,0 +1,853 @@
+# encoding: utf-8
+require 'spec_helper'
+
+java_import 'org.apache.http.entity.mime.MultipartEntityBuilder'
+java_import 'org.apache.http.entity.ContentType'
+
+describe Manticore::Client do
+
+  let(:client) { Manticore::Client.new }
+
+  it "fetches a URL and return a response" do
+    expect(client.get(local_server)).to be_a Manticore::Response
+  end
+
+  it "resolves redirections" do
+    response = client.get(local_server, headers: {"X-Redirect" => "/foobar"})
+    expect(response.code).to eq 200
+    expect(response.final_url).to eq URI(local_server("/foobar"))
+  end
+
+  it "accepts custom headers" do
+    response = client.get(local_server, headers: {"X-Custom-Header" => "Blaznotts"})
+    json = JSON.load(response.body)
+    expect(json["headers"]["X-Custom-Header"]).to eq "Blaznotts"
+  end
+
+  it "accepts repeated header values" do
+    response = client.get(local_server, headers: {"X-Custom-Header" => ["Whizzles", "Blaznotts"]})
+    json = JSON.load(response.body)
+    expect(json["headers"]["X-Custom-Header"].sort).to eq ["Blaznotts", "Whizzles"]
+  end
+
+  it "enables compression" do
+    response = client.get(local_server)
+    json = JSON.load(response.body)
+    expect(json["headers"]).to have_key "Accept-Encoding"
+    expect(json["headers"]["Accept-Encoding"]).to match "gzip"
+  end
+
+  it "authenticates" do
+    expect(client.get(local_server("/auth")).code).to eq 401
+    expect(client.get(local_server("/auth"), auth: {user: "user", pass: "pass"}).code).to eq 200
+  end
+
+  it "authenticates with eager auth" do
+    expect(client.get(local_server("/auth"), auth: {user: "user", pass: "pass", eager: true}).code).to eq 200
+  end
+
+  it "proxies" do
+    j = JSON.parse(client.get(local_server("/proxy"), proxy: "http://localhost:55442").body)
+    expect(j["server_port"]).to eq 55442
+    expect(j["uri"]["port"]).to eq 55441
+  end
+
+  context "via an authenticated proxy" do
+    let(:proxy) { "http://localhost:55442" }
+    let(:auth) { nil }
+    let(:req) { client.get(local_server("/authproxy"), proxy: proxy, auth: auth) }
+    let(:j) { JSON.parse req.body }
+
+    context "with authentication as a hash" do
+      let(:auth) { {user: "user", pass: "pass"} }
+
+      it "proxies" do
+        expect(j["server_port"]).to eq 55442
+        expect(j["uri"]["port"]).to eq 55441
+        expect(j["headers"]["Proxy-Authorization"]).to eq "Basic dXNlcjpwYXNz"
+      end
+    end
+
+    context "with authentication as a string" do
+      let(:proxy) { "http://user:pass@localhost:55442"}
+
+      it "proxies" do
+        expect(j["server_port"]).to eq 55442
+        expect(j["uri"]["port"]).to eq 55441
+        expect(j["headers"]["Proxy-Authorization"]).to eq "Basic dXNlcjpwYXNz"
+      end
+    end
+  end
+  it "proxies with authentication as a hash" do
+  end
+
+  describe "with a custom user agent" do
+    let(:client) { Manticore::Client.new user_agent: "test-agent/1.0" }
+
+    it "uses the specified UA" do
+      response = client.get(local_server("/"))
+      json = JSON.load(response.body)
+      expect(json["headers"]["User-Agent"]).to eq "test-agent/1.0"
+    end
+  end
+
+  describe "ignore_ssl_validation (deprecated option)" do
+    context "when on" do
+      let(:client) { Manticore::Client.new ssl: {verify: false} }
+
+      it "does not break on SSL validation errors" do
+        expect { client.get("https://localhost:55444/").body }.to_not raise_exception
+      end
+    end
+
+    context "when off" do
+      let(:client) { Manticore::Client.new ssl: {verify: true} }
+
+      it "breaks on SSL validation errors" do
+        expect { client.get("https://localhost:55444/").call }.to raise_exception(Manticore::ClientProtocolException)
+      end
+    end
+  end
+
+  describe 'ssl settings' do
+    describe 'verify' do
+      context 'default' do
+        let(:client) { Manticore::Client.new }
+
+        it "breaks on SSL validation errors" do
+          expect { client.get("https://localhost:55444/").call }.to raise_exception(Manticore::ClientProtocolException)
+        end
+      end
+
+      context 'when on and no trust store is given' do
+        let(:client) { Manticore::Client.new :ssl => {:verify => :strict} }
+
+        it "breaks on SSL validation errors" do
+          expect { client.get("https://localhost:55444/").call }.to raise_exception(Manticore::ClientProtocolException)
+        end
+      end
+
+      context 'when on and custom trust store is given' do
+        let(:client) { Manticore::Client.new :ssl => {verify: :strict, truststore: File.expand_path("../../ssl/truststore.jks", __FILE__), truststore_password: "test123"} }
+
+        it "verifies the request and succeed" do
+          expect { client.get("https://localhost:55444/").body }.to_not raise_exception
+        end
+      end
+
+      context "when the client specifies a protocol list" do
+        let(:client) { Manticore::Client.new :ssl => {verify: :strict, truststore: File.expand_path("../../ssl/truststore.jks", __FILE__), truststore_password: "test123", protocols: ["TLSv1", "TLSv1.1", "TLSv1.2"]} }
+
+        it "verifies the request and succeed" do
+          expect { client.get("https://localhost:55444/").body }.to_not raise_exception
+        end
+      end
+
+      context 'when on and custom trust store is given with the wrong password' do
+        let(:client) { Manticore::Client.new :ssl => {verify: :strict, truststore: File.expand_path("../../ssl/truststore.jks", __FILE__), truststore_password: "wrongpass"} }
+
+        it "fails to load the keystore" do
+          expect { client.get("https://localhost:55444/").body }.to raise_exception(Java::JavaIo::IOException)
+        end
+      end
+
+      context 'when ca_file is given' do
+        let(:client) { Manticore::Client.new :ssl => {verify: :strict, ca_file: File.expand_path("../../ssl/root-ca.crt", __FILE__) } }
+
+        it "verifies the request and succeed" do
+          expect { client.get("https://localhost:55444/").body }.to_not raise_exception
+        end
+      end
+
+      context 'when client_cert and client_key are given' do
+        let(:client) { Manticore::Client.new(
+          :ssl => {
+            verify: :strict,
+            ca_file: File.expand_path("../../ssl/root-ca.crt", __FILE__),
+            client_cert: File.expand_path("../../ssl/client.crt", __FILE__),
+            client_key: File.expand_path("../../ssl/client.key", __FILE__)
+          })
+        }
+
+        it "successfully auths requests" do
+          expect(client.get("https://localhost:55445/").body).to match("hello")
+        end
+      end
+
+      context 'when off' do
+        let(:client) { Manticore::Client.new :ssl => {:verify => :none} }
+
+        it "does not break on SSL validation errors" do
+          expect { client.get("https://localhost:55444/").body }.to_not raise_exception
+        end
+      end
+
+      context "against a server that verifies clients" do
+        context "when client cert auth is provided" do
+          let(:client) {
+            options = {
+              truststore: File.expand_path("../../ssl/truststore.jks", __FILE__),
+              truststore_password: "test123",
+              keystore: File.expand_path("../../ssl/client.p12", __FILE__),
+              keystore_password: "test123",
+              verify: :strict
+            }
+            Manticore::Client.new :ssl => options
+          }
+
+          it "successfully auths requests" do
+            expect(client.get("https://localhost:55445/").body).to match("hello")
+          end
+        end
+
+        context "when client cert auth is not provided" do
+          let(:client) {
+            options = {
+              truststore: File.expand_path("../../ssl/truststore.jks", __FILE__),
+              truststore_password: "test123",
+              verify: :strict
+            }
+            Manticore::Client.new :ssl => options
+          }
+
+          it "fails the request" do
+            # oraclejdk7 throws a SocketException here, oraclejdk8/openjdk7 throw ClientProtocolException
+            expect { client.get("https://localhost:55445/").body }.to raise_exception(Manticore::ManticoreException)
+          end
+        end
+      end
+    end
+
+    describe ":cipher_suites" do
+      skip
+    end
+
+    describe ":protocols" do
+      skip
+    end
+  end
+
+  describe "lazy evaluation" do
+    it "does not call synchronous requests by default" do
+      req = client.get(local_server)
+      expect(req).to_not be_called
+    end
+
+    context "given a lazy request" do
+      subject { client.get(local_server) }
+
+      before do
+        expect(subject).to_not be_called
+        expect(subject).to receive(:call).once.and_call_original
+      end
+
+      specify { expect { subject.body }.to change      { subject.called? } }
+      specify { expect { subject.headers }.to change   { subject.called? } }
+      specify { expect { subject.final_url }.to change { subject.called? } }
+      specify { expect { subject.code }.to change      { subject.called? } }
+      specify { expect { subject.length }.to change    { subject.called? } }
+      specify { expect { subject.cookies }.to change   { subject.called? } }
+    end
+
+    it "automatically calls synchronous requests that pass a handler block" do
+      req = client.get(local_server) {|r| }
+      expect(req).to be_called
+    end
+
+    it "does not call asynchronous requests even if a block is passed" do
+      req = client.async.get(local_server) {|r| }
+      expect(req).to_not be_called
+    end
+
+    it "does not call asynchronous requests when on_success is passed" do
+      req = client.async.get(local_server).on_success {|r| }
+      expect(req).to_not be_called
+    end
+
+    it "calls async requests on client execution" do
+      req = client.async.get(local_server).on_success {|r| }
+      expect { client.execute! }.to change { req.called? }.from(false).to(true)
+    end
+
+
+    describe "with a bad port number" do
+      it "returns a Manticore::InvalidArgumentException" do
+        failure = nil
+        client.async.get(local_server("/", 65536)).
+          on_failure {|f| failure = f }
+        client.execute!
+        expect(failure).to be_a(Manticore::InvalidArgumentException)
+      end
+    end
+
+    describe "mysterious failures" do
+      it "still returns an error to on failure" do
+        failure = nil
+        # I'm not crazy about reaching into the client via instance_variable_get here, but it works.
+        expect(client.instance_variable_get("@client")).to receive(:execute).and_raise(StandardError.new("Uh oh"))
+        client.async.get(local_server).
+          on_failure {|f| failure = f }
+        client.execute!
+        expect(failure).to be_a(StandardError)
+      end
+    end
+  end
+
+  context "when client-wide cookie management is disabled" do
+    let(:client) { Manticore::Client.new cookies: false }
+
+    it "persists cookies across multiple redirects from a single request" do
+      response = client.get(local_server("/cookies/1/2"))
+      expect(response.final_url.to_s).to eq local_server("/cookies/2/2")
+      expect(response.cookies["x"]).to be_nil
+      expect(response.headers["set-cookie"]).to match(/1/)
+    end
+
+    it "does not persist cookies between requests" do
+      response = client.get(local_server("/cookies/1/2"))
+      expect(response.final_url.to_s).to eq local_server("/cookies/2/2")
+      expect(response.cookies["x"]).to be_nil
+      expect(response.headers["set-cookie"]).to match(/1/)
+
+      response = client.get(local_server("/cookies/1/2"))
+      expect(response.final_url.to_s).to eq local_server("/cookies/2/2")
+      expect(response.cookies["x"]).to be_nil
+      expect(response.headers["set-cookie"]).to match(/1/)
+    end
+  end
+
+  context "when client-wide cookie management is set to per-request" do
+    let(:client) { Manticore::Client.new cookies: :per_request }
+
+    it "persists cookies across multiple redirects from a single request" do
+      response = client.get(local_server("/cookies/1/2"))
+      expect(response.final_url.to_s).to eq local_server("/cookies/2/2")
+      expect(response.headers["set-cookie"]).to match(/2/)
+      expect(response.cookies["x"].first.value).to eq "2"
+    end
+
+    it "does not persist cookies between requests" do
+      response = client.get(local_server("/cookies/1/2"))
+      expect(response.final_url.to_s).to eq local_server("/cookies/2/2")
+      expect(response.headers["set-cookie"]).to match(/2/)
+      expect(response.cookies["x"].first.value).to eq "2"
+
+      response = client.get(local_server("/cookies/1/2"))
+      expect(response.final_url.to_s).to eq local_server("/cookies/2/2")
+      expect(response.headers["set-cookie"]).to match(/2/)
+      expect(response.cookies["x"].first.value).to eq "2"
+    end
+  end
+
+  context "when client-wide cookie management is enabled" do
+    let(:client) { Manticore::Client.new cookies: true }
+
+    it "persists cookies across multiple redirects from a single request" do
+      response = client.get(local_server("/cookies/1/2"))
+      expect(response.final_url.to_s).to eq local_server("/cookies/2/2")
+      expect(response.cookies["x"].first.value).to eq "2"
+    end
+
+    it "persists cookies between requests" do
+      response = client.get(local_server("/cookies/1/2"))
+      expect(response.final_url.to_s).to eq local_server("/cookies/2/2")
+      expect(response.cookies["x"].first.value).to eq "2"
+
+      response = client.get(local_server("/cookies/1/2"))
+      expect(response.final_url.to_s).to eq local_server("/cookies/2/2")
+      expect(response.cookies["x"].first.value).to eq "4"
+    end
+  end
+
+  context "when compression is disabled" do
+    let(:client) {
+      Manticore::Client.new do |client, request_config|
+        client.disable_content_compression
+      end
+    }
+
+    it "disables compression" do
+      response = client.get(local_server)
+      json = JSON.load(response.body)
+      expect(json["headers"]["Accept-Encoding"]).to be_nil
+    end
+  end
+
+  context "when no response charset is specified" do
+    let(:content_type) { "text/plain" }
+
+    it "decodes response bodies according to the content-type header" do
+      expect(client.get(local_server, headers: {"X-Content-Type" => content_type}).body.encoding.name).to eq "ISO-8859-1"
+    end
+  end
+
+  context "when an invalid response charset is specified" do
+    let(:content_type) { "text/plain; charset=bogus" }
+
+    it "decodes the content as UTF-8" do
+      expect(client.get(local_server, headers: {"X-Content-Type" => content_type}).body.encoding.name).to eq "ISO-8859-1"
+    end
+  end
+
+  context "when the response charset is UTF-8" do
+    let(:content_type) { "text/plain; charset=utf-8" }
+
+    it "decodes response bodies according to the content-type header" do
+      expect(client.get(local_server, headers: {"X-Content-Type" => content_type}).body.encoding.name).to eq "UTF-8"
+    end
+  end
+
+  describe "#get" do
+    it "works" do
+      response = client.get(local_server)
+      expect(JSON.load(response.body)["method"]).to eq "GET"
+    end
+
+    it "works with a URI object" do
+      response = client.get(URI.parse local_server)
+      expect(JSON.load(response.body)["method"]).to eq "GET"
+    end
+
+    it "send a query" do
+      response = client.get local_server, query: {foo: "bar"}
+      expect(CGI.parse(JSON.load(response.body)["uri"]["query"])["foo"]).to eq ["bar"]
+    end
+
+    it "sends a body" do
+      response = client.get(local_server, body: "This is a post body")
+      expect(JSON.load(response.body)["body"]).to eq "This is a post body"
+    end
+
+    it "can send an array of parameters as :params" do
+      response = client.get(local_server, params: {"foo" => ["baz", "bar"], "bar" => {"baz" => ["bin", 1, :b]}})
+      j = JSON.load(response.body)
+      expect(j["body"]).to eq ""
+      expect(j["uri"]["query"]).to include("foo=baz")
+    end
+
+    it "can send an array of parameters as :query" do
+      response = client.get(local_server, query: {"foo" => ["baz", "bar"]})
+      j = JSON.load(response.body)
+      expect(j["body"]).to eq ""
+      expect(j["uri"]["query"]).to include("foo=baz")
+    end
+
+    it "sends non-ASCII params" do
+      response = client.get(local_server, query: {"∑" => "√"})
+      j = JSON.load(response.body)
+      expect(CGI.unescape j["uri"]["query"]).to eq "∑=√"
+    end
+
+    it "merges implicit query parameters with explicit ones" do
+      response = client.get(local_server + "?foo=bar", query: {"baz" => "bin"})
+      j = JSON.load(response.body)
+      expect(CGI.parse j["uri"]["query"]).to eq({"foo" => ["bar"], "baz" => ["bin"]})
+    end
+  end
+
+  describe "#post" do
+    it "works" do
+      response = client.post(local_server)
+      expect(JSON.load(response.body)["method"]).to eq "POST"
+    end
+
+    it "sends a body" do
+      response = client.post(local_server, body: "This is a post body")
+      expect(JSON.load(response.body)["body"]).to eq "This is a post body"
+    end
+
+    it "sends a UTF-8 body" do
+      response = client.post(local_server, body: "This is a post body ∑")
+      expect(JSON.load(response.body)["body"]).to eq "This is a post body ∑"
+    end
+
+    it "sends params" do
+      response = client.post(local_server, params: {key: "value"})
+      expect(CGI.unescape(JSON.load(response.body)["body"])).to eq "key=value"
+    end
+
+    it "sends non-ASCII params" do
+      response = client.post(local_server, params: {"∑" => "√"})
+      expect(CGI.unescape(JSON.load(response.body)["body"])).to eq "∑=√"
+    end
+
+    it "sends a binary body" do
+      bytes = [145, 167, 116, 101, 115, 116, 49, 50, 51].pack("c*").encode("binary")
+      response = client.post(local_server, body: bytes, headers: {"X-Base64" => "1"})
+      expect(Base64.decode64(JSON.load(response.body)["body"])).to eq bytes
+    end
+
+    it "sends an arbitrary entity" do
+      f = open(File.expand_path(File.join(__FILE__, "..", "..", "spec_helper.rb")), "r").to_inputstream
+      multipart_entity = MultipartEntityBuilder.create.add_text_body("foo", "bar").add_binary_body("whatever", f , ContentType::TEXT_PLAIN, __FILE__)
+      response = client.post(local_server, entity: multipart_entity.build)
+      expect(response.body).to match "RSpec.configure"
+    end
+  end
+
+  describe "#put" do
+    it "works" do
+      response = client.put(local_server)
+      expect(JSON.load(response.body)["method"]).to eq "PUT"
+    end
+
+    it "sends a body" do
+      response = client.put(local_server, body: "This is a put body")
+      expect(JSON.load(response.body)["body"]).to eq "This is a put body"
+    end
+
+    it "sends params" do
+      response = client.put(local_server, params: {key: "value"})
+      expect(JSON.load(response.body)["body"]).to eq "key=value"
+    end
+  end
+
+  describe "#delete" do
+    it "works" do
+      response = client.delete(local_server)
+      expect(JSON.load(response.body)["method"]).to eq "DELETE"
+    end
+
+    it "sends a body" do
+      response = client.delete(local_server, body: "This is a delete body")
+      expect(JSON.load(response.body)["body"]).to eq "This is a delete body"
+    end
+  end
+
+  describe "#head" do
+    it "works" do
+      response = client.head(local_server)
+      expect(JSON.load(response.body)).to be_nil
+    end
+  end
+
+  describe "#options" do
+    it "works" do
+      response = client.options(local_server)
+      expect(JSON.load(response.body)["method"]).to eq "OPTIONS"
+    end
+  end
+
+  describe "#patch" do
+    it "works" do
+      response = client.patch(local_server)
+      expect(JSON.load(response.body)["method"]).to eq "PATCH"
+    end
+
+    it "sends a body" do
+      response = client.patch(local_server, body: "This is a patch body")
+      expect(JSON.load(response.body)["body"]).to eq "This is a patch body"
+    end
+
+    it "sends params" do
+      response = client.patch(local_server, params: {key: "value"})
+      expect(JSON.load(response.body)["body"]).to eq "key=value"
+    end
+  end
+
+  describe "#execute!" do
+    it "performs multiple concurrent requests" do
+      futures = [55441, 55442].map do |port|
+        client.async.get("http://localhost:#{port}/?sleep=1").
+          on_success do |response|
+            Time.now.to_f
+          end
+      end
+
+      client.execute!
+      values = futures.map(&:callback_result)
+      expect((values[0] - values[1]).abs).to be < 0.25
+    end
+
+    it "returns the results of the handler blocks" do
+      [55441, 55442].each do |port|
+        client.async.get("http://localhost:#{port}/").
+          on_success {|response, request| "Result" }
+      end
+
+      expect(client.execute!.map(&:callback_result)).to eq ["Result", "Result"]
+    end
+  end
+
+  describe "#clear_pending" do
+    it "removes pending requests" do
+      ran = false
+      client.async.get("http://google.com").on_success {|r| ran = true }
+      client.clear_pending
+      expect(client.execute!).to be_empty
+      expect(ran).to be false
+    end
+  end
+
+  describe "#stub" do
+    it "responds with a stubbed response until it is unstubbed" do
+      client.stub(local_server, body: "body", code: 200)
+
+      called = false
+      2.times {
+        client.get(local_server) do |response|
+          called = true
+          expect(response).to be_a Manticore::StubbedResponse
+          expect(response.body).to eq "body"
+          expect(response.code).to eq 200
+        end
+      }
+
+      expect(called).to be true
+
+      client.clear_stubs!
+      client.get(local_server) do |response|
+        expect(response).to be_a Manticore::Response
+        expect(response.body).to match /Manticore/
+        expect(response.code).to eq 200
+      end
+    end
+
+    context 'stubbing' do
+      it "only the provided URLs" do
+        client.stub local_server, body: "body"
+        client.async.get(local_server).on_success {|r| expect(r).to be_a Manticore::StubbedResponse }
+        client.async.get(local_server("/other")).on_success {|r| expect(r).to_not be_a Manticore::StubbedResponse }
+        client.execute!
+      end
+
+      it "by regex matching" do
+        client.stub %r{#{local_server("/foo")}}, body: "body"
+        client.async.get(local_server("/foo")).on_success {|r| expect(r).to be_a Manticore::StubbedResponse }
+        client.async.get(local_server("/bar")).on_success {|r| expect(r).to_not be_a Manticore::StubbedResponse }
+        client.execute!
+      end
+
+      it "strictly matches string stubs" do
+        client.stub local_server("/foo"), body: "body"
+        client.async.get(local_server("/foo")).on_success {|r| expect(r).to be_a Manticore::StubbedResponse }
+        client.async.get(local_server("/other")).on_success {|r| expect(r).to_not be_a Manticore::StubbedResponse }
+        client.execute!
+      end
+
+      it "matches stubs with query strings" do
+        url = "http://google.com?k=v"
+        client.stub(url, body: "response body", code: 200)
+        client.get(url) do |response|
+          expect(response.body).to eq("response body")
+        end
+      end
+
+      it "persists the stub for non-block calls" do
+        url = "http://google.com"
+        client.stub(url, body: "response body", code: 200)
+        response = client.get(url)
+        expect(response.body).to eq("response body")
+      end
+    end
+  end
+
+  describe "#close" do
+    it "makes the client unusable" do
+      client.close
+      response = client.head(local_server)
+      expect { response.body }.to raise_error(Manticore::ClientStoppedException)
+    end
+  end
+
+  describe "keepalive" do
+    let(:url) { "http://www.facebook.com/" }
+
+
+    context "with keepalive" do
+      it "adds the Connection: Keep-Alive header for http/1.0" do
+        expect( client.get(url).request["Connection"] ).to eq "Keep-Alive"
+      end
+
+      let(:client) { Manticore::Client.new keepalive: true, pool_max: 1 }
+
+      it "keeps the connection open after a request" do
+        skip
+        response = client.get(url).call
+        get_connection(client, url) do |conn|
+          expect(conn.is_open).to be true
+        end
+      end
+    end
+
+    context "without keepalive" do
+      let(:client) { Manticore::Client.new keepalive: false, pool_max: 1 }
+
+      it "does not add the Connection: Keep-Alive header for http/1.0" do
+        expect( client.get(url).request["Connection"] ).to be_nil
+      end
+
+      it "closes the connection after a request" do
+        skip
+        response = client.get(url).call
+        puts `netstat -apn`
+        # get_connection(client, url) do |conn|
+        #   conn.is_open.should be false
+        # end
+      end
+    end
+  end
+
+  context "with a misbehaving endpoint" do
+    before do
+      @socket = TCPServer.new 4567
+      @server = Thread.new do
+        loop do
+          client = @socket.accept
+          begin
+            client.puts([
+              "HTTP/1.1 200 OK",
+              "Keep-Alive: timeout=3000",
+              "Connection: Keep-Alive",
+              "Content-Length: 6",
+              "",
+              "Hello!"
+            ].join("\n"))
+            client.close
+          rescue IOError => e
+          end
+        end
+      end
+    end
+
+    let(:client) { Manticore::Client.new keepalive: true, pool_max: 1 }
+
+    it "retries 3 times by default" do
+      # The first time, reply with keepalive, then close the connection
+      # The second connection should succeed
+
+      request1 = client.get("http://localhost:4567/")
+      request2 = client.get("http://localhost:4567/")
+      expect { request1.call }.to_not raise_exception
+      expect { request2.call }.to_not raise_exception
+
+      expect(request1.times_retried).to eq 0
+      expect(request2.times_retried).to eq 1
+    end
+
+    context "when the max retry is restrictive" do
+      let(:client) { Manticore::Client.new keepalive: true, pool_max: 1, automatic_retries: 0 }
+
+      it "retries 0 times and fail on the second request" do
+        # The first time, reply with keepalive, then close the connection
+        # The second connection should succeed
+        expect { client.get("http://localhost:4567/").call }.to_not raise_exception
+        expect { client.get("http://localhost:4567/").call }.to raise_exception(Manticore::SocketException)
+      end
+    end
+
+    context "when keepalive is off" do
+      let(:client) { Manticore::Client.new keepalive: false, pool_max: 1 }
+
+      it "succeeds without any retries" do
+        # The first time, reply with keepalive, then close the connection
+        # The second connection should succeed
+        request1 = client.get("http://localhost:4567/")
+        request2 = client.get("http://localhost:4567/")
+        expect { request1.call }.to_not raise_exception
+        expect { request2.call }.to_not raise_exception
+
+        expect(request1.times_retried).to eq 0
+        expect(request2.times_retried).to eq 0
+      end
+    end
+
+    after do
+      Thread.kill @server
+      begin
+        @socket.close
+      rescue IOError
+        # pass
+      end
+    end
+  end
+
+  describe "with connection timeouts" do
+    let(:client) { Manticore::Client.new request_timeout: 1, connect_timeout: 1, socket_timeout: 1 }
+
+    it "times out" do
+      expect { client.get(local_server "/?sleep=2").body }.to raise_exception(Manticore::SocketTimeout)
+    end
+
+    it "times out when custom request options are passed" do
+      expect { client.get(local_server("/?sleep=2"), max_redirects: 5).body }.to raise_exception(Manticore::SocketTimeout)
+    end
+  end
+
+  describe "request types:" do
+    describe "sync" do
+      it "returns a response" do
+        expect(client.get(local_server)).to be_a Manticore::Response
+      end
+
+      it "evaluates immediately when given a block" do
+        called = false
+        expect { client.get(local_server) { called = true } }.to change { called }.to(true)
+      end
+
+      it "can be evaluated synchronously on-demand" do
+        expect(client.get(local_server).body).to be_a String
+      end
+    end
+
+    describe "async" do
+      it "returns a response" do
+        expect(client.async.get(local_server)).to be_a Manticore::Response
+      end
+
+      it "works with `parallel`" do
+        expect(client.parallel.get(local_server)).to be_a Manticore::Response
+      end
+
+      it "works with `batch`" do
+        expect(client.parallel.get(local_server)).to be_a Manticore::Response
+      end
+
+      it "does not evaluate immediately when given a block" do
+        called = false
+        expect { client.async.get(local_server) { called = true }; sleep 0.5 }.to_not change { called }
+      end
+
+      it "can be evaluated synchronously on-demand" do
+        expect(client.async.get(local_server).body).to be_a String
+      end
+    end
+
+    describe "background" do
+      it "returns a response" do
+        expect( client.background.get(local_server) ).to be_a Manticore::Response
+      end
+
+      it "has the background flag set" do
+        expect( client.background.get(local_server).background ).to eq true
+      end
+
+      it "returns a future when called" do
+        expect( client.background.get(local_server).call ).to be_a Java::JavaUtilConcurrent::FutureTask
+      end
+
+      it "evaluates immediately when given a block" do
+        called = false
+        expect { (client.background.get(local_server) { called = true }).get }.to change { called }.to(true)
+      end
+
+      it "raises an exception when a sync method is called on it" do
+        called = false
+        expect { client.background.get(local_server).body }.to raise_exception(RuntimeError)
+      end
+    end
+  end
+
+  def get_connection(client, uri, &block)
+    java_import "java.util.concurrent.TimeUnit"
+    host = URI.parse(uri).host
+    pool = client.instance_variable_get("@pool")
+    req = pool.requestConnection(Java::OrgApacheHttpConnRouting::HttpRoute.new( Java::OrgApacheHttp::HttpHost.new(host) ), nil)
+    conn = req.get(3, TimeUnit::SECONDS)
+    begin
+      yield conn
+    ensure
+      pool.releaseConnection(conn, nil, 0, TimeUnit::SECONDS)
+    end
+  end
+end