manticore 0.6.0-java → 0.7.0-java

data/lib/manticore/client/proxies.rb

@@ -9,6 +9,7 @@ module Manticore
       def async
         AsyncProxy.new(self)
       end
+
       alias_method :parallel, :async
       alias_method :batch, :async
 
@@ -20,6 +21,7 @@ module Manticore
 
     class BaseProxy
       include ProxiesInterface
+
       def initialize(client)
         @client = client
       end
@@ -55,4 +57,4 @@ module Manticore
       end
     end
   end
-end
+end

data/lib/manticore/cookie.rb

@@ -36,7 +36,7 @@ module Manticore
         value: cookie.get_value,
         secure: cookie.is_secure,
         persistent: cookie.is_persistent,
-        spec_version: cookie.get_version
+        spec_version: cookie.get_version,
       )
     end
 
@@ -63,16 +63,16 @@ module Manticore
     attr_reader :comment, :comment_url, :domain, :expires, :name, :path, :ports, :value, :spec_version
 
     def initialize(args)
-      @comment      = args.fetch(:comment, nil)
-      @comment_url  = args.fetch(:comment_url, nil)
-      @domain       = args.fetch(:domain, nil)
-      @expires      = args.fetch(:expires, nil)
-      @name         = args.fetch(:name, nil)
-      @path         = args.fetch(:path, nil)
-      @ports        = args.fetch(:ports, nil)
-      @value        = args.fetch(:value, nil)
-      @secure       = args.fetch(:secure, nil)
-      @persistent   = args.fetch(:persistent, nil)
+      @comment = args.fetch(:comment, nil)
+      @comment_url = args.fetch(:comment_url, nil)
+      @domain = args.fetch(:domain, nil)
+      @expires = args.fetch(:expires, nil)
+      @name = args.fetch(:name, nil)
+      @path = args.fetch(:path, nil)
+      @ports = args.fetch(:ports, nil)
+      @value = args.fetch(:value, nil)
+      @secure = args.fetch(:secure, nil)
+      @persistent = args.fetch(:persistent, nil)
       @spec_version = args.fetch(:spec_version, nil)
     end
 
@@ -104,4 +104,4 @@ module Manticore
       !@persistent
     end
   end
-end
+end

data/lib/manticore/facade.rb

@@ -1,4 +1,4 @@
-require 'forwardable'
+require "forwardable"
 
 module Manticore
   # Mix-in that can be used to add Manticore functionality to arbitrary classes.
@@ -46,4 +46,4 @@ module Manticore
       end
     end
   end
-end
+end

data/lib/manticore/java_extensions.rb

@@ -4,7 +4,7 @@ class Java::OrgApacheHttpClientMethods::HttpRequestBase
 
   # Provides an easy way to get the request headers from any request
   def headers
-    Hash[*get_all_headers.flat_map {|h| [h.name, h.value] }]
+    Hash[*get_all_headers.flat_map { |h| [h.name, h.value] }]
   end
 
   # Get a single request header

data/lib/manticore/response.rb

@@ -3,7 +3,7 @@ module Manticore
   # as a Ruby proxy for HTTPClient responses.
   #
   # @!attribute [r] headers
-  #   @return [Hash] Headers from this response
+  #   @return [Hash] Headers from this response. If a header is given more than once in a response, the value is an array of values. Otherwise, it is the header value.
   # @!attribute [r] code
   #   @return [Integer] Response code from this response
   # @!attribute [r] context
@@ -15,7 +15,7 @@ module Manticore
     include_package "org.apache.http.util"
     include_package "org.apache.http.protocol"
     java_import "org.apache.http.client.protocol.HttpClientContext"
-    java_import 'java.util.concurrent.Callable'
+    java_import "java.util.concurrent.Callable"
 
     include ResponseHandler
     include Callable
@@ -29,14 +29,14 @@ module Manticore
     # @param  request            [HttpRequestBase] The underlying request object
     # @param  context            [HttpContext] The underlying HttpContext
     def initialize(client, request, context, &block)
-      @client  = client
+      @client = client
       @request = request
       @context = context
       @handlers = {
-        success:   block || Proc.new {|resp| resp.body },
-        failure:   Proc.new {|ex| raise ex },
-        cancelled: Proc.new {},
-        complete:  []
+        success: block || Proc.new { |resp| resp.body },
+        failure: Proc.new { |ex| raise ex },
+        cancelled: Proc.new { },
+        complete: [],
       }
     end
 
@@ -91,9 +91,9 @@ module Manticore
     def final_url
       call_once
       last_request = context.get_attribute ExecutionContext.HTTP_REQUEST
-      last_host    = context.get_attribute ExecutionContext.HTTP_TARGET_HOST
-      host         = last_host.to_uri
-      url          = last_request.get_uri
+      last_host = context.get_attribute ExecutionContext.HTTP_TARGET_HOST
+      host = last_host.to_uri
+      url = last_request.get_uri
       URI.join(host, url.to_s)
     end
 
@@ -115,15 +115,16 @@ module Manticore
     def body(&block)
       call_once
       @body ||= begin
-        if entity = @response.get_entity
-          EntityConverter.new.read_entity(entity, &block)
-        end
-      rescue Java::JavaIo::IOException, Java::JavaNet::SocketException, IOError => e
-        raise StreamClosedException.new("Could not read from stream: #{e.message}")
-      # ensure
-      #   @request.release_connection
-      end
+                  if entity = @response.get_entity
+                    EntityConverter.new.read_entity(entity, &block)
+                  end
+                rescue Java::JavaIo::IOException, Java::JavaNet::SocketException, IOError => e
+                  raise StreamClosedException.new("Could not read from stream: #{e.message}")
+                  # ensure
+                  #   @request.release_connection
+                end
     end
+
     alias_method :read_body, :body
 
     # Returns true if this response has been called (requested and populated) yet
@@ -140,10 +141,14 @@ module Manticore
     end
 
     # Return the value of a single response header. Will call the request if it has not been called yet.
+    # If the header was returned with multiple values, will only return the first value. If you need to get
+    # multiple values, use response#headers[lowercase_key]
     #
-    # @return [String] Value of the header, or nil if not present
+    # @param  key [String] Case-insensitive header key
+    # @return     [String] Value of the header, or nil if not present
     def [](key)
-      headers[key.downcase]
+      v = headers[key.downcase]
+      v.is_a?(Array) ? v.first : v
     end
 
     # Return the response code from this request as an integer. Will call the request if it has not been called yet.
@@ -192,6 +197,7 @@ module Manticore
       @handlers[:success] = block
       self
     end
+
     alias_method :success, :on_success
 
     # Set handler for failure responses
@@ -202,8 +208,9 @@ module Manticore
       @handlers[:failure] = block
       self
     end
+
     alias_method :failure, :on_failure
-    alias_method :fail,    :on_failure
+    alias_method :fail, :on_failure
 
     # Set handler for cancelled requests. NB: Not actually used right now?
     # @param block Proc which will be invoked on a on a cancelled response.
@@ -213,8 +220,9 @@ module Manticore
       @handlers[:cancelled] = block
       self
     end
-    alias_method :cancelled,       :on_cancelled
-    alias_method :cancellation,    :on_cancelled
+
+    alias_method :cancelled, :on_cancelled
+    alias_method :cancellation, :on_cancelled
     alias_method :on_cancellation, :on_cancelled
 
     # Set handler for completed requests
@@ -225,8 +233,9 @@ module Manticore
       @handlers[:complete] = Array(@handlers[:complete]).compact + [block]
       self
     end
-    alias_method :complete,     :on_complete
-    alias_method :completed,    :on_complete
+
+    alias_method :complete, :on_complete
+    alias_method :completed, :on_complete
     alias_method :on_completed, :on_complete
 
     def times_retried
@@ -243,10 +252,19 @@ module Manticore
     # Implementation of {http://hc.apache.org/httpcomponents-client-ga/httpclient/apidocs/org/apache/http/client/ResponseHandler.html#handleResponse(org.apache.http.HttpResponse) ResponseHandler#handleResponse}
     # @param  response [Response] The underlying Java Response object
     def handleResponse(response)
-      @response        = response
-      @code            = response.get_status_line.get_status_code
-      @message         = response.get_status_line.get_reason_phrase
-      @headers         = Hash[* response.get_all_headers.flat_map {|h| [h.get_name.downcase, h.get_value]} ]
+      @response = response
+      @code = response.get_status_line.get_status_code
+      @message = response.get_status_line.get_reason_phrase
+      @headers = response.get_all_headers.each_with_object({}) do |h, o|
+        key = h.get_name.downcase
+        if o.key?(key)
+          o[key] = Array(o[key]) unless o[key].is_a?(Array)
+          o[key].push h.get_value
+        else
+          o[key] = h.get_value
+        end
+      end
+
       @callback_result = @handlers[:success].call(self)
       nil
     end
@@ -261,7 +279,7 @@ module Manticore
     end
 
     def execute_complete
-      @handlers[:complete].each {|h| h.call(self) }
+      @handlers[:complete].each { |h| h.call(self) }
     end
   end
 end

data/lib/manticore/stubbed_response.rb

@@ -33,12 +33,12 @@ module Manticore
     # @return [Manticore::StubbedResponse] self
     def stub(stubs)
       if stubs.key? :cookies
-        stubs[:cookies].keys.each {|key| stubs[:cookies][key] = Array(stubs[:cookies][key]) }
+        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] = 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
@@ -69,6 +69,7 @@ module Manticore
         @body
       end
     end
+
     alias_method :read_body, :body
 
     # Returns the stubbed cookies of this response. This is the union of cookies from the `:cookies`
@@ -82,8 +83,8 @@ module Manticore
 
     def handleResponse(response)
       raise response[:raises] if response.key?(:raises)
-      @body    = response[:body]
-      @code    = response[:code]
+      @body = response[:body]
+      @code = response[:code]
       @headers = response[:headers]
       @cookies = response[:cookies]
       Array(@headers["set-cookie"]).each do |cookie|
@@ -99,4 +100,4 @@ module Manticore
       call unless @called
     end
   end
-end
+end

data/lib/manticore/version.rb

@@ -1,3 +1,3 @@
 module Manticore
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

data/lib/manticore_jars.rb

@@ -1,8 +1,8 @@
 # this is a generated file, to avoid over-writing it just delete this comment
-require 'jar_dependencies'
+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' )
+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/manticore.gemspec

@@ -25,9 +25,11 @@ Gem::Specification.new do |spec|
     spec.cert_chain  = ['gem-public_cert.pem']
   end
 
-  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_dependency "openssl_pkcs8_pure"
+
+  spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "jar-dependencies"
+  spec.add_development_dependency "jar-dependencies", "~> 0.4.1"
 
   spec.requirements << "jar org.apache.httpcomponents:httpclient, '~> 4.5.0'"
   spec.requirements << "jar org.apache.httpcomponents:httpmime,   '~> 4.5.0'"

data/spec/manticore/client_proxy_spec.rb

@@ -1,4 +1,5 @@
-require 'spec_helper'
+# encoding: utf-8
+require "spec_helper"
 describe Manticore::Client do
   let(:client) { Manticore::Client.new }
 
@@ -29,7 +30,7 @@ describe Manticore::Client do
           stub.async.get(local_server)
           stub.async.get(local_server)
 
-          expect( client.execute!.map(&:class) ).to eq [Manticore::StubbedResponse, Manticore::StubbedResponse]
+          expect(client.execute!.map(&:class)).to eq [Manticore::StubbedResponse, Manticore::StubbedResponse]
         end
       end
     end
@@ -58,7 +59,7 @@ describe Manticore::Client do
     end
 
     it "can chain handlers" do
-      client.async.get("http://localhost:55441/").on_success {|r| r.code }
+      client.async.get("http://localhost:55441/").on_success { |r| r.code }
       expect(client.execute!.map(&:callback_result)).to eq [200]
     end
   end
@@ -95,4 +96,4 @@ describe Manticore::Client do
       end
     end
   end
-end
+end

data/spec/manticore/client_spec.rb

@@ -1,11 +1,10 @@
 # encoding: utf-8
-require 'spec_helper'
+require "spec_helper"
 
-java_import 'org.apache.http.entity.mime.MultipartEntityBuilder'
-java_import 'org.apache.http.entity.ContentType'
+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
@@ -24,6 +23,12 @@ describe Manticore::Client do
     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)
@@ -46,6 +51,39 @@ describe Manticore::Client do
     expect(j["uri"]["port"]).to eq 55441
   end
 
+  it "automatically decodes application/JSON as UTF-8" do
+    j = JSON.parse client.get(local_server("/json_utf8")).body
+    expect(j["last_name"]).to eq "Töger"
+  end
+
+  context "via an authenticated proxy" do
+    let(:proxy) { "http://localhost:55442" }
+    let(:auth) { nil }
+    let(:j) { JSON.parse req.body }
+
+    context "with authentication as a hash" do
+      let(:auth) { {user: "user", pass: "pass"} }
+      let(:req) { client.get(local_server("/authproxy"), proxy: proxy, auth: auth) }
+
+      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" }
+      let(:req) { client.get(local_server("/authproxy"), proxy: proxy) }
+
+      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
+
   describe "with a custom user agent" do
     let(:client) { Manticore::Client.new user_agent: "test-agent/1.0" }
 
@@ -74,17 +112,21 @@ describe Manticore::Client do
     end
   end
 
-  describe 'ssl settings' do
-    describe 'verify' do
-      context 'default' do
+  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
+
+        it "breaks on SSL expiry errors" do
+          expect { client.get("https://localhost:55446/").call }.to raise_exception(Manticore::ClientProtocolException)
+        end
       end
 
-      context 'when on and no trust store is given' do
+      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
@@ -92,7 +134,7 @@ describe Manticore::Client do
         end
       end
 
-      context 'when on and custom trust store is given' do
+      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
@@ -108,7 +150,7 @@ describe Manticore::Client do
         end
       end
 
-      context 'when on and custom trust store is given with the wrong password' do
+      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
@@ -116,22 +158,58 @@ describe Manticore::Client do
         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__) } }
+      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__)
-          })
+      context "when client_cert and client_key are given as file paths" 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 client_cert and client_key are given as OpenSSL::X509::Certificate" do
+        let(:client) {
+          Manticore::Client.new(
+            :ssl => {
+              verify: :strict,
+              ca_file: File.expand_path("../../ssl/root-ca.crt", __FILE__),
+              client_cert: OpenSSL::X509::Certificate.new(File.read(File.expand_path("../../ssl/client.crt", __FILE__))),
+              client_key: OpenSSL::PKey::RSA.new(File.read(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 client_cert and client_key are given as strings" do
+        let(:client) {
+          Manticore::Client.new(
+            :ssl => {
+              verify: :strict,
+              ca_file: File.expand_path("../../ssl/root-ca.crt", __FILE__),
+              client_cert: File.read(File.expand_path("../../ssl/client.crt", __FILE__)),
+              client_key: File.read(File.expand_path("../../ssl/client.key", __FILE__)),
+            },
+          )
         }
 
         it "successfully auths requests" do
@@ -139,12 +217,16 @@ describe Manticore::Client do
         end
       end
 
-      context 'when off' do
-        let(:client) { Manticore::Client.new :ssl => {:verify => :none} }
+      context "when off" do
+        let(:client) { Manticore::Client.new :ssl => {:verify => :disable} }
 
         it "does not break on SSL validation errors" do
           expect { client.get("https://localhost:55444/").body }.to_not raise_exception
         end
+
+        it "does not break on expired SSL certificates" do
+          expect { client.get("https://localhost:55446/").body }.to_not raise_exception
+        end
       end
 
       context "against a server that verifies clients" do
@@ -155,7 +237,7 @@ describe Manticore::Client do
               truststore_password: "test123",
               keystore: File.expand_path("../../ssl/client.p12", __FILE__),
               keystore_password: "test123",
-              verify: :strict
+              verify: :strict,
             }
             Manticore::Client.new :ssl => options
           }
@@ -170,7 +252,7 @@ describe Manticore::Client do
             options = {
               truststore: File.expand_path("../../ssl/truststore.jks", __FILE__),
               truststore_password: "test123",
-              verify: :strict
+              verify: :strict,
             }
             Manticore::Client.new :ssl => options
           }
@@ -206,40 +288,39 @@ describe Manticore::Client do
         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.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? } }
+      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| }
+      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| }
+      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| }
+      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| }
+      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 }
+          on_failure { |f| failure = f }
         client.execute!
         expect(failure).to be_a(Manticore::InvalidArgumentException)
       end
@@ -251,7 +332,7 @@ describe Manticore::Client do
         # 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 }
+          on_failure { |f| failure = f }
         client.execute!
         expect(failure).to be_a(StandardError)
       end
@@ -368,6 +449,11 @@ describe Manticore::Client do
       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"]
@@ -438,10 +524,10 @@ describe Manticore::Client do
     end
 
     it "sends an arbitrary entity" do
-      f = open(__FILE__, "r").to_inputstream
-      multipart_entity = MultipartEntityBuilder.create.add_text_body("foo", "bar").add_binary_body("whatever", f , ContentType::TEXT_PLAIN, __FILE__)
+      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 "sends an arbitrary entity"
+      expect(response.body).to match "RSpec.configure"
     end
   end
 
@@ -477,7 +563,7 @@ describe Manticore::Client do
   describe "#head" do
     it "works" do
       response = client.head(local_server)
-      expect(JSON.load(response.body)).to be_nil
+      expect(response.body).to be_nil
     end
   end
 
@@ -510,8 +596,8 @@ describe Manticore::Client do
       futures = [55441, 55442].map do |port|
         client.async.get("http://localhost:#{port}/?sleep=1").
           on_success do |response|
-            Time.now.to_f
-          end
+          Time.now.to_f
+        end
       end
 
       client.execute!
@@ -522,7 +608,7 @@ describe Manticore::Client do
     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" }
+          on_success { |response, request| "Result" }
       end
 
       expect(client.execute!.map(&:callback_result)).to eq ["Result", "Result"]
@@ -532,7 +618,7 @@ describe Manticore::Client do
   describe "#clear_pending" do
     it "removes pending requests" do
       ran = false
-      client.async.get("http://google.com").on_success {|r| ran = true }
+      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
@@ -563,25 +649,25 @@ describe Manticore::Client do
       end
     end
 
-    context 'stubbing' do
+    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.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.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.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
 
@@ -613,10 +699,9 @@ describe Manticore::Client do
   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"
+        expect(client.get(url).request["Connection"]).to eq "Keep-Alive"
       end
 
       let(:client) { Manticore::Client.new keepalive: true, pool_max: 1 }
@@ -634,7 +719,7 @@ describe Manticore::Client 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
+        expect(client.get(url).request["Connection"]).to be_nil
       end
 
       it "closes the connection after a request" do
@@ -649,35 +734,54 @@ describe Manticore::Client do
   end
 
   context "with a misbehaving endpoint" do
+    let(:port) do
+      p = 4000
+      server = nil
+      begin
+        server = TCPServer.new p
+      rescue Errno::EADDRINUSE
+        p += 1
+        retry
+      ensure
+        server.close
+      end
+      p
+    end
+
     before do
-      @socket = TCPServer.new 4567
+      @socket = TCPServer.new port
       @server = Thread.new do
         loop do
-          client = @socket.accept
           begin
+            client = @socket.accept
             client.puts([
               "HTTP/1.1 200 OK",
               "Keep-Alive: timeout=3000",
               "Connection: Keep-Alive",
               "Content-Length: 6",
               "",
-              "Hello!"
+              "Hello!",
             ].join("\n"))
             client.close
-          rescue StandardError => e
+          rescue IOError => e
+            break
           end
         end
       end
     end
 
+    after do
+      @server.kill
+    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/")
+      request1 = client.get("http://localhost:#{port}/")
+      request2 = client.get("http://localhost:#{port}/")
       expect { request1.call }.to_not raise_exception
       expect { request2.call }.to_not raise_exception
 
@@ -691,8 +795,8 @@ describe Manticore::Client do
       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)
+        expect { client.get("http://localhost:#{port}/").call }.to_not raise_exception
+        expect { client.get("http://localhost:#{port}/").call }.to raise_exception(Manticore::SocketException)
       end
     end
 
@@ -702,8 +806,8 @@ describe Manticore::Client do
       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/")
+        request1 = client.get("http://localhost:#{port}/")
+        request2 = client.get("http://localhost:#{port}/")
         expect { request1.call }.to_not raise_exception
         expect { request2.call }.to_not raise_exception
 
@@ -714,7 +818,11 @@ describe Manticore::Client do
 
     after do
       Thread.kill @server
-      @socket.close
+      begin
+        @socket.close
+      rescue IOError
+        # pass
+      end
     end
   end
 
@@ -771,15 +879,15 @@ describe Manticore::Client do
 
     describe "background" do
       it "returns a response" do
-        expect( client.background.get(local_server) ).to be_a Manticore::Response
+        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
+        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
+        expect(client.background.get(local_server).call).to be_a Java::JavaUtilConcurrent::FutureTask
       end
 
       it "evaluates immediately when given a block" do
@@ -798,7 +906,7 @@ describe Manticore::Client do
     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)
+    req = pool.requestConnection(Java::OrgApacheHttpConnRouting::HttpRoute.new(Java::OrgApacheHttp::HttpHost.new(host)), nil)
     conn = req.get(3, TimeUnit::SECONDS)
     begin
       yield conn