rspec-webservice_matchers 4.9.0 → 4.12.2

data/lib/web_test/util.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+require 'faraday'
+require 'faraday_middleware'
+
+TIMEOUT_IN_SECONDS      = 5
+OPEN_TIMEOUT_IN_SECONDS = 5
+
+module WebTest
+  module Util
+    def self.error_message(errors)
+      return errors.message if errors.respond_to?(:message)
+
+      errors
+        .map(&:to_s)
+        .join('; ')
+        .capitalize
+    end
+
+    def self.status(url_or_domain_name, follow: false)
+      code = head(url_or_domain_name, follow: follow)[0]
+      return code if code != 405
+      get(url_or_domain_name, follow: follow)[0]
+    end
+
+    def self.head(url_or_domain_name, follow: false)
+      request(:head, url_or_domain_name, follow: follow)
+    end
+
+    def self.get(url_or_domain_name, follow: false)
+      request(:get, url_or_domain_name, follow: follow)
+    end
+
+    def self.request(method, url_or_domain_name, follow: false)
+      url = make_url(url_or_domain_name)
+      response = recheck_on_timeout { connection(follow: follow).send(method, url) }
+      [response.status, response.headers]
+    end
+
+    # @return true if the given page has status 200,
+    # and follow a few redirects if necessary.
+    def self.up?(url_or_domain_name)
+      url  = make_url(url_or_domain_name)
+      conn = connection(follow: true)
+      response = recheck_on_timeout { conn.head(url) }
+      response.status == 200
+    end
+
+    def self.valid_cert?(domain_name_or_url)
+      try_ssl_connection(domain_name_or_url)
+      true
+    rescue
+      # Not serving SSL, expired, or incorrect domain name in certificate
+      false
+    end
+
+    def self.try_ssl_connection(domain_name_or_url)
+      url = "https://#{remove_protocol(domain_name_or_url)}"
+      recheck_on_timeout { connection.head(url) }
+      true
+    end
+
+    # private
+
+    def self.connection(follow: false)
+      Faraday.new do |c|
+        c.options[:timeout] = TIMEOUT_IN_SECONDS
+        c.options[:open_timeout] = OPEN_TIMEOUT_IN_SECONDS
+        c.use(FaradayMiddleware::FollowRedirects, limit: 4) if follow
+        c.adapter :net_http
+      end
+    end
+
+    # Ensure that the given string is a URL,
+    # making it into one if necessary.
+    def self.make_url(url_or_domain_name)
+      if %r{^https?://} =~ url_or_domain_name
+        url_or_domain_name
+      else
+        "http://#{url_or_domain_name}"
+      end
+    end
+
+    # Return just the domain name portion of a URL if 
+    # it's simply of the form http://name.tld
+    def self.make_domain_name(url_or_domain_name)
+      if %r{^https?://(.+)} =~ url_or_domain_name
+        $1
+      else
+        url_or_domain_name
+      end
+    end
+
+    # Normalize the input: remove 'http(s)://' if it's there
+    def self.remove_protocol(domain_name_or_url)
+      %r{^https?://(?<name>.+)$} =~ domain_name_or_url
+      name || domain_name_or_url
+    end
+
+    def self.recheck_on_timeout
+      yield
+    rescue Faraday::TimeoutError
+      yield
+    end
+  end
+end

data/rspec-webservice_matchers.gemspec

@@ -1,6 +1,6 @@
-# coding: utf-8
 # frozen_string_literal: true
-lib = File.expand_path('../lib', __FILE__)
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'rspec/webservice_matchers/version'
 
@@ -8,27 +8,28 @@ Gem::Specification.new do |spec|
   spec.name        = 'rspec-webservice_matchers'
   spec.version     = RSpec::WebserviceMatchers::VERSION
   spec.authors     = ['Robb Shecter']
-  spec.email       = ['robb@weblaws.org']
+  spec.email       = ['robb@public.law']
   spec.description = 'Black-box web app configuration testing'
   spec.summary     = 'Black-box web app configuration testing'
   spec.homepage    = 'https://github.com/dogweather/rspec-webservice_matchers'
   spec.license     = 'MIT'
 
   spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
-  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(/^(test|spec|features)\//)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
-  spec.required_ruby_version = '>= 2.1.0'
+  spec.required_ruby_version = '>= 2.4.0'
 
-  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'bundler', '~> 2.0'
   spec.add_development_dependency 'pry'
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec'
   spec.add_development_dependency 'rspec_junit_formatter', '0.2.2'
   spec.add_development_dependency 'webmock'
 
-  spec.add_runtime_dependency 'rspec', '~> 3.0'
   spec.add_runtime_dependency 'faraday'
   spec.add_runtime_dependency 'faraday_middleware'
-  spec.add_runtime_dependency 'validated_object'
+  spec.add_runtime_dependency 'rspec-core', '~> 3.0'
+  spec.add_runtime_dependency 'rspec-expectations', '~> 3.0'
+  spec.add_runtime_dependency 'validated_object', '~> 1.1.0'
 end

data/spec/failure_matchers.rb

@@ -0,0 +1,16 @@
+module RSpec
+  # Matchers to help test RSpec matchers
+  module Matchers
+    def fail
+      raise_error(RSpec::Expectations::ExpectationNotMetError)
+    end
+
+    def fail_with(message)
+      raise_error(RSpec::Expectations::ExpectationNotMetError, message)
+    end
+
+    def fail_matching(regex)
+      raise_error(RSpec::Expectations::ExpectationNotMetError, regex)
+    end
+  end
+end

data/spec/rspec/webservice_matchers/{protcol_spec.rb → protocol_spec.rb}

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 require 'spec_helper'
 require 'rspec/webservice_matchers'
-require 'rspec/webservice_matchers/util'
+require 'web_test/util'
+
 
 describe 'be_status' do
   it 'can check 200 for successful resource requests' do
@@ -30,7 +31,7 @@ describe 'be_status' do
     }.to fail_matching(/404/)
   end
 
-  it 'succeeds even if the site times out on the first try' do
+  xit 'succeeds even if the site times out on the first try' do
     expect('http://www.timeout-once.com').to be_status 200
   end
 
@@ -50,7 +51,7 @@ describe 'be_up' do
   end
 
   it 'is available via a public API' do
-    status = RSpec::WebserviceMatchers::Util.up?('http://www.website.com/')
+    status = WebTest::Util.up?('http://www.website.com/')
     expect(status).to be true
   end
 
@@ -60,11 +61,7 @@ describe 'be_up' do
     }.to fail_matching(/^received status 404$/i)
   end
 
-  it 'succeeds even if the site times out on the first try' do
+  xit 'succeeds even if the site times out on the first try' do
     expect('http://www.timeout-once.com').to be_up
   end
-
-  it 'works on cars.com' do
-    expect('http://cars.com').to be_up
-  end
 end

data/spec/rspec/webservice_matchers/public_api_spec.rb

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
 require 'spec_helper'
-require 'rspec/webservice_matchers/util'
+require 'web_test/util'
+
 include RSpec::WebserviceMatchers
 
 describe '#up?' do
   it 'follows redirects when necessary' do
-    expect(Util.up?('perm-redirector.com')).to be_truthy
-    expect(Util.up?('temp-redirector.org')).to be_truthy
+    expect(WebTest::Util.up?('perm-redirector.com')).to be_truthy
+    expect(WebTest::Util.up?('temp-redirector.org')).to be_truthy
   end
 
-  it 'retries timeout errors once' do
-    expect(Util.up?('http://www.timeout-once.com')).to be_truthy
+  xit 'retries timeout errors once' do
+    expect(WebTest::Util.up?('http://www.timeout-once.com')).to be_truthy
   end
 end

data/spec/rspec/webservice_matchers/redirect_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'spec_helper'
 require 'rspec/webservice_matchers'
 
@@ -16,27 +17,27 @@ describe 'redirect_permanently_to' do
   end
 
   it 'gives a good error message for the wrong redirect type' do
-    expect {
+    expect do
       expect('temp-redirector.org').to redirect_permanently_to 'http://a-page.com/a/page.txt'
-    }.to fail_matching(/temporary/i)
+    end.to fail_matching(/temporary/i)
   end
 
   it 'gives a good error message for a redirect to the wrong location' do
-    expect {
+    expect do
       expect('perm-redirector.com').to redirect_permanently_to 'http://the-wrong-site.com/'
-    }.to fail_matching(/location/i)
+    end.to fail_matching(/location/i)
   end
 
   it 'gives a good error message for a non-redirect status' do
-    expect {
+    expect do
       expect('notfound.com').to redirect_permanently_to 'http://the-wrong-site.com/'
-    }.to fail_matching(/^not a redirect: received status 404$/i)
+    end.to fail_matching(/^not a redirect: received status 404$/i)
   end
 
   it 'gives a good error message when the hostname is bad' do
-    expect {
-      expect('asdhfjadhsfksd.com').to redirect_permanently_to 'http://the-wrong-site.com/'
-    }.to fail_matching(/not known/i)
+    expect do
+      expect('not-a-domain.com').to redirect_permanently_to 'http://the-wrong-site.com/'
+    end.to fail_matching(/not known/i)
   end
 end
 
@@ -54,26 +55,26 @@ describe 'redirect_temporarily_to' do
   end
 
   it 'gives a good error message for the wrong redirect type' do
-    expect {
+    expect do
       expect('perm-redirector.com').to redirect_temporarily_to 'www.website.com/'
-    }.to fail_matching(/permanent/i)
+    end.to fail_matching(/permanent/i)
   end
 
   it 'gives a good error message for a redirect to the wrong location' do
-    expect {
+    expect do
       expect('temp-307-redirector.net').to redirect_temporarily_to 'www.nowhere.com'
-    }.to fail_matching(/location/i)
+    end.to fail_matching(/location/i)
   end
 
   it 'gives a good error message for a non-redirect status' do
-    expect {
+    expect do
       expect('notfound.com').to redirect_temporarily_to 'www.nowhere.com'
-    }.to fail_matching(/^not a redirect: received status 404$/i)
+    end.to fail_matching(/^not a redirect: received status 404$/i)
   end
 
   it 'gives a good error message when the hostname is bad' do
-    expect {
-      expect('234678234687234.com').to redirect_temporarily_to 'www.nowhere.com'
-    }.to fail_matching(/not known/i)
+    expect do
+      expect('not-a-domain.com').to redirect_temporarily_to 'www.nowhere.com'
+    end.to fail_matching(/not known/i)
   end
 end

data/spec/rspec/webservice_matchers/ssl_spec.rb

@@ -1,62 +1,87 @@
 # frozen_string_literal: true
+
 require 'spec_helper'
 require 'rspec/webservice_matchers'
 
-describe 'have_a_valid_cert matcher' do
-  it 'passes when SSL is properly configured' do
-    # EFF created the HTTPS Everywhere movement
-    # TODO: set up a test server for this. (?)
-    expect('www.eff.org').to have_a_valid_cert
-  end
+describe 'SSL tests' do
+  before(:each) { WebMock.allow_net_connect! }
+  after(:each)  { WebMock.disable_net_connect! }
 
-  it 'fails if the server is not serving SSL at all' do
-    expect {
-      expect('www.psu.edu').to have_a_valid_cert
-    }.to fail_matching(/443/)
-  end
+  describe 'have_a_valid_cert matcher' do
+    it 'passes when SSL is properly configured' do
+      # EFF created the HTTPS Everywhere movement
+      # TODO: set up a test server for this. (?)
+      expect('www.eff.org').to have_a_valid_cert
+    end
 
-  it 'provides a relevant error message' do
-    expect {
-      expect('www.psu.edu').to have_a_valid_cert
-    }.to fail_matching(/(unreachable)|(no route to host)|(connection refused)/i)
-  end
+    it 'fails if the server is not serving SSL at all' do
+      expect do
+        expect('neverssl.com').to have_a_valid_cert
+      end.to fail_matching(/Unable to verify/)
+    end
 
-  it "provides a relevant error message when the domain name doesn't exist" do
-    expect {
-      expect('sdfgkljhsdfghjkhsdfgj.edu').to have_a_valid_cert
-    }.to fail_matching(/not known/i)
-  end
+    it 'provides a relevant error message' do
+      expect do
+        expect('neverssl.com').to have_a_valid_cert
+      end.to fail_matching(/(unreachable)|(no route to host)|(connection refused)|(redirect was detected)/i)
+    end
 
-  it "provides a good error message when it's a redirect" do
-    expect {
-      # Can't figure out how to do this with WebMock.
-      expect('bloc.io').to have_a_valid_cert
-    }.to fail_matching(/redirect/i)
-  end
+    xit "provides a relevant error message when the domain name doesn't exist" do
+      expect do
+        expect('sdfgkljhsdfghjkhsdfgj.edu').to have_a_valid_cert
+      end.to fail_matching(/not known/i)
+    end
 
-  # TODO: Find a good way to test this.
-  # it 'provides a good error message if the request times out' do
-  #   expect {
-  #     expect('www.myapp.com').to have_a_valid_cert
-  #   }.to fail_matching(/(timeout)|(execution expired)/)
-  # end
-end
+    xit "provides a good error message when it's a redirect" do
+      expect do
+        # Can't figure out how to do this with WebMock.
+        expect('bloc.io').to have_a_valid_cert
+      end.to fail_matching(/redirect/i)
+    end
 
-# See https://www.eff.org/https-everywhere
-describe 'enforce_https_everywhere' do
-  it 'passes when http requests are redirected to valid https urls' do
-    expect('eff.org').to enforce_https_everywhere
+    # TODO: Find a good way to test this.
+    xit 'provides a good error message if the request times out' do
+      expect {
+        expect('www.myapp.com').to have_a_valid_cert
+      }.to fail_matching(/(timeout)|(execution expired)/)
+    end
   end
 
-  it 'provides a relevant error message' do
-    expect {
-      expect('www.psu.edu').to enforce_https_everywhere
-    }.to fail_matching(/200/)
-  end
+  # See https://www.eff.org/https-everywhere
+  describe 'enforce_https_everywhere' do
+    it 'passes when http requests are redirected to valid https urls' do
+      expect('www.eff.org').to enforce_https_everywhere
+    end
+
+    it 'passes when given an https url' do
+      expect('https://www.eff.org').to enforce_https_everywhere
+    end
+
+    it 'passes when given an http url' do
+      expect('http://www.eff.org').to enforce_https_everywhere
+    end
+
+    it 'provides a relevant error code' do
+      expect do
+        expect('neverssl.com').to enforce_https_everywhere
+      end.to fail_matching(/200/)
+    end
+
+    it 'provides a relevant error code with https url' do
+      expect do
+        expect('https://neverssl.com').to enforce_https_everywhere
+      end.to fail_matching(/200/)
+    end
 
-  it "provides a relevant error message when the domain name doesn't exist" do
-    expect {
-      expect('asdhfjkalsdhfjklasdfhjkasdhfl.com').to enforce_https_everywhere
-    }.to fail_matching(/connection failed/i)
+    it 'provides a relevant error code with http url' do
+      expect do
+        expect('http://neverssl.com').to enforce_https_everywhere
+      end.to fail_matching(/200/)
+    end
+    # it "provides a relevant error message when the domain name doesn't exist" do
+    #   expect do
+    #     expect('asdhfjkalsdhfjklasdfhjkasdhfl.com').to enforce_https_everywhere
+    #   end.to fail_matching(/connection failed/i)
+    # end
   end
 end

data/spec/spec_helper.rb

@@ -1,56 +1,5 @@
 # frozen_string_literal: true
-require 'webmock/rspec'
+require 'web_mock_config'
+require 'failure_matchers'
 
-RSpec.configure do |config|
-  config.before(:each) do
-    WebMock.stub_request :any, 'http://a-page.com/a/page.txt'
-    WebMock.stub_request :any, 'www.website.com'
-    WebMock.stub_request(:any, /notfound.com/).to_return(status: 404)
-    WebMock.stub_request(:any, 'outoforder.com').to_return(status: 503)
-
-    # A host which doesn't support HEAD
-    WebMock.stub_request(:head, 'appengine.com').to_return(status: 405)
-    WebMock.stub_request(:get,  'appengine.com').to_return(status: 200)
-
-    WebMock.stub_request(:any, 'perm-redirector.com')
-           .to_return(status: 301, headers: { Location: 'http://www.website.com/' })
-
-    WebMock.stub_request(:any, 'temp-redirector.org')
-           .to_return(status: 302, headers: { Location: 'http://a-page.com/a/page.txt' })
-
-    WebMock.stub_request(:any, 'temp-307-redirector.net')
-           .to_return(status: 307, headers: { Location: 'http://a-page.com/a/page.txt' })
-
-    # Timeout scenarios
-    WebMock.stub_request(:any, 'www.timeout.com').to_timeout
-    WebMock.stub_request(:any, 'www.timeout-once.com').to_timeout.then.to_return(body: 'abc')
-
-    # Insights API
-    key = ENV['WEBSERVICE_MATCHER_INSIGHTS_KEY']
-    WebMock.stub_request(:get, "https://www.googleapis.com/pagespeedonline/v2/runPagespeed?key=#{key}&screenshot=false&url=http://nonstop.qa")
-           .with(headers: { 'Accept' => '*/*', 'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent' => 'Faraday v0.9.2' })
-           .to_return(
-             status: 200,
-             body: IO.read('spec/fixtures/pagespeed.json'),
-             headers: {})
-
-    WebMock.allow_net_connect!
-  end
-end
-
-module RSpec
-  # Matchers to help test RSpec matchers
-  module Matchers
-    def fail
-      raise_error(RSpec::Expectations::ExpectationNotMetError)
-    end
-
-    def fail_with(message)
-      raise_error(RSpec::Expectations::ExpectationNotMetError, message)
-    end
-
-    def fail_matching(regex)
-      raise_error(RSpec::Expectations::ExpectationNotMetError, regex)
-    end
-  end
-end
+SAMPLE_PAGESPEED_JSON_RESPONSE = 'spec/fixtures/pagespeed.json'