manticore 0.2.1-java → 0.3.0-java

data/lib/manticore/cookie.rb

@@ -29,7 +29,7 @@ module Manticore
         comment: cookie.get_comment,
         comment_url: cookie.getCommentURL,
         domain: cookie.get_domain,
-        expiry_date: expiry,
+        expires: expiry,
         name: cookie.get_name,
         path: cookie.get_path,
         ports: cookie.get_ports.to_a,
@@ -40,13 +40,33 @@ module Manticore
       )
     end
 
-    attr_reader :comment, :comment_url, :domain, :expiry_date, :name, :path, :ports, :value, :spec_version
+    def self.from_set_cookie(value)
+      opts = {name: nil, value: nil}
+      value.split(";").each do |part|
+        k, v = part.split("=", 2).map(&:strip)
+
+        if opts[:name].nil?
+          opts[:name] = k
+          opts[:value] = v
+        end
+
+        case k.downcase
+        when "domain", "path"
+          opts[k.to_sym] = v
+        when "secure"
+          opts[:secure] = true
+        end
+      end
+      Manticore::Cookie.new opts
+    end
+
+    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)
-      @expiry_date  = args.fetch(:expiry_date, nil)
+      @expires      = args.fetch(:expires, nil)
       @name         = args.fetch(:name, nil)
       @path         = args.fetch(:path, nil)
       @ports        = args.fetch(:ports, nil)

data/lib/manticore/response.rb

@@ -14,40 +14,62 @@ module Manticore
     include_package "org.apache.http.client"
     include_package "org.apache.http.util"
     include_package "org.apache.http.protocol"
-    # java_import "org.manticore.EntityConverter"
+    java_import "org.apache.http.client.protocol.HttpClientContext"
+    java_import 'java.util.concurrent.Callable'
+
     include ResponseHandler
+    include Callable
 
-    attr_reader :headers, :code, :context, :request, :callback_result
+    attr_reader :context, :request, :callback_result, :called
 
     # Creates a new Response
     #
     # @param  request            [HttpRequestBase] The underlying request object
     # @param  context            [HttpContext] The underlying HttpContext
-    # @param  body_handler_block [Proc] And optional block to by yielded to for handling this response
-    def initialize(request, context, body_handler_block)
+    def initialize(client, request, context, &block)
+      @client  = client
       @request = request
       @context = context
-      @handler_block = body_handler_block
+      @handlers = {
+        success:   block || Proc.new {|resp| resp.body },
+        failure:   Proc.new {|ex| raise ex },
+        cancelled: Proc.new {},
+        complete:  []
+      }
     end
 
-    # 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 handle_response(response)
-      @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]} ]
-      if @handler_block
-        @callback_result = @handler_block.call(self)
-      else
-        read_body
+    # Implementation of Callable#call
+    # Used by Manticore::Client to invoke the request tied to this response. Users should never call this directly.
+    def call
+      raise "Already called" if @called
+      @called = true
+      begin
+        @client.execute @request, self, @context
+        execute_complete
+        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
-      self
+      @exception = ex
+      @handlers[:failure].call ex
+      execute_complete
     end
 
-    # Fetch the final resolved URL for this response
+    def fire_and_forget
+      @client.executor.submit self
+    end
+
+    # Fetch the final resolved URL for this response. Will call the request if it has not been called yet.
     #
     # @return [String]
     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
@@ -55,7 +77,7 @@ module Manticore
       URI.join(host, url.to_s)
     end
 
-    # Fetch the body content of this response.
+    # Fetch the body content of this response. Will call the request if it has not been called yet.
     # This fetches the input stream in Ruby; this isn't optimal, but it's faster than
     # fetching the whole thing in Java then UTF-8 encoding it all into a giant Ruby string.
     #
@@ -70,47 +92,127 @@ module Manticore
     #     end
     #
     # @return [String] Reponse body
-    def read_body(&block)
+    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} (Did you forget to read #body from your block?)")
+        raise StreamClosedException.new("Could not read from stream: #{e.message}")
+      # ensure
+      #   @request.release_connection
       end
     end
-    alias_method :body, :read_body
+    alias_method :read_body, :body
+
+    # Returns true if this response has been called (requested and populated) yet
+    def called?
+      !!@called
+    end
+
+    # Return a hash of headers from this response. Will call the request if it has not been called yet.
+    #
+    # @return [Array<string, obj>] Hash of headers. Keys will be lower-case.
+    def headers
+      call_once
+      @headers
+    end
+
+    # Return the response code from this request as an integer. Will call the request if it has not been called yet.
+    #
+    # @return [Integer] The response code
+    def code
+      call_once
+      @code
+    end
 
     # Returns the length of the response body. Returns -1 if content-length is not present in the response.
     #
     # @return [Integer]
     def length
-      (@headers["content-length"] || -1).to_i
+      (headers["content-length"] || -1).to_i
     end
 
     # Returns an array of {Manticore::Cookie Cookies} associated with this request's execution context
     #
     # @return [Array<Manticore::Cookie>]
     def cookies
-      @context.get_cookie_store.get_cookies.inject({}) do |all, java_cookie|
-        c = Cookie.from_java(java_cookie)
-        all[c.name] ||= []
-        all[c.name] << c
-        all
+      call_once
+      @cookies ||= begin
+        @context.get_cookie_store.get_cookies.inject({}) do |all, java_cookie|
+          c = Cookie.from_java(java_cookie)
+          all[c.name] ||= []
+          all[c.name] << c
+          all
+        end
       end
     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
+
+    # Set handler for cancelled requests
+    # @param block Proc which will be invoked on a on a cancelled response.
+    #
+    # @return self
+    def on_complete(&block)
+      @handlers[:complete] = Array(@handlers[:complete]).compact + [block]
+      self
+    end
+    alias_method :complete,     :on_complete
+    alias_method :completed,    :on_complete
+    alias_method :on_completed, :on_complete
+
     private
 
-    def encode(string, charset)
-      return string if charset.nil?
-      begin
-        string.encode(charset)
-      rescue Encoding::ConverterNotFoundError
-        string.encode("utf-8")
-      rescue
-        string
-      end
+    # 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
+      @headers         = Hash[* response.get_all_headers.flat_map {|h| [h.get_name.downcase, h.get_value]} ]
+      @callback_result = @handlers[:success].call(self)
+      nil
+    end
+
+    def call_once
+      call unless called?
+      @called = true
+    end
+
+    def execute_complete
+      @handlers[:complete].each &:call
     end
   end
 end

data/lib/manticore/stubbed_response.rb

@@ -0,0 +1,91 @@
+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[:body] ||= "" if stubs[:code] == 200
+
+      stubs[:headers] ||= {}
+      stubs[:headers] = Hash[*stubs[:headers].flat_map {|k, v| [k.downcase, v] }]
+      stubs[:headers]["content-length"] = stubs[:body].length 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
+      @headers["location"]
+    end
+
+    # Returns the stubbed body of this response.
+    def body
+      @body
+    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
+      @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
+      @handlers[:success].call(self)
+      self
+    end
+  end
+end

data/lib/manticore/version.rb

@@ -1,3 +1,3 @@
 module Manticore
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/lib/manticore.rb

@@ -1,9 +1,18 @@
 require 'java'
+require 'uri'
+require 'cgi'
+require 'cgi/cookie'
+
+jars = ["httpcore-4.3.1", "httpclient-4.3.2-patched", "commons-logging-1.1.3", "commons-codec-1.6.jar"]
+jars.each do |jar|
+  begin
+    require_relative "./jar/#{jar}"
+  rescue LoadError
+    raise "Unable to load #{jar}; is there another version of it in your classpath?"
+  end
+end
+
 # 4.3.x
-require_relative "./jar/httpcore-4.3.1"
-require_relative "./jar/httpclient-4.3.2-patched"
-require_relative "./jar/commons-logging-1.1.3"
-require_relative "./jar/commons-codec-1.6.jar"
 require_relative "./jar/manticore-ext"
 
 org.manticore.Manticore.new.load(JRuby.runtime, false)
@@ -29,9 +38,10 @@ module Manticore
   # Socket breaks, etc
   class SocketException < ManticoreException; end
 
+  require_relative './manticore/client/proxies'
   require_relative './manticore/client'
   require_relative './manticore/response'
-  require_relative './manticore/async_response'
+  require_relative './manticore/stubbed_response'
   require_relative './manticore/cookie'
   require_relative './manticore/facade'
 

data/manticore.gemspec

@@ -19,6 +19,12 @@ Gem::Specification.new do |spec|
   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_dependency "addressable", "~> 2.3"
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"

data/spec/manticore/client_proxy_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+describe Manticore::Client do
+  let(:client) { Manticore::Client.new }
+
+  describe Manticore::Client::StubProxy do
+    describe "#respond_with" do
+      it "should respond with a stubbed response" do
+        client.respond_with(body: "body", code: 200).get(local_server).on_success do |response|
+          response.should be_a Manticore::StubbedResponse
+          response.body.should == "body"
+          response.code.should == 200
+        end
+      end
+
+      context "for synchronous requests" do
+        it "should respond only stub the next subsequent response" do
+          stub = client.respond_with(body: "body", code: 200)
+
+          stub.get(local_server) do |response|
+            response.should be_a Manticore::StubbedResponse
+          end
+
+          stub.get(local_server) do |response|
+            response.should be_a Manticore::Response
+          end
+        end
+      end
+
+      context "for synchronous requests" do
+        it "should respond only stub the next subsequent response" do
+          stub = client.respond_with(body: "body", code: 200)
+
+          stub.async.get(local_server).on_success do |response|
+            response.should be_a Manticore::StubbedResponse
+          end
+
+          stub.async.get(local_server).on_success do |response|
+            response.should be_a Manticore::Response
+          end
+
+          client.execute!
+        end
+      end
+    end
+  end
+
+  describe Manticore::Client::AsyncProxy do
+    it "should not make a request until execute is called" do
+      anchor = Time.now.to_f
+      client.async.get("http://localhost:55441/?sleep=1.6")
+      (Time.now.to_f - anchor).should < 1.0
+
+      anchor = Time.now.to_f
+      client.execute!
+      (Time.now.to_f - anchor).should > 1.0
+    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 Manticore::Client::BackgroundProxy do
+    it "should not block execution" do
+      anchor = Time.now.to_f
+      future = client.background.get("http://localhost:55441/?sleep=1.5")
+      (Time.now.to_f - anchor).should < 1.0
+
+      response = future.get
+      (Time.now.to_f - anchor).should > 1.0
+      response.body.should match(/sleep=1.5/)
+    end
+
+    it "should return a future" do
+      response = client.background.get("http://localhost:55441/")
+      response.should be_a Java::JavaUtilConcurrent::FutureTask
+      response.get
+    end
+  end
+end