tarantula 0.3.3 → 0.4.0

data/lib/relevance/tarantula/invalid_html_handler.rb

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

data/lib/relevance/tarantula/io_reporter.rb

@@ -1,34 +1,40 @@
-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}"
+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
-      raise "#{failures.size} failures"
+
     end
+
   end
-  
-end
+end

data/lib/relevance/tarantula/link.rb

@@ -1,76 +1,100 @@
-class Relevance::Tarantula::Link
-  include Relevance::Tarantula
-  
-  class << self
-    include ActionView::Helpers::UrlHelper
-    # method_javascript_function needs this method
-    def protect_against_forgery?
-      false
+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 = {}
+      [: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, :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'].downcase) : nil
+          @tag = link
+        end
+      end
+
+      def crawl
+        response = crawler.follow(method, href)
+        log "Response #{response.code} for #{self}"
+        crawler.handle_link_results(self, make_result(response))
+      end
+
+      def make_result(response)
+        crawler.make_result(:method    => method,
+                            :url       => href,
+                            :response  => response,
+                            :referrer  => referrer)
+      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 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.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
+
   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, :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'].downcase) : nil
-      @tag = link
-    end
-  end
-  
-  def crawl
-    response = crawler.follow(method, href)
-    log "Response #{response.code} for #{self}"
-    crawler.handle_link_results(self, make_result(response))
-  end
-  
-  def make_result(response)
-    crawler.make_result(:method    => method,
-                        :url       => href,
-                        :response  => response,
-                        :referrer  => referrer)
-  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 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.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

@@ -1,16 +1,22 @@
-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!
+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

@@ -1,68 +1,74 @@
 require 'test/unit'
 
-class Relevance::Tarantula::RailsIntegrationProxy
-  include Relevance::Tarantula
-  extend Relevance::Tarantula
-  extend Forwardable
-  attr_accessor :integration_test
+module Relevance
+  module Tarantula
 
-  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
+    class RailsIntegrationProxy
+      include Relevance::Tarantula
+      extend Relevance::Tarantula
+      extend Forwardable
+      attr_accessor :integration_test
 
-  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 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 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.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}"
+      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 /html|te?xt|css|js|jpe?g|gif|psd|png|eps|pdf|ico/
+              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
-    # 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