casper 0.0.1

data/README.md

@@ -0,0 +1,85 @@
+Casper
+======
+
+A DSL for automated mouse <del>and keyboard</del> input in X11.
+
+Usage
+-----
+
+Right now Casper only does mouse input, it looks something like this:
+
+    Casper::Mouse.move 200, 300 # puts the cursor at x: 200px, y: 300px
+    Casper::Mouse.down          # presses the primary mouse button
+    Casper::Mouse.up            # releases the primary mouse button
+    Casper::Mouse.click         # clicks with the primary mouse button
+    Casper::Mouse.location      # => [ 200, 300 ]
+
+Which is all well and good, but the more useful stuff looks like:
+
+    Casper::Mouse.drag :from => [ 200, 300 ], :distance => [ 30, 60 ], :increments => 10 do
+      Casper::Mouse.drag :distance => [ 80, 100 ] do
+        sleep 0.5
+      end
+    end
+    
+We've found it particularly useful in conjunction with Selenium-based
+Javascript testing. We use it to reliably test complex movements (such as a
+velocity-aware drag, or drag and drop between multiple containers with
+timeouts, etc...)
+
+Requirements
+------------
+
+Requires `libxdo` (comes with `xdotool`). Details and installation
+instructions can be found at http://www.semicomplete.com/projects/xdotool/.
+
+Quick build instructions for Ubuntu (tested on 10.04):
+
+    $ sudo apt-get install xorg-dev
+    $ wget http://semicomplete.googlecode.com/files/xdotool-2.20100818.3004.tar.gz
+    $ tar xzvf xdotool-2.20100818.3004.tar.gz
+    $ cd xdotool-2.20100818.3004
+    $ sudo make all install
+
+Testing
+-------
+
+We test Casper in a VM environment set up by Vagrant. If you have Vagrant
+(http://www.vagrantup.com/) set up and running, and you have the lucid32.box,
+you can just do:
+
+    $ cd test && vagrant up
+
+Once your VM is provisioned and running, ssh in (`vagrant ssh`) and then:
+
+    $ startx &
+    $ cd ~/casper/test
+    $ ruby casper_test.rb
+
+If you don't have Vagrant set up, you can follow the getting started guide at
+http://www.vagrantup.com/, or you can install the necessary dependencies on
+your local machine and test locally. Instructions for installing the
+dependencies can be found under `test/cookbooks`.
+
+License
+-------
+
+Copyright (c) 2010 Ben Alavi and Chris Schneider
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/lib/casper.rb

@@ -0,0 +1,115 @@
+require "libxdo"
+
+module Casper
+  class Mouse
+    class << self
+      # Move the mouse directly to the specified x/y coordinates.
+      # 
+      # If relative = true the x/y coordinates used are relative from the
+      # current position, otherwise they are considered to be absolute.
+      def move(x, y, relative=false)
+        relative ? relative(x, y) : absolute(x, y)
+      end
+            
+      # Press the given mouse button down (default is 1: primary)
+      def down(button=1)
+        Libxdo.xdo_mousedown xdo, Libxdo::CurrentWindow, button
+      end
+      
+      # Release the given mouse button (default is 1: primary)
+      def up(button=1)
+        Libxdo.xdo_mouseup xdo, Libxdo::CurrentWindow, button
+      end
+      
+      # Click the given mouse button (default is 1: primary)
+      def click(button=1)
+        Libxdo.xdo_click xdo, Libxdo::CurrentWindow, button
+      end
+      
+      # Gives the current mouse position
+      def location
+        x = FFI::MemoryPointer.new :pointer
+        y = FFI::MemoryPointer.new :pointer
+        s = FFI::MemoryPointer.new :pointer
+        Libxdo.xdo_mouselocation xdo, x, y, s
+        [ x.read_int, y.read_int ]
+      end
+      
+      # Perform a drag operation with the given options. A drag is performed
+      # by moving the mouse to a starting location, pressing the primary mouse
+      # button down, incrementally moving to another location, and then
+      # releasing the primary mouse button.
+      # 
+      # Available options are:
+      # 
+      # * :from => [ x, y ] -- The absolute x/y coordinates to start from. If
+      #   omitted the drag will be started from the current mouse location.
+      # * :to => [ x, y ] -- The absolute x/y coordinates to end at. Can use
+      #   :distance instead for relative movements.
+      # * :distance => [ x, y ] -- Can be used instead of :to to provide an
+      #   end point relative to the starting point.
+      # * :increments => i -- The number of increments to include in the drag
+      #   from the start to the end, defaults to 10. More increments cause a
+      #   smoother, slower drag. Fewer increments cause a faster "jerkier"
+      #   drag.
+      # 
+      # Also a block can be passed which will be yielded before the mouse is
+      # released. This can be used to drag and hover for a period of time, or
+      # chain multiple drags, etc...
+      # 
+      # i.e.
+      # 
+      #   drag :to => [ 300, 350 ]
+      #   drag :from => [ 200, 300 ], :to => [ 400, 800 ]
+      #   drag :from => [ 200, 300 ], :distance => [ 200, 500 ]
+      #   drag :from => [ 200, 300 ], :distance => [ 220, 340 ], :increments => 20
+      #   drag :from => [ 200, 300 ], :to => [ 300, 400 ] do
+      #     sleep 0.5
+      #   end
+      #   drag :distance => [ 20, 0 ] do
+      #     drag :distance => [ 0, 30 ]
+      #   end
+      def drag(options={}, &block)        
+        raise ArgumentError.new(":to or :distance is required to provide ending location") unless options.has_key?(:to) || options.has_key?(:distance)
+        raise ArgumentError.new(":increments must be > 0") if options.has_key?(:increments) && options[:increments] <= 0
+        
+        from       ||= options[:from] || location
+        increments   = options[:increments] || 10
+        distance     = options[:distance] || [ options[:to][0] - from[0], options[:to][1] - from[1] ]
+        
+        shift_x = distance[0] / increments
+        shift_y = distance[1] / increments
+
+        move from[0], from[1]
+        down
+        increments.times{ |i| move(shift_x, shift_y, true) }
+        yield if block_given?
+        up
+      end
+      
+      private
+      
+      # Returns a new xdo instance
+      def xdo
+        Libxdo.xdo_new(nil)
+      end      
+      
+      # Performs an absolute mouse move
+      def absolute(x, y)
+        xdor = xdo
+        
+        Libxdo.xdo_mousemove(xdor, x, y, 0)
+        Libxdo.xdo_mouse_wait_for_move_to(xdor, x, y)
+      end
+      
+      # Performs a relative mouse move
+      def relative(x, y)
+        xdor = xdo
+        loc  = location
+        
+        Libxdo.xdo_mousemove_relative(xdor, x, y)
+        Libxdo.xdo_mouse_wait_for_move_to(xdor, loc[0] + x, loc[1] + y)
+      end
+    end
+  end
+end

data/lib/libxdo.rb

@@ -0,0 +1,256 @@
+require "ffi"
+
+module Casper
+  module Libxdo
+    extend FFI::Library
+
+    CurrentWindow = 0
+    
+    ffi_lib "xdo"
+
+    # xdo_t * xdo_new (char *display)
+    attach_function "xdo_new", [ :string ], :pointer
+
+    # xdo_t * xdo_new_with_opened_display (Display *xdpy, const char *display, int close_display_when_freed)
+    attach_function "xdo_new_with_opened_display", [:pointer, :string, :int], :pointer
+
+    # const char * xdo_version (void)
+    attach_function "xdo_version", [], :string
+
+    # void xdo_free (xdo_t *xdo)
+    attach_function "xdo_free", [:pointer], :void
+
+    # int xdo_mousemove (const xdo_t *xdo, int x, int y, int screen)
+    attach_function "xdo_mousemove", [:pointer, :int, :int, :int], :int
+
+    # int xdo_mousemove_relative_to_window (const xdo_t *xdo, Window window, int x, int y)
+    # XXX: Window is not a pointer - find the typedef
+    attach_function "xdo_mousemove_relative_to_window", [:pointer, :pointer, :int, :int], :int
+    
+    # int xdo_mousemove_relative (const xdo_t *xdo, int x, int y)
+    attach_function "xdo_mousemove_relative", [:pointer, :int, :int], :int
+
+    # int xdo_mousedown (const xdo_t *xdo, Window window, int button)
+    attach_function "xdo_mousedown", [:pointer, :int, :int], :int
+
+    # int xdo_mouseup (const xdo_t *xdo, Window window, int button)
+    attach_function "xdo_mouseup", [:pointer, :int, :int], :int
+
+    # int xdo_mouselocation (const xdo_t *xdo, int *x, int *y, int *screen_num)
+    attach_function "xdo_mouselocation", [:pointer, :pointer, :pointer, :pointer], :int
+
+    # int xdo_mouse_wait_for_move_from (const xdo_t *xdo, int origin_x, int origin_y)
+    attach_function "xdo_mouse_wait_for_move_from", [:pointer, :int, :int], :int
+
+    # int xdo_mouse_wait_for_move_to (const xdo_t *xdo, int dest_x, int dest_y)
+    attach_function "xdo_mouse_wait_for_move_to", [:pointer, :int, :int], :int
+
+    # int xdo_click (const xdo_t *xdo, Window window, int button)
+    attach_function "xdo_click", [:pointer, :int, :int], :int
+
+    # int xdo_type (const xdo_t *xdo, Window window, char *string, useconds_t delay)
+    # XXX: Map useconds_t
+    attach_function "xdo_type", [:pointer, :int, :string, :int], :int
+
+    # int xdo_keysequence (const xdo_t *xdo, Window window, const char *keysequence, useconds_t delay)
+    # XXX: Window != pointer
+    # XXX: Map useconds_t
+    attach_function "xdo_keysequence", [:pointer, :pointer, :string, :int], :int
+
+    # int xdo_keysequence_up (const xdo_t *xdo, Window window, const char *keysequence, useconds_t delay)
+    # XXX: Window != pointer
+    # XXX: Map useconds_t
+    attach_function "xdo_keysequence_up", [:pointer, :pointer, :string, :int], :int
+
+    # int xdo_keysequence_down (const xdo_t *xdo, Window window, const char *keysequence, useconds_t delay)
+    # XXX: Window != pointer
+    # XXX: Map useconds_t
+    attach_function "xdo_keysequence_down", [:pointer, :pointer, :string, :int], :int
+
+    # int xdo_keysequence_list_do (const xdo_t *xdo, Window window, charcodemap_t *keys, int nkeys, int pressed, int *modifier, useconds_t delay)
+    # XXX: Window != pointer
+    # XXX: What"s a charcodemap_t?
+    # XXX: Map useconds_t
+    attach_function "xdo_keysequence_list_do", [:pointer, :pointer, :pointer, :int, :int, :pointer, :int], :int
+
+    # int xdo_active_keys_to_keycode_list (const xdo_t *xdo, charcodemap_t **keys, int *nkeys)
+    # XXX: Map useconds_t
+    # XXX: What"s a pointer to pointer to charcodemap_t?
+    attach_function "xdo_active_keys_to_keycode_list", [:pointer, :pointer, :pointer], :int
+
+    # int xdo_window_wait_for_map_state (const xdo_t *xdo, Window wid, int map_state)
+    # XXX: Window != pointer
+    attach_function "xdo_window_wait_for_map_state", [:pointer, :pointer, :int], :int
+
+    # int xdo_window_move (const xdo_t *xdo, Window wid, int x, int y)
+    # XXX: Window != pointer
+    attach_function "xdo_window_move", [:pointer, :pointer, :int, :int], :int
+
+    # int xdo_window_setsize (const xdo_t *xdo, Window wid, int w, int h, int flags)
+    # XXX: Window != pointer
+    attach_function "xdo_window_setsize", [:pointer, :pointer, :int, :int, :int], :int
+
+    # int xdo_window_setprop (const xdo_t *xdo, Window wid, const char *property, const char *value)
+    # XXX: Window != pointer
+    attach_function "xdo_window_setprop", [:pointer, :pointer, :string, :string], :int
+
+    # int xdo_window_setclass (const xdo_t *xdo, Window wid, const char *name, const char *class)
+    # XXX: Window != pointer
+    attach_function "xdo_window_setclass", [:pointer, :pointer, :string, :string], :int
+
+    # int xdo_window_focus (const xdo_t *xdo, Window wid)
+    # XXX: Window != pointer
+    attach_function "xdo_window_focus", [:pointer, :pointer], :int
+
+    # int xdo_window_raise (const xdo_t *xdo, Window wid)
+    # XXX: Window != pointer
+    attach_function "xdo_window_raise", [:pointer, :pointer], :int
+
+    # int xdo_window_get_focus (const xdo_t *xdo, Window *window_ret)
+    # NOTE: This window is actually a pointer.  Watch out
+    attach_function "xdo_window_get_focus", [:pointer, :pointer], :int
+
+    # int xdo_window_wait_for_focus (const xdo_t *xdo, Window window, int want_focus)
+    # XXX: Window != pointer
+    attach_function "xdo_window_wait_for_focus", [:pointer, :pointer, :int], :int
+
+    # int xdo_window_get_pid (const xdo_t *xdo, Window window)
+    # XXX: Window != pointer
+    attach_function "xdo_window_get_pid", [:pointer, :pointer], :int
+
+    # int xdo_window_sane_get_focus (const xdo_t *xdo, Window *window_ret)
+    # NOTE: This window is actually a pointer.  Watch out
+    attach_function "xdo_window_sane_get_focus", [:pointer, :pointer], :int
+
+    # int xdo_window_activate (const xdo_t *xdo, Window wid)
+    # XXX: Window != pointer
+    attach_function "xdo_window_activate", [:pointer, :pointer], :int
+
+    # int xdo_window_wait_for_active (const xdo_t *xdo, Window window, int active)
+    # XXX: Window != pointer
+    attach_function "xdo_window_wait_for_active", [:pointer, :pointer, :int], :int
+
+    # int xdo_window_map (const xdo_t *xdo, Window wid)
+    # XXX: Window != pointer
+    attach_function "xdo_window_map", [:pointer, :pointer], :int
+
+    # int xdo_window_unmap (const xdo_t *xdo, Window wid)
+    attach_function "xdo_window_unmap", [:pointer, :pointer], :int
+
+    # int xdo_get_window_location (const xdo_t *xdo, Window wid, int *x_ret, int *y_ret, Screen **screen_ret)
+    # XXX: Window != pointer
+    # XXX: What"s a screen double pointer
+    attach_function "xdo_get_window_location", [:pointer, :pointer, :pointer, :pointer, :pointer], :int
+
+    # int xdo_get_window_size (const xdo_t *xdo, Window wid, unsigned int *width_ret, unsigned int *height_ret)
+    # XXX: Window != pointer
+    attach_function "xdo_get_window_size", [:pointer, :pointer, :pointer, :pointer], :int
+
+    # int xdo_window_get_active (const xdo_t *xdo, Window *window_ret)
+    # NOTE: This window is actually a pointer.  Watch out
+    attach_function "xdo_window_get_active", [:pointer, :pointer], :int
+
+    # int xdo_set_number_of_desktops (const xdo_t *xdo, long ndesktops)
+    attach_function "xdo_set_number_of_desktops", [:pointer, :long], :int
+
+    # int xdo_get_number_of_desktops (const xdo_t *xdo, long *ndesktops)
+    attach_function "xdo_get_number_of_desktops", [:pointer, :pointer], :int
+
+    # int xdo_set_current_desktop (const xdo_t *xdo, long desktop)
+    attach_function "xdo_set_current_desktop", [:pointer, :long], :int
+
+    # int xdo_get_current_desktop (const xdo_t *xdo, long *desktop)
+    attach_function "xdo_get_current_desktop", [:pointer, :pointer], :int
+
+    # int xdo_set_desktop_for_window (const xdo_t *xdo, Window wid, long desktop)
+    # XXX: Window != pointer
+    attach_function "xdo_set_desktop_for_window", [:pointer, :pointer, :long], :int
+
+    # int xdo_get_desktop_for_window (const xdo_t *xdo, Window wid, long *desktop)
+    # XXX: Window != pointer
+    attach_function "xdo_get_desktop_for_window", [:pointer, :pointer, :pointer], :int
+
+    # int xdo_window_search (const xdo_t *xdo, const xdo_search_t *search, Window **windowlist_ret, int *nwindows_ret)
+    # XXX: xdo_search_t?  How do I make that.
+    attach_function "xdo_window_search", [:pointer, :pointer, :pointer, :pointer], :int
+
+    # unsigned char * xdo_getwinprop (const xdo_t *xdo, Window window, Atom atom, long *nitems, Atom *type, int *size)
+    # XXX: Window != pointer
+    # XXX: Atom != pointer
+    # XXX: Unsigned char * != :string?
+    attach_function "xdo_getwinprop", [:pointer, :pointer, :pointer, :pointer, :pointer, :pointer], :string
+
+    # unsigned int xdo_get_input_state (const xdo_t *xdo)
+    attach_function "xdo_get_input_state", [:pointer], :uint
+
+    # const keysym_charmap_t * xdo_keysym_charmap (void)
+    attach_function "xdo_keysym_charmap", [], :pointer
+
+    # XXX: char** is an array of strings?
+    # const char ** xdo_symbol_map (void)
+    attach_function "xdo_symbol_map", [], :string
+
+    # xdo_active_mods_t * xdo_get_active_modifiers (const xdo_t *xdo)
+    attach_function "xdo_get_active_modifiers", [:pointer], :pointer
+
+    # int xdo_clear_active_modifiers (const xdo_t *xdo, Window window, xdo_active_mods_t *active_mods)
+    attach_function "xdo_clear_active_modifiers", [:pointer, :pointer, :pointer], :int
+
+    # int xdo_set_active_modifiers (const xdo_t *xdo, Window window, const xdo_active_mods_t *active_mods)
+    # XXX: Window != pointer
+    attach_function "xdo_set_active_modifiers", [], :int
+
+    # void xdo_free_active_modifiers (xdo_active_mods_t *active_mods)
+    attach_function "xdo_free_active_modifiers", [:pointer], :void
+
+    class Xdo < FFI::Struct
+ 	  # The Display for Xlib. 
+      # Display * xdpy
+      layout :xdpy                     ,:pointer, # Display * xdpy
+             :display_name             ,:string,  # The display name.
+             :charcodes                ,:pointer, # charcodemap_t * charcodes
+             :charcodes_len            ,:int, 
+             :modmap                   ,:pointer, # XModifierKeymap * modmap
+             :keymap                   ,:pointer, # KeySym * keymap
+             :keycode_high             ,:int, 
+             :keycode_low              ,:int, 
+             :keysyms_per_keycode      ,:int, 
+             :close_display_when_freed ,:int  # Should we close the display when calling xdo_free?
+    end
+
+    class KeysymCharmap < FFI::Struct
+      layout :keysym ,:string, 
+             :key    ,:char
+    end
+
+    # XXX: Is the native documentation off by a field?  Feels like it.
+    # class Charcodemap < FFI::Struct
+    #   # XXX: keycode isn"t a type
+    #   layout :code          ,:KeyCode, # the letter for this key, like "a"
+    #          :symbol        ,:KeySym,  # the keycode that this key is on
+    #          :index         ,:int,     # the symbol representing this key
+    #          :modmask       ,:int,     # the index in the keysym-per-keycode list that is this key
+    #          :needs_binding ,:int      # the modifiers activated by this key
+    # end
+
+    class XdoActiveMods < FFI::Struct
+      layout :keymods, :pointer,  # charcodemap_t * keymods
+             :nkeymods, :int,     # int nkeymods
+             :input_state, :uint  # unsigned int input_state
+    end
+
+    # class XdoSearch < FFI::Struct
+    #   layout :title        ,:string,      # char * title
+    #          :winclass     ,:string,      # char * winclass # pattern to test against a window title
+    #          :winclassname ,:string,      # char * winclassname # pattern to test against a window class
+    #          :winname      ,:string,      # char *  winname # pattern to test against a window class
+    #          :pid          ,:int,         # int pid # window pid (From window atom _NET_WM_PID)
+    #          :max_depth    ,:long,        # long max_depth # depth of search.
+    #          :only_visible ,:int,         # only_visible   boolean; set true to search only visible windows
+    #          :screen       ,:int,         # screen
+    #          # XXX: Map this enum. Not sure how that works.
+    #          :xdo_search   ,:search_enum, # what screen to search, if any.
+    #          :searchmask   ,:uint         # unsigned int searchmask # bitmask of things you are searching for, such as SEARCH_NAME                                               , etc.
+    # end
+  end
+end

data/test/Vagrantfile

@@ -0,0 +1,20 @@
+Vagrant::Config.run do |config|
+  config.vm.box = "base"
+  config.vm.customize do |vm|
+    vm.name = "casper"
+    vm.memory_size = 512
+  end
+
+  config.vm.network("33.33.33.10")
+  config.vm.share_folder("v-root", "~/casper", "..", :nfs => true)
+  config.vm.provisioner = :chef_solo
+  config.vm.boot_mode   = :gui
+
+  config.chef.run_list = %w(
+    recipe[application::vagrant]
+    recipe[rvm]
+    recipe[testing]
+  )
+  
+  config.chef.log_level = :debug
+end

data/test/casper_test.rb

@@ -0,0 +1,116 @@
+require File.dirname(__FILE__) + "/lib/test_helper"
+require "casper"
+
+# Yeah, we use Capybara & Selenium & jQuery & Firefox and X11 and all sorts
+# of other stuff when we could just as easily mock out the xdo lib and
+# simply make sure we're sending the right commands.
+# 
+# But this is way more fun =)
+class CasperTest < Test::Unit::TestCase
+  # Places a target div onto the document body with the given attributes
+  def target!(id, x, y, width=50, height=50)
+    evaluate_script <<-JS
+$('<div class="target" id="#{id}"></div>').
+  appendTo("body").
+  css({ left: #{x}, top: #{y}, width: #{width}, height: #{height }}).
+  draggable()
+    JS
+  end
+  
+  setup do
+    Casper::Mouse.move 0, 0
+    # Gets rid of the menu if it was left open (i.e. from leaving the mouse
+    # button down and moving over it).
+    Casper::Mouse.click
+    resize_browser 1024, 768
+    visit "/"
+  end
+  
+  describe "mouse actions" do
+    setup do
+      target! "a", 300, 220
+    end
+    
+    should "position the mouse at 320, 240" do
+      assert !has_class?("#a", "mouseover")
+    
+      Casper::Mouse.move(320, 350)
+      assert has_class?("#a", "mouseover")
+    end
+  
+    should "press the primary mouse button down on the element" do
+      assert !has_class?("#a", "mousedown")
+
+      Casper::Mouse.move(320, 350)
+      Casper::Mouse.down(1)
+      assert has_class?("#a", "mousedown")
+    end
+
+    should "release the primary mouse button on the element" do
+      assert !has_class?("#a", "mousedown")
+
+      Casper::Mouse.move(320, 350)
+      Casper::Mouse.down(1)
+      assert has_class?("#a", "mousedown")
+
+      Casper::Mouse.up(1)
+      assert !has_class?("#a", "mousedown")
+    end
+    
+    should "provide the current mouse location" do
+      Casper::Mouse.move 318, 473
+      assert_equal [ 318, 473 ], Casper::Mouse.location
+    end
+  end
+
+  describe "dragging" do
+    setup do
+      target! "a", 300, 220
+    end
+    
+    should "drag an item" do
+      Casper::Mouse.drag :from => [ 320, 350 ], :to => [ 350, 400 ]
+      assert_has_position? "#a", :left => 330, :top => 270
+    end
+    
+    should "use the current mouse position when no :from option is provided" do
+      Casper::Mouse.move 320, 350
+      assert_has_position? "#a", :left => 300, :top => 220
+
+      Casper::Mouse.drag :distance => [ 20, 20 ]
+      assert_has_position? "#a", :left => 320, :top => 240
+    end
+    
+    should "move from the current mouse position to the specified position when :to is provided without :from" do
+      Casper::Mouse.move 320, 350
+      assert_has_position? "#a", :left => 300, :top => 220
+      
+      Casper::Mouse.drag :to => [ 410, 510 ]
+      assert_has_position? "#a", :left => 390, :top => 380
+    end
+
+    should "have a default increments value, making it an optional parameter" do
+      Casper::Mouse.drag :from => [ 1, 1 ], :to => [ 2, 2 ]
+    end
+
+    should "not raise an argument error if you have a positive increment value" do
+      Casper::Mouse.drag :from => [ 1, 1 ], :to => [ 2, 2 ], :increment => 5
+    end
+
+    should "raise an argument error if you have a negative, or 0 increment" do
+      assert_raise ArgumentError do
+        Casper::Mouse.drag :from => [ 1, 1 ], :to => [ 2, 2 ], :increments => 0
+      end
+
+      assert_raise ArgumentError do
+        Casper::Mouse.drag :from => [ 1, 1 ], :to => [ 2, 2 ], :increments => -5
+      end
+    end
+
+    should "raise argument error if you did not provide either to or distance" do
+      assert_raise ArgumentError do
+        Casper::Mouse.drag :from => [ 1, 1 ]
+      end
+    end    
+  end
+end

data/test/cookbooks/application/recipes/default.rb

@@ -0,0 +1,6 @@
+require_recipe "apt"
+
+# Packages needed
+package "git-core"
+package "libxml2-dev"
+package "libxslt1-dev"

data/test/cookbooks/application/recipes/vagrant.rb

@@ -0,0 +1 @@
+require_recipe "application"

data/test/cookbooks/application/templates/default/application.erb

@@ -0,0 +1,11 @@
+<VirtualHost *:80>
+    DocumentRoot <%= @node[:vagrant][:directory] %>/public
+
+    RackEnv development
+    RailsEnv development
+
+    <Directory <%= @node[:vagrant][:directory] %>/public>
+        Allow from all
+        Options -MultiViews
+    </Directory>
+</VirtualHost>

data/test/cookbooks/apt/README.md

@@ -0,0 +1,44 @@
+DESCRIPTION
+===========
+
+Configures various APT components on Debian-like systems.
+
+RECIPES
+=======
+
+default
+-------
+
+The default recipe runs apt-get update during the Compile Phase of the Chef run to ensure that the system's package cache is updated with the latest. It is recommended that this recipe appear first in a node's run list (directly or through a role) to ensure that when installing packages, Chef will be able to download the latest version available on the remote APT repository.
+
+This recipe also sets up a local cache directory for preseeding packages.
+
+cacher
+------
+
+Installs the apt-cacher package and service so the system can be an APT cache.
+
+proxy
+-----
+
+Installs the apt-proxy package and service so the system can be an APT proxy.
+
+LICENSE AND AUTHOR
+==================
+
+Author:: Joshua Timberman (<joshua@opscode.com>)
+
+Copyright 2009, Opscode, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+

data/test/cookbooks/apt/files/default/apt-cacher

@@ -0,0 +1,9 @@
+# apt-cacher startup configuration file
+
+# IMPORTANT: check the apt-cacher.conf file before using apt-cacher as daemon.
+
+# set to 1 to start the daemon at boot time
+AUTOSTART=1
+
+# extra settings to override the ones in apt-cacher.conf
+# EXTRAOPT=" daemon_port=3142 limit=30 "