eventlet/tests/convenience_test.py

   1 import os
   2
   3 import eventlet
   4 from eventlet import debug, event
   5 from eventlet.green import socket
   6 from eventlet.support import six
   7 from tests import LimitedTestCase, skip_if_no_ssl
   8
   9
  10 certificate_file = os.path.join(os.path.dirname(__file__), 'test_server.crt')
  11 private_key_file = os.path.join(os.path.dirname(__file__), 'test_server.key')
  12
  13
  14 class TestServe(LimitedTestCase):
  15     def setUp(self):
  16         super(TestServe, self).setUp()
  17         debug.hub_exceptions(False)
  18
  19     def tearDown(self):
  20         super(TestServe, self).tearDown()
  21         debug.hub_exceptions(True)
  22
  23     def test_exiting_server(self):
  24         # tests that the server closes the client sock on handle() exit
  25         def closer(sock, addr):
  26             pass
  27
  28         l = eventlet.listen(('localhost', 0))
  29         gt = eventlet.spawn(eventlet.serve, l, closer)
  30         client = eventlet.connect(('localhost', l.getsockname()[1]))
  31         client.sendall(b'a')
  32         self.assertFalse(client.recv(100))
  33         gt.kill()
  34
  35     def test_excepting_server(self):
  36         # tests that the server closes the client sock on handle() exception
  37         def crasher(sock, addr):
  38             sock.recv(1024)
  39             0 // 0
  40
  41         l = eventlet.listen(('localhost', 0))
  42         gt = eventlet.spawn(eventlet.serve, l, crasher)
  43         client = eventlet.connect(('localhost', l.getsockname()[1]))
  44         client.sendall(b'a')
  45         self.assertRaises(ZeroDivisionError, gt.wait)
  46         self.assertFalse(client.recv(100))
  47
  48     def test_excepting_server_already_closed(self):
  49         # same as above but with explicit clsoe before crash
  50         def crasher(sock, addr):
  51             sock.recv(1024)
  52             sock.close()
  53             0 // 0
  54
  55         l = eventlet.listen(('localhost', 0))
  56         gt = eventlet.spawn(eventlet.serve, l, crasher)
  57         client = eventlet.connect(('localhost', l.getsockname()[1]))
  58         client.sendall(b'a')
  59         self.assertRaises(ZeroDivisionError, gt.wait)
  60         self.assertFalse(client.recv(100))
  61
  62     def test_called_for_each_connection(self):
  63         hits = [0]
  64
  65         def counter(sock, addr):
  66             hits[0] += 1
  67         l = eventlet.listen(('localhost', 0))
  68         gt = eventlet.spawn(eventlet.serve, l, counter)
  69         for i in six.moves.range(100):
  70             client = eventlet.connect(('localhost', l.getsockname()[1]))
  71             self.assertFalse(client.recv(100))
  72         gt.kill()
  73         self.assertEqual(100, hits[0])
  74
  75     def test_blocking(self):
  76         l = eventlet.listen(('localhost', 0))
  77         x = eventlet.with_timeout(
  78             0.01,
  79             eventlet.serve, l, lambda c, a: None,
  80             timeout_value="timeout")
  81         self.assertEqual(x, "timeout")
  82
  83     def test_raising_stopserve(self):
  84         def stopit(conn, addr):
  85             raise eventlet.StopServe()
  86         l = eventlet.listen(('localhost', 0))
  87         # connect to trigger a call to stopit
  88         gt = eventlet.spawn(eventlet.connect, ('localhost', l.getsockname()[1]))
  89         eventlet.serve(l, stopit)
  90         gt.wait()
  91
  92     def test_concurrency(self):
  93         evt = event.Event()
  94
  95         def waiter(sock, addr):
  96             sock.sendall(b'hi')
  97             evt.wait()
  98         l = eventlet.listen(('localhost', 0))
  99         eventlet.spawn(eventlet.serve, l, waiter, 5)
 100
 101         def test_client():
 102             c = eventlet.connect(('localhost', l.getsockname()[1]))
 103             # verify the client is connected by getting data
 104             self.assertEqual(b'hi', c.recv(2))
 105             return c
 106         [test_client() for i in range(5)]
 107         # very next client should not get anything
 108         x = eventlet.with_timeout(
 109             0.01,
 110             test_client,
 111             timeout_value="timed out")
 112         self.assertEqual(x, "timed out")
 113
 114     @skip_if_no_ssl
 115     def test_wrap_ssl(self):
 116         server = eventlet.wrap_ssl(
 117             eventlet.listen(('localhost', 0)),
 118             certfile=certificate_file, keyfile=private_key_file,
 119             server_side=True)
 120         port = server.getsockname()[1]
 121
 122         def handle(sock, addr):
 123             sock.sendall(sock.recv(1024))
 124             raise eventlet.StopServe()
 125
 126         eventlet.spawn(eventlet.serve, server, handle)
 127         client = eventlet.wrap_ssl(eventlet.connect(('localhost', port)))
 128         client.sendall(b"echo")
 129         self.assertEqual(b"echo", client.recv(1024))
 130
 131     def test_socket_reuse(self):
 132         lsock1 = eventlet.listen(('localhost', 0))
 133         port = lsock1.getsockname()[1]
 134
 135         def same_socket():
 136             return eventlet.listen(('localhost', port))
 137
 138         self.assertRaises(socket.error, same_socket)
 139         lsock1.close()
 140         assert same_socket()