def _test_complete_exchange(self, client_handshaker_class,
client_failure=False, server_failure=False):
tcli = StringTransport()
tsrv = StringTransport()
p_cli = TestHandshakeProtocol()
p_srv = TestHandshakeProtocol()
now = time.time()
hs_cli = client_handshaker_class(p_cli, now - 0.001, is_client=True)
hs_srv = CryptoHandshaker(p_srv, now - 0.042)
p_srv.init_handler(hs_srv.gen_handler())
p_cli.init_handler(hs_cli.gen_handler(), do_init=False)
p_srv.makeConnection(tsrv)
self.assertEquals(tsrv.value(), '')
p_cli.makeConnection(tcli)
self.assertEquals(tcli.value(), '')
p_cli.init_handler()
# self.assertEquals(len(tcli.value()), 1 + 1536)
err = p_srv.dataReceived(tcli.value())
tcli.clear()
# self.assertEquals(len(tsrv.value()), 1 + 1536 + 1536)
self.assertIdentical(err, None)
self.assertEquals(p_cli.handshake_status, None)
err = p_cli.dataReceived(tsrv.value() + '\x00')
tsrv.clear()
if client_failure:
self.assertIsInstance(err, failure.Failure)
self.assertIsInstance(err.value, HandshakeFailedError)
self.assertFalse(tcli.disconnecting, 'should not be disconnecting')
self.assertEquals(p_cli.handshake_status, 'fail')
self.assertEquals(p_srv.handshake_status, None)
else:
self.assertIdentical(err, None)
self.assertFalse(tcli.disconnecting, 'disconnecting')
self.assertEquals(p_cli.handshake_status, 'ok')
self.assertEquals(p_srv.handshake_status, None)
err = p_srv.dataReceived(tcli.value() + '\x00')
tcli.clear()
if server_failure:
self.assertIsInstance(err, failure.Failure)
self.assertIsInstance(err.value, HandshakeFailedError)
self.assertFalse(tsrv.disconnecting, 'should not be disconnecting')
self.assertEquals(p_srv.handshake_status, 'fail')
else:
self.assertIdentical(err, None)
self.assertFalse(tsrv.disconnecting, 'disconnecting')
self.assertEquals(p_srv.handshake_status, 'ok')
def _test_complete_exchange(self,
client_handshaker_class,
client_failure=False,
server_failure=False):
tcli = StringTransport()
tsrv = StringTransport()
p_cli = TestHandshakeProtocol()
p_srv = TestHandshakeProtocol()
now = time.time()
hs_cli = client_handshaker_class(p_cli, now - 0.001, is_client=True)
hs_srv = CryptoHandshaker(p_srv, now - 0.042)
p_srv.init_handler(hs_srv.gen_handler())
p_cli.init_handler(hs_cli.gen_handler(), do_init=False)
p_srv.makeConnection(tsrv)
self.assertEquals(tsrv.value(), '')
p_cli.makeConnection(tcli)
self.assertEquals(tcli.value(), '')
p_cli.init_handler()
# self.assertEquals(len(tcli.value()), 1 + 1536)
err = p_srv.dataReceived(tcli.value())
tcli.clear()
# self.assertEquals(len(tsrv.value()), 1 + 1536 + 1536)
self.assertIdentical(err, None)
self.assertEquals(p_cli.handshake_status, None)
err = p_cli.dataReceived(tsrv.value() + '\x00')
tsrv.clear()
if client_failure:
self.assertIsInstance(err, failure.Failure)
self.assertIsInstance(err.value, HandshakeFailedError)
self.assertFalse(tcli.disconnecting, 'should not be disconnecting')
self.assertEquals(p_cli.handshake_status, 'fail')
self.assertEquals(p_srv.handshake_status, None)
else:
self.assertIdentical(err, None)
self.assertFalse(tcli.disconnecting, 'disconnecting')
self.assertEquals(p_cli.handshake_status, 'ok')
self.assertEquals(p_srv.handshake_status, None)
err = p_srv.dataReceived(tcli.value() + '\x00')
tcli.clear()
if server_failure:
self.assertIsInstance(err, failure.Failure)
self.assertIsInstance(err.value, HandshakeFailedError)
self.assertFalse(tsrv.disconnecting, 'should not be disconnecting')
self.assertEquals(p_srv.handshake_status, 'fail')
else:
self.assertIdentical(err, None)
self.assertFalse(tsrv.disconnecting, 'disconnecting')
self.assertEquals(p_srv.handshake_status, 'ok')
def test_complete_exchange_plus(self):
# almost exactly the same test as above except writing some
# additional (garbage) data immediately (as in the same
# "socket.read()") after the handshake data
tcli = StringTransport()
tsrv = StringTransport()
p_cli = TestHandshakeProtocol()
p_srv = TestHandshakeProtocol()
now = time.time()
hs_cli = Handshaker(p_cli, now - 0.001, is_client=True)
hs_srv = Handshaker(p_srv, now - 0.042)
p_srv.init_handler(hs_srv.gen_handler())
p_cli.init_handler(hs_cli.gen_handler(), do_init=False)
p_srv.makeConnection(tsrv)
self.assertEquals(tsrv.value(), '')
p_cli.makeConnection(tcli)
self.assertEquals(tcli.value(), '')
p_cli.init_handler()
# self.assertEquals(len(tcli.value()), 1 + 1536)
err = p_srv.dataReceived(tcli.value())
tcli.clear()
# self.assertEquals(len(tsrv.value()), 1 + 1536 + 1536)
self.assertIdentical(err, None)
self.assertEquals(p_cli.handshake_status, None)
err = p_cli.dataReceived(tsrv.value() + '\x00')
tsrv.clear()
self.assertIdentical(err, None)
self.assertEquals(p_cli.handshake_status, 'ok')
self.assertEquals(p_srv.handshake_status, None)
err = p_srv.dataReceived(tcli.value() + '\x00')
tcli.clear()
self.assertIdentical(err, None)
self.assertFalse(tsrv.disconnecting, 'disconnecting')
self.assertFalse(tcli.disconnecting, 'disconnecting')
self.assertEquals(p_srv.handshake_status, 'ok')
def test_complete_exchange_plus(self):
# almost exactly the same test as above except writing some
# additional (garbage) data immediately (as in the same
# "socket.read()") after the handshake data
tcli = StringTransport()
tsrv = StringTransport()
p_cli = TestHandshakeProtocol()
p_srv = TestHandshakeProtocol()
now = time.time()
hs_cli = Handshaker(p_cli, now - 0.001, is_client=True)
hs_srv = Handshaker(p_srv, now - 0.042)
p_srv.init_handler(hs_srv.gen_handler())
p_cli.init_handler(hs_cli.gen_handler(), do_init=False)
p_srv.makeConnection(tsrv)
self.assertEquals(tsrv.value(), '')
p_cli.makeConnection(tcli)
self.assertEquals(tcli.value(), '')
p_cli.init_handler()
# self.assertEquals(len(tcli.value()), 1 + 1536)
err = p_srv.dataReceived(tcli.value())
tcli.clear()
# self.assertEquals(len(tsrv.value()), 1 + 1536 + 1536)
self.assertIdentical(err, None)
self.assertEquals(p_cli.handshake_status, None)
err = p_cli.dataReceived(tsrv.value() + '\x00')
tsrv.clear()
self.assertIdentical(err, None)
self.assertEquals(p_cli.handshake_status, 'ok')
self.assertEquals(p_srv.handshake_status, None)
err = p_srv.dataReceived(tcli.value() + '\x00')
tcli.clear()
self.assertIdentical(err, None)
self.assertFalse(tsrv.disconnecting, 'disconnecting')
self.assertFalse(tcli.disconnecting, 'disconnecting')
self.assertEquals(p_srv.handshake_status, 'ok')
def test_complete_exchange(self):
tcli = StringTransport()
tsrv = StringTransport()
p_cli = TestHandshakeProtocol()
p_srv = TestHandshakeProtocol()
now = time.time()
hs_cli = Handshaker(p_cli, now - 0.001, is_client=True)
hs_srv = Handshaker(p_srv, now - 0.042)
p_srv.init_handler(hs_srv.gen_handler())
p_cli.init_handler(hs_cli.gen_handler(), do_init=False)
p_srv.makeConnection(tsrv)
self.assertEquals(tsrv.value(), '')
p_cli.makeConnection(tcli)
self.assertEquals(tcli.value(), '')
p_cli.init_handler()
# self.assertEquals(len(tcli.value()), 1 + 1536)
err = p_srv.dataReceived(tcli.value())
tcli.clear()
# self.assertEquals(len(tsrv.value()), 1 + 1536 + 1536)
self.assertIdentical(err, None)
self.assertEquals(p_cli.handshake_status, None)
err = p_cli.dataReceived(tsrv.value())
tsrv.clear()
self.assertIdentical(err, None)
self.assertEquals(p_cli.handshake_status, 'ok')
self.assertEquals(p_srv.handshake_status, None)
err = p_srv.dataReceived(tcli.value())
tcli.clear()
self.assertIdentical(err, None)
self.assertFalse(tsrv.disconnecting, 'disconnecting')
self.assertFalse(tcli.disconnecting, 'disconnecting')
self.assertEquals(p_srv.handshake_status, 'ok')
def test_complete_exchange(self):
tcli = StringTransport()
tsrv = StringTransport()
p_cli = TestHandshakeProtocol()
p_srv = TestHandshakeProtocol()
now = time.time()
hs_cli = Handshaker(p_cli, now - 0.001, is_client=True)
hs_srv = Handshaker(p_srv, now - 0.042)
p_srv.init_handler(hs_srv.gen_handler())
p_cli.init_handler(hs_cli.gen_handler(), do_init=False)
p_srv.makeConnection(tsrv)
self.assertEquals(tsrv.value(), '')
p_cli.makeConnection(tcli)
self.assertEquals(tcli.value(), '')
p_cli.init_handler()
# self.assertEquals(len(tcli.value()), 1 + 1536)
err = p_srv.dataReceived(tcli.value())
tcli.clear()
# self.assertEquals(len(tsrv.value()), 1 + 1536 + 1536)
self.assertIdentical(err, None)
self.assertEquals(p_cli.handshake_status, None)
err = p_cli.dataReceived(tsrv.value())
tsrv.clear()
self.assertIdentical(err, None)
self.assertEquals(p_cli.handshake_status, 'ok')
self.assertEquals(p_srv.handshake_status, None)
err = p_srv.dataReceived(tcli.value())
tcli.clear()
self.assertIdentical(err, None)
self.assertFalse(tsrv.disconnecting, 'disconnecting')
self.assertFalse(tcli.disconnecting, 'disconnecting')
self.assertEquals(p_srv.handshake_status, 'ok')
