GhostDriver is a project that lets you write Selenium WebDriver automation tests that run using the PhantomJS headless WebKit, instead of a traditional web browser.

Put another way, PhantomJS can replace Firefox and friends in your WebDriver scripts - and it doesn’t require a display, so testing complex web apps from the command line is just about as easy as using a GUI browser. Very cool!

Getting your system ready to run Python scripts that use GhostDriver can be done in a few brief steps, if you have homebrew on OS X.

First you’ll need the Selenium python package:

1

sudo pip install selenium

Then, use homebrew to install PhantomJS:

1

brew install phantomjs

If you don’t want to use homebrew (or you’re not on a Mac) you can simply download the latest PhantomJS build manually and install it.

Believe it or not, that is all. GhostDriver is integrated into PhantomJS, so you should now be set up to take them for a test drive.

A typical Hello World program in the web automation world is one that performs a Google search. So, here’s what that looks like in Python and GhostDriver, using Python in interactive mode:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

$ python

>>> from selenium import webdriver
>>> driver = webdriver.PhantomJS('phantomjs')
>>> driver.get("http://www.google.com")
>>> driver.title
u'Google'
>>> driver.current_url
u'http://www.google.com/'
>>> driver.find_element_by_name("q").is_displayed()
True
>>> driver.find_element_by_name("q").send_keys("selenium")
>>> driver.find_element_by_name("btnG").click()
>>> driver.current_url
u'http://www.google.com/search?hl=en&source=hp&q=selenium&gbv=2&oq=selenium'

A natural next step, when developing automated test cases based on experiments like the one above, is to start storing your code into a Python unittest script.

Here’s an example of how one might start organizing the code above:

If all is right with the world, running the above script will print output along the lines of the text below.

1
2
3
4
5
6
7

$ ./test_google_ghost_driver.py
current_url is now 'http://www.google.com/search?hl=en&source=hp&q=selenium&gbv=2&oq=selenium'
.
----------------------------------------------------------------------
Ran 1 test in 2.770s

OK

That’s all for the moment. Now, go forth and Ghost Drive!

My last post was about executing small Java programs from within vim, without leaving the editor to manually open a shell.

The goal was to rapidly execute example code for your own edification, or when showing code to other people - basically any time you need a Short, Self Contained, Correct (Compilable), Example (also known as an SSCCE).

While vim does indeed work for that purpose, I feel TextMate has the edge when it comes to running Java examples.

Here’s what setting up and using TextMate to run Java programs on Mac looks like:

• After you install TextMate, open the Bundle settings (in ‘TextMate > Preferences > Bundles’) and make sure the ‘Java’ checkbox is set:

• Open or compose your demo program, and make sure you’ve saved the file to disk.

• In the bottom status bar, Make sure the Java bundle is selected:

• Now simply use Command-R to run your code! A new window should open to display the output.

For instructional purposes (either when experimenting on your own, or when demonstrating code to others) it’s always useful to be able to run snippets of code in a REPL, or a similar environment allowing fast turnaround in the edit/compile/run cycle.

When using Java, the customary IDEs offer ways to get REPL-like behavior, but what if you don’t want to use a traditional Java IDE?

Perhaps you just want to demonstrate a trivial bit of code without much overhead.

In that situation, a couple of nice options for Java are:

• Use GroovyConsole as a Java REPL
• Edit your code in Vim, and compile and run it without leaving the editor

1. Using GroovyConsole

If you’re on a Mac, GroovyConsole can be installed via the homebrew groovy formula (or, just get it from http://groovy.codehaus.org):

brew install groovy

Launch GroovyConsole with this command:

groovyConsole

Then simply type in a code snippet and run it with <Command-R> (or on Windows, <CTRL-R>):

2. Using Vim as an improvised Java IDE

First, launch vim and write a small program - for example, Foo.java:

Then, compile your program without leaving vim by passing the file open in your vim buffer to javac, using the :! command sequence and %

If all goes well, you’ll temporarily be dropped to the shell, with no visible errors, and get prompted to press ENTER to continue back to vim:

Back in the editor, use :!java Foo to invoke the Java class file you just created with javac:

Finally, you’ll see your program’s output in the console.

For further fun, try compiling with javac -g %, then launch your class file with jdb Foo to debug your program from within vim.

Also, you might consider taking the javacomplete omni-completion plugin for a spin.

Say you’re on the console on your Raspberry Pi, and you want to take a screenshot. But without X running, what does one do?

Simple: Use fbgrab. To install it, just:

sudo apt-get install fbgrab

Pass fbgrab the name of the virtual terminal/tty you want to snapshot, and it’ll spit out a PNG file.

For example, say you have an awesome console program running on /dev/tty1, and want to screenshot it - just run:

sudo fbgrab -c 1 screenshot.png

And that’s it! Here’s an example of the output:

Lately I’ve been looking for reasons to use OmniGraffle for diagramming.

And with the steps to set up static web hosting in S3 (as mentioned in my last post) still fresh in mind, it seems like a good time to document what I did. And the steps are simple enough that a diagram might just be enough to cover the important bits.

So here it is - someday it’ll be interesting to look back on this and see what’s easier/more streamlined in this process, and what remains the same:

New year, new hosting stack! This blog is now brought to you by Octopress, hosted on Amazon S3, instead of Blogger.

After spending some quality time with the tools I used in the move from Blogger (Octopress, S3, Route 53, git), I feel like the proverbial new pair of glasses has descended and shown me a new world.

So what are the benefits of Octopress? To list just a few:

• Solarized syntax highlighting built in. This was all I had to hear to get really interested.
• Easy editing of posts in the editor of your choice, using markdown, instead of wrestling the blogger tools.
• Cheap! For my minimal custom domain hosting needs, S3/Route 53 costs should be super low.
• Applying third-party themes is super easy, should you get the urge to check out alternatives.
• Storing everything in a git repo is painless, so no worries when playing around with new themes, or making other significant edits. In blogger-land this didn’t feel anywhere near as easy.

To sum up, maintaining this blog just became a lot more enjoyable.

Some helpful Octopress references were:

• http://approache.com/blog/migrating-from-blogger-to-octopress/
• http://mattgemmell.com/2011/09/12/blogging-with-octopress/
• http://www.julianbonilla.com/blog/2012/11/05/octopress-on-amazon-s3/