format_parser 1.6.0 → 2.0.0.pre

data/lib/parsers/zip_parser/file_reader.rb

@@ -27,52 +27,43 @@ class FormatParser::ZIPParser::FileReader
   # To prevent too many tiny reads, read the maximum possible size of end of
   # central directory record upfront (all the fixed fields + at most 0xFFFF
   # bytes of the archive comment)
-  MAX_END_OF_CENTRAL_DIRECTORY_RECORD_SIZE =
-    begin
-      4 + # Offset of the start of central directory
-        4 + # Size of the central directory
-        2 + # Number of files in the cdir
-        4 + # End-of-central-directory signature
-        2 + # Number of this disk
-        2 + # Number of disk with the start of cdir
-        2 + # Number of files in the cdir of this disk
-        2 + # The comment size
-        0xFFFF # Maximum comment size
-    end
+  MAX_END_OF_CENTRAL_DIRECTORY_RECORD_SIZE = 4 + # Offset of the start of central directory
+                                             4 + # Size of the central directory
+                                             2 + # Number of files in the cdir
+                                             4 + # End-of-central-directory signature
+                                             2 + # Number of this disk
+                                             2 + # Number of disk with the start of cdir
+                                             2 + # Number of files in the cdir of this disk
+                                             2 + # The comment size
+                                             0xFFFF # Maximum comment size
 
   # To prevent too many tiny reads, read the maximum possible size of the local file header upfront.
   # The maximum size is all the usual items, plus the maximum size
   # of the filename (0xFFFF bytes) and the maximum size of the extras (0xFFFF bytes)
-  MAX_LOCAL_HEADER_SIZE =
-    begin
-      4 + # signature
-        2 + # Version needed to extract
-        2 + # gp flags
-        2 + # storage mode
-        2 + # dos time
-        2 + # dos date
-        4 + # CRC32
-        4 + # Comp size
-        4 + # Uncomp size
-        2 + # Filename size
-        2 + # Extra fields size
-        0xFFFF + # Maximum filename size
-        0xFFFF   # Maximum extra fields size
-    end
-
-  SIZE_OF_USABLE_EOCD_RECORD =
-    begin
-      4 + # Signature
-        2 + # Number of this disk
-        2 + # Number of the disk with the EOCD record
-        2 + # Number of entries in the central directory of this disk
-        2 + # Number of entries in the central directory total
-        4 + # Size of the central directory
-        4   # Start of the central directory offset
-    end
+  MAX_LOCAL_HEADER_SIZE = 4 + # signature
+                          2 + # Version needed to extract
+                          2 + # gp flags
+                          2 + # storage mode
+                          2 + # dos time
+                          2 + # dos date
+                          4 + # CRC32
+                          4 + # Comp size
+                          4 + # Uncomp size
+                          2 + # Filename size
+                          2 + # Extra fields size
+                          0xFFFF + # Maximum filename size
+                          0xFFFF # Maximum extra fields size
+
+  SIZE_OF_USABLE_EOCD_RECORD = 4 + # Signature
+                               2 + # Number of this disk
+                               2 + # Number of the disk with the EOCD record
+                               2 + # Number of entries in the central directory of this disk
+                               2 + # Number of entries in the central directory total
+                               4 + # Size of the central directory
+                               4 # Start of the central directory offset
 
   private_constant :C_UINT32LE, :C_UINT16LE, :C_UINT64LE, :MAX_END_OF_CENTRAL_DIRECTORY_RECORD_SIZE,
-                   :MAX_LOCAL_HEADER_SIZE, :SIZE_OF_USABLE_EOCD_RECORD
+    :MAX_LOCAL_HEADER_SIZE, :SIZE_OF_USABLE_EOCD_RECORD
 
   # Represents a file within the ZIP archive being read
   class ZipEntry
@@ -216,7 +207,7 @@ class FormatParser::ZIPParser::FileReader
     io.seek(absolute_pos)
     unless absolute_pos == io.pos
       raise ReadError,
-            "Expected to seek to #{absolute_pos} but only got to #{io.pos}"
+        "Expected to seek to #{absolute_pos} but only got to #{io.pos}"
     end
     nil
   end
@@ -235,18 +226,14 @@ class FormatParser::ZIPParser::FileReader
     io.seek(io.pos + n)
     pos_after = io.pos
     delta = pos_after - pos_before
-    unless delta == n
-      raise ReadError, "Expected to seek #{n} bytes ahead, but could only seek #{delta} bytes ahead"
-    end
+    raise ReadError, "Expected to seek #{n} bytes ahead, but could only seek #{delta} bytes ahead" unless delta == n
     nil
   end
 
   def read_n(io, n_bytes)
     io.read(n_bytes).tap do |d|
       raise ReadError, "Expected to read #{n_bytes} bytes, but the IO was at the end" if d.nil?
-      unless d.bytesize == n_bytes
-        raise ReadError, "Expected to read #{n_bytes} bytes, read #{d.bytesize}"
-      end
+      raise ReadError, "Expected to read #{n_bytes} bytes, read #{d.bytesize}" unless d.bytesize == n_bytes
     end
   end
 
@@ -310,15 +297,9 @@ class FormatParser::ZIPParser::FileReader
         #
         # It means that before we read this stuff we need to check if the previously-read
         # values are at overflow, and only _then_ proceed to read them. Bah.
-        if e.uncompressed_size == 0xFFFFFFFF
-          e.uncompressed_size = read_8b(zip64_extra)
-        end
-        if e.compressed_size == 0xFFFFFFFF
-          e.compressed_size = read_8b(zip64_extra)
-        end
-        if e.local_file_header_offset == 0xFFFFFFFF
-          e.local_file_header_offset = read_8b(zip64_extra)
-        end
+        e.uncompressed_size = read_8b(zip64_extra) if e.uncompressed_size == 0xFFFFFFFF
+        e.compressed_size = read_8b(zip64_extra) if e.compressed_size == 0xFFFFFFFF
+        e.local_file_header_offset = read_8b(zip64_extra) if e.local_file_header_offset == 0xFFFFFFFF
         # Disk number comes last and we can skip it anyway, since we do
         # not support multi-disk archives
       end
@@ -370,9 +351,7 @@ class FormatParser::ZIPParser::FileReader
       signature, *_rest, comment_size = maybe_record.unpack(unpack_pattern)
 
       # Check the only condition for the match
-      if signature == 0x06054b50 && (maybe_record.bytesize - minimum_record_size) == comment_size
-        return check_at # Found the EOCD marker location
-      end
+      return check_at if signature == 0x06054b50 && (maybe_record.bytesize - minimum_record_size) == comment_size
     end
     # If we haven't caught anything, return nil deliberately instead of returning the last statement
     nil
@@ -422,16 +401,12 @@ class FormatParser::ZIPParser::FileReader
 
     disk_n = read_4b(zip64_eocdr) # number of this disk
     disk_n_with_eocdr = read_4b(zip64_eocdr) # number of the disk with the EOCDR
-    if disk_n != disk_n_with_eocdr
-      raise UnsupportedFeature, 'The archive spans multiple disks'
-    end
+    raise UnsupportedFeature, 'The archive spans multiple disks' if disk_n != disk_n_with_eocdr
 
     num_files_this_disk = read_8b(zip64_eocdr) # number of files on this disk
-    num_files_total     = read_8b(zip64_eocdr) # files total in the central directory
+    num_files_total = read_8b(zip64_eocdr) # files total in the central directory
 
-    if num_files_this_disk != num_files_total
-      raise UnsupportedFeature, 'The archive spans multiple disks'
-    end
+    raise UnsupportedFeature, 'The archive spans multiple disks' if num_files_this_disk != num_files_total
 
     log do
       format(
@@ -439,8 +414,8 @@ class FormatParser::ZIPParser::FileReader
         num_files_total)
     end
 
-    central_dir_size    = read_8b(zip64_eocdr) # Size of the central directory
-    central_dir_offset  = read_8b(zip64_eocdr) # Where the central directory starts
+    central_dir_size = read_8b(zip64_eocdr) # Size of the central directory
+    central_dir_offset = read_8b(zip64_eocdr) # Where the central directory starts
 
     [num_files_total, central_dir_offset, central_dir_size]
   end
@@ -456,8 +431,8 @@ class FormatParser::ZIPParser::FileReader
     skip_ahead_2(io) # number_of_this_disk
     skip_ahead_2(io) # number of the disk with the EOCD record
     skip_ahead_2(io) # number of entries in the central directory of this disk
-    num_files = read_2b(io)   # number of entries in the central directory total
-    cdir_size = read_4b(io)   # size of the central directory
+    num_files = read_2b(io) # number of entries in the central directory total
+    cdir_size = read_4b(io) # size of the central directory
     cdir_offset = read_4b(io) # start of central directorty offset
     [num_files, cdir_offset, cdir_size]
   end

data/lib/parsers/zip_parser.rb

@@ -34,7 +34,7 @@ class FormatParser::ZIPParser
     end
   rescue FileReader::Error
     # This is not a ZIP, or a broken ZIP.
-    return
+    nil
   end
 
   def directory?(zip_entry)

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,27 @@ 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
+        request_range(range, redirect_uri(location, 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/parsers/arw_parser_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+describe FormatParser::ARWParser do
+  shared_examples 'likely_match for file' do |filename_with_extension|
+    it "matches '#{filename_with_extension}'" do
+      expect(subject.likely_match?(filename_with_extension)).to be_truthy
+    end
+  end
+
+  shared_examples 'no likely_match for file' do |filename_with_extension|
+    it "does not match '#{filename_with_extension}'" do
+      expect(subject.likely_match?(filename_with_extension)).to be_falsey
+    end
+  end
+
+  describe 'likely_match' do
+    filenames = ['raw_file', 'another raw file', 'and.another', 'one-more']
+    valid_extensions = ['.arw', '.Arw', '.aRw', '.arW', '.ARw', '.ArW', '.aRW', '.ARW']
+    invalid_extensions = ['.tiff', '.cr2', '.new', '.jpeg']
+    filenames.each do |filename|
+      valid_extensions.each do |extension|
+        include_examples 'likely_match for file', filename + extension
+      end
+      invalid_extensions.each do |extension|
+        include_examples 'no likely_match for file', filename + extension
+      end
+    end
+  end
+
+  describe 'parses Sony ARW fixtures as arw format file' do
+    expected_parsed_dimensions = {
+      'RAW_SONY_A100.ARW' => {
+        width_px: 3872,
+        height_px: 2592,
+        display_width_px: 3872,
+        display_height_px: 2592,
+        orientation: :top_left
+      },
+      'RAW_SONY_A700.ARW' => {
+        width_px: 4288,
+        height_px: 2856,
+        display_width_px: 4288,
+        display_height_px: 2856,
+        orientation: :top_left
+      },
+      'RAW_SONY_A900.ARW' => {
+        width_px: 6080,
+        height_px: 4048,
+        display_width_px: 6080,
+        display_height_px: 4048,
+        orientation: :top_left
+      },
+      # rotated 90 degree image
+      'RAW_SONY_DSC-RX100M2.ARW' => {
+        width_px: 5472,
+        height_px: 3648,
+        display_width_px: 3648,
+        display_height_px: 5472,
+        orientation: :right_top,
+      },
+      'RAW_SONY_ILCE-7RM2.ARW' => {
+        width_px: 7952,
+        height_px: 5304,
+        display_width_px: 7952,
+        display_height_px: 5304,
+        orientation: :top_left,
+      },
+      'RAW_SONY_NEX7.ARW' => {
+        width_px: 6000,
+        height_px: 4000,
+        display_width_px: 6000,
+        display_height_px: 4000,
+        orientation: :top_left,
+      },
+      'RAW_SONY_SLTA55V.ARW' => {
+        width_px: 4928,
+        height_px: 3280,
+        display_width_px: 4928,
+        display_height_px: 3280,
+        orientation: :top_left,
+      },
+    }
+
+    Dir.glob(fixtures_dir + '/ARW/*.ARW').each do |arw_path|
+      it "is able to parse #{File.basename(arw_path)}" do
+        expected_dimension = expected_parsed_dimensions[File.basename(arw_path)]
+        # error if a new .arw test file is added without specifying the expected dimensions
+        expect(expected_dimension).not_to be_nil
+
+        parsed = subject.call(File.open(arw_path, 'rb'))
+        expect(parsed).not_to be_nil
+        expect(parsed.nature).to eq(:image)
+        expect(parsed.format).to eq(:arw)
+        expect(parsed.intrinsics[:exif]).not_to be_nil
+        expect(parsed.content_type).to eq('image/x-sony-arw')
+
+        expect(parsed.width_px).to eq(expected_dimension[:width_px])
+        expect(parsed.height_px).to eq(expected_dimension[:height_px])
+        expect(parsed.display_width_px).to eq(expected_dimension[:display_width_px])
+        expect(parsed.display_height_px).to eq(expected_dimension[:display_height_px])
+        expect(parsed.orientation).to eq(expected_dimension[:orientation])
+      end
+    end
+
+    shared_examples 'invalid filetype' do |filetype, fixture_path|
+      it "should fail to parse #{filetype}" do
+        file_path = fixtures_dir + fixture_path
+        parsed = subject.call(File.open(file_path, 'rb'))
+        expect(parsed).to be_nil
+      end
+    end
+
+    include_examples 'invalid filetype', 'NEF', '/NEF/RAW_NIKON_1S2.NEF'
+    include_examples 'invalid filetype', 'TIFF', '/TIFF/Shinbutsureijoushuincho.tiff'
+    include_examples 'invalid filetype', 'JPG', '/JPEG/orient_6.jpg'
+    include_examples 'invalid filetype', 'PNG', '/PNG/cat.png'
+    include_examples 'invalid filetype', 'CR2', '/CR2/RAW_CANON_1DM2.CR2'
+  end
+end

data/spec/parsers/tiff_parser_spec.rb

@@ -47,21 +47,6 @@ describe FormatParser::TIFFParser do
     expect(parsed.intrinsics[:exif]).not_to be_nil
   end
 
-  it 'parses Sony ARW fixture as arw format file' do
-    arw_path = fixtures_dir + '/ARW/RAW_SONY_ILCE-7RM2.ARW'
-
-    parsed = subject.call(File.open(arw_path, 'rb'))
-
-    expect(parsed).not_to be_nil
-    expect(parsed.nature).to eq(:image)
-    expect(parsed.format).to eq(:arw)
-
-    expect(parsed.width_px).to eq(7952)
-    expect(parsed.height_px).to eq(5304)
-    expect(parsed.intrinsics[:exif]).not_to be_nil
-    expect(parsed.content_type).to eq('image/x-sony-arw')
-  end
-
   describe 'correctly extracts dimensions from various TIFF flavors of the same file' do
     Dir.glob(fixtures_dir + '/TIFF/IMG_9266*.tif').each do |tiff_path|
       it "is able to parse #{File.basename(tiff_path)}" do
@@ -100,4 +85,13 @@ describe FormatParser::TIFFParser do
       end
     end
   end
+
+  describe 'bails out on ARW files, such as' do
+    Dir.glob(fixtures_dir + '/ARW/*.ARW').each do |arw_path|
+      it "skips #{File.basename(arw_path)}" do
+        parsed = subject.call(File.open(arw_path, 'rb'))
+        expect(parsed).to be_nil
+      end
+    end
+  end
 end

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(