depengine 0.0.1

data/etc/isolate/ruby-1.8/gems/net-sftp-2.0.4/test/protocol/04/test_attributes.rb

@@ -0,0 +1,148 @@
+require 'common'
+
+module Etc; end
+
+class Protocol::V04::TestAttributes < Net::SFTP::TestCase
+  def setup
+    @directory = attributes_factory.new(:type => attributes_factory::T_DIRECTORY)
+    @symlink = attributes_factory.new(:type => attributes_factory::T_SYMLINK)
+    @file = attributes_factory.new(:type => attributes_factory::T_REGULAR)
+  end
+
+  def test_from_buffer_should_correctly_parse_buffer_and_return_attribute_object
+    attributes = attributes_factory.from_buffer(full_buffer)
+
+    assert_equal 9, attributes.type
+    assert_equal 1234567890, attributes.size
+    assert_equal "jamis", attributes.owner
+    assert_equal "users", attributes.group
+    assert_equal 0755, attributes.permissions
+    assert_equal 1234567890, attributes.atime
+    assert_equal 12345, attributes.atime_nseconds
+    assert_equal 2345678901, attributes.createtime
+    assert_equal 23456, attributes.createtime_nseconds
+    assert_equal 3456789012, attributes.mtime
+    assert_equal 34567, attributes.mtime_nseconds
+
+    assert_equal 2, attributes.acl.length
+
+    assert_equal 1, attributes.acl.first.type
+    assert_equal 2, attributes.acl.first.flag
+    assert_equal 3, attributes.acl.first.mask
+    assert_equal "foo", attributes.acl.first.who
+
+    assert_equal 4, attributes.acl.last.type
+    assert_equal 5, attributes.acl.last.flag
+    assert_equal 6, attributes.acl.last.mask
+    assert_equal "bar", attributes.acl.last.who
+    
+    assert_equal "second", attributes.extended["first"]
+  end
+
+  def test_from_buffer_should_correctly_parse_buffer_with_attribute_subset_and_return_attribute_object
+    buffer = Net::SSH::Buffer.from(:long, 0x4, :byte, 1, :long, 0755)
+
+    attributes = attributes_factory.from_buffer(buffer)
+
+    assert_equal 1, attributes.type
+    assert_equal 0755, attributes.permissions
+
+    assert_nil attributes.size
+    assert_nil attributes.owner
+    assert_nil attributes.group
+    assert_nil attributes.atime
+    assert_nil attributes.atime_nseconds
+    assert_nil attributes.createtime
+    assert_nil attributes.createtime_nseconds
+    assert_nil attributes.mtime
+    assert_nil attributes.mtime_nseconds
+    assert_nil attributes.acl
+    assert_nil attributes.extended
+  end
+
+  def test_attributes_to_s_should_build_binary_representation
+    attributes = attributes_factory.new(
+      :type => 9,
+      :size => 1234567890,
+      :owner  => "jamis", :group => "users",
+      :permissions => 0755,
+      :atime => 1234567890, :atime_nseconds => 12345,
+      :createtime => 2345678901, :createtime_nseconds => 23456,
+      :mtime => 3456789012, :mtime_nseconds => 34567,
+      :acl => [attributes_factory::ACL.new(1,2,3,"foo"),
+               attributes_factory::ACL.new(4,5,6,"bar")],
+      :extended => { "first" => "second" })
+
+    assert_equal full_buffer.to_s, attributes.to_s
+  end
+
+  def test_attributes_to_s_should_build_binary_representation_when_subset_is_present
+    attributes = attributes_factory.new(:permissions => 0755)
+    assert_equal Net::SSH::Buffer.from(:long, 0x4, :byte, 1, :long, 0755).to_s, attributes.to_s
+  end
+
+  def test_attributes_to_s_with_uid_and_gid_should_translate_to_owner_and_group
+    attributes = attributes_factory.new(:uid => 100, :gid => 200)
+    attributes.expects(:require).with("etc").times(2)
+    Etc.expects(:getpwuid).with(100).returns(mock('user', :name => "jamis"))
+    Etc.expects(:getgrgid).with(200).returns(mock('group', :name => "sftp"))
+    assert_equal Net::SSH::Buffer.from(:long, 0x80, :byte, 1, :string, "jamis", :string, "sftp").to_s, attributes.to_s
+  end
+
+  def test_uid_should_translate_from_owner
+    attributes = attributes_factory.new(:owner => "jamis")
+    attributes.expects(:require).with("etc")
+    Etc.expects(:getpwnam).with("jamis").returns(mock('user', :uid => 100))
+    assert_equal 100, attributes.uid
+  end
+
+  def test_gid_should_translate_from_group
+    attributes = attributes_factory.new(:group => "sftp")
+    attributes.expects(:require).with("etc")
+    Etc.expects(:getgrnam).with("sftp").returns(mock('group', :gid => 200))
+    assert_equal 200, attributes.gid
+  end
+
+  def test_attributes_without_subsecond_times_should_serialize_without_subsecond_times
+    attributes = attributes_factory.new(:atime => 100)
+    assert_equal Net::SSH::Buffer.from(:long, 0x8, :byte, 1, :int64, 100).to_s, attributes.to_s
+  end
+
+  def test_directory_should_be_true_only_when_type_is_directory
+    assert @directory.directory?
+    assert !@symlink.directory?
+    assert !@file.directory?
+  end
+
+  def test_symlink_should_be_true_only_when_type_is_symlink
+    assert !@directory.symlink?
+    assert @symlink.symlink?
+    assert !@file.symlink?
+  end
+
+  def test_file_should_be_true_only_when_type_is_file
+    assert !@directory.file?
+    assert !@symlink.file?
+    assert @file.file?
+  end
+
+  private
+
+    def full_buffer
+      Net::SSH::Buffer.from(:long, 0x800001fd,
+        :byte, 9, :int64, 1234567890,
+        :string, "jamis", :string, "users",
+        :long, 0755,
+        :int64, 1234567890, :long, 12345,
+        :int64, 2345678901, :long, 23456,
+        :int64, 3456789012, :long, 34567,
+        :string, raw(:long, 2,
+          :long, 1, :long, 2, :long, 3, :string, "foo",
+          :long, 4, :long, 5, :long, 6, :string, "bar"),
+        :long, 1, :string, "first", :string, "second")
+    end
+
+    def attributes_factory
+      Net::SFTP::Protocol::V04::Attributes
+    end
+end

data/etc/isolate/ruby-1.8/gems/net-sftp-2.0.4/test/protocol/04/test_base.rb

@@ -0,0 +1,74 @@
+require 'common'
+require 'protocol/03/test_base'
+
+class Protocol::V04::TestBase < Protocol::V03::TestBase
+  def test_version
+    assert_equal 4, @base.version
+  end
+
+  def test_parse_attrs_packet_should_use_correct_attributes_class
+    Net::SFTP::Protocol::V04::Attributes.expects(:from_buffer).with(:packet).returns(:result)
+    assert_equal({ :attrs => :result }, @base.parse_attrs_packet(:packet))
+  end
+
+  def test_parse_name_packet_should_use_correct_name_class
+    packet = Net::SSH::Buffer.from(:long, 2,
+      :string, "name1", :long, 0x4, :byte, 1, :long, 0755,
+      :string, "name2", :long, 0x4, :byte, 1, :long, 0550)
+    names = @base.parse_name_packet(packet)[:names]
+
+    assert_not_nil names
+    assert_equal 2, names.length
+    assert_instance_of Net::SFTP::Protocol::V04::Name, names.first
+
+    assert_equal "name1", names.first.name
+    assert_equal 0755, names.first.attributes.permissions
+
+    assert_equal "name2", names.last.name
+    assert_equal 0550, names.last.attributes.permissions
+  end
+
+  undef test_fstat_should_ignore_flags_parameter
+  undef test_lstat_should_ignore_flags_parameter
+  undef test_stat_should_ignore_flags_parameter
+
+  def test_lstat_should_send_lstat_packet
+    @session.expects(:send_packet).with(FXP_LSTAT, :long, 0, :string, "/path/to/file", :long, 0x800001fd)
+    assert_equal 0, @base.lstat("/path/to/file")
+  end
+
+  def test_lstat_with_custom_flags_should_send_lstat_packet_with_given_flags
+    @session.expects(:send_packet).with(FXP_LSTAT, :long, 0, :string, "/path/to/file", :long, 1234)
+    assert_equal 0, @base.lstat("/path/to/file", 1234)
+  end
+
+  def test_fstat_should_send_fstat_packet
+    @session.expects(:send_packet).with(FXP_FSTAT, :long, 0, :string, "handle", :long, 0x800001fd)
+    assert_equal 0, @base.fstat("handle")
+  end
+
+  def test_fstat_with_custom_flags_should_send_fstat_packet_with_given_flags
+    @session.expects(:send_packet).with(FXP_FSTAT, :long, 0, :string, "handle", :long, 1234)
+    assert_equal 0, @base.fstat("handle", 1234)
+  end
+
+  def test_stat_should_send_stat_packet
+    @session.expects(:send_packet).with(FXP_STAT, :long, 0, :string, "/path/to/file", :long, 0x800001fd)
+    assert_equal 0, @base.stat("/path/to/file")
+  end
+
+  def test_stat_with_custom_flags_should_send_stat_packet_with_given_flags
+    @session.expects(:send_packet).with(FXP_STAT, :long, 0, :string, "/path/to/file", :long, 1234)
+    assert_equal 0, @base.stat("/path/to/file", 1234)
+  end
+
+  private
+
+    def driver
+      Net::SFTP::Protocol::V04::Base
+    end
+
+    def attributes
+      Net::SFTP::Protocol::V04::Attributes
+    end
+end

data/etc/isolate/ruby-1.8/gems/net-sftp-2.0.4/test/protocol/04/test_name.rb

@@ -0,0 +1,53 @@
+require 'common'
+
+class Protocol::V04::TestName < Net::SFTP::TestCase
+  def setup
+    @save_tz   = ENV['TZ']
+    ENV['TZ']  = 'UTC'
+
+    @directory = Net::SFTP::Protocol::V04::Name.new("test", Net::SFTP::Protocol::V04::Attributes.new(:type => 2, :mtime => 1205293237, :owner => "jamis", :group => "users", :size => 1024, :permissions => 0755))
+    @link      = Net::SFTP::Protocol::V04::Name.new("test", Net::SFTP::Protocol::V04::Attributes.new(:type => 3, :mtime => 1205293237, :owner => "jamis", :group => "users", :size => 32, :permissions => 0755))
+    @file      = Net::SFTP::Protocol::V04::Name.new("test", Net::SFTP::Protocol::V04::Attributes.new(:type => 1, :mtime => 1205293237, :owner => "jamis", :group => "users", :size => 10240, :permissions => 0755))
+  end
+
+  def teardown
+    if @save_tz
+      ENV['TZ'] = @save_tz
+    else
+      ENV.delete('TZ')
+    end
+  end
+
+  def test_directory?
+    assert @directory.directory?
+    assert !@link.directory?
+    assert !@file.directory?
+  end
+
+  def test_symlink?
+    assert !@directory.symlink?
+    assert @link.symlink?
+    assert !@file.symlink?
+  end
+
+  def test_file?
+    assert !@directory.file?
+    assert !@link.file?
+    assert @file.file?
+  end
+
+  def test_longname_for_directory_should_format_as_directory
+    assert_equal "drwxr-xr-x jamis    users        1024 Mar 12 03:40 test",
+      @directory.longname
+  end
+
+  def test_longname_for_symlink_should_format_as_symlink
+    assert_equal "lrwxr-xr-x jamis    users          32 Mar 12 03:40 test",
+      @link.longname
+  end
+
+  def test_longname_for_file_should_format_as_file
+    assert_equal "-rwxr-xr-x jamis    users       10240 Mar 12 03:40 test",
+      @file.longname
+  end
+end

data/etc/isolate/ruby-1.8/gems/net-sftp-2.0.4/test/protocol/05/test_base.rb

@@ -0,0 +1,62 @@
+require 'common'
+require 'protocol/04/test_base'
+
+class Protocol::V05::TestBase < Protocol::V04::TestBase
+  include Net::SFTP::Constants::OpenFlags
+  include Net::SFTP::Constants
+
+  def test_version
+    assert_equal 5, @base.version
+  end
+
+  undef test_rename_should_ignore_flags_parameter
+
+  def test_rename_should_send_rename_packet
+    @session.expects(:send_packet).with(FXP_RENAME, :long, 0, :string, "/old/file", :string, "/new/file", :long, 0)
+    assert_equal 0, @base.rename("/old/file", "/new/file")
+  end
+
+  def test_rename_with_flags_should_send_rename_packet_with_flags
+    @session.expects(:send_packet).with(FXP_RENAME, :long, 0, :string, "/old/file", :string, "/new/file", :long, RenameFlags::ATOMIC)
+    assert_equal 0, @base.rename("/old/file", "/new/file", RenameFlags::ATOMIC)
+  end
+
+  def test_open_with_numeric_flag_should_accept_IO_constants
+    @session.expects(:send_packet).with(FXP_OPEN, :long, 0,
+      :string, "/path/to/file",
+      :long, ACE::Mask::READ_DATA | ACE::Mask::READ_ATTRIBUTES | ACE::Mask::WRITE_DATA | ACE::Mask::WRITE_ATTRIBUTES,
+      :long, FV5::CREATE_NEW,
+      :raw, attributes.new.to_s)
+
+    assert_equal 0, @base.open("/path/to/file", IO::RDWR | IO::CREAT | IO::EXCL, {})
+  end
+
+  { "r"  => [FV5::OPEN_EXISTING, ACE::Mask::READ_DATA | ACE::Mask::READ_ATTRIBUTES],
+    "rb" => [FV5::OPEN_EXISTING, ACE::Mask::READ_DATA | ACE::Mask::READ_ATTRIBUTES],
+    "r+" => [FV5::OPEN_EXISTING, ACE::Mask::READ_DATA | ACE::Mask::READ_ATTRIBUTES | ACE::Mask::WRITE_DATA | ACE::Mask::WRITE_ATTRIBUTES],
+    "w"  => [FV5::CREATE_TRUNCATE, ACE::Mask::WRITE_DATA | ACE::Mask::WRITE_ATTRIBUTES],
+    "w+" => [FV5::CREATE_TRUNCATE, ACE::Mask::READ_DATA | ACE::Mask::READ_ATTRIBUTES | ACE::Mask::WRITE_DATA | ACE::Mask::WRITE_ATTRIBUTES],
+    "a"  => [FV5::OPEN_OR_CREATE | FV5::APPEND_DATA, ACE::Mask::WRITE_DATA | ACE::Mask::WRITE_ATTRIBUTES | ACE::Mask::APPEND_DATA],
+    "a+" => [FV5::OPEN_OR_CREATE | FV5::APPEND_DATA, ACE::Mask::READ_DATA | ACE::Mask::READ_ATTRIBUTES | ACE::Mask::WRITE_DATA | ACE::Mask::WRITE_ATTRIBUTES | ACE::Mask::APPEND_DATA]
+  }.each do |mode_string, (flags, access)|
+    define_method("test_open_with_#{mode_string.sub(/\+/, '_plus')}_should_translate_correctly") do
+      @session.expects(:send_packet).with(FXP_OPEN, :long, 0,
+        :string, "/path/to/file", :long, access, :long, flags, :raw, attributes.new.to_s)
+
+      assert_equal 0, @base.open("/path/to/file", mode_string, {})
+    end
+  end
+
+  def test_open_with_attributes_converts_hash_to_attribute_packet
+    @session.expects(:send_packet).with(FXP_OPEN, :long, 0,
+      :string, "/path/to/file", :long, ACE::Mask::READ_DATA | ACE::Mask::READ_ATTRIBUTES,
+      :long, FV5::OPEN_EXISTING, :raw, attributes.new(:permissions => 0755).to_s)
+    @base.open("/path/to/file", "r", :permissions => 0755)
+  end
+
+  private
+
+    def driver
+      Net::SFTP::Protocol::V05::Base
+    end
+end

data/etc/isolate/ruby-1.8/gems/net-sftp-2.0.4/test/protocol/06/test_attributes.rb

@@ -0,0 +1,124 @@
+require 'common'
+
+module Etc; end
+
+class Protocol::V06::TestAttributes < Net::SFTP::TestCase
+  def test_from_buffer_should_correctly_parse_buffer_and_return_attribute_object
+    attributes = attributes_factory.from_buffer(full_buffer)
+
+    assert_equal 9, attributes.type
+    assert_equal 1234567890, attributes.size
+    assert_equal 2345678901, attributes.allocation_size
+    assert_equal "jamis", attributes.owner
+    assert_equal "users", attributes.group
+    assert_equal 0755, attributes.permissions
+    assert_equal 1234567890, attributes.atime
+    assert_equal 12345, attributes.atime_nseconds
+    assert_equal 2345678901, attributes.createtime
+    assert_equal 23456, attributes.createtime_nseconds
+    assert_equal 3456789012, attributes.mtime
+    assert_equal 34567, attributes.mtime_nseconds
+    assert_equal 4567890123, attributes.ctime
+    assert_equal 45678, attributes.ctime_nseconds
+
+    assert_equal 2, attributes.acl.length
+
+    assert_equal 1, attributes.acl.first.type
+    assert_equal 2, attributes.acl.first.flag
+    assert_equal 3, attributes.acl.first.mask
+    assert_equal "foo", attributes.acl.first.who
+
+    assert_equal 4, attributes.acl.last.type
+    assert_equal 5, attributes.acl.last.flag
+    assert_equal 6, attributes.acl.last.mask
+    assert_equal "bar", attributes.acl.last.who
+
+    assert_equal 0x12341234, attributes.attrib_bits
+    assert_equal 0x23452345, attributes.attrib_bits_valid
+    assert_equal 0x3, attributes.text_hint
+    assert_equal "text/html", attributes.mime_type
+    assert_equal 144, attributes.link_count
+    assert_equal "an untranslated name", attributes.untranslated_name
+
+    assert_equal "second", attributes.extended["first"]
+  end
+
+  def test_from_buffer_should_correctly_parse_buffer_with_attribute_subset_and_return_attribute_object
+    buffer = Net::SSH::Buffer.from(:long, 0x4, :byte, 1, :long, 0755)
+
+    attributes = attributes_factory.from_buffer(buffer)
+
+    assert_equal 1, attributes.type
+    assert_equal 0755, attributes.permissions
+
+    assert_nil attributes.size
+    assert_nil attributes.allocation_size
+    assert_nil attributes.owner
+    assert_nil attributes.group
+    assert_nil attributes.atime
+    assert_nil attributes.atime_nseconds
+    assert_nil attributes.createtime
+    assert_nil attributes.createtime_nseconds
+    assert_nil attributes.mtime
+    assert_nil attributes.mtime_nseconds
+    assert_nil attributes.ctime
+    assert_nil attributes.ctime_nseconds
+    assert_nil attributes.acl
+    assert_nil attributes.attrib_bits
+    assert_nil attributes.attrib_bits_valid
+    assert_nil attributes.text_hint
+    assert_nil attributes.mime_type
+    assert_nil attributes.link_count
+    assert_nil attributes.untranslated_name
+    assert_nil attributes.extended
+  end
+
+  def test_attributes_to_s_should_build_binary_representation
+    attributes = attributes_factory.new(
+      :type => 9,
+      :size => 1234567890, :allocation_size => 2345678901,
+      :owner  => "jamis", :group => "users",
+      :permissions => 0755,
+      :atime => 1234567890, :atime_nseconds => 12345,
+      :createtime => 2345678901, :createtime_nseconds => 23456,
+      :mtime => 3456789012, :mtime_nseconds => 34567,
+      :ctime => 4567890123, :ctime_nseconds => 45678,
+      :acl => [attributes_factory::ACL.new(1,2,3,"foo"),
+               attributes_factory::ACL.new(4,5,6,"bar")],
+      :attrib_bits => 0x12341234, :attrib_bits_valid => 0x23452345,
+      :text_hint => 0x3, :mime_type => "text/html",
+      :link_count => 144, :untranslated_name => "an untranslated name",
+      :extended => { "first" => "second" })
+
+    assert_equal full_buffer.to_s, attributes.to_s
+  end
+
+  def test_attributes_to_s_should_build_binary_representation_when_subset_is_present
+    attributes = attributes_factory.new(:permissions => 0755)
+    assert_equal Net::SSH::Buffer.from(:long, 0x4, :byte, 1, :long, 0755).to_s, attributes.to_s
+  end
+
+  private
+
+    def full_buffer
+      Net::SSH::Buffer.from(:long, 0x8000fffd,
+        :byte, 9, :int64, 1234567890, :int64, 2345678901,
+        :string, "jamis", :string, "users",
+        :long, 0755,
+        :int64, 1234567890, :long, 12345,
+        :int64, 2345678901, :long, 23456,
+        :int64, 3456789012, :long, 34567,
+        :int64, 4567890123, :long, 45678,
+        :string, raw(:long, 2,
+          :long, 1, :long, 2, :long, 3, :string, "foo",
+          :long, 4, :long, 5, :long, 6, :string, "bar"),
+        :long, 0x12341234, :long, 0x23452345,
+        :byte, 0x3, :string, "text/html", :long, 144,
+        :string, "an untranslated name",
+        :long, 1, :string, "first", :string, "second")
+    end
+
+    def attributes_factory
+      Net::SFTP::Protocol::V06::Attributes
+    end
+end

data/etc/isolate/ruby-1.8/gems/net-sftp-2.0.4/test/protocol/06/test_base.rb

@@ -0,0 +1,51 @@
+require 'common'
+require 'protocol/05/test_base'
+
+class Protocol::V06::TestBase < Protocol::V05::TestBase
+  include Net::SFTP::Constants::OpenFlags
+  include Net::SFTP::Constants
+
+  def test_version
+    assert_equal 6, @base.version
+  end
+
+  def test_parse_attrs_packet_should_use_correct_attributes_class
+    Net::SFTP::Protocol::V06::Attributes.expects(:from_buffer).with(:packet).returns(:result)
+    assert_equal({ :attrs => :result }, @base.parse_attrs_packet(:packet))
+  end
+
+  undef test_link_should_raise_not_implemented_error
+  undef test_block_should_raise_not_implemented_error
+  undef test_unblock_should_raise_not_implemented_error
+  undef test_symlink_should_send_symlink_packet
+
+  def test_link_should_send_link_packet
+    @session.expects(:send_packet).with(FXP_LINK, :long, 0, :string, "/path/to/link", :string, "/path/to/file", :bool, true)
+    assert_equal 0, @base.link("/path/to/link", "/path/to/file", true)
+  end
+
+  def test_symlink_should_send_link_packet_as_symlink
+    @session.expects(:send_packet).with(FXP_LINK, :long, 0, :string, "/path/to/link", :string, "/path/to/file", :bool, true)
+    assert_equal 0, @base.symlink("/path/to/link", "/path/to/file")
+  end
+
+  def test_block_should_send_block_packet
+    @session.expects(:send_packet).with(FXP_BLOCK, :long, 0, :string, "handle", :int64, 1234, :int64, 4567, :long, 0x40)
+    assert_equal 0, @base.block("handle", 1234, 4567, 0x40)
+  end
+
+  def test_unblock_should_send_unblock_packet
+    @session.expects(:send_packet).with(FXP_UNBLOCK, :long, 0, :string, "handle", :int64, 1234, :int64, 4567)
+    assert_equal 0, @base.unblock("handle", 1234, 4567)
+  end
+
+  private
+
+    def driver
+      Net::SFTP::Protocol::V06::Base
+    end
+
+    def attributes
+      Net::SFTP::Protocol::V06::Attributes
+    end
+end

data/etc/isolate/ruby-1.8/gems/net-sftp-2.0.4/test/protocol/test_base.rb

@@ -0,0 +1,42 @@
+require 'common'
+
+class Protocol::TestBase < Net::SFTP::TestCase
+  def setup
+    @base = Net::SFTP::Protocol::Base.new(stub('session', :logger => nil))
+  end
+
+  def test_parse_with_status_packet_should_delegate_to_parse_status_packet
+    packet = stub('packet', :type => FXP_STATUS)
+    @base.expects(:parse_status_packet).with(packet).returns(:result)
+    assert_equal :result, @base.parse(packet)
+  end
+
+  def test_parse_with_handle_packet_should_delegate_to_parse_handle_packet
+    packet = stub('packet', :type => FXP_HANDLE)
+    @base.expects(:parse_handle_packet).with(packet).returns(:result)
+    assert_equal :result, @base.parse(packet)
+  end
+
+  def test_parse_with_data_packet_should_delegate_to_parse_data_packet
+    packet = stub('packet', :type => FXP_DATA)
+    @base.expects(:parse_data_packet).with(packet).returns(:result)
+    assert_equal :result, @base.parse(packet)
+  end
+
+  def test_parse_with_name_packet_should_delegate_to_parse_name_packet
+    packet = stub('packet', :type => FXP_NAME)
+    @base.expects(:parse_name_packet).with(packet).returns(:result)
+    assert_equal :result, @base.parse(packet)
+  end
+
+  def test_parse_with_attrs_packet_should_delegate_to_parse_attrs_packet
+    packet = stub('packet', :type => FXP_ATTRS)
+    @base.expects(:parse_attrs_packet).with(packet).returns(:result)
+    assert_equal :result, @base.parse(packet)
+  end
+
+  def test_parse_with_unknown_packet_should_raise_exception
+    packet = stub('packet', :type => FXP_WRITE)
+    assert_raises(NotImplementedError) { @base.parse(packet) }
+  end
+end

data/etc/isolate/ruby-1.8/gems/net-sftp-2.0.4/test/test_all.rb

@@ -0,0 +1,4 @@
+#  $ ruby -Ilib -Itest -rrubygems test/test_all.rb
+Dir.chdir(File.dirname(__FILE__)) do
+  Dir['**/test_*.rb'].each { |file| require(file) }
+end

data/etc/isolate/ruby-1.8/gems/net-sftp-2.0.4/test/test_dir.rb

@@ -0,0 +1,47 @@
+require 'common'
+
+class DirOperationsTest < Net::SFTP::TestCase
+  def setup
+    @sftp = mock("sftp")
+    @dir = Net::SFTP::Operations::Dir.new(@sftp)
+  end
+
+  def test_foreach_should_iterate_over_all_entries_in_directory
+    @sftp.expects(:opendir!).with("/path/to/remote").returns("handle")
+    @sftp.expects(:readdir!).with("handle").returns([:e1, :e2, :e3], [:e4, :e5], nil).times(3)
+    @sftp.expects(:close!).with("handle")
+
+    entries = []
+    @dir.foreach("/path/to/remote") { |entry| entries << entry }
+    assert_equal [:e1, :e2, :e3, :e4, :e5], entries
+  end
+
+  def test_entries_should_return_all_entries_in_a_single_array
+    @sftp.expects(:opendir!).with("/path/to/remote").returns("handle")
+    @sftp.expects(:readdir!).with("handle").returns([:e1, :e2, :e3], [:e4, :e5], nil).times(3)
+    @sftp.expects(:close!).with("handle")
+
+    assert_equal [:e1, :e2, :e3, :e4, :e5], @dir.entries("/path/to/remote")
+  end
+
+  def test_glob_should_search_under_path_for_matching_entries
+    @sftp.expects(:opendir!).with("/path/to/remote").returns("handle")
+    @sftp.expects(:opendir!).with("/path/to/remote/e3").returns("handle-e3")
+    @sftp.expects(:opendir!).with("/path/to/remote/e5").returns("handle-e5")
+    @sftp.expects(:readdir!).with("handle").returns([n(".", true), n("..", true), n("e1"), n("e2"), n("e3", true)], [n("e4"), n("e5", true)], nil).times(3)
+    @sftp.expects(:readdir!).with("handle-e3").returns([n(".", true), n("..", true), n("e3e1"), n("e3e2")], nil).times(2)
+    @sftp.expects(:readdir!).with("handle-e5").returns([n(".", true), n("..", true), n("e5e1"), n("e5e2"), n("e5e3")], nil).times(2)
+    @sftp.expects(:close!).with("handle")
+    @sftp.expects(:close!).with("handle-e3")
+    @sftp.expects(:close!).with("handle-e5")
+
+    assert_equal %w(e3/e3e2 e5/e5e2), @dir.glob("/path/to/remote", "**/e?e2").map { |e| e.name }
+  end
+
+  private
+
+    def n(name, directory=false)
+      Net::SFTP::Protocol::V01::Name.new(name.to_s, "longname for #{name}",
+        Net::SFTP::Protocol::V01::Attributes.new(:permissions => directory ? 040755 : 0100644))
+    end
+end