auser-poolparty 1.3.4 → 1.3.5

data/vendor/gems/net-ssh/test/authentication/methods/common.rb

@@ -0,0 +1,28 @@
+module Authentication; module Methods
+
+  module Common
+    include Net::SSH::Authentication::Constants
+
+    private
+
+      def socket(options={})
+        @socket ||= stub("socket", :client_name => "me.ssh.test")
+      end
+
+      def transport(options={})
+        @transport ||= MockTransport.new(options.merge(:socket => socket))
+      end
+
+      def session(options={})
+        @session ||= begin
+          sess = stub("auth-session", :logger => nil, :transport => transport(options))
+          def sess.next_message
+            transport.next_message
+          end
+          sess
+        end
+      end
+
+  end
+
+end; end

data/vendor/gems/net-ssh/test/authentication/methods/test_abstract.rb

@@ -0,0 +1,51 @@
+require 'common'
+require 'authentication/methods/common'
+require 'net/ssh/authentication/methods/abstract'
+
+module Authentication; module Methods
+
+  class TestAbstract < Test::Unit::TestCase
+    include Common
+
+    def test_constructor_should_set_defaults
+      assert_nil subject.key_manager
+    end
+
+    def test_constructor_should_honor_options
+      assert_equal :manager, subject(:key_manager => :manager).key_manager
+    end
+
+    def test_session_id_should_query_session_id_from_key_exchange
+      transport.stubs(:algorithms).returns(stub("algorithms", :session_id => "abcxyz123"))
+      assert_equal "abcxyz123", subject.session_id
+    end
+
+    def test_send_message_should_delegate_to_transport
+      transport.expects(:send_message).with("abcxyz123")
+      subject.send_message("abcxyz123")
+    end
+
+    def test_userauth_request_should_build_well_formed_userauth_packet
+      packet = subject.userauth_request("jamis", "ssh-connection", "password")
+      assert_equal "\062\0\0\0\005jamis\0\0\0\016ssh-connection\0\0\0\010password", packet.to_s
+    end
+
+    def test_userauth_request_should_translate_extra_booleans_onto_end
+      packet = subject.userauth_request("jamis", "ssh-connection", "password", true, false)
+      assert_equal "\062\0\0\0\005jamis\0\0\0\016ssh-connection\0\0\0\010password\1\0", packet.to_s
+    end
+
+    def test_userauth_request_should_translate_extra_strings_onto_end
+      packet = subject.userauth_request("jamis", "ssh-connection", "password", "foo", "bar")
+      assert_equal "\062\0\0\0\005jamis\0\0\0\016ssh-connection\0\0\0\010password\0\0\0\3foo\0\0\0\3bar", packet.to_s
+    end
+
+    private
+
+      def subject(options={})
+        @subject ||= Net::SSH::Authentication::Methods::Abstract.new(session(options), options)
+      end
+
+  end
+
+end; end

data/vendor/gems/net-ssh/test/authentication/methods/test_hostbased.rb

@@ -0,0 +1,114 @@
+require 'common'
+require 'net/ssh/authentication/methods/hostbased'
+require 'authentication/methods/common'
+
+module Authentication; module Methods
+
+  class TestHostbased < Test::Unit::TestCase
+    include Common
+
+    def test_authenticate_should_return_false_when_no_key_manager_has_been_set
+      assert_equal false, subject(:key_manager => nil).authenticate("ssh-connection", "jamis")
+    end
+
+    def test_authenticate_should_return_false_when_key_manager_has_no_keys
+      assert_equal false, subject(:keys => []).authenticate("ssh-connection", "jamis")
+    end
+
+    def test_authenticate_should_return_false_if_no_keys_can_authenticate
+      ENV.stubs(:[]).with('USER').returns(nil)
+      key_manager.expects(:sign).with(&signature_parameters(keys.first)).returns("sig-one")
+      key_manager.expects(:sign).with(&signature_parameters(keys.last)).returns("sig-two")
+
+      transport.expect do |t, packet|
+        assert_equal USERAUTH_REQUEST, packet.type
+        assert verify_userauth_request_packet(packet, keys.first)
+        assert_equal "sig-one", packet.read_string
+        t.return(USERAUTH_FAILURE, :string, "hostbased,password")
+
+        t.expect do |t2, packet2|
+          assert_equal USERAUTH_REQUEST, packet2.type
+          assert verify_userauth_request_packet(packet2, keys.last)
+          assert_equal "sig-two", packet2.read_string
+          t2.return(USERAUTH_FAILURE, :string, "hostbased,password")
+        end
+      end
+
+      assert_equal false, subject.authenticate("ssh-connection", "jamis")
+    end
+
+    def test_authenticate_should_return_true_if_any_key_can_authenticate
+      ENV.stubs(:[]).with('USER').returns(nil)
+      key_manager.expects(:sign).with(&signature_parameters(keys.first)).returns("sig-one")
+
+      transport.expect do |t, packet|
+        assert_equal USERAUTH_REQUEST, packet.type
+        assert verify_userauth_request_packet(packet, keys.first)
+        assert_equal "sig-one", packet.read_string
+        t.return(USERAUTH_SUCCESS)
+      end
+
+      assert subject.authenticate("ssh-connection", "jamis")
+    end
+
+    private
+
+      def signature_parameters(key)
+        Proc.new do |given_key, data|
+          next false unless given_key.to_blob == key.to_blob
+          buffer = Net::SSH::Buffer.new(data)
+          buffer.read_string == "abcxyz123"      && # session-id
+          buffer.read_byte   == USERAUTH_REQUEST && # type
+          verify_userauth_request_packet(buffer, key)
+        end
+      end
+
+      def verify_userauth_request_packet(packet, key)
+        packet.read_string == "jamis"          && # user-name
+        packet.read_string == "ssh-connection" && # next service
+        packet.read_string == "hostbased"      && # auth-method
+        packet.read_string == key.ssh_type     && # key type
+        packet.read_buffer.read_key.to_blob == key.to_blob && # key
+        packet.read_string == "me.ssh.test."   && # client hostname
+        packet.read_string == "jamis"             # client username
+      end
+
+      @@keys = nil
+      def keys
+        @@keys ||= [OpenSSL::PKey::RSA.new(32), OpenSSL::PKey::DSA.new(32)]
+      end
+
+      def key_manager(options={})
+        @key_manager ||= begin
+          manager = stub("key_manager")
+          manager.stubs(:each_identity).multiple_yields(*(options[:keys] || keys))
+          manager
+        end
+      end
+
+      def subject(options={})
+        options[:key_manager] = key_manager(options) unless options.key?(:key_manager)
+        @subject ||= Net::SSH::Authentication::Methods::Hostbased.new(session(options), options)
+      end
+
+      def socket(options={})
+        @socket ||= stub("socket", :client_name => "me.ssh.test")
+      end
+
+      def transport(options={})
+        @transport ||= MockTransport.new(options.merge(:socket => socket))
+      end
+
+      def session(options={})
+        @session ||= begin
+          sess = stub("auth-session", :logger => nil, :transport => transport(options))
+          def sess.next_message
+            transport.next_message
+          end
+          sess
+        end
+      end
+
+  end
+
+end; end

data/vendor/gems/net-ssh/test/authentication/methods/test_keyboard_interactive.rb

@@ -0,0 +1,98 @@
+require 'common'
+require 'net/ssh/authentication/methods/keyboard_interactive'
+require 'authentication/methods/common'
+
+module Authentication; module Methods
+
+  class TestKeyboardInteractive < Test::Unit::TestCase
+    include Common
+
+    USERAUTH_INFO_REQUEST  = 60
+    USERAUTH_INFO_RESPONSE = 61
+
+    def test_authenticate_should_be_false_when_server_does_not_support_this_method
+      transport.expect do |t,packet|
+        assert_equal USERAUTH_REQUEST, packet.type
+        assert_equal "jamis", packet.read_string
+        assert_equal "ssh-connection", packet.read_string
+        assert_equal "keyboard-interactive", packet.read_string
+        assert_equal "", packet.read_string # language tags
+        assert_equal "", packet.read_string # submethods
+
+        t.return(USERAUTH_FAILURE, :string, "password")
+      end
+
+      assert_equal false, subject.authenticate("ssh-connection", "jamis")
+    end
+
+    def test_authenticate_should_be_false_if_given_password_is_not_accepted
+      transport.expect do |t,packet|
+        assert_equal USERAUTH_REQUEST, packet.type
+        t.return(USERAUTH_INFO_REQUEST, :string, "", :string, "", :string, "", :long, 1, :string, "Password:", :bool, false)
+        t.expect do |t2,packet2|
+          assert_equal USERAUTH_INFO_RESPONSE, packet2.type
+          assert_equal 1, packet2.read_long
+          assert_equal "the-password", packet2.read_string
+          t2.return(USERAUTH_FAILURE, :string, "publickey")
+        end
+      end
+
+      assert_equal false, subject.authenticate("ssh-connection", "jamis", "the-password")
+    end
+
+    def test_authenticate_should_be_true_if_given_password_is_accepted
+      transport.expect do |t,packet|
+        assert_equal USERAUTH_REQUEST, packet.type
+        t.return(USERAUTH_INFO_REQUEST, :string, "", :string, "", :string, "", :long, 1, :string, "Password:", :bool, false)
+        t.expect do |t2,packet2|
+          assert_equal USERAUTH_INFO_RESPONSE, packet2.type
+          t2.return(USERAUTH_SUCCESS)
+        end
+      end
+
+      assert subject.authenticate("ssh-connection", "jamis", "the-password")
+    end
+
+    def test_authenticate_should_duplicate_password_as_needed_to_fill_request
+      transport.expect do |t,packet|
+        assert_equal USERAUTH_REQUEST, packet.type
+        t.return(USERAUTH_INFO_REQUEST, :string, "", :string, "", :string, "", :long, 2, :string, "Password:", :bool, false, :string, "Again:", :bool, false)
+        t.expect do |t2,packet2|
+          assert_equal USERAUTH_INFO_RESPONSE, packet2.type
+          assert_equal 2, packet2.read_long
+          assert_equal "the-password", packet2.read_string
+          assert_equal "the-password", packet2.read_string
+          t2.return(USERAUTH_SUCCESS)
+        end
+      end
+
+      assert subject.authenticate("ssh-connection", "jamis", "the-password")
+    end
+
+    def test_authenticate_should_prompt_for_input_when_password_is_not_given
+      subject.expects(:prompt).with("Name:", true).returns("name")
+      subject.expects(:prompt).with("Password:", false).returns("password")
+
+      transport.expect do |t,packet|
+        assert_equal USERAUTH_REQUEST, packet.type
+        t.return(USERAUTH_INFO_REQUEST, :string, "", :string, "", :string, "", :long, 2, :string, "Name:", :bool, true, :string, "Password:", :bool, false)
+        t.expect do |t2,packet2|
+          assert_equal USERAUTH_INFO_RESPONSE, packet2.type
+          assert_equal 2, packet2.read_long
+          assert_equal "name", packet2.read_string
+          assert_equal "password", packet2.read_string
+          t2.return(USERAUTH_SUCCESS)
+        end
+      end
+
+      assert subject.authenticate("ssh-connection", "jamis", nil)
+    end
+
+    private
+
+      def subject(options={})
+        @subject ||= Net::SSH::Authentication::Methods::KeyboardInteractive.new(session(options), options)
+      end
+  end
+
+end; end

data/vendor/gems/net-ssh/test/authentication/methods/test_password.rb

@@ -0,0 +1,50 @@
+require 'common'
+require 'net/ssh/authentication/methods/password'
+require 'authentication/methods/common'
+
+module Authentication; module Methods
+
+  class TestPassword < Test::Unit::TestCase
+    include Common
+
+    def test_authenticate_when_password_is_unacceptible_should_return_false
+      transport.expect do |t,packet|
+        assert_equal USERAUTH_REQUEST, packet.type
+        assert_equal "jamis", packet.read_string
+        assert_equal "ssh-connection", packet.read_string
+        assert_equal "password", packet.read_string
+        assert_equal false, packet.read_bool
+        assert_equal "the-password", packet.read_string
+
+        t.return(USERAUTH_FAILURE, :string, "publickey")
+      end
+
+      assert !subject.authenticate("ssh-connection", "jamis", "the-password")
+    end
+
+    def test_authenticate_when_password_is_acceptible_should_return_true
+      transport.expect do |t,packet|
+        assert_equal USERAUTH_REQUEST, packet.type
+        t.return(USERAUTH_SUCCESS)
+      end
+
+      assert subject.authenticate("ssh-connection", "jamis", "the-password")
+    end
+
+    def test_authenticate_should_return_false_if_password_change_request_is_received
+      transport.expect do |t,packet|
+        assert_equal USERAUTH_REQUEST, packet.type
+        t.return(USERAUTH_PASSWD_CHANGEREQ, :string, "Change your password:", :string, "")
+      end
+
+      assert !subject.authenticate("ssh-connection", "jamis", "the-password")
+    end
+
+    private
+
+      def subject(options={})
+        @subject ||= Net::SSH::Authentication::Methods::Password.new(session(options), options)
+      end
+  end
+
+end; end

data/vendor/gems/net-ssh/test/authentication/methods/test_publickey.rb

@@ -0,0 +1,127 @@
+require 'common'
+require 'net/ssh/authentication/methods/publickey'
+require 'authentication/methods/common'
+
+module Authentication; module Methods
+
+  class TestPublickey < Test::Unit::TestCase
+    include Common
+
+    def test_authenticate_should_return_false_when_no_key_manager_has_been_set
+      assert_equal false, subject(:key_manager => nil).authenticate("ssh-connection", "jamis")
+    end
+
+    def test_authenticate_should_return_false_when_key_manager_has_no_keys
+      assert_equal false, subject(:keys => []).authenticate("ssh-connection", "jamis")
+    end
+
+    def test_authenticate_should_return_false_if_no_keys_can_authenticate
+      transport.expect do |t, packet|
+        assert_equal USERAUTH_REQUEST, packet.type
+        assert verify_userauth_request_packet(packet, keys.first, false)
+        t.return(USERAUTH_FAILURE, :string, "hostbased,password")
+
+        t.expect do |t2, packet2|
+          assert_equal USERAUTH_REQUEST, packet2.type
+          assert verify_userauth_request_packet(packet2, keys.last, false)
+          t2.return(USERAUTH_FAILURE, :string, "hostbased,password")
+        end
+      end
+
+      assert_equal false, subject.authenticate("ssh-connection", "jamis")
+    end
+
+    def test_authenticate_should_return_false_if_signature_exchange_fails
+      key_manager.expects(:sign).with(&signature_parameters(keys.first)).returns("sig-one")
+      key_manager.expects(:sign).with(&signature_parameters(keys.last)).returns("sig-two")
+
+      transport.expect do |t, packet|
+        assert_equal USERAUTH_REQUEST, packet.type
+        assert verify_userauth_request_packet(packet, keys.first, false)
+        t.return(USERAUTH_PK_OK, :string, keys.first.ssh_type, :string, Net::SSH::Buffer.from(:key, keys.first))
+
+        t.expect do |t2,packet2|
+          assert_equal USERAUTH_REQUEST, packet2.type
+          assert verify_userauth_request_packet(packet2, keys.first, true)
+          assert_equal "sig-one", packet2.read_string
+          t2.return(USERAUTH_FAILURE, :string, "hostbased,password")
+
+          t2.expect do |t3, packet3|
+            assert_equal USERAUTH_REQUEST, packet3.type
+            assert verify_userauth_request_packet(packet3, keys.last, false)
+            t3.return(USERAUTH_PK_OK, :string, keys.last.ssh_type, :string, Net::SSH::Buffer.from(:key, keys.last))
+
+            t3.expect do |t4,packet4|
+              assert_equal USERAUTH_REQUEST, packet4.type
+              assert verify_userauth_request_packet(packet4, keys.last, true)
+              assert_equal "sig-two", packet4.read_string
+              t4.return(USERAUTH_FAILURE, :string, "hostbased,password")
+            end
+          end
+        end
+      end
+
+      assert !subject.authenticate("ssh-connection", "jamis")
+    end
+
+    def test_authenticate_should_return_true_if_any_key_can_authenticate
+      key_manager.expects(:sign).with(&signature_parameters(keys.first)).returns("sig-one")
+
+      transport.expect do |t, packet|
+        assert_equal USERAUTH_REQUEST, packet.type
+        assert verify_userauth_request_packet(packet, keys.first, false)
+        t.return(USERAUTH_PK_OK, :string, keys.first.ssh_type, :string, Net::SSH::Buffer.from(:key, keys.first))
+
+        t.expect do |t2,packet2|
+          assert_equal USERAUTH_REQUEST, packet2.type
+          assert verify_userauth_request_packet(packet2, keys.first, true)
+          assert_equal "sig-one", packet2.read_string
+          t2.return(USERAUTH_SUCCESS)
+        end
+      end
+
+      assert subject.authenticate("ssh-connection", "jamis")
+    end
+
+    private
+
+      def signature_parameters(key)
+        Proc.new do |given_key, data|
+          next false unless given_key.to_blob == key.to_blob
+          buffer = Net::SSH::Buffer.new(data)
+          buffer.read_string == "abcxyz123"      && # session-id
+          buffer.read_byte   == USERAUTH_REQUEST && # type
+          verify_userauth_request_packet(buffer, key, true)
+        end
+      end
+
+      def verify_userauth_request_packet(packet, key, has_sig)
+        packet.read_string == "jamis"          && # user-name
+        packet.read_string == "ssh-connection" && # next service
+        packet.read_string == "publickey"      && # auth-method
+        packet.read_bool   == has_sig          && # whether a signature is appended
+        packet.read_string == key.ssh_type     && # ssh key type
+        packet.read_buffer.read_key.to_blob == key.to_blob # key
+      end
+
+      @@keys = nil
+      def keys
+        @@keys ||= [OpenSSL::PKey::RSA.new(32), OpenSSL::PKey::DSA.new(32)]
+      end
+
+      def key_manager(options={})
+        @key_manager ||= begin
+          manager = stub("key_manager")
+          manager.stubs(:each_identity).multiple_yields(*(options[:keys] || keys))
+          manager
+        end
+      end
+
+      def subject(options={})
+        options[:key_manager] = key_manager(options) unless options.key?(:key_manager)
+        @subject ||= Net::SSH::Authentication::Methods::Publickey.new(session(options), options)
+      end
+
+  end
+
+end; end

data/vendor/gems/net-ssh/test/authentication/test_agent.rb

@@ -0,0 +1,205 @@
+require 'common'
+require 'net/ssh/authentication/agent'
+
+module Authentication
+
+  class TestAgent < Test::Unit::TestCase
+
+    SSH2_AGENT_REQUEST_VERSION    = 1
+    SSH2_AGENT_REQUEST_IDENTITIES = 11
+    SSH2_AGENT_IDENTITIES_ANSWER  = 12
+    SSH2_AGENT_SIGN_REQUEST       = 13
+    SSH2_AGENT_SIGN_RESPONSE      = 14
+    SSH2_AGENT_FAILURE            = 30
+    SSH2_AGENT_VERSION_RESPONSE   = 103
+
+    SSH_COM_AGENT2_FAILURE        = 102
+
+    SSH_AGENT_REQUEST_RSA_IDENTITIES = 1
+    SSH_AGENT_RSA_IDENTITIES_ANSWER  = 2
+    SSH_AGENT_FAILURE                = 5
+
+    def setup
+      @original, ENV['SSH_AUTH_SOCK'] = ENV['SSH_AUTH_SOCK'], "/path/to/ssh.agent.sock"
+    end
+
+    def teardown
+      ENV['SSH_AUTH_SOCK'] = @original
+    end
+
+    def test_connect_should_use_agent_factory_to_determine_connection_type
+      factory.expects(:open).with("/path/to/ssh.agent.sock").returns(socket)
+      agent(false).connect!
+    end
+
+    def test_connect_should_raise_error_if_connection_could_not_be_established
+      factory.expects(:open).raises(SocketError)
+      assert_raises(Net::SSH::Authentication::AgentNotAvailable) { agent(false).connect! }
+    end
+
+    def test_negotiate_should_raise_error_if_ssh2_agent_response_recieved
+      socket.expect do |s, type, buffer|
+        assert_equal SSH2_AGENT_REQUEST_VERSION, type
+        assert_equal Net::SSH::Transport::ServerVersion::PROTO_VERSION, buffer.read_string
+        s.return(SSH2_AGENT_VERSION_RESPONSE)
+      end
+      assert_raises(NotImplementedError) { agent.negotiate! }
+    end
+
+    def test_negotiate_should_raise_error_if_response_was_unexpected
+      socket.expect do |s, type, buffer|
+        assert_equal SSH2_AGENT_REQUEST_VERSION, type
+        s.return(255)
+      end
+      assert_raises(Net::SSH::Authentication::AgentError) { agent.negotiate! }
+    end
+
+    def test_negotiate_should_be_successful_with_expected_response
+      socket.expect do |s, type, buffer|
+        assert_equal SSH2_AGENT_REQUEST_VERSION, type
+        s.return(SSH_AGENT_RSA_IDENTITIES_ANSWER)
+      end
+      assert_nothing_raised { agent(:connect).negotiate! }
+    end
+
+    def test_identities_should_fail_if_SSH_AGENT_FAILURE_recieved
+      socket.expect do |s, type, buffer|
+        assert_equal SSH2_AGENT_REQUEST_IDENTITIES, type
+        s.return(SSH_AGENT_FAILURE) 
+      end
+      assert_raises(Net::SSH::Authentication::AgentError) { agent.identities }
+    end
+
+    def test_identities_should_fail_if_SSH2_AGENT_FAILURE_recieved
+      socket.expect do |s, type, buffer|
+        assert_equal SSH2_AGENT_REQUEST_IDENTITIES, type
+        s.return(SSH2_AGENT_FAILURE) 
+      end
+      assert_raises(Net::SSH::Authentication::AgentError) { agent.identities }
+    end
+
+    def test_identities_should_fail_if_SSH_COM_AGENT2_FAILURE_recieved
+      socket.expect do |s, type, buffer|
+        assert_equal SSH2_AGENT_REQUEST_IDENTITIES, type
+        s.return(SSH_COM_AGENT2_FAILURE) 
+      end
+      assert_raises(Net::SSH::Authentication::AgentError) { agent.identities }
+    end
+
+    def test_identities_should_fail_if_response_is_not_SSH2_AGENT_IDENTITIES_ANSWER
+      socket.expect do |s, type, buffer|
+        assert_equal SSH2_AGENT_REQUEST_IDENTITIES, type
+        s.return(255)
+      end
+      assert_raises(Net::SSH::Authentication::AgentError) { agent.identities }
+    end
+
+    def test_identities_should_augment_identities_with_comment_field
+      key1 = key
+      key2 = OpenSSL::PKey::DSA.new(32)
+
+      socket.expect do |s, type, buffer|
+        assert_equal SSH2_AGENT_REQUEST_IDENTITIES, type
+        s.return(SSH2_AGENT_IDENTITIES_ANSWER, :long, 2, :string, Net::SSH::Buffer.from(:key, key1), :string, "My favorite key", :string, Net::SSH::Buffer.from(:key, key2), :string, "Okay, but not the best")
+      end
+
+      result = agent.identities
+      assert_equal key1.to_blob, result.first.to_blob
+      assert_equal key2.to_blob, result.last.to_blob
+      assert_equal "My favorite key", result.first.comment
+      assert_equal "Okay, but not the best", result.last.comment
+    end
+
+    def test_close_should_close_socket
+      socket.expects(:close)
+      agent.close
+    end
+
+    def test_sign_should_fail_if_response_is_SSH_AGENT_FAILURE
+      socket.expect { |s,| s.return(SSH_AGENT_FAILURE) }
+      assert_raises(Net::SSH::Authentication::AgentError) { agent.sign(key, "hello world") }
+    end
+
+    def test_sign_should_fail_if_response_is_SSH2_AGENT_FAILURE
+      socket.expect { |s,| s.return(SSH2_AGENT_FAILURE) }
+      assert_raises(Net::SSH::Authentication::AgentError) { agent.sign(key, "hello world") }
+    end
+
+    def test_sign_should_fail_if_response_is_SSH_COM_AGENT2_FAILURE
+      socket.expect { |s,| s.return(SSH_COM_AGENT2_FAILURE) }
+      assert_raises(Net::SSH::Authentication::AgentError) { agent.sign(key, "hello world") }
+    end
+
+    def test_sign_should_fail_if_response_is_not_SSH2_AGENT_SIGN_RESPONSE
+      socket.expect { |s,| s.return(255) }
+      assert_raises(Net::SSH::Authentication::AgentError) { agent.sign(key, "hello world") }
+    end
+
+    def test_sign_should_return_signed_data_from_agent
+      socket.expect do |s,type,buffer|
+        assert_equal SSH2_AGENT_SIGN_REQUEST, type
+        assert_equal key.to_blob, Net::SSH::Buffer.new(buffer.read_string).read_key.to_blob
+        assert_equal "hello world", buffer.read_string
+        assert_equal 0, buffer.read_long
+
+        s.return(SSH2_AGENT_SIGN_RESPONSE, :string, "abcxyz123")
+      end
+
+      assert_equal "abcxyz123", agent.sign(key, "hello world")
+    end
+
+    private
+
+      class MockSocket
+        def initialize
+          @expectation = nil
+          @buffer = Net::SSH::Buffer.new
+        end
+
+        def expect(&block)
+          @expectation = block
+        end
+
+        def return(type, *args)
+          data = Net::SSH::Buffer.from(*args)
+          @buffer.append([data.length+1, type, data.to_s].pack("NCA*"))
+        end
+
+        def send(data, flags)
+          raise "got #{data.inspect} but no packet was expected" unless @expectation
+          buffer = Net::SSH::Buffer.new(data)
+          buffer.read_long # skip the length
+          type = buffer.read_byte
+          @expectation.call(self, type, buffer)
+          @expectation = nil
+        end
+
+        def read(length)
+          @buffer.read(length)
+        end
+      end
+
+      def key
+        @key ||= OpenSSL::PKey::RSA.new(32)
+      end
+
+      def socket
+        @socket ||= MockSocket.new
+      end
+
+      def factory
+        @factory ||= stub("socket factory", :open => socket)
+      end
+
+      def agent(auto=:connect)
+        @agent ||= begin
+          agent = Net::SSH::Authentication::Agent.new
+          agent.stubs(:agent_socket_factory).returns(factory)
+          agent.connect! if auto == :connect
+          agent
+        end
+      end
+
+  end
+
+end