tourbus 0.1.2

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2008-2009 David Brady github@shinybit.com
+ 
+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/README.rdoc

@@ -0,0 +1,206 @@
+= TourBus
+
+Flexible and scalable website testing tool.
+
+== Authors
+
+* David Brady -- github@shinybit.com
+* Tim Harper -- tim.harper@leadmediapartners.com
+* James Britt -- james@neurogami.com
+* JT Zemp -- jtzemp@gmail.com
+
+
+== General Info
+
+TourBus is an intelligent website load testing tool. Allows for
+complicated testing scenarios including filling out forms, following
+redirects, handling cookies, and following links--all of the things
+you'd normally associate with a regression suite or integration
+testing tool. The difference is that TourBus also scales concurrently,
+and you can perform hundreds of complicated regression tests
+simultaneously in order to thoroughly load test your website.
+
+It uses Webrat::Mechanize to run the browsing session, so you get the
+load testing you want, and all the sweetness of Webrat to write your
+tests in.
+
+== Motivation
+
+I started writing TourBus because I needed flexibility and scalability
+in a website testing tool, and the extant tools all provided one but
+not the other. Selenium is ultraflexible but limited to the number of
+browsers you can have open at once, while Apache Bench is powerful and
+fast but limited to simple tests.
+
+TourBus lets you define complicated paths through your website, then
+execute those paths concurrently for stress testing.
+
+== Example
+
+To see TourBus in action, you need to write scripts. For lack of a
+better name, these are called Tours. 
+
+=== Example Tour 
+
+* Make a folder called tours and put a file in it called simple.rb. In
+  it write:
+
+      class Simple < Tour
+        def test_homepage
+          visit "http://#{@host}/"
+          assert_contain "My Home Page"
+        end
+      end
+
+* Files in ./tours should have classes that match their names. E.g.
+  "class BigHairyTest < Tour" belongs in ./tours/big_hairy_test.rb
+
+* Think Test::Unit. test_* methods will be found automagically.
+  setup() and teardown() methods will be executed at the appropriate
+  times.
+
+=== Example TourBus Run
+
+You want to invoke +tourbus+ from the parent directory of the @tours/@ folder.
+
+For example, if you have this project  tree ...
+
+    `-- contact_app
+        |-- README.rdoc
+        |-- contact_app.rb
+        `-- tours
+            |-- simple.rb
+            `-- tourbus.yml
+
+... then you execute  +tourbus+ from the +contact_app/+ directory.
+
+    tourbus -c 2 -n 3 simple
+
+That will run the +simple.rb+ tour file.
+
+It will create 2 concurrent Tour runners, each of which will run all
+of the methods in Simple three times.
+
+* You can specify multiple tours.
+
+    tourbus -c 2 -n 3 simple1 simple2 simple3
+
+* If you don't specify a tour, all tours in ./tours will be run.
+
+* tourbus --help will give you more information.
+
+* You can run tours and filter given tests.
+
+    tourbus -c 2 -n 3 simple -t test_login,test_logout
+
+Note that if you specify multiple tours and filter tests, the filtered
+tests will be run on all tours specified. If you do not specify a
+tour, the filtered tests will be run on all tours found in the
++./tours+ folder.
+
+=== Example TourWatch Run
+
+On the webserver, you can type 
+
+    tourwatch -c 4
+
+To begin running tourwatch. It's basically a stripped-down version of
+top with cheesy text graphs. (TourWatch's development cycles were
+included in the 2 days for TourBus.)
+
+* The -c option is for the total number of cores on the server. The
+  top app will cheerfully report a process as taking 392% CPU if it is
+  using 98% of four cores. This option is only necessary for making
+  the little text graphs scale correctly.
+
+* You can choose which processes to watch by passing a csv to -p:
+  
+    tourwatch -p ruby,mongrel
+
+  Each process name is a partial regexp, so the above would match
+  mongrel AND mongrel_rails, etc.
+
+* tourwatch --help will give you more information.
+
+== History and Status
+
+TourBus began life as a 2-day throwaway app. It is definitely an app
+whose development provides many opportunities for open-source
+contributors to make improvements. It is chock-full of brutal hacks,
+duplications, oversights, and kludges.
+
+== Hacks, Kludges, Known Issues, and Piles of Steaming Poo
+
+* If you give a tour a name that is pluralized, it won't work. This is
+  probably a bug worth fixing. The reason for it is that we take file
+  names and "classify" them, and e.g. "ranking_reports" becomes
+  "RankingReport", not "RankingReports". This is an artifact of
+  borrowing from Rails' activesupport libs and should probably be
+  fixed.
+
+* Mechanize 0.8 doesn't always play well together with TourBus. If you
+  get "connection refused" socket errors, try upgrading to Mechanize
+  0.9.
+
+* JRuby doesn't play well with Nokogiri. I have set the html_parser to
+  use hpricot, which should work around the issue for now.
+
+* There are no specs. Yikes! This is to my eternal shame because I'm
+  sort of a testing freak. Because TourBus *WAS* a testing tool, I
+  didn't put tests on it. I haven't put tests on it yet because I'm
+  not sure how to go about it. Instead of exercising a web app with a
+  test browser, we need to exercise a test browser with... um... a web
+  app? (dbrady notes: Now that we have a contact_app, we could try
+  writing some specs and features to run tourbus against it.)
+
+* Web-Sickle is another internal app, written by Tim Harper, that
+  works "well enough". Until I open-sourced this project, it was a
+  submodule in the app. We wanted to keep TourBus extensions separate
+  from WebSickle itself, so there's a lot of code in Runner that
+  really belongs in WebSickle.
+
+* Documentation is <strike>horrible</strike> merely quite bad.
+
+* There's not much in the way of examples, either. When I removed all
+  the LMP-specific code, all of the examples went with it. Sorry about
+  that. Coming soon.
+
+== Feature Requests (How You Can Help!)
+
+* I'd like to beef up the example contact app to show more of TourBus
+  than the simplest possible path. Adding in another page or two, and
+  then adding an additional tour or two would make it more apparent to
+  new users that you can do things like run multiple tours at once.
+  Also, having more than one test_ method in simple.rb would let us
+  demonstrate test filtering as well. (Be aware that at present
+  [2009-04-17], webrat still does not play well with Sinatra sessions
+  so there would be complications. dbrady's fork of webrat combines
+  jferris' fix with the latest webrat, and will be maintained until
+  main webrat includes the feature. That fork is at
+  http://github.com/dbrady/webrat)
+
+* I'd like to remove WebSickle and replace it with Webrat. There is a
+  webrat branch on the main fork (http://github.com/dbrady/tourbus)
+  that is 90% complete. Once that's done we can start massaging the
+  API to be a little more friendly. [done (but now that it is, it 
+  needs a refactoring--Tour should probably inherit from 
+  Webrat::Mechanize, not delegate to it.)]
+
+== Credits
+
+* Tim Harper camped at my place for a day fixing bugs in WebSickle as
+  I exercised more and more new bits of it. Thanks, dude.
+
+* Lead Media Partners paid me to write TourBus, then let me open
+  source it. How much do they rock? All the way to 11, that's how much
+  they rock.
+
+* James Britt jumped on this and revived it as it was gathering dust.
+  Thanks!
+
+* JT Zemp added before_tour, after_tour. Thanks!
+
+== License
+
+MIT. See the license file.
+

data/bin/tourbus

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'common'))
+require 'trollop'
+require_all_files_in_folder 'tours'
+
+# load config file, we'll use these as defaults
+config_file = ["./tourbus.yml", "./tours/tourbus.yml", "./config/tourbus.yml", "~/tourbus.yml"].map {|p| File.expand_path(p)}.find {|p| File.exists? p}
+config = config_file ? YAML::load_file(config_file).symbolize_keys : {}
+
+config_map = { :host => :to_s, :concurrency => :to_i, :number => :to_i, :rand => :to_i, :tests => :to_s }
+config_map.each {|key,conv| config[key] = config[key].send(conv) if config.key? key }
+
+# defaults
+config[:host] ||= "http://localhost:3000"
+config[:concurrency] ||= 1
+config[:number] ||= 1
+config[:rand] ||= nil
+
+opts = Trollop.options do
+  opt :host, "Remote hostname to test", :default => config[:host]
+  opt :concurrency, "Number of simultaneous runs to perform", :type => :integer, :default => config[:concurrency]
+  opt :number, "Number of times to run the tour (in each concurrent step, so -c 10 -n 10 will run the tour 100 times)", :type => :integer, :default => config[:number]
+  opt :list, "List tours and runs available. If tours or runs are included, filters the list", :type => :boolean, :default => nil
+  opt :rand, "Random seed", :type => :integer, :default => config[:rand]
+  opt :tests, "Test name(s) filter. The name of the test to run (use --list to see the test names). Use commas, no spaces, for mulitple names",  :type => :string, :default => nil
+end
+
+tours = if ARGV.empty?
+          Tour.tours
+         else
+           ARGV
+         end
+
+srand opts[:rand] || Time.now.to_i
+
+if opts[:list]
+  Tour.tours(ARGV).each do |tour|
+    puts tour
+    puts Tour.tests(tour).map {|test| "  #{test}"}
+  end
+else
+  opts[:tests] = opts[:tests].split(',') if opts[:tests]
+  
+  TourBus.new(opts[:host], opts[:concurrency], opts[:number], tours, opts[:tests]).run
+end
+

data/bin/tourwatch

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+
+# tourwatch - cheap monitor program for tourbus
+# 
+# Notes:
+# 
+# tourwatch is a cheap logger program for tourbus. It runs on the
+# targeted server and monitors cpu and memory usage of webserver
+# processes. It's a moderately quick hack: I have a 2-hour budget to
+# write and debug the whole thing and here I am wasting time by
+# starting with documentation. This is because I figure the chance of
+# this program needing maintenance in the next 6 months to be well
+# over 100%, and the poor guy behind me (Hey, that's you! Hi.) will
+# need to know why tourwatch is so barebones.
+# 
+# So. TourWatch runs on the target server, collects top information
+# every second, and logs it to file. End of story. "Automation" is
+# handled by the meat cloud (Hey, that's you! Hi.) when the maintainer
+# starts and stops the process manually. Report collection is handled
+# by you reading the logfiles in a terminal. Report aggregation is
+# handled by you aggregating the reports. Yes, there's a theme here.
+# 
+# TODO:
+# 
+# - Remote reporting? Send log events to main log server?
+# 
+# - If we logged to a lightweight database like sqlite3, we could do
+#   some clever things like track individual pids and process groups.
+#   This would let us track, e.g., aggregate apache stress as well as
+#   rogue mongrels. I'm not doing this now because it will require
+#   writing something to read and parse the previous information. For
+#   now, we'll leave it up to the user (Hey, that's you! Hi.) to parse
+#   the logfiles.
+# 
+# - Tweak output format. Currently it's crap. I don't think we need
+#   dynamic templating or anything, but it might be nice to improve
+#   the existing formats.
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'common'))
+require 'trollop'
+require 'tour_watch'
+
+opts = Trollop.options do
+  opt :outfile, "Logfile name (default to STDOUT)", :type => :string, :default => nil
+  opt :processes, "csv of processes to monitor", :type => :string, :default => nil
+  opt :cores, "number of cores present (max CPU% is number of cores * 100)", :type => :integer, :default => 4
+  opt :mac, "Set if running on MacOSX. The Mac top command is different than linux top.", :type => :boolean, :default => false
+end
+
+TourWatch.new(opts).run
+
+

data/examples/contact_app/README.rdoc

@@ -0,0 +1,128 @@
+= Contact App
+
+Silly little contact app to show you how to tour a website.
+
+= Requirements
+
+In addition to tourbus, you will need Sinatra to run
+this app.
+
+  sudo gem install sinatra
+
+= Contact App
+
+== Start the app
+
+Once that's working, start the app with "ruby contact_app.rb". Sinatra
+should start up, and you can now point your browser at
+http://localhost:4567 to see the app's homepage.
+
+Pretty humble, I know; just the one link labeled Enter Contacts. Click
+it to get to the Contact form. Here you can enter a first and last
+name then click submit.
+
+The app then shows you that name in last_name, first_name format.
+That's the whole app. Don't everybody applaud all at once.
+
+== First Tour
+
+Still here? Okay, let's tour this website.
+
+In the tours folder, you will find two files: simple.rb and
+tourbus.yml. The YAML file just sets the default host to
+localhost:4567. (Without it, tourbus will default to http://localhost:3000.
+You could override this by running tourbus with "-h localhost:4567"
+every time, but that gets tedious.
+
+Before we go any farther, let's run tourbus. Leave Sinatra running and
+open another terminal window. Go into the contact_app folder and just
+type "tourbus". You should get a screenful of information ending with
+a happy little banner something like this:
+
+  2009-01-10 12:09:36 TourBus: --------------------------------------------------------------------------------
+  2009-01-10 12:09:36 TourBus: 1 runs: 1x1 of simple
+  2009-01-10 12:09:36 TourBus: All Runners finished.
+  2009-01-10 12:09:36 TourBus: Total Runs: 1
+  2009-01-10 12:09:36 TourBus: Total Passes: 1
+  2009-01-10 12:09:36 TourBus: Total Fails: 0
+  2009-01-10 12:09:36 TourBus: Total Errors: 0
+  2009-01-10 12:09:36 TourBus: Elapsed Time: 0.0131220817565918
+  2009-01-10 12:09:36 TourBus: Speed: 76.207 v/s
+  2009-01-10 12:09:36 TourBus: --------------------------------------------------------------------------------
+
+== Tourbus Defaults
+
+Tourbus tries to be sensible; if you don't provide a number of runs or
+concurrency, it sets them to 1. If you don't choose a tour to run, it
+runs them all. It looks for tourbus.yml in the current folder,
+./tours, in ./config (a Rails convention), and in your home folder.
+(It looks for them in that order, and stops as soon as it finds one.
+It does not merge multiple yaml files together.)
+
+== Simple Tour
+
+Okay, now let's look at tours/simple.rb.
+
+It defines a class named Simple that inherits from Tour. Tourbus won't
+try to run a tour unless the file contains a Tour child class of the
+same name as the file.
+
+Inside the class, methods whose names begin with test_ will
+automatically be run as part of the tour. They are not run in any
+particular order.
+
+=== test_home
+
+Right. Let's look test_home first, because it's simpler:
+
+    def test_home
+      visit "/"
+      assert_contain "If you click this"
+
+      click_link "Enter Contact"
+      assert_match /\/contacts/, current_page.url
+    end
+
++visit+ is a webrat method that you can call inside of your tours. It opens the given path on the
+host that tourbus is testing.
+
++assert_contain+ is also a webrat method that confirms the given string is on the page.
+
++click_link+ does what you'd expect. It takes a hash that identifies
+the link to click. +click_link+ will raise an exception
+if it cannot find the link to click.
+
++assert_match+ comes from Test::Unit which is used internally to webrat. It will raise an exception unless the uri
+matches the given regexp.
+
+So you should be able to use any Webrat locator or matcher, and any of the Test::Unit assertions.
+
+=== test_contacts
+
+Okay, let's actually submit a form.
+
+    def test_contacts
+      visit "/contacts"
+  
+      fill_in "first_name", :with => "Joe"
+      fill_in "last_name", :with => "Tester"
+      click_button 
+  
+      assert_contain "Tester, Joe"
+    end
+
+test_contacts starts by going directly to the contacts app. Note that
+the leading "/" isn't optional.
+
++fill_in+ is a Webrat method that will look for form fields based on ids, label text, and other things. 
+It's matchers are pretty good. Check out Webrat's documentation for more info. In the examples above, 
+we're finding the fields for the first name and last name and putting in "Joe" and "Tester" respectively.
++fill_in+ asserts that the fields actually exist and will raise an exception if they don't.
+
++click_button+ does what its name implies. It finds the correct form to
+submit Webrat is smart like that. *Note:* Like +click_link+, +click_button+
+contains some implicit assertions and will raise an exception if the button doesn't exist.
+
++assert_contain+ we've already seen.
+
+Good luck, and happy touring!

data/examples/contact_app/contact_app.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby -w
+
+# Contact app. Example Sinatra application that you can use to test tourbus.
+# 
+# Pretty simple applet. You go to / and enter your contact
+# information. When you click submit, it shows you your name in all
+# caps. Okay, "pretty simple" was an understatement. I get that. Shut up.
+require 'rubygems'
+require 'sinatra'
+
+get '/' do
+  %{If you click this, I'll take you to a page where you can enter your contact info: <a href="/contacts">Enter Contact</a>}
+end 
+
+get '/contacts' do
+  <<-eos
+<html>
+  <head>
+    <title>Contact App</title>
+  </head>
+  <body>
+    <h1>Contact Info:</h1>
+    <form action="/contacts" method="POST">
+      <p><label for="first_name"><b>First Name:</b></label> <input name="first_name" size="30"></p>
+      <p><label for="last_name"><b>Last Name:</b></label> <input name="last_name" size="30"></p>
+      <input type="submit" value="Submit">
+    </form>
+  </body>
+</html>
+eos
+end
+
+post '/contacts' do
+  "<h1>#{params[:last_name]}, #{params[:first_name]}</h1>"
+end 
+

data/examples/contact_app/tours/simple.rb

@@ -0,0 +1,19 @@
+class Simple < Tour
+  def test_home
+    visit "/"
+    assert_contain "If you click this"
+
+    click_link "Enter Contact"
+    assert_match /\/contacts/, current_page.url
+  end
+
+  def test_contacts
+    visit "/contacts"
+    
+    fill_in "first_name", :with => "Joe"
+    fill_in "last_name", :with => "Tester"
+    click_button 
+    
+    assert_contain "Tester, Joe"
+  end
+end

data/examples/contact_app/tours/tourbus.yml

@@ -0,0 +1,2 @@
+---
+host:   http://localhost:4567

data/lib/common.rb

@@ -0,0 +1,30 @@
+# common.rb - Common settings, requires and helpers
+unless defined? TOURBUS_LIB_PATH
+  TOURBUS_LIB_PATH = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+  $:<< TOURBUS_LIB_PATH unless $:.include? TOURBUS_LIB_PATH
+end
+
+require 'rubygems'
+
+gem 'mechanize', ">= 0.8.5"
+gem 'trollop', ">= 1.10.0"
+gem 'faker', '>= 0.3.1'
+
+# TODO: I'd like to remove dependency on Rails. Need to see what all
+# we're using (like classify) and remove each dependency individually.
+require 'activesupport'
+
+require 'monitor'
+require 'faker'
+require 'tour_bus'
+require 'runner'
+require 'tour'
+
+class TourBusException < Exception; end
+
+def require_all_files_in_folder(folder, extension = "*.rb")
+  for file in Dir[File.join('.', folder, "**/#{extension}")]
+    require file
+  end
+end
+

data/lib/runner.rb

@@ -0,0 +1,80 @@
+require 'monitor'
+require 'common'
+
+# The common base class for all exceptions raised by Webrat.
+class WebratError < StandardError ; end
+
+class Runner
+  attr_reader :host, :tours, :number, :runner_type, :runner_id
+  
+  def initialize(host, tours, number, runner_id, test_list)
+    @host, @tours, @number, @runner_id, @test_list = host, tours, number, runner_id, test_list
+    @runner_type = self.send(:class).to_s
+    log("Ready to run #{@runner_type}")
+  end
+  
+  # Dispatches to subclass run method
+  def run_tours 
+    log "Filtering on tests #{@test_list.join(', ')}" unless @test_list.to_a.empty?
+    tours,tests,passes,fails,errors = 0,0,0,0,0
+    1.upto(number) do |num|
+      log("Starting #{@runner_type} run #{num}/#{number}")
+      @tours.each do |tour_name|
+        
+        log("Starting run #{number} of Tour #{tour_name}")
+        tours += 1
+        tour = Tour.make_tour(tour_name,@host,@tours,@number,@runner_id)
+        tour.before_tour
+        
+        tour.tests.each do |test|
+          times = Hash.new {|h,k| h[k] = {}}
+          
+          next if test_limited_to(test) #  test_list && !test_list.empty? && !test_list.include?(test.to_s) 
+
+          begin
+            tests += 1
+            times[test][:started] = Time.now
+            tour.run_test test
+            passes += 1
+          rescue TourBusException, WebratError => e
+            log("********** FAILURE IN RUN! **********")
+            log e.message
+            e.backtrace.each do |trace|
+              log trace
+            end
+            fails += 1
+          rescue Exception => e
+            log("*************************************")
+            log("*********** ERROR IN RUN! ***********")
+            log("*************************************")
+            log e.message
+            e.backtrace.each do |trace|
+              log trace
+            end
+            errors += 1
+          ensure
+            times[test][:finished] = Time.now
+            times[test][:elapsed] = times[test][:finished] - times[test][:started]
+          end 
+          log("Finished run #{number} of Tour #{tour_name}")
+        end
+        
+        tour.after_tour
+      end
+      log("Finished #{@runner_type} run #{num}/#{number}")
+    end
+    log("Finished all #{@runner_type} tours.")
+    [tours,tests,passes,fails,errors]
+  end
+  
+  protected
+  
+  def log(message)
+    puts "#{Time.now.strftime('%F %H:%M:%S')} Runner ##{@runner_id}: #{message}"
+  end
+
+  def test_limited_to(test_name)
+    @test_list && !@test_list.empty? && !@test_list.include?(test_name.to_s) 
+  end
+end
+

data/lib/tour.rb

@@ -0,0 +1,151 @@
+require 'forwardable'
+require 'monitor'
+require 'common'
+require 'webrat'
+require 'webrat/mechanize'
+require 'test/unit/assertions'
+
+# A tour is essentially a test suite file. A Tour subclass
+# encapsulates a set of tests that can be done, and may contain helper
+# and support methods for a given task. If you have a two or three
+# paths through a specific area of your website, define a tour for
+# that area and create test_ methods for each type of test to be done.
+
+class Tour
+  extend Forwardable
+  include Webrat::Matchers
+  include Webrat::SaveAndOpenPage
+  include Test::Unit::Assertions
+  
+  attr_reader :host, :tours, :number, :tour_type, :tour_id, :webrat_session
+  
+  # delegate goodness to webrat
+  [
+    :attach_file, 
+    :attaches_file, 
+    :automate, 
+    :basic_auth, 
+    :check, 
+    :check_for_infinite_redirects, 
+    :checks, 
+    :choose, 
+    :chooses, 
+    :click_area, 
+    :click_button, 
+    :click_link, 
+    :click_link_within, 
+    :clicks_area, 
+    :clicks_button, 
+    :clicks_link, 
+    :current_page,
+    :dom, 
+    :field_by_xpath, 
+    :field_labeled, 
+    :field_with_id, 
+    :fill_in, 
+    :fills_in, 
+    :get,
+    :header, 
+    :http_accept, 
+    :infinite_redirect_limit_exceeded?, 
+    :internal_redirect?, 
+    :redirected_to, 
+    :reload, 
+    :response_body,
+    :select, 
+    :select_date, 
+    :select_datetime, 
+    :select_option, 
+    :select_time, 
+    :selects, 
+    :selects_date, 
+    :selects_datetime, 
+    :selects_time, 
+    :set_hidden_field, 
+    :simulate, 
+    :submit_form, 
+    :uncheck, 
+    :unchecks, 
+    :within, 
+    :xml_content_type?
+  ].each {|m| def_delegators(:webrat_session, m) }
+
+  def initialize(host, tours, number, tour_id)
+    @host, @tours, @number, @tour_id = host, tours, number, tour_id
+    @tour_type = self.send(:class).to_s
+    @webrat_session = Webrat::MechanizeAdapter.new()
+  end
+ 
+  def visit(url, data=nil)
+    get url, data
+  end
+  
+  # before_tour runs once per tour, before any tests get run
+  def before_tour; end
+  
+  # after_tour runs once per tour, after all the tests have run
+  def after_tour; end
+  
+  def setup
+  end
+  
+  def teardown
+  end
+  
+  def wait(time)
+    sleep time.to_i
+  end
+  
+  # Lists tours in tours folder. If a string is given, filters the
+  # list by that string. If an array of filter strings is given,
+  # returns items that match ANY filter string in the array.
+  def self.tours(filter=[])
+    filter = [filter].flatten
+    # All files in tours folder, stripped to basename, that match any item in filter
+    # I do loves me a long chain. This returns an array containing
+    # 1. All *.rb files in tour folder (recursive)
+    # 2. Each filename stripped to its basename
+    # 3. If you passed in any filters, these basenames are rejected unless they match at least one filter
+    # 4. The filenames remaining are then checked to see if they define a class of the same name that inherits from Tour
+    Dir[File.join('.', 'tours', '**', '*.rb')].map {|fn| File.basename(fn, ".rb")}.select {|fn| filter.size.zero? || filter.any?{|f| fn =~ /#{f}/}}.select {|tour| Tour.tour? tour }
+  end 
+  
+  def self.tests(tour_name)
+    Tour.make_tour(tour_name).tests
+  end
+  
+  def self.tour?(tour_name)
+    Object.const_defined?(tour_name.classify) && tour_name.classify.constantize.ancestors.include?(Tour)
+  end
+  
+  # Factory method, creates the named child class instance
+  def self.make_tour(tour_name,host="http://localhost:3000",tours=[],number=1,tour_id=nil)
+    tour_name.classify.constantize.new(host,tours,number,tour_id)
+  end
+  
+  # Returns list of tests in this tour. (Meant to be run on a subclass
+  # instance; returns the list of tests available).
+  def tests
+    methods.grep(/^test_/).map {|m| m.sub(/^test_/,'')}
+  end
+  
+  def run_test(test_name)
+    @test = "test_#{test_name}"
+    raise TourBusException.new("run_test couldn't run test '#{test_name}' because this tour did not respond to :#{@test}") unless respond_to? @test
+    setup
+    send @test
+    teardown
+  end
+  
+  protected
+  
+  def session
+    @session ||= Webrat::MechanizeSession.new
+  end
+  
+  def log(message)
+    puts "#{Time.now.strftime('%F %H:%M:%S')} Tour ##{@tour_id}: (#{@test}) #{message}"
+  end
+  
+end
+

data/lib/tour_bus.rb

@@ -0,0 +1,92 @@
+require 'benchmark'
+
+class TourBus < Monitor
+  attr_reader :host, :concurrency, :number, :tours, :runs, :tests, :passes, :fails, :errors, :benchmarks
+  
+  def initialize(host="localhost", concurrency=1, number=1, tours=[], test_list=nil)
+    @host, @concurrency, @number, @tours, @test_list = host, concurrency, number, tours, test_list
+    @runner_id = 0
+    @runs, @tests, @passes, @fails, @errors = 0,0,0,0,0
+    super()
+  end
+  
+  def next_runner_id
+    synchronize do
+      @runner_id += 1
+    end 
+  end
+  
+  def update_stats(runs,tests,passes,fails,errors)
+    synchronize do
+      @runs += runs
+      @tests += tests
+      @passes += passes
+      @fails += fails
+      @errors += errors
+    end
+  end
+  
+  def update_benchmarks(bm)
+    synchronize do
+      @benchmarks = @benchmarks.zip(bm).map { |a,b| a+b}
+    end 
+  end
+  
+  def runners(filter=[])
+    # All files in tours folder, stripped to basename, that match any item in filter
+    Dir[File.join('.', 'tours', '**', '*.rb')].map {|fn| File.basename(fn, ".rb")}.select {|fn| filter.size.zero? || filter.any?{|f| fn =~ /#{f}/}}
+  end
+  
+  def total_runs
+    tours.size * concurrency * number    
+  end
+  
+  def run
+    threads = []
+    tour_name = "#{total_runs} runs: #{concurrency}x#{number} of #{tours * ','}"
+    started = Time.now.to_f
+    concurrency.times do |conc|
+      log "Starting #{tour_name}"
+      threads << Thread.new do
+        runner_id = next_runner_id
+        runs,tests,passes,fails,errors,start = 0,0,0,0,0,Time.now.to_f
+        bm = Benchmark.measure do
+          runner = Runner.new(@host, @tours, @number, runner_id, @test_list)
+          runs,tests,passes,fails,errors = runner.run_tours
+          update_stats runs, tests, passes, fails, errors
+        end
+        log "Runner Finished!"
+        log "Runner finished in %0.3f seconds" % (Time.now.to_f - start)
+        log "Runner Finished! runs,passes,fails,errors: #{runs},#{passes},#{fails},#{errors}"
+        log "Benchmark for runner #{runner_id}: #{bm}"
+      end
+    end
+    log "All Runners started!"
+    threads.each {|t| t.join }
+    finished = Time.now.to_f
+    log '-' * 80
+    log tour_name
+    log "All Runners finished."
+    log "Total Tours: #{@runs}"
+    log "Total Tests: #{@tests}"
+    log "Total Passes: #{@passes}"
+    log "Total Fails: #{@fails}"
+    log "Total Errors: #{@errors}"
+    log "Elapsed Time: #{finished - started}"
+    log "Speed: %5.3f tours/sec" % (@runs / (finished-started))
+    log '-' * 80
+    if @fails > 0 || @errors > 0
+      log '********************************************************************************'
+      log '********************************************************************************'
+      log '                            !! THERE WERE FAILURES !!'
+      log '********************************************************************************'
+      log '********************************************************************************'
+    end
+  end
+  
+  def log(message)
+    puts "#{Time.now.strftime('%F %H:%M:%S')} TourBus: #{message}"
+  end
+
+end
+

data/lib/tour_watch.rb

@@ -0,0 +1,88 @@
+class TourWatch
+  attr_reader :processes
+  
+  def initialize(options={})
+    @processes = if options[:processes]
+                   options[:processes].split(/,/) * '|'
+                 else 
+                   "ruby|mysql|apache|http|rails|mongrel"
+                 end
+    @cores = options[:cores] || 4
+    @logfile = options[:outfile]
+    @mac = options[:mac]
+  end
+  
+  def stats
+    top = @mac ? top_mac : top_linux
+    lines = []
+    @longest = Hash.new(0)
+    top.each_line do |line|
+      name,pid,cpu = fields(line.split(/\s+/))
+      lines << [name,pid,cpu]
+      @longest[:name] = name.size if name.size > @longest[:name]
+      @longest[:pid] = pid.to_s.size if pid.to_s.size > @longest[:pid]
+    end
+    lines
+  end
+  
+  def fields(parts)
+    @mac ? fields_mac(parts) : fields_linux(parts)
+  end
+  
+  # Note: MacOSX is so awesome I just cacked. Top will report 0.0% cpu
+  # the first time you run top, every time. The only way to get actual
+  # CPU% here is to wait for it to send another page and then throw
+  # away the first page. Isn't that just awesome?!? I KNOW!!!
+  def top_mac
+    top = `top -l 1 | grep -E '(#{@processes})'`
+  end
+  
+  def fields_mac(fields)
+    name,pid,cpu = fields[1], fields[0].to_i, fields[2].to_f
+  end
+  
+  def top_linux
+    top = `top -bn 1 | grep -E '(#{@processes})'`
+  end
+  
+  
+  def fields_linux(fields)
+    # linux top isn't much smarter. It spits out a blank field ahead
+    # of the pid if the pid is too short, which makes the indexes
+    # shift off by one.
+    a,b,c = if fields.size == 13
+              [-1,1,9]
+            else
+              [-1,0,8]
+            end
+    name,pid,cpu = fields[a], fields[b].to_i, fields[c].to_f
+  end
+  
+  
+  def run()
+    while(true)
+      now = Time.now.to_i
+      if @time != now
+        log '--'
+        lines = stats
+        lines.sort! {|a,b| a[1]==b[1] ? a[2]<=>b[2] : a[1]<=>b[1] }
+        lines.each do |vars|
+          vars << bargraph(vars[2], 100 * @cores)
+          log "%#{@longest[:name]}s %#{@longest[:pid]}d CPU: %6.2f%% [%-40s]" % vars 
+        end
+      end
+      sleep 0.1
+      @time = now
+    end
+  end
+  
+  def bargraph(value, max=100, length=40, on='#', off='.')
+    (on * (([[value, 0].max, max].min * length) / max).to_i).ljust(length, off)
+  end
+  
+  def log(message)
+    msg = "#{Time.now.strftime('%F %H:%M:%S')} TourWatch: #{message}"
+    puts msg
+    File.open(@logfile, "a") {|f| f.puts msg } if @logfile
+  end
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification 
+name: tourbus
+version: !ruby/object:Gem::Version 
+  version: 0.1.2
+platform: ruby
+authors: 
+- David Brady
+- James Britt
+- JT Zemp
+- Tim Harper
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-22 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mechanize
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.8.5
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: trollop
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: faker
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hpricot
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: webrat
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: TourBus, a web stress-testing tool that combines complex 'tour' definitions with scalable concurrent testing
+email: github@shinybit.com
+executables: 
+- tourbus
+- tourwatch
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- MIT-LICENSE
+- examples/contact_app/README.rdoc
+files: 
+- bin/tourbus
+- bin/tourwatch
+- examples/contact_app/README.rdoc
+- examples/contact_app/contact_app.rb
+- examples/contact_app/tours/simple.rb
+- examples/contact_app/tours/tourbus.yml
+- lib/common.rb
+- lib/runner.rb
+- lib/tour.rb
+- lib/tour_bus.rb
+- lib/tour_watch.rb
+- README.rdoc
+- MIT-LICENSE
+has_rdoc: true
+homepage: http://github.com/dbrady/tourbus/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --main
+- README.rdoc
+- --title
+- Tourbus - Web Stress Testing in Ruby
+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: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: TourBus web stress-testing tool
+test_files: []
+