zip_tricks 4.2.3 → 4.2.4

data/spec/zip_tricks/file_reader_spec.rb

@@ -1,287 +0,0 @@
-require 'spec_helper'
-describe ZipTricks::FileReader do
-  
-  context 'with a file without EOCD' do
-    it 'raises the MissingEOCD exception and refuses to read' do
-      f = StringIO.new
-      10.times { f << ('A' * 1024 ) }
-      f.rewind
-      
-      expect {
-        described_class.read_zip_structure(io: f)
-      }.to raise_error(described_class::MissingEOCD)
-    end
-  end
-  
-  describe 'read_zip_straight_ahead' do
-    it 'returns all the entries it can recover' do
-      zipfile = StringIO.new
-      war_and_peace = File.read(__dir__ + '/war-and-peace.txt')
-      ZipTricks::Streamer.open(zipfile) do |zip|
-        zip.add_stored_entry filename: 'text1.txt', crc32: Zlib.crc32(war_and_peace), size: war_and_peace.bytesize
-        zip << war_and_peace
-        zip.add_stored_entry filename: 'text2.txt', crc32: Zlib.crc32(war_and_peace), size: war_and_peace.bytesize
-        zip << war_and_peace
-        zip.add_stored_entry filename: 'text3.txt', crc32: Zlib.crc32(war_and_peace), size: war_and_peace.bytesize
-        zip << war_and_peace
-      end
-      zipfile.rewind
-
-      recovered_entries = described_class.read_zip_straight_ahead(io: zipfile)
-      expect(recovered_entries.length).to eq(3)
-      recovered_entries.each do |entry|
-        expect(entry.storage_mode).to eq(0)
-        expect(entry.compressed_size).to eq(496006)
-        expect(entry.uncompressed_size).to eq(496006)
-      end
-      
-      first, second, third = recovered_entries
-      expect(first.compressed_data_offset).to eq(39)
-      expect(second.compressed_data_offset).to eq(496084)
-      expect(third.compressed_data_offset).to eq(992129)
-      
-      recovered_entries.each do |entry|
-        zipfile.seek(entry.compressed_data_offset)
-        expect(zipfile.read(5)).to eq(war_and_peace[0...5])
-      end
-    end
-    
-    it 'recovers an entry that uses Zip64 extra fields' do
-      zipfile = StringIO.new
-      w = ZipTricks::ZipWriter.new
-      w.write_local_file_header(io: zipfile, filename: 'big.bin', compressed_size: 0xFFFFFFFFFF, uncompressed_size: 0xFFFFFFFFF,
-        crc32: 0, gp_flags: 0, mtime: Time.now, storage_mode: 0)
-      zipfile.rewind
-      recovered_entries = described_class.read_zip_straight_ahead(io: zipfile)
-      expect(recovered_entries.length).to eq(1)
-      entry = recovered_entries.shift
-      expect(entry.compressed_size).to eq(0xFFFFFFFFFF)
-    end
-    
-    it 'raises when an entry uses a data descriptor' do
-      zipfile = StringIO.new
-      ZipTricks::Streamer.open(zipfile) do |zip|
-        zip.write_deflated_file('war-and-peace.txt') do |sink|
-          sink << File.read(__dir__ + '/war-and-peace.txt')
-        end
-      end
-      zipfile.rewind
-      
-      expect {
-        described_class.read_zip_straight_ahead(io: zipfile)
-      }.to raise_error(described_class::UnsupportedFeature)
-    end
-  end
-
-  context 'with a ZIP file where the size of the central directory is recorded incorrectly, and has a wrong value' do
-    it 'is still able to read the entries' do
-      # Purposefully create a ZIP that we will damage after
-      zipfile = StringIO.new
-      tolstoy = File.read(__dir__ + '/war-and-peace.txt')
-      tolstoy.force_encoding(Encoding::BINARY)
-      
-      # Make a one-off Writer that corrupts the size of the central directory and says there is more data
-      # in it than there actually is
-      class EvilWriter < ZipTricks::ZipWriter
-        def write_end_of_central_directory(**kwargs)
-          kwargs[:central_directory_size] = kwargs[:central_directory_size] + 64 # Pretend there has to be more data
-          super(**kwargs)
-        end
-      end
-        
-      ZipTricks::Streamer.open(zipfile, writer: EvilWriter.new) do |zip|
-        zip.write_deflated_file('text-1.txt') { |sink| sink << tolstoy }
-        zip.write_deflated_file('text-2.txt') { |sink| sink << tolstoy }
-      end
-      
-      # Find the start of the EOCD record (signature, then the information about disk numbers and the information
-      # about the file counts
-      eocd_start_marker = [0x06054b50, 0, 0, 2, 2].pack('Vvvvv')
-      eocd_offset = zipfile.string.index(eocd_start_marker)
-      expect(eocd_offset).not_to be_nil
-      
-      # Seek to the offset where the central directory size is going to be (just after the string we looked for)
-      zipfile.seek(eocd_offset + eocd_start_marker.bytesize)
-      # and overwrite it.
-      zipfile.write([118].pack('V'))
-      zipfile.rewind
-      
-      entries = ZipTricks::FileReader.read_zip_structure(io: zipfile)
-      
-      expect(entries.length).to eq(2)
-    end
-  end
-
-  context 'with an end-to-end ZIP file to read' do
-    it 'reads and uncompresses the file written deflated with data descriptors' do
-      zipfile = StringIO.new
-      tolstoy = File.read(__dir__ + '/war-and-peace.txt')
-      tolstoy.force_encoding(Encoding::BINARY)
-
-      ZipTricks::Streamer.open(zipfile) do |zip|
-        zip.write_deflated_file('war-and-peace.txt') do |sink|
-          sink << tolstoy
-        end
-      end
-
-      entries = described_class.read_zip_structure(io: zipfile)
-      expect(entries.length).to eq(1)
-
-      entry = entries.first
-
-      readback = ''
-      reader = entry.extractor_from(zipfile)
-      readback << reader.extract(10) until reader.eof?
-
-      expect(readback.bytesize).to eq(tolstoy.bytesize)
-      expect(readback[0..10]).to eq(tolstoy[0..10])
-      expect(readback[-10..-1]).to eq(tolstoy[-10..-1])
-    end
-
-    it 'performs local file header reads by default' do
-      zipfile = StringIO.new
-      tolstoy = File.read(__dir__ + '/war-and-peace.txt')
-      tolstoy.force_encoding(Encoding::BINARY)
-
-      ZipTricks::Streamer.open(zipfile) do |zip|
-        40.times do |i|
-          zip.write_deflated_file('war-and-peace-%d.txt' % i) { |sink| sink << tolstoy }
-        end
-      end
-      zipfile.rewind
-    
-      read_monitor = ReadMonitor.new(zipfile)
-      entries = described_class.read_zip_structure(io: read_monitor, read_local_headers: true)
-      expect(read_monitor.num_reads).to eq(44)
-    end
-
-    it 'performs local file header reads when `read_local_headers` is set to true' do
-      zipfile = StringIO.new
-      tolstoy = File.read(__dir__ + '/war-and-peace.txt')
-      tolstoy.force_encoding(Encoding::BINARY)
-
-      ZipTricks::Streamer.open(zipfile) do |zip|
-        40.times do |i|
-          zip.write_deflated_file('war-and-peace-%d.txt' % i) { |sink| sink << tolstoy }
-        end
-      end
-      zipfile.rewind
-    
-      read_monitor = ReadMonitor.new(zipfile)
-      entries = described_class.read_zip_structure(io: read_monitor, read_local_headers: true)
-      expect(read_monitor.num_reads).to eq(44)
-
-      expect(entries.length).to eq(40)
-      entry = entries.first
-      expect(entry).to be_known_offset
-    end
-
-    it 'performs a limited number of reads when `read_local_headers` is set to false' do
-      zipfile = StringIO.new
-      tolstoy = File.read(__dir__ + '/war-and-peace.txt')
-      tolstoy.force_encoding(Encoding::BINARY)
-
-      ZipTricks::Streamer.open(zipfile) do |zip|
-        40.times do |i|
-          zip.write_deflated_file('war-and-peace-%d.txt' % i) { |sink| sink << tolstoy }
-        end
-      end
-      zipfile.rewind
-      read_monitor = ReadMonitor.new(zipfile)
-
-      entries = described_class.read_zip_structure(io: read_monitor, read_local_headers: false)
-
-      expect(read_monitor.num_reads).to eq(4)
-      expect(entries.length).to eq(40)
-      entry = entries.first
-      expect(entry).not_to be_known_offset
-      expect {
-        entry.compressed_data_offset
-      }.to raise_error(/read/)
-    end
-
-    it 'reads the file written stored with data descriptors' do
-      zipfile = StringIO.new
-      tolstoy = File.read(__dir__ + '/war-and-peace.txt')
-      ZipTricks::Streamer.open(zipfile) do |zip|
-        zip.write_stored_file('war-and-peace.txt') do |sink|
-          sink << tolstoy
-        end
-      end
-
-      entries = described_class.read_zip_structure(io: zipfile)
-      expect(entries.length).to eq(1)
-
-      entry = entries.first
-
-      readback = entry.extractor_from(zipfile).extract
-      expect(readback.bytesize).to eq(tolstoy.bytesize)
-      expect(readback[0..10]).to eq(tolstoy[0..10])
-    end
-  end
-  
-  describe '#get_compressed_data_offset' do
-    it 'reads the offset for an entry having Zip64 extra fields' do
-      w = ZipTricks::ZipWriter.new
-      out = StringIO.new
-      out << Random.new.bytes(7656177)
-      w.write_local_file_header(io: out, filename: 'some file',
-        compressed_size: 0xFFFFFFFF + 5, uncompressed_size: 0xFFFFFFFFF, crc32: 123, gp_flags: 4,
-        mtime: Time.now, storage_mode: 8)
-      
-      out.rewind
-      
-      compressed_data_offset = subject.get_compressed_data_offset(io: out, local_file_header_offset: 7656177)
-      expect(compressed_data_offset).to eq(7656236)
-    end
-    
-    it 'reads the offset for an entry having a long name' do
-      w = ZipTricks::ZipWriter.new
-      out = StringIO.new
-      out << Random.new.bytes(7)
-      w.write_local_file_header(io: out, filename: 'This is a file with a ridiculously long name.doc',
-        compressed_size: 10, uncompressed_size: 15, crc32: 123, gp_flags: 4,
-        mtime: Time.now, storage_mode: 8)
-      
-      out.rewind
-      
-      compressed_data_offset = subject.get_compressed_data_offset(io: out, local_file_header_offset: 7)
-      expect(compressed_data_offset).to eq(85)
-    end
-  end
-  
-  it 'is able to latch to the EOCD location even if the signature for the EOCD record appears all over the ZIP' do
-    # A VERY evil ZIP file which has this signature all over
-    eocd_sig = [0x06054b50].pack('V')
-    evil_str = "#{eocd_sig} and #{eocd_sig}"
-    
-    z = StringIO.new
-    w = ZipTricks::ZipWriter.new
-    w.write_local_file_header(io: z, filename: evil_str, compressed_size: evil_str.bytesize,
-       uncompressed_size: evil_str.bytesize, crc32: 0x06054b50, gp_flags: 0, mtime: Time.now, storage_mode: 0)
-    z << evil_str
-    where = z.tell
-    w.write_central_directory_file_header(io: z, local_file_header_location: 0, gp_flags: 0, storage_mode: 0,
-      filename: evil_str, compressed_size: evil_str.bytesize,
-      uncompressed_size: evil_str.bytesize, mtime: Time.now, crc32: 0x06054b50)
-    w.write_end_of_central_directory(io: z, start_of_central_directory_location: where,
-      central_directory_size: z.tell - where, num_files_in_archive: 1, comment: evil_str)
-    
-    z.rewind
-    entries = described_class.read_zip_structure(io: z)
-    expect(entries.length).to eq(1)
-  end
-  
-  it 'can handle a Zip64 central directory fields that only contains the required fields (substitutes for standard fields)' do
-    # In this example central directory, 2 entries contain Zip64 extra where only the local header offset is set (8 bytes each)
-    # This is the exceptional case where we have to poke at a private method directly
-    File.open(__dir__ + '/cdir_entry_with_partial_use_of_zip64_extra_fields.bin', 'rb') do |f|
-      reader = described_class.new
-      entry = reader.send(:read_cdir_entry, f)
-      expect(entry.local_file_header_offset).to eq(4312401349)
-      expect(entry.filename).to eq('Motorhead - Ace Of Spades.srt')
-      expect(entry.compressed_size).to eq(69121)
-      expect(entry.uncompressed_size).to eq(69121)
-    end
-  end
-end

data/spec/zip_tricks/rack_body_spec.rb

@@ -1,34 +0,0 @@
-require_relative '../spec_helper'
-
-describe ZipTricks::RackBody do
-  it 'is usable as a Rack response body, supports each() and close()' do
-    output_buf = Tempfile.new('output')
-
-    file_body = SecureRandom.random_bytes(1024 * 1024 + 8981)
-
-    body = described_class.new do | zip |
-      zip.add_stored_entry(filename: "A file", size: file_body.bytesize, crc32: Zlib.crc32(file_body))
-      zip << file_body
-    end
-
-    body.each do | some_data |
-      output_buf << some_data
-    end
-    body.close
-
-    output_buf.rewind
-    expect(output_buf.size).to eq(1057696)
-
-    per_filename = {}
-    Zip::File.open(output_buf.path) do |zip_file|
-      # Handle entries one by one
-      zip_file.each do |entry|
-        # The entry name gets returned with a binary encoding, we have to force it back.
-        per_filename[entry.name] = entry.get_input_stream.read
-      end
-    end
-
-    expect(per_filename).to have_key('A file')
-    expect(per_filename['A file'].bytesize).to eq(file_body.bytesize)
-  end
-end

data/spec/zip_tricks/remote_io_spec.rb

@@ -1,125 +0,0 @@
-require 'spec_helper'
-
-describe ZipTricks::RemoteIO do
-
-  context 'working with the fetcher object' do
-    it 'asks the fetcher object to obtain the object size and the actual data when reading' do
-      mock_fetcher = double(request_object_size: 120, request_range: 'abc')
-      subject = described_class.new(mock_fetcher)
-      expect(subject.read(3)).to eq('abc')
-    end
-  end
-
-  context 'when it internally addresses a remote resource' do
-    it 'requests the size of the resource once via #request_object_size and does neet to read if resource is empty' do
-      subject = described_class.new
-      expect(subject).to receive(:request_object_size).and_return(0)
-      expect(subject.read).to be_nil
-    end
-
-    it 'performs remote reads when repeatedly requesting the same chunk, via #request_range' do
-      subject = described_class.new
-
-      expect(subject).to receive(:request_object_size).and_return(120)
-      allow(subject).to receive(:request_range) {|range|
-        expect(range).to eq(5..14)
-        Random.new.bytes(10)
-      }
-      20.times do
-        subject.seek(5, IO::SEEK_SET)
-        subject.read(10)
-      end
-    end
-  end
-
-  describe '#seek' do
-    context 'with an unsupported mode' do
-      it 'raises an error' do
-        uncap = described_class.new
-        expect {
-          uncap.seek(123, :UNSUPPORTED)
-        }.to raise_error(/unsupported/i)
-      end
-    end
-
-    context 'with SEEK_SET mode' do
-      it 'returns the offset of 10 when asked to seek to 10' do
-        uncap = described_class.new
-        expect(uncap).to receive(:request_object_size).and_return(100)
-        mode = IO::SEEK_SET
-        expect(uncap.seek(10, mode)).to eq(0)
-      end
-    end
-  end
-
-  describe '#read' do
-    before :each do
-      @buf = Tempfile.new('simulated-http')
-      @buf.binmode
-      5.times { @buf << Random.new.bytes(1024 * 1024 * 3) }
-      @buf.rewind
-
-      @subject = described_class.new
-
-      allow(@subject).to receive(:request_object_size).and_return(@buf.size)
-      allow(@subject).to receive(:request_range) {|range|
-        @buf.read[range].tap { @buf.rewind }
-      }
-    end
-
-    after :each do
-      if @buf
-        @buf.close; @buf.unlink
-      end
-    end
-
-    context 'without arguments' do
-      it 'reads the entire buffer and alters the position pointer' do
-        expect(@subject.tell).to eq(0)
-        read = @subject.read
-        expect(read.bytesize).to eq(@buf.size)
-        expect(@subject.tell).to eq(@buf.size)
-      end
-    end
-
-    context 'with length' do
-      it 'supports an unlimited number of reads of size 0 and does not perform remote fetches for them' do
-        expect(@subject).not_to receive(:request_range)
-        20.times do
-          data = @subject.read(0)
-          expect(data).to eq('')
-        end
-      end
-      
-      it 'returns exact amount of bytes at the start of the buffer' do
-        bytes_read = @subject.read(10)
-        expect(@subject.tell).to eq(10)
-        @buf.seek(0)
-        expect(bytes_read).to eq(@buf.read(10))
-      end
-
-      it 'returns exact amount of bytes from the middle of the buffer' do
-        @subject.seek(456, IO::SEEK_SET)
-
-        bytes_read = @subject.read(10)
-        expect(@subject.tell).to eq(456+10)
-
-        @buf.seek(456)
-        expect(bytes_read).to eq(@buf.read(10))
-      end
-
-      it 'returns the last N bytes it can read' do
-        at_end = @buf.size - 4
-        @subject.seek(at_end, IO::SEEK_SET)
-
-        expect(@subject.tell).to eq(15728636)
-        bytes_read = @subject.read(10)
-        expect(@subject.tell).to eq(@buf.size) # Should have moved the pos pointer to the end
-
-        expect(bytes_read.bytesize).to eq(4)
-
-        expect(@subject.tell).to eq(@buf.size)
-      end
-    end
-  end
-end