akephalos-2s 0.2.4

data/lib/akephalos/node.rb

@@ -0,0 +1,132 @@
+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?
+      @_node.isChecked
+    end
+
+    # @return [String] inner text of the node
+    def text
+      @_node.asText
+    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(value)
+      when "input"
+        @_node.setValueAttribute(value)
+      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
+
+    # 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
+
+    # Click the node and then wait for any triggered JavaScript callbacks to
+    # fire.
+    def click
+      @_node.click
+      @_node.getPage.getEnclosingWindow.getJobManager.waitForJobs(1000)
+      @_node.getPage.getEnclosingWindow.getJobManager.waitForJobsStartingBefore(1000)
+    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
+  end
+
+end

data/lib/akephalos/page.rb

@@ -0,0 +1,113 @@
+module Akephalos
+
+  # Akephalos::Page wraps HtmlUnit's HtmlPage class, exposing an API for
+  # interacting with a page in the browser.
+  class Page
+    # @param [HtmlUnit::HtmlPage] page
+    def initialize(page)
+      @nodes = []
+      @_page = page
+    end
+
+    # Search for nodes which match the given XPath selector.
+    #
+    # @param [String] selector an XPath selector
+    # @return [Array<Node>] the matched nodes
+    def find(selector)
+      nodes = current_frame.getByXPath(selector).map { |node| Node.new(node) }
+      @nodes << nodes
+      nodes
+    end
+
+    # Return the page's source, including any JavaScript-triggered DOM changes.
+    #
+    # @return [String] the page's modified source
+    def modified_source
+      current_frame.asXml
+    end
+
+    # Return the page's source as returned by the web server.
+    #
+    # @return [String] the page's original source
+    def source
+      current_frame.getWebResponse.getContentAsString
+    end
+
+    # @return [Hash{String => String}] the page's response headers
+    def response_headers
+      headers = current_frame.getWebResponse.getResponseHeaders.map do |header|
+        [header.getName, header.getValue]
+      end
+      Hash[*headers.flatten]
+    end
+
+    # @return [Integer] the response's status code
+    def status_code
+      current_frame.getWebResponse.getStatusCode
+    end
+
+    # Execute the given block in the context of the frame specified.
+    #
+    # @param [String] frame_id the frame's id
+    # @return [true] if the frame is found
+    # @return [nil] if the frame is not found
+    def within_frame(frame_id)
+      return unless @current_frame = find_frame(frame_id)
+      yield
+      true
+    ensure
+      @current_frame = nil
+    end
+
+    # @return [String] the current page's URL.
+    def current_url
+      current_frame.getWebResponse.getRequestSettings.getUrl.toString
+    end
+
+    # Execute JavaScript against the current page, discarding any return value.
+    #
+    # @param [String] script the JavaScript to be executed
+    # @return [nil]
+    def execute_script(script)
+      current_frame.executeJavaScript(script)
+      nil
+    end
+
+    # Execute JavaScript against the current page and return the results.
+    #
+    # @param [String] script the JavaScript to be executed
+    # @return the result of the JavaScript
+    def evaluate_script(script)
+      current_frame.executeJavaScript(script).getJavaScriptResult
+    end
+
+    # Compare this page with an HtmlUnit page.
+    #
+    # @param [HtmlUnit::HtmlPage] other an HtmlUnit page
+    # @return [true, false]
+    def ==(other)
+      @_page == other
+    end
+
+    private
+
+    # Return the current frame. Usually just @_page, except when inside of the
+    # within_frame block.
+    #
+    # @return [HtmlUnit::HtmlPage] the current frame
+    def current_frame
+      @current_frame || @_page
+    end
+
+    # @param [String] id the frame's id
+    # @return [HtmlUnit::HtmlPage] the specified frame
+    # @return [nil] if no frame is found
+    def find_frame(id)
+      frame = @_page.getFrames.find do |frame|
+        frame.getFrameElement.getAttribute("id") == id
+      end
+      frame.getEnclosedPage if frame
+    end
+  end
+
+end

data/lib/akephalos/remote_client.rb

@@ -0,0 +1,84 @@
+require 'socket'
+require 'drb/drb'
+
+# We need to define our own NativeException class for the cases when a native
+# exception is raised by the JRuby DRb server.
+class NativeException < StandardError; end
+
+module Akephalos
+
+  # The +RemoteClient+ class provides an interface to an +Akephalos::Client+
+  # isntance on a remote DRb server.
+  #
+  # == Usage
+  #     client = Akephalos::RemoteClient.new
+  #     client.visit "http://www.oinopa.com"
+  #     client.page.source # => "<!DOCTYPE html PUBLIC..."
+  class RemoteClient
+    # Start a remote akephalos server and return the remote Akephalos::Client
+    # instance.
+    #
+    # @return [DRbObject] the remote client instance
+    def self.new
+      server_port = start!
+
+      DRb.start_service("druby://127.0.0.1:#{find_available_port}")
+      client = DRbObject.new_with_uri("druby://127.0.0.1:#{server_port}")
+
+      # We want to share our local configuration with the remote server
+      # process, so we share an undumped version of our configuration. This
+      # lets us continue to make changes locally and have them reflected in the
+      # remote process.
+      client.configuration = Akephalos.configuration.extend(DRbUndumped)
+
+      client
+    end
+
+    # Start a remote server process and return when it is available for use.
+    def self.start!
+      port = find_available_port
+
+      remote_client = IO.popen("#{Akephalos::BIN_DIR + 'akephalos'} #{port}")
+
+      # Set up a monitor thread to detect if the forked server exits
+      # prematurely.
+      server_monitor = Thread.new { Thread.current[:exited] = Process.wait(remote_client.pid) }
+
+      # Wait for the server to be accessible on the socket we specified.
+      until responsive?(port)
+        exit!(1) if server_monitor[:exited]
+        sleep 0.5
+      end
+      server_monitor.kill
+
+      # Ensure that the remote server shuts down gracefully when we are
+      # finished.
+      at_exit { Process.kill(:INT, remote_client.pid) }
+
+      port
+    end
+
+    private
+
+    # @api private
+    # @param [Integer] port the port to check for responsiveness
+    # @return [true, false] whether the port is responsive
+    def self.responsive?(port)
+      socket = TCPSocket.open('127.0.0.1', port)
+      true
+    rescue Errno::ECONNREFUSED
+      false
+    ensure
+      socket.close if socket
+    end
+
+    # @api private
+    # @return [Integer] the next available port
+    def self.find_available_port
+      server = TCPServer.new('127.0.0.1', 0)
+      server.addr[1]
+    ensure
+      server.close if server
+    end
+  end
+end

data/lib/akephalos/server.rb

@@ -0,0 +1,56 @@
+require "pathname"
+require "drb/drb"
+require "akephalos/client"
+
+# In ruby-1.8.7 and later, the message for a NameError exception is lazily
+# evaluated. There are, however, different implementations of this between ruby
+# and jruby, so we realize these messages when sending over DRb.
+class NameError::Message
+  # @note This method is called by DRb before sending the error to the remote
+  # connection.
+  # @return [String] the inner message.
+  def _dump
+    to_s
+  end
+end
+
+[
+  Akephalos::Page,
+  Akephalos::Node,
+  Akephalos::Client::Cookies,
+  Akephalos::Client::Cookies::Cookie
+].each { |klass| klass.send(:include, DRbUndumped) }
+
+module Akephalos
+
+  # Akephalos::Server is used by `akephalos --server` to start a DRb server
+  # serving an instance of Akephalos::Client.
+  class Server
+    # Start DRb service for an Akephalos::Client.
+    #
+    # @param [String] port attach server to
+    def self.start!(port)
+      abort_on_parent_exit!
+      client = Client.new
+      DRb.start_service("druby://127.0.0.1:#{port}", client)
+      DRb.thread.join
+    end
+
+    private
+
+    # Exit if STDIN is no longer readable, which corresponds to the process
+    # which started the server exiting prematurely.
+    #
+    # @api private
+    def self.abort_on_parent_exit!
+      Thread.new do
+        begin
+          STDIN.read
+        rescue IOError
+          exit
+        end
+      end
+    end
+  end
+
+end

data/lib/akephalos/version.rb

@@ -0,0 +1,3 @@
+module Akephalos #:nodoc
+  VERSION = "0.2.4"
+end

metadata

@@ -0,0 +1,164 @@
+--- !ruby/object:Gem::Specification 
+name: akephalos-2s
+version: !ruby/object:Gem::Version 
+  hash: 31
+  prerelease: 
+  segments: 
+  - 0
+  - 2
+  - 4
+  version: 0.2.4
+platform: ruby
+authors: 
+- Bernerd Schaefer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-10 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: capybara
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 0
+        - 4
+        - 0
+        version: 0.4.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: jruby-jars
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: sinatra
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        - 2
+        - 0
+        version: 2.2.0
+  type: :development
+  version_requirements: *id004
+description: Headless Browser for Integration Testing with Capybara
+email: bj.schaefer@gmail.com
+executables: 
+- akephalos
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/akephalos/node.rb
+- lib/akephalos/version.rb
+- lib/akephalos/client/filter.rb
+- lib/akephalos/client/cookies.rb
+- lib/akephalos/htmlunit.rb
+- lib/akephalos/htmlunit/ext/http_method.rb
+- lib/akephalos/configuration.rb
+- lib/akephalos/page.rb
+- lib/akephalos/remote_client.rb
+- lib/akephalos/cucumber.rb
+- lib/akephalos/console.rb
+- lib/akephalos/capybara.rb
+- lib/akephalos/server.rb
+- lib/akephalos/client.rb
+- lib/akephalos.rb
+- src/htmlunit/htmlunit-2.8.jar
+- src/htmlunit/httpclient-4.0.1.jar
+- src/htmlunit/xalan-2.7.1.jar
+- src/htmlunit/commons-logging-1.1.1.jar
+- src/htmlunit/serializer-2.7.1.jar
+- src/htmlunit/xml-apis-1.3.04.jar
+- src/htmlunit/htmlunit-core-js-2.8.jar
+- src/htmlunit/apache-mime4j-0.6.jar
+- src/htmlunit/cssparser-0.9.5.jar
+- src/htmlunit/nekohtml-1.9.14.jar
+- src/htmlunit/httpmime-4.0.1.jar
+- src/htmlunit/sac-1.3.jar
+- src/htmlunit/commons-io-1.4.jar
+- src/htmlunit/httpcore-4.0.1.jar
+- src/htmlunit/xercesImpl-2.9.1.jar
+- src/htmlunit/commons-codec-1.4.jar
+- src/htmlunit/commons-collections-3.2.1.jar
+- src/htmlunit/commons-lang-2.4.jar
+- README.md
+- MIT_LICENSE
+- bin/akephalos
+has_rdoc: true
+homepage: http://bernerdschaefer.github.com/akephalos
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+- src
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: akephalos-2s
+rubygems_version: 1.4.2
+signing_key: 
+specification_version: 3
+summary: Headless Browser for Integration Testing with Capybara
+test_files: []
+