RubyGems - html-proofer - Versions diffs - 1.4.0 → 1.5.0 - Mend

html-proofer 1.4.0 → 1.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (39) hide show

checksums.yaml +4 -4
data/README.md +8 -2
data/bin/htmlproof +3 -1
data/html-proofer.gemspec +4 -2
data/lib/html/proofer.rb +66 -10
data/lib/html/proofer/check.rb +1 -1
data/lib/html/proofer/checkable.rb +6 -6
data/lib/html/proofer/checks.rb +2 -1
data/lib/html/proofer/checks/favicon.rb +0 -2
data/lib/html/proofer/checks/html.rb +24 -0
data/lib/html/proofer/checks/links.rb +12 -0
data/lib/html/proofer/issue.rb +1 -1
data/lib/html/proofer/version.rb +5 -0
data/spec/html/proofer/favicon_spec.rb +15 -14
data/spec/html/proofer/fixtures/html/div_inside_head.html +6 -0
data/spec/html/proofer/fixtures/html/html5_tags.html +9 -0
data/spec/html/proofer/fixtures/html/invalid_tag.html +3 -0
data/spec/html/proofer/fixtures/html/missing_closing_quotes.html +5 -0
data/spec/html/proofer/fixtures/html/opening_and_ending_tag_mismatch.html +7 -0
data/spec/html/proofer/fixtures/html/unescaped_ampersand_in_attribute.html +4 -0
data/spec/html/proofer/fixtures/html/unmatched_end_tag.html +5 -0
data/spec/html/proofer/fixtures/links/brokenHashOnTheWeb.html +2 -0
data/spec/html/proofer/fixtures/links/githubHash.html +1 -0
data/spec/html/proofer/fixtures/links/non_standard_characters.html +10 -0
data/spec/html/proofer/fixtures/links/other_protocols.html +4 -0
data/spec/html/proofer/fixtures/sorting/issue/broken_image_one.html +1 -0
data/spec/html/proofer/fixtures/sorting/issue/broken_image_two.html +4 -0
data/spec/html/proofer/fixtures/sorting/path/multiple_issues.html +11 -0
data/spec/html/proofer/fixtures/sorting/path/single_issue.html +1 -0
data/spec/html/proofer/fixtures/sorting/status/a_404.html +1 -0
data/spec/html/proofer/fixtures/sorting/status/broken_link.html +3 -0
data/spec/html/proofer/fixtures/sorting/status/missing_redirect.html +1 -0
data/spec/html/proofer/html_spec.rb +51 -0
data/spec/html/proofer/images_spec.rb +33 -33
data/spec/html/proofer/links_spec.rb +115 -86
data/spec/html/proofer/scripts_spec.rb +12 -12
data/spec/html/proofer_spec.rb +50 -9
data/spec/spec_helper.rb +13 -1
metadata +58 -4

data/spec/html/proofer/fixtures/html/opening_and_ending_tag_mismatch.html ADDED Viewed

@@ -0,0 +1,7 @@
+<html>
+<body>
+<p>The quick <strong>brown fox</p>
+jumped over the
+<p>lazy</strong> dog.</p>
+</body>
+</html>

data/spec/html/proofer/fixtures/html/unescaped_ampersand_in_attribute.html ADDED Viewed

@@ -0,0 +1,4 @@
+<html>
+<body data-something="up&down">
+</body>
+</html>

data/spec/html/proofer/fixtures/html/unmatched_end_tag.html ADDED Viewed

@@ -0,0 +1,5 @@
+<html>
+<body>
+</div>
+</body>
+</html>

data/spec/html/proofer/fixtures/links/brokenHashOnTheWeb.html ADDED Viewed

	@@ -0,0 +1,2 @@
1	+
2	+ <a href="https://help.github.com/articles/searching-issues#no">External URL, no hash</a>

data/spec/html/proofer/fixtures/links/githubHash.html ADDED Viewed

	@@ -0,0 +1 @@
1	+ <a href="https://github.com/typhoeus/typhoeus#other-curl-options">This gets converted</a>.

data/spec/html/proofer/fixtures/links/non_standard_characters.html ADDED Viewed

@@ -0,0 +1,10 @@
+<html>
+<body>
+<a href="http://ben.balter.com/2014/10/08/why-government-contractors-should-%3C3-open-source/">We &lt;3 valid links</a>
+<a href="http://ben.balter.com/2014/09/29/source-disclosed-%E2%89%A0-open-source/">A valid URL</a>
+</body>
+</html>

data/spec/html/proofer/fixtures/links/other_protocols.html ADDED Viewed

@@ -0,0 +1,4 @@
+<a href="git://github.com/mono/mono">Git</a>
+<a href="ftp://ftp.example.com">FTP</a>
+<a href="irc://irc.gimp.org/mono">IRC</a>
+<a href="svn://svn.example.com">SVN</a>

data/spec/html/proofer/fixtures/sorting/issue/broken_image_one.html ADDED Viewed

	@@ -0,0 +1 @@
1	+ <img src="./gpl.png" />

data/spec/html/proofer/fixtures/sorting/issue/broken_image_two.html ADDED Viewed

@@ -0,0 +1,4 @@
+<img src="./gpl.png" />
+<img alt="An existing image" src="NOT_AN_IMAGE" />

data/spec/html/proofer/fixtures/sorting/path/multiple_issues.html ADDED Viewed

@@ -0,0 +1,11 @@
+<html>
+<body>
+<a href="tel:">Tel me</a>
+<img src="gpl.png"/>Image.
+</body>
+</html>

data/spec/html/proofer/fixtures/sorting/path/single_issue.html ADDED Viewed

	@@ -0,0 +1 @@
1	+ <img src="./Screen Shot 2012-08-09 at 7.51.18 AM.png" alt="textbox"/>

data/spec/html/proofer/fixtures/sorting/status/a_404.html ADDED Viewed

	@@ -0,0 +1 @@
1	+ <img alt="An existing image" src="//upload.wikimedia.org/wikipedia/en/thumb/not_here.png" />

data/spec/html/proofer/fixtures/sorting/status/broken_link.html ADDED Viewed

@@ -0,0 +1,3 @@
+<img alt="An existing image" src="//upload.wikimedia.org/wikipedia/en/thumb/fooooof.png" />
+<a href="nowhere.fooof">nope</a>

data/spec/html/proofer/fixtures/sorting/status/missing_redirect.html ADDED Viewed

	@@ -0,0 +1 @@
1	+ <a href="https://help.github.com/changing-author-info/">This is another redirect.</a>

data/spec/html/proofer/html_spec.rb ADDED Viewed

@@ -0,0 +1,51 @@
+require "spec_helper"
+describe "Html test" do
+  it "ignores an invalid tag by default" do
+    html = "#{FIXTURES_DIR}/html/invalid_tag.html"
+    output = capture_stderr { HTML::Proofer.new(html).run }
+    expect(output).to eq ""
+  end
+  it "doesn't fail for html5 tags" do
+    html = "#{FIXTURES_DIR}/html/html5_tags.html"
+    output = capture_stderr { HTML::Proofer.new(html, {:validate_html => true}).run }
+    expect(output).to eq ""
+  end
+  it "fails for an invalid tag" do
+    html = "#{FIXTURES_DIR}/html/invalid_tag.html"
+    output = capture_stderr { HTML::Proofer.new(html, {:validate_html => true}).run }
+    expect(output).to match /Tag myfancytag invalid/
+  end
+  it "fails for an unmatched end tag" do
+    html = "#{FIXTURES_DIR}/html/unmatched_end_tag.html"
+    output = capture_stderr { HTML::Proofer.new(html, {:validate_html => true}).run }
+    expect(output).to match /Unexpected end tag : div/
+  end
+  it "fails for an unescaped ampersand in attribute" do
+    html = "#{FIXTURES_DIR}/html/unescaped_ampersand_in_attribute.html"
+    output = capture_stderr { HTML::Proofer.new(html, {:validate_html => true}).run }
+    expect(output).to match /htmlParseEntityRef: expecting ';'/
+  end
+  it "fails for mismatch between opening and ending tag" do
+    html = "#{FIXTURES_DIR}/html/opening_and_ending_tag_mismatch.html"
+    output = capture_stderr { HTML::Proofer.new(html, {:validate_html => true}).run }
+    expect(output).to match /Opening and ending tag mismatch: p and strong/
+  end
+  it "fails for div inside head" do
+    html = "#{FIXTURES_DIR}/html/div_inside_head.html"
+    output = capture_stderr { HTML::Proofer.new(html, {:validate_html => true}).run }
+    expect(output).to match /Unexpected end tag : head/
+  end
+  it "fails for missing closing quotation mark in href" do
+    html = "#{FIXTURES_DIR}/html/missing_closing_quotes.html"
+    output = capture_stderr { HTML::Proofer.new(html, {:validate_html => true}).run }
+    expect(output).to match /Couldn't find end of Start Tag a/
+  end
+end

data/spec/html/proofer/images_spec.rb CHANGED Viewed

@@ -3,96 +3,96 @@ require "spec_helper"
 describe "Images test" do
   it "passes for existing external images" do
     externalImageFilepath = "#{FIXTURES_DIR}/images/existingImageExternal.html"
-    output = capture_stderr { HTML::Proofer.new(externalImageFilepath).run }
-    output.should == ""
+    proofer = make_proofer(externalImageFilepath)
+    expect(proofer.failed_tests).to eq []
   end
   it "fails for image without alt attribute" do
     missingAltFilepath = "#{FIXTURES_DIR}/images/missingImageAlt.html"
-    output = capture_stderr { HTML::Proofer.new(missingAltFilepath).run }
-    output.should match /gpl.png does not have an alt attribute/
+    proofer = make_proofer(missingAltFilepath)
+    expect(proofer.failed_tests.first).to match /gpl.png does not have an alt attribute/
   end
   it "fails for image with an empty alt attribute" do
     missingAltFilepath = "#{FIXTURES_DIR}/images/missingImageAltText.html"
-    output = capture_stderr { HTML::Proofer.new(missingAltFilepath).run }
-    output.should match /gpl.png does not have an alt attribute/
+    proofer = make_proofer(missingAltFilepath)
+    expect(proofer.failed_tests.first).to match /gpl.png does not have an alt attribute/
   end
   it "fails for missing external images" do
     externalImageFilepath = "#{FIXTURES_DIR}/images/missingImageExternal.html"
-    output = capture_stderr { HTML::Proofer.new(externalImageFilepath).run }
-    output.should match /External link http:\/\/www.whatthehell\/? failed: 0 Couldn't resolve host/
+    proofer = make_proofer(externalImageFilepath)
+    expect(proofer.failed_tests.first).to match /External link http:\/\/www.whatthehell\/? failed: 0 Couldn't resolve host/
   end
   it "fails for missing internal images" do
     internalImageFilepath = "#{FIXTURES_DIR}/images/missingImageInternal.html"
-    output = capture_stderr { HTML::Proofer.new(internalImageFilepath).run }
-    output.should match /doesnotexist.png does not exist/
+    proofer = make_proofer(internalImageFilepath)
+    expect(proofer.failed_tests.first).to match /doesnotexist.png does not exist/
   end
   it "fails for image with no src" do
     imageSrcFilepath = "#{FIXTURES_DIR}/images/missingImageSrc.html"
-    output = capture_stderr { HTML::Proofer.new(imageSrcFilepath).run }
-    output.should match /image has no src attribute/
+    proofer = make_proofer(imageSrcFilepath)
+    expect(proofer.failed_tests.first).to match /image has no src attribute/
   end
   it "fails for image with default mac filename" do
     terribleImageName = "#{FIXTURES_DIR}/images/terribleImageName.html"
-    output = capture_stderr { HTML::Proofer.new(terribleImageName).run }
-    output.should match /image has a terrible filename/
+    proofer = make_proofer(terribleImageName)
+    expect(proofer.failed_tests.first).to match /image has a terrible filename/
   end
   it 'ignores images marked as ignore data-proofer-ignore' do
     ignorableImages = "#{FIXTURES_DIR}/images/ignorableImages.html"
-    output = capture_stderr { HTML::Proofer.new(ignorableImages).run }
-    output.should == ""
+    proofer = make_proofer(ignorableImages)
+    expect(proofer.failed_tests).to eq []
   end
   it 'properly checks relative images' do
     relativeImages = "#{FIXTURES_DIR}/images/rootRelativeImages.html"
-    output = capture_stderr { HTML::Proofer.new(relativeImages).run }
-    output.should == ""
+    proofer = make_proofer(relativeImages)
+    expect(proofer.failed_tests).to eq []
     relativeImages = "#{FIXTURES_DIR}/resources/books/nestedRelativeImages.html"
-    output = capture_stderr { HTML::Proofer.new(relativeImages).run }
-    output.should == ""
+    proofer = make_proofer(relativeImages)
+    expect(proofer.failed_tests).to eq []
   end
   it 'properly ignores data URI images' do
     dataURIImage = "#{FIXTURES_DIR}/images/workingDataURIImage.html"
-    output = capture_stderr { HTML::Proofer.new(dataURIImage).run }
-    output.should == ""
+    proofer = make_proofer(dataURIImage)
+    expect(proofer.failed_tests).to eq []
   end
   it "works for valid images missing the protocol" do
     missingProtocolLink = "#{FIXTURES_DIR}/images/image_missing_protocol_valid.html"
-    output = capture_stderr { HTML::Proofer.new(missingProtocolLink).run }
-    output.should == ""
+    proofer = make_proofer(missingProtocolLink)
+    expect(proofer.failed_tests).to eq []
   end
   it "fails for invalid images missing the protocol" do
     missingProtocolLink = "#{FIXTURES_DIR}/images/image_missing_protocol_invalid.html"
-    output = capture_stderr { HTML::Proofer.new(missingProtocolLink).run }
-    output.should match /404 No error/
+    proofer = make_proofer(missingProtocolLink)
+    expect(proofer.failed_tests.first).to match /404 No error/
   end
   it 'properly checks relative links' do
     relativeLinks = "#{FIXTURES_DIR}/images/relativeToSelf.html"
-    output = capture_stderr { HTML::Proofer.new(relativeLinks).run }
-    output.should == ""
+    proofer = make_proofer(relativeLinks)
+    expect(proofer.failed_tests).to eq []
   end
   it 'properly ignores missing alt tags when asked' do
     ignorableLinks = "#{FIXTURES_DIR}/images/ignorableAltViaOptions.html"
-    output = capture_stderr { HTML::Proofer.new(ignorableLinks, {:alt_ignore => [/wikimedia/, "gpl.png"]}).run }
-    output.should == ""
+    proofer = make_proofer(ignorableLinks, {:alt_ignore => [/wikimedia/, "gpl.png"]})
+    expect(proofer.failed_tests).to eq []
   end
   it 'properly ignores missing alt tags, but not all URLs, when asked' do
     ignorableLinks = "#{FIXTURES_DIR}/images/ignoreAltButNotLink.html"
-    output = capture_stderr { HTML::Proofer.new(ignorableLinks, {:alt_ignore => [/.*/]}).run }
-    output.should match /Couldn't resolve host name/
-    output.should_not match /does not have an alt attribute/
+    proofer = make_proofer(ignorableLinks, {:alt_ignore => [/.*/]})
+    expect(proofer.failed_tests.first).to match /Couldn't resolve host name/
+    expect(proofer.failed_tests.first).to_not match /does not have an alt attribute/
   end
 end

data/spec/html/proofer/links_spec.rb CHANGED Viewed

@@ -4,259 +4,288 @@ describe "Links test" do
   it "fails for broken external hash (even if the file exists)" do
     brokenHashExternalFilepath = "#{FIXTURES_DIR}/links/brokenHashExternal.html"
-    output = capture_stderr { HTML::Proofer.new(brokenHashExternalFilepath).run }
-    output.should match /linking to ..\/images\/missingImageAlt.html#asdfasfdkafl, but asdfasfdkafl does not exist/
+    proofer = make_proofer(brokenHashExternalFilepath)
+    expect(proofer.failed_tests.last).to match /linking to ..\/images\/missingImageAlt.html#asdfasfdkafl, but asdfasfdkafl does not exist/
+  end
+  it "fails for broken hashes on the web (even if the file exists)" do
+    brokenHashOnTheWeb = "#{FIXTURES_DIR}/links/brokenHashOnTheWeb.html"
+    proofer = make_proofer(brokenHashOnTheWeb)
+    expect(proofer.failed_tests.first).to match /but the hash 'no' does not/
+  end
+  it "passes for GitHub hashes on the web" do
+    githubHash = "#{FIXTURES_DIR}/links/githubHash.html"
+    proofer = make_proofer(githubHash)
+    expect(proofer.failed_tests).to eq []
+  end
+  it "passes for broken hashes on the web (when we look only for 4xx)" do
+    options = { :only_4xx => true }
+    brokenHashOnTheWeb = "#{FIXTURES_DIR}/links/brokenHashOnTheWeb.html"
+    proofer = make_proofer(brokenHashOnTheWeb, options)
+    expect(proofer.failed_tests).to eq []
   end
   it "fails for broken internal hash" do
     brokenHashInternalFilepath = "#{FIXTURES_DIR}/links/brokenHashInternal.html"
-    output = capture_stderr { HTML::Proofer.new(brokenHashInternalFilepath).run }
-    output.should match /linking to internal hash #noHash that does not exist/
+    proofer = make_proofer(brokenHashInternalFilepath)
+    expect(proofer.failed_tests.first).to match /linking to internal hash #noHash that does not exist/
   end
   it "fails for broken external links" do
     brokenLinkExternalFilepath = "#{FIXTURES_DIR}/links/brokenLinkExternal.html"
-    output = capture_stderr { HTML::Proofer.new(brokenLinkExternalFilepath).run }
-    output.should match /External link http:\/\/www.asdo3IRJ395295jsingrkrg4.com\/? failed: 0 Couldn't resolve host name/
+    proofer = make_proofer(brokenLinkExternalFilepath)
+    expect(proofer.failed_tests.first).to match /External link http:\/\/www.asdo3IRJ395295jsingrkrg4.com\/? failed: 0 Couldn't resolve host name/
   end
   it "fails for broken internal links" do
     brokenLinkInternalFilepath = "#{FIXTURES_DIR}/links/brokenLinkInternal.html"
-    output = capture_stderr { HTML::Proofer.new(brokenLinkInternalFilepath).run }
-    output.should match /internally linking to .\/notreal.html, which does not exist/
+    proofer = make_proofer(brokenLinkInternalFilepath)
+    expect(proofer.failed_tests.first).to match /internally linking to .\/notreal.html, which does not exist/
   end
   it "fails for link with no href" do
     missingLinkHrefFilepath = "#{FIXTURES_DIR}/links/missingLinkHref.html"
-    output = capture_stderr { HTML::Proofer.new(missingLinkHrefFilepath).run }
-    output.should match /anchor has no href attribute/
+    proofer = make_proofer(missingLinkHrefFilepath)
+    expect(proofer.failed_tests.first).to match /anchor has no href attribute/
   end
   it "should follow redirects" do
     linkWithRedirectFilepath = "#{FIXTURES_DIR}/links/linkWithRedirect.html"
-    output = capture_stderr { HTML::Proofer.new(linkWithRedirectFilepath).run }
-    output.should == ""
+    proofer = make_proofer(linkWithRedirectFilepath)
+    expect(proofer.failed_tests).to eq []
   end
   it "fails on redirects if not following" do
-    options = { :followlocation => false }
     linkWithRedirectFilepath = "#{FIXTURES_DIR}/links/linkWithRedirect.html"
-    output = capture_stderr { HTML::Proofer.new(linkWithRedirectFilepath, options).run }
-    output.should match /External link https:\/\/help.github.com\/changing-author-info\/ failed: 301 No error/
+    proofer = make_proofer(linkWithRedirectFilepath, { :followlocation => false })
+    expect(proofer.failed_tests.first).to match /failed: 301 No error/
   end
   it "does not fail on redirects we're not following" do
     # this test should emit a 301--see above--but we're intentionally supressing it
-    options = { :only_4xx => true, :followlocation => false }
     linkWithRedirectFilepath = "#{FIXTURES_DIR}/links/linkWithRedirect.html"
-    output = capture_stderr { HTML::Proofer.new(linkWithRedirectFilepath, options).run }
-    output.should == ""
+    proofer = make_proofer(linkWithRedirectFilepath, { :only_4xx => true, :followlocation => false })
+    expect(proofer.failed_tests).to eq []
   end
   it "should understand https" do
     linkWithHttpsFilepath = "#{FIXTURES_DIR}/links/linkWithHttps.html"
-    output = capture_stderr { HTML::Proofer.new(linkWithHttpsFilepath).run }
-    output.should == ""
+    proofer = make_proofer(linkWithHttpsFilepath)
+    expect(proofer.failed_tests).to eq []
   end
   it "fails for broken hash links with status code numbers" do
     brokenLinkWithNumberFilepath = "#{FIXTURES_DIR}/links/brokenLinkWithNumber.html"
-    output = capture_stderr { HTML::Proofer.new(brokenLinkWithNumberFilepath).run }
-    output.should match /linking to internal hash #25-method-not-allowed that does not exist/
+    proofer = make_proofer(brokenLinkWithNumberFilepath)
+    expect(proofer.failed_tests.first).to match /linking to internal hash #25-method-not-allowed that does not exist/
   end
   it 'properly resolves implicit /index.html in link paths' do
     linkToFolder = "#{FIXTURES_DIR}/links/linkToFolder.html"
-    output = capture_stderr { HTML::Proofer.new(linkToFolder).run }
-    output.should == ""
+    proofer = make_proofer(linkToFolder)
+    expect(proofer.failed_tests).to eq []
   end
   it 'properly checks links to root' do
     rootLink = "#{FIXTURES_DIR}/links/rootLink/rootLink.html"
-    output = capture_stderr { HTML::Proofer.new(rootLink).run }
-    output.should == ""
+    proofer = make_proofer(rootLink)
+    expect(proofer.failed_tests).to eq []
   end
   it 'properly checks relative links' do
     relativeLinks = "#{FIXTURES_DIR}/links/relativeLinks.html"
-    output = capture_stderr { HTML::Proofer.new(relativeLinks).run }
-    output.should == ""
+    proofer = make_proofer(relativeLinks)
+    expect(proofer.failed_tests).to eq []
   end
   it 'properly checks ssl links' do
     checkSSLLinks = "#{FIXTURES_DIR}/links/checkSSLLinks.html"
-    output = capture_stderr { HTML::Proofer.new(checkSSLLinks).run }
-    output.should == ""
+    proofer = make_proofer(checkSSLLinks)
+    expect(proofer.failed_tests).to eq []
   end
   it 'ignores links marked as ignore data-proofer-ignore' do
     ignorableLinks = "#{FIXTURES_DIR}/links/ignorableLinks.html"
-    output = capture_stderr { HTML::Proofer.new(ignorableLinks).run }
-    output.should == ""
+    proofer = make_proofer(ignorableLinks)
+    expect(proofer.failed_tests).to eq []
   end
   it 'ignores links via href_ignore' do
     ignorableLinks = "#{FIXTURES_DIR}/links/ignorableLinksViaOptions.html"
-    output = capture_stderr { HTML::Proofer.new(ignorableLinks, {:href_ignore => [/^http:\/\//, /sdadsad/, "../whaadadt.html"]}).run }
-    output.should == ""
+    proofer = make_proofer(ignorableLinks, {:href_ignore => [/^http:\/\//, /sdadsad/, "../whaadadt.html"]})
+    expect(proofer.failed_tests).to eq []
   end
   it 'translates links via href_swap' do
     translatedLink = "#{FIXTURES_DIR}/links/linkTranslatedViaHrefSwap.html"
-    output = capture_stderr { HTML::Proofer.new(translatedLink, {:href_swap => { /\A\/articles\/([\w-]+)/ => "\\1.html" }}).run }
-    output.should == ""
+    proofer = make_proofer(translatedLink, {:href_swap => { /\A\/articles\/([\w-]+)/ => "\\1.html" }})
+    expect(proofer.failed_tests).to eq []
   end
   it 'finds a mix of broken and unbroken links' do
     multipleProblems = "#{FIXTURES_DIR}/links/multipleProblems.html"
-    output = capture_stderr { HTML::Proofer.new(multipleProblems).run }
-    output.should match /linking to internal hash #anadaasdadsadschor that does not exist/
+    proofer = make_proofer(multipleProblems)
+    expect(proofer.failed_tests.first).to match /linking to internal hash #anadaasdadsadschor that does not exist/
   end
   it 'ignores valid mailto links' do
     ignorableLinks = "#{FIXTURES_DIR}/links/mailto_link.html"
-    output = capture_stderr { HTML::Proofer.new(ignorableLinks).run }
-    output.should == ""
+    proofer = make_proofer(ignorableLinks)
+    expect(proofer.failed_tests).to eq []
   end
   it "fails for blank mailto links" do
     blankMailToLink = "#{FIXTURES_DIR}/links/blank_mailto_link.html"
-    output = capture_stderr { HTML::Proofer.new(blankMailToLink).run }
-    output.should match /mailto: is an invalid URL/
+    proofer = make_proofer(blankMailToLink)
+    expect(proofer.failed_tests.first).to match /mailto: contains no email address/
   end
   it 'ignores valid tel links' do
     ignorableLinks = "#{FIXTURES_DIR}/links/tel_link.html"
-    output = capture_stderr { HTML::Proofer.new(ignorableLinks).run }
-    output.should == ""
+    proofer = make_proofer(ignorableLinks)
+    expect(proofer.failed_tests).to eq []
   end
   it "fails for blank tel links" do
     blankTelLink = "#{FIXTURES_DIR}/links/blank_tel_link.html"
-    output = capture_stderr { HTML::Proofer.new(blankTelLink).run }
-    output.should match /tel: is an invalid URL/
+    proofer = make_proofer(blankTelLink)
+    expect(proofer.failed_tests.first).to match /tel: contains no phone number/
   end
   it 'ignores javascript links' do
     javascriptLink = "#{FIXTURES_DIR}/links/javascript_link.html"
-    output = capture_stderr { HTML::Proofer.new(javascriptLink).run }
-    output.should == ""
+    proofer = make_proofer(javascriptLink)
+    expect(proofer.failed_tests).to eq []
   end
   it "works for valid links missing the protocol" do
     missingProtocolLink = "#{FIXTURES_DIR}/links/link_missing_protocol_valid.html"
-    output = capture_stderr { HTML::Proofer.new(missingProtocolLink).run }
-    output.should == ""
+    proofer = make_proofer(missingProtocolLink)
+    expect(proofer.failed_tests).to eq []
   end
   it "fails for invalid links missing the protocol" do
     missingProtocolLink = "#{FIXTURES_DIR}/links/link_missing_protocol_invalid.html"
-    output = capture_stderr { HTML::Proofer.new(missingProtocolLink).run }
-    output.should match /Couldn't resolve host name/
+    proofer = make_proofer(missingProtocolLink)
+    expect(proofer.failed_tests.first).to match /Couldn't resolve host name/
   end
   it "works for valid href within link elements" do
     head_link = "#{FIXTURES_DIR}/links/head_link_href.html"
-    output = capture_stderr { HTML::Proofer.new(head_link).run }
-    output.should == ""
+    proofer = make_proofer(head_link)
+    expect(proofer.failed_tests).to eq []
   end
   it "fails for empty href within link elements" do
     head_link = "#{FIXTURES_DIR}/links/head_link_href_empty.html"
-    output = capture_stderr { HTML::Proofer.new(head_link).run }
-    output.should match /anchor has no href attribute/
+    proofer = make_proofer(head_link)
+    expect(proofer.failed_tests.first).to match /anchor has no href attribute/
   end
   it "fails for absent href within link elements" do
     head_link = "#{FIXTURES_DIR}/links/head_link_href_absent.html"
-    output = capture_stderr { HTML::Proofer.new(head_link).run }
-    output.should match /anchor has no href attribute/
+    proofer = make_proofer(head_link)
+    expect(proofer.failed_tests.first).to match /anchor has no href attribute/
   end
   it "fails for internal linking to a directory without trailing slash" do
     options = { :followlocation => false }
     internal = "#{FIXTURES_DIR}/links/link_directory_without_slash.html"
-    output = capture_stderr { HTML::Proofer.new(internal, options).run }
-    output.should match /without trailing slash/
+    proofer = make_proofer(internal, options)
+    expect(proofer.failed_tests.first).to match /without trailing slash/
   end
   it "works for array of links" do
-    output = capture_stderr { HTML::Proofer.new(["www.github.com", "foofoofoo.biz"]).run }
-    output.should match /foofoofoo.biz\/? failed: 0 Couldn't resolve host name/
+    proofer = make_proofer(["www.github.com", "foofoofoo.biz"])
+    expect(proofer.failed_tests.first).to match /foofoofoo.biz\/? failed: 0 Couldn't resolve host name/
   end
   it "works for broken anchors within pre" do
     anchor_pre = "#{FIXTURES_DIR}/links/anchors_in_pre.html"
-    output = capture_stderr { HTML::Proofer.new(anchor_pre).run }
-    output.should == ""
+    proofer = make_proofer(anchor_pre)
+    expect(proofer.failed_tests).to eq []
   end
   it "works for broken link within pre" do
     link_pre = "#{FIXTURES_DIR}/links/links_in_pre.html"
-    output = capture_stderr { HTML::Proofer.new(link_pre).run }
-    output.should == ""
+    proofer = make_proofer(link_pre)
+    expect(proofer.failed_tests).to eq []
   end
   it "works for pipes in the URL" do
     escape_pipes = "#{FIXTURES_DIR}/links/escape_pipes.html"
-    output = capture_stderr { HTML::Proofer.new(escape_pipes).run }
-    output.should == ""
+    proofer = make_proofer(escape_pipes)
+    expect(proofer.failed_tests).to eq []
   end
   it "fails for broken hash with query" do
     broken_hash = "#{FIXTURES_DIR}/links/broken_hash_with_query.html"
-    output = capture_stderr { HTML::Proofer.new(broken_hash).run }
-    output.should match /linking to internal hash #example that does not exist/
+    proofer = make_proofer(broken_hash)
+    expect(proofer.failed_tests.first).to match /linking to internal hash #example that does not exist/
   end
   it "works for directory index file" do
     options = { :directory_index_file => "index.php" }
     link_pointing_to_directory = "#{FIXTURES_DIR}/links/link_pointing_to_directory.html"
-    output = capture_stderr { HTML::Proofer.new(link_pointing_to_directory, options).run }
-    output.should == ""
+    proofer = make_proofer(link_pointing_to_directory, options)
+    expect(proofer.failed_tests).to eq []
   end
   it "fails if directory index file doesn't exist" do
     options = { :directory_index_file => "README.md" }
     link_pointing_to_directory = "#{FIXTURES_DIR}/links/link_pointing_to_directory.html"
-    output = capture_stderr { HTML::Proofer.new(link_pointing_to_directory, options).run }
-    output.should match "internally linking to folder-php/, which does not exist"
+    proofer = make_proofer(link_pointing_to_directory, options)
+    expect(proofer.failed_tests.first).to match "internally linking to folder-php/, which does not exist"
   end
   it "ensures Typhoeus options are passed" do
     options = { ssl_verifypeer: false }
     typhoeus_options_link = "#{FIXTURES_DIR}/links/ensure_typhoeus_options.html"
-    output = capture_stderr { HTML::Proofer.new(typhoeus_options_link, options).run }
-    output.should == ""
+    proofer = make_proofer(typhoeus_options_link, options)
+    expect(proofer.failed_tests).to eq []
   end
   it "works if subdirectory ends with .html" do
     with_subdirectory_html = "#{FIXTURES_DIR}/links/_site"
-    output = capture_stderr { HTML::Proofer.new(with_subdirectory_html).run }
-    output.should == ""
+    proofer = make_proofer(with_subdirectory_html)
+    expect(proofer.failed_tests).to eq []
   end
   it "works for hash referring to itself" do
     hashReferringToSelf = "#{FIXTURES_DIR}/links/hashReferringToSelf.html"
-    output = capture_stderr { HTML::Proofer.new(hashReferringToSelf).run }
-    output.should == ""
+    proofer = make_proofer(hashReferringToSelf)
+    expect(proofer.failed_tests).to eq []
   end
   it "ignores placeholder with name" do
     placeholder_with_name = "#{FIXTURES_DIR}/links/placeholder_with_name.html"
-    output = capture_stderr { HTML::Proofer.new(placeholder_with_name).run }
-    output.should == ""
+    proofer = make_proofer(placeholder_with_name)
+    expect(proofer.failed_tests).to eq []
   end
   it "ignores placeholder with id" do
     placeholder_with_id = "#{FIXTURES_DIR}/links/placeholder_with_id.html"
-    output = capture_stderr { HTML::Proofer.new(placeholder_with_id).run }
-    output.should == ""
+    proofer = make_proofer(placeholder_with_id)
+    expect(proofer.failed_tests).to eq []
   end
   it "fails for placeholder with empty id" do
     empty_id = "#{FIXTURES_DIR}/links/placeholder_with_empty_id.html"
-    output = capture_stderr { HTML::Proofer.new(empty_id).run }
-    output.should match /anchor has no href attribute/
+    proofer = make_proofer(empty_id)
+    expect(proofer.failed_tests.first).to match /anchor has no href attribute/
+  end
+  it "ignores non-http(s) protocols" do
+    other_protocols = "#{FIXTURES_DIR}/links/other_protocols.html"
+    proofer = make_proofer(other_protocols)
+    expect(proofer.failed_tests).to eq []
+  end
+  it "passes non-standard characters" do
+    fixture = "#{FIXTURES_DIR}/links/non_standard_characters.html"
+    proofer = make_proofer(fixture)
+    expect(proofer.failed_tests).to eq []
   end
 end