codez-tarantula 0.5.0

data/lib/relevance/tarantula/invalid_html_handler.rb

@@ -0,0 +1,27 @@
+module Relevance
+  module Tarantula
+
+    class InvalidHtmlHandler
+      include Relevance::Tarantula
+      def handle(result)
+        response = result.response
+        unless response.html?
+          log "Skipping #{self.class} on url: #{result.url} because response is not html."
+          return
+        end
+        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
+
+  end
+end

data/lib/relevance/tarantula/io_reporter.rb

@@ -0,0 +1,40 @@
+module Relevance
+  module Tarantula
+
+    class 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
+
+  end
+end

data/lib/relevance/tarantula/link.rb

@@ -0,0 +1,105 @@
+module Relevance
+  module Tarantula
+
+    class Link
+      include Relevance::Tarantula
+
+      class << self
+        include ActionView::Helpers::UrlHelper
+        # method_javascript_function needs this method
+        def protect_against_forgery?
+          false
+        end
+        #fast fix for rails3
+        def method_javascript_function(method, url = '', href = nil)
+          action = (href && url.size > 0) ? "'#{url}'" : 'this.href'
+          submit_function =
+            "var f = document.createElement('form'); f.style.display = 'none'; " +
+            "this.parentNode.appendChild(f); f.method = 'POST'; f.action = #{action};"
+
+          unless method == 'post'
+            submit_function << "var m = document.createElement('input'); m.setAttribute('type', 'hidden'); "
+            submit_function << "m.setAttribute('name', '_method'); m.setAttribute('value', '#{method}'); f.appendChild(m);"
+          end
+
+          if protect_against_forgery?
+            submit_function << "var s = document.createElement('input'); s.setAttribute('type', 'hidden'); "
+            submit_function << "s.setAttribute('name', '#{request_forgery_protection_token}'); s.setAttribute('value', '#{escape_javascript form_authenticity_token}'); f.appendChild(s);"
+          end
+          submit_function << "f.submit();"
+        end
+      end
+
+      METHOD_REGEXPS = {}
+      %w(put delete post patch).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, :crawler, :referrer
+
+      def initialize(link, crawler, referrer)
+        @crawler, @referrer = crawler, referrer
+
+        if String === link || link.nil?
+          @href = transform_url(link)
+          @method = 'get'
+        else # should be a tag
+          @href = link['href'] ? transform_url(link['href']) : nil
+          @tag = link
+        end
+      end
+
+      def crawl
+        response = crawler.follow(meth, href)
+        log "Response #{response.code} for #{self}"
+        crawler.handle_link_results(self, make_result(response))
+      end
+
+      def make_result(response)
+        crawler.make_result(:method    => meth,
+                            :url       => href,
+                            :response  => response,
+                            :referrer  => referrer)
+      end
+
+      def meth
+        @meth ||= begin
+                      (@tag &&
+                       %w(put delete post patch).detect do |m| # post should be last since it's least specific
+                        @tag['onclick'] =~ METHOD_REGEXPS[m] ||
+                        @tag['data-method'] == m
+                       end) ||
+                         'get'
+                    end
+      end
+      
+      def url
+        href
+      end
+
+      def transform_url(link)
+        crawler.transform_url(link)
+      end
+
+      def ==(obj)
+        obj.respond_to?(:href) && obj.respond_to?(:method) &&
+          self.href.to_s == obj.href.to_s && self.meth.to_s == obj.meth.to_s
+      end
+      alias :eql? :==
+
+        def hash
+          to_s.hash
+        end
+
+      def to_s
+        "<Relevance::Tarantula::Link href=#{href}, method=#{meth}>"
+      end
+
+    end
+
+  end
+end

data/lib/relevance/tarantula/log_grabber.rb

@@ -0,0 +1,22 @@
+module Relevance
+  module Tarantula
+
+    class 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
+
+  end
+end

data/lib/relevance/tarantula/rails_integration_proxy.rb

@@ -0,0 +1,90 @@
+require 'test/unit'
+
+module Relevance
+  module Tarantula
+
+    class 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|
+          response = nil
+          begin
+            integration_test.send(verb, url, *args)
+            response = integration_test.response
+          rescue ActiveRecord::RecordNotFound, 
+                 ActionController::RoutingError => e
+            response = integration_test.response
+            alter_response(response, '404', e.message + "\n\n" + e.backtrace.join("\n"))
+          rescue Exception => e
+            response = integration_test.response
+            alter_response(response, '500', e.message + "\n\n" + e.backtrace.join("\n"))
+          end
+          patch_response(url, response)
+          response
+        end
+      end
+
+      def alter_response(response, code, body)
+        response.meta.attr_accessor :code
+        response.code = code
+        response.body = body
+        response
+      end
+
+      def patch_response(url, response)
+        if response.code == '404'
+          if File.exist?(static_content_path(url))
+            case ext = File.extension(url)
+            when /html|te?xt|css|js|jpe?g|gif|psd|png|eps|pdf|ico/
+              response.headers["type"] = "text/#{ext}"  # readable as response.content_type
+              alter_response(response, '200', static_content_file(url))
+            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
+
+  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,19 @@
+# Used to create a stub response when we didn't get back a real response
+module Relevance
+  module Tarantula
+
+    class 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
+
+  end
+end

data/lib/relevance/tarantula/result.rb

@@ -0,0 +1,83 @@
+module Relevance
+  module Tarantula
+
+    class 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
+
+  end
+end

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

@@ -0,0 +1,32 @@
+<div id="<%= test_name %>">
+  <% %w{failures successes}.each do |result_type| %>
+    <table class="list tablesorter" cellspacing="0">
+      <caption><%= send(result_type).size %> <%= result_type.capitalize %></caption>
+      <thead>
+        <tr>
+          <th class="sort asc"><span>URL</span><span class="sort">&nbsp;</span></th>
+          <th><span>Action</span><span class="sort">&nbsp;</span></th>
+          <th><span>Response</span><span class="sort">&nbsp;</span></th>
+          <th class="left"><span>Description</span><span class="sort">&nbsp;</span></th>
+          <th><span>Referrer</span><span class="sort">&nbsp;</span></th>
+        </tr>
+      </thead>
+      <tfoot>
+         <tr><td colspan="5">&nbsp;</td></tr>
+      </tfoot>
+      
+      <tbody>
+        <% send(result_type).sort{|x,y| y.code.to_s <=> x.code.to_s}.each_with_index do |result,i| %>
+          <tr class="<%= (i%2 == 0) ? 'even' : 'odd' %>">
+            <td class="left"><a href="<%= "#{test_name}/#{result.file_name}" %>"><%= result.url.ellipsize(50) %></a></td>
+            <td class="method"><%= result.method.to_s.upcase %></td> <!-- TODO Clean up demeter violation -->
+            <td><span class="<%= class_for_code(result.code) %>"><%= result.code %></span></td>
+            <td class="left"><%= result.description %></td>
+            <td class="left"><%= result.referrer.ellipsize(30) %></td>
+          </tr>
+        <% end %>
+      </tbody>
+    </table>       
+    <br/>
+  <% end %>
+</div>

data/lib/relevance/tarantula/tidy_handler.rb

@@ -0,0 +1,35 @@
+begin
+  require 'tidy'
+rescue LoadError
+  puts "Tidy gem not available -- 'gem install tidy' to get it."
+end
+
+if defined? Tidy
+  Tidy.path = ENV['TIDY_PATH'] if ENV['TIDY_PATH']
+
+  module Relevance
+    module Tarantula
+
+      class 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
+  end
+end