) # * +script+ elements within the +body+ element # :call-seq: # assert_unobtrusive_javascript # assert_unobtrusive_javascript(response [, message]) # assert_unobtrusive_javascript(string [, message]) # assert_unobtrusive_javascript(options [, message]) # # Asserts that the document does not have Javascript mixed into the markup. # # If passing an options hash, the following keys are meaningful: # # [:content] The string being checked # [:allowed] An array of obtrusive Javascript indicators which will # not be checked for. Possible values are: # # [:blank_hrefs] +a+ elements with +href+ # attributes that have an empty # URI fragment in them (i.e., # #). # # [:javascript_hrefs] +a+ elements with +href+ # attributes that have URIs # with the # javascript # protocol (e.g., # href="javascript:etc.".) # # [:inline_events] Elements which have any of the # +oneventname+-style events in # them. # # [:script_elements_in_body] +script+ elements # inside the +body+ # element, instead of # the +head+. # # By default, +assert_unobtrusive_javascript+ checks for # all of these. # Javascript best practices can be found in the lovely # {DOM Scripting}[http://www.amazon.com/gp/product/1590595335/] by Jeremy # Keith. # # assert_unobtrusive_javascript # assert_unobtrusive_javascript(:allowed => [:blank_hrefs]) # assert_unobtrusive_javascript(a_string) # assert_unobtrusive_javascript(:content => a_string, :allowed => [:inline_events]) # assert_unobtrusive_javascript({ :content => a_string, :allowed => [:inline_events] }, 'Custom message') def assert_unobtrusive_javascript(param = @response, message = MSG_OBTRUSIVE_JAVASCRIPT) options = param_to_options(param, { :allowed => [] }) content = options[:content] allowed = options[:allowed] raise ArgumentError('allowed javascript elements must be an Array') unless allowed.is_a?(Array) matches = scan((OBTRUSIVE_JAVASCRIPTS.keys - allowed - [:script_elements_in_body]).map{|e|OBTRUSIVE_JAVASCRIPTS[e]}, content) unless allowed.include?(:script_elements_in_body) # This is a special case, since we need to get the body *first*, and *then* check it for # script elements. I realize I could do it with a single regex, but it'd match the entire # contents of any body element with a script element, which would make for a crappy # error message. Still, it prompted a nice refactor of the scanning and raising # methods. if md = content.match(/]*>(.+)<\/body>/im) matches += scan(OBTRUSIVE_JAVASCRIPTS[:script_elements_in_body], md.to_s) end end raise_informatively(message, matches) end # :call-seq: # assert_valid_html # assert_valid_html(response [, message]) # assert_valid_html(string [, message]) # # Asserts the validity of an (X)HTML document. The document is sent to the # {W3C Validator}[http://validator.w3.org] by default, and the results are # cached in system temp directory. To change the validator, refer to # validator_uri=. # # assert_valid_html # assert_valid_html(test_response) # assert_valid_html(a_string) # assert_valid_html(@response, "'/welcome' is invalid HTML.') def assert_valid_html(response = @response, message = MSG_INVALID_XHTML) content = response_to_string(response) # validate using W3C, but pull from cache if we've got it filename = cache_filename(content) unless File.exist?(filename) begin uri = URI.parse(@@validator_uri) validator_response = Net::HTTP.start(uri.host, uri.port).post2(uri.path, "fragment=#{CGI.escape(content)}&output=xml") File.open(filename, 'w+') { |f| Marshal.dump(validator_response, f) } rescue => e raise ConnectionError.new("Couldn't connect to the validator: #{e.message}") end else validator_response = File.open(filename) { |f| Marshal.load(f) } end unless validator_response.is_a?(Net::HTTPSuccess) raise ConnectionError.new("Couldn't connect to the validator: HTTP Error #{validator_response.code} #{validator_response.message}") end # parse body into components begin xml_doc = REXML::Document.new(validator_response.body) rescue => e raise ParsingError.new("Couldn't parse the results from the W3C Validator: #{e.message}") end # parse errors into nice, palatable messages # (it'd be nice to abstract this into the main formatting section, but the data is just too different.) messages = Array.new lines = content.split("\n") xml_doc.elements.each("//messages/msg") do |msg| messages << "Line #{msg.attributes['line']}, Column #{msg.attributes['col']}: #{msg.text}" line = lines[msg.attributes['line'].to_i-1].to_s line_to_display, column = excerpt(line.strip, msg.attributes['col'].to_i) column = msg.attributes['col'].to_i - column - (line.size - line.lstrip.size) messages << " #{line_to_display}" messages << " #{' ' * column}^" end # do the actual assertion messages = messages.map{|x|" #{x}"}.join("\n") clean_assert_block("#{message}\n#{messages}"){ xml_doc.elements["//meta/errors"].text == '0' } end alias :assert_valid_xhtml :assert_valid_html # :call-seq: # assert_well_formed_xml # assert_well_formed_xml(response [, message]) # assert_well_formed_xml(string [, message]) # # Asserts the well-formedness of an XML document. # # N.B.: This does *not* mean the XML document is valid, but rather that # the document can be parsed. Validity must be assessed in reference to a DTD # which specifies which elements go where. def assert_well_formed_xml(response = @response, message = MSG_INVALID_XML) content = response_to_string(response) errors = Array.new begin document = REXML::Document.new(content) document.root rescue REXML::ParseException => e errors = e.to_s.split("\n") errors = errors.slice(errors.index('...')+1, errors.size-1) message = [message, '-' * message.size, errors.map{ |e| " " << e.capitalize}].flatten.join("\n") end clean_assert_block(message){ errors.empty? } end private def cache_filename(content) File.join(Dir.tmpdir, CACHE_FILENAME_STEM + Digest::MD5.hexdigest(@@validator_uri+content)) end def response_to_string(response) content = response.respond_to?(:body) ? response.body.to_s : response.to_s raise ArgumentError.new("can't check a blank string") if content.empty? return content end def param_to_options(param, defaults = {}, default_param = nil) options = Hash.new if param.respond_to?(:body) && param.respond_to?(:headers) options[:content] = param.body.to_s options[:headers] = param.headers elsif param.is_a?(String) options[:content] = param elsif param.is_a?(Hash) options = param if @response && @response.respond_to?(:body) && !options[:content] options[:content] = @response.body options[:headers] = @response.headers end elsif default_param options[default_param] = param if @response && @response.respond_to?(:body) && !options[:content] options[:content] = @response.body options[:headers] = @response.headers end else raise ArgumentError.new("can't interpret first parameter <#{param.inspect}>") end raise ArgumentError.new("can't check a blank string") if options[:content].to_s == '' return defaults.merge(options) end # Scan, format, and raise. Yes. def scan_format_and_raise(expression, content, message) raise_informatively(message, scan(expression, content)) end # Blows up well. def raise_informatively(message, matches) clean_assert_block("#{message}\n#{format_match(matches)}"){ matches.empty? } end # Converts an offset into a line and column number. # May go totally wonky on output with CR\LF line endings. def offset_to_location(offset, lines) lines = lines.split("\n").map{ |line| line.split(//) } unless lines.is_a?(Array) offset_counter = 0 current_line = 0 while offset_counter <= offset && current_line < lines.size offset_counter += lines[current_line].size current_line += 1 end # TODO: this pukes when run on Windows. # Tough titty, or to be fixed? return { :line => current_line, :column => offset - (offset_counter - lines[current_line-1].size) } end # Finds all instances of +expression+ within +content+ and returns a hash # of matches with subkeys :line, :column, :excerpt, # and :offset def scan(expression, content) if expression.is_a?(Array) matches = expression.map{ |e| scan(e, content) }.flatten else lines = content.split("\n").map{ |line| line.split(//) } matches = Array.new s = StringScanner.new(content) while s.scan_until(expression) location = offset_to_location(s.pos+1, lines) matches << { :excerpt => excerpt(s.matched, 1, 40).first, :offset => s.pos+1, :line => location[:line], :column => location[:column] } end end if !matches.empty? && matches.first[:offset] # remove all matches which occur more than once matches.reject!{ |m| matches.select{|x| x[:offset] == m[:offset] }.size > 1 } # sort the bastards matches.sort!{ |a,b| a[:offset] <=> b[:offset]} end return matches end # Turns match information into a happy message. def format_match(match) if match.is_a?(Array) match.map{ |m| format_match(m) }.flatten.map{|x|" #{x}"}.join("\n") else ["Line #{match[:line]}, Column #{match[:column]}:"]+ [" #{match[:excerpt]}\n"] end end # Excerpts a string based on a position in the string, and returns # both the excerpt and the offset (used for caret positioning). def excerpt(text, position, radius = 20, excerpt_string = '...') # Adapted from the Rails source. start_pos = [ position - radius, 0 ].max end_pos = [ position + 10 + radius, text.size ].min prefix = start_pos > 0 ? excerpt_string : "" postfix = end_pos < text.size ? excerpt_string : "" return (prefix + text[start_pos..end_pos].strip + postfix), (start_pos - prefix.size) end def equal_without_case_or_whitespace?(a, b) a.to_s.downcase.gsub(/[\s]/,'') == b.to_s.downcase.gsub(/[\s]/,'') end # Lifted from the Rails source. def clean_backtrace(&block) yield rescue Test::Unit::AssertionFailedError => e path = File.expand_path(__FILE__) raise Test::Unit::AssertionFailedError, e.message, e.backtrace.reject { |line| File.expand_path(line) =~ /#{path}/ } end def clean_assert_block(message, &block) clean_backtrace do assert_block(message) { block.call } end end def clean_assert_equal(a, b, message, ignore_case_and_whitespace = false) clean_backtrace do if ignore_case_and_whitespace && !a.nil? && !b.nil? assert_equal(a.downcase.gsub(/[\s]/,''), b.downcase.gsub(/[\s]/,''), message) else assert_equal((a.nil? ? '' : a), (b.nil? ? '' : b), message) end end end end module Test #:nodoc module Unit #:nodoc class TestCase #:nodoc include ResponsibleMarkup #:nodoc end end end