ruby-link-checker 0.3.0 → 0.5.1

data/spec/ruby-link-checker/async/http/checker_spec.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'async'
+require 'async/http'
+
+describe LinkChecker::Async::HTTP::Checker do
+  module AsyncTestLinkChecker
+    class Task < LinkChecker::Async::HTTP::Task; end
+
+    class LinkChecker < LinkChecker::Async::HTTP::Checker
+      def check(url, options = {})
+        super
+        run
+      end
+    end
+  end
+
+  before :all do
+    VCR.configure do |config|
+      config.hook_into :webmock
+      # async-http's WebMock adapter replays responses through a real HTTP/1
+      # parser, which rejects a Transfer-Encoding header alongside a
+      # Content-Length or an empty body. Let the adapter set Content-Length.
+      config.before_playback do |interaction|
+        interaction.response.headers.delete('Transfer-Encoding')
+        interaction.response.headers.delete_if { |key, _value| key.downcase == 'content-length' }
+      end
+    end
+  end
+
+  after do
+    LinkChecker::Async::HTTP::Config.reset
+  end
+
+  describe 'concurrency' do
+    let(:checker) { described_class.new(max_concurrency: 2) }
+    let(:counts) { [] }
+    let(:completed) { [] }
+
+    before do
+      active = 0
+      5.times do
+        checker._queue do
+          counts << (active += 1)
+          sleep(0.005)
+          active -= 1
+          completed << active
+        end
+      end
+    end
+
+    it 'bounds active work and waits for queued tasks' do
+      checker.run
+      expect(counts.max).to eq(2)
+      expect(counts.size).to eq(5)
+      expect(completed.size).to eq(5)
+      expect(completed.last).to eq(0)
+    end
+
+    it 'rejects invalid limits' do
+      expect { described_class.new(max_concurrency: 0) }.to raise_error ArgumentError
+    end
+
+    it 'reuses clients for the same endpoint' do
+      expect(checker._client_for(URI('https://www.example.org/one'))).to equal(
+        checker._client_for(URI('https://www.example.org/two'))
+      )
+      checker.run
+    end
+  end
+
+  describe AsyncTestLinkChecker::LinkChecker do
+    it_behaves_like 'a link checker'
+
+    describe '.config' do
+      it 'returns the Config module' do
+        expect(LinkChecker::Async::HTTP.config).to eq LinkChecker::Async::HTTP::Config
+      end
+    end
+
+    context 'with timeout options', vcr: { cassette_name: '200' } do
+      before do
+        LinkChecker::Async::HTTP.configure do |config|
+          config.read_timeout = 5
+          config.open_timeout = 10
+        end
+        expect(Async::HTTP::Endpoint).to receive(:parse).with(
+          URI(url).to_s,
+          hash_including(timeout: 10)
+        ).and_call_original
+      end
+
+      include_context 'with url'
+
+      it 'creates requests with a default timeout' do
+        expect(result.success?).to be true
+      end
+    end
+
+    context 'with a protocol option', vcr: { cassette_name: '200' } do
+      before do
+        LinkChecker::Async::HTTP.configure do |config|
+          config.protocol = protocol
+        end
+        expect(Async::HTTP::Endpoint).to receive(:parse).with(
+          URI(url).to_s,
+          hash_including(protocol: expected_protocol)
+        ).and_call_original
+      end
+
+      include_context 'with url'
+
+      context 'http1' do
+        let(:protocol) { :http1 }
+        let(:expected_protocol) { Async::HTTP::Protocol::HTTP1 }
+
+        it 'creates requests using HTTP/1' do
+          expect(result.success?).to be true
+        end
+      end
+
+      context 'http2' do
+        let(:protocol) { :http2 }
+        let(:expected_protocol) { Async::HTTP::Protocol::HTTP2 }
+
+        it 'creates requests using HTTP/2' do
+          expect(result.success?).to be true
+        end
+      end
+    end
+
+    context 'with an unsupported protocol option' do
+      before do
+        LinkChecker::Async::HTTP.configure do |config|
+          config.protocol = :http3
+        end
+      end
+
+      include_context 'with url'
+
+      it 'raises an ArgumentError' do
+        expect(result.error?).to be true
+        expect(result.error.message).to eq('Unsupported protocol: :http3, expected :http1 or :http2')
+      end
+    end
+
+    context 'timeout' do
+      before do
+        stub_request(:get, 'https://www.example.org/').to_timeout
+      end
+
+      include_context 'with url'
+
+      around do |example|
+        VCR.turned_off { example.run }
+      end
+
+      it 'times out' do
+        expect(result.success?).to be false
+        expect(result.error?).to be true
+      end
+
+      context 'with metadata' do
+        let(:options) { { foo: :bar } }
+
+        it 'times out' do
+          expect(result.error?).to be true
+          expect(result.options).to eq(foo: :bar)
+        end
+      end
+    end
+  end
+
+  describe LinkChecker::Async::HTTP::Result do
+    describe '#code' do
+      it 'returns -1 when there is no response' do
+        request = instance_double(Protocol::HTTP::Request)
+        result = described_class.new(URI('https://www.example.org'), 'GET', nil, request, nil, {})
+        expect(result.code).to eq(-1)
+      end
+    end
+  end
+end

data/spec/ruby-link-checker/callbacks_spec.rb

@@ -6,6 +6,10 @@ describe LinkChecker::Callbacks do
   subject do
     Class.new do
       include LinkChecker::Callbacks
+
+      def logger
+        @logger ||= Logger.new(nil)
+      end
     end.new
   end
 
@@ -40,4 +44,33 @@ describe LinkChecker::Callbacks do
       expect(subject).to have_received(:called!).with(:bar)
     end
   end
+
+  context 'method_missing' do
+    it 'invokes callback for a bang method' do
+      allow(subject).to receive(:called!)
+      subject.on :foo do |data|
+        subject.called! data
+      end
+      subject.foo! :foo
+      expect(subject).to have_received(:called!).with(:foo)
+    end
+
+    it 'raises NoMethodError for a non-bang method' do
+      expect { subject.foo }.to raise_error NoMethodError
+    end
+  end
+
+  context 'when a callback raises an error' do
+    before do
+      subject.on :foo do
+        raise StandardError, 'oops'
+      end
+    end
+
+    it 'rescues and logs the error' do
+      allow(subject.logger).to receive(:error)
+      expect(subject.send(:callback, :foo)).to be false
+      expect(subject.logger).to have_received(:error)
+    end
+  end
 end

data/spec/ruby-link-checker/checker_spec.rb

@@ -2,9 +2,96 @@
 require 'spec_helper'
 
 describe LinkChecker::Checker do
-    context 'config' do
+  describe LinkChecker::Cache do
+    let(:directory) { Dir.mktmpdir('link-checker-spec-') }
+    let(:file) { File.join(directory, 'cache.json') }
+    let(:cache) { described_class.new({ file: file, ttl: 60 }, logger: LinkChecker::Logger.default) }
+    let(:result) do
+      LinkChecker::Net::HTTP::Result.new(
+        URI('https://www.example.org/final'), 'GET', URI('https://www.example.org/'),
+        {}, Net::HTTPOK.new('1.1', '200', 'OK'), { location: 'private.html' }
+      )
+    end
+
+    after do
+      FileUtils.remove_entry(directory)
+    end
+
+    it 'expires successful entries using the configured TTL' do
+      cache.store('key', result)
+      allow(Time).to receive(:now).and_return(Time.now + 61)
+      expect(cache.fetch('key', 'https://www.example.org/')).to be_nil
+    end
+
+    it 'retains the final URL and status without persisting metadata or headers' do
+      cache.store('key', result)
+      restored = cache.fetch('key', 'https://www.example.org/')
+      expect(restored.result_uri.to_s).to eq('https://www.example.org/final')
+      expect(restored.code).to eq(200)
+      data = JSON.parse(File.read(file)).fetch('entries').fetch('key')
+      expect(data.keys).to contain_exactly('checked_at', 'method', 'code', 'result_uri')
+    end
+
+    it 'merges writes from separate cache instances' do
+      other_cache = described_class.new({ file: file, ttl: 60 }, logger: LinkChecker::Logger.default)
+      cache.store('one', result)
+      other_cache.store('two', result)
+      expect(cache.fetch('one', 'https://www.example.org/')).not_to be_nil
+      expect(cache.fetch('two', 'https://www.example.org/')).not_to be_nil
+    end
+
+    it 'recovers from corrupted cache files' do
+      File.write(file, 'invalid JSON')
+      expect(cache.fetch('key', 'https://www.example.org/')).to be_nil
+      cache.store('key', result)
+      expect(cache.fetch('key', 'https://www.example.org/').code).to eq(200)
+    end
+
+    it 'ignores malformed cache entries' do
+      File.write(file, JSON.generate('version' => 1, 'entries' => { 'key' => true }))
+      expect(cache.fetch('key', 'https://www.example.org/')).to be_nil
+    end
+
+    it 'does not store credentials in redirect URLs' do
+      result.result_uri = URI('https://user:password@www.example.org/')
+      cache.store('key', result)
+      expect(File).not_to exist(file)
+    end
+
+    it 'requires an explicit file and TTL' do
+      expect { described_class.new({}, logger: LinkChecker::Logger.default) }.to raise_error ArgumentError
+      expect { described_class.new({ file: file }, logger: LinkChecker::Logger.default) }.to raise_error ArgumentError
+    end
+
+    it 'does not turn a cache write failure into a failed link' do
+      allow(FileUtils).to receive(:mkdir_p).and_raise(Errno::EACCES)
+      expect { cache.store('key', result) }.not_to raise_error
+    end
+  end
+
+  context 'config' do
     it 'requires at least one method' do
-      expect { LinkChecker::Checker.new(methods: []) }.to raise_error ArgumentError, 'Missing methods.'
+      expect { described_class.new(methods: []) }.to raise_error ArgumentError, 'Missing methods.'
+    end
+
+    it 'rejects an invalid redirect limit' do
+      expect { described_class.new(max_redirects: -1) }.to raise_error ArgumentError, 'Invalid redirect limit: -1'
+    end
+
+    it 'validates retry delays and backoff' do
+      expect { described_class.new(retry_after: -1) }.to raise_error ArgumentError
+      expect { described_class.new(retry_backoff: 0.5) }.to raise_error ArgumentError
+      expect { described_class.new(retry_jitter: 2) }.to raise_error ArgumentError
+      expect { described_class.new(max_retry_delay: Float::INFINITY) }.to raise_error ArgumentError
+    end
+
+    it 'rejects invalid retry status codes' do
+      expect { described_class.new(retry_status_codes: ['503']) }.to raise_error ArgumentError
+    end
+
+    it 'allows per-instance disabling of global Retry-After handling' do
+      LinkChecker.config.respect_retry_after = true
+      expect(described_class.new(respect_retry_after: false).respect_retry_after).to be false
     end
   end
 end

data/spec/ruby-link-checker/config_spec.rb

@@ -19,6 +19,12 @@ describe LinkChecker::Config do
       it 'requires a positive integer' do
         expect { LinkChecker.config.retries = -1 }.to raise_error ArgumentError, 'Invalid number of retries: -1'
       end
+
+      context 'max_redirects' do
+        it 'rejects negative limits' do
+          expect { LinkChecker.config.max_redirects = -1 }.to raise_error ArgumentError, 'Invalid redirect limit: -1'
+        end
+      end
     end
   end
 

data/spec/ruby-link-checker/errors/redirect_loop_error_spec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe LinkChecker::Errors::RedirectLoopError do
+  subject(:error) do
+    described_class.new(['https://www.example.org', 'https://www.example.org/redirect'])
+  end
+
+  it 'returns the last url' do
+    expect(error.url).to eq 'https://www.example.org/redirect'
+  end
+
+  it 'formats a message with all urls' do
+    expect(error.message)
+      .to eq 'Redirect loop: https://www.example.org -> https://www.example.org/redirect.'
+  end
+end

data/spec/ruby-link-checker/net/http/checker_spec.rb

@@ -15,6 +15,27 @@ describe LinkChecker::Net::HTTP::Checker do
 
   it_behaves_like 'a link checker'
 
+  context 'with an HTTP URL' do
+    let(:checker) { described_class.new(methods: ['GET']) }
+
+    around do |example|
+      VCR.turned_off { example.run }
+    end
+
+    it 'does not enable TLS' do
+      stub_request(:get, 'http://www.example.org/').to_return(status: 200)
+      checker.check('http://www.example.org/')
+      expect(checker.results[:success].first.code).to eq(200)
+      expect(a_request(:get, 'http://www.example.org/')).to have_been_made.once
+    end
+  end
+
+  describe '.config' do
+    it 'returns the Config module' do
+      expect(LinkChecker::Net::HTTP.config).to eq LinkChecker::Net::HTTP::Config
+    end
+  end
+
   context 'with timeout options', vcr: { cassette_name: '200' } do
     before do
       LinkChecker::Net::HTTP.configure do |config|
@@ -58,4 +79,15 @@ describe LinkChecker::Net::HTTP::Checker do
       end
     end
   end
+
+  describe LinkChecker::Net::HTTP::Result do
+    describe '#code' do
+      it 'returns -1 when the response raises' do
+        response = instance_double(Net::HTTPResponse)
+        allow(response).to receive(:code).and_raise(StandardError)
+        result = described_class.new(URI('https://www.example.org'), 'GET', nil, nil, response, {})
+        expect(result.code).to eq(-1)
+      end
+    end
+  end
 end

data/spec/ruby-link-checker/result_error_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe LinkChecker::ResultError do
+  subject(:result) do
+    described_class.new('https://www.example.org', 'GET', 'https://www.example.org', StandardError.new('oops'))
+  end
+
+  it 'is an error' do
+    expect(result.error?).to be true
+  end
+
+  it 'returns the error class name as code' do
+    expect(result.code).to eq 'StandardError'
+  end
+
+  it 'classifies native timeouts without replacing the exception' do
+    error = Net::ReadTimeout.new('timeout')
+    result.error = error
+    expect(result.error_type).to eq(:timeout)
+    expect(result.error).to equal(error)
+  end
+
+  it 'classifies native connection failures' do
+    result.error = Errno::ECONNREFUSED.new
+    expect(result.error_type).to eq(:connection)
+  end
+
+  it 'does not classify programming errors as transient' do
+    result.error = ArgumentError.new
+    expect(result.error_type).to eq(:other)
+  end
+end

data/spec/ruby-link-checker/result_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe LinkChecker::Result do
+  subject(:result) do
+    described_class.new('https://www.example.org', 'GET', 'https://www.example.org')
+  end
+
+  it 'defaults to not successful' do
+    expect(result.success?).to be false
+  end
+
+  it 'defaults to not a failure' do
+    expect(result.failure?).to be false
+  end
+
+  it 'defaults to not an error' do
+    expect(result.error?).to be false
+  end
+
+  it 'defaults to not a redirect' do
+    expect(result.redirect?).to be false
+  end
+
+  it 'defaults redirect_to to nil' do
+    expect(result.redirect_to).to be_nil
+  end
+
+  it 'defaults request_headers to an empty hash' do
+    expect(result.request_headers).to eq({})
+  end
+
+  it 'defaults code to nil' do
+    expect(result.code).to be_nil
+  end
+
+  it 'defaults error to nil' do
+    expect(result.error).to be_nil
+  end
+end

data/spec/ruby-link-checker/task_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe LinkChecker::Task do
+  subject(:task) do
+    described_class.new(
+      LinkChecker::Net::HTTP::Checker.new,
+      'https://www.example.org',
+      'GET',
+      'https://www.example.org'
+    )
+  end
+
+  describe '#run!' do
+    it 'raises NotImplementedError' do
+      expect { task.run! }.to raise_error NotImplementedError
+    end
+  end
+end

data/spec/ruby-link-checker/tasks_spec.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe LinkChecker::Tasks do
+  describe 'retry delays' do
+    let(:checker) { LinkChecker::Net::HTTP::Checker.new }
+    let(:tasks) { described_class.new(checker, LinkChecker::Net::HTTP::Task, 'https://www.example.org', ['GET']) }
+    let(:headers) { { 'Retry-After' => '60' } }
+    let(:result) { instance_double(LinkChecker::Net::HTTP::Result, response_headers: headers) }
+
+    before do
+      allow(tasks).to receive(:result).and_return(result)
+    end
+
+    it 'parses delta-seconds' do
+      expect(tasks.send(:_server_retry_delay)).to eq(60)
+    end
+
+    context 'with a past HTTP date' do
+      let(:headers) { { 'Retry-After' => (Time.now - 60).httpdate } }
+
+      it 'does not delay a retry' do
+        expect(tasks.send(:_server_retry_delay)).to eq(0)
+      end
+    end
+
+    context 'with an invalid negative delay' do
+      let(:headers) { { 'Retry-After' => '-5' } }
+
+      it 'does not delay a retry' do
+        expect(tasks.send(:_server_retry_delay)).to eq(0)
+      end
+    end
+
+    it 'caps configured delays' do
+      checker.retry_after = 120
+      checker.max_retry_delay = 10
+      expect(tasks.send(:_retry_delay)).to eq(10)
+    end
+
+    it 'adds jitter without reducing the minimum delay' do
+      checker.retry_after = 2
+      checker.retry_jitter = 0.5
+      allow(tasks).to receive(:rand).and_return(0.5)
+      expect(tasks.send(:_retry_delay)).to eq(2.5)
+    end
+  end
+
+  describe '#_handle_result' do
+    # Reproduces issue #12: SystemStackError when logging causes repeated errors
+    # https://github.com/dblock/ruby-link-checker/issues/12
+    context 'when logger.info raises an error repeatedly' do
+      let(:checker) { LinkChecker::Net::HTTP::Checker.new(methods: ['GET']) }
+      let(:task_klass) { LinkChecker::Net::HTTP::Task }
+      let(:url) { 'https://www.example.org' }
+
+      before do
+        stub_request(:get, url).to_return(status: 200, body: '', headers: {})
+      end
+
+      it 'does not cause infinite recursion leading to SystemStackError' do
+        tasks = described_class.new(checker, task_klass, url, ['GET'])
+
+        # Stub logger to always raise an error on info, simulating the scenario
+        # from issue #12 where logging causes a stack overflow due to the
+        # rescue block in _handle_result recursively calling itself
+        allow(tasks).to receive(:logger).and_return(
+          instance_double(LinkChecker::Logger).tap do |logger|
+            allow(logger).to receive(:info).and_raise(StandardError, 'stack level too deep')
+            allow(logger).to receive(:error)
+          end
+        )
+
+        # Should not raise SystemStackError - the error should be handled gracefully
+        expect { tasks.execute! }.not_to raise_error
+      end
+    end
+  end
+
+  describe '#retries' do
+    let(:checker) { LinkChecker::Net::HTTP::Checker.new(methods: ['GET'], retries: 2) }
+    let(:task_klass) { LinkChecker::Net::HTTP::Task }
+    let(:url) { 'https://www.example.org' }
+
+    it 'delegates to the checker' do
+      tasks = described_class.new(checker, task_klass, url, ['GET'])
+      expect(tasks.send(:retries)).to eq 2
+    end
+  end
+end