rubyzip 1.3.0 → 3.0.0.alpha

data/test/pass_thru_compressor_test.rb

@@ -1,30 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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/path_traversal_test.rb

@@ -1,141 +0,0 @@
-class PathTraversalTest < MiniTest::Test
-  TEST_FILE_ROOT = File.absolute_path('test/data/path_traversal')
-
-  def setup
-    # With apologies to anyone using these files... but they are the files in
-    # the sample zips, so we don't have much choice here.
-    FileUtils.rm_f '/tmp/moo'
-    FileUtils.rm_f '/tmp/file.txt'
-  end
-
-  def extract_path_traversal_zip(name)
-    Zip::File.open(File.join(TEST_FILE_ROOT, name)) do |zip_file|
-      zip_file.each do |entry|
-        entry.extract
-      end
-    end
-  end
-
-  def in_tmpdir
-    Dir.mktmpdir do |tmp|
-      test_path = File.join(tmp, 'test')
-      Dir.mkdir test_path
-      Dir.chdir test_path do
-        yield test_path
-      end
-    end
-  end
-
-  def test_leading_slash
-    in_tmpdir do
-      extract_path_traversal_zip 'jwilk/absolute1.zip'
-      refute File.exist?('/tmp/moo')
-    end
-  end
-
-  def test_multiple_leading_slashes
-    in_tmpdir do
-      extract_path_traversal_zip 'jwilk/absolute2.zip'
-      refute File.exist?('/tmp/moo')
-    end
-  end
-
-  def test_leading_dot_dot
-    in_tmpdir do
-      extract_path_traversal_zip 'jwilk/relative0.zip'
-      refute File.exist?('../moo')
-    end
-  end
-
-  def test_non_leading_dot_dot_with_existing_folder
-    in_tmpdir do
-      extract_path_traversal_zip 'relative1.zip'
-      assert Dir.exist?('tmp')
-      refute File.exist?('../moo')
-    end
-  end
-
-  def test_non_leading_dot_dot_without_existing_folder
-    in_tmpdir do
-      extract_path_traversal_zip 'jwilk/relative2.zip'
-      refute File.exist?('../moo')
-    end
-  end
-
-  def test_file_symlink
-    in_tmpdir do
-      extract_path_traversal_zip 'jwilk/symlink.zip'
-      assert File.exist?('moo')
-      refute File.exist?('/tmp/moo')
-    end
-  end
-
-  def test_directory_symlink
-    in_tmpdir do
-      # Can't create tmp/moo, because the tmp symlink is skipped.
-      assert_raises Errno::ENOENT do
-        extract_path_traversal_zip 'jwilk/dirsymlink.zip'
-      end
-      refute File.exist?('/tmp/moo')
-    end
-  end
-
-  def test_two_directory_symlinks_a
-    in_tmpdir do
-      # Can't create par/moo because the symlinks are skipped.
-      assert_raises Errno::ENOENT do
-        extract_path_traversal_zip 'jwilk/dirsymlink2a.zip'
-      end
-      refute File.exist?('cur')
-      refute File.exist?('par')
-      refute File.exist?('par/moo')
-    end
-  end
-
-  def test_two_directory_symlinks_b
-    in_tmpdir do
-      # Can't create par/moo, because the symlinks are skipped.
-      assert_raises Errno::ENOENT do
-        extract_path_traversal_zip 'jwilk/dirsymlink2b.zip'
-      end
-      refute File.exist?('cur')
-      refute File.exist?('../moo')
-    end
-  end
-
-  def test_entry_name_with_absolute_path_does_not_extract
-    in_tmpdir do
-      extract_path_traversal_zip 'tuzovakaoff/absolutepath.zip'
-      refute File.exist?('/tmp/file.txt')
-    end
-  end
-
-  def test_entry_name_with_absolute_path_extract_when_given_different_path
-    in_tmpdir do |test_path|
-      zip_path = File.join(TEST_FILE_ROOT, 'tuzovakaoff/absolutepath.zip')
-      Zip::File.open(zip_path) do |zip_file|
-        zip_file.each do |entry|
-          entry.extract(File.join(test_path, entry.name))
-        end
-      end
-      refute File.exist?('/tmp/file.txt')
-    end
-  end
-
-  def test_entry_name_with_relative_symlink
-    in_tmpdir do
-      # Doesn't create the symlink path, so can't create path/file.txt.
-      assert_raises Errno::ENOENT do
-        extract_path_traversal_zip 'tuzovakaoff/symlink.zip'
-      end
-      refute File.exist?('/tmp/file.txt')
-    end
-  end
-
-  def test_entry_name_with_tilde
-    in_tmpdir do
-      extract_path_traversal_zip 'tilde.zip'
-      assert File.exist?('~tilde~')
-    end
-  end
-end

data/test/samples/example_recursive_test.rb

@@ -1,37 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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

@@ -1,234 +0,0 @@
-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_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
-
-module ZipEntryData
-  TEST_ZIPFILE = 'someZipFile.zip'
-  TEST_COMMENT = 'a comment'
-  TEST_COMPRESSED_SIZE = 1234
-  TEST_CRC = 325_324
-  TEST_EXTRA = 'Some data here'
-  TEST_COMPRESSIONMETHOD = ::Zip::Entry::DEFLATED
-  TEST_NAME = 'entry name'
-  TEST_SIZE = 8432
-  TEST_ISDIRECTORY = false
-  TEST_TIME = Time.now
-end

data/test/unicode_file_names_and_comments_test.rb

@@ -1,62 +0,0 @@
-# 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
-
-    ::Zip.force_entry_names_encoding = 'UTF-8'
-    ::Zip::File.open(FILENAME) do |zip|
-      file_entrys.each do |filename|
-        refute_nil(zip.find_entry(filename))
-      end
-      directory_entrys.each do |filepath|
-        refute_nil(zip.find_entry(filepath))
-      end
-    end
-    ::Zip.force_entry_names_encoding = nil
-
-    ::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

@@ -1,51 +0,0 @@
-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 -tqq #{test_filename}"), 'third-party zip validation failed'
-    end
-  end
-
-end

data/test/zip64_support_test.rb

@@ -1,14 +0,0 @@
-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