Back to Repositories

Testing Adapter Timeout Configuration in Faraday

This test suite validates the timeout handling functionality in Faraday’s Adapter class. It thoroughly examines how different types of timeouts are managed and prioritized within HTTP requests, ensuring robust timeout behavior for network operations.

Test Coverage Overview

The test suite provides comprehensive coverage of timeout handling mechanisms in Faraday’s Adapter.

Key areas tested include:

Read timeout configuration and fallback behavior
Open timeout settings and inheritance
Write timeout management and default values
Error handling for invalid timeout types

Implementation Analysis

The testing approach utilizes RSpec’s context-based structure to organize related timeout scenarios. It employs let blocks for common setup and implements helper methods for cleaner test execution.

Key patterns include:

Isolated timeout type testing
Priority-based timeout resolution
Error condition validation

Technical Details

Testing infrastructure includes:

RSpec as the testing framework
Frozen string literals for optimization
Custom helper methods for timeout verification
Mock request hash for simulating configurations

Best Practices Demonstrated

The test suite exemplifies several testing best practices:

Clear test case isolation
DRY principle through helper methods
Explicit error case handling
Consistent assertion patterns
Well-structured test organization

lostisland/faraday

spec/faraday/adapter_spec.rb

            
# frozen_string_literal: true

RSpec.describe Faraday::Adapter do
  let(:adapter) { Faraday::Adapter.new }
  let(:request) { {} }

  context '#request_timeout' do
    it 'gets :read timeout' do
      expect(timeout(:read)).to eq(nil)

      request[:timeout] = 5
      request[:write_timeout] = 1

      expect(timeout(:read)).to eq(5)

      request[:read_timeout] = 2

      expect(timeout(:read)).to eq(2)
    end

    it 'gets :open timeout' do
      expect(timeout(:open)).to eq(nil)

      request[:timeout] = 5
      request[:write_timeout] = 1

      expect(timeout(:open)).to eq(5)

      request[:open_timeout] = 2

      expect(timeout(:open)).to eq(2)
    end

    it 'gets :write timeout' do
      expect(timeout(:write)).to eq(nil)

      request[:timeout] = 5
      request[:read_timeout] = 1

      expect(timeout(:write)).to eq(5)

      request[:write_timeout] = 2

      expect(timeout(:write)).to eq(2)
    end

    it 'attempts unknown timeout type' do
      expect { timeout(:unknown) }.to raise_error(ArgumentError)
    end

    def timeout(type)
      adapter.send(:request_timeout, type, request)
    end
  end
end