html-proofer 2.5.1 → 2.5.2

data/spec/html/proofer/fixtures/vcr_cassettes/www_garbalarba_com_href_swap_/garbalarba/_github_.yml

@@ -1,73 +0,0 @@
----
-http_interactions:
-- request:
-    method: head
-    uri: www.github.com
-    body:
-      encoding: US-ASCII
-      string: ''
-    headers:
-      User-Agent:
-      - Mozilla/5.0 (compatible; HTML Proofer/2.3.0; +https://github.com/gjtorikian/html-proofer)
-  response:
-    status:
-      code: 200
-      message: OK
-    headers:
-      Server:
-      - GitHub.com
-      Date:
-      - Mon, 06 Jul 2015 05:10:25 GMT
-      Content-Type:
-      - text/html; charset=utf-8
-      Status:
-      - 200 OK
-      Content-Security-Policy:
-      - 'default-src *; script-src assets-cdn.github.com collector-cdn.github.com;
-        object-src assets-cdn.github.com; style-src ''self'' ''unsafe-inline'' ''unsafe-eval''
-        assets-cdn.github.com; img-src ''self'' data: assets-cdn.github.com identicons.github.com
-        www.google-analytics.com collector.githubapp.com *.githubusercontent.com *.gravatar.com
-        *.wp.com; media-src ''none''; frame-src ''self'' render.githubusercontent.com
-        gist.github.com www.youtube.com player.vimeo.com checkout.paypal.com; font-src
-        assets-cdn.github.com; connect-src ''self'' live.github.com wss://live.github.com
-        uploads.github.com status.github.com api.github.com www.google-analytics.com
-        github-cloud.s3.amazonaws.com'
-      Public-Key-Pins:
-      - max-age=300; pin-sha256="WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18="; pin-sha256="JbQbUG5JMJUoI6brnx0x3vZF6jilxsapbXGVfjhN8Fg=";
-        includeSubDomains
-      Cache-Control:
-      - no-cache
-      Vary:
-      - X-PJAX
-      - Accept-Encoding
-      X-UA-Compatible:
-      - IE=Edge,chrome=1
-      Set-Cookie:
-      - logged_in=no; domain=.github.com; path=/; expires=Fri, 06 Jul 2035 05:10:25
-        -0000; secure; HttpOnly
-      - _gh_sess=eyJzZXNzaW9uX2lkIjoiNzA3ZmQzMmVhNGE1NDQ4YzUxOGFkMjZkMjk4YThiMjkiLCJfY3NyZl90b2tlbiI6IklTYjRZRUh5dWhra3M3SXRKU0RMVVNTTzYwOXc0MEhSQS85bnJmWCtwT2M9In0%3D--598600b6d119d1c5da32745e013cf915e81b53bf;
-        path=/; secure; HttpOnly
-      X-Request-Id:
-      - 223cae55bc9682cb3b30c3a559c5d2aa
-      X-Runtime:
-      - '0.009497'
-      X-GitHub-Request-Id:
-      - 490F8465:506F:2609878:559A0DC0
-      Strict-Transport-Security:
-      - max-age=31536000; includeSubdomains; preload
-      X-Content-Type-Options:
-      - nosniff
-      X-XSS-Protection:
-      - 1; mode=block
-      X-Frame-Options:
-      - deny
-      X-Served-By:
-      - a0387c52951b3c2853740ef9cede1dec
-    body:
-      encoding: UTF-8
-      string: ''
-    http_version: '1.1'
-    adapter_metadata:
-      effective_url: https://github.com/
-  recorded_at: Mon, 06 Jul 2015 05:10:25 GMT
-recorded_with: VCR 2.9.3

data/spec/html/proofer/fixtures/vcr_cassettes/www_github_com_foofoofoo_biz.yml

@@ -1,115 +0,0 @@
----
-http_interactions:
-- request:
-    method: head
-    uri: foofoofoo.biz
-    body:
-      encoding: US-ASCII
-      string: ''
-    headers:
-      User-Agent:
-      - Mozilla/5.0 (compatible; HTML Proofer/2.3.0; +https://github.com/gjtorikian/html-proofer)
-  response:
-    status:
-      code: 0
-      message: 
-    headers: {}
-    body:
-      encoding: UTF-8
-      string: ''
-    http_version: 
-    adapter_metadata:
-      effective_url: HTTP://foofoofoo.biz/
-  recorded_at: Mon, 06 Jul 2015 05:10:19 GMT
-- request:
-    method: get
-    uri: foofoofoo.biz
-    body:
-      encoding: US-ASCII
-      string: ''
-    headers:
-      User-Agent:
-      - Mozilla/5.0 (compatible; HTML Proofer/2.3.0; +https://github.com/gjtorikian/html-proofer)
-  response:
-    status:
-      code: 0
-      message: 
-    headers: {}
-    body:
-      encoding: UTF-8
-      string: ''
-    http_version: 
-    adapter_metadata:
-      effective_url: HTTP://foofoofoo.biz/
-  recorded_at: Mon, 06 Jul 2015 05:10:19 GMT
-- request:
-    method: head
-    uri: www.github.com
-    body:
-      encoding: US-ASCII
-      string: ''
-    headers:
-      User-Agent:
-      - Mozilla/5.0 (compatible; HTML Proofer/2.3.0; +https://github.com/gjtorikian/html-proofer)
-  response:
-    status:
-      code: 200
-      message: OK
-    headers:
-      Server:
-      - GitHub.com
-      Date:
-      - Mon, 06 Jul 2015 05:10:21 GMT
-      Content-Type:
-      - text/html; charset=utf-8
-      Status:
-      - 200 OK
-      Content-Security-Policy:
-      - 'default-src *; script-src assets-cdn.github.com collector-cdn.github.com;
-        object-src assets-cdn.github.com; style-src ''self'' ''unsafe-inline'' ''unsafe-eval''
-        assets-cdn.github.com; img-src ''self'' data: assets-cdn.github.com identicons.github.com
-        www.google-analytics.com collector.githubapp.com *.githubusercontent.com *.gravatar.com
-        *.wp.com; media-src ''none''; frame-src ''self'' render.githubusercontent.com
-        gist.github.com www.youtube.com player.vimeo.com checkout.paypal.com; font-src
-        assets-cdn.github.com; connect-src ''self'' live.github.com wss://live.github.com
-        uploads.github.com status.github.com api.github.com www.google-analytics.com
-        github-cloud.s3.amazonaws.com'
-      Public-Key-Pins:
-      - max-age=300; pin-sha256="WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18="; pin-sha256="JbQbUG5JMJUoI6brnx0x3vZF6jilxsapbXGVfjhN8Fg=";
-        includeSubDomains
-      Cache-Control:
-      - no-cache
-      Vary:
-      - X-PJAX
-      - Accept-Encoding
-      X-UA-Compatible:
-      - IE=Edge,chrome=1
-      Set-Cookie:
-      - logged_in=no; domain=.github.com; path=/; expires=Fri, 06 Jul 2035 05:10:21
-        -0000; secure; HttpOnly
-      - _gh_sess=eyJzZXNzaW9uX2lkIjoiYjVmM2Q3ZjFhODQxMWIxNjdhODIyNWQ5ZGI1ZDNlMDkiLCJfY3NyZl90b2tlbiI6IlE5R1lsT3pFWW9Fb2VJWndZVGJUQ1ZodzJCeXZsclBzYmVEc1JvdVU1VE09In0%3D--afddd987025ba23ca6db5388811d74e15126663a;
-        path=/; secure; HttpOnly
-      X-Request-Id:
-      - cfa6252fd906896bc99fa744471f06af
-      X-Runtime:
-      - '0.009622'
-      X-GitHub-Request-Id:
-      - 490F8465:506E:3EED418:559A0DBD
-      Strict-Transport-Security:
-      - max-age=31536000; includeSubdomains; preload
-      X-Content-Type-Options:
-      - nosniff
-      X-XSS-Protection:
-      - 1; mode=block
-      X-Frame-Options:
-      - deny
-      X-Served-By:
-      - a22dbcbd09a98eacdd14ac7804a635dd
-    body:
-      encoding: UTF-8
-      string: ''
-    http_version: '1.1'
-    adapter_metadata:
-      effective_url: https://github.com/
-  recorded_at: Mon, 06 Jul 2015 05:10:21 GMT
-recorded_with: VCR 2.9.3

data/spec/html/proofer/html_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-
-describe 'Html test' do
-  it 'ignores an invalid tag by default' do
-    html = "#{FIXTURES_DIR}/html/invalid_tag.html"
-    proofer = run_proofer(html)
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it "doesn't fail for html5 tags" do
-    html = "#{FIXTURES_DIR}/html/html5_tags.html"
-    proofer = run_proofer(html, { :check_html => true })
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it "doesn't fail for svg elements" do
-    html = "#{FIXTURES_DIR}/html/svg_elements.html"
-    proofer = run_proofer(html, { :check_html => true })
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'fails for an invalid tag' do
-    html = "#{FIXTURES_DIR}/html/invalid_tag.html"
-    proofer = run_proofer(html, { :check_html => true })
-    expect(proofer.failed_tests.first).to match(/Tag myfancytag invalid \(line 2\)/)
-  end
-
-  it 'fails for an unmatched end tag' do
-    html = "#{FIXTURES_DIR}/html/unmatched_end_tag.html"
-    proofer = run_proofer(html, { :check_html => true })
-    expect(proofer.failed_tests.first).to match(/Unexpected end tag : div \(line 3\)/)
-  end
-
-  it 'fails for an unescaped ampersand in attribute' do
-    html = "#{FIXTURES_DIR}/html/unescaped_ampersand_in_attribute.html"
-    proofer = run_proofer(html, { :check_html => true })
-    expect(proofer.failed_tests.first).to match(/htmlParseEntityRef: expecting ';' \(line 2\)/)
-  end
-
-  it 'fails for mismatch between opening and ending tag' do
-    html = "#{FIXTURES_DIR}/html/opening_and_ending_tag_mismatch.html"
-    proofer = run_proofer(html, { :check_html => true })
-    expect(proofer.failed_tests.first).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"
-    proofer = run_proofer(html, { :check_html => true })
-    expect(proofer.failed_tests.first).to match(/Unexpected end tag : head \(line 5\)/)
-  end
-
-  it 'fails for missing closing quotation mark in href' do
-    html = "#{FIXTURES_DIR}/html/missing_closing_quotes.html"
-    proofer = run_proofer(html, { :check_html => true })
-    expect(proofer.failed_tests.to_s).to match(/Couldn't find end of Start Tag a \(line 6\)/)
-  end
-
-  it 'ignores embeded scripts when asked' do
-    opts = { :check_html => true, :validation => { :ignore_script_embeds => true } }
-    ignorableScript = "#{FIXTURES_DIR}/html/ignore_script_embeds.html"
-    proofer = run_proofer(ignorableScript, opts)
-    expect(proofer.failed_tests).to eq []
-  end
-end

data/spec/html/proofer/images_spec.rb

@@ -1,147 +0,0 @@
-require 'spec_helper'
-
-describe 'Images test' do
-  it 'passes for existing external images' do
-    externalImageFilepath = "#{FIXTURES_DIR}/images/existingImageExternal.html"
-    proofer = run_proofer(externalImageFilepath)
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'fails for image without alt attribute' do
-    missingAltFilepath = "#{FIXTURES_DIR}/images/missingImageAlt.html"
-    proofer = run_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"
-    proofer = run_proofer(missingAltFilepath)
-    expect(proofer.failed_tests.first).to match(/gpl.png does not have an alt attribute/)
-  end
-
-  it 'fails for image with nothing but spaces in alt attribute' do
-    emptyAltFilepath = "#{FIXTURES_DIR}/images/emptyImageAltText.html"
-    proofer = run_proofer(emptyAltFilepath)
-    expect(proofer.failed_tests.first).to match(/gpl.png does not have an alt attribute/)
-    expect(proofer.failed_tests.length).to equal(3)
-  end
-
-  it 'passes when ignoring image with nothing but spaces in alt attribute' do
-    emptyAltFilepath = "#{FIXTURES_DIR}/images/emptyImageAltText.html"
-    proofer = run_proofer(emptyAltFilepath, {:alt_ignore => [/.+/]})
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'fails for missing external images' do
-    externalImageFilepath = "#{FIXTURES_DIR}/images/missingImageExternal.html"
-    proofer = run_proofer(externalImageFilepath)
-    expect(proofer.failed_tests.first).to match(/failed: 0/)
-  end
-
-  it 'fails for missing internal images' do
-    internalImageFilepath = "#{FIXTURES_DIR}/images/missingImageInternal.html"
-    proofer = run_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"
-    proofer = run_proofer(imageSrcFilepath)
-    expect(proofer.failed_tests.first).to match(/image has no src or srcset attribute/)
-  end
-
-  it 'fails for image with default mac filename' do
-    terribleImageName = "#{FIXTURES_DIR}/images/terribleImageName.html"
-    proofer = run_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"
-    proofer = run_proofer(ignorableImages)
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'properly checks relative images' do
-    relativeImages = "#{FIXTURES_DIR}/images/rootRelativeImages.html"
-    proofer = run_proofer(relativeImages)
-    expect(proofer.failed_tests).to eq []
-
-    relativeImages = "#{FIXTURES_DIR}/resources/books/nestedRelativeImages.html"
-    proofer = run_proofer(relativeImages)
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'properly ignores data URI images' do
-    dataURIImage = "#{FIXTURES_DIR}/images/workingDataURIImage.html"
-    proofer = run_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"
-    proofer = run_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"
-    proofer = run_proofer(missingProtocolLink)
-    expect(proofer.failed_tests.first).to match(/failed: 404/)
-  end
-
-  it 'properly checks relative links' do
-    relativeLinks = "#{FIXTURES_DIR}/images/relativeToSelf.html"
-    proofer = run_proofer(relativeLinks)
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'properly ignores missing alt tags when asked' do
-    ignorableLinks = "#{FIXTURES_DIR}/images/ignorableAltViaOptions.html"
-    proofer = run_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"
-    proofer = run_proofer(ignorableLinks, {:alt_ignore => [/.*/]})
-    expect(proofer.failed_tests.first).to match(/failed: 0/)
-    expect(proofer.failed_tests.first).to_not match /does not have an alt attribute/
-  end
-
-  it 'properly ignores empty alt attribute when empty_alt_ignore set' do
-    missingAltFilepath = "#{FIXTURES_DIR}/images/emptyImageAltText.html"
-    proofer = run_proofer(missingAltFilepath, {:empty_alt_ignore => true})
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'properly ignores empty alt attributes, but not missing alt attributes, when empty_alt_ignore set' do
-    missingAltFilepath = "#{FIXTURES_DIR}/images/missingImageAlt.html"
-    proofer = run_proofer(missingAltFilepath, {:empty_alt_ignore => true})
-    expect(proofer.failed_tests.first).to match(/gpl.png does not have an alt attribute/)
-  end
-
-  it 'works for images with a srcset' do
-    srcSetCheck = "#{FIXTURES_DIR}/images/srcSetCheck.html"
-    proofer = run_proofer(srcSetCheck)
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'fails for images with a srcset but missing alt' do
-    srcSetMissingAlt = "#{FIXTURES_DIR}/images/srcSetMissingAlt.html"
-    proofer = run_proofer(srcSetMissingAlt)
-    expect(proofer.failed_tests.first).to match(/image gpl.png does not have an alt attribute/)
-  end
-
-  it 'fails for images with an alt but missing src or srcset' do
-    srcSetMissingAlt = "#{FIXTURES_DIR}/images/srcSetMissingImage.html"
-    proofer = run_proofer(srcSetMissingAlt)
-    expect(proofer.failed_tests.first).to match(/internal image notreal.png does not exist/)
-  end
-
-  it 'properly ignores missing alt tags when asked for srcset' do
-    ignorableLinks = "#{FIXTURES_DIR}/images/srcSetIgnorable.html"
-    proofer = run_proofer(ignorableLinks, {:alt_ignore => [/wikimedia/, "gpl.png"]})
-    expect(proofer.failed_tests).to eq []
-  end
-end

data/spec/html/proofer/links_spec.rb

@@ -1,376 +0,0 @@
-require 'spec_helper'
-
-describe 'Links test' do
-
-  it 'fails for broken internal hash (even if the file exists)' do
-    brokenHashExternalFilepath = "#{FIXTURES_DIR}/links/brokenHashExternal.html"
-    proofer = run_proofer(brokenHashExternalFilepath)
-    expect(proofer.failed_tests.last).to match(%r{linking to ../images/missingImageAlt.html#asdfasfdkafl, but asdfasfdkafl does not exist})
-  end
-
-  it 'fails for broken hashes on the web when asked (even if the file exists)' do
-    brokenHashOnTheWeb = "#{FIXTURES_DIR}/links/brokenHashOnTheWeb.html"
-    proofer = run_proofer(brokenHashOnTheWeb, { :check_external_hash => true} )
-    expect(proofer.failed_tests.first).to match(/but the hash 'no' does not/)
-  end
-
-  it 'passes for broken hashes on the web when ignored (even if the file exists)' do
-    brokenHashOnTheWeb = "#{FIXTURES_DIR}/links/brokenHashOnTheWeb.html"
-    proofer = run_proofer(brokenHashOnTheWeb)
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'passes for GitHub hashes on the web when asked' do
-    githubHash = "#{FIXTURES_DIR}/links/githubHash.html"
-    proofer = run_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 = run_proofer(brokenHashOnTheWeb, options)
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'fails for broken internal hash' do
-    brokenHashInternalFilepath = "#{FIXTURES_DIR}/links/brokenHashInternal.html"
-    proofer = run_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"
-    proofer = run_proofer(brokenLinkExternalFilepath)
-    expect(proofer.failed_tests.first).to match(/failed: 0/)
-  end
-
-  it 'passes for different filename without option' do
-    brokenLinkExternalFilepath = "#{FIXTURES_DIR}/links/file.foo"
-    proofer = run_proofer(brokenLinkExternalFilepath)
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'fails for different filenames' do
-    options = { :ext => '.foo' }
-    brokenLinkExternalFilepath = "#{FIXTURES_DIR}/links/file.foo"
-    proofer = run_proofer(brokenLinkExternalFilepath, options)
-    expect(proofer.failed_tests.first).to match(/failed: 0/)
-  end
-
-  it 'fails for broken internal links' do
-    brokenLinkInternalFilepath = "#{FIXTURES_DIR}/links/brokenLinkInternal.html"
-    proofer = run_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"
-    proofer = run_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"
-    proofer = run_proofer(linkWithRedirectFilepath)
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'fails on redirects if not following' do
-    linkWithRedirectFilepath = "#{FIXTURES_DIR}/links/linkWithRedirect.html"
-    proofer = run_proofer(linkWithRedirectFilepath, :typhoeus => { :followlocation => false })
-    expect(proofer.failed_tests.first).to match(/failed: 301/)
-  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
-    linkWithRedirectFilepath = "#{FIXTURES_DIR}/links/linkWithRedirect.html"
-    proofer = run_proofer(linkWithRedirectFilepath, { :only_4xx => true, :typhoeus => { :followlocation => false } })
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'should understand https' do
-    linkWithHttpsFilepath = "#{FIXTURES_DIR}/links/linkWithHttps.html"
-    proofer = run_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"
-    proofer = run_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"
-    proofer = run_proofer(linkToFolder)
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'properly checks links to root' do
-    rootLink = "#{FIXTURES_DIR}/links/rootLink/rootLink.html"
-    proofer = run_proofer(rootLink)
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'properly checks relative links' do
-    relativeLinks = "#{FIXTURES_DIR}/links/relativeLinks.html"
-    proofer = run_proofer(relativeLinks)
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'properly checks ssl links' do
-    checkSSLLinks = "#{FIXTURES_DIR}/links/checkSSLLinks.html"
-    proofer = run_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"
-    proofer = run_proofer(ignorableLinks)
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'ignores links via href_ignore' do
-    ignorableLinks = "#{FIXTURES_DIR}/links/ignorableLinksViaOptions.html"
-    proofer = run_proofer(ignorableLinks, { :href_ignore => [%r{^http://}, /sdadsad/, '../whaadadt.html'] })
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'translates links via href_swap' do
-    translatedLink = "#{FIXTURES_DIR}/links/linkTranslatedViaHrefSwap.html"
-    proofer = run_proofer(translatedLink, { :href_swap => { %r{\A/articles/([\w-]+)} => "\\1.html" } })
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'translates links via href_swap for list of links' do
-    proofer = run_proofer(['www.garbalarba.com'], { :href_swap => { /garbalarba/ => 'github' } })
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'finds a mix of broken and unbroken links' do
-    multipleProblems = "#{FIXTURES_DIR}/links/multipleProblems.html"
-    proofer = run_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"
-    proofer = run_proofer(ignorableLinks)
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'fails for blank mailto links' do
-    blankMailToLink = "#{FIXTURES_DIR}/links/blank_mailto_link.html"
-    proofer = run_proofer(blankMailToLink)
-    expect(proofer.failed_tests.first).to match(/mailto: contains no email address/)
-  end
-
-  it 'fails for invalid mailto links' do
-    invalidMailToLink = "#{FIXTURES_DIR}/links/invalid_mailto_link.html"
-    proofer = run_proofer(invalidMailToLink)
-    expect(proofer.failed_tests.first).to match(/mailto:octocat contains an invalid email address/)
-  end
-
-  it 'ignores valid tel links' do
-    ignorableLinks = "#{FIXTURES_DIR}/links/tel_link.html"
-    proofer = run_proofer(ignorableLinks)
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'fails for blank tel links' do
-    blankTelLink = "#{FIXTURES_DIR}/links/blank_tel_link.html"
-    proofer = run_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"
-    proofer = run_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"
-    proofer = run_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"
-    proofer = run_proofer(missingProtocolLink)
-    expect(proofer.failed_tests.first).to match(/failed: 0/)
-  end
-
-  it 'works for valid href within link elements' do
-    head_link = "#{FIXTURES_DIR}/links/head_link_href.html"
-    proofer = run_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"
-    proofer = run_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"
-    proofer = run_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 = { :typhoeus => { :followlocation => false } }
-    internal = "#{FIXTURES_DIR}/links/link_directory_without_slash.html"
-    proofer = run_proofer(internal, options)
-    expect(proofer.failed_tests.first).to match(/without trailing slash/)
-  end
-
-  it 'ignores external links when asked' do
-    options = { :disable_external => true }
-    external = "#{FIXTURES_DIR}/links/brokenLinkExternal.html"
-    proofer = run_proofer(external, options)
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'works for array of links' do
-    proofer = run_proofer(['www.github.com', 'foofoofoo.biz'])
-    expect(proofer.failed_tests.first).to match(/failed: 0/)
-  end
-
-  it 'works for broken anchors within pre' do
-    anchor_pre = "#{FIXTURES_DIR}/links/anchors_in_pre.html"
-    proofer = run_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"
-    proofer = run_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"
-    proofer = run_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"
-    proofer = run_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"
-    proofer = run_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"
-    proofer = run_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 = { :typhoeus => { :ssl_verifypeer => false } }
-    typhoeus_options_link = "#{FIXTURES_DIR}/links/ensure_typhoeus_options.html"
-    proofer = run_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"
-    proofer = run_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"
-    proofer = run_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"
-    proofer = run_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"
-    proofer = run_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"
-    proofer = run_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 = run_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 = run_proofer(fixture)
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'does not dupe errors' do
-    fixture = "#{FIXTURES_DIR}/links/nodupe.html"
-    proofer = run_proofer(fixture)
-    expect(proofer.failed_tests.length).to eq 1
-  end
-
-  it 'passes for broken *nix links' do
-    fixture = "#{FIXTURES_DIR}/links/brokenUnixLinks.html"
-    proofer = run_proofer(fixture)
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'passes for external UTF-8 links' do
-    fixture = "#{FIXTURES_DIR}/links/utf8Link.html"
-    proofer = run_proofer(fixture)
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'passes for urlencoded href' do
-    fixture = "#{FIXTURES_DIR}/links/urlencoded-href.html"
-    proofer = run_proofer(fixture)
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'reports failures for the original link, not the redirection' do
-    fixture = "#{FIXTURES_DIR}/links/redirected_error.html"
-    proofer = run_proofer(fixture)
-    expect(proofer.failed_tests.first).to match(/failed: 404/)
-  end
-
-  it 'does not complain for files with attributes containing dashes' do
-    fixture = "#{FIXTURES_DIR}/links/attributeWithDash.html"
-    proofer = run_proofer(fixture)
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'does not complain for internal links with mismatched cases' do
-    fixture = "#{FIXTURES_DIR}/links/ignores_cases.html"
-    proofer = run_proofer(fixture)
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'does not check links with parameters multiple times' do
-    fixture = "#{FIXTURES_DIR}/links/check_just_once.html"
-    proofer = run_proofer(fixture)
-    expect(proofer.iterable_external_urls.length).to eq 2
-  end
-end