ndd-url_checker 0.1.1

data/lib/ndd/url_checker/forked_url_checker.rb

@@ -0,0 +1,100 @@
+require 'cod'
+require 'logging'
+require 'ndd/url_checker/abstract_url_checker'
+require 'ndd/url_checker/blocking_url_checker'
+require 'ndd/url_checker/status'
+
+module NDD
+  module UrlChecker
+
+    # An URL checker using forks to parallelize processing. To be used with MRI.
+    # @author David DIDIER
+    class ForkedUrlChecker < AbstractUrlChecker
+
+      attr_reader :delegate
+      attr_reader :parallelism
+
+      # Create a new instance.
+      # @param [AbstractUrlChecker] delegate_checker defaults to {NDD::UrlChecker::BlockingUrlChecker}.
+      # @param [Fixnum] parallelism the number of processes.
+      def initialize(delegate_checker=nil, parallelism=10)
+        @logger = Logging.logger[self]
+        @delegate = delegate_checker || BlockingUrlChecker.new
+        @parallelism = parallelism
+      end
+
+      def check(*urls)
+        return delegate.check(*urls) if urls.size < 2
+        process(urls, :check)
+      end
+
+      def validate(*urls)
+        return delegate.validate(*urls) if urls.size < 2
+        process(urls, :validate)
+      end
+
+
+      private
+
+      def process(urls, method)
+        # for receiving results
+        result_pipe = Cod.pipe
+        # partition the URLs, but not too much :)
+        url_slices = partition(urls, [parallelism, urls.size].min)
+        # and distribute them among the workers
+        pids = url_slices.each_with_index.map do |url_slice, index|
+          fork { Worker.new(index, result_pipe, delegate).send(method, url_slice) }
+        end
+
+        # read back the results
+        results = urls.reduce({}) do |hash, _|
+          result = result_pipe.get
+          hash.merge!(result)
+          @logger.debug("Processed URLs #{hash.size}/#{urls.size}")
+          hash
+        end
+
+        # kill all the workers
+        pids.each { |pid| Process.kill(:TERM, pid) }
+
+        results
+      end
+
+      # Evenly distributes data into buckets. For example:
+      #     partition([1, 2, 3], 2) => [[1, 3], [2]]
+      #     partition([1, 2, 3, 4, 5, 6], 3) => [[1, 4], [2, 5], [3, 6]]
+      def partition(data, buckets)
+        Array.new.tap do |slices|
+          buckets.times.each { |_| slices << Array.new }
+          data.each_with_index { |element, index| slices[index % buckets] << element }
+        end
+      end
+
+
+      # A simple worker class processing URL one by one.
+      class Worker
+        def initialize(id, result_pipe, url_checker)
+          @logger = Logging.logger[self]
+          @id = id
+          @result_pipe = result_pipe
+          @url_checker = url_checker
+        end
+
+        def check(urls)
+          @logger.debug("[worker #{@id}] Checking #{urls.size} URLs")
+          urls.each do |url|
+            @result_pipe.put({url => @url_checker.check(url)})
+          end
+        end
+
+        def validate(urls)
+          @logger.debug("[worker #{@id}] Validating #{urls.size} URLs")
+          urls.each do |url|
+            @result_pipe.put({url => @url_checker.validate(url)})
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/ndd/url_checker/parallel_url_checker.rb

@@ -0,0 +1,45 @@
+require 'logging'
+require 'ndd/url_checker/abstract_url_checker'
+require 'ndd/url_checker/forked_url_checker'
+require 'ndd/url_checker/status'
+require 'ndd/url_checker/threaded_url_checker'
+
+module NDD
+  module UrlChecker
+
+    # Wraps an instance of ThreadedUrlChecker or ForkedUrlChecker
+    # depending of the underlying Ruby implementation.
+    # @author David DIDIER
+    class ParallelUrlChecker < AbstractUrlChecker
+
+      attr_reader :delegate
+
+      # Create a new instance.
+      # @param [AbstractUrlChecker] delegate_checker defaults to {NDD::UrlChecker::BlockingUrlChecker}.
+      # @param [Fixnum] parallelism the number of threads or processes.
+      def initialize(delegate_checker=nil, parallelism=10)
+        @logger = Logging.logger[self]
+
+        @logger.debug "Ruby engine is #{RUBY_ENGINE}"
+        if RUBY_ENGINE == 'jruby'
+          @logger.info 'Creating a threaded URL checker'
+          parallel_checker = ThreadedUrlChecker.new(delegate_checker, parallelism)
+        else
+          @logger.info 'Creating a forked URL checker'
+          parallel_checker = ForkedUrlChecker.new(delegate_checker, parallelism)
+        end
+
+        @delegate = parallel_checker
+      end
+
+      def check(*urls)
+        @delegate.check(*urls)
+      end
+
+      def validate(*urls)
+        @delegate.validate(*urls)
+      end
+
+    end
+  end
+end

data/lib/ndd/url_checker/status.rb

@@ -0,0 +1,104 @@
+module NDD
+  module UrlChecker
+
+    # The result of a URI test.
+    # @author David DIDIER
+    # @attr_reader code [String] the state
+    # @attr_reader error [String|StandardError] the last error if any
+    # @attr_reader uris [Array<String>] the list of requested URI
+    class Status
+
+      attr_reader :code
+      attr_reader :error
+      attr_reader :uris
+
+      # Create a new NDD::UrlChecker::Status instance in the unknown state.
+      # @param uri [String|URI::HTTP] the requested URI.
+      def initialize(uri)
+        @uris = [uri.to_s]
+        @code = :unknown
+      end
+
+      # Returns the first requested URI.
+      # @return [String] the first requested URI.
+      def uri
+        uris.first
+      end
+
+      # Note that the code :unknown is neither valid nor invalid.
+      # @return [Boolean] true if valid, false otherwise.
+      def valid?
+        VALID_CODES.include? @code
+      end
+
+      # Note that the code :unknown is neither valid nor invalid.
+      # @return [Boolean] true if invalid, false otherwise.
+      def invalid?
+        INVALID_CODES.include? @code
+      end
+
+      # @return [Boolean] true if redirected, false otherwise.
+      def redirected?
+        @code == :redirected
+      end
+
+
+      # When the URI is valid without any redirect.
+      # @return [NDD::UrlChecker::Status] self.
+      def direct
+        update_code(:direct, %i(unknown))
+      end
+
+      # When a generic error is raised.
+      # @param error [StandardError|String] the generic error.
+      # @return [NDD::UrlChecker::Status] self.
+      def failed(error)
+        @error = error
+        update_code(:failed, %i(unknown redirected))
+      end
+
+      # Adds a new URI to the redirected URI list.
+      # @param uri [String|URI::HTTP] the redirection URI.
+      # @return [NDD::UrlChecker::Status] self.
+      def redirected(uri)
+        @uris << uri.to_s
+        update_code(:redirected, %i(unknown redirected))
+      end
+
+      # When there are too many redirects.
+      # @return [NDD::UrlChecker::Status] self.
+      def too_many_redirects
+        update_code(:too_many_redirects, %i(unknown redirected))
+      end
+
+      # When the host cannot be resolved.
+      # @return [NDD::UrlChecker::Status] self.
+      def unknown_host
+        update_code(:unknown_host, %i(unknown redirected))
+      end
+
+      def to_s
+        self.inspect
+      end
+
+
+      private
+
+      VALID_CODES = %i(direct redirected).freeze
+      INVALID_CODES = %i(failed too_many_redirects unknown_host).freeze
+
+      # Updates the code if the transition is valid.
+      # @param code [Symbol] the new code.
+      # @param valid_source_codes [Array<Symbol>] the codes from which the transition can happen.
+      # @return [NDD::UrlChecker::Status] self.
+      def update_code(code, valid_source_codes)
+        unless valid_source_codes.include?(@code)
+          raise "Changing the status code from :#{@code} to :#{code} is forbidden"
+        end
+        @code = code
+        self
+      end
+
+    end
+  end
+end

data/lib/ndd/url_checker/threaded_url_checker.rb

@@ -0,0 +1,36 @@
+require 'logging'
+require 'ndd/url_checker/abstract_url_checker'
+require 'ndd/url_checker/blocking_url_checker'
+require 'ndd/url_checker/status'
+
+module NDD
+  module UrlChecker
+
+    # An URL checker using threads to parallelize processing. Does not work on MRI.
+    # @author David DIDIER
+    class ThreadedUrlChecker < AbstractUrlChecker
+
+      attr_reader :delegate
+
+      # Create a new instance.
+      # @param [AbstractUrlChecker] delegate_checker defaults to {NDD::UrlChecker::BlockingUrlChecker}.
+      # @param [Fixnum] parallelism the number of threads.
+      def initialize(delegate_checker=nil, parallelism=10)
+        @logger = Logging.logger[self]
+        @delegate = delegate_checker || BlockingUrlChecker.new
+        @parallelism = parallelism
+      end
+
+      def check(*urls)
+        # delegate.check(*urls)
+        raise 'TODO'
+      end
+
+      def validate(*urls)
+        # delegate.validate(*urls)
+        raise 'TODO'
+      end
+
+    end
+  end
+end

data/spec/ndd/url_checker/abstract_url_checker_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe NDD::UrlChecker::AbstractUrlChecker do
+
+  context '#validate' do
+    it 'is not implemented' do
+      expect { subject.validate('http://www.valid.mock/') }.to raise_error /must be implemented/
+    end
+  end
+
+  context '#check' do
+    it 'is not implemented' do
+      expect { subject.check('http://www.valid.mock/') }.to raise_error /must be implemented/
+    end
+  end
+
+end

data/spec/ndd/url_checker/blocking_url_checker_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe NDD::UrlChecker::BlockingUrlChecker do
+
+  before(:all) do
+    # Logging.logger.root.level = :debug
+  end
+
+  it_behaves_like 'a single URL checker'
+  it_behaves_like 'a multiple URL checker'
+
+end

data/spec/ndd/url_checker/forked_url_checker_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe NDD::UrlChecker::ForkedUrlChecker do
+
+  before(:all) do
+    # Logging.logger.root.level = :debug
+  end
+
+  it_behaves_like 'a single URL checker'
+  it_behaves_like 'a multiple URL checker', skip_verify = true
+
+end

data/spec/ndd/url_checker/parallel_url_checker_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe NDD::UrlChecker::ParallelUrlChecker do
+
+  before(:all) do
+    # Logging.logger.root.level = :debug
+  end
+
+  # ---------------------------------------------------------------------------------------------------------- MRI -----
+  context 'when running MRI' do
+
+    before(:all) do
+      @old_engine = RUBY_ENGINE
+      silence_warnings { RUBY_ENGINE = 'ruby' }
+    end
+
+    describe '#initialize' do
+      it 'delegates to a ForkedUrlChecker instance' do
+        expect(NDD::UrlChecker::ParallelUrlChecker.new.delegate).to be_a NDD::UrlChecker::ForkedUrlChecker
+      end
+    end
+
+    it_behaves_like 'a single URL checker'
+
+    after(:all) do
+      silence_warnings { RUBY_ENGINE = @old_engine }
+    end
+  end
+
+  # -------------------------------------------------------------------------------------------------------- JRuby -----
+  context 'when running JRuby' do
+    before(:all) do
+      @old_engine = RUBY_ENGINE
+      silence_warnings { RUBY_ENGINE = 'jruby' }
+    end
+
+    describe '#initialize' do
+      it 'delegates to a ThreadedUrlChecker instance' do
+        expect(NDD::UrlChecker::ParallelUrlChecker.new.delegate).to be_a NDD::UrlChecker::ThreadedUrlChecker
+      end
+    end
+
+    # TODO
+    # it_behaves_like 'a single URL checker'
+
+    after(:all) do
+      silence_warnings { RUBY_ENGINE = @old_engine }
+    end
+  end
+
+
+  # ------------------------------------------------------------------------------------------------------ private -----
+  private
+
+  def silence_warnings(&block)
+    warn_level = $VERBOSE
+    $VERBOSE = nil
+    result = block.call
+    $VERBOSE = warn_level
+    result
+  end
+end

data/spec/ndd/url_checker/status_spec.rb

@@ -0,0 +1,510 @@
+require 'spec_helper'
+
+describe NDD::UrlChecker::Status do
+
+  # ------------------------------------------------------------------------------------------------------ unknown -----
+  context 'when initialized' do
+    let(:uri) { 'http://www.example.com' }
+    let(:status) { NDD::UrlChecker::Status.new(uri) }
+
+    context '#uri' do
+      it 'returns the original URI' do
+        expect(status.uri).to eq uri
+      end
+    end
+
+    context '#uris' do
+      it 'returns the original URI' do
+        expect(status.uris).to eq [uri]
+      end
+    end
+
+    context '#code' do
+      it 'returns :unknown' do
+        expect(status.code).to eq :unknown
+      end
+    end
+
+    context '#valid?' do
+      it 'returns false' do
+        expect(status.valid?).to be_falsey
+      end
+    end
+
+    context '#invalid?' do
+      it 'returns false' do
+        expect(status.invalid?).to be_falsey
+      end
+    end
+
+    context '#error' do
+      it 'returns nil' do
+        expect(status.error).to be_nil
+      end
+    end
+
+    context '#direct' do
+      let!(:new_status) { status.direct }
+      it 'changes the code to :direct' do
+        expect(status.code).to eq :direct
+      end
+      it 'returns the status' do
+        expect(new_status).to eq status
+      end
+    end
+
+    context '#failed' do
+      let!(:new_status) { status.failed('some error') }
+      it 'changes the code to :failed' do
+        expect(status.code).to eq :failed
+      end
+      it 'returns the status' do
+        expect(new_status).to eq status
+      end
+    end
+
+    context '#redirected' do
+      let!(:new_status) { status.redirected('http://www.redirected.com') }
+      it 'changes the code to :redirected' do
+        expect(status.code).to eq :redirected
+      end
+      it 'returns the status' do
+        expect(new_status).to eq status
+      end
+    end
+
+    context '#too_many_redirects' do
+      let!(:new_status) { status.too_many_redirects }
+      it 'changes the code to :too_many_redirects' do
+        expect(status.code).to eq :too_many_redirects
+      end
+      it 'returns the status' do
+        expect(new_status).to eq status
+      end
+    end
+
+    context '#unknown_host' do
+      it 'changes the code to :unknown_host' do
+        status.unknown_host
+        expect(status.code).to eq :unknown_host
+      end
+      it 'returns the status' do
+        expect(status.unknown_host).to eq status
+      end
+    end
+
+    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=:unknown>$}
+      end
+    end
+  end
+
+  # ------------------------------------------------------------------------------------------------------- direct -----
+  context 'when code is :direct' do
+    let(:uri) { 'http://www.example.com' }
+    let(:status) { NDD::UrlChecker::Status.new(uri).direct }
+
+    context '#uri' do
+      it 'returns the original URI' do
+        expect(status.uri).to eq uri
+      end
+    end
+
+    context '#uris' do
+      it 'returns the original URI' do
+        expect(status.uris).to eq [uri]
+      end
+    end
+
+    context '#code' do
+      it 'returns :direct' do
+        expect(status.code).to eq :direct
+      end
+    end
+
+    context '#valid?' do
+      it 'returns true' do
+        expect(status.valid?).to be_truthy
+      end
+    end
+
+    context '#invalid?' do
+      it 'returns false' do
+        expect(status.invalid?).to be_falsey
+      end
+    end
+
+    context '#error' do
+      it 'returns nil' do
+        expect(status.error).to be_nil
+      end
+    end
+
+    context '#direct' do
+      it 'raises an error' do
+        expect { status.direct }.to raise_error(/from :direct to :direct is forbidden/)
+      end
+    end
+
+    context '#failed' do
+      it 'raises an error' do
+        expect { status.failed('some error') }.to raise_error(/from :direct to :failed is forbidden/)
+      end
+    end
+
+    context '#redirected' do
+      it 'raises an error' do
+        expect { status.redirected('http://www.redirected.com') }.to raise_error(/from :direct to :redirected is forbidden/)
+      end
+    end
+
+    context '#too_many_redirects' do
+      it 'raises an error' do
+        expect { status.too_many_redirects }.to raise_error(/from :direct to :too_many_redirects is forbidden/)
+      end
+    end
+
+    context '#unknown_host' do
+      it 'raises an error' do
+        expect { status.unknown_host }.to raise_error(/from :direct to :unknown_host is forbidden/)
+      end
+    end
+
+    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=:direct>$}
+      end
+    end
+  end
+
+  # ------------------------------------------------------------------------------------------------------- failed -----
+  context 'when code is :failed' do
+    let(:uri) { 'http://www.example.com' }
+    let(:status) { NDD::UrlChecker::Status.new(uri).failed('some error') }
+
+    context '#uri' do
+      it 'returns the original URI' do
+        expect(status.uri).to eq uri
+      end
+    end
+
+    context '#uris' do
+      it 'returns the original URI' do
+        expect(status.uris).to eq [uri]
+      end
+    end
+
+    context '#code' do
+      it 'returns :failed' do
+        expect(status.code).to eq :failed
+      end
+    end
+
+    context '#valid?' do
+      it 'returns false' do
+        expect(status.valid?).to be_falsey
+      end
+    end
+
+    context '#invalid?' do
+      it 'returns true' do
+        expect(status.invalid?).to be_truthy
+      end
+    end
+
+    context '#error' do
+      it 'returns the error' do
+        expect(status.error).to eq 'some error'
+      end
+    end
+
+    context '#direct' do
+      it 'raises an error' do
+        expect { status.direct }.to raise_error(/from :failed to :direct is forbidden/)
+      end
+    end
+
+    context '#failed' do
+      it 'raises an error' do
+        expect { status.failed('some error') }.to raise_error(/from :failed to :failed is forbidden/)
+      end
+    end
+
+    context '#redirected' do
+      it 'raises an error' do
+        expect { status.redirected('http://www.redirected.com') }.to raise_error(/from :failed to :redirected is forbidden/)
+      end
+    end
+
+    context '#too_many_redirects' do
+      it 'raises an error' do
+        expect { status.too_many_redirects }.to raise_error(/from :failed to :too_many_redirects is forbidden/)
+      end
+    end
+
+    context '#unknown_host' do
+      it 'raises an error' do
+        expect { status.unknown_host }.to raise_error(/from :failed to :unknown_host is forbidden/)
+      end
+    end
+
+    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">$}
+      end
+    end
+  end
+
+  # --------------------------------------------------------------------------------------------------- redirected -----
+  context 'when code is :redirected' do
+    let(:uri) { 'http://www.example.com' }
+    let(:redirect_uri) { 'http://www.redirected.com' }
+    let(:status) { NDD::UrlChecker::Status.new(uri).redirected(redirect_uri) }
+
+    context '#uri' do
+      it 'returns the original URI' do
+        expect(status.uri).to eq uri
+      end
+    end
+
+    context '#uris' do
+      it 'returns all the URI' do
+        expect(status.uris).to eq [uri, redirect_uri]
+      end
+    end
+
+    context '#code' do
+      it 'returns :redirected' do
+        expect(status.code).to eq :redirected
+      end
+    end
+
+    context '#valid?' do
+      it 'returns true' do
+        expect(status.valid?).to be_truthy
+      end
+    end
+
+    context '#invalid?' do
+      it 'returns false' do
+        expect(status.invalid?).to be_falsey
+      end
+    end
+
+    context '#error' do
+      it 'returns nil' do
+        expect(status.error).to be_nil
+      end
+    end
+
+    context '#direct' do
+      it 'raises an error' do
+        expect { status.direct }.to raise_error(/from :redirected to :direct is forbidden/)
+      end
+    end
+
+    context '#failed' do
+      let!(:new_status) { status.failed('some error') }
+      it 'changes the code to :failed' do
+        expect(status.code).to eq :failed
+      end
+      it 'returns the status' do
+        expect(new_status).to eq status
+      end
+    end
+
+    context '#redirected' do
+      let!(:new_status) { status.redirected('http://www.redirected.com') }
+      it 'changes the code to :redirected' do
+        expect(status.code).to eq :redirected
+      end
+      it 'returns the status' do
+        expect(new_status).to eq status
+      end
+    end
+
+    context '#too_many_redirects' do
+      let!(:new_status) { status.too_many_redirects }
+      it 'changes the code to :too_many_redirects' do
+        expect(status.code).to eq :too_many_redirects
+      end
+      it 'returns the status' do
+        expect(new_status).to eq status
+      end
+    end
+
+    context '#unknown_host' do
+      it 'changes the code to :unknown_host' do
+        status.unknown_host
+        expect(status.code).to eq :unknown_host
+      end
+      it 'returns the status' do
+        expect(status.unknown_host).to eq status
+      end
+    end
+
+    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", "http://www.redirected.com"\], @code=:redirected>$}
+      end
+    end
+  end
+
+  # ------------------------------------------------------------------------------------------- too_many_redirects -----
+  context 'when code is :too_many_redirects' do
+    let(:uri) { 'http://www.example.com' }
+    let(:status) { NDD::UrlChecker::Status.new(uri).too_many_redirects }
+
+    context '#uri' do
+      it 'returns the original URI' do
+        expect(status.uri).to eq uri
+      end
+    end
+
+    context '#uris' do
+      it 'returns the original URI' do
+        expect(status.uris).to eq [uri]
+      end
+    end
+
+    context '#code' do
+      it 'returns :too_many_redirects' do
+        expect(status.code).to eq :too_many_redirects
+      end
+    end
+
+    context '#valid?' do
+      it 'returns false' do
+        expect(status.valid?).to be_falsey
+      end
+    end
+
+    context '#invalid?' do
+      it 'returns true' do
+        expect(status.invalid?).to be_truthy
+      end
+    end
+
+    context '#error' do
+      it 'returns nil' do
+        expect(status.error).to be_nil
+      end
+    end
+
+    context '#direct' do
+      it 'raises an error' do
+        expect { status.direct }.to raise_error(/from :too_many_redirects to :direct is forbidden/)
+      end
+    end
+
+    context '#failed' do
+      it 'raises an error' do
+        expect { status.failed('some error') }.to raise_error(/from :too_many_redirects to :failed is forbidden/)
+      end
+    end
+
+    context '#redirected' do
+      it 'raises an error' do
+        expect { status.redirected('http://www.redirected.com') }.to raise_error(/from :too_many_redirects to :redirected is forbidden/)
+      end
+    end
+
+    context '#too_many_redirects' do
+      it 'raises an error' do
+        expect { status.too_many_redirects }.to raise_error(/from :too_many_redirects to :too_many_redirects is forbidden/)
+      end
+    end
+
+    context '#unknown_host' do
+      it 'raises an error' do
+        expect { status.unknown_host }.to raise_error(/from :too_many_redirects to :unknown_host is forbidden/)
+      end
+    end
+
+    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=:too_many_redirects>$}
+      end
+    end
+  end
+
+  # ------------------------------------------------------------------------------------------------- unknown_host -----
+  context 'when code is :unknown_host' do
+    let(:uri) { 'http://www.example.com' }
+    let(:status) { NDD::UrlChecker::Status.new(uri).unknown_host }
+
+    context '#uri' do
+      it 'returns the original URI' do
+        expect(status.uri).to eq uri
+      end
+    end
+
+    context '#uris' do
+      it 'returns the original URI' do
+        expect(status.uris).to eq [uri]
+      end
+    end
+
+    context '#code' do
+      it 'returns :unknown_host' do
+        expect(status.code).to eq :unknown_host
+      end
+    end
+
+    context '#valid?' do
+      it 'returns false' do
+        expect(status.valid?).to be_falsey
+      end
+    end
+
+    context '#invalid?' do
+      it 'returns true' do
+        expect(status.invalid?).to be_truthy
+      end
+    end
+
+    context '#error' do
+      it 'returns nil' do
+        expect(status.error).to be_nil
+      end
+    end
+
+    context '#direct' do
+      it 'raises an error' do
+        expect { status.direct }.to raise_error(/from :unknown_host to :direct is forbidden/)
+      end
+    end
+
+    context '#failed' do
+      it 'raises an error' do
+        expect { status.failed('some error') }.to raise_error(/from :unknown_host to :failed is forbidden/)
+      end
+    end
+
+    context '#redirected' do
+      it 'raises an error' do
+        expect { status.redirected('http://www.redirected.com') }.to raise_error(/from :unknown_host to :redirected is forbidden/)
+      end
+    end
+
+    context '#too_many_redirects' do
+      it 'raises an error' do
+        expect { status.too_many_redirects }.to raise_error(/from :unknown_host to :too_many_redirects is forbidden/)
+      end
+    end
+
+    context '#unknown_host' do
+      it 'raises an error' do
+        expect { status.unknown_host }.to raise_error(/from :unknown_host to :unknown_host is forbidden/)
+      end
+    end
+
+    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=:unknown_host>$}
+      end
+    end
+  end
+
+end