site-inspector 3.1.1 → 3.2.0

data/package.json

@@ -4,7 +4,7 @@
   "description": "Returns information about a domain's technology and capabilities",
   "main": "site-inspector",
   "dependencies": {
-    "pa11y": "^2.1.0"
+    "pa11y": "^5.0.0"
   },
   "devDependencies": {},
   "scripts": {

data/script/pa11y-version

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require './lib/site-inspector'
 

data/site-inspector.gemspec

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require File.expand_path './lib/site-inspector/version', File.dirname(__FILE__)
 
 Gem::Specification.new do |s|
@@ -15,21 +17,26 @@ Gem::Specification.new do |s|
   s.test_files            = s.files.grep(%r{^(test|spec|features)/})
   s.require_paths         = ['lib']
 
-  s.add_dependency('nokogiri', '~> 1.6')
-  s.add_dependency('public_suffix', '~> 1.4')
-  s.add_dependency('gman', '~> 4.1')
-  s.add_dependency('dnsruby', '~> 1.56')
-  s.add_dependency('sniffles', '~> 0.2')
-  s.add_dependency('typhoeus', '~> 0.7')
-  s.add_dependency('oj', '~> 2.11')
-  s.add_dependency('mercenary', '~> 0.3')
-  s.add_dependency('colorator', '~> 0.1')
-  s.add_dependency('cliver', '~> 0.3')
-  s.add_dependency('parallel', '~> 1.6')
-  s.add_development_dependency('pry', '~> 0.10')
-  s.add_development_dependency('rake', '~> 10.4')
-  s.add_development_dependency('rspec', '~> 3.2')
-  s.add_development_dependency('bundler', '~> 1.6')
-  s.add_development_dependency('webmock', '~> 1.2')
-  s.add_development_dependency('rubocop', '~> 0.35')
+  s.add_dependency('cliver', '~> 0.0')
+  s.add_dependency('colorator', '~> 1.1')
+  s.add_dependency('dnsruby', '~> 1.0')
+  s.add_dependency('dotenv', '~> 2.0')
+  s.add_dependency('gman', '~> 7.0', '>= 7.0.4')
+  s.add_dependency('mercenary', '~> 0.0')
+  s.add_dependency('nokogiri', '~> 1.0')
+  s.add_dependency('oj', '~> 3.0')
+  s.add_dependency('parallel', '~> 1.0')
+  s.add_dependency('public_suffix', '~> 4.0')
+  s.add_dependency('sniffles', '~> 0.0')
+  s.add_dependency('typhoeus', '~> 1.0')
+  s.add_dependency('urlscan', '~> 0.6')
+  s.add_dependency('whois', '~> 5.0')
+
+  s.add_development_dependency('pry', '~> 0.0')
+  s.add_development_dependency('rake', '~> 13.0')
+  s.add_development_dependency('rspec', '~> 3.0')
+  s.add_development_dependency('rubocop', '~> 1.0')
+  s.add_development_dependency('rubocop-performance', '~> 1.5')
+  s.add_development_dependency('rubocop-rspec', '~> 2.0')
+  s.add_development_dependency('webmock', '~> 3.0')
 end

data/spec/checks/site_inspector_endpoint_accessibility_spec.rb

@@ -1,27 +1,29 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe SiteInspector::Endpoint::Accessibility do
   subject do
     endpoint = SiteInspector::Endpoint.new('http://example.com')
-    SiteInspector::Endpoint::Accessibility.new(endpoint)
+    described_class.new(endpoint)
   end
 
   it "retrieve's pa11y's version" do
-    pending('Pa11y not installed') unless SiteInspector::Endpoint::Accessibility.pa11y?
+    pending('Pa11y not installed') unless described_class.pa11y?
     expect(subject.class.pa11y_version).to match(/\d\.\d\.\d/)
   end
 
   it 'responds to valid standards' do
-    expect(subject.respond_to?(:section508)).to eql(true)
+    expect(subject.respond_to?(:section508)).to be(true)
   end
 
   it 'knows the level' do
-    expect(subject.level).to eql(:error)
+    expect(subject.level).to be(:error)
   end
 
   it 'allows the user to set the level' do
     subject.level = :warning
-    expect(subject.level).to eql(:warning)
+    expect(subject.level).to be(:warning)
   end
 
   it 'errors on invalid levels' do
@@ -29,12 +31,12 @@ describe SiteInspector::Endpoint::Accessibility do
   end
 
   it 'knows the standard' do
-    expect(subject.standard).to eql(:section508)
+    expect(subject.standard).to be(:wcag2a)
   end
 
   it 'allows the user to set the standard' do
     subject.standard = :wcag2a
-    expect(subject.standard).to eql(:wcag2a)
+    expect(subject.standard).to be(:wcag2a)
   end
 
   it 'errors on invalid standards' do
@@ -55,27 +57,27 @@ describe SiteInspector::Endpoint::Accessibility do
 
     it 'knows if a site is valid' do
       with_env 'SKIP_PA11Y_CHECK', 'true' do
-        expect(subject.valid?).to eql(false)
+        expect(subject.valid?).to be(false)
       end
     end
 
     it 'counts the errors' do
       with_env 'SKIP_PA11Y_CHECK', 'true' do
-        expect(subject.errors).to eql(1)
+        expect(subject.errors).to be(1)
       end
     end
 
     it 'runs the check' do
       with_env 'SKIP_PA11Y_CHECK', 'true' do
-        expect(subject.check[:valid]).to eql(false)
-        expect(subject.check[:results].first['code']).to eql('Section508.L.NoContentAnchor')
+        expect(subject.check[:valid]).to be(false)
+        expect(subject.check[:results].first['code']).to eql('WCAG2A.Principle3.Guideline3_1.3_1_1.H57.2')
       end
     end
 
     it 'runs a named check' do
       with_env 'SKIP_PA11Y_CHECK', 'true' do
-        expect(subject.check[:valid]).to eql(false)
-        expect(subject.check[:results].first['code']).to eql('Section508.L.NoContentAnchor')
+        expect(subject.check[:valid]).to be(false)
+        expect(subject.check[:results].first['code']).to eql('WCAG2A.Principle3.Guideline3_1.3_1_1.H57.2')
       end
     end
   end

data/spec/checks/site_inspector_endpoint_check_spec.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe SiteInspector::Endpoint::Check do
   subject do
     stub_request(:head, 'http://example.com/').to_return(status: 200)
     endpoint = SiteInspector::Endpoint.new('http://example.com')
-    SiteInspector::Endpoint::Check.new(endpoint)
+    described_class.new(endpoint)
   end
 
   it 'returns the endpoint' do
@@ -24,17 +26,17 @@ describe SiteInspector::Endpoint::Check do
   end
 
   it 'returns its name' do
-    expect(subject.name).to eql(:check)
+    expect(subject.name).to be(:check)
   end
 
   it 'returns the instance name' do
-    expect(SiteInspector::Endpoint::Check.name).to eql(:check)
+    expect(described_class.name).to be(:check)
   end
 
   it 'enables and disables the check' do
-    expect(SiteInspector::Endpoint::Check.enabled?).to eql(true)
-    SiteInspector::Endpoint::Check.enabled = false
-    expect(SiteInspector::Endpoint::Check.enabled?).to eql(false)
-    SiteInspector::Endpoint::Check.enabled = true
+    expect(described_class.enabled?).to be(true)
+    described_class.enabled = false
+    expect(described_class.enabled?).to be(false)
+    described_class.enabled = true
   end
 end

data/spec/checks/site_inspector_endpoint_content_spec.rb

@@ -1,22 +1,27 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe SiteInspector::Endpoint::Content do
   subject do
-    body = <<-eos
+    body = <<-BODY
     <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
       <html>
+        <head>
+          <meta name="generator" content="Jekyll v3.8.5" />
+        </head>
         <body>
           <h1>Some page</h1>
         </body>
       </html>
-    eos
+    BODY
 
     stub_request(:get, 'http://example.com/')
       .to_return(status: 200, body: body)
     stub_request(:head, 'http://example.com/')
       .to_return(status: 200)
     endpoint = SiteInspector::Endpoint.new('http://example.com')
-    SiteInspector::Endpoint::Content.new(endpoint)
+    described_class.new(endpoint)
   end
 
   it 'returns the doc' do
@@ -33,64 +38,68 @@ describe SiteInspector::Endpoint::Content do
   end
 
   it 'knows when robots.txt exists' do
-    stub_request(:head, %r{http\://example.com/[a-z0-9]{32}}i).to_return(status: 404)
+    stub_request(:head, %r{http://example.com/[a-z0-9]{32}}i).to_return(status: 404)
 
     stub_request(:head, 'http://example.com/robots.txt')
       .to_return(status: 200)
-    expect(subject.robots_txt?).to eql(true)
+    expect(subject.robots_txt?).to be(true)
   end
 
   it "knows when robots.txt doesn't exist" do
-    stub_request(:head, %r{http\://example.com/[a-z0-9]{32}}i).to_return(status: 404)
+    stub_request(:head, %r{http://example.com/[a-z0-9]{32}}i).to_return(status: 404)
 
     stub_request(:head, 'http://example.com/robots.txt')
       .to_return(status: 404)
-    expect(subject.robots_txt?).to eql(false)
+    expect(subject.robots_txt?).to be(false)
   end
 
   it 'knows when sitemap.xml exists' do
-    stub_request(:head, %r{http\://example.com/[a-z0-9]{32}}i).to_return(status: 404)
+    stub_request(:head, %r{http://example.com/[a-z0-9]{32}}i).to_return(status: 404)
 
     stub_request(:head, 'http://example.com/sitemap.xml')
       .to_return(status: 200)
-    expect(subject.sitemap_xml?).to eql(true)
+    expect(subject.sitemap_xml?).to be(true)
   end
 
   it 'knows when sitemap.xml exists' do
-    stub_request(:head, %r{http\://example.com/[a-z0-9]{32}}i).to_return(status: 404)
+    stub_request(:head, %r{http://example.com/[a-z0-9]{32}}i).to_return(status: 404)
 
     stub_request(:head, 'http://example.com/sitemap.xml')
       .to_return(status: 404)
-    expect(subject.sitemap_xml?).to eql(false)
+    expect(subject.sitemap_xml?).to be(false)
   end
 
   it 'knows when humans.txt exists' do
-    stub_request(:head, %r{http\://example.com/[a-z0-9]{32}}i).to_return(status: 404)
+    stub_request(:head, %r{http://example.com/[a-z0-9]{32}}i).to_return(status: 404)
 
     stub_request(:head, 'http://example.com/humans.txt')
       .to_return(status: 200)
-    expect(subject.humans_txt?).to eql(true)
+    expect(subject.humans_txt?).to be(true)
   end
 
   it "knows when humans.txt doesn't exist" do
-    stub_request(:head, %r{http\://example.com/[a-z0-9]{32}}i).to_return(status: 404)
+    stub_request(:head, %r{http://example.com/[a-z0-9]{32}}i).to_return(status: 404)
 
     stub_request(:head, 'http://example.com/humans.txt')
       .to_return(status: 200)
-    expect(subject.humans_txt?).to eql(true)
+    expect(subject.humans_txt?).to be(true)
+  end
+
+  it 'returns the generator' do
+    expect(subject.generator).to eql('Jekyll v3.8.5')
   end
 
   context '404s' do
     it 'knows when an endpoint returns a proper 404' do
-      stub_request(:head, %r{http\://example.com/.*})
+      stub_request(:head, %r{http://example.com/.*})
         .to_return(status: 404)
-      expect(subject.proper_404s?).to eql(true)
+      expect(subject.proper_404s?).to be(true)
     end
 
     it "knows when an endpoint doesn't return a proper 404" do
-      stub_request(:head, %r{http\://example.com/[a-z0-9]{32}}i)
+      stub_request(:head, %r{http://example.com/[a-z0-9]{32}}i)
         .to_return(status: 200)
-      expect(subject.proper_404s?).to eql(false)
+      expect(subject.proper_404s?).to be(false)
     end
 
     it 'generates a random path' do
@@ -100,9 +109,9 @@ describe SiteInspector::Endpoint::Content do
     end
 
     it "doesn't say something exists when there are no 404s" do
-      stub_request(:head, %r{http\://example.com/[a-z0-9]{32}}i).to_return(status: 200)
+      stub_request(:head, %r{http://example.com/[a-z0-9]{32}}i).to_return(status: 200)
       stub_request(:head, 'http://example.com/humans.txt').to_return(status: 200)
-      expect(subject.humans_txt?).to eql(nil)
+      expect(subject.humans_txt?).to be(nil)
     end
   end
 end

data/spec/checks/site_inspector_endpoint_cookies_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe SiteInspector::Endpoint::Cookies do
@@ -6,12 +8,12 @@ describe SiteInspector::Endpoint::Cookies do
       stub_request(:head, 'http://example.com/')
         .to_return(status: 200, body: '')
       endpoint = SiteInspector::Endpoint.new('http://example.com')
-      SiteInspector::Endpoint::Cookies.new(endpoint)
+      described_class.new(endpoint)
     end
 
     it 'knows when there are no cookies' do
-      expect(subject.cookies?).to eql(false)
-      expect(subject.all).to eql(nil)
+      expect(subject.cookies?).to be(false)
+      expect(subject.all).to be(nil)
     end
   end
 
@@ -19,28 +21,28 @@ describe SiteInspector::Endpoint::Cookies do
     subject do
       cookies = [
         CGI::Cookie.new(
-          'name'   => 'foo',
-          'value'  => 'bar',
+          'name' => 'foo',
+          'value' => 'bar',
           'domain' => 'example.com',
-          'path'   => '/'
+          'path' => '/'
         ),
         CGI::Cookie.new(
-          'name'   => 'foo2',
-          'value'  => 'bar2',
+          'name' => 'foo2',
+          'value' => 'bar2',
           'domain' => 'example.com',
-          'path'   => '/'
+          'path' => '/'
         )
       ].map(&:to_s)
 
       stub_request(:head, 'http://example.com/')
         .to_return(status: 200, body: '', headers: { 'set-cookie' => cookies })
       endpoint = SiteInspector::Endpoint.new('http://example.com')
-      SiteInspector::Endpoint::Cookies.new(endpoint)
+      described_class.new(endpoint)
     end
 
     it 'knows when there are cookies' do
-      expect(subject.cookies?).to eql(true)
-      expect(subject.all.count).to eql(2)
+      expect(subject.cookies?).to be(true)
+      expect(subject.all.count).to be(2)
     end
 
     it 'returns a cookie by name' do
@@ -48,7 +50,7 @@ describe SiteInspector::Endpoint::Cookies do
     end
 
     it "knows cookies aren't secure" do
-      expect(subject.secure?).to eql(false)
+      expect(subject.secure?).to be(false)
     end
   end
 
@@ -61,11 +63,11 @@ describe SiteInspector::Endpoint::Cookies do
       stub_request(:head, 'http://example.com/')
         .to_return(status: 200, body: '', headers: { 'set-cookie' => cookies })
       endpoint = SiteInspector::Endpoint.new('http://example.com')
-      SiteInspector::Endpoint::Cookies.new(endpoint)
+      described_class.new(endpoint)
     end
 
     it 'knows cookies are secure' do
-      expect(subject.secure?).to eql(true)
+      expect(subject.secure?).to be(true)
     end
   end
 end

data/spec/checks/site_inspector_endpoint_dns_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'dnsruby'
 
@@ -5,22 +7,22 @@ describe SiteInspector::Endpoint::Dns do
   subject do
     stub_request(:head, 'http://github.com/').to_return(status: 200)
     endpoint = SiteInspector::Endpoint.new('http://github.com')
-    SiteInspector::Endpoint::Dns.new(endpoint)
+    described_class.new(endpoint)
   end
 
   it 'inits the resolver' do
-    expect(SiteInspector::Endpoint::Dns.resolver.class).to eql(Dnsruby::Resolver)
+    expect(described_class.resolver.class).to eql(Dnsruby::Resolver)
   end
 
-  # Note: these tests makes external calls
+  # NOTE: these tests makes external calls
   context 'live tests' do
-    it 'it runs the query' do
+    it 'runs the query' do
       expect(subject.query).not_to be_empty
     end
 
     context 'resolv' do
       it 'returns the IP' do
-        expect(subject.ip).to include('192.30.252.')
+        expect(subject.ip).to include('140.82.')
       end
 
       it 'returns the hostname' do
@@ -33,21 +35,21 @@ describe SiteInspector::Endpoint::Dns do
     before do
       record = Dnsruby::RR.create type: 'A', address: '1.2.3.4', name: 'test'
       allow(subject).to receive(:records) { [record] }
-      allow(subject).to receive(:query) { [] }
+      allow(subject).to receive(:query).and_return([])
     end
 
     it 'returns the records' do
-      expect(subject.records.count).to eql(1)
+      expect(subject.records.count).to be(1)
       expect(subject.records.first.class).to eql(Dnsruby::RR::IN::A)
     end
 
     it 'knows if a record exists' do
-      expect(subject.has_record?('A')).to eql(true)
-      expect(subject.has_record?('CNAME')).to eql(false)
+      expect(subject.has_record?('A')).to be(true)
+      expect(subject.has_record?('CNAME')).to be(false)
     end
 
     it 'knows if a domain supports dnssec' do
-      expect(subject.dnssec?).to eql(false)
+      expect(subject.dnssec?).to be(false)
 
       # via https://github.com/alexdalitz/dnsruby/blob/master/test/tc_dnskey.rb
       input = 'example.com. 86400 IN DNSKEY 256 3 5 ( AQPSKmynfzW4kyBv015MUG2DeIQ3' \
@@ -61,25 +63,25 @@ describe SiteInspector::Endpoint::Dns do
       record = Dnsruby::RR.create input
       allow(subject).to receive(:records) { [record] }
 
-      expect(subject.dnssec?).to eql(true)
+      expect(subject.dnssec?).to be(true)
     end
 
     it 'knows if a domain supports ipv6' do
-      expect(subject.ipv6?).to eql(false)
+      expect(subject.ipv6?).to be(false)
 
       input = {
-        type:    'AAAA',
-        name:    'test',
+        type: 'AAAA',
+        name: 'test',
         address: '102:304:506:708:90a:b0c:d0e:ff10'
       }
       record = Dnsruby::RR.create input
       allow(subject).to receive(:records) { [record] }
 
-      expect(subject.ipv6?).to eql(true)
+      expect(subject.ipv6?).to be(true)
     end
 
     it "knows it's not a localhost address" do
-      expect(subject.localhost?).to eql(false)
+      expect(subject.localhost?).to be(false)
     end
 
     context 'hostname detection' do
@@ -87,38 +89,38 @@ describe SiteInspector::Endpoint::Dns do
         records = []
 
         records.push Dnsruby::RR.create(
-          type:       'CNAME',
+          type: 'CNAME',
           domainname: 'example.com',
-          name:       'example'
+          name: 'example'
         )
 
         records.push Dnsruby::RR.create(
-          type:       'CNAME',
+          type: 'CNAME',
           domainname: 'github.com',
-          name:       'github'
+          name: 'github'
         )
 
         allow(subject).to receive(:records) { records }
 
-        expect(subject.cnames.count).to eql(2)
+        expect(subject.cnames.count).to be(2)
         expect(subject.cnames.first.sld).to eql('example')
       end
 
       it "knows when a domain doesn't have a cdn" do
-        expect(subject.cdn?).to eql(false)
+        expect(subject.cdn?).to be(false)
       end
 
       it 'detects CDNs' do
         records = [Dnsruby::RR.create(
-          type:       'CNAME',
+          type: 'CNAME',
           domainname: 'foo.cloudfront.net',
-          name:       'example'
+          name: 'example'
         )]
         allow(subject).to receive(:records) { records }
 
-        expect(subject.send(:detect_by_hostname, 'cdn')).to eql(:cloudfront)
-        expect(subject.cdn).to eql(:cloudfront)
-        expect(subject.cdn?).to eql(true)
+        expect(subject.send(:detect_by_hostname, 'cdn')).to be(:cloudfront)
+        expect(subject.cdn).to be(:cloudfront)
+        expect(subject.cdn?).to be(true)
       end
 
       it 'builds that path to a data file' do
@@ -133,46 +135,46 @@ describe SiteInspector::Endpoint::Dns do
       end
 
       it "knows when a domain isn't cloud" do
-        expect(subject.cloud?).to eql(false)
+        expect(subject.cloud?).to be(false)
       end
 
       it 'detects cloud providers' do
         records = [Dnsruby::RR.create(
-          type:       'CNAME',
+          type: 'CNAME',
           domainname: 'foo.herokuapp.com',
-          name:       'example'
+          name: 'example'
         )]
         allow(subject).to receive(:records) { records }
 
-        expect(subject.send(:detect_by_hostname, 'cloud')).to eql(:heroku)
-        expect(subject.cloud_provider).to eql(:heroku)
-        expect(subject.cloud?).to eql(true)
+        expect(subject.send(:detect_by_hostname, 'cloud')).to be(:heroku)
+        expect(subject.cloud_provider).to be(:heroku)
+        expect(subject.cloud?).to be(true)
       end
 
       it "knows when a domain doesn't have google apps" do
-        expect(subject.google_apps?).to eql(false)
+        expect(subject.google_apps?).to be(false)
       end
 
       it 'knows when a domain is using google apps' do
         records = [Dnsruby::RR.create(
-          type:       'MX',
-          exchange:   'mx1.google.com',
-          name:       'example',
+          type: 'MX',
+          exchange: 'mx1.google.com',
+          name: 'example',
           preference: 10
         )]
         allow(subject).to receive(:records) { records }
-        expect(subject.google_apps?).to eql(true)
+        expect(subject.google_apps?).to be(true)
       end
     end
   end
 
   context 'localhost' do
     before do
-      allow(subject).to receive(:ip) { '127.0.0.1' }
+      allow(subject).to receive(:ip).and_return('127.0.0.1')
     end
 
     it "knows it's a localhost address" do
-      expect(subject.localhost?).to eql(true)
+      expect(subject.localhost?).to be(true)
     end
 
     it 'returns a LocalhostError' do