net-sftp 2.1.2 → 4.0.0

data/test/protocol/06/test_attributes.rb

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

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

@@ -1,42 +0,0 @@
-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/test/test_all.rb

@@ -1,7 +0,0 @@
-#  $ ruby -I../net-ssh/lib -Ilib -Itest -rrubygems test/test_all.rb
-#require 'net/ssh'
-#puts Net::SSH::Version::CURRENT
-require 'common'
-Dir.chdir(File.dirname(__FILE__)) do
-  Dir['**/test_*.rb'].each { |file| require(file) unless file == File.basename(__FILE__) }
-end

data/test/test_dir.rb

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

data/test/test_download.rb

@@ -1,287 +0,0 @@
-require "common"
-
-class DownloadTest < Net::SFTP::TestCase
-  FXP_DATA_CHUNK_SIZE = 1024
-
-  def setup
-    prepare_progress!
-  end
-
-  def test_download_file_should_transfer_remote_to_local
-    local = "/path/to/local"
-    remote = "/path/to/remote"
-    text = "this is some text\n"
-
-    expect_file_transfer(remote, text)
-
-    file = StringIO.new
-    File.stubs(:open).with(local, "wb").returns(file)
-
-    assert_scripted_command { sftp.download(remote, local) }
-    assert_equal text, file.string
-  end
-
-  def test_download_file_should_transfer_remote_to_local_in_spite_of_fragmentation
-    local = "/path/to/local"
-    remote = "/path/to/remote"
-    text = "this is some text\n"
-
-    expect_file_transfer(remote, text, :fragment_len => 1)
-
-    file = StringIO.new
-    File.stubs(:open).with(local, "wb").returns(file)
-
-    assert_scripted_command { sftp.download(remote, local) }
-    assert_equal text, file.string
-  end
-
-  def test_download_large_file_should_transfer_remote_to_local
-    local = "/path/to/local"
-    remote = "/path/to/remote"
-    text = "0123456789" * 1024
-
-    file = prepare_large_file_download(local, remote, text)
-
-    assert_scripted_command { sftp.download(remote, local, :read_size => 1024) }
-    assert_equal text, file.string
-  end
-
-  def test_download_large_file_should_handle_too_large_read_size
-    local = "/path/to/local"
-    remote = "/path/to/remote"
-    text = "0123456789" * 1024
-
-    # some servers put upper bound on the max read_size value and send less data than requested
-    too_large_read_size = FXP_DATA_CHUNK_SIZE + 1
-    file = prepare_large_file_download(local, remote, text, too_large_read_size)
-
-    assert_scripted_command { sftp.download(remote, local, :read_size => too_large_read_size) }
-    assert_equal text, file.string
-  end
-
-  def test_download_large_file_with_progress_should_report_progress
-    local = "/path/to/local"
-    remote = "/path/to/remote"
-    text = "0123456789" * 1024
-
-    file = prepare_large_file_download(local, remote, text)
-
-    assert_scripted_command do
-      sftp.download(remote, local, :read_size => 1024) do |*args|
-        record_progress(args)
-      end
-    end
-
-    assert_equal text, file.string
-
-    assert_progress_reported_open :remote => "/path/to/remote"
-    assert_progress_reported_get     0, 1024
-    assert_progress_reported_get  1024, 1024
-    assert_progress_reported_get  2048, 1024
-    assert_progress_reported_get  3072, 1024
-    assert_progress_reported_get  4096, 1024
-    assert_progress_reported_get  5120, 1024
-    assert_progress_reported_get  6144, 1024
-    assert_progress_reported_get  7168, 1024
-    assert_progress_reported_get  8192, 1024
-    assert_progress_reported_get  9216, 1024
-    assert_progress_reported_close
-    assert_progress_reported_finish
-    assert_no_more_reported_events
-  end
-
-  def test_download_directory_should_mirror_directory_locally
-    file1, file2 = prepare_directory_tree_download("/path/to/local", "/path/to/remote")
-
-    assert_scripted_command do
-      sftp.download("/path/to/remote", "/path/to/local", :recursive => true)
-    end
-
-    assert_equal "contents of file1", file1.string
-    assert_equal "contents of file2", file2.string
-  end
-
-  def test_download_directory_with_progress_should_report_progress
-    file1, file2 = prepare_directory_tree_download("/path/to/local", "/path/to/remote")
-
-    assert_scripted_command do
-      sftp.download("/path/to/remote", "/path/to/local", :recursive => true) do |*args|
-        record_progress(args)
-      end
-    end
-
-    assert_equal "contents of file1", file1.string
-    assert_equal "contents of file2", file2.string
-
-    assert_progress_reported_mkdir "/path/to/local"
-    assert_progress_reported_mkdir "/path/to/local/subdir1"
-    assert_progress_reported_open  :remote => "/path/to/remote/file1"
-    assert_progress_reported_open  :remote => "/path/to/remote/subdir1/file2"
-    assert_progress_reported_get   0, "contents of file1"
-    assert_progress_reported_close :remote => "/path/to/remote/file1"
-    assert_progress_reported_get   0, "contents of file2"
-    assert_progress_reported_close :remote => "/path/to/remote/subdir1/file2"
-    assert_progress_reported_finish
-    assert_no_more_reported_events
-  end
-
-  def test_download_file_should_transfer_remote_to_local_buffer
-    remote = "/path/to/remote"
-    text = "this is some text\n"
-
-    expect_file_transfer(remote, text)
-
-    local = StringIO.new
-
-    assert_scripted_command { sftp.download(remote, local) }
-    assert_equal text, local.string
-  end
-
-  def test_download_directory_to_buffer_should_fail
-    expect_sftp_session :server_version => 3
-    assert_raises(ArgumentError) { sftp.download("/path/to/remote", StringIO.new, :recursive => true) }
-  end
-
-  private
-
-    def expect_file_transfer(remote, text, opts={})
-      expect_sftp_session :server_version => 3 do |channel|
-        channel.sends_packet(FXP_OPEN, :long, 0, :string, remote, :long, 0x01, :long, 0)
-        channel.gets_packet(FXP_HANDLE, :long, 0, :string, "handle")
-        channel.sends_packet(FXP_READ, :long, 1, :string, "handle", :int64, 0, :long, 32_000)
-        channel.gets_packet_in_two(opts[:fragment_len], FXP_DATA, :long, 1, :string, text)
-        channel.sends_packet(FXP_READ, :long, 2, :string, "handle", :int64, text.bytesize, :long, 32_000)
-        channel.gets_packet(FXP_STATUS, :long, 2, :long, 1)
-        channel.sends_packet(FXP_CLOSE, :long, 3, :string, "handle")
-        channel.gets_packet(FXP_STATUS, :long, 3, :long, 0)
-      end
-    end
-
-    def prepare_large_file_download(local, remote, text, requested_chunk_size = FXP_DATA_CHUNK_SIZE)
-      expect_sftp_session :server_version => 3 do |channel|
-        channel.sends_packet(FXP_OPEN, :long, 0, :string, remote, :long, 0x01, :long, 0)
-        channel.gets_packet(FXP_HANDLE, :long, 0, :string, "handle")
-        offset = 0
-        data_packet_count = (text.bytesize / FXP_DATA_CHUNK_SIZE.to_f).ceil
-        data_packet_count.times do |n|
-          payload = text[n*FXP_DATA_CHUNK_SIZE,FXP_DATA_CHUNK_SIZE]
-          channel.sends_packet(FXP_READ, :long, n+1, :string, "handle", :int64, offset, :long, requested_chunk_size)
-          offset += payload.bytesize
-          channel.gets_packet(FXP_DATA, :long, n+1, :string, payload)
-        end
-        channel.sends_packet(FXP_READ, :long, data_packet_count + 1, :string, "handle", :int64, offset, :long, requested_chunk_size)
-        channel.gets_packet(FXP_STATUS, :long, data_packet_count + 1, :long, 1)
-        channel.sends_packet(FXP_CLOSE, :long, data_packet_count + 2, :string, "handle")
-        channel.gets_packet(FXP_STATUS, :long, data_packet_count + 2, :long, 0)
-      end
-
-      file = StringIO.new
-      File.stubs(:open).with(local, "wb").returns(file)
-
-      return file
-    end
-
-    # 0:OPENDIR(remote) ->
-    # <- 0:HANDLE("dir1")
-    # 1:READDIR("dir1") ->
-    # <- 1:NAME("..", ".", "subdir1", "file1")
-    # 2:OPENDIR(remote/subdir1) ->
-    # 3:OPEN(remote/file1) ->
-    # 4:READDIR("dir1") ->
-    # <- 2:HANDLE("dir2")
-    # 5:READDIR("dir2") ->
-    # <- 3:HANDLE("file1")
-    # 6:READ("file1", 0, 32k) ->
-    # <- 4:STATUS(1)
-    # 7:CLOSE("dir1") ->
-    # <- 5:NAME("..", ".", "file2")
-    # 8:OPEN(remote/subdir1/file2) ->
-    # 9:READDIR("dir2") ->
-    # <- 6:DATA("blah blah blah")
-    # 10:READ("file1", n, 32k)
-    # <- 7:STATUS(0)
-    # <- 8:HANDLE("file2")
-    # 11:READ("file2", 0, 32k) ->
-    # <- 9:STATUS(1)
-    # 12:CLOSE("dir2") ->
-    # <- 10:STATUS(1)
-    # 13:CLOSE("file1") ->
-    # <- 11:DATA("blah blah blah")
-    # 14:READ("file2", n, 32k) ->
-    # <- 12:STATUS(0)
-    # <- 13:STATUS(0)
-    # <- 14:STATUS(1)
-    # 15:CLOSE("file2") ->
-    # <- 15:STATUS(0)
-
-    def prepare_directory_tree_download(local, remote)
-      file1_contents = "contents of file1"
-      file2_contents = "contents of file2"
-      expect_sftp_session :server_version => 3 do |channel|
-        channel.sends_packet(FXP_OPENDIR, :long, 0, :string, remote)
-        channel.gets_packet(FXP_HANDLE, :long, 0, :string, "dir1")
-
-        channel.sends_packet(FXP_READDIR, :long, 1, :string, "dir1")
-        channel.gets_packet(FXP_NAME, :long, 1, :long, 4,
-          :string, "..",      :string, "drwxr-xr-x  4 bob bob  136 Aug  1 ..", :long, 0x04, :long, 040755,
-          :string, ".",       :string, "drwxr-xr-x  4 bob bob  136 Aug  1 .", :long, 0x04, :long, 040755,
-          :string, "subdir1", :string, "drwxr-xr-x  4 bob bob  136 Aug  1 subdir1", :long, 0x04, :long, 040755,
-          :string, "file1",   :string, "-rw-rw-r--  1 bob bob  100 Aug  1 file1", :long, 0x04, :long, 0100644)
-
-        channel.sends_packet(FXP_OPENDIR, :long, 2, :string, File.join(remote, "subdir1"))
-        channel.sends_packet(FXP_OPEN, :long, 3, :string, File.join(remote, "file1"), :long, 0x01, :long, 0)
-        channel.sends_packet(FXP_READDIR, :long, 4, :string, "dir1")
-
-        channel.gets_packet(FXP_HANDLE, :long, 2, :string, "dir2")
-        channel.sends_packet(FXP_READDIR, :long, 5, :string, "dir2")
-
-        channel.gets_packet(FXP_HANDLE, :long, 3, :string, "file1")
-        channel.sends_packet(FXP_READ, :long, 6, :string, "file1", :int64, 0, :long, 32_000)
-
-        channel.gets_packet(FXP_STATUS, :long, 4, :long, 1)
-        channel.sends_packet(FXP_CLOSE, :long, 7, :string, "dir1")
-
-        channel.gets_packet(FXP_NAME, :long, 5, :long, 3,
-          :string, "..",    :string, "drwxr-xr-x  4 bob bob  136 Aug  1 ..", :long, 0x04, :long, 040755,
-          :string, ".",     :string, "drwxr-xr-x  4 bob bob  136 Aug  1 .", :long, 0x04, :long, 040755,
-          :string, "file2", :string, "-rw-rw-r--  1 bob bob  100 Aug  1 file2", :long, 0x04, :long, 0100644)
-
-        channel.sends_packet(FXP_OPEN, :long, 8, :string, File.join(remote, "subdir1", "file2"), :long, 0x01, :long, 0)
-        channel.sends_packet(FXP_READDIR, :long, 9, :string, "dir2")
-
-        channel.gets_packet(FXP_DATA, :long, 6, :string, file1_contents)
-        channel.sends_packet(FXP_READ, :long, 10, :string, "file1", :int64, file1_contents.bytesize, :long, 32_000)
-
-        channel.gets_packet(FXP_STATUS, :long, 7, :long, 0)
-        channel.gets_packet(FXP_HANDLE, :long, 8, :string, "file2")
-        channel.sends_packet(FXP_READ, :long, 11, :string, "file2", :int64, 0, :long, 32_000)
-
-        channel.gets_packet(FXP_STATUS, :long, 9, :long, 1)
-        channel.sends_packet(FXP_CLOSE, :long, 12, :string, "dir2")
-
-        channel.gets_packet(FXP_STATUS, :long, 10, :long, 1)
-        channel.sends_packet(FXP_CLOSE, :long, 13, :string, "file1")
-
-        channel.gets_packet(FXP_DATA, :long, 11, :string, file2_contents)
-        channel.sends_packet(FXP_READ, :long, 14, :string, "file2", :int64, file2_contents.bytesize, :long, 32_000)
-
-        channel.gets_packet(FXP_STATUS, :long, 12, :long, 0)
-        channel.gets_packet(FXP_STATUS, :long, 13, :long, 0)
-        channel.gets_packet(FXP_STATUS, :long, 14, :long, 1)
-        channel.sends_packet(FXP_CLOSE, :long, 15, :string, "file2")
-        channel.gets_packet(FXP_STATUS, :long, 15, :long, 0)
-      end
-
-      File.expects(:directory?).with(local).returns(false)
-      File.expects(:directory?).with(File.join(local, "subdir1")).returns(false)
-      Dir.expects(:mkdir).with(local)
-      Dir.expects(:mkdir).with(File.join(local, "subdir1"))
-
-      file1 = StringIO.new
-      file2 = StringIO.new
-      File.expects(:open).with(File.join(local, "file1"), "wb").returns(file1)
-      File.expects(:open).with(File.join(local, "subdir1", "file2"), "wb").returns(file2)
-
-      [file1, file2]
-    end
-end