browsercuke 0.1.0

data/.gitignore

@@ -0,0 +1,3 @@
+jssh-3.5.x-Darwin-param.xpi
+Manifest.txt
+pkg

data/README.md

@@ -0,0 +1,227 @@
+= BrowserCuke
+
+http://github.com/sminnee/browsercuke
+
+== DESCRIPTION:
+
+BrowserCuke is a layer of browser-based testing on top of Cucumber.  It provides an intuitive way of
+writing business-readable tests for your web applications, that use real web browsers to test.  Your
+test scripts can now be a way of communicating with your client how you have tested the application 
+and how it should work.
+
+For more information about Cucumber, see [the cucumber website](http://cukes.info).
+
+BrowserCuke currently uses Watir to perform the browser automation, although it may be extended in 
+the future to use something like WebRat to test applications sans-JavaScript.
+
+== FEATURES
+
+ * Tests Safari and Firefox
+ * Looks for page elements like a human would: e.g. ignores hidden elements, and you can use form element labels as identifiers.
+ * Automatically wait for ajax requests to complete.
+
+It currently has the following limitations:
+
+ * No known Windows and IE support
+ * No ability to test with JavaScript
+ * Ajax auto-wait only works with Prototype and jQuery generated Ajax requests.
+ * Testing of iframes and multiple windows is untested.
+ * No drag & drop tests.
+
+Roadmap:
+
+ * Make it work in Windows/OSX/Linux and Firefox/Safari/IE
+ * Add JS-disabled testing using WebRat
+ * Ensure that you can test iframes and multiple windows intuitively
+ * Add tests for drag & drop
+ * Add tests for colour and image changes
+ * Get the FireWatir and SafariWatir monkey patches submitted to those upstream projects.
+
+== INSTALL:
+
+BrowserCuke is packaged as a gem, so the easiest way of installing BrowserCuke is by running this
+command:
+
+  $ gem install browsercuke
+
+After you have installed the gem, you should run this command to set up your browsers properly:
+
+  $ browsercuke-setup
+
+== SYNOPSIS:
+
+Run something like this to execute a test freature.
+
+   browsercuke http://localhost/yoursite create-page.feature
+
+=== Using BrowserCuke to run tests from another project
+
+BrowserCuke doesn't come bundled with any actual tests, so usually you have to write tests as part
+of your project.
+
+
+This example runs a copy of BrowserCuke installed in ~/browsercuke to execute the features 
+contained in a Sapphire project.  `sake SapphireURL/baseurl` return the URL of the current Sapphire
+project.
+
+    browsercuke firefox `sake SapphireInfo/baseurl` */tests/cuke/*.feature
+
+Because BrowserCuke was written in order to support testing of Sapphire projects, we have a special
+script for this particular example.  This will probably go away as BrowserCuke matures
+
+    sapphirecuke firefox
+
+=== Rules
+
+Please see [the cucumber website](http://cukes.info) for information about the exact cucumber 
+syntax.
+
+Actions
+-------
+
+### When I click the "(identifier)" button
+
+### When I click the "(identifier)" checkbox
+
+### When I click the "(identifier)" image
+
+### When I click the "(identifier)" link
+
+### When I click the "(identifier)" radio button
+
+### When I visit (url)
+
+### When I select "(value)" from "(dropdown identfier)"
+
+### When I put "(value)" in the "(field identifier)" field / When I set "(field)" to "(value)"
+
+Assertions
+----------
+
+### Then I see "(text)"
+
+### Then I don't see "(text)"
+
+### Then I am at (url) / Then I am sent to (url)
+
+### Then the url (url) does not exist
+
+### Then "(value)" is selected in "(dropdown identfier)"
+
+### Then the "(identifier)" field is "(value)" / Then the "(identifier)" field becomes "(value)"
+
+### Then the "(identifier)" field is blank
+
+
+
+Waiting
+-------
+
+### I wait for "(text)"
+
+### I wait for HTML ("html")
+
+Misc
+----
+
+### I cancel pop-ups
+
+### I confirm pop-ups
+
+### I put "(text)" in the pop-up
+
+-----
+
+Recommended amendment - we should alter the rules to operate this way:
+
+Actions
+-------
+
+### When I click "(button/image/link/checkbox/radiobutton)"
+
+### When I visit "(url)"
+
+### When I set "(dropdown/textfield)" to "(value)"
+
+Assertions
+----------
+
+### Then I see "(text)"
+
+### Then I don't see "(text)"
+
+### Then I am at (url)
+
+### Then the url (url) doesn't exist
+
+### Then "(field/dropdown)" is "(value)"
+
+### Then "(checkbox/radio)" is selected
+
+### Then "(checkbox/radio)" isn't selected
+
+### Then "(identifier)" is blank
+
+
+Waiting
+-------
+
+### I wait for "(text)"
+
+### I wait for HTML ("html")
+
+Misc
+----
+
+### I cancel pop-ups
+
+### I confirm pop-ups
+
+### I put "(text)" in pop-ups
+
+== REQUIREMENTS:
+
+Currently browsercuke works with the following browsers.
+
+ * Firefox 3.5
+ * Safari
+
+It has been tested on OS X only; Windows and IE support coming soon!
+
+== DEVELOPERS:
+
+After checking out the source, run:
+
+  $ rake newb
+
+This task will install any missing dependencies, run the tests/specs,
+and generate the RDoc.
+
+== LICENSE:
+
+Browsercuke is licensed under the BSD license
+
+Copyright (c) 2009, Sam Minnée
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the <organization> nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/bin/browsercuke

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+if [ "$2" = "" ]; then
+	echo "Usage: $0 (browser) (url) (feature-file) (other cucumber args)
+	
+Run the given feature file using the URL has the test site, on the given browser.
+
+Supported browsers:
+  firefox
+  safari
+
+"
+	exit 1
+fi
+
+basedir=`dirname $0`
+
+export BROWSERSALAD_BROWSER=$1
+export BROWSERSALAD_URL=$2
+
+
+# Special case for Sapphire applications - collect all the step_definitions from the modules
+if [ -d sapphire/tests/cuke ]; then
+	for file in `ls -1d */tests/cuke/step_definitions`; do
+		extras="$extras -r $file"
+	done
+fi
+
+echo "cucumber -r $basedir/support -r $basedir/step_definitions $extras $3 $4 $5 $6 $7 $8 $9"
+cucumber -r $basedir/support -r $basedir/step_definitions $extras $3 $4 $5 $6 $7 $8 $9

data/bin/browsercuke-setup

@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+echo "Browsercuke OS X installer
+===========================
+"
+
+ffbin=/Applications/Firefox.app/Contents/MacOS/firefox-bin
+
+
+if [ ! -f jssh-3.5.x-Darwin-param.xpi ]; then
+	echo "> Downloading Firefox 3.5 JSSH plugin"
+	wget http://wiki.openqa.org/download/attachments/13893658/jssh-3.5.x-Darwin-param.xpi
+fi
+
+echo "> Installing Firefox 3.5 JSSH plugin"
+open ./jssh-3.5.x-Darwin-param.xpi
+
+echo "> Please go to System Prefences -> Universal Access and check the box labelled 'Enable access for assistive devices'
+
+When you're done, press enter to continue."
+
+read -s -n1
+
+echo "
+Done!
+
+You should be able to run one of these commands now:
+
+browsercuke firefox http://localhost/yourtestsite create-page.feature
+browsercuke safari http://localhost/yourtestsite create-page.feature
+
+"

data/bin/sapphirecuke

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+if [ "$1" = "" ]; then
+	echo "Usage: $0 (browser)
+"
+	exit 1
+fi
+
+if [ ! -f sapphire/main.php ]; then
+	echo "Please run $0 from within your sapphire project root.
+I couldn't find ./sapphire/main.php.
+"
+	exit 2
+fi
+
+dirname=`dirname $0`
+$dirname/browsercuke $1 `./sapphire/sake SapphireInfo/baseurl` */tests/cuke/*.feature

data/step_definitions/browser/README.md

@@ -0,0 +1,38 @@
+Web Application Testing Kit
+===========================
+
+These step definitions are intended to provide a generic, intuitive and powerful mechanism for 
+building web application tests in Cucumber.  They have been originally developed for the
+SilverStripe CMS but should be able to be used anywhere you find Ajax and HTML.
+
+
+To do
+-----
+
+### Soon
+ 
+ * [x] Wait for ajax
+ * [x] Use <label for="X"> tags to find fields by label
+ * [x] Exclude hidden fields from the search; find the first visible tab
+ * [ ] Make label matchers case-insensitive
+ * [ ] Drag & drop testing (incl. SiteTree)
+ * [ ] ComplexTableField, pop-up, iframe testing
+ * [ ] Content-identification testing
+ * [ ] Multi-window testing (incl. checking the front-end site)
+ * [ ] TinyMCE testing
+
+### Later
+
+ * Allow detection of an element's colour - The "New Page" link is green.
+
+Origin
+------
+
+These step definitions came from [Watircuke](http://github.com/richdownie/watircuke),
+by Rich Downie.  They have been modified quite a bit.
+
+No license was provided with them, so we've included this credit and our thanks. :-)
+
+Sam Minnée
+SilverStripe
+

data/step_definitions/browser/ajax.rb

@@ -0,0 +1,83 @@
+=begin
+Ajax Handling
+This pair of methods lets us wait for ajax actions to complete before proceeding.
+
+To use:
+ * Call ajax_before_action prior to the action - e.g. button/link click
+ * Call ajax_after_action after the action
+
+What happens:
+ * If the action didn't trigger an ajax call, then it won't wait
+ * If the action did trigger an ajax call, then it will wait until after the success handler is
+   completed
+
+Because the handler does nothing if there wasn't an ajax call, it's safe to be wrapped around all
+button/link clicks.
+=end
+
+def ajax_before_action(browser)
+  
+  # Warning: don't use // comments in the JS, only /* */, because newlines are removed
+  
+  js = <<-eos
+      window.__ajaxStatus = function() { return 'no ajax'; };
+
+      if(typeof window.__ajaxPatch == 'undefined') {
+        window.__ajaxPatch = 1;
+      
+        var patchedList = "";
+
+        /* Monkey-patch Prototype */
+        if(typeof window.Ajax!='undefined' && typeof window.Ajax.Request!='undefined') {
+          window.Ajax.Request.prototype.initialize = function(url, options) {
+            this.transport = window.Ajax.getTransport();
+
+            var __activeTransport = this.transport;
+            window.__ajaxStatus = function() {
+              return (__activeTransport.readyState == 4) ? 'success' : 'waiting';
+            };
+
+            this.setOptions(options);
+            this.request(url);
+          };
+          patchedList += " prototype";
+        }
+
+        /* Monkey-patch jQuery */
+        if(typeof window.jQuery!='undefined') {
+          var _orig_ajax = window.jQuery.ajax;
+
+          window.jQuery(window).ajaxStop(function() {
+            window.__ajaxStatus = function() { return 'success'; };
+          });
+        
+          window.jQuery.ajax = function(s) {
+            window.__ajaxStatus = function() { return 'waiting'; };
+            _orig_ajax(s);
+          };
+          patchedList += " jquery";
+        }
+        return "patched" + patchedList;
+      } else {
+        return "already patched: " + window.__ajaxPatch;
+      }
+  eos
+  
+  browser.evaluate_script(js)
+  
+  #js = js.gsub(/[\n\r]/, "; ")
+  #browser.js_eval(js)
+  
+  # For debugging
+  #puts "Patching:"
+  #puts browser.js_eval(js)
+end
+
+def ajax_after_action(browser)
+  Watir::Waiter::wait_until {
+    status = browser.evaluate_script("return window.__ajaxStatus ? window.__ajaxStatus() : 'no ajax'")
+    # For debugging
+    # puts "Waiting for ajax: #{status}"
+    status != "waiting"
+  }
+end

data/step_definitions/browser/buttons.rb

@@ -0,0 +1,33 @@
+# Try running with the button ":id", ":name", ":value", ":text", ":index" or ":class" element attribute.
+# Does not matter what you select!
+# The proper watir code will be executed regardless.
+
+Given /click the "(.*)" button/i do |type|
+  btn = getButton(@browser, type)
+  
+  if(btn) then
+    ajax_before_action @browser
+    btn.click
+    ajax_after_action @browser
+  else
+    fail("could not find the '#{type}'button on #{@browser.url}")
+  end
+end
+
+def getButton(browser, type)
+  button = browser.button(:id, type)
+  button = browser.button(:value, type) unless button.exists?
+
+  # :text used for Firefox suport
+  if browser.instance_of?(FireWatir::Firefox)
+    button = browser.button(:text, type) unless button.exists?
+  end
+  # :xpath used for Safari suport
+  button = browser.button(:xpath, "//button[.='#{type}']") unless button.exists?
+
+  button = browser.button(:index, type) unless button.exists?
+  button = browser.button(:class, type) unless button.exists?
+  
+  button = nil unless button.exists?
+  return button
+end

data/step_definitions/browser/checkboxes.rb

@@ -0,0 +1,26 @@
+# Try running with the checkbox  ":id", ":name", ":value", ":text", ":index" or ":class" element attribute.
+# Does not matter what you select!
+# The proper watir code will be executed regardless.
+
+Given /click the "(.*)" checkbox/i do |type|
+  if @browser.checkbox(:id, type).exists? then
+     @browser.checkbox(:id, type).click
+  elsif
+    @browser.checkbox(:name, type).exists? then
+    @browser.checkbox(:name, type).click
+  elsif
+    @browser.checkbox(:value, type).exists? then
+    @browser.checkbox(:value, type).click
+  elsif
+    @browser.checkbox(:text, type).exists? then
+    @browser.checkbox(:text, type).click
+  elsif
+    @browser.checkbox(:index, type).exists? then
+    @browser.checkbox(:index, type).click
+  elsif
+    @browser.checkbox(:class, type).exists? then
+    @browser.checkbox(:class, type).click
+  else
+    fail("could not find what you asked for")
+  end
+end

data/step_definitions/browser/expectations.rb

@@ -0,0 +1,29 @@
+Given /I see "(.*)"/ do |text|
+  describe "Matcher" do
+    it "should have text" do
+      @browser.should have_text(text)
+    end
+  end
+end
+
+Given /I don't see "(.*)"/ do |text|
+  describe "Matcher" do
+    it "shouldn't have text" do
+      @browser.should_not have_text(text)
+    end
+  end
+end
+
+Given /I wait for "(.*)"/ do |text|
+  Watir::Waiter::wait_until { @browser.text.include? text}
+end
+
+Given /I wait for html "(.*)"/ do |text|
+  Watir::Waiter::wait_until { @browser.html.include? text}
+end
+
+# Wait for time
+Given /Wait ([0-9]+)s$/i do |seconds|
+  sleep seconds.to_i
+end
+

data/step_definitions/browser/images.rb

@@ -0,0 +1,26 @@
+# Try running with the image ":src", ":id", ":name", ":index", ":class" element attribute.
+# Does not matter what you select!
+# The proper watir code will be executed regardless.
+
+Given /click the "(.*)" image/i do |type|
+  if @browser.image(:src, type).exists? then
+     @browser.image(:src, type).click
+  elsif 
+    @browser.image(:id, type).exists? then
+    @browser.image(:id, type).click
+  elsif 
+    @browser.image(:name, type).exists? then
+    @browser.image(:name, type).click
+  elsif 
+    @browser.image(:text, type).exists? then
+    @browser.image(:text, type).click
+  elsif 
+    @browser.image(:index, type).exists? then
+    @browser.image(:index, type).click
+  elsif 
+    @browser.image(:class, type).exists? then
+    @browser.image(:class, type).click
+  else
+    fail("could not find what you asked for")  
+  end
+end

data/step_definitions/browser/links.rb

@@ -0,0 +1,26 @@
+# Try running with the link ":id", ":text", ":class" element attribute.
+# Does not matter what you select!
+# The proper watir code will be executed regardless.
+
+Given /click the "(.*)" link/i do |type|
+  if link = getLink(@browser, type) then
+    ajax_before_action @browser
+    link.click
+    ajax_after_action @browser
+  else
+    fail("could not find the '#{type}' link on #{@browser.url}")
+  end
+end
+
+def getLink(browser, match)
+  link = browser.link(:id, match)
+  if not link.exists? then link = browser.link(:text, match) end
+  if not link.exists? then link = browser.link(:class, match) end
+  # Try the URL with both the baseURL prefix and without it
+  if not link.exists? then link = browser.link(:url, @baseURL + match) end
+  if not link.exists? then link = browser.link(:url, match) end
+  if not link.exists? then link = browser.link(:xpath, match) end
+  if not link.exists? then link = nil end
+
+  return link
+end

data/step_definitions/browser/pages.rb

@@ -0,0 +1,17 @@
+Given /visit (.*)/o do |url|
+  @browser.goto(@baseURL + url)
+end
+
+Given /I am at (.*)/i do |url|
+  @browser.url.should =~ /^#{@baseURL}#{url}/
+end
+
+  Given /I am sent to (.*)/i do |url|
+    Given "I am at #{url}"
+  end
+  
+Given /url (.*) does not exist/ do |url|
+  Given "I visit #{url}"
+  # Brittle - needs to check that actual 404 status, but that's hard
+  And "I see \"The requested page couldn't be found.\""
+end

data/step_definitions/browser/popups.rb

@@ -0,0 +1,32 @@
+Given /cancel pop-ups/i do
+  script = "window.confirm=window.alert=window.prompt=function(){ return false; };"
+
+  # Special case for FireWatir
+  if @browser.respond_to?('evaluate_script_alternate')
+    @browser.evaluate_script_alternate(script)
+  else
+    @browser.evaluate_script(script)
+  end
+end
+
+Given /confirm pop-ups/i do
+  script ="window.confirm=window.alert=function(){ return true; }; window.prompt=function(){ return false; }";
+
+  # Special case for FireWatir
+  if @browser.respond_to?('evaluate_script_alternate')
+    @browser.evaluate_script_alternate(script)
+  else
+    @browser.evaluate_script(script)
+  end
+end
+
+Given /put "(.*)" in the pop-up/i do | value |
+  script = "window.confirm=window.alert=function(){ return true; }; window.prompt=function(){ return \"#{value}\"; }"
+
+  # Special case for FireWatir
+  if @browser.respond_to?('evaluate_script_alternate')
+    @browser.evaluate_script_alternate(script)
+  else
+    @browser.evaluate_script(script)
+  end
+end

data/step_definitions/browser/radio_buttons.rb

@@ -0,0 +1,26 @@
+# Try running with the radio ":id", ":name", ":value", ":text", ":index" or ":class" element attribute.
+# Does not matter what you select!
+# The proper watir code will be executed regardless.
+
+Given /click the "(.*)" radio button/i do |type|
+  if @browser.radio(:id, type).exists? then
+     @browser.radio(:id, type).click
+  elsif 
+    @browser.radio(:name, type).exists? then
+    @browser.radio(:name, type).click
+  elsif 
+    @browser.radio(:value, type).exists? then
+    @browser.radio(:value, type).click
+  elsif 
+    @browser.radio(:text, type).exists? then
+    @browser.radio(:text, type).click
+  elsif 
+    @browser.radio(:index, type).exists? then
+    @browser.radio(:index, type).click
+  elsif 
+    @browser.radio(:class, type).exists? then
+    @browser.radio(:class, type).click
+  else
+    fail("could not find what you asked for")
+  end
+end

data/step_definitions/browser/select_lists.rb

@@ -0,0 +1,31 @@
+# Try running with the select-list ":id", ":name", ":value", ":text", ":index" or ":class" element attribute.
+# Does not matter what you select!
+# The proper watir code will be executed regardless.
+
+Given /select "(.*)" from "(.*)"/i do |text, type|
+  if @browser.select_list(:id, type).exists? then
+     @browser.select_list(:id, type).select(text)
+
+  elsif @browser.select_list(:name, type).exists? then
+        @browser.select_list(:name, type).select(text)
+
+  elsif @browser.select_list(:value, type).exists? then
+        @browser.select_list(:value, type).select(text)
+
+  elsif @browser.select_list(:text, type).exists? then
+        @browser.select_list(:text, type).select(text)
+
+  elsif @browser.select_list(:index, type).exists? then
+        @browser.select_list(:index, type).select(text)
+
+  elsif @browser.select_list(:class, /(^|\s)#{type}(\s|$)/).exists? then
+        @browser.select_list(:class, /(^|\s)#{type}(\s|$)/).set(text)
+  else
+    fail("could not find what you asked for")
+  end 
+end
+
+Given /"(.*)" is selected in "(.*)"/i do |text, field|
+  pending
+end
+  

data/step_definitions/browser/text_fields.rb

@@ -0,0 +1,71 @@
+Given /put "(.*)" in the "(.*)" field/i do |text,type|
+  field = getTextField(@browser, type)
+  if field then
+     field.set(text) 
+  else
+    fail("could not find the '#{type}' field to write '#{text}' into on #{@browser.url}")
+  end
+end  
+
+
+Given /The "(.*)" field is "(.*)"/i do |name, value|
+  field = getTextField(@browser, name)
+
+  if field then
+     field.value.should == value
+  else
+    fail("could not find the '#{name}' field on #{@browser.url}")
+  end
+end
+
+# Synonyms
+Given /set "(.*)" to "(.*)"/i do |type,text|
+  Given "I put \"#{text}\" in the \"#{type}\" field"
+end
+
+Given /The "(.*)" field is blank/i do |field|
+    Given "The \"#{field}\" field is \"\""
+end
+
+Given /The value of "(.*)" becomes "(.*)"/i do |field, value|
+  Given "The \"#{field}\" field is \"#{value}\""
+end
+
+# Try running with the text_field ":id", ":name", ":value", ":index" or ":class" element attribute.
+# Does not matter what you select!
+# The proper watir code will be executed regardless.
+
+def getTextField(browser, type)
+  # Build an array of all potential fields
+  fields = []
+  # By ID
+  browser.text_fields().each { | field |
+    if field.id == type then fields.push field end
+  }
+  # By Name
+  browser.text_fields().each { | field |
+    if field.respond_to?('htmlname') then
+      if field.htmlname == type then fields.push field end
+    else
+      if field.name == type then fields.push field end
+    end
+  }
+  # By the associated <label>
+  browser.elements_by_xpath("//label[.='#{type}']").each { | label |
+    if label.for then
+      browser.text_fields().each { | field |
+        if field.id == label.for then fields.push field end
+      }
+    end
+  }
+  # By value
+  #fields += browser.text_fields(:value, type)
+  # By CSS Class
+  #fields += browser.text_fields(:class, type)
+  
+  # Return the first visible one
+  fields.each { | field |
+    if field.visible? then return field end
+  }
+  return nil
+end

data/support/env.rb

@@ -0,0 +1,104 @@
+require 'spec'
+VERSION = "0.1.0"
+
+
+$killFF = false
+ 
+if ENV['BROWSERSALAD_BROWSER'] and ENV['BROWSERSALAD_BROWSER'].downcase == 'safari'
+  require 'safariwatir'
+  Browser = Watir::Safari
+else
+  case RUBY_PLATFORM
+  when /darwin/
+    require 'firewatir'
+
+    class FireWatir::Firefox
+      # Modified implementation of Firewatir start-up to give it up to 30 seconds to get things sorted
+      def initialize(options = {})
+        if(options.kind_of?(Integer))
+          options = {:waitTime => options}
+        end
+
+        # check for jssh not running, firefox may be open but not with -jssh
+        # if its not open at all, regardless of the :suppress_launch_process option start it
+        # error if running without jssh, we don't want to kill their current window (mac only)
+        jssh_down = false
+        begin
+          set_defaults()
+        rescue Watir::Exception::UnableToStartJSShException
+          jssh_down = true
+        end
+
+        if current_os == :macosx && !%x{ps x | grep firefox-bin | grep -v grep}.empty?
+          raise "Firefox is running without -jssh" if jssh_down
+          open_window unless options[:suppress_launch_process]
+        elsif not options[:suppress_launch_process]
+          launch_browser(options)
+        end
+
+        set_defaults(300)
+        get_window_number()
+        set_browser_document()
+      end
+
+      def set_defaults(no_of_tries = 3)
+        no_of_tries_so_far = 0
+        # JSSH listens on port 9997. Create a new socket to connect to port 9997.
+        begin
+          $jssh_socket = TCPSocket::new(MACHINE_IP, "9997")
+          $jssh_socket.sync = true
+          read_socket()
+        rescue
+          no_of_tries_so_far += 1
+          sleep 0.1
+          retry if no_of_tries_so_far < no_of_tries
+          raise UnableToStartJSShException, "Unable to connect to machine : #{MACHINE_IP} on port 9997. Make sure that JSSh is properly installed and Firefox is running with '-jssh' option"
+        end
+        @error_checkers = []
+      end
+    end
+
+    Watir::Browser.default = 'firefox'
+    Browser = Watir::Browser
+    $killFF = true
+  when /win32|mingw/
+    require 'watir'
+    Browser = Watir::IE
+  when /java/
+    require 'celerity'
+    Browser = Celerity::Browser
+  else
+    raise "This platform is not supported (#{PLATFORM})"
+  end
+end
+
+# Set up 
+$browser = Browser.new
+
+if ENV['BROWSERSALAD_URL'] then
+  $baseURL = ENV['BROWSERSALAD_URL']
+  if not $baseURL.match(/\/$/) then
+      $baseURL += '/'
+  end
+else
+  $baseURL = "http://demo.silverstripe.com/"
+end
+
+# Make it go fast - IE only
+# $browser.speed = :zippy
+
+# Before each scenario, load in the globals
+Before do
+  @browser = $browser
+  @baseURL = $baseURL
+end
+ 
+at_exit do
+  # Let us see the aftermath for 10 seconds
+  sleep 10
+  
+  # Kill database
+  $browser.goto $baseURL + 'dev/tests/endsession'
+
+  if $killFF then `killall -9 firefox-bin` end
+end

data/support/firewatir-mods.rb

@@ -0,0 +1,46 @@
+require 'firewatir'
+
+class Element
+  # Returns true if the current elements returns true
+  # Feature missing from FireWatir
+  def visible?
+    js = "(function(el) {
+      var w = getWindows()[#{$browser.window_index}].content;
+      while(el && el != w.document) {
+        var s = w.getComputedStyle(el, null);
+        if(s.getPropertyValue('display') == 'none' || s.getPropertyValue('visibility') == 'hidden') return false;
+        el = el.parentNode;
+      }; 
+      return true;
+    })(#{element_object});"
+    return js_eval(js) == 'true'
+  end
+end
+
+class FireWatir::Firefox
+  def evaluate_script(script)
+    # Warning: don't use // comments in the JS, only /* */, because newlines are removed
+  
+    outerScript = <<-eos
+    (function(window) {
+      #{script};
+    })(getWindows()[#{@window_index}].content);
+    eos
+    
+    return self.js_eval(outerScript)
+  end
+
+  def evaluate_script_alternate(script)
+    # Warning: don't use // comments in the JS, only /* */, because newlines are removed
+  
+    outerScript = <<-eos
+    var _old_window = window;
+    var window = getWindows()[#{@window_index}].content;
+    #{script};
+    window = _old_window;
+    delete _old_window;
+    eos
+    
+    return self.js_eval(outerScript)
+  end
+end

data/support/safariwatir-mods.rb

@@ -0,0 +1,167 @@
+=begin
+
+This is a collection of modifications to SafariWatir to get it to work more consistently with the
+Watir API
+
+=end
+
+require 'safariwatir'
+
+module Watir
+  module Container
+    # Implement missing API method - all text fields
+    def text_fields()
+      return @scripter.get_all_text_fields
+    end
+    
+    # Implement missing API method - all elements matching an xpath
+    def elements_by_xpath(xpath)
+      return @scripter.get_all_by_xpath(xpath)
+    end
+    
+    class HtmlElement
+      # Implement missing API methods - id, for, and name on all HTML elements
+      def id
+        return attr('id') || ''
+      end
+      def for
+        return attr('for') || ''
+      end
+      # This htmlname rather than name because name seems to have a special meaning in some versions of Ruby.
+      def htmlname
+        return @scripter.get_attribute('name', self) || ''
+      end
+      def value
+        return @scripter.get_value_for(self) || ''
+      end
+
+      # Implement missing API method - is the element visible?
+      def visible?
+        return @scripter.eval_on_element("return (function(el) {
+          while(el && el != document) {
+            var s = window.getComputedStyle(el, null);
+            if(s.getPropertyValue('display') == 'none' || s.getPropertyValue('visibility') == 'hidden') return false;
+            el = el.parentNode;
+          }; 
+          return true;
+        })(element);", self)
+      end
+    end
+    
+    class TextField
+      # Altered API method for consistency - char-by-char setting of the value mucked with onchange
+      # handlers
+      def set(value)
+        @scripter.focus(self)
+        @scripter.highlight(self) do
+          clear_text_input
+          append_text_input(value.to_s)
+        end
+        @scripter.blur(self)
+      end
+    end
+  end
+  
+  class Safari
+    # Added missing API method - evaluate an arbitrary script
+    def evaluate_script(script)
+      return @scripter.evaluate_script(script)
+    end
+  end
+  
+  class AppleScripter
+    # Internal handler for Safari class to access
+    def evaluate_script(script)
+      return execute(script)
+    end
+
+    # Internal handler for Safari class to access
+    def get_all_text_fields()
+      ids = get_ids_from_js("document.getElementsByTagName('input')", "item.type == 'text' || item.type == 'password'") + get_ids_from_js("document.getElementsByTagName('textarea')")
+      return ids.map { |id|
+        Container::TextField.new(self, :id, id)
+      }
+    end
+    
+    # Internal handler for Safari class to access
+    def get_all_by_xpath(xpath) 
+      xpath = xpath.gsub("'","\'")
+      ids = get_ids_from_js("document.evaluate(\"#{xpath}\", document.documentElement, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null)",
+        nil, 
+        "items.snapshotLength",
+        "items.snapshotItem(i)")
+      return ids.map { |id|
+        Container::HtmlElement.new(self, :id, id)
+      }
+    end
+
+    # Return the IDs of the elements returned by the given JS expression
+    # js: The JavaScript that returns a list of items
+    # filter: The JavaScript to evaluate on each item (variable name will be 'item') to filter the
+    # list.  This is optional
+    # getLength: Expression to get the length of the JS var 'items'
+    # getItem: Expression to get the 'i'th of the JS var 'items'
+    def get_ids_from_js(js, filter = nil, getLength = "items.length", getItem = "items[i]")
+      if filter == nil
+        filter = "true"
+      end
+
+      fullJS = <<-eos
+        return (function() {
+          var items = #{js};
+          var i, item;
+          var output = [];
+          for(i=0;i<#{getLength};i++) {
+            item = #{getItem};
+            if(#{filter}) {
+              // Adding a random ID is a little clumsy but will do, for now
+              if(!item.id) item.id = 'safariwatir-' + parseInt(Math.random()*1000000000);
+              output.push(item.id);
+            }
+          }
+          return output;
+        })()
+        eos
+        
+      return eval_js(fullJS)
+    end
+    
+    # Internal handler for HtmlElement class - Evaluate JS on a particular element
+    def eval_on_element(js, element)
+      execute(element.operate { js }, element)
+    end
+    
+    # Altered API methdo - fix bugs in match by ID and Value
+    def handle_match(element, how = nil)
+      how = {:text => "text", :url => "href", :id => 'id', :value => 'value', :xpath => 'xpath'}[element.how] unless how
+      case element.what
+        when Regexp
+          %|#{how}.match(/#{element.what.source}/#{element.what.casefold? ? "i":nil})|          
+        when String
+          %|#{how} == '#{element.what}'|
+        else
+          raise RuntimeError, "Unable to locate #{element.element_name} with #{element.how}"
+      end
+    end    
+  
+    # Altered internal API method - need to wait for the URL displayed to actually change, so that
+    # we can handle slow-loading pages better
+    def navigate_to(url, &extra_action)
+      page_load(extra_action) do
+        currentURL = @document.URL.get
+        @document.URL.set(url)
+        
+        if currentURL != url
+          60.times do |tries|
+            if @document.URL.get != currentURL
+              break
+            else
+              sleep 0.5
+            end
+          end
+        end
+      end
+    end
+
+  end
+end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification 
+name: browsercuke
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- "Sam Minn\xC3\xA9e"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-07 00:00:00 +13:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.4.4
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: firewatir>= 1.6.5
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: safariwatir>= 0.3.7
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rb-appscript>= 0.5.3
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.4.0
+    version: 
+description: |-
+  BrowserCuke is a layer of browser-based testing on top of Cucumber.  It provides an intuitive way of
+  writing business-readable tests for your web applications, that use real web browsers to test.  Your
+  test scripts can now be a way of communicating with your client how you have tested the application 
+  and how it should work.
+  
+  For more information about Cucumber, see [the cucumber website](http://cukes.info).
+  
+  BrowserCuke currently uses Watir to perform the browser automation, although it may be extended in 
+  the future to use something like WebRat to test applications sans-JavaScript.
+email: 
+- sam@silverstripe.com
+executables: 
+- browsercuke
+- browsercuke-setup
+- sapphirecuke
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- README.md
+- bin/browsercuke
+- bin/browsercuke-setup
+- bin/sapphirecuke
+- step_definitions/browser/README.md
+- step_definitions/browser/ajax.rb
+- step_definitions/browser/buttons.rb
+- step_definitions/browser/checkboxes.rb
+- step_definitions/browser/expectations.rb
+- step_definitions/browser/images.rb
+- step_definitions/browser/links.rb
+- step_definitions/browser/pages.rb
+- step_definitions/browser/popups.rb
+- step_definitions/browser/radio_buttons.rb
+- step_definitions/browser/select_lists.rb
+- step_definitions/browser/text_fields.rb
+- support/env.rb
+- support/firewatir-mods.rb
+- support/safariwatir-mods.rb
+has_rdoc: true
+homepage: http://github.com/sminnee/browsercuke
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.md
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: browsercuke
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: BrowserCuke is a layer of browser-based testing on top of Cucumber
+test_files: []
+