ndd-url_checker 0.2.1 → 0.3.0

data/spec/ndd/url_checker/status_decorator_spec.rb

@@ -0,0 +1,208 @@
+require 'spec_helper'
+
+# ----------------------------------------------------------------------------------------------------------------------
+RSpec.shared_examples 'a status' do |code|
+  context '#uri' do
+    it 'is decorated' do
+      expect(decorator.uri).to eq uri
+    end
+  end
+
+  context '#code' do
+    it 'is decorated' do
+      expect(decorator.code).to eq code
+    end
+  end
+end
+
+# ----------------------------------------------------------------------------------------------------------------------
+
+RSpec.describe NDD::UrlChecker::StatusDecorator do
+
+  let(:uri) { 'http://www.example.com' }
+  let(:status) { NDD::UrlChecker::Status.new(uri) }
+  let(:decorator) { NDD::UrlChecker::StatusDecorator.new(status) }
+
+  let(:redirect_uri_1) { 'http://www.redirected1.com' }
+  let(:redirect_uri_2) { 'http://www.redirected2.com' }
+  let(:redirect_uri_3) { 'http://www.redirected3.com' }
+
+
+  # ------------------------------------------------------------------------------------------------------- direct -----
+  context 'when code is :direct' do
+    before(:each) { status.direct }
+
+    it_behaves_like 'a status', :direct
+
+    context '#details_title' do
+      it 'returns nil' do
+        expect(decorator.details_title).to be_nil
+      end
+    end
+
+    context '#details_body' do
+      it 'returns nil' do
+        expect(decorator.details_body).to be_nil
+      end
+    end
+  end
+
+
+  # ------------------------------------------------------------------------------------------------------- failed -----
+  context 'when code is :failed' do
+    context 'and received a Net::HTTPResponse' do
+      before(:each) do
+        response = Net::HTTPForbidden.new('1.1', 403, 'forbidden!')
+        status.failed(response)
+        allow(response).to receive(:body).and_return('The forbidden body!')
+      end
+
+      it_behaves_like 'a status', :failed
+
+      context '#details_title' do
+        it 'returns the name of the class' do
+          expect(decorator.details_title).to eq 'Net::HTTPForbidden'
+        end
+      end
+
+      context '#details_body' do
+        it 'returns the body of the response' do
+          expect(decorator.details_body).to eq 'The forbidden body!'
+        end
+      end
+    end
+  end
+
+  # --------------------------------------------------------------------------------------------------- redirected -----
+  context 'when code is :redirected' do
+    context 'and redirected 1 time' do
+      before(:each) { status.redirected(redirect_uri_1) }
+
+      it_behaves_like 'a status', :redirected
+
+      context '#details_title' do
+        it 'returns the number of redirect' do
+          expect(decorator.details_title).to eq 1
+        end
+      end
+
+      context '#details_body' do
+        it 'returns the list of redirected URIs' do
+          expect(decorator.details_body).to eq <<-DOC.gsub(/^ +/, '')
+            - http://www.example.com
+            - http://www.redirected1.com
+          DOC
+        end
+      end
+    end
+
+    context 'and redirected 3 times' do
+      before(:each) do
+        status
+            .redirected(redirect_uri_1)
+            .redirected(redirect_uri_2)
+            .redirected(redirect_uri_3)
+      end
+
+      it_behaves_like 'a status', :redirected
+
+      context '#details_title' do
+        it 'returns the number of redirect' do
+          expect(decorator.details_title).to eq 3
+        end
+      end
+
+      context '#details_body' do
+        it 'returns the list of redirected URIs' do
+          expect(decorator.details_body).to eq <<-DOC.gsub(/^ +/, '')
+            - http://www.example.com
+            - http://www.redirected1.com
+            - http://www.redirected2.com
+            - http://www.redirected3.com
+          DOC
+        end
+      end
+    end
+  end
+
+  # ------------------------------------------------------------------------------------------- too_many_redirects -----
+  context 'when code is :too_many_redirects' do
+    context 'and redirected 1 time' do
+      before(:each) { status.redirected(redirect_uri_1).too_many_redirects }
+
+      it_behaves_like 'a status', :too_many_redirects
+
+      context '#details_title' do
+        it 'returns the number of redirect' do
+          expect(decorator.details_title).to eq 1
+        end
+      end
+
+      context '#details_body' do
+        it 'returns the list of redirected URIs' do
+          expect(decorator.details_body).to eq <<-DOC.gsub(/^ +/, '')
+            - http://www.example.com
+            - http://www.redirected1.com
+          DOC
+        end
+      end
+    end
+
+    context 'and redirected 3 times' do
+      before(:each) do
+        status
+            .redirected(redirect_uri_1)
+            .redirected(redirect_uri_2)
+            .redirected(redirect_uri_3)
+            .too_many_redirects
+      end
+
+      it_behaves_like 'a status', :too_many_redirects
+
+      context '#details_title' do
+        it 'returns the number of redirect' do
+          expect(decorator.details_title).to eq 3
+        end
+      end
+
+      context '#details_body' do
+        it 'returns the list of redirected URIs' do
+          expect(decorator.details_body).to eq <<-DOC.gsub(/^ +/, '')
+            - http://www.example.com
+            - http://www.redirected1.com
+            - http://www.redirected2.com
+            - http://www.redirected3.com
+          DOC
+        end
+      end
+    end
+  end
+
+  # ------------------------------------------------------------------------------------------------- unknown_host -----
+  context 'when code is :unknown_host' do
+    before(:each) { status.redirected(redirect_uri_1).unknown_host }
+
+    it_behaves_like 'a status', :unknown_host
+
+    context '#code_as_css' do
+      it 'returns a CSS class suffix' do
+        expect(decorator.code_as_css).to eq 'unknown-host'
+      end
+    end
+
+    context '#details_title' do
+      it 'returns the unknown URI' do
+        expect(decorator.details_title).to eq redirect_uri_1
+      end
+    end
+
+    context '#details_body' do
+      it 'returns the list of redirected URIs' do
+        expect(decorator.details_body).to eq <<-DOC.gsub(/^ +/, '')
+            - http://www.example.com
+            - http://www.redirected1.com
+        DOC
+      end
+    end
+  end
+end

data/spec/ndd/url_checker/status_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe NDD::UrlChecker::Status do
+RSpec.describe NDD::UrlChecker::Status do
 
   # ------------------------------------------------------------------------------------------------------ unknown -----
   context 'when initialized' do
@@ -54,7 +54,7 @@ describe NDD::UrlChecker::Status do
     end
 
     context '#failed' do
-      let!(:new_status) { status.failed('some error') }
+      let!(:new_status) { status.failed(StandardError.new('some error')) }
       it 'changes the code to :failed' do
         expect(status.code).to eq :failed
       end
@@ -149,7 +149,7 @@ describe NDD::UrlChecker::Status do
 
     context '#failed' do
       it 'raises an error' do
-        expect { status.failed('some error') }.to raise_error(/from :direct to :failed is forbidden/)
+        expect { status.failed(StandardError.new('some error')) }.to raise_error(/from :direct to :failed is forbidden/)
       end
     end
 
@@ -181,7 +181,7 @@ describe NDD::UrlChecker::Status do
   # ------------------------------------------------------------------------------------------------------- failed -----
   context 'when code is :failed' do
     let(:uri) { 'http://www.example.com' }
-    let(:status) { NDD::UrlChecker::Status.new(uri).failed('some error') }
+    let(:status) { NDD::UrlChecker::Status.new(uri).failed(StandardError.new('some error')) }
 
     context '#uri' do
       it 'returns the original URI' do
@@ -215,7 +215,7 @@ describe NDD::UrlChecker::Status do
 
     context '#error' do
       it 'returns the error' do
-        expect(status.error).to eq 'some error'
+        expect(status.error).to eq StandardError.new('some error')
       end
     end
 
@@ -227,7 +227,7 @@ describe NDD::UrlChecker::Status do
 
     context '#failed' do
       it 'raises an error' do
-        expect { status.failed('some error') }.to raise_error(/from :failed to :failed is forbidden/)
+        expect { status.failed(StandardError.new('some error')) }.to raise_error(/from :failed to :failed is forbidden/)
       end
     end
 
@@ -251,7 +251,7 @@ describe NDD::UrlChecker::Status do
 
     context '#to_s' do
       it 'returns the status representation' do
-        expect(status.to_s).to match %r{^#<NDD::UrlChecker::Status:0[xX][0-9a-fA-F]+ @uris=\["http://www.example.com"\], @code=:failed, @error="some error">$}
+        expect(status.to_s).to match %r{^#<NDD::UrlChecker::Status:0[xX][0-9a-fA-F]+ @uris=\["http://www.example.com"\], @code=:failed, @error=#<StandardError: some error>>$}
       end
     end
   end
@@ -305,7 +305,7 @@ describe NDD::UrlChecker::Status do
     end
 
     context '#failed' do
-      let!(:new_status) { status.failed('some error') }
+      let!(:new_status) { status.failed(StandardError.new('some error')) }
       it 'changes the code to :failed' do
         expect(status.code).to eq :failed
       end
@@ -400,7 +400,7 @@ describe NDD::UrlChecker::Status do
 
     context '#failed' do
       it 'raises an error' do
-        expect { status.failed('some error') }.to raise_error(/from :too_many_redirects to :failed is forbidden/)
+        expect { status.failed(StandardError.new('some error')) }.to raise_error(/from :too_many_redirects to :failed is forbidden/)
       end
     end
 
@@ -478,7 +478,7 @@ describe NDD::UrlChecker::Status do
 
     context '#failed' do
       it 'raises an error' do
-        expect { status.failed('some error') }.to raise_error(/from :unknown_host to :failed is forbidden/)
+        expect { status.failed(StandardError.new('some error')) }.to raise_error(/from :unknown_host to :failed is forbidden/)
       end
     end
 

data/spec/ndd/url_checker/threaded_url_checker_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe NDD::UrlChecker::ThreadedUrlChecker do
+RSpec.describe NDD::UrlChecker::ThreadedUrlChecker do
 
   before(:all) do
     # Logging.logger.root.level = :debug

data/spec/spec_helper.rb

@@ -50,12 +50,10 @@ Spork.prefork do
 
     # ----- filters
     config.alias_example_to :fit, :focused
+    config.disable_monkey_patching!
     config.filter_run_including :focused
     config.order = 'random'
     config.run_all_when_everything_filtered = true
-    config.expect_with :rspec do |c|
-      c.syntax = :expect
-    end
 
   end
 

data/spec/support/multiple_url_checker_spec.rb

@@ -15,11 +15,11 @@ RSpec.shared_examples 'a multiple URL checker' do |skip_verify|
   # ------------------------------------------------------------------------------------------------- multiple URL -----
   context 'when there are multiple URLs' do
     let!(:stub1) { stub_request(:get, 'http://www.valid.mock/').to_return(status: 200) }
-    let!(:stub2) { stub_request(:get, 'http://www.invalid.mock/').to_raise(SocketError) }
+    let!(:stub2) { stub_request(:get, 'http://www.unknown.mock/').to_raise(SocketError) }
 
     describe '#check' do
       it 'returns a map of the results indexed by the URI' do
-        results = subject.check('http://www.valid.mock/', 'http://www.invalid.mock/')
+        results = subject.check('http://www.valid.mock/', 'http://www.unknown.mock/')
         expect(results).to have(2).items
         results_hash = results.reduce({}) { |hash, result| hash[result.uri] = result; hash }
 
@@ -28,9 +28,9 @@ RSpec.shared_examples 'a multiple URL checker' do |skip_verify|
         expect(status1.uri).to eq 'http://www.valid.mock/'
         expect(status1.error).to be_nil
 
-        status2 = results_hash['http://www.invalid.mock/']
+        status2 = results_hash['http://www.unknown.mock/']
         expect(status2.code).to eq :failed
-        expect(status2.uri).to eq 'http://www.invalid.mock/'
+        expect(status2.uri).to eq 'http://www.unknown.mock/'
         expect(status2.error).to be_a StandardError
       end
     end

data/spec/support/single_url_checker_spec.rb

@@ -20,9 +20,15 @@ RSpec.shared_examples 'a single URL checker' do
       it 'returns a status with a :direct code' do
         expect(status.code).to eq :direct
       end
+
       it 'returns a status with the requested URI' do
+        expect(status.uri).to eq 'http://www.valid.mock/'
+      end
+
+      it 'returns a status with the requested URIs' do
         expect(status.uris).to eq ['http://www.valid.mock/']
       end
+
       it 'returns a status with no error' do
         expect(status.error).to be_nil
       end
@@ -52,7 +58,14 @@ RSpec.shared_examples 'a single URL checker' do
       end
 
       it 'returns a status with the requested URIs' do
-        expect(status.uris).to eq (1..4).to_a.map { |i| "http://www.redirect#{i}.mock/" }
+        expect(status.uris).to eq %w(http://www.redirect1.mock/
+                                     http://www.redirect2.mock/
+                                     http://www.redirect3.mock/
+                                     http://www.redirect4.mock/)
+      end
+
+      it 'returns a status with no error' do
+        expect(status.error).to be_nil
       end
     end
 
@@ -70,17 +83,27 @@ RSpec.shared_examples 'a single URL checker' do
     let!(:stub5) { stub_redirect('http://www.redirect4.mock/relative', 'http://www.redirect5.mock/') }
 
     describe '#check' do
-      it 'returns UrlChecker::Direct' do
-        result = subject.check('http://www.redirect1.mock/')
-        expect(result).to be_kind_of NDD::UrlChecker::Status
-        expect(result.uri).to eq 'http://www.redirect1.mock/'
-        expect(result.uris).to eq %w(http://www.redirect1.mock/
+      let (:status) { subject.check('http://www.redirect1.mock/') }
+
+      it 'returns a status with a :too_many_redirects code' do
+        expect(status.code).to eq :too_many_redirects
+      end
+
+      it 'returns a status with the requested URI' do
+        expect(status.uri).to eq 'http://www.redirect1.mock/'
+      end
+
+      it 'returns a status with the requested URIs' do
+        expect(status.uris).to eq %w(http://www.redirect1.mock/
                                      http://www.redirect2.mock/
                                      http://www.redirect3.mock/
                                      http://www.redirect4.mock/
                                      http://www.redirect4.mock/relative
-                                     http://www.redirect5.mock/
-                                    )
+                                     http://www.redirect5.mock/)
+      end
+
+      it 'returns a status with no error' do
+        expect(status.error).to be_nil
       end
     end
 
@@ -91,55 +114,73 @@ RSpec.shared_examples 'a single URL checker' do
 
   # ------------------------------------------------------------------------------------------------- unknown_host -----
   context 'when the URL cannot be resolved' do
-    let!(:stub) {
-      error = SocketError.new('getaddrinfo: Name or service not known')
-      stub_request(:get, 'http://www.invalid.mock/').to_raise(error)
-    }
+    let!(:error) { SocketError.new('getaddrinfo: Name or service not known') }
+    let!(:stub1) { stub_redirect('http://www.redirect1.mock/', 'http://www.redirect2.mock/') }
+    let!(:stub2) { stub_redirect('http://www.redirect2.mock/', 'http://www.unknown.mock/') }
+    let!(:stub3) { stub_request(:get, 'http://www.unknown.mock/').to_raise(error) }
 
     describe '#check' do
-      let (:status) { subject.check('http://www.invalid.mock/') }
+      let (:status) { subject.check('http://www.redirect1.mock/') }
 
       it 'returns a status with a :unknown_host code' do
         expect(status.code).to eq :unknown_host
       end
+
       it 'returns a status with the requested URI' do
-        expect(status.uri).to eq 'http://www.invalid.mock/'
+        expect(status.uri).to eq 'http://www.redirect1.mock/'
       end
+
+      it 'returns a status with the requested URIs' do
+        expect(status.uris).to eq %w(http://www.redirect1.mock/
+                                     http://www.redirect2.mock/
+                                     http://www.unknown.mock/)
+      end
+
       it 'returns a status with no error' do
         expect(status.error).to be_nil
       end
     end
 
     after(:each) do
-      expect(stub).to have_been_requested
+      [stub1, stub2, stub3].each { |stub| expect(stub).to have_been_requested }
     end
   end
 
   # ------------------------------------------------------------------------------------------------- socket error -----
   context 'when there is a socket error' do
-    let!(:stub) { stub_request(:get, 'http://www.invalid.mock/').to_raise(SocketError) }
+    let!(:stub1) { stub_redirect('http://www.redirect1.mock/', 'http://www.redirect2.mock/') }
+    let!(:stub2) { stub_redirect('http://www.redirect2.mock/', 'http://www.invalid.mock/') }
+    let!(:stub3) { stub_request(:get, 'http://www.invalid.mock/').to_raise(SocketError) }
 
     describe '#check' do
-      let (:status) { subject.check('http://www.invalid.mock/') }
+      let (:status) { subject.check('http://www.redirect1.mock/') }
 
       it 'returns a status with a :failed code' do
         expect(status.code).to eq :failed
       end
+
       it 'returns a status with the requested URI' do
-        expect(status.uri).to eq 'http://www.invalid.mock/'
+        expect(status.uri).to eq 'http://www.redirect1.mock/'
+      end
+
+      it 'returns a status with the requested URIs' do
+        expect(status.uris).to eq %w(http://www.redirect1.mock/
+                                     http://www.redirect2.mock/
+                                     http://www.invalid.mock/)
       end
+
       it 'returns a status with the raised error' do
         expect(status.error).to be_a SocketError
       end
     end
 
     after(:each) do
-      expect(stub).to have_been_requested
+      [stub1, stub2, stub3].each { |stub| expect(stub).to have_been_requested }
     end
   end
 
-  # ----------------------------------------------------------------------------------------------- expected error -----
-  context 'when there is an unexpected error' do
+  # --------------------------------------------------------------------------------------- expected network error -----
+  context 'when there is an expected network error' do
     let!(:stub) { stub_request(:get, 'http://www.error.mock/').to_return(status: 400) }
 
     describe '#check' do
@@ -148,9 +189,15 @@ RSpec.shared_examples 'a single URL checker' do
       it 'returns a status with a :failed code' do
         expect(status.code).to eq :failed
       end
+
       it 'returns a status with the requested URI' do
         expect(status.uri).to eq 'http://www.error.mock/'
       end
+
+      it 'returns a status with the requested URIs' do
+        expect(status.uris).to eq ['http://www.error.mock/']
+      end
+
       it 'returns a status with the raised error' do
         expect(status.error).to be_a Net::HTTPBadRequest
       end
@@ -171,9 +218,15 @@ RSpec.shared_examples 'a single URL checker' do
       it 'returns a status with a :failed code' do
         expect(status.code).to eq :failed
       end
+
       it 'returns a status with the requested URI' do
         expect(status.uri).to eq 'http://www.error.mock/'
       end
+
+      it 'returns a status with the requested URIs' do
+        expect(status.uris).to eq ['http://www.error.mock/']
+      end
+
       it 'returns a status with the raised error' do
         expect(status.error).to be_a StandardError
       end