net-sftp 2.1.2 → 2.1.3.rc2

data/test/test_file_factory.rb

@@ -1,48 +0,0 @@
-require "common"
-
-class FileFactoryTest < Net::SFTP::TestCase
-  def setup
-    @sftp = stub(:sftp)
-    @factory = Net::SFTP::Operations::FileFactory.new(@sftp)
-  end
-
-  def test_open_with_block_should_yield_and_close_handle
-    @sftp.expects(:open!).with("/path/to/remote", "r", :permissions => nil).returns("handle")
-    @sftp.expects(:close!).with("handle")
-
-    called = false
-    @factory.open("/path/to/remote") do |f|
-      called = true
-      assert_instance_of Net::SFTP::Operations::File, f
-    end
-
-    assert called
-  end
-
-  def test_open_with_block_should_close_file_even_if_exception_is_raised
-    @sftp.expects(:open!).with("/path/to/remote", "r", :permissions => nil).returns("handle")
-    @sftp.expects(:close!).with("handle")
-
-    assert_raises(RuntimeError) do
-      @factory.open("/path/to/remote") { |f| raise RuntimeError, "b00m" }
-    end
-  end
-
-  def test_open_without_block_should_return_new_file
-    @sftp.expects(:open!).with("/path/to/remote", "r", :permissions => nil).returns("handle")
-    @sftp.expects(:close!).never
-
-    f = @factory.open("/path/to/remote")
-    assert_instance_of Net::SFTP::Operations::File, f
-  end
-
-  def test_directory_should_be_true_for_directory
-    @sftp.expects(:lstat!).with("/path/to/dir").returns(mock('attrs', :directory? => true))
-    assert @factory.directory?("/path/to/dir")
-  end
-
-  def test_directory_should_be_false_for_non_directory
-    @sftp.expects(:lstat!).with("/path/to/file").returns(mock('attrs', :directory? => false))
-    assert !@factory.directory?("/path/to/file")
-  end
-end

data/test/test_packet.rb

@@ -1,9 +0,0 @@
-require 'common'
-
-class PacketTest < Net::SFTP::TestCase
-  def test_packet_should_auto_read_type_byte
-    packet = Net::SFTP::Packet.new("\001rest-of-packet-here")
-    assert_equal 1, packet.type
-    assert_equal "rest-of-packet-here", packet.content[packet.position..-1]
-  end
-end

data/test/test_protocol.rb

@@ -1,17 +0,0 @@
-require 'common'
-
-class ProtocolTest < Net::SFTP::TestCase
-  1.upto(6) do |version|
-    define_method("test_load_version_#{version}_should_return_v#{version}_driver") do
-      session = stub('session', :logger => nil)
-      driver = Net::SFTP::Protocol.load(session, version)
-      assert_instance_of Net::SFTP::Protocol.const_get("V%02d" % version)::Base, driver
-    end
-  end
-
-  def test_load_version_7_should_be_unsupported
-    assert_raises(NotImplementedError) do
-      Net::SFTP::Protocol.load(stub('session'), 7)
-    end
-  end
-end

data/test/test_request.rb

@@ -1,71 +0,0 @@
-require 'common'
-
-class RequestTest < Net::SFTP::TestCase
-  def test_property_setter_should_symbolize_key
-    request = Net::SFTP::Request.new(stub("session"), :open, 1)
-    request["key"] = :value
-    assert_equal :value, request['key']
-    assert_equal :value, request[:key]
-    assert_equal :value, request.properties[:key]
-    assert_nil request.properties['key']
-  end
-
-  def test_pending_should_query_pending_requests_of_session
-    session = stub("session", :pending_requests => {1 => true})
-    request = Net::SFTP::Request.new(session, :open, 1)
-    assert request.pending?
-    request = Net::SFTP::Request.new(session, :open, 2)
-    assert !request.pending?
-  end
-
-  def test_wait_should_run_loop_while_pending_and_return_self
-    session = MockSession.new
-    request = Net::SFTP::Request.new(session, :open, 1)
-    request.expects(:pending?).times(4).returns(true, true, true, false)
-    assert_equal 0, session.loops
-    assert_equal request, request.wait
-    assert_equal 4, session.loops
-  end
-
-  def test_respond_to_should_set_response_property
-    packet = stub("packet", :type => 1)
-    session = stub("session", :protocol => mock("protocol"))
-    session.protocol.expects(:parse).with(packet).returns({})
-    request = Net::SFTP::Request.new(session, :open, 1)
-    assert_nil request.response
-    request.respond_to(packet)
-    assert_instance_of Net::SFTP::Response, request.response
-  end
-
-  def test_respond_to_with_callback_should_invoke_callback
-    packet = stub("packet", :type => 1)
-    session = stub("session", :protocol => mock("protocol"))
-    session.protocol.expects(:parse).with(packet).returns({})
-
-    called = false
-    request = Net::SFTP::Request.new(session, :open, 1) do |response|
-      called = true
-      assert_equal request.response, response
-    end
-
-    request.respond_to(packet)
-    assert called
-  end
-
-  private
-
-    class MockSession
-      attr_reader :loops
-
-      def initialize
-        @loops = 0
-      end
-
-      def loop
-        while true
-          @loops += 1
-          break unless yield
-        end
-      end
-    end
-end

data/test/test_response.rb

@@ -1,53 +0,0 @@
-require 'common'
-
-class ResponseTest < Net::SFTP::TestCase
-  def test_code_should_default_to_FX_OK
-    response = Net::SFTP::Response.new(mock("response"))
-    assert_equal Net::SFTP::Response::FX_OK, response.code
-  end
-
-  def test_brackets_should_symbolize_key
-    response = Net::SFTP::Response.new(mock("response"), :handle => "foo")
-    assert_equal "foo", response['handle']
-  end
-
-  def test_to_s_with_nil_message_should_show_default_message
-    response = Net::SFTP::Response.new(mock("response"), :code => 14)
-    assert_equal "no space on filesystem (14)", response.to_s
-  end
-
-  def test_to_s_with_empty_message_should_show_default_message
-    response = Net::SFTP::Response.new(mock("response"), :code => 14, :message => "")
-    assert_equal "no space on filesystem (14)", response.to_s
-  end
-
-  def test_to_s_with_default_message_should_show_default_message
-    response = Net::SFTP::Response.new(mock("response"), :code => 14, :message => "no space on filesystem")
-    assert_equal "no space on filesystem (14)", response.to_s
-  end
-
-  def test_to_s_with_explicit_message_should_show_explicit_message
-    response = Net::SFTP::Response.new(mock("response"), :code => 14, :message => "out of space")
-    assert_equal "out of space (no space on filesystem, 14)", response.to_s
-  end
-
-  def test_ok_should_be_true_when_code_is_FX_OK
-    response = Net::SFTP::Response.new(mock("response"))
-    assert_equal true, response.ok?
-  end
-
-  def test_ok_should_be_false_when_code_is_not_FX_OK
-    response = Net::SFTP::Response.new(mock("response"), :code => 14)
-    assert_equal false, response.ok?
-  end
-
-  def test_eof_should_be_true_when_code_is_FX_EOF
-    response = Net::SFTP::Response.new(mock("response"), :code => 1)
-    assert_equal true, response.eof?
-  end
-
-  def test_eof_should_be_false_when_code_is_not_FX_EOF
-    response = Net::SFTP::Response.new(mock("response"), :code => 14)
-    assert_equal false, response.eof?
-  end
-end

data/test/test_session.rb

@@ -1,741 +0,0 @@
-require "common"
-
-class SessionTest < Net::SFTP::TestCase
-  include Net::SFTP::Constants
-  include Net::SFTP::Constants::OpenFlags
-  include Net::SFTP::Constants::PacketTypes
-
-  (1..6).each do |version|
-    define_method("test_server_reporting_version_#{version}_should_cause_version_#{version}_to_be_used") do
-      expect_sftp_session :server_version => version
-      assert_scripted { sftp.connect! }
-      assert_equal version, sftp.protocol.version
-    end
-  end
-
-  def test_v1_open_read_only_that_succeeds_should_invoke_callback
-    expect_open("/path/to/file", "r", nil, :server_version => 1)
-    assert_successful_open("/path/to/file")
-  end
-
-  def test_v1_open_read_only_that_fails_should_invoke_callback
-    expect_open("/path/to/file", "r", nil, :server_version => 1, :fail => 2)
-
-    assert_command_with_callback(:open, "/path/to/file") do |response|
-      assert !response.ok?
-      assert_equal 2, response.code
-    end
-  end
-
-  def test_v1_open_write_only_that_succeeds_should_invoke_callback
-    expect_open("/path/to/file", "w", nil, :server_version => 1)
-    assert_successful_open("/path/to/file", "w")
-  end
-
-  def test_v1_open_read_write_that_succeeds_should_invoke_callback
-    expect_open("/path/to/file", "rw", nil, :server_version => 1)
-    assert_successful_open("/path/to/file", "r+")
-  end
-
-  def test_v1_open_append_that_succeeds_should_invoke_callback
-    expect_open("/path/to/file", "a", nil, :server_version => 1)
-    assert_successful_open("/path/to/file", "a")
-  end
-
-  def test_v1_open_with_permissions_should_specify_permissions
-    expect_open("/path/to/file", "r", 0765, :server_version => 1)
-    assert_successful_open("/path/to/file", "r", :permissions => 0765)
-  end
-
-  def test_v4_open_with_permissions_should_specify_permissions
-    expect_open("/path/to/file", "r", 0765, :server_version => 4)
-    assert_successful_open("/path/to/file", "r", :permissions => 0765)
-  end
-
-  def test_v5_open_read_only_shuld_invoke_callback
-    expect_open("/path/to/file", "r", 0765, :server_version => 5)
-    assert_successful_open("/path/to/file", "r", :permissions => 0765)
-  end
-
-  def test_v6_open_with_permissions_should_specify_permissions
-    expect_open("/path/to/file", "r", 0765, :server_version => 6)
-    assert_successful_open("/path/to/file", "r", :permissions => 0765)
-  end
-
-  def test_open_bang_should_block_and_return_handle
-    expect_open("/path/to/file", "r", nil)
-    handle = assert_synchronous_command(:open!, "/path/to/file", "r")
-    assert_equal "handle", handle
-  end
-
-  def test_open_bang_should_block_and_raise_exception_on_error
-    expect_open("/path/to/file", "r", nil, :fail => 5)
-    assert_raises(Net::SFTP::StatusException) do
-      assert_synchronous_command(:open!, "/path/to/file", "r")
-    end
-  end
-
-  def test_close_should_send_close_request_and_invoke_callback
-    expect_sftp_session do |channel|
-      channel.sends_packet(FXP_CLOSE, :long, 0, :string, "handle")
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 0)
-    end
-
-    assert_command_with_callback(:close, "handle") { |r| assert r.ok? }
-  end
-
-  def test_close_bang_should_block_and_return_response
-    expect_sftp_session do |channel|
-      channel.sends_packet(FXP_CLOSE, :long, 0, :string, "handle")
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 0)
-    end
-
-    response = assert_synchronous_command(:close!, "handle")
-    assert response.ok?
-  end
-
-  def test_read_should_send_read_request_and_invoke_callback
-    expect_sftp_session do |channel|
-      channel.sends_packet(FXP_READ, :long, 0, :string, "handle", :int64, 512123, :long, 1024)
-      channel.gets_packet(FXP_DATA, :long, 0, :string, "this is some data!")
-    end
-
-    assert_command_with_callback(:read, "handle", 512123, 1024) do |response|
-      assert response.ok?
-      assert_equal "this is some data!", response[:data]
-    end
-  end
-
-  def test_read_bang_should_block_and_return_data
-    expect_sftp_session do |channel|
-      channel.sends_packet(FXP_READ, :long, 0, :string, "handle", :int64, 512123, :long, 1024)
-      channel.gets_packet(FXP_DATA, :long, 0, :string, "this is some data!")
-    end
-
-    data = assert_synchronous_command(:read!, "handle", 512123, 1024)
-    assert_equal "this is some data!", data
-  end
-
-  def test_read_bang_should_block_and_return_nil_on_eof
-    expect_sftp_session do |channel|
-      channel.sends_packet(FXP_READ, :long, 0, :string, "handle", :int64, 512123, :long, 1024)
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 1)
-    end
-
-    data = assert_synchronous_command(:read!, "handle", 512123, 1024)
-    assert_nil data
-  end
-
-  def test_write_should_send_write_request_and_invoke_callback
-    expect_sftp_session do |channel|
-      channel.sends_packet(FXP_WRITE, :long, 0, :string, "handle", :int64, 512123, :string, "this is some data!")
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 0)
-    end
-
-    assert_command_with_callback(:write, "handle", 512123, "this is some data!") do |response|
-      assert response.ok?
-    end
-  end
-
-  def test_write_bang_should_block_and_return_response
-    expect_sftp_session do |channel|
-      channel.sends_packet(FXP_WRITE, :long, 0, :string, "handle", :int64, 512123, :string, "this is some data!")
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 0)
-    end
-
-    response = assert_synchronous_command(:write!, "handle", 512123, "this is some data!")
-    assert response.ok?
-  end
-
-  def test_v1_lstat_should_send_lstat_request_and_invoke_callback
-    expect_sftp_session :server_version => 1 do |channel|
-      channel.sends_packet(FXP_LSTAT, :long, 0, :string, "/path/to/file")
-      channel.gets_packet(FXP_ATTRS, :long, 0, :long, 0xF, :int64, 123456, :long, 1, :long, 2, :long, 0765, :long, 123456789, :long, 234567890)
-    end
-
-    assert_command_with_callback(:lstat, "/path/to/file") do |response|
-      assert response.ok?
-      assert_equal 123456, response[:attrs].size
-      assert_equal 1, response[:attrs].uid
-      assert_equal 2, response[:attrs].gid
-      assert_equal 0765, response[:attrs].permissions
-      assert_equal 123456789, response[:attrs].atime
-      assert_equal 234567890, response[:attrs].mtime
-    end
-  end
-
-  def test_v4_lstat_should_send_default_flags_parameter
-    expect_sftp_session :server_version => 4 do |channel|
-      channel.sends_packet(FXP_LSTAT, :long, 0, :string, "/path/to/file", :long, 0x800001fd)
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 2)
-    end
-
-    assert_command_with_callback(:lstat, "/path/to/file")
-  end
-
-  def test_v4_lstat_should_honor_flags_parameter
-    expect_sftp_session :server_version => 4 do |channel|
-      channel.sends_packet(FXP_LSTAT, :long, 0, :string, "/path/to/file", :long, 0x1)
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 2)
-    end
-
-    assert_command_with_callback(:lstat, "/path/to/file", 0x1)
-  end
-
-  def test_lstat_bang_should_block_and_return_attrs
-    expect_sftp_session :server_version => 1 do |channel|
-      channel.sends_packet(FXP_LSTAT, :long, 0, :string, "/path/to/file")
-      channel.gets_packet(FXP_ATTRS, :long, 0, :long, 0xF, :int64, 123456, :long, 1, :long, 2, :long, 0765, :long, 123456789, :long, 234567890)
-    end
-
-    attrs = assert_synchronous_command(:lstat!, "/path/to/file")
-
-    assert_equal 123456, attrs.size
-    assert_equal 1, attrs.uid
-    assert_equal 2, attrs.gid
-    assert_equal 0765, attrs.permissions
-    assert_equal 123456789, attrs.atime
-    assert_equal 234567890, attrs.mtime
-  end
-
-  def test_v1_fstat_should_send_fstat_request_and_invoke_callback
-    expect_sftp_session :server_version => 1 do |channel|
-      channel.sends_packet(FXP_FSTAT, :long, 0, :string, "handle")
-      channel.gets_packet(FXP_ATTRS, :long, 0, :long, 0xF, :int64, 123456, :long, 1, :long, 2, :long, 0765, :long, 123456789, :long, 234567890)
-    end
-
-    assert_command_with_callback(:fstat, "handle") do |response|
-      assert response.ok?
-      assert_equal 123456, response[:attrs].size
-      assert_equal 1, response[:attrs].uid
-      assert_equal 2, response[:attrs].gid
-      assert_equal 0765, response[:attrs].permissions
-      assert_equal 123456789, response[:attrs].atime
-      assert_equal 234567890, response[:attrs].mtime
-    end
-  end
-
-  def test_v4_fstat_should_send_default_flags_parameter
-    expect_sftp_session :server_version => 4 do |channel|
-      channel.sends_packet(FXP_FSTAT, :long, 0, :string, "handle", :long, 0x800001fd)
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 2)
-    end
-
-    assert_command_with_callback(:fstat, "handle")
-  end
-
-  def test_v4_fstat_should_honor_flags_parameter
-    expect_sftp_session :server_version => 4 do |channel|
-      channel.sends_packet(FXP_FSTAT, :long, 0, :string, "handle", :long, 0x1)
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 2)
-    end
-
-    assert_command_with_callback(:fstat, "handle", 0x1)
-  end
-
-  def test_fstat_bang_should_block_and_return_attrs
-    expect_sftp_session :server_version => 1 do |channel|
-      channel.sends_packet(FXP_FSTAT, :long, 0, :string, "handle")
-      channel.gets_packet(FXP_ATTRS, :long, 0, :long, 0xF, :int64, 123456, :long, 1, :long, 2, :long, 0765, :long, 123456789, :long, 234567890)
-    end
-
-    attrs = assert_synchronous_command(:fstat!, "handle")
-
-    assert_equal 123456, attrs.size
-    assert_equal 1, attrs.uid
-    assert_equal 2, attrs.gid
-    assert_equal 0765, attrs.permissions
-    assert_equal 123456789, attrs.atime
-    assert_equal 234567890, attrs.mtime
-  end
-
-  def test_v1_setstat_should_send_v1_attributes
-    expect_sftp_session :server_version => 1 do |channel|
-      channel.sends_packet(FXP_SETSTAT, :long, 0, :string, "/path/to/file", :long, 0xc, :long, 0765, :long, 1234567890, :long, 2345678901)
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 0)
-    end
-
-    assert_command_with_callback(:setstat, "/path/to/file", :permissions => 0765, :atime => 1234567890, :mtime => 2345678901)
-  end
-
-  def test_v4_setstat_should_send_v4_attributes
-    expect_sftp_session :server_version => 4 do |channel|
-      channel.sends_packet(FXP_SETSTAT, :long, 0, :string, "/path/to/file", :long, 0x2c, :byte, 1, :long, 0765, :int64, 1234567890, :int64, 2345678901)
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 0)
-    end
-
-    assert_command_with_callback(:setstat, "/path/to/file", :permissions => 0765, :atime => 1234567890, :mtime => 2345678901)
-  end
-
-  def test_v6_setstat_should_send_v6_attributes
-    expect_sftp_session :server_version => 6 do |channel|
-      channel.sends_packet(FXP_SETSTAT, :long, 0, :string, "/path/to/file", :long, 0x102c, :byte, 1, :long, 0765, :int64, 1234567890, :int64, 2345678901, :string, "text/plain")
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 0)
-    end
-
-    assert_command_with_callback(:setstat, "/path/to/file", :permissions => 0765, :atime => 1234567890, :mtime => 2345678901, :mime_type => "text/plain")
-  end
-
-  def test_setstat_bang_should_block_and_return_response
-    expect_sftp_session :server_version => 1 do |channel|
-      channel.sends_packet(FXP_SETSTAT, :long, 0, :string, "/path/to/file", :long, 0xc, :long, 0765, :long, 1234567890, :long, 2345678901)
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 0)
-    end
-
-    response = assert_synchronous_command(:setstat!, "/path/to/file", :permissions => 0765, :atime => 1234567890, :mtime => 2345678901)
-    assert response.ok?
-  end
-
-  def test_v1_fsetstat_should_send_v1_attributes
-    expect_sftp_session :server_version => 1 do |channel|
-      channel.sends_packet(FXP_FSETSTAT, :long, 0, :string, "handle", :long, 0xc, :long, 0765, :long, 1234567890, :long, 2345678901)
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 0)
-    end
-
-    assert_command_with_callback(:fsetstat, "handle", :permissions => 0765, :atime => 1234567890, :mtime => 2345678901)
-  end
-
-  def test_v4_fsetstat_should_send_v4_attributes
-    expect_sftp_session :server_version => 4 do |channel|
-      channel.sends_packet(FXP_FSETSTAT, :long, 0, :string, "handle", :long, 0x2c, :byte, 1, :long, 0765, :int64, 1234567890, :int64, 2345678901)
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 0)
-    end
-
-    assert_command_with_callback(:fsetstat, "handle", :permissions => 0765, :atime => 1234567890, :mtime => 2345678901)
-  end
-
-  def test_v6_fsetstat_should_send_v6_attributes
-    expect_sftp_session :server_version => 6 do |channel|
-      channel.sends_packet(FXP_FSETSTAT, :long, 0, :string, "handle", :long, 0x102c, :byte, 1, :long, 0765, :int64, 1234567890, :int64, 2345678901, :string, "text/plain")
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 0)
-    end
-
-    assert_command_with_callback(:fsetstat, "handle", :permissions => 0765, :atime => 1234567890, :mtime => 2345678901, :mime_type => "text/plain")
-  end
-
-  def test_fsetstat_bang_should_block_and_return_response
-    expect_sftp_session :server_version => 1 do |channel|
-      channel.sends_packet(FXP_FSETSTAT, :long, 0, :string, "handle", :long, 0xc, :long, 0765, :long, 1234567890, :long, 2345678901)
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 0)
-    end
-
-    response = assert_synchronous_command(:fsetstat!, "handle", :permissions => 0765, :atime => 1234567890, :mtime => 2345678901)
-    assert response.ok?
-  end
-
-  def test_opendir_should_send_opendir_request_and_invoke_callback
-    expect_sftp_session do |channel|
-      channel.sends_packet(FXP_OPENDIR, :long, 0, :string, "/path/to/dir")
-      channel.gets_packet(FXP_HANDLE, :long, 0, :string, "handle")
-    end
-
-    assert_command_with_callback(:opendir, "/path/to/dir")
-  end
-
-  def test_opendir_bang_should_block_and_return_handle
-    expect_sftp_session do |channel|
-      channel.sends_packet(FXP_OPENDIR, :long, 0, :string, "/path/to/dir")
-      channel.gets_packet(FXP_HANDLE, :long, 0, :string, "handle")
-    end
-
-    handle = assert_synchronous_command(:opendir!, "/path/to/dir")
-    assert_equal "handle", handle
-  end
-
-  def test_readdir_should_send_readdir_request_and_invoke_callback
-    expect_sftp_session do |channel|
-      channel.sends_packet(FXP_READDIR, :long, 0, :string, "handle")
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 1)
-    end
-
-    assert_command_with_callback(:readdir, "handle") { |r| assert r.eof? }
-  end
-
-  def test_readdir_bang_should_block_and_return_names_array
-    expect_sftp_session :server_version => 1 do |channel|
-      channel.sends_packet(FXP_READDIR, :long, 0, :string, "handle")
-      channel.gets_packet(FXP_NAME, :long, 0, :long, 2,
-        :string, "first", :string, "longfirst", :long, 0x0,
-        :string, "next", :string, "longnext", :long, 0x0)
-    end
-
-    names = assert_synchronous_command(:readdir!, "handle")
-    assert_equal 2, names.length
-    assert_equal %w(first next), names.map { |n| n.name }
-  end
-
-  def test_remove_should_send_remove_packet
-    expect_sftp_session do |channel|
-      channel.sends_packet(FXP_REMOVE, :long, 0, :string, "/path/to/file")
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 0)
-    end
-
-    assert_command_with_callback(:remove, "/path/to/file")
-  end
-
-  def test_remove_bang_should_block_and_return_response
-    expect_sftp_session do |channel|
-      channel.sends_packet(FXP_REMOVE, :long, 0, :string, "/path/to/file")
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 0)
-    end
-
-    response = assert_synchronous_command(:remove!, "/path/to/file")
-    assert response.ok?
-  end
-
-  def test_mkdir_should_send_mkdir_packet
-    expect_sftp_session do |channel|
-      channel.sends_packet(FXP_MKDIR, :long, 0, :string, "/path/to/dir", :long, 0x4, :byte, 1, :long, 0765)
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 0)
-    end
-
-    assert_command_with_callback(:mkdir, "/path/to/dir", :permissions => 0765)
-  end
-
-  def test_mkdir_bang_should_block_and_return_response
-    expect_sftp_session do |channel|
-      channel.sends_packet(FXP_MKDIR, :long, 0, :string, "/path/to/dir", :long, 0x4, :byte, 1, :long, 0765)
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 0)
-    end
-
-    response = assert_synchronous_command(:mkdir!, "/path/to/dir", :permissions => 0765)
-    assert response.ok?
-  end
-
-  def test_rmdir_should_send_rmdir_packet
-    expect_sftp_session do |channel|
-      channel.sends_packet(FXP_RMDIR, :long, 0, :string, "/path/to/dir")
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 0)
-    end
-
-    assert_command_with_callback(:rmdir, "/path/to/dir")
-  end
-
-  def test_rmdir_bang_should_block_and_return_response
-    expect_sftp_session do |channel|
-      channel.sends_packet(FXP_RMDIR, :long, 0, :string, "/path/to/dir")
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 0)
-    end
-
-    response = assert_synchronous_command(:rmdir!, "/path/to/dir")
-    assert response.ok?
-  end
-
-  def test_realpath_should_send_realpath_packet
-    expect_sftp_session do |channel|
-      channel.sends_packet(FXP_REALPATH, :long, 0, :string, "/path/to/dir")
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 2)
-    end
-
-    assert_command_with_callback(:realpath, "/path/to/dir")
-  end
-
-  def test_realpath_bang_should_block_and_return_names_item
-    expect_sftp_session do |channel|
-      channel.sends_packet(FXP_REALPATH, :long, 0, :string, "/path/to/dir")
-      channel.gets_packet(FXP_NAME, :long, 0, :long, 1, :string, "dir", :long, 0x0, :long, 2)
-    end
-
-    name = assert_synchronous_command(:realpath!, "/path/to/dir")
-    assert_equal "dir", name.name
-  end
-
-  def test_v1_stat_should_send_stat_request_and_invoke_callback
-    expect_sftp_session :server_version => 1 do |channel|
-      channel.sends_packet(FXP_STAT, :long, 0, :string, "/path/to/file")
-      channel.gets_packet(FXP_ATTRS, :long, 0, :long, 0xF, :int64, 123456, :long, 1, :long, 2, :long, 0765, :long, 123456789, :long, 234567890)
-    end
-
-    assert_command_with_callback(:stat, "/path/to/file") do |response|
-      assert response.ok?
-      assert_equal 123456, response[:attrs].size
-      assert_equal 1, response[:attrs].uid
-      assert_equal 2, response[:attrs].gid
-      assert_equal 0765, response[:attrs].permissions
-      assert_equal 123456789, response[:attrs].atime
-      assert_equal 234567890, response[:attrs].mtime
-    end
-  end
-
-  def test_v4_stat_should_send_default_flags_parameter
-    expect_sftp_session :server_version => 4 do |channel|
-      channel.sends_packet(FXP_STAT, :long, 0, :string, "/path/to/file", :long, 0x800001fd)
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 2)
-    end
-
-    assert_command_with_callback(:stat, "/path/to/file")
-  end
-
-  def test_v4_stat_should_honor_flags_parameter
-    expect_sftp_session :server_version => 4 do |channel|
-      channel.sends_packet(FXP_STAT, :long, 0, :string, "/path/to/file", :long, 0x1)
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 2)
-    end
-
-    assert_command_with_callback(:stat, "/path/to/file", 0x1)
-  end
-
-  def test_stat_bang_should_block_and_return_attrs
-    expect_sftp_session :server_version => 1 do |channel|
-      channel.sends_packet(FXP_STAT, :long, 0, :string, "/path/to/file")
-      channel.gets_packet(FXP_ATTRS, :long, 0, :long, 0xF, :int64, 123456, :long, 1, :long, 2, :long, 0765, :long, 123456789, :long, 234567890)
-    end
-
-    attrs = assert_synchronous_command(:stat!, "/path/to/file")
-
-    assert_equal 123456, attrs.size
-    assert_equal 1, attrs.uid
-    assert_equal 2, attrs.gid
-    assert_equal 0765, attrs.permissions
-    assert_equal 123456789, attrs.atime
-    assert_equal 234567890, attrs.mtime
-  end
-
-  def test_v1_rename_should_be_unimplemented
-    assert_not_implemented 1, :rename, "from", "to"
-  end
-
-  def test_v2_rename_should_send_rename_packet
-    expect_sftp_session :server_version => 2 do |channel|
-      channel.sends_packet(FXP_RENAME, :long, 0, :string, "from", :string, "to")
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 0)
-    end
-
-    assert_command_with_callback(:rename, "from", "to")
-  end
-
-  def test_v5_rename_should_send_rename_packet_and_default_flags
-    expect_sftp_session :server_version => 5 do |channel|
-      channel.sends_packet(FXP_RENAME, :long, 0, :string, "from", :string, "to", :long, 0)
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 0)
-    end
-
-    assert_command_with_callback(:rename, "from", "to")
-  end
-
-  def test_v5_rename_should_send_rename_packet_and_honor_flags
-    expect_sftp_session :server_version => 5 do |channel|
-      channel.sends_packet(FXP_RENAME, :long, 0, :string, "from", :string, "to", :long, 1)
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 0)
-    end
-
-    assert_command_with_callback(:rename, "from", "to", 1)
-  end
-
-  def test_rename_bang_should_block_and_return_response
-    expect_sftp_session :server_version => 2 do |channel|
-      channel.sends_packet(FXP_RENAME, :long, 0, :string, "from", :string, "to")
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 0)
-    end
-
-    response = assert_synchronous_command(:rename!, "from", "to")
-    assert response.ok?
-  end
-
-  def test_v2_readlink_should_be_unimplemented
-    assert_not_implemented 2, :readlink, "/path/to/link"
-  end
-
-  def test_v3_readlink_should_send_readlink_packet
-    expect_sftp_session :server_version => 3 do |channel|
-      channel.sends_packet(FXP_READLINK, :long, 0, :string, "/path/to/link")
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 2)
-    end
-
-    assert_command_with_callback(:readlink, "/path/to/link")
-  end
-
-  def test_readlink_bang_should_block_and_return_name
-    expect_sftp_session :server_version => 3 do |channel|
-      channel.sends_packet(FXP_READLINK, :long, 0, :string, "/path/to/link")
-      channel.gets_packet(FXP_NAME, :long, 0, :long, 1, :string, "target", :string, "longtarget", :long, 0x0)
-    end
-
-    name = assert_synchronous_command(:readlink!, "/path/to/link")
-    assert_equal "target", name.name
-  end
-
-  def test_v2_symlink_should_be_unimplemented
-    assert_not_implemented 2, :symlink, "/path/to/source", "/path/to/link"
-  end
-
-  def test_v3_symlink_should_send_symlink_packet
-    expect_sftp_session :server_version => 3 do |channel|
-      channel.sends_packet(FXP_SYMLINK, :long, 0, :string, "/path/to/source", :string, "/path/to/link")
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 0)
-    end
-
-    assert_command_with_callback(:symlink, "/path/to/source", "/path/to/link")
-  end
-
-  def test_v6_symlink_should_send_link_packet
-    expect_sftp_session :server_version => 6 do |channel|
-      channel.sends_packet(FXP_LINK, :long, 0, :string, "/path/to/link", :string, "/path/to/source", :bool, true)
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 0)
-    end
-
-    assert_command_with_callback(:symlink, "/path/to/link", "/path/to/source")
-  end
-
-  def test_symlink_bang_should_block_and_return_response
-    expect_sftp_session :server_version => 3 do |channel|
-      channel.sends_packet(FXP_SYMLINK, :long, 0, :string, "/path/to/source", :string, "/path/to/link")
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 0)
-    end
-
-    response = assert_synchronous_command(:symlink!, "/path/to/source", "/path/to/link")
-    assert response.ok?
-  end
-
-  def test_v5_link_should_be_unimplemented
-    assert_not_implemented 5, :link, "/path/to/source", "/path/to/link", true
-  end
-
-  def test_v6_link_should_send_link_packet
-    expect_sftp_session :server_version => 6 do |channel|
-      channel.sends_packet(FXP_LINK, :long, 0, :string, "/path/to/link", :string, "/path/to/source", :bool, true)
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 0)
-    end
-
-    assert_command_with_callback(:link, "/path/to/link", "/path/to/source", true)
-  end
-
-  def test_link_bang_should_block_and_return_response
-    expect_sftp_session :server_version => 6 do |channel|
-      channel.sends_packet(FXP_LINK, :long, 0, :string, "/path/to/link", :string, "/path/to/source", :bool, true)
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 0)
-    end
-
-    response = assert_synchronous_command(:link!, "/path/to/link", "/path/to/source", true)
-    assert response.ok?
-  end
-
-  def test_v5_block_should_be_unimplemented
-    assert_not_implemented 5, :block, "handle", 12345, 67890, 0xabcd
-  end
-
-  def test_v6_block_should_send_block_packet
-    expect_sftp_session :server_version => 6 do |channel|
-      channel.sends_packet(FXP_BLOCK, :long, 0, :string, "handle", :int64, 12345, :int64, 67890, :long, 0xabcd)
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 0)
-    end
-
-    assert_command_with_callback(:block, "handle", 12345, 67890, 0xabcd)
-  end
-
-  def test_block_bang_should_block_and_return_response
-    expect_sftp_session :server_version => 6 do |channel|
-      channel.sends_packet(FXP_BLOCK, :long, 0, :string, "handle", :int64, 12345, :int64, 67890, :long, 0xabcd)
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 0)
-    end
-
-    response = assert_synchronous_command(:block!, "handle", 12345, 67890, 0xabcd)
-    assert response.ok?
-  end
-
-  def test_v5_unblock_should_be_unimplemented
-    assert_not_implemented 5, :unblock, "handle", 12345, 67890
-  end
-
-  def test_v6_unblock_should_send_block_packet
-    expect_sftp_session :server_version => 6 do |channel|
-      channel.sends_packet(FXP_UNBLOCK, :long, 0, :string, "handle", :int64, 12345, :int64, 67890)
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 0)
-    end
-
-    assert_command_with_callback(:unblock, "handle", 12345, 67890)
-  end
-
-  def test_unblock_bang_should_block_and_return_response
-    expect_sftp_session :server_version => 6 do |channel|
-      channel.sends_packet(FXP_UNBLOCK, :long, 0, :string, "handle", :int64, 12345, :int64, 67890)
-      channel.gets_packet(FXP_STATUS, :long, 0, :long, 0)
-    end
-
-    response = assert_synchronous_command(:unblock!, "handle", 12345, 67890)
-    assert response.ok?
-  end
-
-  private
-
-    def assert_not_implemented(server_version, command, *args)
-      expect_sftp_session :server_version => 1
-      sftp.connect!
-      assert_raises(NotImplementedError) { sftp.send(command, *args) }
-    end
-
-    def assert_command_with_callback(command, *args)
-      called = false
-      assert_scripted_command do
-        sftp.send(command, *args) do |response|
-          called = true
-          yield response if block_given?
-        end
-      end
-      assert called, "expected callback to be invoked, but it wasn't"
-    end
-
-    def assert_synchronous_command(command, *args)
-      assert_scripted_command do
-        sequence = [:start]
-        result = sftp.send(command, *args) do |response|
-          sequence << :done
-          yield response if block_given?
-        end
-        sequence << :after
-        assert_equal [:start, :done, :after], sequence, "expected #{command} to be synchronous"
-        return result
-      end
-    end
-
-    def assert_successful_open(*args)
-      assert_command_with_callback(:open, *args) do |response|
-        assert response.ok?
-        assert_equal "handle", response[:handle]
-      end
-    end
-
-    def expect_open(path, mode, perms, options={})
-      version = options[:server_version] || 6
-
-      fail = options.delete(:fail)
-
-      attrs = [:long, perms ? 0x4 : 0]
-      attrs += [:byte, 1] if version >= 4
-      attrs += [:long, perms] if perms
-
-      expect_sftp_session(options) do |channel|
-        if version >= 5
-          flags, access = case mode
-            when "r" then 
-              [FV5::OPEN_EXISTING, ACE::Mask::READ_DATA | ACE::Mask::READ_ATTRIBUTES]
-            when "w" then
-              [FV5::CREATE_TRUNCATE, ACE::Mask::WRITE_DATA | ACE::Mask::WRITE_ATTRIBUTES]
-            when "rw" then
-              [FV5::OPEN_OR_CREATE, ACE::Mask::READ_DATA | ACE::Mask::READ_ATTRIBUTES | ACE::Mask::WRITE_DATA | ACE::Mask::WRITE_ATTRIBUTES]
-            when "a" then
-              [FV5::OPEN_OR_CREATE | FV5::APPEND_DATA, ACE::Mask::WRITE_DATA | ACE::Mask::WRITE_ATTRIBUTES | ACE::Mask::APPEND_DATA]
-            else raise ArgumentError, "unsupported mode #{mode.inspect}"
-          end
-
-          channel.sends_packet(FXP_OPEN, :long, 0, :string, path, :long, access, :long, flags, *attrs)
-        else
-          flags = case mode
-            when "r"  then FV1::READ
-            when "w"  then FV1::WRITE | FV1::TRUNC | FV1::CREAT
-            when "rw" then FV1::WRITE | FV1::READ
-            when "a"  then FV1::APPEND | FV1::WRITE | FV1::CREAT
-            else raise ArgumentError, "unsupported mode #{mode.inspect}"
-          end
-
-          channel.sends_packet(FXP_OPEN, :long, 0, :string, path, :long, flags, *attrs)
-        end
-
-        if fail
-          channel.gets_packet(FXP_STATUS, :long, 0, :long, fail)
-        else
-          channel.gets_packet(FXP_HANDLE, :long, 0, :string, "handle")
-        end
-      end
-    end
-end