The problem here is that you cannot auto authenticate to a proxy server using Chrome –proxy-server=my.proxy.com:3128 or using Firefox.

Chrome will always prompt you for a user name and password on an authenticating proxy when it starts up [...]]]> A question came up on stack overflow about how to route Watir through an authenticating proxy within your script.

The problem here is that you cannot auto authenticate to a proxy server using Chrome –proxy-server=my.proxy.com:3128 or using Firefox.

Chrome will always prompt you for a user name and password on an authenticating proxy when it starts up (via Webdriver or manually). Firefox will not prompt (when launched via WebDriver) and will silently fail.

I *almost* got this to work by modifying headers on the fly with a Firefox add on (Modify Headers). Basic authentication is just base-64 encoded so you can force each request to authorize itself by modifying the Proxy-Authorization request header e.g.:
Proxy-Authorization Basic asHJksaKHs87akhkjah7

However whilst this works for manually launched instances of Firefox, Webdriver launched instances would complain that the add on is not compatible with FF3.6.3 and so once again would fail. The other problem with this approach is that I couldn’t find a similar plugin for Chrome.

Eventually I gave in and went with a slightly more complicated workaround. That is, chaining an authenticated proxy (with squid) running on localhost with a cache_peer relationship to the authenticated proxy running out there on the ‘tubes’. I had thought about using Webrick as a proxy (as per previous posts) but lack of SSL support is a gotcha for me. Squid seemed most appropriate in this case:

To install squid from source:
cd /opt/src
sudo curl -O http://www.squid-cache.org/Versions/v2/2.7/squid-2.7.STABLE9.tar.gz
sudo tar xjf squid-2.7.STABLE9.tar.gz
cd squid-2.7.STABLE9
# I wanted SSL support for this
./configure --enable-ssl
make
sudo make install

Edit the squid.conf (location is normally /etc/squid/squid.conf on linux):
sudo vim /usr/local/squid/etc/squid.conf

# Don't want to run squid as root
# TAG: cache_effective_user
cache_effective_user nobody
# TAG: cache_effective_group
cache_effective_group wheel
# Point this proxy to a peer cache, and provide the logon credentials
# TAG: cache_peer
cache_peer proxy.altentee.com parent 3128 0 default no-query login=username:mypassword
never_direct allow all
# Allow access from my local private network
# TAG: cache_peer
acl localnet src 10.0.0.0/0

Save changes and change ownership as appropriate:
sudo chown -R nobody:wheel /usr/local/squid

Initialize the cache and startup squid:
sudo /usr/local/squid/sbin/squid -z
sudo /usr/local/squid/sbin/squid -D

Now you can configure firefox (using -ProfileManager) or chrome (using –proxy-server=127.0.0.1) to point to your local proxy server. This proxy will then authenticate on your behalf and peer all requests via the original parent.

A little long winded but achieves the outcome. Added side benefit is you’ve now got a local proxy (with access logs) that you can start doing interesting things with in your automation / performance tests like modifying headers and so forth.

Hope this helps!

Part of my grievance for that was based on frustration in dealing with different load testing platforms. Not frustration born out of incompetence, more the frustration born out writing tests for increasingly [...]]]> In my last post I made a tongue-in-cheek observation that load testing really doesn’t work by today’s perceived standards for web automation and testing.

Part of my grievance for that was based on frustration in dealing with different load testing platforms. Not frustration born out of incompetence, more the frustration born out writing tests for increasingly complex browsers with an antiquated toolset.

That’s not to say that protocol based application load testing (or the languages they sit on) aren’t powerful in their own right. LoadRunner, JMeter et al. has their place in the load testing world. But I would like to relegate them to the background as useful, sometimes expensive tools to spin up the wheels so to speak. Nothing like a bit of JMeter infused fun to get the wheels smoking on your system under test. But for the real part, measuring user experience on the web platform?

If you can’t wait to get started then I’d like to introduce BrowserMob.com. Been around since mid 2008 and offers real browser testing using Selenium scripts distributed across a grid of EC2 computers. Reasonably priced, well documented and supported by the legendary Patrick Lightbody, founder of things like OpenQA and Selenium Remote Control.

But hang on a second, you don’t like Selenium right? Have zero budget? Love Watir? Well I’m working on a similar construct aptly called WatirGrid which also allows for distributed testing across a grid network using Watir. The engine (gem) itself is open source and you can get it as follows:

gem install watirgrid

If you’d like to contribute please follow the WatirGrid project on github.

The Basics
WatirGrid is built on Rinda which implements the Linda distributed computing paradigm in Ruby. According to Wikipedia: “Linda is a model of coordination and communication among several parallel processes operating upon objects stored in and retrieved from shared, virtual, associative memory.”

In other words, WatirGrid allows multiple parallel processes to provide remote Watir objects in the form of tuple spaces across a grid network. This grid network is controlled by a ring server and looks a bit like this:

Key Terminology
The controller implements a repository of tuples (tuple space) that can be accessed concurrently. The controller hosts the ring server which advertises these tuples across a grid network. Typically you will host one controller on a central machine.

The providers make remote Watir objects available to the tuple space hosted by the ring server. Typically you will host one or many providers on your grid network, for example, each PC may become a single provider of a Watir tuple in the form of an Internet Explorer, Firefox or Safari browser object.

Simple Example
Pick a server to host the controller for the ring server and execute the following:

  $ controller

This should find your external facing IP and start the corresponding DRb and Ring Servers:

  DRb server started on : druby://143.238.105.61:11235
  Ring server started on: druby://143.238.105.61:12358

On each client PC, host the provider for the distributed (DRb) Watir objects

  $  provider

This should find the recently started Ring Server and register a tuple for the Watir object:

  DRb server started on : druby://143.238.105.61:11236
  Ring server found on  : druby://143.238.105.61:12358
  New tuple registered  : druby://143.238.105.61:12358

You will now be able to execute commands across remote browsers on your grid network.
e.g.

  grid = Watir::Grid.new(:ring_server_port => 12358)
  grid.start(:quantity => 1, :read_all => true)
  threads = []
  grid.browsers.each do |browser|
    threads << Thread.new do
      b = browser[:object].new_browser
      b.goto("http://www.google.com")
      b.text_field(:name, 'q').set("watirgrid")
      b.button(:name, "btnI").click
    end
  end
  threads.each {|thread| thread.join}

You may wish to host the controller and providers on different machines in a real scenario. You can specify things like server hostnames, ports and access control lists for each of the different types of servers. For more help see:

  $  controller --help
  Usage: controller [options]
  Specific options:
      -H, --drb-server-host HOST       Specify DRb Server interface to host on
      -d, --drb-server-port PORT       Specify DRb Server port to listen on
      -h, --ring-server-host HOST      Specify Ring Server interface to host on
      -r, --ring-server-port PORT      Specify Ring Server port to listen on
      -a, --access-control-list ACLS   Specify a comma separated Access Control List
      -l, --log-level LEVEL            Specify log level {DEBUG|INFO|ERROR}
          --help                       Show this message
 
  $  provider --help
  Usage: provider [options]
  Specific options:
      -H, --drb-server-host HOST       Specify DRb Server interface to host on
      -d, --drb-server-port PORT       Specify DRb Server port to listen on
      -h, --ring-server-host HOST      Specify Ring Server host to connect to
      -r, --ring-server-port PORT      Specify Ring Server port to broadcast on
      -b, --browser-type TYPE          Specify browser type to register {ie|firefox|safari}
      -a, --access-control-list ACLS   Specify a comma separated Access Control List
      -l, --log-level LEVEL            Specify log level {DEBUG|INFO|ERROR}
          --help                       Show this message

Need more help?

Keep an eye on the wiki and the rspec test cases!

Even worse, have you had to write those scripts against a development environment with an unstable code base and shocking performance? Sound familiar? Ever felt the frustration of re-recording [...]]]> Here’s an idea… Ever been in a LoadRunner contract where you’ve got a ton of scripts to write for business transactions that have many many design steps?

Even worse, have you had to write those scripts against a development environment with an unstable code base and shocking performance? Sound familiar? Ever felt the frustration of re-recording manual test cases back into LoadRunner in said environments. Why wouldn’t you just automate the script recording process?

Well if you’re in a LoadRunner shop there’s probably a QTP license floating around. However there’s a great alternative with Ruby, specifically Web Application Testing In Ruby.

The gist is that you setup your manual test case using a watir script, then re-record your LoadRunner scripts using those watir scripts as the driver. The benefits are many:

1. Reduce user input errors when recording the LoadRunner scripts.
2. Have a consistent way of re-recording LoadRunner scripts based on the same input delivered by the watir script.
3. Diffing for correlation becomes easier because of consistency between multiple recordings of the same script.
4. Watir scripts are easier to maintain than LoadRunner scripts.
5. You can incorporate other Ruby gems into your watir scripts to assist with repetitive tasks during recording. For example, I copy transaction names to the clipboard between each step so I can easily paste them into transaction start timers.
6. Watir scripts can double as a smoke test which you can run in parallel with load tests that use only virtual users.
7. Watir scripts (and sampling response time from a real browser) will incorporate other factors such as client render time. Something which vusers really can’t do.

Downside is that you need to do a little more preparation than you might have to if you’re just following a manual test case. Once you have a framework for creating your watir script, this becomes easier. I figure it takes me about 1 hour to script up an end to end transaction that might have around 30 sub transactions (or design steps).

So what do you need to get started?

Firstly to install watir, follow these instructions here.

Come up with a framework for driving your manual test cases. There’s plenty of examples out there on how to make bullet proof frameworks driven from a variety of sources. Alister shares some good tips here.

Here’s a simple framework to get you started.

I have a helpers class that fires up the browser (attaches to the window that LoadRunner spawns) and some common methods for starting/stopping transaction timers and writing out information to a logfile. It looks like this.
helpers.rb

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

require 'rubygems'
require 'watir'
require 'logger'
require 'win32/clipboard'
require 'dl'
require 'win32/sound'
include Win32
 
logfile = 'C:\temp\output.log'
@log = Logger.new(logfile, 'daily')
@log.info("\nNew test started at " + Time.now.to_s)
@log.datetime_format = "%H:%M:%S"
 
# if I want each step to start on the minute
# useful when tracing back through profile logs
# on the target server
@staggered = false
 
# pause after each step to prompt you to
# stop a transaction time or start a new one
@pause = false
 
# setup a clipboard object to copy transaction names to
@clipboard ||= Win32::Clipboard
 
# setup my browser object and attach to a running browser
# spawned by the loadrunner recording engine
@b ||=Watir::IE.attach(:title, /FOOBAR/)
 
# alternatively start a new browser
#~ @b ||=Watir::Browser.new
@b.visible = true
@b.speed = :fast
@b.bring_to_front
 
# display a simple message box with a dodgy sound
# to grab your attention
def message_box(txt, title=APP_TITLE, buttons=0)
  5.upto(10) { |i| Sound.beep(i*1000,30) }
  user32 = DL.dlopen('user32')
  msgbox = user32['MessageBoxA', 'ILSSI']
  r, rs = msgbox.call(0, txt, title, buttons)
  return r
end
 
# a start timer method
def timer_start
 
  # figure out how long to sleep if staggered start is true
  now = DateTime.now
  diff = 60 - now.sec
  sleep diff if @staggered
 
  # empty clipboard and copy current transaction name to it
  @clipboard.empty()
  @clipboard.set_data(@t)
 
  # prompt you to start a new transaction if pause is true
  message_box(@t, "Start Transaction", 0) if @pause
 
  @start_time = Time.now
end
 
# end timer method
def timer_end
  @end_time = Time.now
 
  # prompt you to stpo end a transaction if pause is true
  message_box(@t, "End Transaction", 0) if @pause
 
  # figure out elapsed time
  @elapsed_time = (@end_time - @start_time) * 1000
  tab = "\t"
 
  # write it all to you logger
  @log.info(@start_time.to_f.to_s + tab + @end_time.to_f.to_s  + tab \
  + tab + @start_time.to_s + tab + sprintf('%-60s', @t) + tab + sprintf('%10s', @elapsed_time.to_s) )
end
 
# a simple sync method to wait for text on a scren
def sync(text)
  Watir::Waiter.wait_until{ @b.text.include?(text) }
end

Now your manual test case in ruby should look pretty simple. I typically rely on things like the :name, :text or :id attributes of html elements depending on how the application was written by the developers. The manual test case will look something like this.
001_test_case.rb

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

require 'helpers.rb'
 
begin
 
  @t = "INIT"
  timer_start
  @b.goto('https://foobar/wps/myportal')
  timer_end
 
  @t = "LOGIN"
  timer_start
  @b.text_field(:name, "username").set("yoohoo")
  @b.text_field(:name, "password").set("foobar")
  @b.button(:index, 1).click
  timer_end
 
  @t = "FOOBAR_03a_03_Tab"
  timer_start
  @b.link(:text, /FOOBAR/).click
  timer_end
 
  @t = "FOOBAR_03a_04_FOOBAR_Tab"
  timer_start
  @b.link(:text, /FOOBAR/).click
  sync("New FOOBAR")
  timer_end
 
  @t = "FOOBAR_03a_27_Record_Notes"
  @b.text_field(:id, "PC_7_C5L40JR2001F002J5MT98S28H6__L_8_0_1_0_14_1_1").set("Justification")
  timer_start
  @b.button(:text, /Save/).click
  timer_end
 
  @t = "FOOBAR_03a_28_Save_And_Foobaz"
  timer_start
  @b.link(:text, /Save & Foobaz/).click
  timer_end
 
  # etc ...
 
rescue Exception => e
  @log.error(@start_time.to_i.to_s + "\t" + sprintf('%-60s', @trans) + "\tError\n" + e)
end

Running this test case will output a log file to C:\temp\output.log that looks like this.

New test started at Thu Oct 08 20:37:48 +1100 2009
1254994670.936  1254994671.576          Thu Oct 08 20:37:50 +1100 2009  INIT                                                                 640.0
1254994671.576  1254994678.233          Thu Oct 08 20:37:51 +1100 2009  LOGIN                                                               6657.0
1254994678.233  1254994694.123          Thu Oct 08 20:37:58 +1100 2009  FOOBAR_03a_03_Tab                                          15890.0
1254994694.123  1254994696.014          Thu Oct 08 20:38:14 +1100 2009  FOOBAR_03a_04_FOOBAR_Tab                                      1891.0
1254994717.171  1254994727.608          Thu Oct 08 20:38:37 +1100 2009  FOOBAR_03a_05_Enter_FOOBAR_Type                              10437.0
1254994729.28   1254994743.499          Thu Oct 08 20:38:49 +1100 2009  FOOBAR_03a_06_Search_for_Primary_Person                      14219.0
1254994748.093  1254994767.265          Thu Oct 08 20:39:08 +1100 2009  FOOBAR_03a_07_Associate_Primary_Person                       19172.0
1254994767.265  1254994780.796          Thu Oct 08 20:39:27 +1100 2009  FOOBAR_03a_08_Enter_Primary_Person_Address_Details           13531.0
1254994780.796  1254994818.765          Thu Oct 08 20:39:40 +1100 2009  FOOBAR_03a_09_Enter_Primary_Person_Doc_Details        37969.0
1254994818.765  1254994835.906          Thu Oct 08 20:40:18 +1100 2009  FOOBAR_03a_16_Add_PoC _Link                                     17141.0
1254994838.828  1254994843.515          Thu Oct 08 20:40:38 +1100 2009  FOOBAR_03a_17_Add_PoC                                            4687.0
1254994852.078  1254994855.469          Thu Oct 08 20:40:52 +1100 2009  FOOBAR_03a_18_Search_Agent                                       3391.0
1254994855.469  1254994859.203          Thu Oct 08 20:40:55 +1100 2009  FOOBAR_03a_19_View_Agent                                         3734.0
1254994863.953  1254994876.203          Thu Oct 08 20:41:03 +1100 2009  FOOBAR_03a_20_Associate_Agent                                   12250.0
1254994876.203  1254994879.484          Thu Oct 08 20:41:16 +1100 2009  FOOBAR_03a_21_Add_Payment_Link                                   3281.0
1254994894.094  1254994894.703          Thu Oct 08 20:41:34 +1100 2009  FOOBAR_03a_22_Record_Payment_Details                              609.0
1254995196.611  1254995196.611          Thu Oct 08 20:46:36 +1100 2009  SAP                                                                    0.0
1254995202.486  1254995258.517          Thu Oct 08 20:46:42 +1100 2009  FOOBAR_03a_25_ Run Validity Assessment                          56031.0
1254995267.736  1254995280.017          Thu Oct 08 20:47:47 +1100 2009  FOOBAR_03a_27_Record_Notes                                      12281.0
1254995280.017  1254995346.579          Thu Oct 08 20:48:00 +1100 2009  FOOBAR_03a_28_Save_And_Foobaz                                    66562.0

Which gives you things like start and stop times, elapsed times and action names to help you debug things further down the track.

All up I think it’s a pretty neat solution for re-re-re-recording LoadRunner scripts (or your tool of choice) you inevitably face in fast changing environments. Whilst writing this post I had a script ticking away in the background recording some 3000+ LoadRunner events. YMMV.

I couldn’t really do this from Ruby itself, so I installed Fiddler. [...]]]> By this I mean I wanted to determine how much network and server time was spent processing a request initiated by a Watir script. Server time as defined by time to first buffer and network time as time to last buffer (minus the first).

I couldn’t really do this from Ruby itself, so I installed Fiddler. Fiddler lets you capture traffic in much the same way as ethereal / wireshark but with a nice GUI. There are some Fiddler customization scripts which let you display this info in the Custom column i.e.
oSession["ui-customcolumn"] = "FB: " + oSession["X-TTFB"] + "; LB: " + oSession["X-TTLB"];

But if you’re a neat freak like me and want them in separate columns then do this:

public static BindUIColumn("Time")
function CalcMethodCol1(oS: Session){
if (null != oS.oRequest) return DateTime.Now.ToString("dd/MM/yy HH:mm:ss.ffff");
else return String.Empty;
}

public static BindUIColumn("TTLBuffer")
function CalcMethodCol4(oS: Session){
if (null != oS.oResponse) return oS["X-TTLB"];
else return String.Empty;
}


You place them before you declare the static function OnBeforeRequest. The time stamp used above ends up being the ‘end’ timestamp, not the ’start’ so you just need to subtract time to last buffer to determine that. You end up with this in your summary view:

Once this is done you can pretty up the results by copying the ‘Full Summary’ for your selected sessions in Fiddler and pasting them into Excel. This was the main reason for doing this. If you’re happy with the Fiddler ‘timeline’ view then you don’t need to bother. I just wanted the data so I could merge/correlate with other data sources.

Would be interested to know if anyone has achieved this in ruby itself. I was thinking of using the webrick/httpproxy but would have come short if testing a HTTPS web app.

To use FireWatir, you will have to install a Firefox [...]]]> A new version of FireWatir has been released. This includes some fixes related to Firefox 3 but more importantly, it marks the merger of FireWatir and Watir projects, allowing for tighter coupling of methods and functionality between the two, allowing you to write less code =)

To use FireWatir, you will have to install a Firefox plugin that enables use of a JavaScript Shell (jssh). FireWatir works on Windows, Mac and Linux.
Install FireWatir: [sudo] gem install FireWatir
Install Plugin: http://wiki.openqa.org/display/WTR/FireWatir

I will be using FireWatir on my mac for impromptu testing, since more recently I’ve found it beneficial to write automated test cases to provide consistent input when recording load test scenarios in JMeter or LoadRunner. For those interested in even more x-browser support, check out SafariWatir as well: http://safariwatir.rubyforge.org/

Watir is a simple open-source library for automating web browsers. It allows you [...]]]> In an effort to get more actively involved with the open source community, I’ve recently starting working with another colleague on a new site called justaddwatir.com. This is an exciting collaboration of examples for web application testing in ruby (watir – pronounced “water”).

Watir is a simple open-source library for automating web browsers. It allows you to write tests that are easy to read and easy to maintain. It is optimized for simplicity and flexibility. Watir drives browsers the same way people do. It clicks links, fills in forms, presses buttons. Watir also checks results, such as whether expected text appears on the page.

Its main purpose will be to serve as a working repository of examples that answer questions newcomers have when scripting in watir. Its secondary purpose is to act as an extended regression suite of more applied test cases, which with the blessing of the lead developers of watir (Brett Pettichord) will help test future releases of watir. A working code base of unit tests is being maintained at http://code.google.com/p/justaddwatir/

If you’d like to get involved in the project or you have a blog about watir which you’d like to be aggregated, please send an email to tim.koops at gmail.com

Specifically I wanted to achieve the following:

I’ve been using this tool mostly from a windows box, and knew of the firefox equivalent, aptly named ‘Firewatir’ [...]]]> By now you’ve probably heard of watir or Web Application Testing In Ruby, a great automation framework which supports Microsoft Internet Explorer, and recently came in at number 3 as a popular oss tool on this blog.

I’ve been using this tool mostly from a windows box, and knew of the firefox equivalent, aptly named ‘Firewatir’ which is currently a Google code project. The beauty of this version, is that it allows you as a tester to explore functionality on your favourite platform for development, as I like to leave windows at work, and take OSX with me on the train.

Read on for some simple instructions in getting this running on your Macbook Pro …

Install the latest gem for firewatir using terminal
sudo gem install firewatir

Download the latest browser extension (XPI) for JSSh from here:
http://firewatir.googlecode.com/files/jssh-darwin-0.94.xpi

I found the easiest way to install it on a Mac is to open up Firefox, then just drag the .xpi file across to the browser. You’ll then be prompted with the usual in order to install the extension. You can also check for updates at the main Google code page.

Once installed, restart Firefox and enable the JSSh plugin from the Tools->JSSh configuration

You need to tick the checkbox that enables JSSh to listen in on port 9997

You should now be able to telnet to that port from a terminal
telnet 127.0.0.1 9997

ctrl-] to quit the shell and type quit to exit telnet

Allow popups for firefox by setting preferences->content as follows

Run the unit tests that come with your firewatir gem, typically:
cd /Library/Ruby/Gems/1.8/gems/firewatir-1.1.1/unittests/
ruby mozilla_all_tests.rb

This will take a couple of minutes after which you should get something similar to the following:
251 tests, 1414 assertions, 0 failures, 2 errors

Note: I get a couple of errors in attaching to new windows as per the following

1) Error:
test_simply_attach_to_new_window_using_title(TC_NewWindow):
FireWatir::Exception::NoMatchingWindowFoundException: Unable to locate window, using title and Pass Page
./../firewatir.rb:410:in `attach'
./unittests/attach_to_new_window_test.rb:16:in `test_simply_attach_to_new_window_using_title'

2) Error:
test_simply_attach_to_new_window_using_url(TC_NewWindow):
FireWatir::Exception::NoMatchingWindowFoundException: Unable to locate window, using url and (?-mix:pass\.html)
./../firewatir.rb:410:in `attach'
./unittests/attach_to_new_window_test.rb:24:in `test_simply_attach_to_new_window_using_url'

which at this stage I’m not overly concerned with as I’m not using that functionality. I’ll post an update if I resolve that for my system.

For such a simple requirement, it’s frustrating that solutions available either cost money (such as the purchase of SnagIt) or are a tad complicated in implementation requiring the installation of some out of date gems and dependencies. [...]]]> Recently I noticed some discussion in the watir user group about trying to capture screenshots when running automated tests.

For such a simple requirement, it’s frustrating that solutions available either cost money (such as the purchase of SnagIt) or are a tad complicated in implementation requiring the installation of some out of date gems and dependencies. I’ve also come across this requirement in other automation tools such as QTP, so I thought it’s about time I rolled up my sleeves and hack together a simple solution with C#.NET 2.0.

First thing I did was created a small app called snapit.exe which you can download here. If anyone is interested in improving the code, you’re welcome to get a copy of my source code here. In short, all this app does is take a screenshot of the entire screen, and save it to a default location (currently C:\snapit.png). Repeated use of the app will increment the filename by 1 i.e. snapit1.png, snapit2.png …

You can change the default file path by passing it a parameter at runtime
e.g. D:\\snapit.exe D:\\images\\testcase.png

Next thing to do is call it from your watir code. In Ruby, this is as simple as:

1
2

cmd = 'D:\\snapit.exe'
puts %x{#{cmd}}

Putting it all together with some watir as an example:

1
2
3
4
5
6
7

require "watir"
test_site = "http://www.90kts.com"
ie = Watir::IE.new
ie.goto test_site
ie.link(:text, "Contact").click
cmd = 'D:\\snapit.exe D:\\images\\testsuite.png'
puts %x{#{cmd}}

Hopefully someone finds that useful. You can use this in any automation suite really, up to you. It’s free of course, unless you want to donate some money towards my appreciation for beer…