rubyzip 1.0.0 → 1.2.0

data/test/pass_thru_compressor_test.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+
+class PassThruCompressorTest < MiniTest::Test
+  include CrcTest
+
+  def test_size
+    File.open('test/data/generated/dummy.txt', 'wb') do |file|
+      compressor = ::Zip::PassThruCompressor.new(file)
+
+      assert_equal(0, compressor.size)
+
+      t1 = 'hello world'
+      t2 = ''
+      t3 = 'bingo'
+
+      compressor << t1
+      assert_equal(compressor.size, t1.size)
+
+      compressor << t2
+      assert_equal(compressor.size, t1.size + t2.size)
+
+      compressor << t3
+      assert_equal(compressor.size, t1.size + t2.size + t3.size)
+    end
+  end
+
+  def test_crc
+    run_crc_test(::Zip::PassThruCompressor)
+  end
+end

data/test/pass_thru_decompressor_test.rb

@@ -0,0 +1,14 @@
+require 'test_helper'
+class PassThruDecompressorTest < MiniTest::Test
+  include DecompressorTests
+
+  def setup
+    super
+    @file = File.new(TEST_FILE)
+    @decompressor = ::Zip::PassThruDecompressor.new(@file, File.size(TEST_FILE))
+  end
+
+  def teardown
+    @file.close
+  end
+end

data/test/samples/example_recursive_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+require 'fileutils'
+require_relative '../../samples/example_recursive'
+
+class ExampleRecursiveTest < MiniTest::Test
+  DIRECTORY_TO_ZIP  = 'test/data/globTest'
+  OUTPUT_DIRECTORY  = 'test/data/example_recursive.zip'
+  TEMP_DIRECTORY    = 'test/data/tmp'
+
+  def setup
+    @generator = ::ZipFileGenerator.new(DIRECTORY_TO_ZIP, OUTPUT_DIRECTORY)
+  end
+
+  def teardown
+    FileUtils.rm_rf TEMP_DIRECTORY
+    FileUtils.rm_f OUTPUT_DIRECTORY
+  end
+
+  def test_write
+    @generator.write
+    unzip
+    assert_equal Dir.entries(DIRECTORY_TO_ZIP).sort, Dir.entries(TEMP_DIRECTORY).sort
+  end
+
+  private
+
+  def unzip(file = OUTPUT_DIRECTORY)
+    Zip::File.open(file) do |zip_file|
+      zip_file.each do |f|
+        file_path = File.join(TEMP_DIRECTORY, f.name)
+        FileUtils.mkdir_p(File.dirname(file_path))
+
+        zip_file.extract(f, file_path) unless File.exist?(file_path)
+      end
+    end
+  end
+end

data/test/settings_test.rb

@@ -0,0 +1,95 @@
+require 'test_helper'
+
+class ZipSettingsTest < MiniTest::Test
+  # TODO: Refactor out into common test module
+  include CommonZipFileFixture
+
+  TEST_OUT_NAME = 'test/data/generated/emptyOutDir'
+
+  def setup
+    super
+
+    Dir.rmdir(TEST_OUT_NAME) if File.directory? TEST_OUT_NAME
+    File.delete(TEST_OUT_NAME) if File.exist? TEST_OUT_NAME
+  end
+
+  def teardown
+    ::Zip.reset!
+  end
+
+  def open_zip(&aProc)
+    assert(!aProc.nil?)
+    ::Zip::File.open(TestZipFile::TEST_ZIP4.zip_name, &aProc)
+  end
+
+  def extract_test_dir(&aProc)
+    open_zip do |zf|
+      zf.extract(TestFiles::EMPTY_TEST_DIR, TEST_OUT_NAME, &aProc)
+    end
+  end
+
+  def test_true_on_exists_proc
+    Zip.on_exists_proc = true
+    File.open(TEST_OUT_NAME, 'w') { |f| f.puts 'something' }
+    extract_test_dir
+    assert(File.directory?(TEST_OUT_NAME))
+  end
+
+  def test_false_on_exists_proc
+    Zip.on_exists_proc = false
+    File.open(TEST_OUT_NAME, 'w') { |f| f.puts 'something' }
+    assert_raises(Zip::DestinationFileExistsError) { extract_test_dir }
+  end
+
+  def test_false_continue_on_exists_proc
+    Zip.continue_on_exists_proc = false
+
+    assert_raises(::Zip::EntryExistsError) do
+      ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
+        zf.add(zf.entries.first.name, 'test/data/file2.txt')
+      end
+    end
+  end
+
+  def test_true_continue_on_exists_proc
+    Zip.continue_on_exists_proc = true
+
+    replacedEntry = nil
+
+    ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
+      replacedEntry = zf.entries.first.name
+      zf.add(replacedEntry, 'test/data/file2.txt')
+    end
+
+    ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
+      assert_contains(zf, replacedEntry, 'test/data/file2.txt')
+    end
+  end
+
+  def test_false_warn_invalid_date
+    test_file = File.join(File.dirname(__FILE__), 'data', 'WarnInvalidDate.zip')
+    Zip.warn_invalid_date = false
+
+    assert_output('', '') do
+      ::Zip::File.open(test_file) do |_zf|
+      end
+    end
+  end
+
+  def test_true_warn_invalid_date
+    test_file = File.join(File.dirname(__FILE__), 'data', 'WarnInvalidDate.zip')
+    Zip.warn_invalid_date = true
+
+    assert_output('', /Invalid date\/time in zip entry/) do
+      ::Zip::File.open(test_file) do |_zf|
+      end
+    end
+  end
+
+  private
+
+  def assert_contains(zf, entryName, filename = entryName)
+    assert(zf.entries.detect { |e| e.name == entryName } != nil, "entry #{entryName} not in #{zf.entries.join(', ')} in zip file #{zf}")
+    assert_entry_contents(zf, entryName, filename) if File.exist?(filename)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,221 @@
+require 'simplecov'
+require 'minitest/autorun'
+require 'minitest/unit'
+require 'fileutils'
+require 'digest/sha1'
+require 'zip'
+require 'gentestfiles'
+
+TestFiles.create_test_files
+TestZipFile.create_test_zips
+
+if defined? JRUBY_VERSION
+  require 'jruby'
+  JRuby.objectspace = true
+end
+
+::MiniTest.after_run do
+  FileUtils.rm_rf('test/data/generated')
+end
+
+module IOizeString
+  attr_reader :tell
+
+  def read(count = nil)
+    @tell ||= 0
+    count = size unless count
+    retVal = slice(@tell, count)
+    @tell += count
+    retVal
+  end
+
+  def seek(index, offset)
+    @tell ||= 0
+    case offset
+    when IO::SEEK_END
+      newPos = size + index
+    when IO::SEEK_SET
+      newPos = index
+    when IO::SEEK_CUR
+      newPos = @tell + index
+    else
+      raise 'Error in test method IOizeString::seek'
+    end
+    if newPos < 0 || newPos >= size
+      raise Errno::EINVAL
+    else
+      @tell = newPos
+    end
+  end
+
+  def reset
+    @tell = 0
+  end
+end
+
+module DecompressorTests
+  # expects @refText, @refLines and @decompressor
+
+  TEST_FILE = 'test/data/file1.txt'
+
+  def setup
+    @refText = ''
+    File.open(TEST_FILE) { |f| @refText = f.read }
+    @refLines = @refText.split($/)
+  end
+
+  def test_read_everything
+    assert_equal(@refText, @decompressor.sysread)
+  end
+
+  def test_read_in_chunks
+    chunkSize = 5
+    while (decompressedChunk = @decompressor.sysread(chunkSize))
+      assert_equal(@refText.slice!(0, chunkSize), decompressedChunk)
+    end
+    assert_equal(0, @refText.size)
+  end
+
+  def test_mixing_reads_and_produce_input
+    # Just some preconditions to make sure we have enough data for this test
+    assert(@refText.length > 1000)
+    assert(@refLines.length > 40)
+
+    assert_equal(@refText[0...100], @decompressor.sysread(100))
+
+    assert(!@decompressor.input_finished?)
+    buf = @decompressor.produce_input
+    assert_equal(@refText[100...(100 + buf.length)], buf)
+  end
+end
+
+module AssertEntry
+  def assert_next_entry(filename, zis)
+    assert_entry(filename, zis, zis.get_next_entry.name)
+  end
+
+  def assert_entry(filename, zis, entryName)
+    assert_equal(filename, entryName)
+    assert_entry_contents_for_stream(filename, zis, entryName)
+  end
+
+  def assert_entry_contents_for_stream(filename, zis, entryName)
+    File.open(filename, 'rb') do |file|
+      expected = file.read
+      actual = zis.read
+      if (expected != actual)
+        if (expected && actual) && (expected.length > 400 || actual.length > 400)
+          zipEntryFilename = entryName + '.zipEntry'
+          File.open(zipEntryFilename, 'wb') { |entryfile| entryfile << actual }
+          fail("File '#{filename}' is different from '#{zipEntryFilename}'")
+        else
+          assert_equal(expected, actual)
+        end
+      end
+    end
+  end
+
+  def self.assert_contents(filename, aString)
+    fileContents = ''
+    File.open(filename, 'rb') { |f| fileContents = f.read }
+    if (fileContents != aString)
+      if fileContents.length > 400 || aString.length > 400
+        stringFile = filename + '.other'
+        File.open(stringFile, 'wb') { |f| f << aString }
+        fail("File '#{filename}' is different from contents of string stored in '#{stringFile}'")
+      else
+        assert_equal(fileContents, aString)
+      end
+    end
+  end
+
+  def assert_stream_contents(zis, testZipFile)
+    assert(!zis.nil?)
+    testZipFile.entry_names.each do |entryName|
+      assert_next_entry(entryName, zis)
+    end
+    assert_equal(nil, zis.get_next_entry)
+  end
+
+  def assert_test_zip_contents(testZipFile)
+    ::Zip::InputStream.open(testZipFile.zip_name) do |zis|
+      assert_stream_contents(zis, testZipFile)
+    end
+  end
+
+  def assert_entry_contents(zipFile, entryName, filename = entryName.to_s)
+    zis = zipFile.get_input_stream(entryName)
+    assert_entry_contents_for_stream(filename, zis, entryName)
+  ensure
+    zis.close if zis
+  end
+end
+
+module CrcTest
+  class TestOutputStream
+    include ::Zip::IOExtras::AbstractOutputStream
+
+    attr_accessor :buffer
+
+    def initialize
+      @buffer = ''
+    end
+
+    def <<(data)
+      @buffer << data
+      self
+    end
+  end
+
+  def run_crc_test(compressorClass)
+    str = "Here's a nice little text to compute the crc for! Ho hum, it is nice nice nice nice indeed."
+    fakeOut = TestOutputStream.new
+
+    deflater = compressorClass.new(fakeOut)
+    deflater << str
+    assert_equal(0x919920fc, deflater.crc)
+  end
+end
+
+module Enumerable
+  def compare_enumerables(otherEnumerable)
+    otherAsArray = otherEnumerable.to_a
+    each_with_index do |element, index|
+      return false unless yield(element, otherAsArray[index])
+    end
+    size == otherAsArray.size
+  end
+end
+
+module CommonZipFileFixture
+  include AssertEntry
+
+  EMPTY_FILENAME = 'emptyZipFile.zip'
+
+  TEST_ZIP = TestZipFile::TEST_ZIP2.clone
+  TEST_ZIP.zip_name = 'test/data/generated/5entry_copy.zip'
+
+  def setup
+    File.delete(EMPTY_FILENAME) if File.exist?(EMPTY_FILENAME)
+    FileUtils.cp(TestZipFile::TEST_ZIP2.zip_name, TEST_ZIP.zip_name)
+  end
+end
+
+module ExtraAssertions
+  def assert_forwarded(anObject, method, retVal, *expectedArgs)
+    callArgs = nil
+    setCallArgsProc = proc { |args| callArgs = args }
+    anObject.instance_eval <<-"end_eval"
+      alias #{method}_org #{method}
+      def #{method}(*args)
+        ObjectSpace._id2ref(#{setCallArgsProc.object_id}).call(args)
+        ObjectSpace._id2ref(#{retVal.object_id})
+        end
+    end_eval
+
+    assert_equal(retVal, yield) # Invoke test
+    assert_equal(expectedArgs, callArgs)
+  ensure
+    anObject.instance_eval "undef #{method}; alias #{method} #{method}_org"
+  end
+end

data/test/unicode_file_names_and_comments_test.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require 'test_helper'
+
+class ZipUnicodeFileNamesAndComments < MiniTest::Test
+  FILENAME = File.join(File.dirname(__FILE__), 'test1.zip')
+
+  def test_unicode_file_name
+    file_entrys = ['текстовыйфайл.txt', 'Résumé.txt', '슬레이어스휘.txt']
+    directory_entrys = ['папка/текстовыйфайл.txt', 'Résumé/Résumé.txt', '슬레이어스휘/슬레이어스휘.txt']
+    stream = ::Zip::OutputStream.open(FILENAME) do |io|
+      file_entrys.each do |filename|
+        io.put_next_entry(filename)
+        io.write(filename)
+      end
+      directory_entrys.each do |filepath|
+        io.put_next_entry(filepath)
+        io.write(filepath)
+      end
+    end
+    assert(!stream.nil?)
+    ::Zip::InputStream.open(FILENAME) do |io|
+      file_entrys.each do |filename|
+        entry = io.get_next_entry
+        entry_name = entry.name
+        entry_name = entry_name.force_encoding('UTF-8')
+        assert(filename == entry_name)
+      end
+      directory_entrys.each do |filepath|
+        entry = io.get_next_entry
+        entry_name = entry.name
+        entry_name = entry_name.force_encoding('UTF-8')
+        assert(filepath == entry_name)
+      end
+    end
+    ::File.unlink(FILENAME)
+  end
+
+  def test_unicode_comment
+    str = '渠道升级'
+    ::Zip::File.open(FILENAME, Zip::File::CREATE) do |z|
+      z.comment = str
+    end
+
+    ::Zip::File.open(FILENAME) do |z|
+      assert(z.comment.force_encoding('UTF-8') == str)
+    end
+    ::File.unlink(FILENAME)
+  end
+end

data/test/zip64_full_test.rb

@@ -0,0 +1,51 @@
+if ENV['FULL_ZIP64_TEST']
+  require 'minitest/autorun'
+  require 'minitest/unit'
+  require 'fileutils'
+  require 'zip'
+
+  # test zip64 support for real, by actually exceeding the 32-bit size/offset limits
+  # this test does not, of course, run with the normal unit tests! ;)
+
+  class Zip64FullTest < MiniTest::Test
+    def teardown
+      ::Zip.reset!
+    end
+
+    def prepare_test_file(test_filename)
+      ::File.delete(test_filename) if ::File.exist?(test_filename)
+      test_filename
+    end
+
+    def test_large_zip_file
+      ::Zip.write_zip64_support = true
+      first_text = 'starting out small'
+      last_text = 'this tests files starting after 4GB in the archive'
+      test_filename = prepare_test_file('huge.zip')
+      ::Zip::OutputStream.open(test_filename) do |io|
+        io.put_next_entry('first_file.txt')
+        io.write(first_text)
+
+        # write just over 4GB (stored, so the zip file exceeds 4GB)
+        buf = 'blah' * 16_384
+        io.put_next_entry('huge_file', nil, nil, ::Zip::Entry::STORED)
+        65_537.times { io.write(buf) }
+
+        io.put_next_entry('last_file.txt')
+        io.write(last_text)
+      end
+
+      ::Zip::File.open(test_filename) do |zf|
+        assert_equal %w(first_file.txt huge_file last_file.txt), zf.entries.map(&:name)
+        assert_equal first_text, zf.read('first_file.txt')
+        assert_equal last_text, zf.read('last_file.txt')
+      end
+
+      # note: if this fails, be sure you have UnZip version 6.0 or newer
+      # as this is the first version to support zip64 extensions
+      # but some OSes (*cough* OSX) still bundle a 5.xx release
+      assert system("unzip -t #{test_filename}"), 'third-party zip validation failed'
+    end
+  end
+
+end

data/test/zip64_support_test.rb

@@ -0,0 +1,14 @@
+require 'test_helper'
+
+class Zip64SupportTest < MiniTest::Test
+  TEST_FILE = File.join(File.dirname(__FILE__), 'data', 'zip64-sample.zip')
+
+  def test_open_zip64_file
+    zip_file = ::Zip::File.open(TEST_FILE)
+    assert(!zip_file.nil?)
+    assert(zip_file.entries.count == 2)
+    test_rb = zip_file.entries.find { |x| x.name == 'test.rb' }
+    assert(test_rb.size == 482)
+    assert(test_rb.compressed_size == 229)
+  end
+end