net-sftp 2.1.2 → 4.0.0

data/test/protocol/01/test_base.rb

@@ -1,210 +0,0 @@
-require 'common'
-
-# NOTE: these tests assume that the interface to Net::SFTP::Session#send_packet
-# will remain constant. If that interface ever changes, these tests will need
-# to be updated!
-
-class Protocol::V01::TestBase < Net::SFTP::TestCase
-  include Net::SFTP::Constants
-  include Net::SFTP::Constants::PacketTypes
-  include Net::SFTP::Constants::OpenFlags
-
-  def setup
-    @session = stub('session', :logger => nil)
-    @base = driver.new(@session)
-  end
-
-  def test_version
-    assert_equal 1, @base.version
-  end
-
-  def test_parse_handle_packet_should_read_string_from_packet_and_return_handle_in_hash
-    packet = Net::SSH::Buffer.from(:string, "here is a string")
-    assert_equal({ :handle => "here is a string" }, @base.parse_handle_packet(packet))
-  end
-
-  def test_parse_status_packet_should_read_long_from_packet_and_return_code_in_hash
-    packet = Net::SSH::Buffer.from(:long, 15)
-    assert_equal({ :code => 15 }, @base.parse_status_packet(packet))
-  end
-
-  def test_parse_data_packet_should_read_string_from_packet_and_return_data_in_hash
-    packet = Net::SSH::Buffer.from(:string, "here is a string")
-    assert_equal({ :data => "here is a string" }, @base.parse_data_packet(packet))
-  end
-
-  def test_parse_attrs_packet_should_use_correct_attributes_class
-    Net::SFTP::Protocol::V01::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", :string, "long1", :long, 0x4, :long, 0755,
-      :string, "name2", :string, "long2", :long, 0x4, :long, 0550)
-    names = @base.parse_name_packet(packet)[:names]
-
-    assert_not_nil names
-    assert_equal 2, names.length
-    assert_instance_of Net::SFTP::Protocol::V01::Name, names.first
-
-    assert_equal "name1", names.first.name
-    assert_equal "long1", names.first.longname
-    assert_equal 0755, names.first.attributes.permissions
-
-    assert_equal "name2", names.last.name
-    assert_equal "long2", names.last.longname
-    assert_equal 0550, names.last.attributes.permissions
-  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, FV1::READ | FV1::WRITE | FV1::CREAT | FV1::EXCL,
-      :raw, attributes.new.to_s)
-
-    assert_equal 0, @base.open("/path/to/file", IO::RDWR | IO::CREAT | IO::EXCL, {})
-  end
-
-  { "r"  => FV1::READ,
-    "rb" => FV1::READ,
-    "r+" => FV1::READ | FV1::WRITE,
-    "w"  => FV1::WRITE | FV1::TRUNC | FV1::CREAT,
-    "w+" => FV1::WRITE | FV1::READ | FV1::TRUNC | FV1::CREAT,
-    "a"  => FV1::APPEND | FV1::WRITE | FV1::CREAT,
-    "a+" => FV1::APPEND | FV1::WRITE | FV1::READ | FV1::CREAT
-  }.each do |flags, options|
-    safe_name = flags.sub(/\+/, "_plus")
-    define_method("test_open_with_#{safe_name}_should_translate_correctly") do
-      @session.expects(:send_packet).with(FXP_OPEN, :long, 0,
-        :string, "/path/to/file", :long, options, :raw, attributes.new.to_s)
-
-      assert_equal 0, @base.open("/path/to/file", flags, {})
-    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, FV1::READ, :raw, attributes.new(:permissions => 0755).to_s)
-    @base.open("/path/to/file", "r", :permissions => 0755)
-  end
-
-  def test_close_should_send_close_packet
-    @session.expects(:send_packet).with(FXP_CLOSE, :long, 0, :string, "handle")
-    assert_equal 0, @base.close("handle")
-  end
-
-  def test_read_should_send_read_packet
-    @session.expects(:send_packet).with(FXP_READ, :long, 0, :string, "handle", :int64, 1234, :long, 5678)
-    assert_equal 0, @base.read("handle", 1234, 5678)
-  end
-
-  def test_write_should_send_write_packet
-    @session.expects(:send_packet).with(FXP_WRITE, :long, 0, :string, "handle", :int64, 1234, :string, "data")
-    assert_equal 0, @base.write("handle", 1234, "data")
-  end
-
-  def test_lstat_should_send_lstat_packet
-    @session.expects(:send_packet).with(FXP_LSTAT, :long, 0, :string, "/path/to/file")
-    assert_equal 0, @base.lstat("/path/to/file")
-  end
-
-  def test_lstat_should_ignore_flags_parameter
-    @session.expects(:send_packet).with(FXP_LSTAT, :long, 0, :string, "/path/to/file")
-    assert_equal 0, @base.lstat("/path/to/file", 12345)
-  end
-
-  def test_fstat_should_send_fstat_packet
-    @session.expects(:send_packet).with(FXP_FSTAT, :long, 0, :string, "handle")
-    assert_equal 0, @base.fstat("handle")
-  end
-
-  def test_fstat_should_ignore_flags_parameter
-    @session.expects(:send_packet).with(FXP_FSTAT, :long, 0, :string, "handle")
-    assert_equal 0, @base.fstat("handle", 12345)
-  end
-
-  def test_setstat_should_translate_hash_to_attributes_and_send_setstat_packet
-    @session.expects(:send_packet).with(FXP_SETSTAT, :long, 0, :string, "/path/to/file", :raw, attributes.new(:atime => 1, :mtime => 2, :permissions => 0755).to_s)
-    assert_equal 0, @base.setstat("/path/to/file", :atime => 1, :mtime => 2, :permissions => 0755)
-  end
-
-  def test_fsetstat_should_translate_hash_to_attributes_and_send_fsetstat_packet
-    @session.expects(:send_packet).with(FXP_FSETSTAT, :long, 0, :string, "handle", :raw, attributes.new(:atime => 1, :mtime => 2, :permissions => 0755).to_s)
-    assert_equal 0, @base.fsetstat("handle", :atime => 1, :mtime => 2, :permissions => 0755)
-  end
-
-  def test_opendir_should_send_opendir_packet
-    @session.expects(:send_packet).with(FXP_OPENDIR, :long, 0, :string, "/path/to/dir")
-    assert_equal 0, @base.opendir("/path/to/dir")
-  end
-
-  def test_readdir_should_send_readdir_packet
-    @session.expects(:send_packet).with(FXP_READDIR, :long, 0, :string, "handle")
-    assert_equal 0, @base.readdir("handle")
-  end
-
-  def test_remove_should_send_remove_packet
-    @session.expects(:send_packet).with(FXP_REMOVE, :long, 0, :string, "/path/to/file")
-    assert_equal 0, @base.remove("/path/to/file")
-  end
-
-  def test_mkdir_should_translate_hash_to_attributes_and_send_mkdir_packet
-    @session.expects(:send_packet).with(FXP_MKDIR, :long, 0, :string, "/path/to/dir", :raw, attributes.new(:atime => 1, :mtime => 2, :permissions => 0755).to_s)
-    assert_equal 0, @base.mkdir("/path/to/dir", :atime => 1, :mtime => 2, :permissions => 0755)
-  end
-
-  def test_rmdir_should_send_rmdir_packet
-    @session.expects(:send_packet).with(FXP_RMDIR, :long, 0, :string, "/path/to/dir")
-    assert_equal 0, @base.rmdir("/path/to/dir")
-  end
-
-  def test_realpath_should_send_realpath_packet
-    @session.expects(:send_packet).with(FXP_REALPATH, :long, 0, :string, "/path/to/file")
-    assert_equal 0, @base.realpath("/path/to/file")
-  end
-
-  def test_stat_should_send_stat_packet
-    @session.expects(:send_packet).with(FXP_STAT, :long, 0, :string, "/path/to/file")
-    assert_equal 0, @base.stat("/path/to/file")
-  end
-
-  def test_stat_should_ignore_flags_parameter
-    @session.expects(:send_packet).with(FXP_STAT, :long, 0, :string, "/path/to/file")
-    assert_equal 0, @base.stat("/path/to/file", 12345)
-  end
-
-  def test_rename_should_raise_not_implemented_error
-    assert_raises(NotImplementedError) { @base.rename("/path/to/old", "/path/to/new") }
-  end
-
-  def test_readlink_should_raise_not_implemented_error
-    assert_raises(NotImplementedError) { @base.readlink("/path/to/link") }
-  end
-
-  def test_symlink_should_raise_not_implemented_error
-    assert_raises(NotImplementedError) { @base.symlink("/path/to/link", "/path/to/file") }
-  end
-
-  def test_link_should_raise_not_implemented_error
-    assert_raises(NotImplementedError) { @base.link("/path/to/link", "/path/to/file", true) }
-  end
-
-  def test_block_should_raise_not_implemented_error
-    assert_raises(NotImplementedError) { @base.block("handle", 100, 200, 0) }
-  end
-
-  def test_unblock_should_raise_not_implemented_error
-    assert_raises(NotImplementedError) { @base.unblock("handle", 100, 200) }
-  end
-
-  private
-
-    def driver
-      Net::SFTP::Protocol::V01::Base
-    end
-
-    def attributes
-      Net::SFTP::Protocol::V01::Attributes
-    end
-end

data/test/protocol/01/test_name.rb

@@ -1,27 +0,0 @@
-require 'common'
-
-class Protocol::V01::TestName < Net::SFTP::TestCase
-  def setup
-    @directory = Net::SFTP::Protocol::V01::Name.new("test", "drwxr-x-r-x  89 test  test  3026 Mar 10 17:45 test", Net::SFTP::Protocol::V01::Attributes.new(:permissions => 040755))
-    @link      = Net::SFTP::Protocol::V01::Name.new("test", "lrwxr-x-r-x  89 test  test  3026 Mar 10 17:45 test", Net::SFTP::Protocol::V01::Attributes.new(:permissions => 0120755))
-    @file      = Net::SFTP::Protocol::V01::Name.new("test", "-rwxr-x-r-x  89 test  test  3026 Mar 10 17:45 test", Net::SFTP::Protocol::V01::Attributes.new(:permissions => 0100755))
-  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
-end

data/test/protocol/02/test_base.rb

@@ -1,26 +0,0 @@
-require 'common'
-require 'protocol/01/test_base'
-
-class Protocol::V02::TestBase < Protocol::V01::TestBase
-  def test_version
-    assert_equal 2, @base.version
-  end
-
-  undef test_rename_should_raise_not_implemented_error
-
-  def test_rename_should_send_rename_packet
-    @session.expects(:send_packet).with(FXP_RENAME, :long, 0, :string, "/old/file", :string, "/new/file")
-    assert_equal 0, @base.rename("/old/file", "/new/file")
-  end
-
-  def test_rename_should_ignore_flags_parameter
-    @session.expects(:send_packet).with(FXP_RENAME, :long, 0, :string, "/old/file", :string, "/new/file")
-    assert_equal 0, @base.rename("/old/file", "/new/file", 1234)
-  end
-
-  private
-
-    def driver
-      Net::SFTP::Protocol::V02::Base
-    end
-end

data/test/protocol/03/test_base.rb

@@ -1,27 +0,0 @@
-require 'common'
-require 'protocol/02/test_base'
-
-class Protocol::V03::TestBase < Protocol::V02::TestBase
-  def test_version
-    assert_equal 3, @base.version
-  end
-
-  undef test_readlink_should_raise_not_implemented_error
-  undef test_symlink_should_raise_not_implemented_error
-
-  def test_readlink_should_send_readlink_packet
-    @session.expects(:send_packet).with(FXP_READLINK, :long, 0, :string, "/path/to/link")
-    assert_equal 0, @base.readlink("/path/to/link")
-  end
-
-  def test_symlink_should_send_symlink_packet
-    @session.expects(:send_packet).with(FXP_SYMLINK, :long, 0, :string, "/path/to/link", :string, "/path/to/file")
-    assert_equal 0, @base.symlink("/path/to/link", "/path/to/file")
-  end
-
-  private
-
-    def driver
-      Net::SFTP::Protocol::V03::Base
-    end
-end

data/test/protocol/04/test_attributes.rb

@@ -1,148 +0,0 @@
-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/test/protocol/04/test_base.rb

@@ -1,74 +0,0 @@
-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/test/protocol/04/test_name.rb

@@ -1,53 +0,0 @@
-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/test/protocol/05/test_base.rb

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