be_valid_asset 1.2.3 → 1.3.0

data/spec/be_valid_asset/be_valid_feed_spec.rb

@@ -4,61 +4,61 @@ unless defined?(SpecFailed)
   SpecFailed = RSpec::Expectations::ExpectationNotMetError
 end
 
-describe 'be_valid_feed' do
+RSpec.describe 'be_valid_feed' do
 
   describe "without caching" do
     it "should validate a valid string" do
       feed = get_file('valid_feed.xml')
-      feed.should be_valid_feed
+      expect(feed).to be_valid_feed
     end
 
     it "should work when called as be_valid_rss" do
       feed = get_file('valid_feed.xml')
-      feed.should be_valid_rss
+      expect(feed).to be_valid_rss
     end
 
     it "should work when called as be_valid_atom" do
       feed = get_file('valid_feed.xml')
-      feed.should be_valid_atom
+      expect(feed).to be_valid_atom
     end
 
     it "should validate a valid response" do
       response = MockResponse.new(get_file('valid_feed.xml'))
-      response.should be_valid_feed
+      expect(response).to be_valid_feed
     end
 
     it "should validate if body is not a string but can be converted to valid string" do
-      response = MockResponse.new(stub("Feed", :to_s => get_file('valid_feed.xml')))
-      response.should be_valid_feed
+      response = MockResponse.new(double("Feed", :to_s => get_file('valid_feed.xml')))
+      expect(response).to be_valid_feed
     end
 
     it "should not validate an invalid string" do
       feed = get_file('invalid_feed.xml')
-      lambda {
-        feed.should be_valid_feed
-      }.should raise_error(SpecFailed) { |e|
-        e.message.should match(/expected feed to be valid, but validation produced these errors/)
-        e.message.should match(/Invalid feed: line 12: Invalid email address/)
+      expect {
+        expect(feed).to be_valid_feed
+      }.to raise_error(SpecFailed) { |e|
+        expect(e.message).to match(/expected feed to be valid, but validation produced these errors/)
+        expect(e.message).to match(/Invalid feed: line 12: Invalid email address/)
       }
     end
 
     it "should not validate an invalid response" do
       response = MockResponse.new(get_file('invalid_feed.xml'))
-      lambda {
-        response.should be_valid_feed
-      }.should raise_error(SpecFailed) { |e|
-        e.message.should match(/expected feed to be valid, but validation produced these errors/)
-        e.message.should match(/Invalid feed: line 12: Invalid email address/)
+      expect {
+        expect(response).to be_valid_feed
+      }.to raise_error(SpecFailed) { |e|
+        expect(e.message).to match(/expected feed to be valid, but validation produced these errors/)
+        expect(e.message).to match(/Invalid feed: line 12: Invalid email address/)
       }
     end
 
     it "should display invalid content when requested" do
       BeValidAsset::Configuration.display_invalid_content = true
       feed = get_file('invalid_feed.xml')
-      lambda {
-        feed.should be_valid_feed
-      }.should raise_error(SpecFailed) { |e|
-        e.message.should match(%r{<link>http://site.example.com/articles/article-1-title</link>})
+      expect {
+        expect(feed).to be_valid_feed
+      }.to raise_error(SpecFailed) { |e|
+        expect(e.message).to match(%r{<link>http://site.example.com/articles/article-1-title</link>})
       }
       BeValidAsset::Configuration.display_invalid_content = false
     end
@@ -68,21 +68,21 @@ describe 'be_valid_feed' do
 
       r = Net::HTTPServiceUnavailable.new('1.1', 503, 'Service Unavailable')
       h = Net::HTTP.new(BeValidAsset::Configuration.feed_validator_host)
-      h.stub!(:post).and_return(r)
-      Net::HTTP.stub!(:start).and_return(h)
+      allow(h).to receive(:post).and_return(r)
+      allow(Net::HTTP).to receive(:start).and_return(h)
 
-      lambda {
-        feed.should be_valid_feed
-      }.should raise_error
+      expect {
+        expect(feed).to be_valid_feed
+      }.to raise_error
     end
 
     it "should mark test as pending if ENV['NONET'] is true" do
       ENV['NONET'] = 'true'
 
       feed = get_file('valid_feed.xml')
-      lambda {
-        feed.should be_valid_feed
-      }.should raise_error(RSpec::Core::Pending::PendingDeclaredInExample)
+      expect {
+        expect(feed).to be_valid_feed
+      }.to raise_error(BeValidAsset::DontRunValidAssetSpecs)
 
       ENV.delete('NONET')
     end
@@ -100,40 +100,40 @@ describe 'be_valid_feed' do
     it "should validate valid feed and cache the response" do
       feed = get_file('valid_feed.xml')
       count = Dir.glob(BeValidAsset::Configuration.cache_path + '/*').size
-      feed.should be_valid_feed
-      Dir.glob(BeValidAsset::Configuration.cache_path + '/*').size.should eql(count + 1)
+      expect(feed).to be_valid_feed
+      expect(Dir.glob(BeValidAsset::Configuration.cache_path + '/*').size).to eql(count + 1)
     end
 
     it "should validate valid feed using the cached response" do
       feed = get_file('valid_feed.xml')
-      feed.should be_valid_feed
+      expect(feed).to be_valid_feed
 
-      Net::HTTP.should_not_receive(:start)
-      feed.should be_valid_feed
+      expect(Net::HTTP).not_to receive(:start)
+      expect(feed).to be_valid_feed
     end
 
     it "should not validate invalid feed, but still cache the response" do
       feed = get_file('invalid_feed.xml')
       count = Dir.glob(BeValidAsset::Configuration.cache_path + '/*').size
-      lambda {
-        feed.should be_valid_feed
-      }.should raise_error(SpecFailed) { |e|
-        e.message.should match(/expected feed to be valid, but validation produced these errors/)
-        e.message.should match(/Invalid feed: line 12: Invalid email address/)
+      expect {
+        expect(feed).to be_valid_feed
+      }.to raise_error(SpecFailed) { |e|
+        expect(e.message).to match(/expected feed to be valid, but validation produced these errors/)
+        expect(e.message).to match(/Invalid feed: line 12: Invalid email address/)
       }
-      Dir.glob(BeValidAsset::Configuration.cache_path + '/*').size.should eql(count + 1)
+      expect(Dir.glob(BeValidAsset::Configuration.cache_path + '/*').size).to eql(count + 1)
     end
 
     it "should not validate invalid feed, but use the cached response" do
       feed = get_file('invalid_feed.xml')
-      feed.should_not be_valid_feed
-
-      Net::HTTP.should_not_receive(:start)
-      lambda {
-        feed.should be_valid_feed
-      }.should raise_error(SpecFailed) { |e|
-        e.message.should match(/expected feed to be valid, but validation produced these errors/)
-        e.message.should match(/Invalid feed: line 12: Invalid email address/)
+      expect(feed).not_to be_valid_feed
+
+      expect(Net::HTTP).not_to receive(:start)
+      expect {
+        expect(feed).to be_valid_feed
+      }.to raise_error(SpecFailed) { |e|
+        expect(e.message).to match(/expected feed to be valid, but validation produced these errors/)
+        expect(e.message).to match(/Invalid feed: line 12: Invalid email address/)
       }
     end
 
@@ -143,23 +143,23 @@ describe 'be_valid_feed' do
 
       r = Net::HTTPServiceUnavailable.new('1.1', 503, 'Service Unavailable')
       h = Net::HTTP.new(BeValidAsset::Configuration.feed_validator_host)
-      h.stub!(:post).and_return(r)
-      Net::HTTP.stub!(:start).and_return(h)
+      allow(h).to receive(:post).and_return(r)
+      allow(Net::HTTP).to receive(:start).and_return(h)
 
-      lambda {
-        feed.should be_valid_feed
-      }.should raise_error
-      Dir.glob(BeValidAsset::Configuration.cache_path + '/*').size.should eql(count)
+      expect {
+        expect(feed).to be_valid_feed
+      }.to raise_error
+      expect(Dir.glob(BeValidAsset::Configuration.cache_path + '/*').size).to eql(count)
     end
 
     it "should use the cached result (if available) when network tests disabled" do
       feed = get_file('valid_feed.xml')
-      feed.should be_valid_feed
+      expect(feed).to be_valid_feed
 
       ENV['NONET'] = 'true'
 
-      Net::HTTP.should_not_receive(:start)
-      feed.should be_valid_feed
+      expect(Net::HTTP).not_to receive(:start)
+      expect(feed).to be_valid_feed
 
       ENV.delete('NONET')
     end
@@ -168,9 +168,9 @@ describe 'be_valid_feed' do
       ENV['NONET'] = 'true'
 
       feed = get_file('valid_feed.xml')
-      lambda {
-        feed.should be_valid_feed
-      }.should raise_error(RSpec::Core::Pending::PendingDeclaredInExample)
+      expect {
+        expect(feed).to be_valid_feed
+      }.to raise_error(BeValidAsset::DontRunValidAssetSpecs)
 
       ENV.delete('NONET')
     end

data/spec/be_valid_asset/be_valid_markup_spec.rb

@@ -4,72 +4,72 @@ unless defined?(SpecFailed)
   SpecFailed = RSpec::Expectations::ExpectationNotMetError
 end
 
-describe 'be_valid_markup' do
+RSpec.describe 'be_valid_markup' do
 
   describe "without caching" do
     it "should validate a valid string" do
       html = get_file('valid.html')
-      html.should be_valid_markup
+      expect(html).to be_valid_markup
     end
 
     it "should validate a valid xhtml response" do
       response = MockResponse.new(get_file('valid.html'))
-      response.should be_valid_markup
+      expect(response).to be_valid_markup
     end
-    
+
     it "should validate a valid html5 response" do
       response = MockResponse.new(get_file('valid.html5'))
-      response.should be_valid_markup
+      expect(response).to be_valid_markup
     end
 
     it "should validate a valid html5 response when only 'source' is available" do
-      response = mock(:source => get_file('valid.html5'))
-      response.should be_valid_markup
+      response = double(:source => get_file('valid.html5'))
+      expect(response).to be_valid_markup
     end
-    
+
     it "should validate a valid html5 response when only 'body' is available" do
-      response = mock(:body => get_file('valid.html5'))
-      response.should be_valid_markup
+      response = double(:body => get_file('valid.html5'))
+      expect(response).to be_valid_markup
     end
 
     it "should validate if body is not a string but can be converted to valid string" do
-      response = MockResponse.new(stub("XHTML", :to_s => get_file('valid.html')))
-      response.should be_valid_markup
+      response = MockResponse.new(double("XHTML", :to_s => get_file('valid.html')))
+      expect(response).to be_valid_markup
     end
 
     it "should validate a valid fragment" do
-      "<p>This is a Fragment</p>".should be_valid_markup_fragment
+      expect("<p>This is a Fragment</p>").to be_valid_markup_fragment
     end
 
     it "should not validate an invalid string" do
       html = get_file('invalid.html')
-      lambda {
-        html.should be_valid_markup
-      }.should raise_error(SpecFailed) { |e|
-        e.message.should match(/expected markup to be valid, but validation produced these errors/)
-        e.message.should match(/Invalid markup: line 12: end tag for "b" omitted, but OMITTAG NO was specified/)
-        e.message.should match(/Invalid markup: line 12: end tag for element "b" which is not open/)
+      expect {
+        expect(html).to be_valid_markup
+      }.to raise_error(SpecFailed) { |e|
+        expect(e.message).to match(/expected markup to be valid, but validation produced these errors/)
+        expect(e.message).to match(/Invalid markup: line 12: end tag for "b" omitted, but OMITTAG NO was specified/)
+        expect(e.message).to match(/Invalid markup: line 12: end tag for element "b" which is not open/)
       }
     end
 
     it "should not validate an invalid response" do
       response = MockResponse.new(get_file('invalid.html'))
-      lambda {
-        response.should be_valid_markup
-      }.should raise_error(SpecFailed) { |e|
-        e.message.should match(/expected markup to be valid, but validation produced these errors/)
-        e.message.should match(/Invalid markup: line 12: end tag for "b" omitted, but OMITTAG NO was specified/)
-        e.message.should match(/Invalid markup: line 12: end tag for element "b" which is not open/)
+      expect {
+        expect(response).to be_valid_markup
+      }.to raise_error(SpecFailed) { |e|
+        expect(e.message).to match(/expected markup to be valid, but validation produced these errors/)
+        expect(e.message).to match(/Invalid markup: line 12: end tag for "b" omitted, but OMITTAG NO was specified/)
+        expect(e.message).to match(/Invalid markup: line 12: end tag for element "b" which is not open/)
       }
     end
 
     it "should display invalid content when requested" do
       BeValidAsset::Configuration.display_invalid_content = true
       html = get_file('invalid.html')
-      lambda {
-        html.should be_valid_markup
-      }.should raise_error(SpecFailed) { |e|
-        e.message.should match(/<p><b>This is an example invalid html file<\/p><\/b>/)
+      expect {
+        expect(html).to be_valid_markup
+      }.to raise_error(SpecFailed) { |e|
+        expect(e.message).to match(/<p><b>This is an example invalid html file<\/p><\/b>/)
       }
       BeValidAsset::Configuration.display_invalid_content = false
     end
@@ -85,67 +85,67 @@ describe 'be_valid_markup' do
 
       it "should display invalid lines when requested" do
         html = get_file('invalid.html')
-        lambda do
-          html.should be_valid_markup
-        end.should raise_error(SpecFailed) { |e|
-          e.message.should match(/expected markup to be valid, but validation produced these errors/)
-          e.message.should_not match(/0009  :/)
-          e.message.should match(/0010  :/)
-          e.message.should match(/0011  :/)
-          e.message.should match(/0012>>:/)
-          e.message.should match(/0013  :/)
-          e.message.should match(/0014  :/)
-          e.message.should_not match(/0015  :/)
+        expect do
+          expect(html).to be_valid_markup
+        end.to raise_error(SpecFailed) { |e|
+          expect(e.message).to match(/expected markup to be valid, but validation produced these errors/)
+          expect(e.message).not_to match(/0009  :/)
+          expect(e.message).to match(/0010  :/)
+          expect(e.message).to match(/0011  :/)
+          expect(e.message).to match(/0012>>:/)
+          expect(e.message).to match(/0013  :/)
+          expect(e.message).to match(/0014  :/)
+          expect(e.message).not_to match(/0015  :/)
         }
       end
 
       it "should display specified invalid lines window when requested" do
         BeValidAsset::Configuration.display_invalid_lines_count = 3
         html = get_file('invalid.html')
-        lambda do
-          html.should be_valid_markup
-        end.should raise_error(SpecFailed) { |e|
-          e.message.should match(/expected markup to be valid, but validation produced these errors/)
-          e.message.should_not match(/0010  :/)
-          e.message.should match(/0011  :/)
-          e.message.should match(/0012>>:/)
-          e.message.should match(/0013  :/)
-          e.message.should_not match(/0014  :/)
+        expect do
+          expect(html).to be_valid_markup
+        end.to raise_error(SpecFailed) { |e|
+          expect(e.message).to match(/expected markup to be valid, but validation produced these errors/)
+          expect(e.message).not_to match(/0010  :/)
+          expect(e.message).to match(/0011  :/)
+          expect(e.message).to match(/0012>>:/)
+          expect(e.message).to match(/0013  :/)
+          expect(e.message).not_to match(/0014  :/)
         }
       end
 
       it "should not underrun the beginning of the source" do
         BeValidAsset::Configuration.display_invalid_lines_count = 7
         html = get_file('invalid2.html')
-        lambda do
-          html.should be_valid_markup
-        end.should raise_error(SpecFailed) { |e|
-          e.message.should match(/expected markup to be valid, but validation produced these errors/)
-          e.message.should_not match(/0000  :/)
-          e.message.should match(/0001  :/)
-          e.message.should match(/0003>>:/)
+        expect do
+          expect(html).to be_valid_markup
+        end.to raise_error(SpecFailed) { |e|
+          expect(e.message).to match(/expected markup to be valid, but validation produced these errors/)
+          expect(e.message).not_to match(/0000  :/)
+          expect(e.message).to match(/0001  :/)
+          expect(e.message).to match(/0003>>:/)
         }
       end
 
       it "should not overrun the end of the source" do
         BeValidAsset::Configuration.display_invalid_lines_count = 11
         html = get_file('invalid.html')
-        lambda do
-          html.should be_valid_markup
-        end.should raise_error(SpecFailed) { |e|
-          e.message.should match(/expected markup to be valid, but validation produced these errors/)
-          e.message.should match(/0012>>:/)
-          e.message.should match(/0015  :/)
-          e.message.should_not match(/0016  :/)
+        expect do
+          expect(html).to be_valid_markup
+        end.to raise_error(SpecFailed) { |e|
+          expect(e.message).to match(/expected markup to be valid, but validation produced these errors/)
+          expect(e.message).to match(/0012>>:/)
+          expect(e.message).to match(/0015  :/)
+          expect(e.message).not_to match(/0016  :/)
         }
       end
     end
 
     it "should fail when passed a response with a blank body" do
       response = MockResponse.new('')
-      lambda {
-        response.should be_valid_markup
-      }.should raise_error(SpecFailed)
+      expect {
+        expect(response).to be_valid_markup
+      }.to raise_error(SpecFailed)
     end
 
     it "should fail unless resposne is HTTP OK" do
@@ -153,21 +153,21 @@ describe 'be_valid_markup' do
 
       r = Net::HTTPServiceUnavailable.new('1.1', 503, 'Service Unavailable')
       h = Net::HTTP.new(BeValidAsset::Configuration.markup_validator_host)
-      h.stub!(:post2).and_return(r)
-      Net::HTTP.stub!(:start).and_return(h)
+      allow(h).to receive(:post2).and_return(r)
+      allow(Net::HTTP).to receive(:start).and_return(h)
 
-      lambda {
-        html.should be_valid_markup
-      }.should raise_error
+      expect {
+        expect(html).to be_valid_markup
+      }.to raise_error
     end
 
     it "should mark test as pending if network tests are disabled" do
       ENV['NONET'] = 'true'
 
       html = get_file('valid.html')
-      lambda {
-        html.should be_valid_markup
-      }.should raise_error(RSpec::Core::Pending::PendingDeclaredInExample)
+      expect {
+        expect(html).to be_valid_markup
+      }.to raise_error(BeValidAsset::DontRunValidAssetSpecs)
 
       ENV.delete('NONET')
     end
@@ -185,42 +185,42 @@ describe 'be_valid_markup' do
     it "should validate a valid string and cache the response" do
       html = get_file('valid.html')
       count = Dir.glob(BeValidAsset::Configuration.cache_path + '/*').size
-      html.should be_valid_markup
-      Dir.glob(BeValidAsset::Configuration.cache_path + '/*').size.should eql(count + 1)
+      expect(html).to be_valid_markup
+      expect(Dir.glob(BeValidAsset::Configuration.cache_path + '/*').size).to eql(count + 1)
     end
 
     it "should validate a valid string using the cached response" do
       html = get_file('valid.html')
-      html.should be_valid_markup
+      expect(html).to be_valid_markup
 
-      Net::HTTP.should_not_receive(:start)
-      html.should be_valid_markup
+      expect(Net::HTTP).not_to receive(:start)
+      expect(html).to be_valid_markup
     end
 
     it "should not validate an invalid response, but still cache the response" do
       response = MockResponse.new(get_file('invalid.html'))
       count = Dir.glob(BeValidAsset::Configuration.cache_path + '/*').size
-      lambda {
-        response.should be_valid_markup
-      }.should raise_error(SpecFailed) { |e|
-        e.message.should match(/expected markup to be valid, but validation produced these errors/)
-        e.message.should match(/Invalid markup: line 12: end tag for "b" omitted, but OMITTAG NO was specified/)
-        e.message.should match(/Invalid markup: line 12: end tag for element "b" which is not open/)
+      expect {
+        expect(response).to be_valid_markup
+      }.to raise_error(SpecFailed) { |e|
+        expect(e.message).to match(/expected markup to be valid, but validation produced these errors/)
+        expect(e.message).to match(/Invalid markup: line 12: end tag for "b" omitted, but OMITTAG NO was specified/)
+        expect(e.message).to match(/Invalid markup: line 12: end tag for element "b" which is not open/)
       }
-      Dir.glob(BeValidAsset::Configuration.cache_path + '/*').size.should eql(count + 1)
+      expect(Dir.glob(BeValidAsset::Configuration.cache_path + '/*').size).to eql(count + 1)
     end
 
     it "should not validate an invalid response, but use the cached response" do
       response = MockResponse.new(get_file('invalid.html'))
-      response.should_not be_valid_markup
-
-      Net::HTTP.should_not_receive(:start)
-      lambda {
-        response.should be_valid_markup
-      }.should raise_error(SpecFailed) { |e|
-        e.message.should match(/expected markup to be valid, but validation produced these errors/)
-        e.message.should match(/Invalid markup: line 12: end tag for "b" omitted, but OMITTAG NO was specified/)
-        e.message.should match(/Invalid markup: line 12: end tag for element "b" which is not open/)
+      expect(response).not_to be_valid_markup
+
+      expect(Net::HTTP).not_to receive(:start)
+      expect {
+        expect(response).to be_valid_markup
+      }.to raise_error(SpecFailed) { |e|
+        expect(e.message).to match(/expected markup to be valid, but validation produced these errors/)
+        expect(e.message).to match(/Invalid markup: line 12: end tag for "b" omitted, but OMITTAG NO was specified/)
+        expect(e.message).to match(/Invalid markup: line 12: end tag for element "b" which is not open/)
       }
     end
 
@@ -230,23 +230,23 @@ describe 'be_valid_markup' do
 
       r = Net::HTTPServiceUnavailable.new('1.1', 503, 'Service Unavailable')
       h = Net::HTTP.new(BeValidAsset::Configuration.markup_validator_host)
-      h.stub!(:post2).and_return(r)
-      Net::HTTP.stub!(:start).and_return(h)
+      allow(h).to receive(:post2).and_return(r)
+      allow(Net::HTTP).to receive(:start).and_return(h)
 
-      lambda {
-        html.should be_valid_markup
-      }.should raise_error
-      Dir.glob(BeValidAsset::Configuration.cache_path + '/*').size.should eql(count)
+      expect {
+        expect(html).to be_valid_markup
+      }.to raise_error
+      expect(Dir.glob(BeValidAsset::Configuration.cache_path + '/*').size).to eql(count)
     end
 
     it "should use the cached result (if available) when network tests disabled" do
       html = get_file('valid.html')
-      html.should be_valid_markup
+      expect(html).to be_valid_markup
 
       ENV['NONET'] = 'true'
 
-      Net::HTTP.should_not_receive(:start)
-      html.should be_valid_markup
+      expect(Net::HTTP).not_to receive(:start)
+      expect(html).to be_valid_markup
 
       ENV.delete('NONET')
     end
@@ -255,9 +255,9 @@ describe 'be_valid_markup' do
       ENV['NONET'] = 'true'
 
       html = get_file('valid.html')
-      lambda {
-        html.should be_valid_markup
-      }.should raise_error(RSpec::Core::Pending::PendingDeclaredInExample)
+      expect {
+        expect(html).to be_valid_markup
+      }.to raise_error(BeValidAsset::DontRunValidAssetSpecs)
 
       ENV.delete('NONET')
     end
@@ -267,7 +267,7 @@ describe 'be_valid_markup' do
         html = get_file('valid_with_cache_busters.html')
         html_modified = get_file('valid_without_cache_busters.html')
         be_valid_markup = BeValidAsset::BeValidMarkup.new
-        be_valid_markup.should_receive(:validate).with({:fragment => html_modified})
+        expect(be_valid_markup).to receive(:validate).with({:fragment => html_modified})
         be_valid_markup.matches?(html)
       end
 
@@ -275,7 +275,7 @@ describe 'be_valid_markup' do
         BeValidAsset::Configuration.enable_caching = false
         html = get_file('valid_with_cache_busters.html')
         be_valid_markup = BeValidAsset::BeValidMarkup.new
-        be_valid_markup.should_receive(:validate).with({:fragment => html})
+        expect(be_valid_markup).to receive(:validate).with({:fragment => html})
         be_valid_markup.matches?(html)
       end
     end
@@ -292,39 +292,71 @@ describe 'be_valid_markup' do
       html = get_file('html_with_srcset.html')
       html_modified = get_file('html_without_srcset.html')
       be_valid_markup = BeValidAsset::BeValidMarkup.new
-      be_valid_markup.should_receive(:validate).with({:fragment => html_modified})
+      expect(be_valid_markup).to receive(:validate).with({:fragment => html_modified})
       be_valid_markup.matches?(html)
     end
   end
 
+  describe 'host and path configuration' do
+    let(:response) { Net::HTTPSuccess.new('1.1', 200, 'HTTPOK').tap { |r| r['x-w3c-validator-status'] = 'Valid' } }
+    let(:http) { double('HTTP', :post2 => response) }
+    let(:html) { MockResponse.new(get_file('valid.html')) }
+
+    it "parses the domain and port out of the host configuration" do
+      allow(BeValidAsset::Configuration).to receive_messages(:markup_validator_host => 'http://validator.example.com:1234')
+
+      expect(Net::HTTP).to receive(:start).with('validator.example.com', 1234).and_return(http)
+      expect(html).to be_valid_markup
+    end
+
+    it "forces http if no protocol is specificed in the host configuration" do
+      allow(BeValidAsset::Configuration).to receive_messages(:markup_validator_host => 'validator.example.com')
+
+      expect(Net::HTTP).to receive(:start).with('validator.example.com', 80).and_return(http)
+      expect(html).to be_valid_markup
+    end
+
+    it "configures net/http to use ssl if https is specificed in the host configuration" do
+      allow(BeValidAsset::Configuration).to receive_messages(:markup_validator_host => 'https://validator.example.com')
+
+      ssl_connection = double('Net/HTTP SSL')
+      expect(Net::HTTP).to receive(:new).with('validator.example.com', 443).and_return(ssl_connection)
+      expect(ssl_connection).to receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_NONE)
+      expect(ssl_connection).to receive(:use_ssl=).with(true)
+      expect(ssl_connection).to receive(:start).and_return(http)
+      expect(html).to be_valid_markup
+    end
+  end
+
   describe "Proxying" do
     before :each do
       r = Net::HTTPSuccess.new('1.1', 200, 'HTTPOK')
       r['x-w3c-validator-status'] = 'Valid'
-      @http = mock('HTTP')
-      @http.stub!(:post2).and_return(r)
+      @http = double('HTTP')
+      allow(@http).to receive(:post2).and_return(r)
 
       @html = MockResponse.new(get_file('valid.html'))
+      allow(BeValidAsset::Configuration).to receive_messages(:markup_validator_host => 'http://validator.example.com:1234')
     end
 
     it "should use direct http without ENV['http_proxy']" do
       ENV.delete('http_proxy')
-      Net::HTTP.should_receive(:start).with(BeValidAsset::Configuration.markup_validator_host).and_return(@http)
-      @html.should be_valid_markup
+      expect(Net::HTTP).to receive(:start).with('validator.example.com', 1234).and_return(@http)
+      expect(@html).to be_valid_markup
     end
 
     it "should use proxied http connection with ENV['http_proxy']" do
       ENV['http_proxy'] = "http://user:pw@localhost:3128"
-      Net::HTTP.should_receive(:start).with(BeValidAsset::Configuration.markup_validator_host, nil, 'localhost', 3128, "user", "pw").and_return(@http)
-      @html.should be_valid_markup
+      expect(Net::HTTP).to receive(:start).with('validator.example.com', 1234, 'localhost', 3128, "user", "pw").and_return(@http)
+      expect(@html).to be_valid_markup
       ENV.delete('http_proxy')
     end
 
     it "should raise exception with invalid http_proxy" do
       ENV['http_proxy'] = "http://invalid:uri"
-      lambda {
-        @html.should be_valid_markup
-      }.should raise_error(URI::InvalidURIError)
+      expect {
+        expect(@html).to be_valid_markup
+      }.to raise_error(URI::InvalidURIError)
       ENV.delete('http_proxy')
     end
   end