relevance-tarantula 0.0.1

data/lib/relevance/tarantula/form_submission.rb

@@ -0,0 +1,70 @@
+class Relevance::Tarantula::FormSubmission
+  attr_accessor :method, :action, :data
+  def initialize(form)
+    @method = form.method
+    @action = form.action
+    @data = mutate_selects(form).merge(mutate_text_areas(form)).merge(mutate_inputs(form))
+  end
+  
+  def self.mutate(form)
+    [self.new(form)]
+  end
+  
+  def to_s
+    "#{action} #{method} #{data.inspect}"
+  end
+  
+  # a form's signature is what makes it unique (e.g. action + fields)
+  # used to keep track of which forms we have submitted already
+  def signature
+    [action, data.keys.sort]
+  end
+  
+  def create_random_data_for(form, tag_selector)
+    form.search(tag_selector).inject({}) do |form_args, input|
+      # TODO: test
+      form_args[input['name']] = random_data(input) if input['name']
+      form_args
+    end
+  end
+
+  def mutate_inputs(form)
+    create_random_data_for(form, 'input')
+  end
+
+  def mutate_text_areas(form)
+    create_random_data_for(form, 'textarea')
+  end
+  
+  def mutate_selects(form)
+    form.search('select').inject({}) do |form_args, select|
+      options = select.search('option')
+      option = options.rand
+      form_args[select['name']] = option['value'] 
+      form_args
+    end
+  end
+  
+  def random_data(input)
+    case input['name']
+      when /amount/         : random_int
+      when /_id$/           : random_whole_number
+      when /uploaded_data/  : nil
+      when /^_method$/      : input['value']
+      when nil              : input['value']
+      else                    random_int
+    end
+  end
+  
+  def big_number
+    10000   # arbitrary
+  end
+  
+  def random_int
+    rand(big_number) - (big_number/2)
+  end
+  
+  def random_whole_number
+    rand(big_number)
+  end
+end

data/lib/relevance/tarantula/html_document_handler.rb

@@ -0,0 +1,36 @@
+require 'hpricot'
+
+class Relevance::Tarantula::HtmlDocumentHandler 
+  extend Forwardable
+  def_delegators("@crawler", :queue_link, :queue_form)
+  
+  def initialize(crawler)
+    @crawler = crawler
+  end              
+  # HTML::Document shouts to stderr when it sees ugly HTML
+  # We don't want this -- the InvalidHtmlHandler will deal with it
+  def html_doc_without_stderr_noise(html)  
+    body = nil
+    Recording.stderr do
+      body = Hpricot html
+    end       
+    body
+  end
+  def handle(result)
+    response = result.response
+    url = result.url
+    return unless response.html?
+    body = html_doc_without_stderr_noise(response.body)
+    body.search('a').each do |tag|
+      queue_link(tag, url)
+    end
+    body.search('link').each do |tag|
+      queue_link(tag, url)
+    end
+    body.search('form').each do |form|
+      form['action'] = url unless form['action']
+      queue_form(form, url)
+    end
+    nil
+  end
+end

data/lib/relevance/tarantula/html_report_helper.rb

@@ -0,0 +1,56 @@
+require "erb"
+module Relevance::Tarantula::HtmlReportHelper 
+  include ERB::Util
+  include Relevance::Tarantula
+  def wrap_in_line_number_table(text, &blk)
+    x = Builder::XmlMarkup.new
+    x.table(:class => "grid tablesorter") do      
+      x.thead do
+        x.tr do
+          x.th(:class => "sort asc") do
+            x.span("Line \#")
+            x.span(:class => "sort") do
+              x.em do
+                x << '&#8613;'
+              end
+            end
+          end
+          x.th(:class => "sort left") do
+            x.span("Line")
+            x.span(:class => "sort") do
+              x.em do
+                x << '&#8613;'
+              end
+            end               
+          end
+        end
+      end
+      text.split("\n").each_with_index do |line, index|
+        x.tr do
+          x.td(index+1)
+          if block_given?
+            x.td {x << yield(line)}
+          else
+            x.td(line)
+          end
+        end
+      end   
+    end
+    x.target!
+  end 
+                                                                            
+  def textmate_url(file, line_no)
+    "txmt://open?url=file://#{File.expand_path(File.join(rails_root,file))}&line_no=#{line_no}"
+  end
+  
+  def wrap_stack_trace_line(text)
+    if text =~ %r{^\s*(/[^:]+):(\d+):([^:]+)$}
+      file = h($1) # .to_s_xss_protected
+      line_number = $2
+      message = h($3) # .to_s_xss_protected
+      "<a href='#{textmate_url(file, line_number)}'>#{file}:#{line_number}</a>:#{message}" # .mark_as_xss_protected
+    else
+      h(text) # .to_s_xss_protected
+    end
+  end
+end

data/lib/relevance/tarantula/html_reporter.rb

@@ -0,0 +1,105 @@
+class Relevance::Tarantula::HtmlReporter
+  
+  include Relevance::Tarantula
+  attr_accessor :basedir, :results
+  delegate :successes, :failures, :to => :results
+  
+  HtmlResultOverview = Struct.new(:code, :url, :description, :method, :referrer, :file_name)
+  
+  def initialize(basedir)
+    @basedir = basedir    
+    @results = Struct.new(:successes, :failures).new([], [])
+    FileUtils.mkdir_p(@basedir)
+  end
+  
+  def report(result)
+    return if result.nil?
+    
+    create_detail_report(result)
+    
+    collection = result.success ? results.successes : results.failures
+    collection << HtmlResultOverview.new(
+      result.code, result.url, result.description, result.method, result.referrer, result.file_name
+    )
+  end
+
+  def finish_report(test_name)
+    puts "Writing results to #{basedir}"
+    copy_styles  unless styles_exist?
+    create_index unless index_exists?
+    update_index(test_name)
+  end
+  
+  def create_detail_report(result)
+    template = ERB.new(template("detail.html.erb"))
+    output(result.file_name, template.result(result.send(:binding)), result.test_name)
+  end 
+   
+  def copy_styles
+    # not using cp_r because it picks up .svn crap
+    FileUtils.mkdir_p(File.join(basedir, "stylesheets"))
+    Dir.glob("#{tarantula_home}/laf/stylesheets/*.css").each do |file|
+      FileUtils.cp(file, File.join(basedir, "stylesheets")) 
+    end
+    FileUtils.mkdir_p(File.join(basedir, "images"))
+    Dir.glob("#{tarantula_home}/laf/images/*.{jpg,gif,png}").each do |file|
+      FileUtils.cp(file, File.join(basedir, "images")) 
+    end
+    FileUtils.mkdir_p(File.join(basedir, "javascripts"))
+    Dir.glob("#{tarantula_home}/laf/javascripts/*.js").each do |file|
+      FileUtils.cp(file, File.join(basedir, "javascripts")) 
+    end
+  end
+  
+  def create_index
+    template = ERB.new(template("index.html.erb"))
+    output("index.html", template.result(binding))
+  end
+  
+  def update_index(test_name)    
+    File.open(File.join(basedir, "index.html"), "r+") do |file|
+      doc = Hpricot file.read
+      tabs_container = doc.search "#tabs-container ul"
+      results_container = doc.search "#tabs-container"
+      tabs_container.append tab_html(test_name)
+      results_container.append results_html(test_name)
+      file.rewind
+      file.write doc.to_s
+    end
+  end
+  
+  def index_exists?
+    File.exists?(File.join(basedir, "index.html"))
+  end
+  
+  def styles_exist?
+    File.exists?(File.join(basedir, "stylesheets", "tarantula.css"))
+  end
+
+  def tab_html(test_name)
+    "<li><a href='##{test_name}'><span>#{test_name}</span></a></li>"
+  end
+
+  def results_html(test_name)
+    template = ERB.new(template("test_report.html.erb"))
+    template.result(binding)
+  end
+  
+  def template(name)
+    File.read(File.join(File.dirname(__FILE__), name))
+  end
+  
+  def output(name, body, subdir = '')
+    FileUtils.mkdir_p(File.join(basedir, subdir)) unless subdir.empty?
+    File.open(File.join(basedir, subdir, name), "w") do |file|
+      file.write body
+    end
+  end      
+  
+  # CSS class for HTML status codes
+  def class_for_code(code)
+    "r#{Integer(code)/100}" 
+  end
+  
+  
+end

data/lib/relevance/tarantula/index.html.erb

@@ -0,0 +1,48 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+
+<html>
+  <head>
+    <meta http-equiv="Content-type" content="text/html; charset=utf-8"/>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+    <meta name="Author" content="Erik Yowell; erik[at]thinkrelevance.com"/>
+    <title>Tarantula report</title>
+    <script type="text/javascript" src="javascripts/jquery-1.2.3.js"></script>
+    <script type="text/javascript" src="javascripts/jquery.tablesorter.js"></script>
+    <script type="text/javascript" src="javascripts/jquery-ui-tabs.js"></script>
+    <script type="text/javascript" src="javascripts/tarantula.js"></script>
+    <link type="text/css" media="screen" rel="stylesheet" href="stylesheets/tarantula.css"/>
+    <link type="text/css" media="screen" rel="stylesheet" href="stylesheets/ui.tabs.css"/>
+  </head>
+
+  <body id="top">
+
+    <div id="container">
+
+      <div id="header">
+        <hr class="top"/>
+        <h1><span>Tarantula : Eight Legs, Two Fangs, and an Attitude</span></h1>
+        <ul class="navigation">
+          <li><a href="#" class="result-all"><span>All</span> <em><%= successes.size + failures.size %></em></a></li>
+          <li><a href="#" class="result-failure"><span>Failures</span> <em><%= failures.size %></em></a></li>
+          <li><a href="#" class="result-success"><span>Successful</span> <em><%= successes.size %></em></a></li>
+        </ul>
+      </div>
+    </div>
+    <div id="page-container">
+      <hr class="top"/>
+      <div id="page">
+        <p>Generated on <%= Time.now %></p>
+        <div id="tabs-container">
+          <ul>
+          </ul>
+        </div>
+      </div>
+      <div id="sidebar">
+        <h3><span>Tarantula</span></h3>
+        <p>Tarantula is an open-source tool for testing Rails web applications. Tarantula is developed by <a href="http://thinkrelevance.com">Relevance, Inc.</a> and lives at <a href="http://opensource.thinkrelevance.com">http://opensource.thinkrelevance.com</a>.</p>
+      </div>
+    </div>
+  </body>
+
+</html>

data/lib/relevance/tarantula/invalid_html_handler.rb

@@ -0,0 +1,18 @@
+class Relevance::Tarantula::InvalidHtmlHandler
+  include Relevance::Tarantula
+  def handle(result)
+    response = result.response
+    return unless response.html?
+    begin
+      body = HTML::Document.new(response.body, true)
+    rescue Exception => e
+      error_result = result.dup
+      error_result.success = false
+      error_result.description = "Bad HTML (Scanner)"
+      error_result.data = e.message
+      error_result
+    else
+      nil
+    end
+  end
+end

data/lib/relevance/tarantula/io_reporter.rb

@@ -0,0 +1,34 @@
+class Relevance::Tarantula::IOReporter
+  
+  include Relevance::Tarantula
+  attr_accessor :io, :results
+  delegate :successes, :failures, :to => :results
+  
+  IOResultOverview = Struct.new(:code, :url)
+  
+  def initialize(io)
+    @io = io
+    @results = Struct.new(:successes, :failures).new([], [])
+  end
+  
+  def report(result)
+    return if result.nil?
+    
+    unless result.success # collection = result.success ? results.successes : results.failures
+      results.failures << IOResultOverview.new(
+        result.code, result.url
+      )
+    end
+  end
+  
+  def finish_report(test_name)
+    unless (failures).empty?
+      io.puts "****** FAILURES"
+      failures.each do |failure|
+        io.puts "#{failure.code}: #{failure.url}"
+      end
+      raise "#{failures.size} failures"
+    end
+  end
+  
+end

data/lib/relevance/tarantula/link.rb

@@ -0,0 +1,56 @@
+class Relevance::Tarantula::Link
+  
+  class << self
+    include ActionView::Helpers::UrlHelper
+    # method_javascript_function needs this method
+    def protect_against_forgery?
+      false
+    end
+  end
+  
+  METHOD_REGEXPS = {}
+  [:put, :delete, :post].each do |m|
+    # remove submit from the end so we'll match with or without forgery protection
+    s = method_javascript_function(m).gsub( /f.submit();/, "" )
+    # don't just match this.href in case a different url was passed originally
+    s = Regexp.escape(s).gsub( /this.href/, ".*" )
+    METHOD_REGEXPS[m] = /#{s}/
+  end
+  
+  attr_accessor :href
+  
+  def initialize(link)
+    if String === link || link.nil?
+      @href = link
+      @method = :get
+    else # should be a tag
+      @href = link['href'].downcase
+      @tag = link
+    end
+  end
+  
+  def method
+    @method ||= begin
+      (@tag &&
+       [:put, :delete, :post].detect do |m| # post should be last since it's least specific
+         @tag['onclick'] =~ METHOD_REGEXPS[m]
+       end) ||
+      :get
+    end
+  end
+  
+  def ==(obj)
+    obj.respond_to?(:href) && obj.respond_to?(:method) &&
+      self.href.to_s == obj.href.to_s && self.method.to_s == obj.method.to_s
+  end
+  alias :eql? :==
+  
+  def hash
+    to_s.hash
+  end
+  
+  def to_s
+    "<Relevance::Tarantula::Link href=#{href}, method=#{method}>"
+  end
+  
+end

data/lib/relevance/tarantula/log_grabber.rb

@@ -0,0 +1,16 @@
+class Relevance::Tarantula::LogGrabber
+  attr_accessor :path
+  def initialize(path)
+    @path = path
+  end
+  
+  def clear!
+    File.open(@path, "w")
+  end
+  
+  def grab!
+    File.read(@path)
+  ensure
+    clear!
+  end
+end

data/lib/relevance/tarantula/rails_integration_proxy.rb

@@ -0,0 +1,70 @@
+require 'test/unit'
+
+class Relevance::Tarantula::RailsIntegrationProxy
+  include Relevance::Tarantula
+  extend Relevance::Tarantula
+  extend Forwardable
+  attr_accessor :integration_test
+
+  def self.rails_integration_test(integration_test, options = {})
+    t = Crawler.new
+    t.max_url_length = options[:max_url_length] if options[:max_url_length] 
+    t.proxy = RailsIntegrationProxy.new(integration_test)    
+    t.handlers << HtmlDocumentHandler.new(t)
+    t.handlers << InvalidHtmlHandler.new
+    t.log_grabber = Relevance::Tarantula::LogGrabber.new(File.join(rails_root, "log/test.log"))
+    t.skip_uri_patterns << /logout$/
+    t.transform_url_patterns += [
+      [/\?\d+$/, ''],                               # strip trailing numbers for assets
+      [/^http:\/\/#{integration_test.host}/, '']    # strip full path down to relative
+    ]
+    t.test_name = t.proxy.integration_test.method_name
+    t.reporters << Relevance::Tarantula::HtmlReporter.new(t.report_dir)
+    t
+  end
+
+  def initialize(integration_test)
+    @integration_test = integration_test
+    @integration_test.meta.attr_accessor :response
+  end
+  
+  [:get, :post, :put, :delete].each do |verb|
+    define_method(verb) do |url, *args|
+      integration_test.send(verb, url, *args)
+      response = integration_test.response
+      patch_response(url, response)
+      response
+    end
+  end
+
+  def patch_response(url, response)
+    if response.code == '404'
+      if File.exist?(static_content_path(url))
+        case ext = File.extension(url)
+        when /jpe?g|gif|psd|png|eps|pdf/
+          log "Skipping #{url} (for now)"
+        when /html|te?xt|css|js/
+          response.body = static_content_file(url)
+          response.headers["type"] = "text/#{ext}"  # readable as response.content_type
+          response.meta.attr_accessor :code
+          response.code = "200"
+        else
+          log "Skipping unknown type #{url}"
+        end
+      end
+    end
+    # don't count on metaclass taking block, e.g.
+    # http://relevancellc.com/2008/2/12/how-should-metaclass-work
+    response.metaclass.class_eval do
+      include Relevance::CoreExtensions::Response
+    end
+  end
+  
+  def static_content_file(url)
+    File.read(static_content_path(url))
+  end
+  
+  def static_content_path(url)
+    File.expand_path(File.join(rails_root, "public", url))
+  end
+end

data/lib/relevance/tarantula/recording.rb

@@ -0,0 +1,12 @@
+module Recording
+  def self.stderr
+    $stderr = recorder = StringIO.new
+    begin
+      yield
+    ensure
+      $stderr = STDERR
+    end
+    recorder.rewind
+    recorder.read
+  end
+end

data/lib/relevance/tarantula/response.rb

@@ -0,0 +1,13 @@
+# Used to create a stub response when we didn't get back a real response
+class Relevance::Tarantula::Response
+  HASHABLE_ATTRS = [:code, :body, :content_type]
+  attr_accessor *HASHABLE_ATTRS
+
+  def initialize(hash)
+    hash.each do |k,v|
+      raise ArgumentError, k unless HASHABLE_ATTRS.member?(k)
+      self.instance_variable_set("@#{k}", v)
+    end
+  end
+  
+end

data/lib/relevance/tarantula/result.rb

@@ -0,0 +1,66 @@
+class Relevance::Tarantula::Result
+  HASHABLE_ATTRS = [:success, :method, :url, :response, :referrer, :data, :description, :log, :test_name]
+  DEFAULT_LOCALHOST = "http://localhost:3000"
+  attr_accessor *HASHABLE_ATTRS
+  include Relevance::Tarantula
+  include Relevance::Tarantula::HtmlReportHelper
+
+  def initialize(hash)
+    hash.each do |k,v|
+      raise ArgumentError, k unless HASHABLE_ATTRS.member?(k)
+      self.instance_variable_set("@#{k}", v)
+    end
+  end
+  def short_description
+    [method,url].join(" ")
+  end
+  def sequence_number
+    @sequence_number ||= (self.class.next_number += 1)
+  end
+  def file_name
+    "#{sequence_number}.html"
+  end
+  def code
+    response && response.code
+  end
+  def body
+    response && response.body
+  end
+  def full_url
+    "#{DEFAULT_LOCALHOST}#{url}"
+  end
+  ALLOW_NNN_FOR = /^allow_(\d\d\d)_for$/
+  class << self
+    attr_accessor :next_number
+    def handle(result)
+      retval = result.dup
+      retval.success = successful?(result.response) || can_skip_error?(result)
+      retval.description = "Bad HTTP Response" unless retval.success
+      retval
+    end
+    def success_codes 
+      %w{200 201 302 401}
+    end
+    
+    # allow_errors_for is a hash 
+    #  k=error code,
+    #  v=array of matchers for urls that can skip said error
+    attr_accessor :allow_errors_for
+    def can_skip_error?(result)
+      coll = allow_errors_for[result.code]
+      return false unless coll
+      coll.any? {|item| item === result.url}
+    end
+    def successful?(response)
+      success_codes.member?(response.code)
+    end
+    def method_missing(meth, *args)  
+      super unless ALLOW_NNN_FOR =~ meth.to_s
+      (allow_errors_for[$1] ||= []).push(*args)
+    end
+  end
+  self.allow_errors_for = {}
+  self.next_number = 0
+  
+  
+end

data/lib/relevance/tarantula/test_report.html.erb

@@ -0,0 +1,34 @@
+<div id="<%= test_name %>">
+  <% %w{failures successes}.each do |result_type| %>
+    <table class="grid tablesorter" cellspacing="0">
+      <caption><%= result_type.capitalize %> (<%= send(result_type).size %>)</caption>
+      <thead>
+        <tr>
+          <th class="sort asc"><span>URL</span><span class="sort"><em>&#8613;</em></span></th>
+          <th><span>Action</span><span class="sort"><em>&#8613;</em></span></th>
+          <th><span>Response</span><span class="sort"><em>&#8613;</em></span></th>
+          <th><span>Description</span><span class="sort"><em>&#8613;</em></span></th>
+          <th><span>Referrer</span><span class="sort"><em>&#8613;</em></span></th>
+        </tr>
+      </thead>
+      <tfoot>
+        <tr>
+          <td colspan="5">
+            Footer
+          </td>
+        </tr>
+      </tfoot>
+      <tbody>
+        <% send(result_type).sort{|x,y| y.code.to_s <=> x.code.to_s}.each do |result| %>
+          <tr>
+            <td class="left"><a href="<%= "#{test_name}/#{result.file_name}" %>"><%= result.url.ellipsize(30) %></a></td>
+            <td class="center"><%= result.method %></td>
+            <td class="center"><span class="<%= class_for_code(result.code) %>"><%= result.code %></span></td>
+            <td><%= result.description %></td>
+            <td><%= result.referrer.ellipsize(30) %></td>
+          </tr>
+        <% end %>
+      </tbody>
+    </table>
+  <% end %>
+</div>

data/lib/relevance/tarantula/tidy_handler.rb

@@ -0,0 +1,32 @@
+require 'rubygems'
+begin
+  gem 'tidy'
+  require 'tidy'
+rescue Gem::LoadError
+  # tidy not available
+end
+
+if defined? Tidy
+  Tidy.path = ENV['TIDY_PATH'] if ENV['TIDY_PATH']
+
+  class Relevance::Tarantula::TidyHandler 
+    include Relevance::Tarantula
+    def initialize(options = {})
+      @options = {:show_warnings=>true}.merge(options)
+    end
+    def handle(result)
+      response = result.response
+      return unless response.html?
+      tidy = Tidy.open(@options) do |tidy|
+        xml = tidy.clean(response.body)
+        tidy
+      end
+      unless tidy.errors.blank?
+        error_result = result.dup
+        error_result.description = "Bad HTML (Tidy)"
+        error_result.data = tidy.errors.inspect
+        error_result
+      end
+    end
+  end
+end