net-sftp 2.0.5 → 3.0.0

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