format_parser 1.7.0 → 2.0.0.pre.2

data/lib/read_limiter.rb

@@ -45,9 +45,7 @@ class FormatParser::ReadLimiter
   # @return Integer
   def seek(to)
     @seeks += 1
-    if @max_seeks && @seeks > @max_seeks
-      raise BudgetExceeded, 'Seek budget exceeded (%d seeks performed)' % @max_seeks
-    end
+    raise BudgetExceeded, 'Seek budget exceeded (%d seeks performed)' % @max_seeks if @max_seeks && @seeks > @max_seeks
     @io.seek(to)
   end
 
@@ -60,26 +58,20 @@ class FormatParser::ReadLimiter
     @bytes += n_bytes
     @reads += 1
 
-    if @max_bytes && @bytes > @max_bytes
-      raise BudgetExceeded, 'Read bytes budget (%d) exceeded' % @max_bytes
-    end
-
-    if @max_reads && @reads > @max_reads
-      raise BudgetExceeded, 'Number of read() calls exceeded (%d max)' % @max_reads
-    end
+    raise BudgetExceeded, 'Read bytes budget (%d) exceeded' % @max_bytes if @max_bytes && @bytes > @max_bytes
+    raise BudgetExceeded, 'Number of read() calls exceeded (%d max)' % @max_reads if @max_reads && @reads > @max_reads
 
     @io.read(n_bytes)
   end
 
   # Sends the metrics about the state of this ReadLimiter to a Measurometer
   #
-  # @param prefix[String] the prefix to set. For example, with prefix "TIFF" the metrics will be called
-  #   `format_parser.TIFF.read_limiter.num_seeks` and so forth
+  # @param parser[String] the parser to add as a tag.
   # @return void
-  def send_metrics(prefix)
-    Measurometer.add_distribution_value('format_parser.%s.read_limiter.num_seeks' % prefix, @seeks)
-    Measurometer.add_distribution_value('format_parser.%s.read_limiter.num_reads' % prefix, @reads)
-    Measurometer.add_distribution_value('format_parser.%s.read_limiter.read_bytes' % prefix, @bytes)
+  def send_metrics(parser)
+    Measurometer.add_distribution_value('format_parser.read_limiter.num_seeks', @seeks, parser: parser)
+    Measurometer.add_distribution_value('format_parser.read_limiter.num_reads', @reads, parser: parser)
+    Measurometer.add_distribution_value('format_parser.read_limiter.read_bytes', @bytes, parser: parser)
   end
 
   # Resets all the recorded call counters so that the object can be reused for the next parser,

data/lib/remote_io.rb

@@ -1,14 +1,14 @@
+require 'net/http'
+
 # Acts as a wrapper for turning a given URL into an IO object
-# you can read from and seek in. Uses Faraday under the hood
-# to perform fetches, so if you apply Faraday configuration
-# tweaks using `Faraday.default_connection = ...` these will
-# take effect for these RemoteIO objects as well
+# you can read from and seek in.
 class FormatParser::RemoteIO
   class UpstreamError < StandardError
     # @return Integer
     attr_reader :status_code
+
     def initialize(status_code, message)
-      @status_code = status_code
+      @status_code = Integer(status_code)
       super(message)
     end
   end
@@ -23,13 +23,19 @@ class FormatParser::RemoteIO
   class InvalidRequest < UpstreamError
   end
 
-  # @param uri[URI, String] the remote URL to obtain
+  # Represents a failure where the maximum amount of
+  # redirect requests are exceeded.
+  class RedirectLimitReached < UpstreamError
+    def initialize(uri)
+      super(504, "Too many redirects; last one to: #{uri}")
+    end
+  end
+
+  # @param uri[String, URI::Generic] the remote URL to obtain
   # @param headers[Hash] (optional) the HTTP headers to be used in the HTTP request
   def initialize(uri, headers: {})
-    require 'faraday'
-    require 'faraday_middleware/response/follow_redirects'
     @headers = headers
-    @uri = uri
+    @uri = URI(uri)
     @pos = 0
     @remote_size = false
   end
@@ -63,7 +69,7 @@ class FormatParser::RemoteIO
   # @return [String] the read bytes
   def read(n_bytes)
     http_range = (@pos..(@pos + n_bytes - 1))
-    maybe_size, maybe_body = Measurometer.instrument('format_parser.RemoteIO.read') { request_range(http_range) }
+    maybe_size, maybe_body = Measurometer.instrument('format_parser.remote_io.read') { request_range(http_range) }
     if maybe_size && maybe_body
       @remote_size = maybe_size
       @pos += maybe_body.bytesize
@@ -73,23 +79,39 @@ class FormatParser::RemoteIO
 
   protected
 
+  REDIRECT_LIMIT = 3
+  UNSAFE_URI_CHARS = %r{[^\-_.!~*'()a-zA-Z\d;/?:@&=+$,\[\]%]}
+
+  # Generate the URI to fetch from following a redirect response.
+  #
+  # @param location[String] The new URI reference, as provided by the Location header of the previous response.
+  # @param previous_uri[URI] The URI used in the previous request.
+  def redirect_uri(location, previous_uri)
+    # Escape unsafe characters in location. Use location as new URI if absolute, otherwise use it to replace the path of
+    # the previous URI.
+    new_uri = previous_uri.merge(location.to_s.gsub(UNSAFE_URI_CHARS) do |unsafe_char|
+      "%#{unsafe_char.unpack('H2' * unsafe_char.bytesize).join('%').upcase}"
+    end)
+    # Keep previous URI's fragment if not present in location (https://www.rfc-editor.org/rfc/rfc9110.html#section-10.2.2-5)
+    new_uri.fragment = previous_uri.fragment unless new_uri.fragment
+    new_uri
+  end
+
   # Only used internally when reading the remote file
   #
-  # @param range[Range] the HTTP range of data to fetch from remote
-  # @return [String] the response body of the ranged request
-  def request_range(range)
+  # @param range[Range] The HTTP range of data to fetch from remote
+  # @param uri[URI] The URI to fetch from
+  # @param redirects[Integer] The amount of remaining permitted redirects
+  # @return [[Integer, String]] The response body of the ranged request
+  def request_range(range, uri = @uri, redirects = REDIRECT_LIMIT)
     # We use a GET and not a HEAD request followed by a GET because
     # S3 does not allow HEAD requests if you only presigned your URL for GETs, so we
     # combine the first GET of a segment and retrieving the size of the resource
-    conn = Faraday.new(headers: @headers) do |faraday|
-      faraday.use FaradayMiddleware::FollowRedirects
-      # we still need the default adapter, more details: https://blog.thecodewhisperer.com/permalink/losing-time-to-faraday
-      faraday.adapter Faraday.default_adapter
+    response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
+      http.request_get(uri, @headers.merge({ 'range' => 'bytes=%d-%d' % [range.begin, range.end] }))
     end
-    response = conn.get(@uri, nil, range: 'bytes=%d-%d' % [range.begin, range.end])
-
-    case response.status
-    when 200
+    case response
+    when Net::HTTPOK
       # S3 returns 200 when you request a Range that is fully satisfied by the entire object,
       # we take that into account here. Also, for very tiny responses (and also for empty responses)
       # the responses are going to be 200 which does not mean we cannot proceed
@@ -100,16 +122,16 @@ class FormatParser::RemoteIO
         error_message = [
           "We requested #{requested_range_size} bytes, but the server sent us more",
           "(#{response_size} bytes) - it likely has no `Range:` support.",
-          "The error occurred when talking to #{@uri})"
+          "The error occurred when talking to #{uri}"
         ]
-        raise InvalidRequest.new(response.status, error_message.join("\n"))
+        raise InvalidRequest.new(response.code, error_message.join("\n"))
       end
       [response_size, response.body]
-    when 206
+    when Net::HTTPPartialContent
       # Figure out of the server supports content ranges, if it doesn't we have no
       # business working with that server
-      range_header = response.headers['Content-Range']
-      raise InvalidRequest.new(response.status, "The server replied with 206 status but no Content-Range at #{@uri}") unless range_header
+      range_header = response['Content-Range']
+      raise InvalidRequest.new(response.code, "The server replied with 206 status but no Content-Range at #{uri}") unless range_header
 
       # "Content-Range: bytes 0-0/307404381" is how the response header is structured
       size = range_header[/\/(\d+)$/, 1].to_i
@@ -117,19 +139,30 @@ class FormatParser::RemoteIO
       # If we request a _larger_ range than what can be satisfied by the server,
       # the response is going to only contain what _can_ be sent and the status is also going
       # to be 206
-      return [size, response.body]
-    when 416
+      [size, response.body]
+    when Net::HTTPMovedPermanently, Net::HTTPFound, Net::HTTPSeeOther, Net::HTTPTemporaryRedirect, Net::HTTPPermanentRedirect
+      raise RedirectLimitReached, uri if redirects == 0
+      location = response['location']
+      if location
+        new_uri = redirect_uri(location, uri)
+        # Clear the Authorization header if the new URI has a different host.
+        @headers.delete('Authorization') unless [@uri.scheme, @uri.host, @uri.port] == [new_uri.scheme, new_uri.host, new_uri.port]
+        request_range(range, new_uri, redirects - 1)
+      else
+        raise InvalidRequest.new(response.code, "Server at #{uri} replied with a #{response.code}, indicating redirection; however, the location header was empty.")
+      end
+    when Net::HTTPRangeNotSatisfiable
       # We return `nil` if we tried to read past the end of the IO,
       # which satisfies the Ruby IO convention. The caller should deal with `nil` being the result of a read()
       # S3 will also handily _not_ supply us with the Content-Range of the actual resource, so we
       # cannot hint size with this response - at lease not when working with S3
-      return
-    when 500..599
-      Measurometer.increment_counter('format_parser.RemoteIO.upstream50x_errors', 1)
-      raise IntermittentFailure.new(response.status, "Server at #{@uri} replied with a #{response.status} and we might want to retry")
+      nil
+    when Net::HTTPServerError
+      Measurometer.increment_counter('format_parser.remote_io.upstream50x_errors', 1)
+      raise IntermittentFailure.new(response.code, "Server at #{uri} replied with a #{response.code} and we might want to retry")
     else
-      Measurometer.increment_counter('format_parser.RemoteIO.invalid_request_errors', 1)
-      raise InvalidRequest.new(response.status, "Server at #{@uri} replied with a #{response.status} and refused our request")
+      Measurometer.increment_counter('format_parser.remote_io.invalid_request_errors', 1)
+      raise InvalidRequest.new(response.code, "Server at #{uri} replied with a #{response.code} and refused our request")
     end
   end
 end

data/lib/string.rb

@@ -0,0 +1,9 @@
+class String
+  def underscore
+    gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
+    gsub(/([a-z\d])([A-Z])/, '\1_\2').
+    tr('-', '_').
+    downcase
+  end
+end

data/spec/attributes_json_spec.rb

@@ -106,9 +106,6 @@ describe FormatParser::AttributesJSON do
       struct: Struct.new(:key).new('Value'),
       content: "\x01\xFF\xFEb\x00i\x00r\x00d\x00s\x00 \x005\x00 \x00m\x00o\x00r\x00e\x00 \x00c\x00o\x00m\x00p\x00".b
     }
-    expect {
-      JSON.pretty_generate(nasty_hash) # Should not raise an error
-    }.to raise_error(Encoding::UndefinedConversionError)
 
     anon_class = Struct.new(:evil)
     anon_class.include FormatParser::AttributesJSON

data/spec/remote_fetching_spec.rb

@@ -124,14 +124,9 @@ describe 'Fetching data from HTTP remotes' do
   end
 
   it 'sends provided HTTP headers in the request' do
-    # Faraday is required only after calling .parse_http
-    # This line is just to trigger this require, then it's possible to
-    # add an expectation of how Faraday is initialized after.
-    FormatParser.parse_http('invalid_url') rescue nil
-
-    expect(Faraday)
-      .to receive(:new)
-      .with(headers: {'test-header' => 'test-value'})
+    expect_any_instance_of(Net::HTTP)
+      .to receive(:request_get)
+      .with(anything, a_hash_including('test-header' => 'test-value'))
       .and_call_original
 
     file_information = FormatParser.parse_http(

data/spec/remote_io_spec.rb

@@ -3,131 +3,270 @@ require 'spec_helper'
 describe FormatParser::RemoteIO do
   it_behaves_like 'an IO object compatible with IOConstraint'
 
-  it 'returns the partial content when the server supplies a 206 status' do
-    rio = described_class.new('https://images.invalid/img.jpg')
+  # 2XX
+
+  context 'when the response code is 200 (OK)' do
+    context 'when the response size does not exceed the requested range' do
+      it 'returns the entire response body' do
+        url = 'https://images.invalid/img.jpg'
+        body = 'response body'
+
+        stub = stub_request(:get, url)
+          .with(headers: { 'range' => 'bytes=10-109' })
+          .to_return(body: body, status: 200)
+
+        rio = described_class.new(url)
+        rio.seek(10)
+        read_result = rio.read(100)
+
+        expect(read_result).to eq(body)
+        expect(stub).to have_been_requested
+      end
+    end
+
+    context 'when the response size exceeds the requested range' do
+      it 'raises an error' do
+        url = 'https://images.invalid/img.jpg'
+        body = 'This response is way longer than 10 bytes.'
+
+        stub = stub_request(:get, url)
+          .with(headers: { 'range' => 'bytes=10-19' })
+          .to_return(body: body, status: 200)
+
+        rio = described_class.new(url)
+        rio.seek(10)
+
+        expect { rio.read(10) }.to raise_error(
+          "We requested 10 bytes, but the server sent us more\n"\
+          "(42 bytes) - it likely has no `Range:` support.\n"\
+          "The error occurred when talking to #{url}"
+        )
+        expect(stub).to have_been_requested
+      end
+    end
+  end
 
-    fake_resp = double(headers: {'Content-Range' => '10-109/2577'}, status: 206, body: 'This is the response')
-    faraday_conn = instance_double(Faraday::Connection, get: fake_resp)
-    allow(Faraday).to receive(:new).and_return(faraday_conn)
-    expect(faraday_conn).to receive(:get).with('https://images.invalid/img.jpg', nil, range: 'bytes=10-109')
+  context 'when the response status code is 206 (Partial Content)' do
+    context 'when the Content-Range header is present' do
+      it 'returns the response body' do
+        url = 'https://images.invalid/img.jpg'
+        body = 'response body'
 
-    rio.seek(10)
-    read_result = rio.read(100)
-    expect(read_result).to eq('This is the response')
-  end
+        stub = stub_request(:get, url)
+          .with(headers: { 'range' => 'bytes=10-109' })
+          .to_return(body: body, headers: { 'Content-Range' => '10-109/2577' }, status: 206)
 
-  it 'returns the entire content when the server supplies the Content-Range response but sends a 200 status' do
-    rio = described_class.new('https://images.invalid/img.jpg')
+        rio = described_class.new(url)
+        rio.seek(10)
+        read_result = rio.read(100)
 
-    fake_resp = double(headers: {'Content-Range' => '10-109/2577'}, status: 200, body: 'This is the response')
-    faraday_conn = instance_double(Faraday::Connection, get: fake_resp)
-    allow(Faraday).to receive(:new).and_return(faraday_conn)
-    expect(faraday_conn).to receive(:get).with('https://images.invalid/img.jpg', nil, range: 'bytes=10-109')
+        expect(read_result).to eq(body)
+        expect(stub).to have_been_requested
+      end
 
-    rio.seek(10)
-    read_result = rio.read(100)
-    expect(read_result).to eq('This is the response')
-  end
+      it 'maintains and exposes pos' do
+        url = 'https://images.invalid/img.jpg'
 
-  it 'raises a specific error for all 4xx responses except 416' do
-    rio = described_class.new('https://images.invalid/img.jpg')
+        stub = stub_request(:get, url)
+          .with(headers: { 'range' => 'bytes=0-0' })
+          .to_return(body: 'a', headers: { 'Content-Range' => '0-0/13' }, status: 206)
 
-    fake_resp = double(headers: {}, status: 403, body: 'Please log in')
-    faraday_conn = instance_double(Faraday::Connection, get: fake_resp)
-    allow(Faraday).to receive(:new).and_return(faraday_conn)
-    expect(faraday_conn).to receive(:get).with('https://images.invalid/img.jpg', nil, range: 'bytes=100-199')
+        rio = described_class.new(url)
 
-    rio.seek(100)
-    expect { rio.read(100) }.to raise_error(/replied with a 403 and refused/)
-  end
+        expect(rio.pos).to eq(0)
 
-  it 'returns nil on a 416 response' do
-    rio = described_class.new('https://images.invalid/img.jpg')
+        rio.read(1)
 
-    fake_resp = double(headers: {}, status: 416, body: 'You stepped off the ledge of the range')
-    faraday_conn = instance_double(Faraday::Connection, get: fake_resp)
-    allow(Faraday).to receive(:new).and_return(faraday_conn)
-    expect(faraday_conn).to receive(:get).with('https://images.invalid/img.jpg', nil, range: 'bytes=100-199')
+        expect(rio.pos).to eq(1)
+        expect(stub).to have_been_requested
+      end
+    end
 
-    rio.seek(100)
-    expect(rio.read(100)).to be_nil
-  end
+    context 'when the Content-Range header is not present' do
+      it 'raises an error' do
+        url = 'https://images.invalid/img.jpg'
+
+        stub = stub_request(:get, url)
+          .with(headers: { 'range' => 'bytes=10-109' })
+          .to_return(status: 206)
 
-  it 'sets the status_code of the exception on a 4xx response from upstream' do
-    rio = described_class.new('https://images.invalid/img.jpg')
+        rio = described_class.new(url)
+        rio.seek(10)
 
-    fake_resp = double(headers: {}, status: 403, body: 'Please log in')
-    faraday_conn = instance_double(Faraday::Connection, get: fake_resp)
-    allow(Faraday).to receive(:new).and_return(faraday_conn)
-    expect(faraday_conn).to receive(:get).with('https://images.invalid/img.jpg', nil, range: 'bytes=100-199')
+        expect { rio.read(100) }.to raise_error("The server replied with 206 status but no Content-Range at #{url}")
+        expect(stub).to have_been_requested
+      end
+    end
+  end
 
-    rio.seek(100)
-    # rubocop: disable Lint/AmbiguousBlockAssociation
-    expect { rio.read(100) }.to raise_error { |e| expect(e.status_code).to eq(403) }
+  # 3XX
+
+  [301, 302, 303, 307, 308].each do |code|
+    context "when the response code is #{code}" do
+      context 'when the location header is present and the redirect limit is not exceeded' do
+        context 'when the location is absolute' do
+          it 'redirects to the specified location, without the Authorization header' do
+            redirecting_url = 'https://my_images.invalid/my_image'
+            destination_url = 'https://images.invalid/img.jpg'
+            body = 'response body'
+
+            redirect_stub = stub_request(:get, redirecting_url)
+              .with(headers: { 'Authorization' => 'token', 'range' => 'bytes=10-109' })
+              .to_return(headers: { 'location' => destination_url }, status: code)
+            destination_stub = stub_request(:get, destination_url)
+              .with { |request| request.headers['Range'] == 'bytes=10-109' && !request.headers.key?('Authorization') }
+              .to_return(body: body, status: 200)
+
+            rio = described_class.new(redirecting_url, headers: { 'Authorization' => 'token' })
+            rio.seek(10)
+            read_result = rio.read(100)
+
+            expect(read_result).to eq(body)
+            expect(redirect_stub).to have_been_requested
+            expect(destination_stub).to have_been_requested
+          end
+        end
+
+        context 'when the location is relative' do
+          it 'redirects to the specified location under the same host, with the same Authorization header' do
+            host = 'https://images.invalid'
+            redirecting_path = '/my_image'
+            redirecting_url = host + redirecting_path
+            destination_path = '/img.jpg'
+            destination_url = host + destination_path
+            body = 'response body'
+
+            redirect_stub = stub_request(:get, redirecting_url)
+              .with(headers: { 'Authorization' => 'token', 'range' => 'bytes=10-109' })
+              .to_return(headers: { 'location' => destination_path }, status: code)
+            destination_stub = stub_request(:get, destination_url)
+              .with(headers: { 'Authorization' => 'token', 'range' => 'bytes=10-109' })
+              .to_return(body: body, status: 200)
+
+            rio = described_class.new(redirecting_url, headers: { 'Authorization' => 'token' })
+            rio.seek(10)
+            read_result = rio.read(100)
+
+            expect(read_result).to eq(body)
+            expect(redirect_stub).to have_been_requested
+            expect(destination_stub).to have_been_requested
+          end
+        end
+      end
+
+      context 'when the location header is not present' do
+        it 'raises an error' do
+          url = 'https://images.invalid/my_image'
+
+          stub = stub_request(:get, url)
+            .with(headers: { 'range' => 'bytes=10-109' })
+            .to_return(status: code)
+
+          rio = described_class.new(url)
+          rio.seek(10)
+
+          expect { rio.read(100) }.to raise_error("Server at #{url} replied with a #{code}, indicating redirection; however, the location header was empty.")
+          expect(stub).to have_been_requested
+        end
+      end
+
+      context 'when the redirect limit is exceeded' do
+        it 'raises an error' do
+          redirecting_url = 'https://images.invalid/my_image'
+          destination_url = 'https://images.invalid/img.jpg'
+
+          stub = stub_request(:get, /https:\/\/images\.invalid.*/)
+            .with(headers: { 'range' => 'bytes=10-109' })
+            .to_return(headers: { 'location' => destination_url }, status: code)
+
+          rio = described_class.new(redirecting_url)
+          rio.seek(10)
+
+          expect { rio.read(100) }.to raise_error("Too many redirects; last one to: #{destination_url}")
+          expect(stub).to have_been_requested.times(4)
+        end
+      end
+    end
   end
 
-  it 'returns a nil when the range cannot be satisfied and the response is 416' do
-    rio = described_class.new('https://images.invalid/img.jpg')
+  # 4XX
 
-    fake_resp = double(headers: {}, status: 416, body: 'You jumped off the end of the file maam')
-    faraday_conn = instance_double(Faraday::Connection, get: fake_resp)
-    allow(Faraday).to receive(:new).and_return(faraday_conn)
-    expect(faraday_conn).to receive(:get).with('https://images.invalid/img.jpg', nil, range: 'bytes=100-199')
+  context 'when the response status code is 416 (Range Not Satisfiable)' do
+    it 'returns nil' do
+      url = 'https://images.invalid/img.jpg'
 
-    rio.seek(100)
-    expect(rio.read(100)).to be_nil
-  end
+      stub = stub_request(:get, url)
+        .with(headers: { 'range' => 'bytes=100-199' })
+        .to_return(status: 416)
+
+      rio = described_class.new(url)
+      rio.seek(100)
 
-  it 'does not overwrite size when the range cannot be satisfied and the response is 416' do
-    rio = described_class.new('https://images.invalid/img.jpg')
+      expect(rio.read(100)).to be_nil
+      expect(stub).to have_been_requested
+    end
 
-    fake_resp1 = double(headers: {'Content-Range' => 'bytes 0-0/13'}, status: 206, body: 'a')
-    fake_resp2 = double(headers: {}, status: 416, body: 'You jumped off the end of the file maam')
+    it 'does not change pos or size' do
+      url = 'https://images.invalid/img.jpg'
 
-    faraday_conn = instance_double(Faraday::Connection)
-    allow(Faraday).to receive(:new).and_return(faraday_conn)
-    expect(faraday_conn).to receive(:get)
-      .with('https://images.invalid/img.jpg', nil, range: 'bytes=0-0')
-      .ordered
-      .and_return(fake_resp1)
-    expect(faraday_conn).to receive(:get)
-      .with('https://images.invalid/img.jpg', nil, range: 'bytes=100-199')
-      .ordered
-      .and_return(fake_resp2)
+      stub = stub_request(:get, url)
+        .with(headers: { 'range' => 'bytes=0-0' })
+        .to_return(body: 'response body', headers: { 'Content-Range' => 'bytes 0-0/13' }, status: 206)
 
-    rio.read(1)
+      rio = described_class.new(url)
+      rio.read(1)
 
-    expect(rio.size).to eq(13)
+      expect(rio.size).to eq(13)
+      expect(stub).to have_been_requested
 
-    rio.seek(100)
-    expect(rio.read(100)).to be_nil
+      stub = stub_request(:get, url)
+        .with(headers: { 'range' => 'bytes=100-199' })
+        .to_return(status: 416)
 
-    expect(rio.size).to eq(13)
+      rio.seek(100)
+      rio.read(100)
+
+      expect(rio.pos).to eq(100)
+      expect(rio.size).to eq(13)
+      expect(stub).to have_been_requested
+    end
   end
 
-  it 'raises a specific error for all 5xx responses' do
-    rio = described_class.new('https://images.invalid/img.jpg')
+  [*400..415, *417..499].each do |code|
+    context "when the response status code is #{code}" do
+      it 'raises an error' do
+        url = 'https://images.invalid/img.jpg'
+
+        stub = stub_request(:get, url)
+          .with(headers: { 'range' => 'bytes=100-199' })
+          .to_return(status: code)
 
-    fake_resp = double(headers: {}, status: 502, body: 'Guru meditation')
-    faraday_conn = instance_double(Faraday::Connection, get: fake_resp)
-    allow(Faraday).to receive(:new).and_return(faraday_conn)
-    expect(faraday_conn).to receive(:get).with('https://images.invalid/img.jpg', nil, range: 'bytes=100-199')
+        rio = described_class.new(url)
+        rio.seek(100)
 
-    rio.seek(100)
-    expect { rio.read(100) }.to raise_error(/replied with a 502 and we might want to retry/)
+        expect { rio.read(100) }.to raise_error("Server at #{url} replied with a #{code} and refused our request")
+        expect(stub).to have_been_requested
+      end
+    end
   end
 
-  it 'maintains and exposes #pos' do
-    rio = described_class.new('https://images.invalid/img.jpg')
+  # 5XX
+
+  (500..599).each do |code|
+    context "when the response status code is #{code}" do
+      it 'raises an error' do
+        url = 'https://images.invalid/img.jpg'
 
-    expect(rio.pos).to eq(0)
+        stub = stub_request(:get, url)
+          .with(headers: { 'range' => 'bytes=100-199' })
+          .to_return(status: code)
 
-    fake_resp = double(headers: {'Content-Range' => 'bytes 0-0/13'}, status: 206, body: 'a')
-    faraday_conn = instance_double(Faraday::Connection, get: fake_resp)
-    allow(Faraday).to receive(:new).and_return(faraday_conn)
-    expect(faraday_conn).to receive(:get).with('https://images.invalid/img.jpg', nil, range: 'bytes=0-0')
-    rio.read(1)
+        rio = described_class.new(url)
+        rio.seek(100)
 
-    expect(rio.pos).to eq(1)
+        expect { rio.read(100) }.to raise_error("Server at #{url} replied with a #{code} and we might want to retry")
+        expect(stub).to have_been_requested
+      end
+    end
   end
 end

data/spec/spec_helper.rb

@@ -7,6 +7,10 @@ $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 
 require 'rspec'
+require 'webmock/rspec'
+
+WebMock.disable_net_connect!(allow_localhost: true)
+
 require 'format_parser'
 
 module SpecHelpers