site-inspector 3.1.0 → 3.1.1

data/spec/checks/site_inspector_endpoint_dns_spec.rb

@@ -2,64 +2,61 @@ require 'spec_helper'
 require 'dnsruby'
 
 describe SiteInspector::Endpoint::Dns do
-
   subject do
-    stub_request(:head, "http://github.com/").to_return(:status => 200)
-    endpoint = SiteInspector::Endpoint.new("http://github.com")
+    stub_request(:head, 'http://github.com/').to_return(status: 200)
+    endpoint = SiteInspector::Endpoint.new('http://github.com')
     SiteInspector::Endpoint::Dns.new(endpoint)
   end
 
-  it "inits the resolver" do
+  it 'inits the resolver' do
     expect(SiteInspector::Endpoint::Dns.resolver.class).to eql(Dnsruby::Resolver)
   end
 
   # Note: these tests makes external calls
-  context "live tests" do
-    it "it runs the query" do
+  context 'live tests' do
+    it '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.")
+    context 'resolv' do
+      it 'returns the IP' do
+        expect(subject.ip).to include('192.30.252.')
       end
 
-      it "returns the hostname" do
-        expect(subject.hostname.sld).to eql("github")
-
+      it 'returns the hostname' do
+        expect(subject.hostname.sld).to eql('github')
       end
     end
   end
 
-  context "stubbed tests" do
-
+  context 'stubbed tests' do
     before do
-      record = Dnsruby::RR.create :type => "A", :address => "1.2.3.4", :name => "test"
+      record = Dnsruby::RR.create type: 'A', address: '1.2.3.4', name: 'test'
       allow(subject).to receive(:records) { [record] }
       allow(subject).to receive(:query) { [] }
     end
 
-    it "returns the records" do
+    it 'returns the records' do
       expect(subject.records.count).to eql(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)
+    it 'knows if a record exists' do
+      expect(subject.has_record?('A')).to eql(true)
+      expect(subject.has_record?('CNAME')).to eql(false)
     end
 
-    it "knows if a domain supports dnssec" do
+    it 'knows if a domain supports dnssec' do
       expect(subject.dnssec?).to eql(false)
 
       # via https://github.com/alexdalitz/dnsruby/blob/master/test/tc_dnskey.rb
-      input = "example.com. 86400 IN DNSKEY 256 3 5 ( AQPSKmynfzW4kyBv015MUG2DeIQ3" +
-        "Cbl+BBZH4b/0PY1kxkmvHjcZc8no" +
-        "kfzj31GajIQKY+5CptLr3buXA10h" +
-        "WqTkF7H6RfoRqXQeogmMHfpftf6z" +
-        "Mv1LyBUgia7za6ZEzOJBOztyvhjL" +
-        "742iU/TpPSEDhm2SNKLijfUppn1U" +
-        "aNvv4w==  )"
+      input = 'example.com. 86400 IN DNSKEY 256 3 5 ( AQPSKmynfzW4kyBv015MUG2DeIQ3' \
+        'Cbl+BBZH4b/0PY1kxkmvHjcZc8no' \
+        'kfzj31GajIQKY+5CptLr3buXA10h' \
+        'WqTkF7H6RfoRqXQeogmMHfpftf6z' \
+        'Mv1LyBUgia7za6ZEzOJBOztyvhjL' \
+        '742iU/TpPSEDhm2SNKLijfUppn1U' \
+        'aNvv4w==  )'
 
       record = Dnsruby::RR.create input
       allow(subject).to receive(:records) { [record] }
@@ -67,13 +64,13 @@ describe SiteInspector::Endpoint::Dns do
       expect(subject.dnssec?).to eql(true)
     end
 
-    it "knows if a domain supports ipv6" do
+    it 'knows if a domain supports ipv6' do
       expect(subject.ipv6?).to eql(false)
 
       input = {
-        :type => "AAAA",
-        :name => "test",
-        :address => '102:304:506:708:90a:b0c:d0e:ff10'
+        type:    'AAAA',
+        name:    'test',
+        address: '102:304:506:708:90a:b0c:d0e:ff10'
       }
       record = Dnsruby::RR.create input
       allow(subject).to receive(:records) { [record] }
@@ -85,69 +82,69 @@ describe SiteInspector::Endpoint::Dns do
       expect(subject.localhost?).to eql(false)
     end
 
-    context "hostname detection" do
-      it "lists cnames" do
+    context 'hostname detection' do
+      it 'lists cnames' do
         records = []
 
-        records.push Dnsruby::RR.create({
-          :type => "CNAME",
-          :domainname => "example.com",
-          :name => "example"
-        })
+        records.push Dnsruby::RR.create(
+          type:       'CNAME',
+          domainname: 'example.com',
+          name:       'example'
+        )
 
-        records.push Dnsruby::RR.create({
-          :type => "CNAME",
-          :domainname => "github.com",
-          :name => "github"
-        })
+        records.push Dnsruby::RR.create(
+          type:       'CNAME',
+          domainname: 'github.com',
+          name:       'github'
+        )
 
         allow(subject).to receive(:records) { records }
 
         expect(subject.cnames.count).to eql(2)
-        expect(subject.cnames.first.sld).to eql("example")
+        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)
       end
 
-      it "detects CDNs" do
-        records = [Dnsruby::RR.create({
-          :type => "CNAME",
-          :domainname => "foo.cloudfront.net",
-          :name => "example"
-        })]
+      it 'detects CDNs' do
+        records = [Dnsruby::RR.create(
+          type:       'CNAME',
+          domainname: 'foo.cloudfront.net',
+          name:       'example'
+        )]
         allow(subject).to receive(:records) { records }
 
-        expect(subject.send(:detect_by_hostname, "cdn")).to eql(:cloudfront)
+        expect(subject.send(:detect_by_hostname, 'cdn')).to eql(:cloudfront)
         expect(subject.cdn).to eql(:cloudfront)
         expect(subject.cdn?).to eql(true)
       end
 
-      it "builds that path to a data file" do
-        path = subject.send(:data_path, "foo")
-        expected = File.expand_path "../../lib/data/foo.yml", File.dirname(__FILE__)
+      it 'builds that path to a data file' do
+        path = subject.send(:data_path, 'foo')
+        expected = File.expand_path '../../lib/data/foo.yml', File.dirname(__FILE__)
         expect(path).to eql(expected)
       end
 
-      it "loads data files" do
-        data = subject.send(:load_data, "cdn")
-        expect(data.keys).to include("cloudfront")
+      it 'loads data files' do
+        data = subject.send(:load_data, 'cdn')
+        expect(data.keys).to include('cloudfront')
       end
 
       it "knows when a domain isn't cloud" do
         expect(subject.cloud?).to eql(false)
       end
 
-      it "detects cloud providers" do
-        records = [Dnsruby::RR.create({
-          :type => "CNAME",
-          :domainname => "foo.herokuapp.com",
-          :name => "example"
-        })]
+      it 'detects cloud providers' do
+        records = [Dnsruby::RR.create(
+          type:       'CNAME',
+          domainname: 'foo.herokuapp.com',
+          name:       'example'
+        )]
         allow(subject).to receive(:records) { records }
 
-        expect(subject.send(:detect_by_hostname, "cloud")).to eql(:heroku)
+        expect(subject.send(:detect_by_hostname, 'cloud')).to eql(:heroku)
         expect(subject.cloud_provider).to eql(:heroku)
         expect(subject.cloud?).to eql(true)
       end
@@ -156,32 +153,30 @@ describe SiteInspector::Endpoint::Dns do
         expect(subject.google_apps?).to eql(false)
       end
 
-      it "knows when a domain is using google apps" do
-        records = [Dnsruby::RR.create({
-          :type => "MX",
-          :exchange => "mx1.google.com",
-          :name => "example",
-          :preference => 10
-        })]
+      it 'knows when a domain is using google apps' do
+        records = [Dnsruby::RR.create(
+          type:       'MX',
+          exchange:   'mx1.google.com',
+          name:       'example',
+          preference: 10
+        )]
         allow(subject).to receive(:records) { records }
         expect(subject.google_apps?).to eql(true)
       end
     end
   end
 
-  context "localhost" do
-
+  context 'localhost' do
     before do
-      allow(subject).to receive(:ip) { "127.0.0.1" }
+      allow(subject).to receive(:ip) { '127.0.0.1' }
     end
 
     it "knows it's a localhost address" do
       expect(subject.localhost?).to eql(true)
     end
 
-    it "returns a LocalhostError" do
-      expect(subject.to_h).to eql({:error => SiteInspector::Endpoint::Dns::LocalhostError})
+    it 'returns a LocalhostError' do
+      expect(subject.to_h).to eql(error: SiteInspector::Endpoint::Dns::LocalhostError)
     end
-
   end
 end

data/spec/checks/site_inspector_endpoint_headers_spec.rb

@@ -1,11 +1,10 @@
 require 'spec_helper'
 
 describe SiteInspector::Endpoint::Headers do
-
   subject do
-    stub_request(:head, "http://example.com/").
-      to_return(:status => 200, :headers => { :foo => "bar" } )
-    endpoint = SiteInspector::Endpoint.new("http://example.com")
+    stub_request(:head, 'http://example.com/')
+      .to_return(status: 200, headers: { foo: 'bar' })
+    endpoint = SiteInspector::Endpoint.new('http://example.com')
     SiteInspector::Endpoint::Headers.new(endpoint)
   end
 
@@ -13,52 +12,52 @@ describe SiteInspector::Endpoint::Headers do
     allow(subject).to receive(:headers) { { header => value } }
   end
 
-  it "parses the headers" do
+  it 'parses the headers' do
     expect(subject.headers.count).to eql(1)
-    expect(subject.headers.keys).to include("foo")
+    expect(subject.headers.keys).to include('foo')
   end
 
-  it "returns a header" do
-    expect(subject["foo"]).to eql("bar")
-    expect(subject.headers["foo"]).to eql("bar")
+  it 'returns a header' do
+    expect(subject['foo']).to eql('bar')
+    expect(subject.headers['foo']).to eql('bar')
   end
 
-  it "knows the server" do
-    stub_header "server", "foo"
-    expect(subject.server).to eql("foo")
+  it 'knows the server' do
+    stub_header 'server', 'foo'
+    expect(subject.server).to eql('foo')
   end
 
-  it "knows if a server has an xss protection header" do
-    stub_header "x-xss-protection", "foo"
-    expect(subject.xss_protection).to eql("foo")
+  it 'knows if a server has an xss protection header' do
+    stub_header 'x-xss-protection', 'foo'
+    expect(subject.xss_protection).to eql('foo')
   end
 
-  it "validates xss-protection" do
-    stub_header "x-xss-protection", "foo"
+  it 'validates xss-protection' do
+    stub_header 'x-xss-protection', 'foo'
     expect(subject.xss_protection?).to eql(false)
 
-    stub_header "x-xss-protection", "1; mode=block"
+    stub_header 'x-xss-protection', '1; mode=block'
     expect(subject.xss_protection?).to eql(true)
   end
 
-  it "checks for clickjack proetection" do
+  it 'checks for clickjack proetection' do
     expect(subject.click_jacking_protection?).to eql(false)
-    stub_header "x-frame-options", "foo"
-    expect(subject.click_jacking_protection).to eql("foo")
+    stub_header 'x-frame-options', 'foo'
+    expect(subject.click_jacking_protection).to eql('foo')
     expect(subject.click_jacking_protection?).to eql(true)
   end
 
-  it "checks for CSP" do
+  it 'checks for CSP' do
     expect(subject.content_security_policy?).to eql(false)
-    stub_header "content-security-policy", "foo"
-    expect(subject.content_security_policy).to eql("foo")
+    stub_header 'content-security-policy', 'foo'
+    expect(subject.content_security_policy).to eql('foo')
     expect(subject.content_security_policy?).to eql(true)
   end
 
-  it "checks for strict-transport-security" do
+  it 'checks for strict-transport-security' do
     expect(subject.strict_transport_security?).to eql(false)
-    stub_header "strict-transport-security", "foo"
-    expect(subject.strict_transport_security).to eql("foo")
+    stub_header 'strict-transport-security', 'foo'
+    expect(subject.strict_transport_security).to eql('foo')
     expect(subject.strict_transport_security?).to eql(true)
   end
 end

data/spec/checks/site_inspector_endpoint_hsts_spec.rb

@@ -1,12 +1,11 @@
 require 'spec_helper'
 
 describe SiteInspector::Endpoint::Hsts do
-
   subject do
-    headers = { "strict-transport-security" => "max-age=31536000; includeSubDomains;" }
-    stub_request(:head, "http://example.com/").
-      to_return(:status => 200, :headers => headers )
-    endpoint = SiteInspector::Endpoint.new("http://example.com")
+    headers = { 'strict-transport-security' => 'max-age=31536000; includeSubDomains;' }
+    stub_request(:head, 'http://example.com/')
+      .to_return(status: 200, headers: headers)
+    endpoint = SiteInspector::Endpoint.new('http://example.com')
     SiteInspector::Endpoint::Hsts.new(endpoint)
   end
 
@@ -14,77 +13,77 @@ describe SiteInspector::Endpoint::Hsts do
     allow(subject).to receive(:header) { value }
   end
 
-  it "returns the headers" do
+  it 'returns the headers' do
     expect(subject.send(:headers).class).to eql(SiteInspector::Endpoint::Headers)
   end
 
-  it "returns the HSTS header" do
-    expect(subject.send(:header)).to eql("max-age=31536000; includeSubDomains;")
+  it 'returns the HSTS header' do
+    expect(subject.send(:header)).to eql('max-age=31536000; includeSubDomains;')
   end
 
-  it "it parses the directives" do
+  it 'it parses the directives' do
     expect(subject.send(:directives).count).to eql(2)
-    expect(subject.send(:directives).first).to eql("max-age=31536000")
-    expect(subject.send(:directives).last).to eql("includeSubDomains")
+    expect(subject.send(:directives).first).to eql('max-age=31536000')
+    expect(subject.send(:directives).last).to eql('includeSubDomains')
   end
 
-  it "parses pairs" do
+  it 'parses pairs' do
     expect(subject.send(:pairs).keys).to include(:"max-age")
-    expect(subject.send(:pairs)[:"max-age"]).to eql("31536000")
+    expect(subject.send(:pairs)[:"max-age"]).to eql('31536000')
   end
 
-  it "knows if the header is valid" do
+  it 'knows if the header is valid' do
     expect(subject.valid?).to eql(true)
 
-    allow(subject).to receive(:pairs) { ["fo o" => "bar"] }
+    allow(subject).to receive(:pairs) { ['fo o' => 'bar'] }
     expect(subject.valid?).to eql(false)
 
-    allow(subject).to receive(:pairs) { ["fo'o" => "bar"] }
+    allow(subject).to receive(:pairs) { ["fo'o" => 'bar'] }
     expect(subject.valid?).to eql(false)
   end
 
-  it "knows the max age" do
-    expect(subject.max_age).to eql(31536000)
+  it 'knows the max age' do
+    expect(subject.max_age).to eql(31_536_000)
   end
 
-  it "knows if subdomains are included" do
+  it 'knows if subdomains are included' do
     expect(subject.include_subdomains?).to eql(true)
-    allow(subject).to receive(:pairs) { {:foo => "bar"} }
+    allow(subject).to receive(:pairs) { { foo: 'bar' } }
     expect(subject.include_subdomains?).to eql(false)
   end
 
   it "knows if it's preloaded" do
     expect(subject.preload?).to eql(false)
-    allow(subject).to receive(:pairs) { {:preload => nil } }
+    allow(subject).to receive(:pairs) { { preload: nil } }
     expect(subject.preload?).to eql(true)
   end
 
   it "knows if it's enabled" do
     expect(subject.enabled?).to eql(true)
 
-    allow(subject).to receive(:pairs) { {:"max-age" => 0 } }
+    allow(subject).to receive(:pairs) { { "max-age": 0 } }
     expect(subject.preload?).to eql(false)
 
-    allow(subject).to receive(:pairs) { {:foo => "bar" } }
+    allow(subject).to receive(:pairs) { { foo: 'bar' } }
     expect(subject.preload?).to eql(false)
   end
 
   it "knows if it's preload ready" do
     expect(subject.preload_ready?).to eql(false)
 
-    pairs = {:"max-age" => 10886401, :preload => nil, :includesubdomains => nil }
+    pairs = { "max-age": 10_886_401, preload: nil, includesubdomains: nil }
     allow(subject).to receive(:pairs) { pairs }
     expect(subject.preload_ready?).to eql(true)
 
-    pairs = {:"max-age" => 10886401, :includesubdomains => nil }
+    pairs = { "max-age": 10_886_401, includesubdomains: nil }
     allow(subject).to receive(:pairs) { pairs }
     expect(subject.preload_ready?).to eql(false)
 
-    pairs = {:"max-age" => 10886401, :preload => nil, :includesubdomains => nil }
+    pairs = { "max-age": 10_886_401, preload: nil, includesubdomains: nil }
     allow(subject).to receive(:pairs) { pairs }
     expect(subject.preload_ready?).to eql(true)
 
-    pairs = {:"max-age" => 5, :preload => nil, :includesubdomains => nil }
+    pairs = { "max-age": 5, preload: nil, includesubdomains: nil }
     allow(subject).to receive(:pairs) { pairs }
     expect(subject.preload_ready?).to eql(false)
   end