manticore 0.2.1-java → 0.3.0-java

data/spec/manticore/client_spec.rb

@@ -37,6 +37,49 @@ describe Manticore::Client do
     j["uri"]["port"].should == 55441
   end
 
+  describe "lazy evaluation" do
+    it "should not call synchronous requests by default" do
+      req = client.get(local_server)
+      req.should_not be_called
+    end
+
+    context "given a lazy request" do
+      subject { client.get(local_server) }
+
+      before do
+        subject.should_not be_called
+        subject.should_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 "should automatically call synchronous requests that pass a handler block" do
+      req = client.get(local_server) {|r| }
+      req.should be_called
+    end
+
+    it "should not call asynchronous requests even if a block is passed" do
+      req = client.async.get(local_server) {|r| }
+      req.should_not be_called
+    end
+
+    it "should not call asynchronous requests when on_success is passed" do
+      req = client.async.get(local_server).on_success {|r| }
+      req.should_not be_called
+    end
+
+    it "should call 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
+  end
+
   context "when client-wide cookie management is disabled" do
     let(:client) { Manticore::Client.new cookies: false }
 
@@ -213,43 +256,12 @@ describe Manticore::Client do
     end
   end
 
-  describe "async methods" do
-    it "should not make a request until execute is called" do
-      anchor = Time.now.to_f
-      client.async_get("http://localhost:55441/?sleep=0.5")
-      (Time.now.to_f - anchor).should < 0.4
-
-      anchor = Time.now.to_f
-      client.execute!
-      (Time.now.to_f - anchor).should > 0.4
-    end
-
-    it "should return 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!
-      success.should == true
-    end
-
-    it "can chain handlers" do
-      client.async_get("http://localhost:55441/").on_success {|r| r.code }
-      client.execute!.map(&:callback_result).should == [200]
-    end
-  end
-
   describe "#execute!" do
     it "should perform multiple concurrent requests" do
       @times = []
       [55441, 55442].each do |port|
-        client.async_get("http://localhost:#{port}/?sleep=1") do |request|
-          request.on_success do |response, request|
-            @times << Time.now.to_f
-          end
-        end
+        client.async.get("http://localhost:#{port}/?sleep=1").
+          on_success {|response| @times << Time.now.to_f }
       end
 
       client.execute!
@@ -258,9 +270,8 @@ describe Manticore::Client do
 
     it "should return the results of the handler blocks" do
       [55441, 55442].each do |port|
-        client.async_get("http://localhost:#{port}/") do |request|
-          request.on_success {|response, request| "Result" }
-        end
+        client.async.get("http://localhost:#{port}/").
+          on_success {|response, request| "Result" }
       end
 
       client.execute!.map(&:callback_result).should == ["Result", "Result"]
@@ -270,10 +281,84 @@ describe Manticore::Client do
   describe "#clear_pending" do
     it "should remove 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
       client.execute!.should be_empty
       ran.should be_false
     end
   end
+
+  describe "#stub" do
+    it "should respond 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
+          response.should be_a Manticore::StubbedResponse
+          response.body.should == "body"
+          response.code.should == 200
+        end
+      }
+
+      called.should be_true
+
+      client.clear_stubs!
+      client.get(local_server) do |response|
+        response.should be_a Manticore::Response
+        response.body.should match(/Manticore/)
+        response.code.should == 200
+      end
+    end
+
+    it "stubs only the provided URLs" do
+      client.stub local_server, body: "body"
+      client.async.get(local_server).on_success {|r| r.should be_a Manticore::StubbedResponse }
+      client.async.get(local_server("/other")).on_success {|r| r.should be_a Manticore::Response }
+      client.execute!
+    end
+  end
+
+  describe "keepalive" do
+    let(:url) { "http://www.facebook.com/" }
+
+    context "with keepalive" do
+      let(:client) { Manticore::Client.new keepalive: true, pool_max: 1 }
+
+      it "should keep the connection open after a request" do
+        pending
+        response = client.get(url).call
+        get_connection(client, url) do |conn|
+          conn.is_open.should be_true
+        end
+      end
+    end
+
+    context "without keepalive" do
+      let(:client) { Manticore::Client.new keepalive: false, pool_max: 1 }
+
+      it "should close the connection after a request" do
+        pending
+        response = client.get(url).call
+        puts `netstat -apn`
+        # get_connection(client, url) do |conn|
+        #   conn.is_open.should be_false
+        # end
+      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

data/spec/manticore/cookie_spec.rb

@@ -9,9 +9,28 @@ describe Manticore::Cookie do
       response.cookies["x"].first
     }
 
-    its(:name)   { should be_a String }
-    its(:value)  { should be_a String }
-    its(:path)   { should be_a String }
-    its(:domain) { should be_a String }
+    its(:name)   { should == "x" }
+    its(:value)  { should == "2" }
+    its(:path)   { should == "/" }
+    its(:domain) { should == "localhost" }
+  end
+
+
+  let(:opts) {{}}
+  subject {
+    Manticore::Cookie.new({name: "foo", value: "bar"}.merge(opts))
+  }
+
+  its(:secure?)     { should be_false }
+  its(:persistent?) { should be_false }
+
+  context "created as secure" do
+    let(:opts) {{ secure: true }}
+    its(:secure?) { should be_true }
+  end
+
+  context "created as persistent" do
+    let(:opts) {{ persistent: true }}
+    its(:persistent?) { should be_true }
   end
 end

data/spec/manticore/response_spec.rb

@@ -26,4 +26,12 @@ describe Manticore::Response do
       expect { response.body }.to raise_exception(Manticore::StreamClosedException)
     end
   end
+
+  context "when an entity fails to read" do
+    it "releases the connection" do
+      stats_before = client.pool_stats
+      Manticore::EntityConverter.any_instance.should_receive(:read_entity).and_raise(Manticore::StreamClosedException)
+      expect { client.get(local_server).call rescue nil }.to_not change { client.pool_stats[:available] }
+    end
+  end
 end

data/spec/manticore/stubbed_response_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Manticore::StubbedResponse do
+  subject {
+    Manticore::StubbedResponse.stub(
+      body: "test body",
+      code: 200,
+      headers: {
+        "Content-Type" => "text/plain",
+        "Set-Cookie" => ["k=v; path=/; domain=localhost", "k=v; path=/sub; domain=sub.localhost", "k2=v2;2 path=/; domain=localhost"]
+      },
+      cookies: {"test" => Manticore::Cookie.new(name: "test", value: "something", path: "/")}
+    ).call
+  }
+
+  it { should be_a Manticore::Response }
+  its(:body) { should == "test body" }
+  its(:code) { should == 200 }
+
+  it "should persist the set headers" do
+    subject.headers["content-type"].should == "text/plain"
+  end
+
+  it "should set content-length from the body" do
+    subject.headers["content-length"].should == 9
+  end
+
+  it "should persist cookies passed as explicit cookie objects" do
+    subject.cookies["test"].first.value.should == "something"
+  end
+
+  it "should call on_success handlers" do
+    called = false
+    Manticore::StubbedResponse.stub.on_success {|resp| called = true }.call
+    called.should be_true
+  end
+
+  it "should persist cookies passed in set-cookie" do
+    subject.cookies["k"].map(&:value).should  =~ ["v", "v"]
+    subject.cookies["k"].map(&:path).should   =~ ["/", "/sub"]
+    subject.cookies["k"].map(&:domain).should =~ ["localhost", "sub.localhost"]
+    subject.cookies["k2"].first.value.should == "v2"
+  end
+end

data/spec/spec_helper.rb

@@ -56,6 +56,9 @@ def start_server(port = PORT)
       elsif request[:uri][:path] == "/proxy"
         payload = JSON.dump(request.merge(server_port: port))
         [200, {'Content-Type' => content_type, "Content-Length" => payload.length}, [payload]]
+      elsif request[:uri][:path] == "/keepalive"
+        payload = JSON.dump(request.merge(server_port: port))
+        [200, {'Content-Type' => content_type, "Content-Length" => payload.length, "Keep-Alive" => "timeout=60"}, [payload]]
       elsif request[:headers]["X-Redirect"] && request[:uri][:path] != request[:headers]["X-Redirect"]
         [301, {"Location" => local_server( request[:headers]["X-Redirect"] )}, [""]]
       else

metadata

@@ -1,14 +1,36 @@
 --- !ruby/object:Gem::Specification
 name: manticore
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: java
 authors:
 - Chris Heald
 autorequire:
 bindir: bin
-cert_chain: []
-date: 2014-02-23 00:00:00.000000000 Z
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDaDCCAlCgAwIBAgIBATANBgkqhkiG9w0BAQUFADA9MQ8wDQYDVQQDDAZjaGVh
+  bGQxFTATBgoJkiaJk/IsZAEZFgVnbWFpbDETMBEGCgmSJomT8ixkARkWA2NvbTAe
+  Fw0xNDAzMDEyMTE4MzJaFw0xNTAzMDEyMTE4MzJaMD0xDzANBgNVBAMMBmNoZWFs
+  ZDEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYKCZImiZPyLGQBGRYDY29tMIIB
+  IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwcnX2yl+rbjUztC4V+iUJgWv
+  NPxqU4bQBaL+w00wVABWr04Hjg+cEkqiJ6A0kXxZIz5uXKhhvsaO50NvHfplVcUf
+  BxQabIfCS79xdvexXN0or3F5saatGaGa4cj/0uUHjX7w+K5MpEVfbjJp0uAKp62B
+  wUU2ilmn7EvZhEUPOMQi01t8z8OsOGc8kF2UtU1kGCxLV7eThWqu8CdXrux5E140
+  7SnFnPlnXNeHqwZdOMZzQ9PiTQAPCKO3AY0aBFQeG3wlFPqkcEjOrtV1h7werUwz
+  aNb4t5sAuu0f/9B646BOjiMgj1WeUlhgiAsaF5kVvLFNCxwS/xpcN3X01M2KdQID
+  AQABo3MwcTAJBgNVHRMEAjAAMAsGA1UdDwQEAwIEsDAdBgNVHQ4EFgQUtFVpwfEG
+  78mBd2ulzsS+SlffdOcwGwYDVR0RBBQwEoEQY2hlYWxkQGdtYWlsLmNvbTAbBgNV
+  HRIEFDASgRBjaGVhbGRAZ21haWwuY29tMA0GCSqGSIb3DQEBBQUAA4IBAQANcBIJ
+  vIk27iNu4Ic6awNRy4Rd2YchzW4DaMhfpTXxtYWgAE502OdqUTFtmihd2PmnVRIP
+  xdP5K2SpbCLuLKFCZ825qp8R02JSNMdgi2d4Btl0vHSO8O3lQ1ZAOM1BZPn2+Kbn
+  KsiSURg3SnDXItcoedMsS+CQdNyBSdqvpkQ5gn22dN4BSwJg5ApwEYJ9tTuTpRXt
+  1KCQFe5hamoenfoHO6uUXPEs24PUHnXl8QibWCLbt1FIBpTrJYNGiMHHnB7ip+zv
+  E7PWS50D9moUJ6xWcemf0qKYC87qBFh0ng73awjG9uf+13lMslqJRMtek8C92cvh
+  +R9zgQlbeNjy9O1i
+  -----END CERTIFICATE-----
+date: 2014-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -62,11 +84,13 @@ files:
 - .gitignore
 - .travis.yml
 - APACHE-LICENSE-2.0.txt
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - ext/manticore/org/manticore/Manticore.java
+- gem-public_cert.pem
 - lib/jar/commons-codec-1.6.jar
 - lib/jar/commons-logging-1.1.3.jar
 - lib/jar/httpclient-4.3.2-patched.jar
@@ -74,17 +98,20 @@ files:
 - lib/jar/lazy_decompressing_stream.patch
 - lib/jar/manticore-ext.jar
 - lib/manticore.rb
-- lib/manticore/async_response.rb
 - lib/manticore/client.rb
+- lib/manticore/client/proxies.rb
 - lib/manticore/cookie.rb
 - lib/manticore/facade.rb
 - lib/manticore/response.rb
+- lib/manticore/stubbed_response.rb
 - lib/manticore/version.rb
 - manticore.gemspec
+- spec/manticore/client_proxy_spec.rb
 - spec/manticore/client_spec.rb
 - spec/manticore/cookie_spec.rb
 - spec/manticore/facade_spec.rb
 - spec/manticore/response_spec.rb
+- spec/manticore/stubbed_response_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/cheald/manticore
 licenses:
@@ -111,8 +138,10 @@ signing_key:
 specification_version: 4
 summary: Manticore is an HTTP client built on the Apache HttpCore components
 test_files:
+- spec/manticore/client_proxy_spec.rb
 - spec/manticore/client_spec.rb
 - spec/manticore/cookie_spec.rb
 - spec/manticore/facade_spec.rb
 - spec/manticore/response_spec.rb
+- spec/manticore/stubbed_response_spec.rb
 - spec/spec_helper.rb

data/lib/manticore/async_response.rb

@@ -1,88 +0,0 @@
-module Manticore
-  # AsyncResponse is a runnable/future that encapsulates a request to be run asynchronously. It is created by Client#async_* calls.
-  class AsyncResponse < Response
-    java_import 'java.util.concurrent.Callable'
-
-    include Callable
-
-    # Creates a new AsyncResponse. The response is not realized until the client associated
-    # with this response calls #execute!
-    def initialize(client, request, context, body_handler_block)
-      @client = client
-      @handlers = {
-        success:   Proc.new {|resp| resp.body },
-        failure:   Proc.new {},
-        cancelled: Proc.new {}
-      }
-      body_handler_block.call(self) if body_handler_block
-      super request, context, nil
-    end
-
-    # @private
-    # Implementation of Callable#call
-    def call
-      ex = nil
-      begin
-        @client.execute @request, self, @context
-        return self
-      rescue Java::JavaNet::SocketTimeoutException, Java::OrgApacheHttpConn::ConnectTimeoutException, Java::OrgApacheHttp::NoHttpResponseException => e
-        ex = Manticore::Timeout.new(e.get_cause)
-      rescue Java::JavaNet::SocketException => e
-        ex = Manticore::SocketException.new(e.get_cause)
-      rescue Java::OrgApacheHttpClient::ClientProtocolException, Java::JavaxNetSsl::SSLHandshakeException, Java::OrgApacheHttpConn::HttpHostConnectException => e
-        ex = Manticore::ClientProtocolException.new(e.get_cause)
-      rescue Java::JavaNet::UnknownHostException => e
-        ex = Manticore::ResolutionFailure.new(e.get_cause)
-      end
-      @handlers[:failure].call ex
-    end
-
-    # Set handler for success responses
-    # @param block Proc which will be invoked on a successful response. Block will receive |response, request|
-    #
-    # @return self
-    def on_success(&block)
-      @handlers[:success] = block
-      self
-    end
-    alias_method :success, :on_success
-
-    # Set handler for failure responses
-    # @param block Proc which will be invoked on a on a failed response. Block will receive an exception object.
-    #
-    # @return self
-    def on_failure(&block)
-      @handlers[:failure] = block
-      self
-    end
-    alias_method :failure, :on_failure
-    alias_method :fail,    :on_failure
-
-    # Set handler for cancelled requests
-    # @param block Proc which will be invoked on a on a cancelled response.
-    #
-    # @return self
-    def on_cancelled(&block)
-      @handlers[:cancelled] = block
-      self
-    end
-    alias_method :cancelled,       :on_cancelled
-    alias_method :cancellation,    :on_cancelled
-    alias_method :on_cancellation, :on_cancelled
-
-    private
-
-    # @private
-    def handle_response(response)
-      begin
-        @response = response
-        @code     = response.get_status_line.get_status_code
-        @headers  = Hash[* response.get_all_headers.flat_map {|h| [h.get_name.downcase, h.get_value]} ]
-        @callback_result = @handlers[:success].call(self)
-        nil
-      rescue => e
-        @exception = e
-      end
-    end
-  end
-end