akephalos 0.2.3-java → 0.2.4-java

data/README.md

@@ -1,6 +1,6 @@
 # Akephalos
 Akephalos is a full-stack headless browser for integration testing with
-Capybara. It is built on top of [HtmlUnit](http://htmlunit.sourceforge.com),
+Capybara. It is built on top of [HtmlUnit](http://htmlunit.sourceforge.net),
 a GUI-less browser for the Java platform, but can be run on both JRuby and
 MRI with no need for JRuby to be installed on the system.
 
@@ -50,6 +50,7 @@ Here's some sample RSpec code:
 
 ## Resources
 
+* [API Documentation](http://bernerdschaefer.github.com/akephalos/api)
 * [Source code](http://github.com/bernerdschaefer/akephalos) and
   [issues](http://github.com/bernerdschaefer/akephalos/issues) are hosted on
   github.

data/lib/akephalos/capybara.rb

@@ -1,7 +1,17 @@
+# Driver class exposed to Capybara. It implements Capybara's full driver API,
+# and is the entry point for interaction between the test suites and HtmlUnit.
+#
+# This class and +Capybara::Driver::Akephalos::Node+ are written to run on both
+# MRI and JRuby, and is agnostic whether the Akephalos::Client instance is used
+# directly or over DRb.
 class Capybara::Driver::Akephalos < Capybara::Driver::Base
 
+  # Akephalos-specific implementation for Capybara's Node class.
   class Node < Capybara::Node
 
+    # @api capybara
+    # @param [String] name attribute name
+    # @return [String] the attribute value
     def [](name)
       name = name.to_s
       case name
@@ -12,14 +22,22 @@ class Capybara::Driver::Akephalos < Capybara::Driver::Base
       end
     end
 
+    # @api capybara
+    # @return [String] the inner text of the node
     def text
       node.text
     end
 
+    # @api capybara
+    # @return [String] the form element's value
     def value
       node.value
     end
 
+    # Set the form element's value.
+    #
+    # @api capybara
+    # @param [String] value the form element's new value
     def set(value)
       if tag_name == 'textarea'
         node.value = value.to_s
@@ -34,6 +52,10 @@ class Capybara::Driver::Akephalos < Capybara::Driver::Base
       end
     end
 
+    # Select an option from a select box.
+    #
+    # @api capybara
+    # @param [String] option the option to select
     def select(option)
       result = node.select_option(option)
 
@@ -45,6 +67,10 @@ class Capybara::Driver::Akephalos < Capybara::Driver::Base
       end
     end
 
+    # Unselect an option from a select box.
+    #
+    # @api capybara
+    # @param [String] option the option to unselect
     def unselect(option)
       unless self[:multiple]
         raise Capybara::UnselectNotAllowed, "Cannot unselect option '#{option}' from single select box."
@@ -60,36 +86,54 @@ class Capybara::Driver::Akephalos < Capybara::Driver::Base
       end
     end
 
+    # Trigger an event on the element.
+    #
+    # @api capybara
+    # @param [String] event the event to trigger
     def trigger(event)
       node.fire_event(event.to_s)
     end
 
+    # @api capybara
+    # @return [String] the element's tag name
     def tag_name
       node.tag_name
     end
 
+    # @api capybara
+    # @return [true, false] the element's visiblity
     def visible?
       node.visible?
     end
 
+    # Drag the element on top of the target element.
+    #
+    # @api capybara
+    # @param [Node] element the target element
     def drag_to(element)
       trigger('mousedown')
       element.trigger('mousemove')
       element.trigger('mouseup')
     end
 
+    # Click the element.
     def click
       node.click
     end
 
     private
 
+    # Return all child nodes which match the selector criteria.
+    #
+    # @api capybara
+    # @return [Array<Node>] the matched nodes
     def all_unfiltered(selector)
       nodes = []
       node.find(selector).each { |node| nodes << Node.new(driver, node) }
       nodes
     end
 
+    # @return [String] the node's type attribute
     def type
       node[:type]
     end
@@ -97,6 +141,7 @@ class Capybara::Driver::Akephalos < Capybara::Driver::Base
 
   attr_reader :app, :rack_server
 
+  # @return [Client] an instance of Akephalos::Client
   def self.driver
     @driver ||= Akephalos::Client.new
   end
@@ -107,50 +152,101 @@ class Capybara::Driver::Akephalos < Capybara::Driver::Base
     @rack_server.boot if Capybara.run_server
   end
 
+  # Visit the given path in the browser.
+  #
+  # @param [String] path relative path to visit
   def visit(path)
     browser.visit(url(path))
   end
 
+  # @return [String] the page's original source
   def source
     page.source
   end
 
+  # @return [String] the page's modified source
   def body
     page.modified_source
   end
 
+  # @return [Hash{String => String}] the page's response headers
+  def response_headers
+    page.response_headers
+  end
+
+  # @return [Integer] the response's status code
+  def status_code
+    page.status_code
+  end
+
+  # Execute the given block within the context of a specified frame.
+  #
+  # @param [String] frame_id the frame's id
+  # @raise [Capybara::ElementNotFound] if the frame is not found
+  def within_frame(frame_id, &block)
+    unless page.within_frame(frame_id, &block)
+      raise Capybara::ElementNotFound, "Unable to find frame with id '#{frame_id}'"
+    end
+  end
+
+  # Clear all cookie session data.
+  def cleanup!
+    browser.clear_cookies
+  end
+
+  # @return [String] the page's current URL
   def current_url
     page.current_url
   end
 
+  # Search for nodes which match the given XPath selector.
+  #
+  # @param [String] selector XPath query
+  # @return [Array<Node>] the matched nodes
   def find(selector)
     nodes = []
     page.find(selector).each { |node| nodes << Node.new(self, node) }
     nodes
   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)
     page.execute_script script
   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)
     page.evaluate_script script
   end
 
+  # @return the current page
   def page
     browser.page
   end
 
+  # @return the browser
   def browser
     self.class.driver
   end
 
+  # Disable waiting in Capybara, since waiting is handled directly by
+  # Akephalos.
+  #
+  # @return [false]
   def wait
     false
   end
 
-private
+  private
 
+  # @param [String] path
+  # @return [String] the absolute URL for the given path
   def url(path)
     rack_server.url(path)
   end

data/lib/akephalos/client.rb

@@ -11,9 +11,12 @@ else
   require 'akephalos/node'
 
   require 'akephalos/client/filter'
-  require 'akephalos/client/listener'
 
   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
       java_import 'com.gargoylesoftware.htmlunit.NicelyResynchronizingAjaxController'
       java_import 'com.gargoylesoftware.htmlunit.SilentCssErrorHandler'
@@ -25,7 +28,6 @@ else
           client = WebClient.new
 
           Filter.new(client)
-          client.addWebWindowListener(Listener.new(self))
           client.setAjaxController(NicelyResynchronizingAjaxController.new)
           client.setCssErrorHandler(SilentCssErrorHandler.new)
 
@@ -34,15 +36,40 @@ else
         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
 
+      # Clear all cookies for this browser session.
+      def clear_cookies
+        client.getCookieManager.clearCookies
+      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)
@@ -51,6 +78,11 @@ else
       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)

data/lib/akephalos/client/filter.rb

@@ -1,23 +1,62 @@
 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 < WebConnectionWrapper
       java_import 'com.gargoylesoftware.htmlunit.util.NameValuePair'
       java_import 'com.gargoylesoftware.htmlunit.WebResponseData'
       java_import 'com.gargoylesoftware.htmlunit.WebResponseImpl'
 
+      # 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 = Akephalos.filters.find { |filter| request.http_method === filter[:method] && request.url.to_s =~ filter[:filter] }
+        if filter = find_filter(request)
           start_time = Time.now
           headers = filter[:headers].map { |name, value| NameValuePair.new(name.to_s, value.to_s) }
-          response = WebResponseData.new(filter[:body].to_s.to_java_bytes, filter[:status], HTTP_STATUS_CODES.fetch(filter[:status], "Unknown"), headers)
+          response = WebResponseData.new(
+            filter[:body].to_s.to_java_bytes,
+            filter[:status],
+            HTTP_STATUS_CODES.fetch(filter[:status], "Unknown"),
+            headers
+          )
           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",
@@ -78,5 +117,6 @@ module Akephalos
         530 => "User access denied"
       }.freeze
     end
+
   end
 end

data/lib/akephalos/configuration.rb

@@ -1,17 +1,44 @@
 module Akephalos
-  def self.configuration
-    @configuration ||= {}
-  end
 
-  def self.configuration=(config)
-    @configuration = config
+  @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)

data/lib/akephalos/console.rb

@@ -1,3 +1,5 @@
+# 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)
@@ -5,8 +7,11 @@ 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'
 

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

@@ -1,4 +1,13 @@
+# Reopen com.gargoylesoftware.htmlunit.HttpMethod 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
@@ -15,4 +24,5 @@ class HttpMethod
       self == self.class::DELETE
     end
   end
+
 end

data/lib/akephalos/node.rb

@@ -1,22 +1,38 @@
 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"
@@ -33,6 +49,9 @@ module Akephalos
       end
     end
 
+    # Set the value of the form input.
+    #
+    # @param [String] value
     def value=(value)
       case tag_name
       when "textarea"
@@ -42,48 +61,76 @@ module Akephalos
       end
     end
 
+    # Select an option from a select box by its value.
+    #
+    # @return [true, false] whether the selection was successful
     def select_option(option)
       opt = @_node.getOptions.detect { |o| o.asText == option }
 
       opt && opt.setSelected(true)
     end
 
+    # Unselect an option from a select box by its value.
+    #
+    # @return [true, false] whether the unselection was successful
     def unselect_option(option)
       opt = @_node.getOptions.detect { |o| o.asText == option }
 
       opt && opt.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

@@ -1,39 +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 = @_page.getByXPath(selector).map { |node| Node.new(node) }
+      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
-      @_page.asXml
+      current_frame.asXml
     end
 
+    # Return the page's source as returned by the web server.
+    #
+    # @return [String] the page's original source
     def source
-      @_page.getWebResponse.getContentAsString
+      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
-      @_page.getWebResponse.getRequestSettings.getUrl.toString
+      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)
-      @_page.executeJavaScript(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)
-      @_page.executeJavaScript(script).getJavaScriptResult
+      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

@@ -2,10 +2,10 @@ 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 # :nodoc:
+class NativeException < StandardError; end
 
 module Akephalos
-  ##
+
   # The +RemoteClient+ class provides an interface to an +Akephalos::Client+
   # isntance on a remote DRb server.
   #
@@ -16,9 +16,10 @@ module Akephalos
   class RemoteClient
     @socket_file = "/tmp/akephalos.#{Process.pid}.sock"
 
-    ##
-    # Starts a remote akephalos server and returns the remote Akephalos::Client
+    # Start a remote akephalos server and return the remote Akephalos::Client
     # instance.
+    #
+    # @return [DRbObject] the remote client instance
     def self.new
       start!
       DRb.start_service
@@ -31,8 +32,7 @@ module Akephalos
       client
     end
 
-    ##
-    # Start a remote server process, returning when it is available for use.
+    # Start a remote server process and return when it is available for use.
     def self.start!
       remote_client = fork do
         exec("#{Akephalos::BIN_DIR + 'akephalos'} #{@socket_file}")

data/lib/akephalos/server.rb

@@ -1,12 +1,14 @@
-# This file runs a JRuby DRb server, and is run by `akephalos --server`.
 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 jrby, so we realize these messages when sending over DRb.
+# 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
@@ -15,11 +17,18 @@ end
 [Akephalos::Page, Akephalos::Node].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] socket_file path to socket file to start
     def self.start!(socket_file)
       client = Client.new
       DRb.start_service("drbunix://#{socket_file}", client)
       DRb.thread.join
     end
   end
+
 end

data/lib/akephalos/version.rb

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

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 2
-  - 3
-  version: 0.2.3
+  - 4
+  version: 0.2.4
 platform: java
 authors: 
 - Bernerd Schaefer
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-18 00:00:00 -04:00
+date: 2010-09-14 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -68,7 +68,6 @@ extra_rdoc_files: []
 files: 
 - lib/akephalos/capybara.rb
 - lib/akephalos/client/filter.rb
-- lib/akephalos/client/listener.rb
 - lib/akephalos/client.rb
 - lib/akephalos/configuration.rb
 - lib/akephalos/console.rb

data/lib/akephalos/client/listener.rb

@@ -1,18 +0,0 @@
-module Akephalos
-  class Client
-    class Listener
-      include com.gargoylesoftware.htmlunit.WebWindowListener
-
-      def initialize(client)
-        @client = client
-      end
-
-      def webWindowClosed(event)
-      end
-
-      def webWindowContentChanged(event)
-        @client.page = event.getNewPage
-      end
-    end
-  end
-end