redcar 0.3.8.3 → 0.3.8.4

data/plugins/project/vendor/net-sftp/test/common.rb

@@ -1,171 +0,0 @@
-require 'test/unit'
-require 'mocha'
-
-begin
-  require 'net/ssh'
-  require 'net/ssh/version'
-  raise LoadError, "wrong version" unless Net::SSH::Version::STRING >= '1.99.0'
-rescue LoadError
-  begin
-    gem 'net-ssh', ">= 2.0.0"
-    require 'net/ssh'
-  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/plugins/project/vendor/net-sftp/test/protocol/01/test_attributes.rb

@@ -1,97 +0,0 @@
-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/plugins/project/vendor/net-sftp/test/protocol/01/test_base.rb

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