jakewendt-html_test 0.2.3

data/lib/DTD/xhtml1.dcl

@@ -0,0 +1,192 @@
+<!SGML "ISO 8879:1986 (WWW)"
+
+     -- SGML Declaration for XML 1.0 --
+
+     -- from: 
+        Final text of revised Web SGML Adaptations Annex (TC2) to ISO 8879:1986
+        ISO/IEC JTC1/SC34 N0029: 1998-12-06
+        Annex L.2 (informative): SGML Declaration for XML
+
+        changes made to accommodate validation are noted with 'VALID:'
+     --
+
+     CHARSET
+         BASESET
+             "ISO Registration Number 177//CHARSET
+              ISO/IEC 10646-1:1993 UCS-4 with implementation
+              level 3//ESC 2/5 2/15 4/6"
+         DESCSET
+                 0        9  UNUSED
+                 9        2       9
+                11        2  UNUSED
+                13        1      13
+                14       18  UNUSED
+                32       95      32
+               127        1  UNUSED
+               128       32  UNUSED
+               160    55136     160
+             55296     2048  UNUSED  -- surrogates --
+             57344     8190   57344
+             65534        2  UNUSED  -- FFFE and FFFF --
+             65536  1048576   65536
+
+     CAPACITY NONE  -- Capacities are not restricted in XML --
+
+     SCOPE DOCUMENT
+
+     SYNTAX
+         SHUNCHAR NONE
+         BASESET "ISO Registration Number 177//CHARSET
+                  ISO/IEC 10646-1:1993 UCS-4 with implementation
+                  level 3//ESC 2/5 2/15 4/6"
+         DESCSET
+             0 1114112 0
+         FUNCTION
+             RE    13
+             RS    10
+             SPACE 32
+             TAB   SEPCHAR 9
+         NAMING
+             LCNMSTRT ""
+             UCNMSTRT ""
+             NAMESTRT
+                 58 95 192-214 216-246 248-305 308-318 321-328
+                 330-382 384-451 461-496 500-501 506-535 592-680
+                 699-705 902 904-906 908 910-929 931-974 976-982
+                 986 988 990 992 994-1011 1025-1036 1038-1103
+                 1105-1116 1118-1153 1168-1220 1223-1224
+                 1227-1228 1232-1259 1262-1269 1272-1273
+                 1329-1366 1369 1377-1414 1488-1514 1520-1522
+                 1569-1594 1601-1610 1649-1719 1722-1726
+                 1728-1742 1744-1747 1749 1765-1766 2309-2361
+                 2365 2392-2401 2437-2444 2447-2448 2451-2472
+                 2474-2480 2482 2486-2489 2524-2525 2527-2529
+                 2544-2545 2565-2570 2575-2576 2579-2600
+                 2602-2608 2610-2611 2613-2614 2616-2617
+                 2649-2652 2654 2674-2676 2693-2699 2701
+                 2703-2705 2707-2728 2730-2736 2738-2739
+                 2741-2745 2749 2784 2821-2828 2831-2832
+                 2835-2856 2858-2864 2866-2867 2870-2873 2877
+                 2908-2909 2911-2913 2949-2954 2958-2960
+                 2962-2965 2969-2970 2972 2974-2975 2979-2980
+                 2984-2986 2990-2997 2999-3001 3077-3084
+                 3086-3088 3090-3112 3114-3123 3125-3129
+                 3168-3169 3205-3212 3214-3216 3218-3240
+                 3242-3251 3253-3257 3294 3296-3297 3333-3340
+                 3342-3344 3346-3368 3370-3385 3424-3425
+                 3585-3630 3632 3634-3635 3648-3653 3713-3714
+                 3716 3719-3720 3722 3725 3732-3735 3737-3743
+                 3745-3747 3749 3751 3754-3755 3757-3758 3760
+                 3762-3763 3773 3776-3780 3904-3911 3913-3945
+                 4256-4293 4304-4342 4352 4354-4355 4357-4359
+                 4361 4363-4364 4366-4370 4412 4414 4416 4428
+                 4430 4432 4436-4437 4441 4447-4449 4451 4453
+                 4455 4457 4461-4462 4466-4467 4469 4510 4520
+                 4523 4526-4527 4535-4536 4538 4540-4546 4587
+                 4592 4601 7680-7835 7840-7929 7936-7957
+                 7960-7965 7968-8005 8008-8013 8016-8023 8025
+                 8027 8029 8031-8061 8064-8116 8118-8124 8126
+                 8130-8132 8134-8140 8144-8147 8150-8155
+                 8160-8172 8178-8180 8182-8188 8486 8490-8491
+                 8494 8576-8578 12295 12321-12329 12353-12436
+                 12449-12538 12549-12588 19968-40869 44032-55203
+
+             LCNMCHAR ""
+             UCNMCHAR ""
+             NAMECHAR
+                 45-46 183 720-721 768-837 864-865 903 1155-1158
+                 1425-1441 1443-1465 1467-1469 1471 1473-1474
+                 1476 1600 1611-1618 1632-1641 1648 1750-1764
+                 1767-1768 1770-1773 1776-1785 2305-2307 2364
+                 2366-2381 2385-2388 2402-2403 2406-2415
+                 2433-2435 2492 2494-2500 2503-2504 2507-2509
+                 2519 2530-2531 2534-2543 2562 2620 2622-2626
+                 2631-2632 2635-2637 2662-2673 2689-2691 2748
+                 2750-2757 2759-2761 2763-2765 2790-2799
+                 2817-2819 2876 2878-2883 2887-2888 2891-2893
+                 2902-2903 2918-2927 2946-2947 3006-3010
+                 3014-3016 3018-3021 3031 3047-3055 3073-3075
+                 3134-3140 3142-3144 3146-3149 3157-3158
+                 3174-3183 3202-3203 3262-3268 3270-3272
+                 3274-3277 3285-3286 3302-3311 3330-3331
+                 3390-3395 3398-3400 3402-3405 3415 3430-3439
+                 3633 3636-3642 3654-3662 3664-3673 3761
+                 3764-3769 3771-3772 3782 3784-3789 3792-3801
+                 3864-3865 3872-3881 3893 3895 3897 3902-3903
+                 3953-3972 3974-3979 3984-3989 3991 3993-4013
+                 4017-4023 4025 8400-8412 8417 12293 12330-12335
+                 12337-12341 12441-12442 12445-12446 12540-12542
+
+             NAMECASE
+                 GENERAL NO
+                 ENTITY  NO
+         DELIM
+             GENERAL  SGMLREF
+             HCRO     "&#38;#x"
+                      -- Ampersand followed by "#x" (without quotes) --
+             NESTC    "/"
+             NET      ">"
+             PIC      "?>"
+             SHORTREF NONE
+
+         NAMES
+             SGMLREF
+
+         QUANTITY
+             NONE -- Quantities are not restricted in XML --
+
+         ENTITIES
+             "amp"  38
+             "lt"   60
+             "gt"   62
+             "quot" 34
+             "apos" 39
+
+     FEATURES
+         MINIMIZE
+             DATATAG NO
+             OMITTAG NO
+             RANK    NO
+             SHORTTAG
+                 STARTTAG
+                     EMPTY    NO
+                     UNCLOSED NO
+                     NETENABL IMMEDNET
+                 ENDTAG
+                     EMPTY    NO
+                     UNCLOSED NO
+                 ATTRIB
+                     DEFAULT  YES
+                     OMITNAME NO
+                     VALUE    NO
+             EMPTYNRM  YES
+             IMPLYDEF
+                 ATTLIST  NO  -- VALID: was YES --
+                 DOCTYPE  NO
+                 ELEMENT  NO  -- VALID: was YES --
+                 ENTITY   NO
+                 NOTATION NO  -- VALID: was YES --
+         LINK
+             SIMPLE   NO
+             IMPLICIT NO
+             EXPLICIT NO
+         OTHER
+             CONCUR   NO
+             SUBDOC   NO
+             FORMAL   NO
+             URN      NO
+             KEEPRSRE YES
+             VALIDITY TYPE -- VALID: was NOASSERT --
+             ENTITIES
+                 REF      ANY
+                 INTEGRAL YES
+
+     APPINFO NONE
+
+     SEEALSO "ISO 8879//NOTATION Extensible Markup Language (XML) 1.0//EN"
+>
+<!-- Id: $Id: xml1.dcl,v 4.3 2001/04/08 10:30:18 altheim Exp $ SMI
+     Revisions:
+#1999-04-09  changes for XML validation
+#2001-04-08  updated ISO registration number for UCS-4
+-->

data/lib/assertions.rb

@@ -0,0 +1,53 @@
+module Html
+	module Test
+		module Assertions
+			def assert_tidy(body = nil)
+				assert_validates(:tidy, body)
+			end
+
+			def assert_w3c(body = nil)
+				assert_validates(:w3c, body)
+			end
+			
+			def assert_xmllint(body = nil)
+				assert_validates(:xmllint, body)
+			end
+
+			def assert_validates(types = nil, body = nil, url = nil, options = {})
+				verbose = ( options[:verbose] ) ? options[:verbose] : Html::Test::Validator.verbose
+				body ||= @response.body
+				types ||= [:tidy, :w3c, :xmllint]
+				types = [types] if !types.is_a?(Array)
+				types.each do |t|
+					log("validating #{url} with #{t} ... ") if verbose
+					error = Html::Test::Validator.send("#{t}_errors", body)
+					if error.nil?
+						log("OK\n") if verbose
+					else
+						log("FAILURE\n") if verbose
+						assert_message = "Validator #{t} failed"
+						assert_message << " for url #{url}" if url
+						assert_message << " with message '#{error}'"
+						Rails.logger.error(assert_message + " for response body:\n #{with_line_counts(body)}")
+						assert(error.nil?, assert_message)
+					end
+				end
+			end
+			
+			private
+			def log(message)
+				print(message)
+			end
+			
+			def with_line_counts(body)
+				separator = ("-" * 40) + $/
+				body_counts = separator.dup
+				body.each_with_index do |line, i|
+					body_counts << sprintf("%4u %s", i+1, line) # Right align line numbers
+				end
+				body_counts << separator
+				body_counts
+			end
+		end
+	end
+end

data/lib/html_test.rb

@@ -0,0 +1,96 @@
+if !defined?(RAILS_ENV) || RAILS_ENV == 'test'
+
+	%w(validator assertions url_selector url_checker link_validator validate_filter).each do |file|
+		require File.join(File.dirname(__FILE__), file)
+	end
+	
+	class Test::Unit::TestCase
+		include Html::Test::Assertions
+	end
+	
+	module ActionController
+		module Integration #:nodoc:
+			class Session
+				include Html::Test::Assertions			
+			end
+		end
+	end
+	
+#	ActionController::Base
+	require 'action_controller'
+	class ActionController::Base
+		@@validate_all = false
+		cattr_accessor :validate_all
+	
+		@@validators = [:tidy]
+		cattr_accessor :validators
+	
+		@@check_urls = false
+		cattr_accessor :check_urls
+	
+		@@check_redirects = false
+		cattr_accessor :check_redirects
+	
+		after_filter :validate_page
+		after_filter :check_urls_resolve
+		after_filter :check_redirects_resolve
+	
+		private
+		def validate_page
+			return if !validate_all
+			Html::Test::ValidateFilter.new(self).validate_page
+		end
+	
+		def check_urls_resolve
+			return if !check_urls
+			Html::Test::UrlChecker.new(self).check_urls_resolve
+		end
+	
+		def check_redirects_resolve
+			return if !check_redirects
+			Html::Test::UrlChecker.new(self).check_redirects_resolve
+		end
+	end
+
+
+
+
+validate = false
+validators = ["http://localhost/w3c-validator/check", 
+							Html::Test::Validator.w3c_url]
+
+validators.each do |validator|
+	vhost = validator.split('/')[2]
+	vpath = "/"<< validator.split('/')[3..-1].join('/')
+	begin
+		response = Net::HTTP.get_response(vhost, vpath)
+		if response.code == '200'
+			Html::Test::Validator.w3c_url = validator
+			validate = true
+			break
+		end
+	rescue
+	end
+end
+
+if validate
+	ApplicationController.validate_all = true
+	#       default is :tidy, but it doesn't really validate.       
+	#       I've purposely not closed tags and it doesn't complain.
+	#       :w3c is ridiculously slow! even when used locally
+	ApplicationController.validators = [:w3c]
+	#ApplicationController.validators = [:tidy, :w3c]
+	Html::Test::Validator.verbose = false
+	Html::Test::Validator.revalidate_all = true
+	Html::Test::Validator.tidy_ignore_list = 
+		[/<table> lacks "summary" attribute/]
+	puts "Validating all html with " <<
+		Html::Test::Validator.w3c_url
+else
+	puts "NOT validating html at all"
+end
+
+
+
+
+end	#if !defined?(RAILS_ENV) || RAILS_ENV == 'test'

data/lib/jakewendt-html_test.rb

@@ -0,0 +1 @@
+require 'html_test'

data/lib/link_validator.rb

@@ -0,0 +1,175 @@
+require 'test/unit'
+require 'net/http'
+require 'uri'
+
+module Html
+  module Test
+    class LinkValidator
+      include ::Test::Unit::Assertions
+      include ::Html::Test::Assertions
+      include UrlSelector
+      
+      attr_accessor :start_url, :options, :log
+      
+      def options
+        @options ||= {}
+      end
+
+      def log
+        @log ||= ""
+      end
+
+      def initialize(url, options = {})
+        self.start_url = strip_anchor(url)
+
+        # Default values for options
+        if Object.const_defined?(:RailsTidy)
+          self.options[:validators] = %w(tidy)
+        else
+          self.options[:validators] = %w(w3c)      
+        end
+        self.options[:skip_patterns] = []
+        self.options[:follow_external] = true
+        self.options[:follow_links] = true
+        self.options[:quiet] = false
+        Html::Test::Validator.dtd = options[:dtd] if options[:dtd]
+
+        self.options.merge!(options)
+        
+        validate_links
+      end
+
+      # Generates an options hash from the command line options
+      def self.parse_command_line(options_array)
+        if options_array[0] !~ /:\/\//
+          raise "First argument must be URL, i.e. http://my.url.com"
+        end
+
+        options = {}
+
+        opts = OptionParser.new
+        opts.on("--no-follow") { options[:follow_links] = false }
+        opts.on("--validators validators") do |validators|
+          options[:validators] = validators.split(",")
+        end
+        opts.on('--dtd DTD') { |dtd| options[:dtd] = dtd }
+        opts.on("--skip skip_patterns") do |skip_patterns|
+          options[:skip_patterns] = skip_patterns.split(",").map { |p| Regexp.new(p) }
+        end
+        opts.on("--only only_pattern") do |only_pattern|
+          options[:only_pattern] = Regexp.new(only_pattern)
+        end
+        opts.on('--no-external') { options[:follow_external] = false }
+        opts.on('--quiet') { options[:quiet] = true }
+        
+        opts.parse!(options_array)
+
+        options
+      end
+
+      protected
+      def validate_links
+        @url_history = []
+        @failed_urls = []
+
+        get(start_url)
+        return if !options[:follow_links]
+
+        # Fetch links and images on the start page
+        (anchor_urls + image_urls).each do |url|
+          if skip_url?(url)
+            output "skipping url #{url}\n"
+            next
+          end
+          next unless options[:skip_patterns].select { |pattern| url =~ pattern }.empty?
+          next if visited?(url)
+          next if options[:only_pattern] and url !~ options[:only_pattern]
+
+          if external_http?(url)
+            if options[:follow_external]
+              get(url, false)
+            else
+              output "skipping external link #{url}\n"
+            end
+          else
+            get(url)
+          end
+        end
+
+        if !@failed_urls.empty?
+          raise "The following URLs had failures:\n#{@failed_urls.join("\n")}."            
+        end    
+      end
+
+      def get(path, validate = true)
+        begin
+          url = canonical_url(path)
+          output "GET #{url}"
+          @response = Net::HTTP.get_response(URI.parse(url))
+          output " ... #{@response.code}"
+          @url_history << url
+          if ![/200/, /^3/].find { |pattern| @response.code =~ pattern }
+            raise "Invalid response code #{@response.code} for url #{url}"
+          end
+          validate_response if validate
+          output "\n"
+        rescue Exception => e
+          output_error "Exception thrown while getting url #{qualify_url(path)}:" +
+          " #{e} #{e.backtrace.join("\n  ")}\n"
+          @failed_urls << qualify_url(path)
+        end
+      end
+
+      def validate_response
+        if @response and @response.header['content-type'] =~ /text\/html/i
+          options[:validators].each do |type|
+            assert_validates(type)
+            output " ... #{type}"
+          end
+        end
+      end
+
+      def visited?(path)
+        @url_history.include?(canonical_url(path))
+      end
+
+      def strip_anchor(url)
+        url[/^(.*?)(?:\#.+)?$/, 1]
+      end
+
+      def qualify_url(url)
+        return url if url =~ /:\/\// # External URL
+        
+        if url =~ /^\//
+          # Relative site root
+          root_url + url
+        else
+          # Relative start dir
+          start_dir + "/" + url
+        end
+      end
+
+      def canonical_url(url)
+        strip_anchor(qualify_url(url))
+      end
+
+      def root_url
+        start_url[/^([a-z]+:\/\/[^\/]+)/,1]
+      end
+
+      def start_dir
+        return start_url if start_url == root_url # When start_url=http://site.com
+        start_url[/^(.+?)\/[^\/]*$/,1] # Strip last slash and everything after it
+      end
+
+      def output_error(message)
+        output(message, :error)
+      end
+      
+      def output(message, type = :info)
+        log << message
+        print message if (type == :error or !options[:quiet])
+      end
+    end
+  end
+end

data/lib/url_checker.rb

@@ -0,0 +1,142 @@
+module Html
+  module Test
+    class InvalidUrl < RuntimeError; end
+
+    class UrlChecker
+      attr_accessor :request, :response, :params
+      
+      include Html::Test::UrlSelector    
+      
+      def initialize(controller)
+        self.request = controller.request
+        self.response = controller.response
+        self.params = controller.params
+      end
+      
+      def check_urls_resolve
+        urls_to_check.each do |url|
+          check_url_resolves(url)
+        end
+      end
+
+      def check_redirects_resolve        
+        redirect_url = response.headers['Location']
+        if response.status =~ /302/ && redirect_url.present?
+          check_url_resolves(redirect_url)
+        end
+      end
+
+      private
+      def urls_to_check
+        anchor_urls + image_urls + form_urls
+      end
+
+      def check_url_resolves(url)
+        return if skip_url?(url, root_url) || external_http?(url, root_url)
+        url = strip_anchor(remove_query(make_absolute(url)))
+        return if public_file_exists?(url)
+        check_action_exists(url)
+      end
+
+      def root_url
+        request.protocol + request.host_with_port
+      end
+
+      def public_file_exists?(url)
+        public_path = File.join(rails_public_path, url)
+        File.exists?(public_path) || File.exists?(public_path + ".html")
+      end
+
+      def rails_public_path
+        File.join(RAILS_ROOT, "public")
+      end
+
+      # Make URLs absolute paths, i.e. relative to the site root
+      def make_absolute(url)
+        url = remove_host(url) if has_protocol?(url)
+        return url if url =~ %r{^/}
+        current_url = request.request_uri || url_from_params
+        current_url = File.dirname(current_url) if current_url !~ %r{/$}
+        url = File.join(current_url, url) 
+      end
+
+      def remove_host(url)
+        url_no_host = url[%r{^[a-z]+://[^/]+(/.+)$}, 1]
+        url_no_host.blank? ? "/" : url_no_host
+      end
+
+      def remove_query(url)
+        url =~ /\?/ ? url[/^(.+?)\?/, 1] : url
+      end
+
+      def strip_anchor(url)
+        url =~ /\#/ ? url[/^(.+?)\#/, 1] : url
+      end
+
+      # Each URL is required to have at least one HTTP method for which there is a route with an action
+      def check_action_exists(url)
+        unless routes_from_url(url).any? { |route| route_has_action?(route) }
+          raise_invalid_url(url, "No action or template")
+        end
+      end
+
+      def route_has_action?(route)
+        controller = "#{route[:controller].camelize}Controller".constantize
+        controller.public_instance_methods.include?(route[:action]) || template_file_exists?(route, controller)        
+      end
+
+      def template_file_exists?(route, controller)
+        # Workaround for Rails 1.2 that doesn't have the view_paths method
+        template_dirs = controller.respond_to?(:view_paths) ?
+          controller.view_paths : [controller.view_root]
+        template_dirs.each do |template_dir|
+          template_file = File.join(template_dir, controller.controller_path, "#{route[:action]}.*")
+          return true if !Dir.glob(template_file).empty?
+        end
+        false
+      end
+
+      # This is a special case where on my site I had a catch all route for 404s. If you have
+      # such a route, you can override this method and check for it, i.e. you could do something
+      # like this:
+      #
+      #   if params[:action] == "rescue_404"
+      #     raise Html::Test::InvalidUrl.new("Action rescue_404 invoked for url '#{url}'")
+      #   end
+      def check_not_404(url, params)
+        # This method is unimplemented by default
+      end
+
+      def routes_from_url(url)
+        routes = [:get, :post, :put, :delete].map do |method|
+          begin
+            # Need to specify the method here for RESTful resource routes to work, i.e.
+            # for /posts/1 to be recognized as the show action etc.
+            params = ::ActionController::Routing::Routes.recognize_path(url, {:method => method})
+            check_not_404(url, params)
+            params
+          rescue
+            # Could not find a route with that method
+            nil
+          end
+        end.compact
+        routes.present? ? routes : raise_invalid_url(url, "Cannot find a route")
+      end
+
+      def url_from_params(options = params)
+        return "/" if params.empty?
+        options[:controller] ||= params[:controller]
+        ::ActionController::Routing::Routes.generate_extras(symbolize_hash(options))[0]
+      end
+
+      # Convert all keys in the hash to symbols. Not sure why this is needed.
+      def symbolize_hash(hash)
+        hash.keys.inject({}) { |h, k| h[k.to_sym] = hash[k]; h }
+      end
+      
+      def raise_invalid_url(url, message)
+        raise(Html::Test::InvalidUrl.new("#{message} for url '#{url}' request_uri='#{request.request_uri}' body='#{response.body}'"))
+      end
+    end
+  end
+end