html-proofer 2.3.0 → 3.0.0

data/spec/html/proofer/links_spec.rb

@@ -1,364 +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 Couldn't resolve host name/)
-  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 Couldn't resolve host name/)
-  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 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
-    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(/Couldn't resolve host name/)
-  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 Couldn't resolve host name/)
-  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(/post.htm\?id=63009224 failed: 404 No error/)
-  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
-end

data/spec/html/proofer/scripts_spec.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-describe 'Scripts test' do
-
-  it 'fails for broken external src' do
-    file = "#{FIXTURES_DIR}/scripts/script_broken_external.html"
-    proofer = run_proofer(file)
-    expect(proofer.failed_tests.first).to match(/failed: 0 Couldn't resolve host name/)
-  end
-
-  it 'works for valid internal src' do
-    file = "#{FIXTURES_DIR}/scripts/script_valid_internal.html"
-    proofer = run_proofer(file)
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'fails for missing internal src' do
-    file = "#{FIXTURES_DIR}/scripts/script_missing_internal.html"
-    proofer = run_proofer(file)
-    expect(proofer.failed_tests.first).to match(/doesnotexist.js does not exist \(line 5\)/)
-  end
-
-  it 'works for present content' do
-    file = "#{FIXTURES_DIR}/scripts/script_content.html"
-    proofer = run_proofer(file)
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'fails for absent content' do
-    file = "#{FIXTURES_DIR}/scripts/script_content_absent.html"
-    proofer = run_proofer(file)
-    expect(proofer.failed_tests.first).to match(/script is empty and has no src attribute/)
-  end
-
-  it 'works for broken script within pre' do
-    script_pre = "#{FIXTURES_DIR}/scripts/script_in_pre.html"
-    proofer = run_proofer(script_pre)
-    expect(proofer.failed_tests).to eq []
-  end
-
-  it 'ignores links via url_ignore' do
-    ignorableLinks = "#{FIXTURES_DIR}/scripts/ignorableLinksViaOptions.html"
-    proofer = run_proofer(ignorableLinks, { :url_ignore => [/\/assets\/.*(js|css|png|svg)/] })
-    expect(proofer.failed_tests).to eq []
-  end
-
-end

data/spec/html/proofer/utils_spec.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-describe HTML::Utils do
-  describe '::create_nokogiri' do
-    it 'passes for a string' do
-      noko = HTML::Utils::create_nokogiri '<html lang="jp">'
-      expect(noko.css('html').first['lang']).to eq 'jp'
-    end
-    it 'passes for a file' do
-      noko = HTML::Utils::create_nokogiri "#{FIXTURES_DIR}/utils/lang-jp.html"
-      expect(noko.css('html').first['lang']).to eq 'jp'
-    end
-  end
-end

data/spec/html/proofer_spec.rb

@@ -1,122 +0,0 @@
-require "spec_helper"
-
-describe HTML::Proofer do
-
-  describe '#failed_tests' do
-    it 'is a list of the formatted errors' do
-      brokenLinkInternalFilepath = "#{FIXTURES_DIR}/links/brokenLinkInternal.html"
-      proofer = run_proofer(brokenLinkInternalFilepath)
-      expect(proofer.failed_tests).to eq(["spec/html/proofer/fixtures/links/brokenLinkInternal.html: internally linking to ./notreal.html, which does not exist (line 5)", "spec/html/proofer/fixtures/links/brokenLinkInternal.html: internally linking to ./missingImageAlt.html, which does not exist (line 6)"])
-    end
-  end
-
-  describe '#files' do
-    it 'works for directory that ends with .html' do
-      folder = "#{FIXTURES_DIR}/links/_site/folder.html"
-      proofer = HTML::Proofer.new folder
-      expect(proofer.files).to eq(["#{folder}/index.html"])
-    end
-  end
-
-  describe '#options' do
-    it 'strips out undesired Typhoeus options' do
-      folder = "#{FIXTURES_DIR}/links/_site/folder.html"
-      proofer = HTML::Proofer.new folder, :verbose => true
-      expect(proofer.options[:verbose]).to eq(true)
-      expect(proofer.typhoeus_opts[:verbose]).to eq(nil)
-    end
-
-    it 'takes options for Parallel' do
-      folder = "#{FIXTURES_DIR}/links/_site/folder.html"
-      proofer = HTML::Proofer.new folder, :parallel => { :in_processes => 3 }
-      expect(proofer.parallel_opts[:in_processes]).to eq(3)
-      expect(proofer.typhoeus_opts[:in_processes]).to eq(nil)
-      expect(proofer.options[:parallel]).to eq(nil)
-    end
-
-    describe 'sorting' do
-      it 'understands sorting by path' do
-        output = send_proofer_output("#{FIXTURES_DIR}/sorting/path")
-
-        expect(output.strip).to eq('''
-- spec/html/proofer/fixtures/sorting/path/multiple_issues.html
-  *  image gpl.png does not have an alt attribute (line 7)
-  *  internal image gpl.png does not exist (line 7)
-  *  tel: contains no phone number (line 5)
-- spec/html/proofer/fixtures/sorting/path/single_issue.html
-  *  image has a terrible filename (./Screen Shot 2012-08-09 at 7.51.18 AM.png) (line 1)
-      '''.strip)
-      end
-
-      it 'understands sorting by issue' do
-        output = send_proofer_output("#{FIXTURES_DIR}/sorting/issue", :error_sort => :desc)
-        expect(output.strip).to eq('''
-- image ./gpl.png does not have an alt attribute
-  *  spec/html/proofer/fixtures/sorting/issue/broken_image_one.html (line 1)
-  *  spec/html/proofer/fixtures/sorting/issue/broken_image_two.html (line 1)
-- internal image ./gpl.png does not exist
-  *  spec/html/proofer/fixtures/sorting/issue/broken_image_one.html (line 1)
-  *  spec/html/proofer/fixtures/sorting/issue/broken_image_two.html (line 1)
-- internal image NOT_AN_IMAGE does not exist
-  *  spec/html/proofer/fixtures/sorting/issue/broken_image_two.html (line 4)
-      '''.strip)
-      end
-
-
-      it 'understands sorting by status' do
-        output = send_proofer_output("#{FIXTURES_DIR}/sorting/status", :typhoeus => { :followlocation => false }, :error_sort => :status)
-        expect(output.strip).to eq('''
-- -1
-  *  spec/html/proofer/fixtures/sorting/status/broken_link.html: internally linking to nowhere.fooof, which does not exist (line 3)
-- 301
-  *  spec/html/proofer/fixtures/sorting/status/a_404.html: External link http://upload.wikimedia.org/wikipedia/en/thumb/not_here.png failed: 301 No error
-  *  spec/html/proofer/fixtures/sorting/status/broken_link.html: External link http://upload.wikimedia.org/wikipedia/en/thumb/fooooof.png failed: 301 No error
-    '''.strip)
-      end
-    end
-
-    describe 'file ignores' do
-      it 'knows how to ignore a file by string' do
-        options = { :file_ignore => ["#{FIXTURES_DIR}/links/brokenHashInternal.html"] }
-        brokenHashInternalFilepath = "#{FIXTURES_DIR}/links/brokenHashInternal.html"
-        proofer = run_proofer(brokenHashInternalFilepath, options)
-        expect(proofer.failed_tests).to eq []
-      end
-
-      it 'knows how to ignore a file by regexp' do
-        options = { :file_ignore => [/brokenHash/] }
-        brokenHashInternalFilepath = "#{FIXTURES_DIR}/links/brokenHashInternal.html"
-        proofer = run_proofer(brokenHashInternalFilepath, options)
-        expect(proofer.failed_tests).to eq []
-      end
-
-      it 'knows how to ignore multiple files by regexp' do
-        options = { :file_ignore => [%r{.*/javadoc/.*}, %r{.*/catalog/.*}] }
-        brokenFolders = "#{FIXTURES_DIR}/links/folder/multiples"
-        proofer = run_proofer(brokenFolders, options)
-        expect(proofer.failed_tests).to eq []
-      end
-
-      it 'knows how to ignore a directory by regexp' do
-        options = { :file_ignore => [/\S\.html/] }
-        linksDir = "#{FIXTURES_DIR}/links"
-        proofer = run_proofer(linksDir, options)
-        expect(proofer.failed_tests).to eq []
-      end
-    end
-  end
-
-  describe 'ignored checks' do
-    it 'knows how to ignore checks' do
-      options = { :checks_to_ignore => ['ImageRunner'] }
-      proofer = make_proofer('', options)
-      expect(proofer.checks).to_not include 'ImageRunner'
-    end
-
-    it 'does not care about phoney ignored checks' do
-      options = { :checks_to_ignore => ['This is nothing.'] }
-      proofer = make_proofer('', options)
-      expect(proofer.checks.length).to eq 3
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,52 +0,0 @@
-require 'bundler/setup'
-require_relative "../lib/html/proofer"
-
-FIXTURES_DIR = "spec/html/proofer/fixtures"
-
-RSpec.configure do |config|
-  # Use color in STDOUT
-  config.color = true
-
-  # Use color not only in STDOUT but also in pagers and files
-  config.tty = true
-
-  # Use the specified formatter
-  config.formatter = :documentation # :progress, :html, :textmate
-
-  # Run in a random order
-  config.order = :random
-end
-
-def capture_stderr(*)
-  original_stderr = $stderr
-  original_stdout = $stdout
-  $stderr = fake_err = StringIO.new
-  $stdout = fake_out = StringIO.new
-  begin
-    yield
-  rescue RuntimeError
-  ensure
-    $stderr = original_stderr
-    $stdout = original_stdout
-  end
-  fake_err.string
-end
-
-def make_proofer(file, opts)
-  HTML::Proofer.new(file, opts)
-end
-
-def run_proofer(file, opts = {})
-  proofer = make_proofer(file, opts)
-  capture_stderr { proofer.run }
-  proofer
-end
-
-def send_proofer_output(file, opts = {})
-  proofer = make_proofer(file, opts)
-  capture_stderr { proofer.run }
-end
-
-def make_bin(cmd, path=nil)
-  `bin/htmlproof #{cmd} #{path}`
-end