On Windows you'll need Cygwin to get access to GCC, Python, etc. Read
this
for detailed instructions and troubleshooting.

Walking

To start off we're going to need a browser. A browser maintains state
across requests: history, cookies, HTML 5 local and session stroage. A
browser has a main window, and typically a document loaded into that
window.

You can create a new zombie.Browser and point it at a document, either
by setting the location property or calling its visit function. As
a shortcut, you can just call the zombie.visit function with a URL and
callback.

The browser will load the document and if the document includes any
scripts, also load and execute these scripts. It will then process some
events, for example, anything your scripts do on page load. All of
that, just like a real browser, happens asynchronously.

To wait for the page to fully load and all events to fire, you pass
visit a callback function. This function takes two arguments. If
everything is successful (page loaded, events run), the callback is
called with null and a reference to the browser.

Most errors that occur – resource loading and JavaScript execution – are
not fatal, so rather the stopping processing, they are collected in
browser.errors. The error list is passed to the callback as the
fourth argument (the third argument is the status code).

If you worked with Node.js before you're familiar with this callback
pattern. Every time you see a callback in the Zombie.js API, it works
that way: the first argument is an error, or null if there is no error.
And if there are no fatal errors, the remaining arguments may hold
interesting values.

Whenever you want to wait for all events to be processed, just call
browser.wait with a callback.

Hunting

There are several ways you can inspect the contents of a document. For
starters, there's the DOM API, which you
can use to find elements and traverse the document tree.

You can also use CSS selectors to pick a specific element or node list.
Zombie.js implements the DOM Selector
API. These functions are
available from every element, the document, and the Browser object
itself.

To get the HTML contents of an element, read its innerHTML property.
If you want to include the element itself with its attributes, read the
element's outerHTML property instead. Alternatively, you can call the
browser.html function with a CSS selector and optional context
element. If the function selects multiple elements, it will return the
combined HTML of them all.

To see the textual contents of an element, read its textContent
property. Alternatively, you can call the browser.text function with
a CSS selector and optional context element. If the function selects
multiple elements, it will return the combined text contents of them
all.

Here are a few examples for checking the contents of a document:

// Make sure we have an element with the ID brains.
assert.ok(browser.querySelector("#brains"));
// Make sure body has two elements with the class hand.
assert.equal(browser.body.querySelectorAll(".hand").length, 2);
// Check the document title.
assert.equal(browser.text("title"), "The Living Dead");
// Show me the document contents.
console.log(browser.html());
// Show me the contents of the parts table:
console.log(browser.html("table.parts"));

CSS selectors are implemented by Sizzle.js. In addition to CSS 3
selectors you get additional and quite useful extensions, such as
:not(selector), [NAME!=VALUE], :contains(TEXT), :first/:last and
so forth. Check out the Sizzle.js
documentation for more details.

Feeding

You're going to want to perform some actions, like clicking links,
entering text, submitting forms. You can certainly do that using the
DOM API, or several of the convenience
functions we're going to cover next.

To click a link on the page, use clickLink with selector and callback.
The first argument can be a CSS selector (see Hunting), the A
element, or the text contents of the A element you want to click.

The second argument is a callback, which much like the visit callback
gets fired after all events are processed, with either an error, or
null, the browser and the HTTP status code.

To submit a form, use pressButton. The first argument can be a CSS
selector, the button/input element. the button name (the value of the
name argument) or the text that shows on the button. You can press
any BUTTON element or INPUT of type submit, reset or button.
The second argument is a callback, just like clickLink.

Of course, before submitting a form, you'll need to fill it with values.
For text fields, use the fill function, which takes two arguments:
selector and the field value. This time the selector can be a CSS
selector, the input element, the field name (its name attribute), or
the text that shows on the label associated with that field.

The fill function returns a reference to the browser, so you can chain
several functions together. Its sibling functions check and uncheck
(for check boxes), choose (for radio buttons) and select (for drop
downs) work the same way.