jakewendt-html_test 0.2.3

data/lib/url_selector.rb

@@ -0,0 +1,57 @@
+module Html
+  module Test
+    module UrlSelector
+      def skip_url?(url, root_url = nil)
+        if url.blank? || unsupported_protocol?(url) || special_url?(url)
+          true
+        else
+          false
+        end
+      end
+
+      def special_url?(url)
+        [/^javascript:/, /^mailto:/, /^\#$/].any? { |pattern| url =~ pattern }
+      end
+
+      def external_http?(url, root_url = nil)
+        if root_url
+          http_protocol?(url) && !url.starts_with?(root_url)
+        else
+          http_protocol?(url)
+        end
+      end
+
+      def http_protocol?(url)
+        url =~ %r{^http(?:s)?://} ? true : false
+      end
+
+      def has_protocol?(url)
+        url =~ %r{^[a-z]+://} ? true : false
+      end
+
+      def unsupported_protocol?(url)
+        has_protocol?(url) && !http_protocol?(url)
+      end
+
+      def anchor_urls
+        select("a").map { |l| l.attributes['href'] }
+      end
+
+      def image_urls
+        select("img").map { |i| i.attributes['src'] }
+      end
+
+      def form_urls
+        select("form").map { |i| i.attributes['action'] }        
+      end
+      
+      def response_body
+        self.respond_to?(:response) ? response.body : @response.body
+      end
+
+      def select(pattern)
+        HTML::Selector.new(pattern).select(HTML::Document.new(response_body).root)
+      end      
+    end
+  end
+end

data/lib/validate_filter.rb

@@ -0,0 +1,55 @@
+module Html
+	module Test
+		class ValidateFilter
+			attr_accessor :request, :response, :params, :validators
+			
+			include ::Test::Unit::Assertions
+			include ::Html::Test::Assertions
+
+			def initialize(controller)
+				self.request = controller.request
+				self.response = controller.response
+				self.params = controller.params
+				self.validators = controller.class.validators
+			end
+
+			def validate_page
+				url = request.request_uri
+				return if (!should_validate? || ValidateFilter.already_validated?(url))
+#				assert_validates(validators, response.body.strip, url, :verbose => true)
+				assert_validates(validators, response.body.strip, url )
+				ValidateFilter.mark_url_validated(url)
+			end
+
+			def self.already_validated?(url)
+				if Html::Test::Validator.revalidate_all
+					false
+				else
+					validated_urls[url]
+				end
+			end
+
+			def self.mark_url_validated(url)
+				validated_urls[url] = true				
+			end
+
+			def self.validated_urls
+				@validated_urls ||= {}
+			end
+
+			# Override this method if you only want to validate a subset of pages
+			def should_validate?
+				response.status =~ /200/ &&
+					(response.headers['Content-Type'] =~ /text\/html/i || response.body =~ /<html/)
+			end			
+
+			#	Used in testing (of html_test_extension plugin)
+			#	to remove the validated_urls hash
+			#	so can test with the same url.
+			def self.clear_validated_urls
+				@validated_urls = {}
+			end
+
+		end
+	end
+end

data/lib/validator.rb

@@ -0,0 +1,121 @@
+require 'tempfile'
+require 'net/http'
+require 'fileutils'
+
+module Html
+	module Test
+		class Validator
+
+			# verbose = true shows "validating ..."
+			# verbose = false shows NOTHING
+			@@verbose = true
+			cattr_accessor :verbose
+			#
+			#	revalidate_all = true will validate every call to a url
+			#	revalidate_all = false will only validate the first call to a url
+			@@revalidate_all = true
+			cattr_accessor :revalidate_all
+
+			@@tidy_ignore_list = []
+			cattr_accessor :tidy_ignore_list
+
+			# For local validation you might change this to http://localhost/validator/htdocs/check
+			DEFAULT_W3C_URL = "http://validator.w3.org/check"
+			@@w3c_url = DEFAULT_W3C_URL
+			cattr_accessor :w3c_url
+			
+			# Whether the W3C validator should show the HTML document being validated in
+			# its response. Set to 0 to disable.
+			@@w3c_show_source = "1"
+			cattr_accessor :w3c_show_source
+
+			DEFAULT_DTD = File.join(File.dirname(__FILE__), 'DTD', 'xhtml1-strict.dtd')
+
+			# Path to DTD file that the xmllint validator uses
+			def self.dtd(document)
+				DEFAULT_DTD
+			end
+			
+			# Validate an HTML document string using tidy.
+			# Code excerpted from the rails_tidy plugin
+			def self.tidy_errors(body)
+				tidy = RailsTidy.tidy_factory
+				tidy.clean(body)
+				errors = tidy.errors.empty? ? nil :
+					tidy.errors.delete_if { |e| tidy_ignore_list.select { |p| e =~ p }.size > 0 }.join("\n")
+				tidy.release
+				errors.blank? ? nil : errors
+			end
+
+			# Validate an HTML document string by going to the online W3C validator.
+			# Credit for the original code goes to Scott Baron (htonl)
+			def self.w3c_errors(body)
+				response = Net::HTTP.post_form(URI.parse(w3c_url),
+															{'ss'=>w3c_show_source, 'fragment'=>body})
+				status = response['x-w3c-validator-status']
+				if status != 'Valid'
+					# Reference in the stylesheets
+					response.body.sub!(%r{@import "./base.css"}, %Q{@import "#{File.dirname(w3c_url)}/base.css"})
+					response_file = find_unique_path(File.join(tmp_dir, "w3c_response.html"))
+					open(response_file, "w") { |f| f.puts(response.body) }
+					"W3C status #{status}. Response from W3C was written to the file #{response_file}"
+				else
+					nil
+				end
+			end
+
+			# Validate an HTML document string using the xmllint command line validator tool.
+			# Returns nil if validation passes and an error message otherwise.
+			# Original code taken from the book "Enterprise Integration with Ruby"
+			def self.xmllint_errors(body)
+				error_file = create_tmp_file("xmllint_error")
+				doc_file = command = nil
+				if dtd(body) =~ /^doctype$/i
+					# Use the DOCTYPE declaration
+					doc_file = create_tmp_file("xmllint", body)
+					command = "xmllint --noout --valid #{doc_file} &> #{error_file}"
+				else
+					# Override the DOCTYPE declaration
+					doc_file = create_tmp_file("xmllint", body.sub(/<!DOCTYPE[^>]+>/m, ""))
+					command = "xmllint --noout --dtdvalid #{dtd(body)} #{doc_file} &> #{error_file}"
+				end
+				system(command)
+				status = $?.exitstatus
+				if status == 0
+					return nil
+				else
+					failure_doc = File.join(tmp_dir, "xmllint_last_response.html")
+					FileUtils.cp doc_file, failure_doc
+					return ("command='#{command}'. HTML document at '#{failure_doc}'. " +
+						IO.read(error_file))
+				end
+			end
+			
+			private
+			def self.find_unique_path(path)
+				filename = File.basename(path)
+				ext = File.extname(filename)
+				size_no_ext = filename.size - ext.size
+				filename_no_ext = filename[0, size_no_ext]
+				counter = 2
+				while File.exists?(path)
+					new_filename = [filename_no_ext, "-", counter, ext].join
+					path = File.join(File.dirname(path), new_filename)
+					counter += 1
+				end
+				path
+			end
+			
+			def self.create_tmp_file(name, contents = "")
+				tmp_file = Tempfile.new(name)
+				tmp_file.puts(contents)
+				tmp_file.close
+				tmp_file.path
+			end
+			
+			def self.tmp_dir
+				Dir::tmpdir
+			end
+		end
+	end
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require 'jakewendt-html_test' if RAILS_ENV == 'test'

data/script/validate

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+# == Synopsis
+# This script validates an HTML page via HTTP and checks for broken
+# links and images. Links are followed one step away from the start page.
+# HTML validation is also done for pages linked internally from the start page
+# (i.e. relative URLs).
+#
+# == Usage
+# vendor/plugins/html_test/script/validate http://my.url.com [options]
+#
+# Options:
+#
+# --no-follow::                 Don't follow any anchor or images URLs on
+#                               the start page (i.e. only one page is requested).
+#
+# --validators validator_list:: A comma separated list of validators to use
+#                               for HTML validation. Supported validators:
+#                               tidy, xmllint, w3c. Default validator is
+#                               tidy if it is installed, otherwise w3c.
+#
+# --dtd dtd_path::              Path to the DTD file to use for xmllint
+#                               validation. By default xmllint will use
+#                               the XHTML 1.0 strict DTD. Set dtd_path
+#                               to "doctype" to make xmllint use the
+#                               DTD specified in the DOCTYPE tag
+#                               (can be slow).
+#
+# --skip skip_patterns::        A comma separated list of regexp patterns for
+#                               URLs to not visit. Using the pattern '.*'
+#                               is equivalent to the --no-follow option.
+#
+# --only only_pattern::         Only visit URLs matching given regexp pattern
+#
+# --no-external::               Do not visit external URLs, i.e. URLs with
+#                               different domain than the start page.
+#
+# --quiet::                     Don't output anything unless there is a failure.
+
+require 'optparse'
+require 'rdoc/usage'
+require 'uri'
+
+require File.join(File.dirname(__FILE__), "..", "..", "..", "..", "test", "test_helper")
+require File.join(File.dirname(__FILE__), "..", "lib", "html_test")
+
+options = Html::Test::LinkValidator.parse_command_line(ARGV) rescue RDoc::usage
+Html::Test::LinkValidator.new(ARGV[0], options)

data/test/controller_test.rb

@@ -0,0 +1,120 @@
+require File.join(File.dirname(__FILE__), "..", "..", "..", "..", "test", "test_helper")
+require File.join(File.dirname(__FILE__), "test_helper")
+
+ActionController::Routing::Routes.draw do |map|
+  map.connect 'test/:action', :controller => 'test'
+end
+
+class Html::Test::ControllerTest < ActionController::TestCase
+  def setup
+    @controller = TestController.new
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+    
+    ActionController::Base.validate_all = false
+    ActionController::Base.check_urls = true
+    ActionController::Base.check_redirects = true
+    Html::Test::Validator.tidy_ignore_list = []
+    Html::Test::UrlChecker.any_instance.stubs(:rails_public_path).returns(File.join(File.dirname(__FILE__), "public"))
+  end
+  
+  def test_assert_validates_success
+    get :valid
+    assert_response :success
+    assert_validates # Should validate tidy, w3c, and xmllint
+  end
+  
+  def test_assert_tidy_failure
+    get :untidy
+    assert_response :success
+    assert_raise(Test::Unit::AssertionFailedError) do
+      assert_tidy
+    end
+    assert_w3c
+    assert_xmllint
+  end
+  
+  def test_assert_w3c_failure
+    get :invalid
+    assert_response :success
+    assert_raise(Test::Unit::AssertionFailedError) do
+      assert_w3c
+    end
+    assert_raise(Test::Unit::AssertionFailedError) do
+      assert_xmllint
+    end
+    assert_tidy
+  end
+  
+  def test_url_no_route
+    assert_raise(Html::Test::InvalidUrl) do
+      get :url_no_route
+    end
+  end
+
+  def test_url_no_action
+    assert_raise(Html::Test::InvalidUrl) do
+      get :url_no_action
+    end
+  end
+ 
+ # TODO: figure out why those tests don't work 
+#  def test_url_rhtml_template_exists
+#    get :rhtml_template
+#  end
+  
+#  def test_url_rxml_template_exists
+#    get :rxml_template    
+#  end
+
+  def test_url_action_no_template
+    get :action_no_template
+  end
+
+  def test_redirect_no_action
+    assert_raise(Html::Test::InvalidUrl) do
+      get :redirect_no_action
+    end    
+  end
+  
+  def test_redirect_valid_action
+    get :redirect_valid_action
+    assert_response :redirect
+  end
+
+  def test_redirect_external
+    get :redirect_external
+    assert_response :redirect
+  end
+
+  def test_redirect_valid_with_host
+    get :redirect_valid_with_host
+    assert_response :redirect    
+  end
+
+  def test_image_file_exists
+    get :image_file_exists
+    assert_response :success
+  end
+
+  def test_image_does_not_exist
+    assert_raise(Html::Test::InvalidUrl) do
+      get :image_file_does_not_exist
+    end
+  end
+
+  def test_urls_to_resolve
+    checker = Html::Test::UrlChecker.new(@controller)
+    checker.stubs(:response_body).returns(<<-HTML
+      <a href="anchor_url">hej</a>
+      Some text and <div>markup</div>
+      <img src="image_url"/>
+      Some more text
+      <form action="form_url">
+        Some text
+      </form>
+    HTML
+    )
+    assert_equal(%w(anchor_url form_url image_url), checker.send(:urls_to_check).sort)
+  end
+end

data/test/integration_test.rb

@@ -0,0 +1,73 @@
+require File.join(File.dirname(__FILE__), "..", "..", "..", "..", "test", "test_helper")
+require File.join(File.dirname(__FILE__), "test_helper")
+
+ActionController::Routing::Routes.draw do |map|
+  map.connect 'test/:action', :controller => 'test'
+end
+ApplicationController.validate_all = false
+ApplicationController.check_urls = true
+ApplicationController.check_redirects = true
+
+class Html::Test::IntegrationTest < ActionController::IntegrationTest
+  def test_assert_valides_invokes_all
+    get('/test/valid')
+    assert_response :success
+
+    [:tidy_errors, :w3c_errors, :xmllint_errors].each do |method|
+      Html::Test::Validator.expects(method).with(@response.body)
+    end
+    assert_validates
+  end
+
+  def test_assert_tidy_invoked
+    get('/test/valid')
+    assert_response :success
+    Html::Test::Validator.expects(:tidy_errors).with(@response.body)
+    assert_tidy
+  end
+  
+  def test_assert_valid_success
+    get('/test/valid')
+    assert_response :success
+    assert_validates
+  end
+
+  def test_assert_tidy_failure
+    file_string = TestController.test_file_string(:untidy)
+    assert_raise(Test::Unit::AssertionFailedError) do
+      assert_tidy(file_string)
+    end
+    assert_w3c(file_string)
+    assert_xmllint(file_string)
+  end
+  
+  def test_assert_w3c_failure
+    file_string = TestController.test_file_string(:invalid)
+    assert_raise(Test::Unit::AssertionFailedError) do
+      assert_w3c(file_string)
+    end
+    assert_raise(Test::Unit::AssertionFailedError) do
+      assert_xmllint(file_string)
+    end
+    assert_raise(Test::Unit::AssertionFailedError) do
+      Html::Test::Validator.expects(:dtd).returns("doctype")
+      assert_xmllint(file_string)
+    end    
+    assert_tidy(file_string)
+  end
+  
+  def test_url_no_route
+    TestController.any_instance.expects(:rescue_action).with() { |e| e.class == Html::Test::InvalidUrl }
+    get '/test/url_no_route'
+  end
+
+  def test_url_no_route_relative
+    TestController.any_instance.expects(:rescue_action).with() { |e| e.class == Html::Test::InvalidUrl }
+    get '/test/url_no_route_relative'
+  end
+  
+  def test_redirect_valid_action
+    get '/test/redirect_valid_action'
+    assert_response :redirect
+  end
+end

data/test/invalid.html

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!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" />
+    <title>A perfectly invalid document</title>
+  </head>
+  <body>
+    <h1>This is a perfectly invalid XHTML 1 document</h1>
+    
+    Here are some unquoted chars: <>
+    
+    Tidy may not complain about this document, but that's just crazy.
+  </body>
+</html>

data/test/link_validator_test.rb

@@ -0,0 +1,141 @@
+require File.join(File.dirname(__FILE__), "..", "..", "..", "..", "test", "test_helper")
+require File.join(File.dirname(__FILE__), "test_helper")
+require 'ostruct'
+
+# Stub out the HTTP requests
+module Net
+  class HTTP
+    @@test_requests = []
+    cattr_accessor :test_requests
+    
+    @@test_with_links = false
+    cattr_accessor :test_with_links    
+    
+    def self.get_response(uri)
+      self.test_requests << uri.to_s
+
+      if uri.path =~ /valid_links/ or test_with_links
+        file = :valid_links
+      else
+        file = :valid
+      end
+      test_with_links = false
+      return OpenStruct.new({
+        :body => TestController.test_file_string(file),
+        :code => "200",
+        :header => {'content-type' => 'text/html'}
+        })
+    end
+  end
+end
+
+class Html::Test::LinkValidatorTest < Test::Unit::TestCase
+  def setup
+    Net::HTTP.test_requests = []
+  end
+  
+  def test_parse_command_line
+    # Missing URL
+    assert_raise(RuntimeError) { Html::Test::LinkValidator.parse_command_line(["--no-follow"]) }
+
+    # Missing skip patterns
+    options_no_skip = ["http://my.url.com", "--no-follow", "--validators", "w3c,tidy,xmllint",
+      "--no-external", "--dtd", "some.dtd", "--only", "some/url", "--skip"]
+    assert_raise(OptionParser::MissingArgument) do
+      Html::Test::LinkValidator.parse_command_line(options_no_skip.dup)
+    end
+
+    # All options - valid
+    assert_equal({
+      :follow_links => false,
+      :validators => ["w3c", "tidy", "xmllint"],
+      :follow_external => false,
+      :dtd => "some.dtd",
+      :only_pattern => Regexp.new("some/url"),
+      :skip_patterns => [/pattern1/, /pattern2/]
+    }, Html::Test::LinkValidator.parse_command_line(options_no_skip << "pattern1,pattern2"))
+  end
+
+  def test_default_options
+    url = "http://localhost:3000"
+    validator = Html::Test::LinkValidator.new(url)
+    
+    assert_equal url, Net::HTTP.test_requests.first
+    assert_equal 1, Net::HTTP.test_requests.size
+
+    assert validator.options[:follow_links]
+    assert_equal ['tidy'], validator.options[:validators]
+    assert_equal [], validator.options[:skip_patterns]
+    assert_nil validator.options[:only_pattern]
+    assert validator.options[:follow_external]
+  end
+
+  def test_quiet
+    validator = Html::Test::LinkValidator.new("http://my.cool.site", {:quiet => true})
+    # Even in quiet mode the log should be populated
+    assert_match /my\.cool\.site/, validator.log
+  end
+  
+  def test_link_follow_page
+    validator = Html::Test::LinkValidator.new("http://site.com/dir/valid_links")
+    # All links visited
+    assert_equal(["http://site.com/dir/valid_links",
+      "http://site.com/link1",
+      "http://site.com/dir/link2",
+      "http://site.com/dir/foobar/link3",
+      "http://foobar.com/external"].sort,
+      Net::HTTP.test_requests.sort)
+  end
+
+  def test_link_follow_root
+    %w(http://site.com http://site.com/).each do |url|
+      Net::HTTP.test_requests = []
+      Net::HTTP.test_with_links = true
+      validator = Html::Test::LinkValidator.new(url)
+      # All links visited
+      assert_equal([url,
+        "http://site.com/link1",
+        "http://site.com/link2",
+        "http://site.com/foobar/link3",
+        "http://foobar.com/external"].sort,
+        Net::HTTP.test_requests.sort)
+    end
+  end
+
+  def test_link_follow_dir
+    Net::HTTP.test_with_links = true
+    validator = Html::Test::LinkValidator.new("http://site.com/dir/")
+    # All links visited
+    assert_equal(["http://site.com/dir/",
+      "http://site.com/link1",
+      "http://site.com/dir/link2",
+      "http://site.com/dir/foobar/link3",
+      "http://foobar.com/external"].sort,
+      Net::HTTP.test_requests.sort)
+  end
+
+  def test_skip_patterns
+    url = "http://my.cool.site/valid_links"
+    validator = Html::Test::LinkValidator.new(url,
+      {:skip_patterns => [/link[12]/, /http/]})
+    assert_equal [url, "http://my.cool.site/foobar/link3"].sort,
+      Net::HTTP.test_requests.sort
+  end
+  
+  def test_only_pattern
+    url = "http://my.cool.site/dir/valid_links"
+    validator = Html::Test::LinkValidator.new(url, {:only_pattern => /link[12]/})
+    assert_equal [url, "http://my.cool.site/link1", "http://my.cool.site/dir/link2"].sort,
+      Net::HTTP.test_requests.sort
+  end
+  
+  def test_follow_external_false
+    Net::HTTP.test_with_links = true
+    validator = Html::Test::LinkValidator.new("http://site.com/dir/", {:follow_external => false})
+    assert_equal(["http://site.com/dir/",
+      "http://site.com/link1",
+      "http://site.com/dir/link2",
+      "http://site.com/dir/foobar/link3"].sort,
+      Net::HTTP.test_requests.sort)
+  end
+end

data/test/rhtml_template.rhtml

@@ -0,0 +1 @@
+Some contents

data/test/rxml_template.rxml

@@ -0,0 +1,2 @@
+xml.foo do
+end