net-sftp 2.1.2 → 4.0.0

data/test/test_file.rb

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

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