jtzemp-tourbus 0.0.9

data/lib/tour.rb

@@ -0,0 +1,145 @@
+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
+  [
+  :fill_in, 
+  :fills_in, 
+  :set_hidden_field, 
+  :submit_form, 
+  :check, 
+  :checks, 
+  :uncheck, 
+  :unchecks, 
+  :choose, 
+  :chooses, 
+  :select, 
+  :selects, 
+  :select_datetime, 
+  :selects_datetime, 
+  :select_date, 
+  :selects_date, 
+  :select_time, 
+  :selects_time, 
+  :attach_file, 
+  :attaches_file, 
+  :click_area, 
+  :clicks_area, 
+  :click_link, 
+  :clicks_link, 
+  :click_button, 
+  :clicks_button, 
+  :field_labeled, 
+  :field_by_xpath, 
+  :field_with_id, 
+  :select_option, 
+  :automate, 
+  :basic_auth, 
+  :check_for_infinite_redirects, 
+  :click_link_within, 
+  :dom, 
+  :header, 
+  :http_accept, 
+  :infinite_redirect_limit_exceeded?, 
+  :internal_redirect?, 
+  :redirected_to, 
+  :reload, 
+  :response_body, 
+  :simulate, 
+  :visit, 
+  :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::MechanizeSession.new
+  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="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

data/lib/web-sickle/init.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+gem 'mechanize', ">= 0.7.6"
+gem "hpricot", ">= 0.6"
+$: << File.join(File.dirname(__FILE__), 'lib')
+
+require 'hpricot'
+require 'mechanize'
+
+WWW::Mechanize.html_parser = Hpricot
+
+require 'web_sickle'
+require "assertions"
+require "hash_proxy"
+require "helpers/asp_net"
+require "helpers/table_reader"
+
+Hpricot.buffer_size = 524288

data/lib/web-sickle/lib/assertions.rb

@@ -0,0 +1,51 @@
+class WebSickleAssertionException < Exception; end
+
+module WebSickle::Assertions
+  def assert_equals(expected, actual, message = nil)
+    unless(expected == actual)
+      report_error <<-EOF
+Error: Expected 
+#{expected.inspect}, but got
+#{actual.inspect}
+#{message}
+EOF
+    end
+  end
+
+  def assert_select(selector, message)
+    assert_select_in(@page, selector, message)
+  end
+
+  def assert_no_select(selector, message)
+    assert_no_select_in(@page, selector, message)
+  end
+
+  def assert_select_in(content, selector, message)
+    report_error("Error: Expected selector #{selector.inspect} to find a page element, but didn't. #{message}") if (content / selector).blank?
+  end
+
+  def assert_no_select_in(content, selector, message)
+    report_error("Error: Expected selector #{selector.inspect} to not find a page element, but did. #{message}") unless (content / selector).blank?
+  end
+
+  def assert_contains(left, right, message = nil)
+    (right.is_a?(Array) ? right : [right]).each do | item |
+      report_error("Error: Expected #{left.inspect} to contain #{right.inspect}, but didn't. #{message}") unless left.include?(item)
+    end
+  end
+
+  def assert(passes, message = nil)
+    report_error("Error: expected true, got false.  #{message}") unless passes
+  end
+
+  def assert_link_text(link, text)
+    case text
+    when String
+      assert_equals(link.text, text)
+    when Regexp
+      assert(link.text.match(text))
+    else
+      raise ArgumentError, "Don't know how to assert an object like #{text.inspect} - expected: Regexp or String"
+    end
+  end
+end

data/lib/web-sickle/lib/hash_proxy.rb

@@ -0,0 +1,9 @@
+class HashProxy
+  def initialize(options = {})
+    @set = options[:set]
+    @get = options[:get]
+  end
+
+  def [](key); @get && @get.call(key); end
+  def []=(key, value); @set && @set.call(key, value); end
+end

data/lib/web-sickle/lib/helpers/asp_net.rb

@@ -0,0 +1,16 @@
+module WebSickle::Helpers
+module AspNet
+  def asp_net_do_postback(options)
+    target_element = case
+      when options[:button]
+        find_button(options[:button])
+      when options[:field]
+        find_field(options[:field])
+      else
+        nil
+      end
+    @form.fields << WWW::Mechanize::Form::Field.new("__EVENTTARGET", target_element ? target_element.name : "") if target_element
+    submit_form_button
+  end
+end
+end

data/lib/web-sickle/lib/helpers/table_reader.rb

@@ -0,0 +1,39 @@
+module WebSickle::Helpers
+class TableReader
+  attr_reader :headers, :options, :body_rows, :header_row, :extra_rows
+  
+  def initialize(element, p_options = {})
+    @options = {
+      :row_selectors => [" > tr", "thead > tr", "tbody > tr"],
+      :header_selector => " > th",
+      :header_proc => lambda { |th| th.inner_text.gsub(/[\n\s]+/, ' ').strip },
+      :body_selector => " > td",
+      :body_proc => lambda { |header, td| td.inner_text.strip },
+      :header_offset => 0,
+      :body_offset => 1
+    }.merge(p_options)
+    @options[:body_range] ||= options[:body_offset]..-1
+    raw_rows = options[:row_selectors].map{|row_selector| element / row_selector}.compact.flatten
+    
+    @header_row = raw_rows[options[:header_offset]]
+    @body_rows = raw_rows[options[:body_range]]
+    @extra_rows = (options[:body_range].last+1)==0 ? [] : raw_rows[(options[:body_range].last+1)..-1]
+    
+    @headers = (@header_row / options[:header_selector]).map(&options[:header_proc])
+  end
+  
+  def rows
+    @rows ||= @body_rows.map do |row|
+      hash = {}
+      data_array = (headers).zip(row / options[:body_selector]).each do |column_name, td|
+        hash[column_name] = options[:body_proc].call(column_name, td)
+      end
+      hash
+    end
+  end
+  
+  def array_to_hash(data, column_names)
+    column_names.inject({}) {|h,column_name| h[column_name] = data[column_names.index(column_name)]; h }
+  end
+end
+end

data/lib/web-sickle/lib/make_nokigiri_output_useful.rb

@@ -0,0 +1,15 @@
+# Nokogiri::XML::Element.class_eval do
+#   def inspect(indent = "")
+#     breaker = "\n#{indent}"
+#     if children.length == 0
+#       %(#{indent}<#{name}#{breaker}  #{attributes.map {|k,v| k + '=' + v.inspect} * "#{breaker}  "}/>)
+#     else
+#       %(#{indent}<#{name} #{attributes.map {|k,v| k + '=' + v.inspect} * " "}>\n#{children.map {|c| c.inspect(indent + '  ') rescue c.class} * "\n"}#{breaker}</#{name}>)
+#     end
+#   end
+# end
+# Nokogiri::XML::Text.class_eval do
+#   def inspect(indent = "")
+#     "#{indent}#{text.inspect}"
+#   end
+# end