akephalos-nerian 0.2.4-java

data/lib/akephalos/client.rb

@@ -0,0 +1,112 @@
+require 'akephalos/configuration'
+
+if RUBY_PLATFORM != "java"
+  require 'akephalos/remote_client'
+  Akephalos::Client = Akephalos::RemoteClient
+else
+  require 'akephalos/htmlunit'
+  require 'akephalos/htmlunit/ext/http_method'
+
+  require 'akephalos/page'
+  require 'akephalos/node'
+
+  require 'akephalos/client/cookies'
+  require 'akephalos/client/filter'
+
+  module Akephalos
+
+    # Akephalos::Client wraps HtmlUnit's WebClient class. It is the main entry
+    # point for all interaction with the browser, exposing its current page and
+    # allowing navigation.
+    class Client
+      attr_reader :page
+
+      def initialize
+        @_client = java.util.concurrent.FutureTask.new do
+          client = HtmlUnit::WebClient.new
+
+          Filter.new(client)                           
+          client.setThrowExceptionOnFailingStatusCode(false)
+          client.setAjaxController(HtmlUnit::NicelyResynchronizingAjaxController.new)
+          client.setCssErrorHandler(HtmlUnit::SilentCssErrorHandler.new)
+          client.setThrowExceptionOnScriptError(false);
+          client
+        end
+        Thread.new { @_client.run }
+      end
+
+      # Set the global configuration settings for Akephalos.
+      #
+      # @note This is only used when communicating over DRb, since just a
+      # single client instance is exposed.
+      # @param [Hash] config the configuration settings
+      # @return [Hash] the configuration
+      def configuration=(config)
+        Akephalos.configuration = config
+      end
+
+      # Visit the requested URL and return the page.
+      #
+      # @param [String] url the URL to load
+      # @return [Page] the loaded page
+      def visit(url)
+        client.getPage(url)
+        page
+      end
+
+      # @return [Cookies] the cookies for this session
+      def cookies
+        @cookies ||= Cookies.new(client.getCookieManager)
+      end
+
+      # @return [String] the current user agent string
+      def user_agent
+        @user_agent || client.getBrowserVersion.getUserAgent
+      end
+
+      # Set the User-Agent header for this session. If :default is given, the
+      # User-Agent header will be reset to the default browser's user agent.
+      #
+      # @param [:default] user_agent the default user agent
+      # @param [String] user_agent the user agent string to use
+      def user_agent=(user_agent)
+        if user_agent == :default
+          @user_agent = nil
+          client.removeRequestHeader("User-Agent")
+        else
+          @user_agent = user_agent
+          client.addRequestHeader("User-Agent", user_agent)
+        end
+      end
+
+      # @return [Page] the current page
+      def page
+        self.page = client.getCurrentWindow.getTopWindow.getEnclosedPage
+        @page
+      end
+
+      # Update the current page.
+      #
+      # @param [HtmlUnit::HtmlPage] _page the new page
+      # @return [Page] the new page
+      def page=(_page)
+        if @page != _page
+          @page = Page.new(_page)
+        end
+        @page
+      end
+
+      private
+
+      # Call the future set up in #initialize and return the WebCLient
+      # instance.
+      #
+      # @return [HtmlUnit::WebClient] the WebClient instance
+      def client
+        @client ||= @_client.get.tap do |client|
+          client.getCurrentWindow.getHistory.ignoreNewPages_.set(true)
+        end
+      end
+    end
+  end
+end

data/lib/akephalos/client/cookies.rb

@@ -0,0 +1,73 @@
+module Akephalos
+  class Client
+    # Interface for working with HtmlUnit's CookieManager, providing a basic
+    # API for manipulating the cookies in a session.
+    class Cookies
+      include Enumerable
+
+      # @param [HtmlUnit::CookieManager] cookie manager
+      def initialize(cookie_manager)
+        @cookie_manager = cookie_manager
+      end
+
+      # @param [name] the cookie name
+      # @return [Cookie] the cookie with the given name
+      # @return [nil] when no cookie is found
+      def [](name)
+        cookie = @cookie_manager.getCookie(name)
+        Cookie.new(cookie) if cookie
+      end
+
+      # Clears all cookies for this session.
+      def clear
+        @cookie_manager.clearCookies
+      end
+
+      # Iterator for all cookies in the current session.
+      def each
+        @cookie_manager.getCookies.each do |cookie|
+          yield Cookie.new(cookie)
+        end
+      end
+
+      # Remove the cookie from the session.
+      #
+      # @param [Cookie] the cookie to remove
+      def delete(cookie)
+        @cookie_manager.removeCookie(cookie.native)
+      end
+
+      # @return [true, false] whether there are any cookies
+      def empty?
+        !any?
+      end
+
+      class Cookie
+
+        attr_reader :domain, :expires, :name, :path, :value
+
+        # @param [HtmlUnit::Cookie] the cookie
+        def initialize(cookie)
+          @_cookie = cookie
+          @domain = cookie.getDomain
+          @expires = cookie.getExpires
+          @name = cookie.getName
+          @path = cookie.getPath
+          @value = cookie.getValue
+          @secure = cookie.isSecure
+        end
+
+        def secure?
+          !!@secure
+        end
+
+        # @return [HtmlUnit::Cookie] the native cookie object
+        # @api private
+        def native
+          @_cookie
+        end
+      end
+
+    end
+  end
+end

data/lib/akephalos/client/filter.rb

@@ -0,0 +1,120 @@
+module Akephalos
+  class Client
+
+    # Akephalos::Client::Filter extends HtmlUnit's WebConnectionWrapper to
+    # enable filtering outgoing requests generated interally by HtmlUnit.
+    #
+    # When a request comes through, it will be tested against the filters
+    # defined in Akephalos.filters and return a mock response if a match is
+    # found. If no filters are defined, or no filters match the request, then
+    # the response will bubble up to HtmlUnit for the normal request/response
+    # cycle.
+    class Filter < HtmlUnit::Util::WebConnectionWrapper
+      # Filters an outgoing request, and if a match is found, returns the mock
+      # response.
+      #
+      # @param [WebRequest] request the pending HTTP request
+      # @return [WebResponseImpl] when the request matches a defined filter
+      # @return [nil] when no filters match the request
+      def filter(request)
+        if filter = find_filter(request)
+          start_time = Time.now
+          headers = filter[:headers].map do |name, value|
+            HtmlUnit::Util::NameValuePair.new(name.to_s, value.to_s)
+          end
+          response = HtmlUnit::WebResponseData.new(
+            filter[:body].to_s.to_java_bytes,
+            filter[:status],
+            HTTP_STATUS_CODES.fetch(filter[:status], "Unknown"),
+            headers
+          )
+          HtmlUnit::WebResponseImpl.new(response, request, Time.now - start_time)
+        end
+      end
+
+      # Searches for a filter which matches the request's HTTP method and url.
+      #
+      # @param [WebRequest] request the pending HTTP request
+      # @return [Hash] when a filter matches the request
+      # @return [nil] when no filters match the request
+      def find_filter(request)
+        Akephalos.filters.find do |filter|
+          request.http_method === filter[:method] && request.url.to_s =~ filter[:filter]
+        end
+      end
+
+      # This method is called by WebClient when a page is requested, and will
+      # return a mock response if the request matches a defined filter or else
+      # return the actual response.
+      #
+      # @api htmlunit
+      # @param [WebRequest] request the pending HTTP request
+      # @return [WebResponseImpl]
+      def getResponse(request)
+        filter(request) || super
+      end
+
+      # Map of status codes to their English descriptions.
+      HTTP_STATUS_CODES = {
+        100 => "Continue",
+        101 => "Switching Protocols",
+        102 => "Processing",
+        200 => "OK",
+        201 => "Created",
+        202 => "Accepted",
+        203 => "Non-Authoritative Information",
+        204 => "No Content",
+        205 => "Reset Content",
+        206 => "Partial Content",
+        207 => "Multi-Status",
+        300 => "Multiple Choices",
+        301 => "Moved Permanently",
+        302 => "Found",
+        303 => "See Other",
+        304 => "Not Modified",
+        305 => "Use Proxy",
+        306 => "Switch Proxy",
+        307 => "Temporary Redirect",
+        400 => "Bad Request",
+        401 => "Unauthorized",
+        402 => "Payment Required",
+        403 => "Forbidden",
+        404 => "Not Found",
+        405 => "Method Not Allowed",
+        406 => "Not Acceptable",
+        407 => "Proxy Authentication Required",
+        408 => "Request Timeout",
+        409 => "Conflict",
+        410 => "Gone",
+        411 => "Length Required",
+        412 => "Precondition Failed",
+        413 => "Request Entity Too Large",
+        414 => "Request-URI Too Long",
+        415 => "Unsupported Media Type",
+        416 => "Requested Range Not Satisfiable",
+        417 => "Expectation Failed",
+        418 => "I'm a teapot",
+        421 => "There are too many connections from your internet address",
+        422 => "Unprocessable Entity",
+        423 => "Locked",
+        424 => "Failed Dependency",
+        425 => "Unordered Collection",
+        426 => "Upgrade Required",
+        449 => "Retry With",
+        450 => "Blocked by Windows Parental Controls",
+        500 => "Internal Server Error",
+        501 => "Not Implemented",
+        502 => "Bad Gateway",
+        503 => "Service Unavailable",
+        504 => "Gateway Timeout",
+        505 => "HTTP Version Not Supported",
+        506 => "Variant Also Negotiates",
+        507 => "Insufficient Storage",
+        509 => "Bandwidth Limit Exceeded",
+        510 => "Not Extended",
+        530 => "User access denied"
+      }.freeze
+    end
+
+  end
+end

data/lib/akephalos/configuration.rb

@@ -0,0 +1,49 @@
+module Akephalos
+
+  @configuration = {}
+
+  class << self
+    # @return [Hash] the configuration
+    attr_accessor :configuration
+  end
+
+  module Filters
+    # @return [Array] all defined filters
+    def filters
+      configuration[:filters] ||= []
+    end
+
+    # Defines a new filter to be tested by Akephalos::Filter when executing
+    # page requests. An HTTP method and a regex or string to match against the
+    # URL are required for defining a filter.
+    #
+    # You can additionally pass the following options to define how the
+    # filtered request should respond:
+    #
+    #   :status       (defaults to 200)
+    #   :body         (defaults to "")
+    #   :headers      (defaults to {})
+    #
+    # If we define a filter with no additional options, then, we will get an
+    # empty HTML response:
+    #
+    #   Akephalos.filter :post, "http://example.com"
+    #   Akephalos.filter :any, %r{http://.*\.com}
+    #
+    # If you instead, say, wanted to simulate a failure in an external system,
+    # you could do this:
+    #
+    #   Akephalos.filter :post, "http://example.com",
+    #     :status => 500, :body => "Something went wrong"
+    #
+    # @param [Symbol] method the HTTP method to match
+    # @param [RegExp, String] regex URL matcher
+    # @param [Hash] options response values
+    def filter(method, regex, options = {})
+      regex = Regexp.new(Regexp.escape(regex)) if regex.is_a?(String)
+      filters << {:method => method, :filter => regex, :status => 200, :body => "", :headers => {}}.merge!(options)
+    end
+  end
+
+  extend Filters
+end

data/lib/akephalos/console.rb

@@ -0,0 +1,32 @@
+# Begin a new Capybara session, by default connecting to localhost on port
+# 3000.
+def session
+  Capybara.app_host ||= "http://localhost:3000"
+  @session ||= Capybara::Session.new(:Akephalos)
+end
+alias page session
+
+module Akephalos
+  # Simple class for starting an IRB session.
+  class Console
+
+    # Start an IRB session. Tries to load irb/completion, and also loads a
+    # .irbrc file if it exists.
+    def self.start
+      require 'irb'
+
+      begin
+        require 'irb/completion'
+      rescue Exception
+        # No readline available, proceed anyway.
+      end
+
+      if ::File.exists? ".irbrc"
+        ENV['IRBRC'] = ".irbrc"
+      end
+
+      IRB.start
+    end
+
+  end
+end

data/lib/akephalos/cucumber.rb

@@ -0,0 +1,6 @@
+require 'capybara/cucumber'
+
+Before('@akephalos') do
+  Capybara.current_driver = :akephalos
+end
+

data/lib/akephalos/htmlunit.rb

@@ -0,0 +1,38 @@
+require "pathname"
+require "java"
+
+dependency_directory = $:.detect { |path| Dir[File.join(path, 'htmlunit/htmlunit-*.jar')].any? }
+
+raise "Could not find htmlunit/htmlunit-VERSION.jar in load path:\n  [ #{$:.join(",\n    ")}\n  ]" unless dependency_directory
+
+Dir[File.join(dependency_directory, "htmlunit/*.jar")].each do |jar|
+  require jar
+end
+
+java.lang.System.setProperty("org.apache.commons.logging.Log", "org.apache.commons.logging.impl.SimpleLog")
+java.lang.System.setProperty("org.apache.commons.logging.simplelog.defaultlog", "fatal")
+java.lang.System.setProperty("org.apache.commons.logging.simplelog.showdatetime", "true")
+
+# Container module for com.gargoylesoftware.htmlunit namespace.
+module HtmlUnit
+  java_import "com.gargoylesoftware.htmlunit.BrowserVersion"
+  java_import "com.gargoylesoftware.htmlunit.History"
+  java_import "com.gargoylesoftware.htmlunit.HttpMethod"
+  java_import "com.gargoylesoftware.htmlunit.NicelyResynchronizingAjaxController"
+  java_import "com.gargoylesoftware.htmlunit.SilentCssErrorHandler"
+  java_import "com.gargoylesoftware.htmlunit.WebClient"
+  java_import "com.gargoylesoftware.htmlunit.WebResponseData"
+  java_import "com.gargoylesoftware.htmlunit.WebResponseImpl"
+
+  # Container module for com.gargoylesoftware.htmlunit.util namespace.
+  module Util
+    java_import "com.gargoylesoftware.htmlunit.util.NameValuePair"
+    java_import "com.gargoylesoftware.htmlunit.util.WebConnectionWrapper"
+  end
+
+  # Disable history tracking
+  History.field_reader :ignoreNewPages_
+
+  # Run in Firefox compatibility mode
+  BrowserVersion.setDefault(BrowserVersion::FIREFOX_3)
+end

data/lib/akephalos/htmlunit/ext/http_method.rb

@@ -0,0 +1,30 @@
+module HtmlUnit
+  # Reopen HtmlUnit's HttpMethod class to add convenience methods.
+  class HttpMethod
+
+    # Loosely compare HttpMethod with another object, accepting either an
+    # HttpMethod instance or a symbol describing the method. Note that :any is a
+    # special symbol which will always return true.
+    #
+    # @param [HttpMethod] other an HtmlUnit HttpMethod object
+    # @param [Symbol] other a symbolized representation of an http method
+    # @return [true/false]
+    def ===(other)
+      case other
+      when HttpMethod
+        super
+      when :any
+        true
+      when :get
+        self == self.class::GET
+      when :post
+        self == self.class::POST
+      when :put
+        self == self.class::PUT
+      when :delete
+        self == self.class::DELETE
+      end
+    end
+
+  end
+end