archive-zip 0.3.0 → 0.4.0

data/spec/archive/zip/codec/traditional_encryption/decrypt/rewind_spec.rb

@@ -0,0 +1,38 @@
+# encoding: UTF-8
+
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+require File.dirname(__FILE__) + '/../fixtures/classes'
+require 'archive/zip/codec/traditional_encryption'
+
+describe "Archive::Zip::Codec::TraditionalEncryption::Decrypt#rewind" do
+  it "can rewind the stream when the delegate responds to rewind" do
+    TraditionalEncryptionSpecs.encrypted_data do |ed|
+      Archive::Zip::Codec::TraditionalEncryption::Decrypt.open(
+        ed,
+        TraditionalEncryptionSpecs.password,
+        TraditionalEncryptionSpecs.mtime
+      ) do |d|
+        d.read(4)
+        lambda { d.rewind }.should_not raise_error
+        d.read.should == TraditionalEncryptionSpecs.test_data
+      end
+    end
+  end
+
+  it "raises Errno::EINVAL when attempting to rewind the stream when the delegate does not respond to rewind" do
+    delegate = mock('delegate')
+    # RSpec's mocking facility supposedly supports this, but MSpec's does not as
+    # of version 1.5.10.
+    #delegate.should_receive(:read).with(an_instance_of(Fixnum)).at_least(:once).and_return { |n| "\000" * n }
+    # Use the following instead for now.
+    delegate.should_receive(:read).once.and_return("\000" * 12)
+    delegate.should_receive(:close).and_return(nil)
+    Archive::Zip::Codec::TraditionalEncryption::Decrypt.open(
+      delegate,
+      TraditionalEncryptionSpecs.password,
+      TraditionalEncryptionSpecs.mtime
+    ) do |d|
+      lambda { d.rewind }.should raise_error(Errno::EINVAL)
+    end
+  end
+end

data/spec/archive/zip/codec/traditional_encryption/decrypt/seek_spec.rb

@@ -0,0 +1,82 @@
+# encoding: UTF-8
+
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+require File.dirname(__FILE__) + '/../fixtures/classes'
+require 'archive/zip/codec/traditional_encryption'
+
+describe "Archive::Zip::Codec::TraditionalEncryption::Decrypt#seek" do
+  it "can seek to the beginning of the stream when the delegate responds to rewind" do
+    TraditionalEncryptionSpecs.encrypted_data do |ed|
+      Archive::Zip::Codec::TraditionalEncryption::Decrypt.open(
+        ed,
+        TraditionalEncryptionSpecs.password,
+        TraditionalEncryptionSpecs.mtime
+      ) do |d|
+        d.read(4)
+        lambda { d.seek(0) }.should_not raise_error
+      end
+    end
+  end
+
+  it "raises Errno::EINVAL when attempting to seek to the beginning of the stream when the delegate does not respond to rewind" do
+    delegate = mock('delegate')
+    # RSpec's mocking facility supposedly supports this, but MSpec's does not as
+    # of version 1.5.10.
+    #delegate.should_receive(:read).with(an_instance_of(Fixnum)).at_least(:once).and_return { |n| "\000" * n }
+    # Use the following instead for now.
+    delegate.should_receive(:read).once.and_return("\000" * 12)
+    delegate.should_receive(:close).and_return(nil)
+    Archive::Zip::Codec::TraditionalEncryption::Decrypt.open(
+      delegate,
+      TraditionalEncryptionSpecs.password,
+      TraditionalEncryptionSpecs.mtime
+    ) do |d|
+      lambda { d.seek(0) }.should raise_error(Errno::EINVAL)
+    end
+  end
+
+  it "raises Errno::EINVAL when seeking forward or backward from the current position of the stream" do
+    TraditionalEncryptionSpecs.encrypted_data do |ed|
+      Archive::Zip::Codec::TraditionalEncryption::Decrypt.open(
+        ed,
+        TraditionalEncryptionSpecs.password,
+        TraditionalEncryptionSpecs.mtime
+      ) do |d|
+        # Disable read buffering to avoid some seeking optimizations implemented
+        # by IO::Like which allow seeking forward within the buffer.
+        d.fill_size = 0
+
+        d.read(4)
+        lambda { d.seek(1, IO::SEEK_CUR) }.should raise_error(Errno::EINVAL)
+        lambda { d.seek(-1, IO::SEEK_CUR) }.should raise_error(Errno::EINVAL)
+      end
+    end
+  end
+
+  it "raises Errno::EINVAL when seeking a non-zero offset relative to the beginning of the stream" do
+    TraditionalEncryptionSpecs.encrypted_data do |ed|
+      Archive::Zip::Codec::TraditionalEncryption::Decrypt.open(
+        ed,
+        TraditionalEncryptionSpecs.password,
+        TraditionalEncryptionSpecs.mtime
+      ) do |d|
+        lambda { d.seek(-1, IO::SEEK_SET) }.should raise_error(Errno::EINVAL)
+        lambda { d.seek(1, IO::SEEK_SET) }.should raise_error(Errno::EINVAL)
+      end
+    end
+  end
+
+  it "raises Errno::EINVAL when seeking relative to the end of the stream" do
+    TraditionalEncryptionSpecs.encrypted_data do |ed|
+      Archive::Zip::Codec::TraditionalEncryption::Decrypt.open(
+        ed,
+        TraditionalEncryptionSpecs.password,
+        TraditionalEncryptionSpecs.mtime
+      ) do |d|
+        lambda { d.seek(0, IO::SEEK_END) }.should raise_error(Errno::EINVAL)
+        lambda { d.seek(-1, IO::SEEK_END) }.should raise_error(Errno::EINVAL)
+        lambda { d.seek(1, IO::SEEK_END) }.should raise_error(Errno::EINVAL)
+      end
+    end
+  end
+end

data/spec/archive/zip/codec/traditional_encryption/decrypt/tell_spec.rb

@@ -0,0 +1,25 @@
+# encoding: UTF-8
+
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+require File.dirname(__FILE__) + '/../fixtures/classes'
+require 'archive/zip/codec/traditional_encryption'
+
+describe "Archive::Zip::Codec::TraditionalEncryption::Decrypt#tell" do
+  it "returns the current position of the stream" do
+    TraditionalEncryptionSpecs.encrypted_data do |ed|
+      Archive::Zip::Codec::TraditionalEncryption::Decrypt.open(
+        ed,
+        TraditionalEncryptionSpecs.password,
+        TraditionalEncryptionSpecs.mtime
+      ) do |d|
+        d.tell.should == 0
+        d.read(4)
+        d.tell.should == 4
+        d.read
+        d.tell.should == 235
+        d.rewind
+        d.tell.should == 0
+      end
+    end
+  end
+end

data/spec/archive/zip/codec/traditional_encryption/encrypt/close_spec.rb

@@ -0,0 +1,64 @@
+# encoding: UTF-8
+
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+require File.dirname(__FILE__) + '/../fixtures/classes'
+require 'archive/zip/codec/traditional_encryption'
+require 'archive/support/binary_stringio'
+
+describe "Archive::Zip::Codec::TraditionalEncryption::Encrypt#close" do
+  it "closes the stream" do
+    e = Archive::Zip::Codec::TraditionalEncryption::Encrypt.new(
+      BinaryStringIO.new,
+      TraditionalEncryptionSpecs.password,
+      TraditionalEncryptionSpecs.mtime
+    )
+    e.close
+    e.closed?.should be_true
+  end
+
+  it "closes the delegate stream by default" do
+    delegate = mock('delegate')
+    # RSpec's mocking facility supposedly supports this, but MSpec's does not as
+    # of version 1.5.10.
+    #delegate.should_receive(:write).with(an_instance_of(String)).at_least(:once).and_return { |s| s.length }
+    # Use the following instead for now.
+    delegate.should_receive(:write).at_least(:once).and_return(1)
+    delegate.should_receive(:close).and_return(nil)
+    e = Archive::Zip::Codec::TraditionalEncryption::Encrypt.new(
+      delegate,
+      TraditionalEncryptionSpecs.password,
+      TraditionalEncryptionSpecs.mtime
+    )
+    e.close
+  end
+
+  it "optionally leaves the delegate stream open" do
+    delegate = mock('delegate')
+    # RSpec's mocking facility supposedly supports this, but MSpec's does not as
+    # of version 1.5.10.
+    #delegate.should_receive(:write).with(an_instance_of(String)).at_least(:once).and_return { |s| s.length }
+    # Use the following instead for now.
+    delegate.should_receive(:write).at_least(:once).and_return(1)
+    delegate.should_receive(:close).and_return(nil)
+    e = Archive::Zip::Codec::TraditionalEncryption::Encrypt.new(
+      delegate,
+      TraditionalEncryptionSpecs.password,
+      TraditionalEncryptionSpecs.mtime
+    )
+    e.close(true)
+
+    delegate = mock('delegate')
+    # RSpec's mocking facility supposedly supports this, but MSpec's does not as
+    # of version 1.5.10.
+    #delegate.should_receive(:write).with(an_instance_of(String)).at_least(:once).and_return { |s| s.length }
+    # Use the following instead for now.
+    delegate.should_receive(:write).at_least(:once).and_return(1)
+    delegate.should_not_receive(:close)
+    e = Archive::Zip::Codec::TraditionalEncryption::Encrypt.new(
+      delegate,
+      TraditionalEncryptionSpecs.password,
+      TraditionalEncryptionSpecs.mtime
+    )
+    e.close(false)
+  end
+end

data/spec/archive/zip/codec/traditional_encryption/encrypt/new_spec.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+require File.dirname(__FILE__) + '/../fixtures/classes'
+require 'archive/zip/codec/traditional_encryption'
+require 'archive/support/binary_stringio'
+
+describe "Archive::Zip::Codec::TraditionalEncryption::Encrypt.new" do
+  it "returns a new instance" do
+    e = Archive::Zip::Codec::TraditionalEncryption::Encrypt.new(
+      BinaryStringIO.new,
+      TraditionalEncryptionSpecs.password,
+      TraditionalEncryptionSpecs.mtime
+    )
+    e.class.should == Archive::Zip::Codec::TraditionalEncryption::Encrypt
+    e.close
+  end
+end

data/spec/archive/zip/codec/traditional_encryption/encrypt/open_spec.rb

@@ -0,0 +1,39 @@
+# encoding: UTF-8
+
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+require File.dirname(__FILE__) + '/../fixtures/classes'
+require 'archive/zip/codec/traditional_encryption'
+require 'archive/support/binary_stringio'
+
+describe "Archive::Zip::Codec::TraditionalEncryption::Encrypt.open" do
+  it "returns a new instance when run without a block" do
+    e = Archive::Zip::Codec::TraditionalEncryption::Encrypt.open(
+      BinaryStringIO.new,
+      TraditionalEncryptionSpecs.password,
+      TraditionalEncryptionSpecs.mtime
+    )
+    e.class.should == Archive::Zip::Codec::TraditionalEncryption::Encrypt
+    e.close
+  end
+
+  it "executes a block with a new instance as an argument" do
+    Archive::Zip::Codec::TraditionalEncryption::Encrypt.open(
+      BinaryStringIO.new,
+      TraditionalEncryptionSpecs.password,
+      TraditionalEncryptionSpecs.mtime
+    ) do |encryptor|
+      encryptor.class.should == Archive::Zip::Codec::TraditionalEncryption::Encrypt
+    end
+  end
+
+  it "closes the object after executing a block" do
+    e = Archive::Zip::Codec::TraditionalEncryption::Encrypt.open(
+      BinaryStringIO.new,
+      TraditionalEncryptionSpecs.password,
+      TraditionalEncryptionSpecs.mtime
+    ) do |encryptor|
+      encryptor
+    end
+    e.closed?.should.be_true
+  end
+end

data/spec/archive/zip/codec/traditional_encryption/encrypt/rewind_spec.rb

@@ -0,0 +1,41 @@
+# encoding: UTF-8
+
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+require File.dirname(__FILE__) + '/../fixtures/classes'
+require 'archive/zip/codec/traditional_encryption'
+require 'archive/support/binary_stringio'
+
+describe "Archive::Zip::Codec::TraditionalEncryption::Encrypt#rewind" do
+  it "can rewind the stream when the delegate responds to rewind" do
+    encrypted_data = BinaryStringIO.new
+    Archive::Zip::Codec::TraditionalEncryption::Encrypt.open(
+      encrypted_data,
+      TraditionalEncryptionSpecs.password,
+      TraditionalEncryptionSpecs.mtime
+    ) do |e|
+      e.write('test')
+      # Ensure repeatable test data is used for encryption header.
+      srand(0)
+      lambda { e.rewind }.should_not raise_error
+      e.write(TraditionalEncryptionSpecs.test_data)
+    end
+    encrypted_data.string.should == TraditionalEncryptionSpecs.encrypted_data
+  end
+
+  it "raises Errno::EINVAL when attempting to rewind the stream when the delegate does not respond to rewind" do
+    delegate = mock('delegate')
+    # RSpec's mocking facility supposedly supports this, but MSpec's does not as
+    # of version 1.5.10.
+    #delegate.should_receive(:write).with(an_instance_of(String)).at_least(:once).and_return { |s| s.length }
+    # Use the following instead for now.
+    delegate.should_receive(:write).at_least(:once).and_return(1)
+    delegate.should_receive(:close).once.and_return(nil)
+    Archive::Zip::Codec::TraditionalEncryption::Encrypt.open(
+      delegate,
+      TraditionalEncryptionSpecs.password,
+      TraditionalEncryptionSpecs.mtime
+    ) do |e|
+      lambda { e.rewind }.should raise_error(Errno::EINVAL)
+    end
+  end
+end

data/spec/archive/zip/codec/traditional_encryption/encrypt/seek_spec.rb

@@ -0,0 +1,75 @@
+# encoding: UTF-8
+
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+require File.dirname(__FILE__) + '/../fixtures/classes'
+require 'archive/zip/codec/traditional_encryption'
+require 'archive/support/binary_stringio'
+
+describe "Archive::Zip::Codec::TraditionalEncryption::Encrypt#seek" do
+  it "can seek to the beginning of the stream when the delegate responds to rewind" do
+    encrypted_data = BinaryStringIO.new
+    Archive::Zip::Codec::TraditionalEncryption::Encrypt.open(
+      encrypted_data,
+      TraditionalEncryptionSpecs.password,
+      TraditionalEncryptionSpecs.mtime
+    ) do |e|
+      e.write('test')
+      lambda { e.seek(0) }.should_not raise_error
+    end
+  end
+
+  it "raises Errno::EINVAL when attempting to seek to the beginning of the stream when the delegate does not respond to rewind" do
+    delegate = mock('delegate')
+    # RSpec's mocking facility supposedly supports this, but MSpec's does not as
+    # of version 1.5.10.
+    #delegate.should_receive(:write).with(an_instance_of(String)).at_least(:once).and_return { |s| s.length }
+    # Use the following instead for now.
+    delegate.should_receive(:write).at_least(:once).and_return(1)
+    delegate.should_receive(:close).and_return(nil)
+    Archive::Zip::Codec::TraditionalEncryption::Encrypt.open(
+      delegate,
+      TraditionalEncryptionSpecs.password,
+      TraditionalEncryptionSpecs.mtime
+    ) do |e|
+      lambda { e.seek(0) }.should raise_error(Errno::EINVAL)
+    end
+  end
+
+  it "raises Errno::EINVAL when seeking forward or backward from the current position of the stream" do
+    encrypted_data = BinaryStringIO.new
+    Archive::Zip::Codec::TraditionalEncryption::Encrypt.open(
+      encrypted_data,
+      TraditionalEncryptionSpecs.password,
+      TraditionalEncryptionSpecs.mtime
+    ) do |e|
+      e.write('test')
+      lambda { e.seek(1, IO::SEEK_CUR) }.should raise_error(Errno::EINVAL)
+      lambda { e.seek(-1, IO::SEEK_CUR) }.should raise_error(Errno::EINVAL)
+    end
+  end
+
+  it "raises Errno::EINVAL when seeking a non-zero offset relative to the beginning of the stream" do
+    encrypted_data = BinaryStringIO.new
+    Archive::Zip::Codec::TraditionalEncryption::Encrypt.open(
+      encrypted_data,
+      TraditionalEncryptionSpecs.password,
+      TraditionalEncryptionSpecs.mtime
+    ) do |e|
+      lambda { e.seek(-1, IO::SEEK_SET) }.should raise_error(Errno::EINVAL)
+      lambda { e.seek(1, IO::SEEK_SET) }.should raise_error(Errno::EINVAL)
+    end
+  end
+
+  it "raises Errno::EINVAL when seeking relative to the end of the stream" do
+    encrypted_data = BinaryStringIO.new
+    Archive::Zip::Codec::TraditionalEncryption::Encrypt.open(
+      encrypted_data,
+      TraditionalEncryptionSpecs.password,
+      TraditionalEncryptionSpecs.mtime
+    ) do |e|
+      lambda { e.seek(0, IO::SEEK_END) }.should raise_error(Errno::EINVAL)
+      lambda { e.seek(-1, IO::SEEK_END) }.should raise_error(Errno::EINVAL)
+      lambda { e.seek(1, IO::SEEK_END) }.should raise_error(Errno::EINVAL)
+    end
+  end
+end

data/spec/archive/zip/codec/traditional_encryption/encrypt/tell_spec.rb

@@ -0,0 +1,42 @@
+# encoding: UTF-8
+
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+require File.dirname(__FILE__) + '/../fixtures/classes'
+require 'archive/zip/codec/traditional_encryption'
+require 'archive/support/binary_stringio'
+
+describe "Archive::Zip::Codec::TraditionalEncryption::Encrypt#tell" do
+  it "returns the current position of the stream" do
+    encrypted_data = BinaryStringIO.new
+    Archive::Zip::Codec::TraditionalEncryption::Encrypt.open(
+      encrypted_data,
+      TraditionalEncryptionSpecs.password,
+      TraditionalEncryptionSpecs.mtime
+    ) do |e|
+      e.tell.should == 0
+      e.write('test1')
+      e.tell.should == 5
+      e.write('test2')
+      e.tell.should == 10
+      e.rewind
+      e.tell.should == 0
+    end
+  end
+
+  it "raises IOError on closed stream" do
+    delegate = mock('delegate')
+    # RSpec's mocking facility supposedly supports this, but MSpec's does not as
+    # of version 1.5.10.
+    #delegate.should_receive(:write).with(an_instance_of(String)).at_least(:once).and_return { |s| s.length }
+    # Use the following instead for now.
+    delegate.should_receive(:write).at_least(:once).and_return(1)
+    delegate.should_receive(:close).once.and_return(nil)
+    lambda do
+      Archive::Zip::Codec::TraditionalEncryption::Encrypt.open(
+        delegate,
+        TraditionalEncryptionSpecs.password,
+        TraditionalEncryptionSpecs.mtime
+      ) { |e| e }.tell
+    end.should raise_error(IOError)
+  end
+end

data/spec/archive/zip/codec/traditional_encryption/encrypt/write_spec.rb

@@ -0,0 +1,127 @@
+# encoding: UTF-8
+
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+require File.dirname(__FILE__) + '/../fixtures/classes'
+require 'archive/zip/codec/traditional_encryption'
+require 'archive/support/binary_stringio'
+
+describe "Archive::Zip::Codec::TraditionalEncryption::Encrypt#write" do
+  it "calls the write method of the delegate" do
+    delegate = mock('delegate')
+    # RSpec's mocking facility supposedly supports this, but MSpec's does not as
+    # of version 1.5.10.
+    #delegate.should_receive(:write).with(an_instance_of(String)).at_least(:once).and_return { |s| s.length }
+    # Use the following instead for now.
+    delegate.should_receive(:write).at_least(:once).and_return(1)
+    delegate.should_receive(:close).once.and_return(nil)
+    Archive::Zip::Codec::TraditionalEncryption::Encrypt.open(
+      delegate,
+      TraditionalEncryptionSpecs.password,
+      TraditionalEncryptionSpecs.mtime
+    ) do |e|
+      e.write(TraditionalEncryptionSpecs.test_data)
+    end
+  end
+
+  it "writes encrypted data to the delegate" do
+    # Ensure repeatable test data is used for encryption header.
+    srand(0)
+    encrypted_data = BinaryStringIO.new
+    Archive::Zip::Codec::TraditionalEncryption::Encrypt.open(
+      encrypted_data,
+      TraditionalEncryptionSpecs.password,
+      TraditionalEncryptionSpecs.mtime
+    ) do |e|
+      e.write(TraditionalEncryptionSpecs.test_data)
+    end
+    encrypted_data.string.should == TraditionalEncryptionSpecs.encrypted_data
+  end
+
+  it "writes encrypted data to a delegate that only performs partial writes" do
+    # Ensure repeatable test data is used for encryption header.
+    srand(0)
+    encrypted_data = BinaryStringIO.new
+    # Override encrypted_data.write to perform writes 1 byte at a time.
+    class << encrypted_data
+      alias :write_orig :write
+      def write(buffer)
+        write_orig(buffer.slice(0, 1))
+      end
+    end
+
+    Archive::Zip::Codec::TraditionalEncryption::Encrypt.open(
+      encrypted_data,
+      TraditionalEncryptionSpecs.password,
+      TraditionalEncryptionSpecs.mtime
+    ) do |e|
+      e.write(TraditionalEncryptionSpecs.test_data)
+    end
+    encrypted_data.string.should == TraditionalEncryptionSpecs.encrypted_data
+  end
+
+  it "writes encrypted data to a delegate that raises Errno::EAGAIN" do
+    # Ensure repeatable test data is used for encryption header.
+    srand(0)
+    encrypted_data = BinaryStringIO.new
+    # Override encrypted_data.write to raise Errno::EAGAIN every other time it's
+    # called.
+    class << encrypted_data
+      alias :write_orig :write
+      def write(buffer)
+        if @error_raised then
+          @error_raised = false
+          write_orig(buffer)
+        else
+          @error_raised = true
+          raise Errno::EAGAIN
+        end
+      end
+    end
+
+    Archive::Zip::Codec::TraditionalEncryption::Encrypt.open(
+      encrypted_data,
+      TraditionalEncryptionSpecs.password,
+      TraditionalEncryptionSpecs.mtime
+    ) do |e|
+      begin
+        e.write(TraditionalEncryptionSpecs.test_data)
+      rescue Errno::EAGAIN
+        retry
+      end
+    end
+    encrypted_data.string.should == TraditionalEncryptionSpecs.encrypted_data
+  end
+
+  it "writes encrypted data to a delegate that raises Errno::EINTR" do
+    # Ensure repeatable test data is used for encryption header.
+    srand(0)
+    encrypted_data = BinaryStringIO.new
+    # Override encrypted_data.write to raise Errno::EINTR every other time it's
+    # called.
+    class << encrypted_data
+      alias :write_orig :write
+      def write(buffer)
+        if @error_raised then
+          @error_raised = false
+          write_orig(buffer)
+        else
+          @error_raised = true
+          raise Errno::EINTR
+        end
+      end
+    end
+
+    Archive::Zip::Codec::TraditionalEncryption::Encrypt.open(
+      encrypted_data,
+      TraditionalEncryptionSpecs.password,
+      TraditionalEncryptionSpecs.mtime
+    ) do |e|
+      begin
+        e.write(TraditionalEncryptionSpecs.test_data)
+      rescue Errno::EINTR
+        retry
+      end
+    end
+    encrypted_data.string.should == TraditionalEncryptionSpecs.encrypted_data
+  end
+end