rubyzip 1.1.4 → 1.1.5

data/test/odt_test_fix.rb

@@ -0,0 +1,30 @@
+require 'rubygems'
+require 'zip'
+
+file_name    = 'sample.odt'
+content_file = 'content.xml'
+
+def extract_and_compress(file, dir, content_file)
+  cont = "#{dir}/#{content_file}"
+  Zip::File.open(file) do |z|
+    z.extract(content_file, cont)
+    z.replace(content_file, cont)
+  end
+  FileUtils.remove cont
+end
+
+dir     = File.expand_path File.dirname(__FILE__)
+tmpdir  = "#{dir}/#{Time.now.to_i}"
+FileUtils.mkdir tmpdir
+
+file    = "#{dir}/#{file_name}"
+file_cp = "#{tmpdir}/sample_1.odt"
+FileUtils.cp file, file_cp
+
+extract_and_compress file_cp, tmpdir, content_file
+
+file    = "#{tmpdir}/sample_1.odt"
+file_cp = "#{tmpdir}/sample_2.odt"
+FileUtils.cp file, file_cp
+
+extract_and_compress file_cp, tmpdir, content_file

data/test/output_stream_test.rb

@@ -0,0 +1,114 @@
+require 'test_helper'
+
+class ZipOutputStreamTest < MiniTest::Unit::TestCase
+  include AssertEntry
+
+  TEST_ZIP = TestZipFile::TEST_ZIP2.clone
+  TEST_ZIP.zip_name = "output.zip"
+
+  def test_new
+    zos = ::Zip::OutputStream.new(TEST_ZIP.zip_name)
+    zos.comment = TEST_ZIP.comment
+    write_test_zip(zos)
+    zos.close
+    assert_test_zip_contents(TEST_ZIP)
+  end
+
+  def test_open
+    ::Zip::OutputStream.open(TEST_ZIP.zip_name) do |zos|
+      zos.comment = TEST_ZIP.comment
+      write_test_zip(zos)
+    end
+    assert_test_zip_contents(TEST_ZIP)
+  end
+
+  def test_write_buffer
+    io = ::StringIO.new('')
+    buffer = ::Zip::OutputStream.write_buffer(io) do |zos|
+      zos.comment = TEST_ZIP.comment
+      write_test_zip(zos)
+    end
+    File.open(TEST_ZIP.zip_name, 'wb') { |f| f.write buffer.string }
+    assert_test_zip_contents(TEST_ZIP)
+  end
+
+  def test_writingToClosedStream
+    assert_i_o_error_in_closed_stream { |zos| zos << "hello world" }
+    assert_i_o_error_in_closed_stream { |zos| zos.puts "hello world" }
+    assert_i_o_error_in_closed_stream { |zos| zos.write "hello world" }
+  end
+
+  def test_cannotOpenFile
+    name = TestFiles::EMPTY_TEST_DIR
+    begin
+      ::Zip::OutputStream.open(name)
+    rescue Exception
+      assert($!.kind_of?(Errno::EISDIR) || # Linux
+                 $!.kind_of?(Errno::EEXIST) || # Windows/cygwin
+                 $!.kind_of?(Errno::EACCES), # Windows
+             "Expected Errno::EISDIR (or on win/cygwin: Errno::EEXIST), but was: #{$!.class}")
+    end
+  end
+
+  def test_put_next_entry
+    stored_text = "hello world in stored text"
+    entry_name = "file1"
+    comment = "my comment"
+    ::Zip::OutputStream.open(TEST_ZIP.zip_name) do |zos|
+      zos.put_next_entry(entry_name, comment, nil, ::Zip::Entry::STORED)
+      zos << stored_text
+    end
+
+    assert(File.read(TEST_ZIP.zip_name)[stored_text])
+    ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
+      assert_equal(stored_text, zf.read(entry_name))
+    end
+  end
+
+  def test_put_next_entry_using_zip_entry_creates_entries_with_correct_timestamps
+    file = ::File.open("test/data/file2.txt", "rb")
+    ::Zip::OutputStream.open(TEST_ZIP.zip_name) do |zos|
+      zip_entry = ::Zip::Entry.new(zos, file.path, "", "", 0, 0, ::Zip::Entry::DEFLATED, 0, ::Zip::DOSTime.at(file.mtime))
+      zos.put_next_entry(zip_entry)
+      zos << file.read
+    end
+
+    ::Zip::InputStream::open(TEST_ZIP.zip_name) do |io|
+      while (entry = io.get_next_entry)
+        assert(::Zip::DOSTime.at(file.mtime).dos_equals(::Zip::DOSTime.at(entry.mtime))) # Compare DOS Times, since they are stored with two seconds accuracy
+      end
+    end
+  end
+
+  def test_chained_put_into_next_entry
+    stored_text = "hello world in stored text"
+    stored_text2 = "with chain"
+    entry_name = "file1"
+    comment = "my comment"
+    ::Zip::OutputStream.open(TEST_ZIP.zip_name) do |zos|
+      zos.put_next_entry(entry_name, comment, nil, ::Zip::Entry::STORED)
+      zos << stored_text << stored_text2
+    end
+
+    assert(File.read(TEST_ZIP.zip_name)[stored_text])
+    ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
+      assert_equal(stored_text + stored_text2, zf.read(entry_name))
+    end
+
+  end
+
+  def assert_i_o_error_in_closed_stream
+    assert_raises(IOError) {
+      zos = ::Zip::OutputStream.new("test_putOnClosedStream.zip")
+      zos.close
+      yield zos
+    }
+  end
+
+  def write_test_zip(zos)
+    TEST_ZIP.entry_names.each do |entryName|
+      zos.put_next_entry(entryName)
+      File.open(entryName, "rb") { |f| zos.write(f.read) }
+    end
+  end
+end

data/test/pass_thru_compressor_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+class PassThruCompressorTest < MiniTest::Unit::TestCase
+  include CrcTest
+
+  def test_size
+    File.open("test/dummy.txt", "wb") {
+        |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
+
+  def test_crc
+    run_crc_test(::Zip::PassThruCompressor)
+  end
+end

data/test/pass_thru_decompressor_test.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+class PassThruDecompressorTest < MiniTest::Unit::TestCase
+  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/settings_test.rb

@@ -0,0 +1,71 @@
+require 'test_helper'
+
+class ZipSettingsTest < MiniTest::Unit::TestCase
+  # TODO Refactor out into common test module
+  include CommonZipFileFixture
+  TEST_OUT_NAME = "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 open_zip(&aProc)
+    assert(aProc != nil)
+    ::Zip::File.open(TestZipFile::TEST_ZIP4.zip_name, &aProc)
+  end
+
+  def extract_test_dir(&aProc)
+    open_zip {
+        |zf|
+      zf.extract(TestFiles::EMPTY_TEST_DIR, TEST_OUT_NAME, &aProc)
+    }
+  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
+
+
+  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_entryContents(zf, entryName, filename) if File.exist?(filename)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,228 @@
+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
+
+::MiniTest::Unit.after_tests 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
+    return 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_readEverything
+    assert_equal(@refText, @decompressor.sysread)
+  end
+
+  def test_readInChunks
+    chunkSize = 5
+    while (decompressedChunk = @decompressor.sysread(chunkSize))
+      assert_equal(@refText.slice!(0, chunkSize), decompressedChunk)
+    end
+    assert_equal(0, @refText.size)
+  end
+
+  def test_mixingReadsAndProduceInput
+    # 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_entryContentsForStream(filename, zis, entryName)
+  end
+
+  def assert_entryContentsForStream(filename, zis, entryName)
+    File.open(filename, "rb") {
+        |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
+
+  def AssertEntry.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_entryContents(zipFile, entryName, filename = entryName.to_s)
+    zis = zipFile.get_input_stream(entryName)
+    assert_entryContentsForStream(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 {
+        |element, index|
+      return false unless yield(element, otherAsArray[index])
+    }
+    return self.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