net-sftp 1.1.1 → 2.0.0

data/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/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/test/test_all.rb

@@ -0,0 +1,3 @@
+Dir.chdir(File.dirname(__FILE__)) do
+  Dir['**/test_*.rb'].each { |file| require(file) }
+end

data/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

data/test/test_download.rb

@@ -0,0 +1,252 @@
+require "common"
+
+class DownloadTest < Net::SFTP::TestCase
+  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, "w").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_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)
+      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(FXP_DATA, :long, 1, :string, text)
+        channel.sends_packet(FXP_READ, :long, 2, :string, "handle", :int64, 32_000, :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)
+      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")
+        10.times do |n|
+          channel.sends_packet(FXP_READ, :long, n+1, :string, "handle", :int64, n*1024, :long, 1024)
+          channel.gets_packet(FXP_DATA, :long, n+1, :string, text[n*1024,1024])
+        end
+        channel.sends_packet(FXP_READ, :long, 11, :string, "handle", :int64, 10240, :long, 1024)
+        channel.gets_packet(FXP_STATUS, :long, 11, :long, 1)
+        channel.sends_packet(FXP_CLOSE, :long, 12, :string, "handle")
+        channel.gets_packet(FXP_STATUS, :long, 12, :long, 0)
+      end
+
+      file = StringIO.new
+      File.stubs(:open).with(local, "w").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)
+      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, "contents of file1")
+        channel.sends_packet(FXP_READ, :long, 10, :string, "file1", :int64, 32_000, :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, "contents of file2")
+        channel.sends_packet(FXP_READ, :long, 14, :string, "file2", :int64, 32_000, :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"), "w").returns(file1)
+      File.expects(:open).with(File.join(local, "subdir1", "file2"), "w").returns(file2)
+
+      [file1, file2]
+    end
+end

data/test/test_file.rb

@@ -0,0 +1,159 @@
+require 'common'
+
+class FileOperationsTest < Net::SFTP::TestCase
+  def setup
+    @sftp = mock("sftp")
+    @file = Net::SFTP::Operations::File.new(@sftp, "handle")
+    @save_dollar_fslash, $/ = $/, "\n"
+    @save_dollar_bslash, $\ = $\, nil
+  end
+
+  def teardown
+    $/ = @save_dollar_fslash
+    $\ = @save_dollar_bslash
+  end
+
+  def test_pos_assignment_should_set_position
+    @file.pos = 15
+    assert_equal 15, @file.pos
+  end
+
+  def test_pos_assignment_should_reset_eof
+    @sftp.expects(:read!).with("handle", 0, 8192).returns(nil)
+    assert !@file.eof?
+    @file.read
+    assert @file.eof?
+    @file.pos = 0
+    assert !@file.eof?
+  end
+
+  def test_close_should_close_handle_and_set_handle_to_nil
+    assert_equal "handle", @file.handle
+    @sftp.expects(:close!).with("handle")
+    @file.close
+    assert_nil @file.handle
+  end
+
+  def test_eof_should_be_false_if_at_eof_but_data_remains_in_buffer
+    @sftp.expects(:read!).returns("hello world", nil)
+    @file.read(1)
+    assert !@file.eof?
+  end
+
+  def test_eof_should_be_true_if_at_eof_and_no_data_in_buffer
+    @sftp.expects(:read!).times(2).returns("hello world", nil)
+    @file.read
+    assert @file.eof?
+  end
+
+  def test_read_without_argument_should_read_and_return_remainder_of_file_and_set_pos
+    @sftp.expects(:read!).times(2).returns("hello world", nil)
+    assert_equal "hello world", @file.read
+    assert_equal 11, @file.pos
+  end
+
+  def test_read_with_argument_should_read_and_return_n_bytes_and_set_pos
+    @sftp.expects(:read!).returns("hello world")
+    assert_equal "hello", @file.read(5)
+    assert_equal 5, @file.pos
+  end
+
+  def test_read_after_pos_assignment_should_read_from_specified_position
+    @sftp.expects(:read!).with("handle", 5, 8192).returns("hello world")
+    @file.pos = 5
+    assert_equal "hello", @file.read(5)
+    assert_equal 10, @file.pos
+  end
+
+  def test_gets_without_argument_should_read_until_first_dollar_fslash
+    @sftp.expects(:read!).returns("hello world\ngoodbye world\n\nfarewell!\n")
+    assert_equal "\n", $/
+    assert_equal "hello world\n", @file.gets
+    assert_equal 12, @file.pos
+  end
+
+  def test_gets_with_empty_argument_should_read_until_double_dollar_fslash
+    @sftp.expects(:read!).returns("hello world\ngoodbye world\n\nfarewell!\n")
+    assert_equal "\n", $/
+    assert_equal "hello world\ngoodbye world\n\n", @file.gets("")
+    assert_equal 27, @file.pos
+  end
+
+  def test_gets_with_argument_should_read_until_first_instance_of_argument
+    @sftp.expects(:read!).returns("hello world\ngoodbye world\n\nfarewell!\n")
+    assert_equal "hello w", @file.gets("w")
+    assert_equal 7, @file.pos
+  end
+
+  def test_gets_when_no_such_delimiter_exists_in_stream_should_read_to_EOF
+    @sftp.expects(:read!).times(2).returns("hello world\ngoodbye world\n\nfarewell!\n", nil)
+    assert_equal "hello world\ngoodbye world\n\nfarewell!\n", @file.gets("X")
+    assert @file.eof?
+  end
+
+  def test_gets_at_EOF_should_return_nil
+    @sftp.expects(:read!).returns(nil)
+    assert_nil @file.gets
+    assert @file.eof?
+  end
+
+  def test_readline_should_raise_exception_on_EOF
+    @sftp.expects(:read!).returns(nil)
+    assert_raises(EOFError) { @file.readline }
+  end
+
+  def test_write_should_write_data_and_increment_pos_and_return_data_length
+    @sftp.expects(:write!).with("handle", 0, "hello world")
+    assert_equal 11, @file.write("hello world")
+    assert_equal 11, @file.pos
+  end
+
+  def test_write_after_pos_assignment_should_write_at_position
+    @sftp.expects(:write!).with("handle", 15, "hello world")
+    @file.pos = 15
+    assert_equal 11, @file.write("hello world")
+    assert_equal 26, @file.pos
+  end
+
+  def test_print_with_no_arguments_should_write_nothing_if_dollar_bslash_is_nil
+    assert_nil $\
+    @sftp.expects(:write!).never
+    @file.print
+  end
+
+  def test_print_with_no_arguments_should_write_dollar_bslash_if_dollar_bslash_is_not_nil
+    $\ = "-"
+    @sftp.expects(:write!).with("handle", 0, "-")
+    @file.print
+  end
+
+  def test_print_with_arguments_should_write_all_arguments
+    @sftp.expects(:write!).with("handle", 0, "hello")
+    @sftp.expects(:write!).with("handle", 5, " ")
+    @sftp.expects(:write!).with("handle", 6, "world")
+    @file.print("hello", " ", "world")
+  end
+
+  def test_puts_should_recursively_puts_array_arguments
+    10.times do |i|
+      @sftp.expects(:write!).with("handle", i*2, i.to_s)
+      @sftp.expects(:write!).with("handle", i*2+1, "\n")
+    end
+    @file.puts 0, [1, [2, 3], 4, [5, [6, 7, 8]]], 9
+  end
+
+  def test_puts_should_not_append_newline_if_argument_ends_in_newline
+    @sftp.expects(:write!).with("handle", 0, "a")
+    @sftp.expects(:write!).with("handle", 1, "\n")
+    @sftp.expects(:write!).with("handle", 2, "b\n")
+    @sftp.expects(:write!).with("handle", 4, "c")
+    @sftp.expects(:write!).with("handle", 5, "\n")
+    @file.puts "a", "b\n", "c"
+  end
+
+  def test_stat_should_return_attributes_object_for_handle
+    stat = stub("stat")
+    @sftp.expects(:fstat!).with("handle").returns(stat)
+    assert_equal stat, @file.stat
+  end
+end