zip_tricks 4.2.3 → 4.2.4

data/spec/zip_tricks/remote_uncap_spec.rb

@@ -1,100 +0,0 @@
-require 'spec_helper'
-
-describe ZipTricks::RemoteUncap, webmock: true do
-  let(:uri) { URI.parse('http://example.com/file.zip') }
-
-  after :each do
-    File.unlink('temp.zip') rescue Errno::ENOENT
-  end
-
-  it 'returns an array of remote entries that can be used to fetch the segments from within the ZIP' do
-    payload1 = Tempfile.new 'payload1'
-    payload1 << Random.new.bytes((1024 * 1024 * 5) + 10)
-    payload1.flush; payload1.rewind;
-
-    payload2 = Tempfile.new 'payload2'
-    payload2 << Random.new.bytes(1024 * 1024 * 3)
-    payload2.flush; payload2.rewind
-
-    File.open('temp.zip', 'wb') do |f|
-      ZipTricks::Streamer.open(f) do | zip |
-        zip.write_stored_file('first-file.bin') { |w| IO.copy_stream(payload1, w) }
-        zip.write_stored_file('second-file.bin') { |w| IO.copy_stream(payload2, w) }
-      end
-    end
-    payload1.rewind; payload2.rewind
-
-    expect(File).to be_exist('temp.zip')
-
-    allow_any_instance_of(described_class).to receive(:request_object_size) {
-      File.size('temp.zip')
-    }
-    allow_any_instance_of(described_class).to receive(:request_range) {|_instance, range|
-      File.open('temp.zip', 'rb') do |f|
-        f.seek(range.begin)
-        f.read(range.end - range.begin + 1)
-      end
-    }
-
-    payload1.rewind; payload2.rewind
-
-    files = described_class.files_within_zip_at('http://fake.example.com')
-    expect(files).to be_kind_of(Array)
-    expect(files.length).to eq(2)
-
-    first, second = *files
-
-    expect(first.filename).to eq('first-file.bin')
-    expect(first.uncompressed_size).to eq(payload1.size)
-    File.open('temp.zip', 'rb') do |readback|
-      readback.seek(first.compressed_data_offset, IO::SEEK_SET)
-      expect(readback.read(12)).to eq(payload1.read(12))
-    end
-
-    expect(second.filename).to eq('second-file.bin')
-    expect(second.uncompressed_size).to eq(payload2.size)
-    File.open('temp.zip', 'rb') do |readback|
-      readback.seek(second.compressed_data_offset, IO::SEEK_SET)
-      expect(readback.read(12)).to eq(payload2.read(12))
-    end
-  end
-
-  it 'can cope with an empty file within the zip' do
-    payload1 = Tempfile.new 'payload1'
-    payload1.flush; payload1.rewind;
-
-    payload2 = Tempfile.new 'payload2'
-    payload2 << Random.new.bytes(1024)
-    payload2.flush; payload2.rewind
-
-    payload1_crc = Zlib.crc32(payload1.read).tap { payload1.rewind }
-    payload2_crc = Zlib.crc32(payload2.read).tap { payload2.rewind }
-
-    readable_zip = Tempfile.new 'somezip'
-    ZipTricks::Streamer.open(readable_zip) do | zip |
-      zip.add_stored_entry(filename: 'first-file-zero-size.bin', size: payload1.size, crc32: payload1_crc)
-      zip.write_stored_file('second-file.bin') {|w| IO.copy_stream(payload2, w) }
-    end
-    readable_zip.flush; readable_zip.rewind
-
-    allow_any_instance_of(described_class).to receive(:request_object_size) {
-      readable_zip.size
-    }
-    allow_any_instance_of(described_class).to receive(:request_range) {|_instance, range|
-      readable_zip.seek(range.begin, IO::SEEK_SET)
-      readable_zip.read(range.end - range.begin + 1)
-    }
-
-    payload1.rewind; payload2.rewind
-
-    first, second  = described_class.files_within_zip_at('http://fake.example.com')
-
-    expect(first.filename).to eq('first-file-zero-size.bin')
-    expect(first.compressed_size).to be_zero
-    
-    expect(second.filename).to eq('second-file.bin')
-    expect(second.uncompressed_size).to eq(payload2.size)
-    readable_zip.seek(second.compressed_data_offset, IO::SEEK_SET)
-    expect(readable_zip.read(12)).to eq(payload2.read(12))
-  end
-end

data/spec/zip_tricks/size_estimator_spec.rb

@@ -1,31 +0,0 @@
-require_relative '../spec_helper'
-
-describe ZipTricks::SizeEstimator do
-  it 'accurately predicts the output zip size' do
-    # Generate a couple of random files
-    raw_file_1 = SecureRandom.random_bytes(1024 * 20)
-    raw_file_2 = SecureRandom.random_bytes(1024 * 128)
-    raw_file_3 = SecureRandom.random_bytes(1258695)
-
-    predicted_size = described_class.estimate do | estimator |
-      r = estimator.add_stored_entry(filename: "first-file.bin", size: raw_file_1.size)
-      expect(r).to eq(estimator), "add_stored_entry should return self"
-
-      estimator.add_stored_entry(filename: "second-file.bin", size: raw_file_2.size)
-
-      r = estimator.add_compressed_entry(filename: "second-flie.bin", compressed_size: raw_file_3.size,
-        uncompressed_size: raw_file_2.size, )
-      expect(r).to eq(estimator), "add_compressed_entry should return self"
-      
-      r = estimator.add_stored_entry(filename: "first-file-with-descriptor.bin", size: raw_file_1.size,
-        use_data_descriptor: true)
-      expect(r).to eq(estimator), "add_stored_entry should return self"
-
-      r = estimator.add_compressed_entry(filename: "second-file-with-descriptor.bin", compressed_size: raw_file_3.size,
-        uncompressed_size: raw_file_2.size, use_data_descriptor: true)
-      expect(r).to eq(estimator), "add_compressed_entry should return self"
-    end
-
-    expect(predicted_size).to eq(2690095)
-  end
-end

data/spec/zip_tricks/stream_crc32_spec.rb

@@ -1,38 +0,0 @@
-require_relative '../spec_helper'
-
-describe ZipTricks::StreamCRC32 do
-  it 'computes the CRC32 of a large binary file' do
-    raw = StringIO.new(SecureRandom.random_bytes(45 * 1024 * 1024))
-    crc = Zlib.crc32(raw.string)
-    via_from_io = described_class.from_io(raw)
-    expect(via_from_io).to eq(crc)
-  end
-
-  it 'allows in-place updates' do
-    raw = StringIO.new(SecureRandom.random_bytes(45 * 1024 * 1024))
-    crc = Zlib.crc32(raw.string)
-
-    stream_crc = described_class.new
-    stream_crc << raw.read(1024 * 64) until raw.eof?
-    expect(stream_crc.to_i).to eq(crc)
-  end
-
-  it 'supports chained shovel' do
-    str = 'abcdef'
-    crc = Zlib.crc32(str)
-
-    stream_crc = described_class.new
-    stream_crc << 'a' << 'b' << 'c' << 'd' << 'e' << 'f'
-
-    expect(stream_crc.to_i).to eq(crc)
-  end
-
-  it 'allows in-place update with a known value' do
-    crc = Zlib.crc32
-
-    stream_crc = described_class.new
-    stream_crc << "This is some data"
-    stream_crc.append(45678, 12910)
-    expect(stream_crc.to_i).to eq(1555667875)
-  end
-end

data/spec/zip_tricks/streamer/writable_spec.rb

@@ -1,27 +0,0 @@
-require_relative '../../spec_helper'
-
-describe ZipTricks::Streamer::Writable do
-  describe '#<<' do
-    it 'writes the given data to the destination and returns self' do
-      buf = StringIO.new
-      subject = described_class.new(buf)
-
-      result = subject << 'hello!'
-
-      expect(buf.string).to eq('hello!')
-      expect(result).to eq(subject)
-    end
-  end
-
-  describe '#write' do
-    it 'writes the given data to the destination and returns the number of bytes written' do
-      buf = StringIO.new
-      subject = described_class.new(buf)
-
-      result = subject.write('hello!')
-
-      expect(buf.string).to eq('hello!')
-      expect(result).to eq(6)
-    end
-  end
-end

data/spec/zip_tricks/streamer_spec.rb

@@ -1,296 +0,0 @@
-require_relative '../spec_helper'
-
-describe ZipTricks::Streamer do
-  let(:test_text_file_path) {
-    File.join(__dir__, 'war-and-peace.txt')
-  }
-
-  # Run each test in a temporady directory, and nuke it afterwards
-  around(:each) do |example|
-    wd = Dir.pwd
-    Dir.mktmpdir do | td |
-      Dir.chdir(td)
-      example.run
-    end
-    Dir.chdir(wd)
-  end
-
-  def rewind_after(*ios)
-    yield.tap { ios.map(&:rewind) }
-  end
-
-  it 'raises an InvalidOutput if the given object does not support the methods' do
-    expect {
-      described_class.new(nil)
-    }.to raise_error(ZipTricks::Streamer::InvalidOutput)
-  end
-
-  it 'allows the writer to be injectable' do
-    fake_writer = double('ZipWriter')
-    expect(fake_writer).to receive(:write_local_file_header)
-    expect(fake_writer).to receive(:write_data_descriptor)
-    expect(fake_writer).to receive(:write_central_directory_file_header)
-    expect(fake_writer).to receive(:write_end_of_central_directory)
-
-    described_class.open('', writer: fake_writer) do |zip|
-      zip.write_deflated_file('stored.txt') do |sink|
-        sink << File.read(__dir__ + '/war-and-peace.txt')
-      end
-    end
-  end
-
-  it 'returns the position in the IO at every call' do
-    io = StringIO.new
-    zip = described_class.new(io)
-    pos = zip.add_compressed_entry(filename: 'file.jpg', uncompressed_size: 182919, compressed_size: 8912, crc32: 8912)
-    expect(pos).to eq(io.tell)
-    expect(pos).to eq(38)
-
-    retval = zip << SecureRandom.random_bytes(8912)
-    expect(retval).to eq(zip)
-    expect(io.tell).to eq(8950)
-
-    pos = zip.add_stored_entry(filename: 'filf.jpg', size: 8921, crc32: 182919)
-    expect(pos).to eq(8988)
-    zip << SecureRandom.random_bytes(8921)
-    expect(io.tell).to eq(17909)
-
-    pos = zip.close
-    expect(pos).to eq(io.tell)
-    expect(pos).to eq(18068)
-  end
-
-  it 'can write and then read the block-deflated files' do
-    f = Tempfile.new('raw')
-    f.binmode
-
-    rewind_after(f) do
-      f << ('A' * 1024 * 1024)
-      f << SecureRandom.random_bytes(1248)
-      f << ('B' * 1024 * 1024)
-    end
-
-    crc = rewind_after(f) { Zlib.crc32(f.read) }
-
-    compressed_blockwise = StringIO.new
-    rewind_after(compressed_blockwise, f) do
-      ZipTricks::BlockDeflate.deflate_in_blocks_and_terminate(f, compressed_blockwise, block_size: 1024)
-    end
-
-    # Perform the zipping
-    zip_file = Tempfile.new('z')
-    zip_file.binmode
-
-    described_class.open(zip_file) do |zip|
-      zip.add_compressed_entry(filename: "compressed-file.bin", uncompressed_size: f.size,
-        crc32: crc, compressed_size: compressed_blockwise.size)
-      zip << compressed_blockwise.read
-    end
-    zip_file.flush
-
-    per_filename = {}
-    Zip::File.open(zip_file.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['compressed-file.bin'].bytesize).to eq(f.size)
-    expect(Digest::SHA1.hexdigest(per_filename['compressed-file.bin'])).to eq(Digest::SHA1.hexdigest(f.read))
-
-    inspect_zip_with_external_tool(zip_file.path)
-  end
-
-  it 'creates an archive that OSX ArchiveUtility can handle' do
-    outbuf = Tempfile.new('zip')
-    outbuf.binmode
-
-    zip = ZipTricks::Streamer.new(outbuf)
-
-    File.open(test_text_file_path, 'rb') do | source_f |
-      crc32 = rewind_after(source_f) { Zlib.crc32(source_f.read) }
-
-      compressed_buffer = StringIO.new
-
-      expect(ZipTricks::BlockDeflate).to receive(:deflate_chunk).at_least(:twice).and_call_original
-
-      # Compress in blocks of 4 Kb
-      rewind_after(source_f, compressed_buffer) do
-        ZipTricks::BlockDeflate.deflate_in_blocks_and_terminate(source_f, compressed_buffer, block_size: 1024 * 4)
-      end
-
-      # Add this file compressed...
-      zip.add_compressed_entry(filename: 'war-and-peace.txt', uncompressed_size: source_f.size,
-        crc32: crc32, compressed_size: compressed_buffer.size)
-      zip << compressed_buffer.string
-
-      # ...and stored.
-      zip.add_stored_entry(filename: 'war-and-peace-raw.txt', size: source_f.size, crc32: crc32)
-      zip << source_f.read
-
-      zip.close
-
-      outbuf.flush
-      File.unlink('test.zip') rescue nil
-      File.rename(outbuf.path, 'osx-archive-test.zip')
-
-      # Mark this test as skipped if the system does not have the binary
-      open_zip_with_archive_utility('osx-archive-test.zip', skip_if_missing: true)
-    end
-    FileUtils.rm_rf('osx-archive-test')
-    FileUtils.rm_rf('osx-archive-test.zip')
-  end
-
-  it 'archives files which can then be read using the usual means with Rubyzip' do
-    zip_buf = Tempfile.new('zipp')
-    zip_buf.binmode
-    output_io = double('IO')
-
-    # Only allow the methods we provide in BlockWrite.
-    # Will raise an error if other methods are triggered (the ones that
-    # might try to rewind the IO).
-    allow(output_io).to receive(:<<) {|data|
-      zip_buf << data.to_s.force_encoding(Encoding::BINARY)
-    }
-
-    allow(output_io).to receive(:tell) { zip_buf.tell }
-    allow(output_io).to receive(:pos) { zip_buf.pos }
-    allow(output_io).to receive(:close)
-
-    # Generate a couple of random files
-    raw_file_1 = SecureRandom.random_bytes(1024 * 20)
-    raw_file_2 = SecureRandom.random_bytes(1024 * 128)
-
-    # Perform the zipping
-    zip = described_class.new(output_io)
-    zip.add_stored_entry(filename: "first-file.bin", size: raw_file_1.size, crc32: Zlib.crc32(raw_file_1))
-    zip << raw_file_1
-    zip.add_stored_entry(filename: "second-file.bin", size: raw_file_2.size, crc32: Zlib.crc32(raw_file_2))
-    zip << raw_file_2
-    zip.close
-
-    zip_buf.flush
-
-    per_filename = {}
-    Zip::File.open(zip_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.
-        # Somehow an empty string gets read
-        per_filename[entry.name] = entry.get_input_stream.read
-      end
-    end
-
-    expect(per_filename['first-file.bin'].unpack("C*")).to eq(raw_file_1.unpack("C*"))
-    expect(per_filename['second-file.bin'].unpack("C*")).to eq(raw_file_2.unpack("C*"))
-
-    wd = Dir.pwd
-    Dir.mktmpdir do | td |
-      Dir.chdir(td)
-      inspect_zip_with_external_tool(zip_buf.path)
-    end
-    Dir.chdir(wd)
-  end
-
-  it 'sets the general-purpose flag for entries with UTF8 names' do
-    zip_buf = Tempfile.new('zipp')
-    zip_buf.binmode
-
-    # Generate a couple of random files
-    raw_file_1 = SecureRandom.random_bytes(1024 * 20)
-    raw_file_2 = SecureRandom.random_bytes(1024 * 128)
-
-    # Perform the zipping
-    zip = described_class.new(zip_buf)
-    zip.add_stored_entry(filename: "first-file.bin", size: raw_file_1.size, crc32: Zlib.crc32(raw_file_1))
-    zip << raw_file_1
-    zip.add_stored_entry(filename: "второй-файл.bin", size: raw_file_2.size, crc32: Zlib.crc32(raw_file_2))
-    IO.copy_stream(StringIO.new(raw_file_2), zip)
-    zip.close
-
-    zip_buf.flush
-
-    entries = []
-    Zip::File.open(zip_buf.path) do |zip_file|
-      # Handle entries one by one
-      zip_file.each {|entry| entries << entry }
-      first_entry, second_entry = entries
-
-      expect(first_entry.gp_flags).to eq(0)
-      expect(first_entry.name).to eq('first-file.bin')
-
-      # Rubyzip does not properly set the encoding of the entries it reads
-      expect(second_entry.gp_flags).to eq(2048)
-      expect(second_entry.name).to eq("второй-файл.bin".force_encoding(Encoding::BINARY))
-    end
-  end
-
-  it 'creates an archive with data descriptors that can be opened by Rubyzip, with a small number of very tiny text files' do
-    tf = ManagedTempfile.new('zip')
-    z = described_class.open(tf) do |zip|
-      zip.write_stored_file('deflated.txt') do |sink|
-        sink << File.read(__dir__ + '/war-and-peace.txt')
-      end
-      zip.write_deflated_file('stored.txt') do |sink|
-        sink << File.read(__dir__ + '/war-and-peace.txt')
-      end
-    end
-    tf.flush
-
-    pending 'https://github.com/rubyzip/rubyzip/issues/295'
-
-    Zip::File.foreach(tf.path) do |entry|
-      # Make sure it is tagged as UNIX
-      expect(entry.fstype).to eq(3)
-
-      # The CRC
-      expect(entry.crc).to eq(Zlib.crc32(File.read(__dir__ + '/war-and-peace.txt')))
-
-      # Check the name
-      expect(entry.name).to match(/\.txt$/)
-
-      # Check the right external attributes (non-executable on UNIX)
-      expect(entry.external_file_attributes).to eq(2175008768)
-
-      # Check the file contents
-      readback = entry.get_input_stream.read
-      readback.force_encoding(Encoding::BINARY)
-      expect(readback[0..10]).to eq(File.read(__dir__ + '/war-and-peace.txt')[0..10])
-    end
-
-    inspect_zip_with_external_tool(tf.path)
-  end
-
-  it 'can create a valid ZIP archive without any files' do
-    tf = ManagedTempfile.new('zip')
-
-    described_class.open(tf) do |zip|
-    end
-
-    tf.flush
-    tf.rewind
-
-    expect { |b|
-      Zip::File.foreach(tf.path, &b)
-    }.not_to yield_control
-  end
-
-  it 'prevents duplicates in the stored files' do
-    files = ["README", "README", "file.one\\two.jpg", "file_one.jpg", "file_one (1).jpg",
-             "file\\one.jpg", "My.Super.file.txt.zip", "My.Super.file.txt.zip"]
-    fake_writer = double('Writer').as_null_object
-    seen_filenames = []
-    allow(fake_writer).to receive(:write_local_file_header) {|filename:, **others|
-      seen_filenames << filename
-    }
-    zip_streamer = described_class.new(StringIO.new, writer: fake_writer)
-    files.each do |fn|
-      zip_streamer.add_stored_entry(filename: fn, size: 1024, crc32: 0xCC)
-    end
-    expect(seen_filenames).to eq(["README", "README (1)", "file.one_two.jpg", "file_one.jpg",
-                                  "file_one (1).jpg", "file_one (2).jpg", "My.Super.file.txt.zip",
-                                  "My.Super.file (1).txt.zip"])
-  end
-end