net-sftp 1.1.1 → 2.0.0

data/test/common.rb

@@ -0,0 +1,173 @@
+require 'test/unit'
+require 'mocha'
+
+begin
+  gem 'net-ssh', ">= 2.0.0"
+  require 'net/ssh'
+rescue LoadError
+  $LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../../net-ssh/lib"
+
+  begin
+    require 'net/ssh'
+    require 'net/ssh/version'
+    raise LoadError, "wrong version" unless Net::SSH::Version::STRING >= '1.99.0'
+  rescue LoadError => e
+    abort "could not load net/ssh v2 (#{e.inspect})"
+  end
+end
+
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
+require 'net/sftp'
+require 'net/sftp/constants'
+require 'net/ssh/test'
+
+class Net::SFTP::TestCase < Test::Unit::TestCase
+  include Net::SFTP::Constants::PacketTypes
+  include Net::SSH::Test
+
+  def default_test
+    # do nothing, this is just hacky-hack to work around Test::Unit's
+    # insistence that all TestCase subclasses have at least one test
+    # method defined.
+  end
+
+  protected
+
+    def raw(*args)
+      Net::SSH::Buffer.from(*args).to_s
+    end
+
+    def sftp(options={})
+      @sftp ||= Net::SFTP::Session.new(connection(options))
+    end
+
+    def expect_sftp_session(opts={})
+      story do |session|
+        channel = session.opens_channel
+        channel.sends_subsystem("sftp")
+        channel.sends_packet(FXP_INIT, :long, opts[:client_version] || Net::SFTP::Session::HIGHEST_PROTOCOL_VERSION_SUPPORTED)
+        channel.gets_packet(FXP_VERSION, :long, opts[:server_version] || Net::SFTP::Session::HIGHEST_PROTOCOL_VERSION_SUPPORTED)
+        yield channel if block_given?
+      end
+    end
+
+    def assert_scripted_command
+      assert_scripted do
+        sftp.connect!
+        yield
+        sftp.loop
+      end
+    end
+
+    def assert_progress_reported_open(expect={})
+      assert_progress_reported(:open, expect)
+    end
+
+    def assert_progress_reported_put(offset, data, expect={})
+      assert_equal offset, current_event[3] if offset
+      assert_equal data, current_event[4] if data
+      assert_progress_reported(:put, expect)
+    end
+
+    def assert_progress_reported_get(offset, data, expect={})
+      assert_equal offset, current_event[3] if offset
+      if data.is_a?(Fixnum)
+        assert_equal data, current_event[4].length
+      elsif data
+        assert_equal data, current_event[4]
+      end
+      assert_progress_reported(:get, expect)
+    end
+
+    def assert_progress_reported_close(expect={})
+      assert_progress_reported(:close, expect)
+    end
+
+    def assert_progress_reported_mkdir(dir)
+      assert_equal dir, current_event[2]
+      assert_progress_reported(:mkdir)
+    end
+
+    def assert_progress_reported_finish
+      assert_progress_reported(:finish)
+    end
+
+    def assert_progress_reported(event, expect={})
+      assert_equal event, current_event[0]
+      expect.each do |key, value|
+        assert_equal value, current_event[2].send(key)
+      end
+      next_event!
+    end
+
+    def assert_no_more_reported_events
+      assert @progress.empty?, "expected #{@progress.empty?} to be empty"
+    end
+
+    def prepare_progress!
+      @progress = []
+    end
+
+    def record_progress(event)
+      @progress << event
+    end
+
+    def current_event
+      @progress.first
+    end
+
+    def next_event!
+      @progress.shift
+    end
+end
+
+class Net::SSH::Test::Channel
+  def gets_packet(type, *args)
+    gets_data(sftp_packet(type, *args))
+  end
+
+  def sends_packet(type, *args)
+    sends_data(sftp_packet(type, *args))
+  end
+
+  private
+
+    def sftp_packet(type, *args)
+      data = Net::SSH::Buffer.from(*args)
+      Net::SSH::Buffer.from(:long, data.length+1, :byte, type, :raw, data).to_s
+    end
+end
+
+class ProgressHandler
+  def initialize(progress_ref)
+    @progress = progress_ref
+  end
+
+  def on_open(*args)
+    @progress << [:open, *args]
+  end
+
+  def on_put(*args)
+    @progress << [:put, *args]
+  end
+
+  def on_close(*args)
+    @progress << [:close, *args]
+  end
+
+  def on_finish(*args)
+    @progress << [:finish, *args]
+  end
+end
+
+# "prime the pump", so to speak: predefine the modules we need so we can
+# define the test classes in a more elegant short-hand.
+
+module Protocol
+  module V01; end
+  module V02; end
+  module V03; end
+  module V04; end
+  module V05; end
+  module V06; end
+end

data/test/protocol/01/test_attributes.rb

@@ -0,0 +1,97 @@
+require 'common'
+
+module Etc; end
+
+class Protocol::V01::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 1234567890, attributes.size
+    assert_equal 100, attributes.uid
+    assert_equal 200, attributes.gid
+    assert_equal 0755, attributes.permissions
+    assert_equal 1234567890, attributes.atime
+    assert_equal 2345678901, attributes.mtime
+    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, :long, 0755)
+
+    attributes = attributes_factory.from_buffer(buffer)
+
+    assert_equal 0755, attributes.permissions
+
+    assert_nil attributes.size
+    assert_nil attributes.uid
+    assert_nil attributes.gid
+    assert_nil attributes.atime
+    assert_nil attributes.mtime
+    assert_nil attributes.extended
+  end
+
+  def test_attributes_to_s_should_build_binary_representation
+    attributes = attributes_factory.new(
+      :size => 1234567890,
+      :uid  => 100, :gid => 200,
+      :permissions => 0755,
+      :atime => 1234567890, :mtime => 2345678901,
+      :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, :long, 0755).to_s, attributes.to_s
+  end
+
+  def test_attributes_to_s_with_owner_and_group_should_translate_to_uid_and_gid
+    attributes = attributes_factory.new(:owner => "jamis", :group => "sftp")
+    attributes.expects(:require).with("etc").times(2)
+    Etc.expects(:getpwnam).with("jamis").returns(mock('user', :uid => 100))
+    Etc.expects(:getgrnam).with("sftp").returns(mock('group', :gid => 200))
+    assert_equal Net::SSH::Buffer.from(:long, 0x2, :long, 100, :long, 200).to_s, attributes.to_s
+  end
+
+  def test_owner_should_translate_from_uid
+    attributes = attributes_factory.new(:uid => 100)
+    attributes.expects(:require).with("etc")
+    Etc.expects(:getpwuid).with(100).returns(mock('user', :name => "jamis"))
+    assert_equal "jamis", attributes.owner
+  end
+
+  def test_group_should_translate_from_gid
+    attributes = attributes_factory.new(:gid => 200)
+    attributes.expects(:require).with("etc")
+    Etc.expects(:getgrgid).with(200).returns(mock('group', :name => "sftp"))
+    assert_equal "sftp", attributes.group
+  end
+
+  def test_type_should_infer_type_from_permissions
+    assert_equal af::T_SOCKET,       af.new(:permissions => 0140755).type
+    assert_equal af::T_SYMLINK,      af.new(:permissions => 0120755).type
+    assert_equal af::T_REGULAR,      af.new(:permissions => 0100755).type
+    assert_equal af::T_BLOCK_DEVICE, af.new(:permissions =>  060755).type
+    assert_equal af::T_DIRECTORY,    af.new(:permissions =>  040755).type
+    assert_equal af::T_CHAR_DEVICE,  af.new(:permissions =>  020755).type
+    assert_equal af::T_FIFO,         af.new(:permissions =>  010755).type
+    assert_equal af::T_UNKNOWN,      af.new(:permissions =>    0755).type
+    assert_equal af::T_UNKNOWN,      af.new.type
+  end
+
+  private
+
+    def full_buffer
+      Net::SSH::Buffer.from(:long, 0x8000000f,
+        :int64, 1234567890, :long, 100, :long, 200,
+        :long, 0755, :long, 1234567890, :long, 2345678901,
+        :long, 1, :string, "first", :string, "second")
+    end
+
+    def attributes_factory
+      Net::SFTP::Protocol::V01::Attributes
+    end
+
+    alias af attributes_factory
+end

data/test/protocol/01/test_base.rb

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