akephalos2-stable 2.1.1.1

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 [WebResponse] 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::WebResponse.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 [WebResponse]
+      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,31 @@
+require "pathname"
+require "java"
+
+Dir["#{Dir.pwd}/.akephalos/#{ENV['htmlunit_version']}/*.jar"].each {|file| require file }
+
+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.ConfirmHandler'
+  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.WebResponse"
+  java_import "com.gargoylesoftware.htmlunit.WaitingRefreshHandler"
+
+  # 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_
+end

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

@@ -0,0 +1,18 @@
+# Reopen com.gargoylesoftware.htmlunit.ConfirmHandler to provide an interface to
+# confirm a dialog and capture its message
+module HtmlUnit
+  module ConfirmHandler
+
+    # Boolean - true for ok, false for cancel
+    attr_accessor :handleConfirmValue
+
+    # last confirmation's message
+    attr_reader   :text
+
+    # handleConfirm will be called by htmlunit on a confirm, so store the message.
+    def handleConfirm(page, message)
+      @text = message
+      return handleConfirmValue.nil? ? true : handleConfirmValue
+    end
+  end
+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

data/lib/akephalos/htmlunit_downloader.rb

@@ -0,0 +1,38 @@
+module HtmlUnit
+  def self.download_htmlunit(version)
+    if not version_exist?(version)
+      puts "Installing HTMLUnit #{version} at .akephalos/#{version}/"
+      Dir.mkdir(".akephalos") unless File.exists?(".akephalos")
+      Dir.mkdir(".akephalos/#{version}") unless File.exists?(".akephalos/#{version}")
+      download(version)
+      unzip(version)
+      remove_cache(version)
+    else
+      puts "Using HTMLUnit #{version}"
+    end
+  end
+
+  def self.version_exist?(version)
+    File.exist?(".akephalos/#{version}/htmlunit-#{version}.jar")
+  end
+
+  def self.unzip(version)
+    `tar xzf htmlunit-#{version}.zip`
+    `mv -f htmlunit-2.10-SNAPSHOT htmlunit-2.10 > /dev/null 2>&1`
+    `cp -r htmlunit-#{version}/lib/ .akephalos/#{version}/`
+  end
+
+  def self.download(version)
+    if version == "2.10"
+      %x[curl -L -o htmlunit-2.10.zip  http://build.canoo.com/htmlunit/artifacts/htmlunit-2.10-SNAPSHOT-with-dependencies.zip]
+    elsif version == '2.9'
+      %x[curl -L -o htmlunit-2.9.zip  http://sourceforge.net/projects/htmlunit/files/htmlunit/2.9/htmlunit-2.9-bin.zip]
+    else
+      %x[curl -L -O http://sourceforge.net/projects/htmlunit/files/htmlunit/#{version}/htmlunit-#{version}.zip]
+    end
+  end
+
+  def self.remove_cache(version)
+    `rm -rf htmlunit-#{version} htmlunit-#{version}.zip`
+  end
+end

data/lib/akephalos/node.rb

@@ -0,0 +1,187 @@
+module Akephalos
+
+  # Akephalos::Node wraps HtmlUnit's DOMNode class, providing a simple API for
+  # interacting with an element on the page.
+  class Node
+    # @param [HtmlUnit::DOMNode] node
+    def initialize(node)
+      @nodes = []
+      @_node = node
+    end
+
+    # @return [true, false] whether the element is checked
+    def checked?
+      if @_node.respond_to?(:isChecked)
+        @_node.isChecked
+      else
+        !! self[:checked]
+      end
+    end
+
+    # @return [String] inner text of the node
+    # Returns a textual representation of this element that represents what would
+    # be visible to the user if this page was shown in a web browser.
+    # For example, a single-selection select element would return the currently
+    # selected value as text.
+    # Note: This will cleanup/reduce whitespace
+     def text
+       @_node.asText
+     end
+
+    # Returns the raw text content of this node and its descendants...
+    def text_content
+      @_node.getTextContent
+    end
+
+    # Returns a string representation of the XML document from this element and
+    # all it's children (recursively). The charset used is the current page encoding.
+    def xml
+      @_node.asXml
+    end
+
+    # Return the value of the node's attribute.
+    #
+    # @param [String] name attribute on node
+    # @return [String] the value of the named attribute
+    # @return [nil] when the node does not have the named attribute
+    def [](name)
+      @_node.hasAttribute(name.to_s) ? @_node.getAttribute(name.to_s) : nil
+    end
+
+    # Return the value of a form element. If the element is a select box and
+    # has "multiple" declared as an attribute, then all selected options will
+    # be returned as an array.
+    #
+    # @return [String, Array<String>] the node's value
+    def value
+      case tag_name
+      when "select"
+        if self[:multiple]
+          selected_options.map { |option| option.value }
+        else
+          selected_option = @_node.selected_options.first
+          selected_option ? Node.new(selected_option).value : nil
+        end
+      when "option"
+        self[:value] || text
+      when "textarea"
+        @_node.getText
+      else
+        self[:value]
+      end
+    end
+
+    # Set the value of the form input.
+    #
+    # @param [String] value
+    def value=(value)
+      case tag_name
+      when "textarea"
+        @_node.setText("")
+        type(value)
+      when "input"
+        if file_input?
+          @_node.setValueAttribute(value)
+        else
+          @_node.setValueAttribute("")
+          type(value)
+        end
+      end
+    end
+
+    # Types each character into a text or input field.
+    #
+    # @param [String] value the string to type
+    def type(value)
+      value.each_char do |c|
+        @_node.type(c)
+      end
+    end
+
+    # @return [true, false] whether the node allows multiple-option selection (if the node is a select).
+    def multiple_select?
+      !self[:multiple].nil?
+    end
+
+    # @return [true, false] whether the node is a file input
+    def file_input?
+      tag_name == "input" && @_node.getAttribute("type") == "file"
+    end
+
+
+    # Unselect an option.
+    #
+    # @return [true, false] whether the unselection was successful
+    def unselect
+      @_node.setSelected(false)
+    end
+
+    # Return the option elements for a select box.
+    #
+    # @return [Array<Node>] the options
+    def options
+      @_node.getOptions.map { |node| Node.new(node) }
+    end
+
+    # Return the selected option elements for a select box.
+    #
+    # @return [Array<Node>] the selected options
+    def selected_options
+      @_node.getSelectedOptions.map { |node| Node.new(node) }
+    end
+
+    # Fire a JavaScript event on the current node. Note that you should not
+    # prefix event names with "on", so:
+    #
+    #   link.fire_event('mousedown')
+    #
+    # @param [String] JavaScript event name
+    def fire_event(name)
+      @_node.fireEvent(name)
+    end
+
+    # @return [String] the node's tag name
+    def tag_name
+      @_node.getNodeName
+    end
+
+    # @return [true, false] whether the node is visible to the user accounting
+    # for CSS.
+    def visible?
+      @_node.isDisplayed
+    end
+
+    # @return [true, false] whether the node is selected to the user accounting
+    # for CSS.
+    def selected?
+      if @_node.respond_to?(:isSelected)
+        @_node.isSelected
+      else
+        !! self[:selected]
+      end
+    end
+
+    # Click the node and then wait for any triggered JavaScript callbacks to
+    # fire.
+    def click
+      @_node.click
+      @_node.getPage.getWebClient.waitForBackgroundJavaScriptStartingBefore(3000)
+    end
+
+    # Search for child nodes which match the given XPath selector.
+    #
+    # @param [String] selector an XPath selector
+    # @return [Array<Node>] the matched nodes
+    def find(selector)
+      nodes = @_node.getByXPath(selector).map { |node| Node.new(node) }
+      @nodes << nodes
+      nodes
+    end
+
+    # @return [String] the XPath expression for this node
+    def xpath
+      @_node.getCanonicalXPath
+    end
+  end
+
+end