def test_bad_request(self):
address = ('127.0.0.1', 9099)
client = Echo()
try:
result = yield client.request(address, b'Hello!')
except socket.error as e:
pass
self.assertEqual(len(client.connection_pools), 1)
def test_bad_request(self):
address = ('127.0.0.1', 9099)
client = Echo()
try:
result = yield client.request(address, b'Hello!')
except socket.error as e:
pass
self.assertEqual(len(client.connection_pools), 1)
def test_meta(self):
client = Echo()
self.assertEqual(str(client), 'Echo')
self.assertEqual(client.max_reconnect, 1)
client = Echo(max_reconnect=10)
self.assertEqual(client.max_reconnect, 10)
self.assertEqual(client.consumer_factory, EchoProtocol)
client = Echo(consumer_factory=object)
self.assertEqual(client.consumer_factory, object)
self.assertRaises(AttributeError, client._response, None, None, None,
None, None)
def test_bad_request_full_response(self):
address = ('127.0.0.1', 9099)
client = Echo(full_response=True)
def _test_bad_request():
# Run on client event loop so we test for the existing connection
result = client.request(address, b'Hello!')
self.assertTrue(result.connection)
try:
yield result.on_finished
except socket.error as e:
pass
self.assertFalse(result.connection.transport)
self.assertEqual(len(client.connection_pools), 1)
client.get_event_loop().call_soon(_test_bad_request)
def setUpClass(cls):
s = server(name=cls.__name__.lower(), bind='127.0.0.1:0')
cls.server_cfg = yield from send('arbiter', 'run', s)
cls.client = Echo(cls.server_cfg.addresses[0])
cls.green = EchoGreen(cls.server_cfg.addresses[0])
cls.msg = b''.join((b'a' for x in range(2**13)))
cls.pool = greenio.GreenPool()
async def setUpClass(cls):
s = server(name=cls.__name__.lower(),
bind='127.0.0.1:0',
backlog=1024,
concurrency=cls.concurrency)
cls.server_cfg = await send('arbiter', 'run', s)
cls.client = Echo(cls.server_cfg.addresses[0])
async def setUpClass(cls):
s = server(name=cls.__name__.lower(), bind='127.0.0.1:0')
cls.server_cfg = await send('arbiter', 'run', s)
cls.client = Echo(cls.server_cfg.addresses[0])
cls.green = EchoGreen(cls.server_cfg.addresses[0])
cls.msg = b'a'*2**13
cls.pool = greenio.GreenPool()
def test_bad_request_full_response(self):
address = ('127.0.0.1', 9099)
client = Echo(full_response=True)
def _test_bad_request():
# Run on client event loop so we test for the existing connection
result = client.request(address, b'Hello!')
self.assertTrue(result.connection)
try:
yield result.on_finished
except socket.error as e:
pass
self.assertFalse(result.connection.transport)
self.assertEqual(len(client.connection_pools), 1)
client.get_event_loop().call_soon(_test_bad_request)
def test_echo_serve(self):
loop = get_event_loop()
server = TcpServer(loop, '127.0.0.1', 0, EchoServerProtocol)
yield server.start_serving()
sock = server.sock
fn = sock.fileno()
self.assertFalse(is_socket_closed(sock))
client = Echo()
address = sock.getsockname()
result = yield client.request(address, b'Hello!')
self.assertEqual(result, b'Hello!')
self.assertEqual(server.concurrent_connections, 1)
result = yield client.request(address, b'ciao')
self.assertEqual(result, b'ciao')
self.assertEqual(server.concurrent_connections, 1)
yield server.stop_serving()
yield async_while(3, lambda: not is_socket_closed(sock))
self.assertTrue(is_socket_closed(sock))
async def test_connection_pool(self):
'''Test the connection pool. A very important test!'''
client = Echo(self.server_cfg.addresses[0], pool_size=2)
self.assertEqual(client._loop, get_event_loop())
#
self.assertEqual(client.pool.pool_size, 2)
self.assertEqual(client.pool.in_use, 0)
self.assertEqual(client.pool.available, 0)
self.assertEqual(client.sessions, 0)
self.assertEqual(client._requests_processed, 0)
#
response = await client(b'test connection')
self.assertEqual(response, b'test connection')
self.assertEqual(client.pool.in_use, 0)
self.assertEqual(client.pool.available, 1)
self.assertEqual(client.sessions, 1)
self.assertEqual(client._requests_processed, 1)
#
response = await client(b'test connection 2')
self.assertEqual(response, b'test connection 2')
self.assertEqual(client.pool.in_use, 0)
self.assertEqual(client.pool.available, 1)
self.assertEqual(client.sessions, 1)
self.assertEqual(client._requests_processed, 2)
#
result = await gather(client(b'ciao'),
client(b'pippo'),
client(b'foo'))
self.assertEqual(len(result), 3)
self.assertTrue(b'ciao' in result)
self.assertTrue(b'pippo' in result)
self.assertTrue(b'foo' in result)
self.assertEqual(client.pool.in_use, 0)
self.assertEqual(client.pool.available, 2)
self.assertEqual(client.sessions, 2)
self.assertEqual(client._requests_processed, 5)
#
# drop a connection
await run_in_loop(client._loop, self._drop_conection, client)
#
result = await gather(client(b'ciao'),
client(b'pippo'),
client(b'foo'))
self.assertEqual(len(result), 3)
self.assertEqual(client.pool.in_use, 0)
self.assertEqual(client.pool.available, 2)
self.assertEqual(client.sessions, 3)
self.assertEqual(client._requests_processed, 8)
#
await run_in_loop(client._loop, client.pool.close)
#
self.assertEqual(client.pool.in_use, 0)
self.assertEqual(client.pool.available, 0)
self.assertEqual(client.sessions, 3)
self.assertEqual(client._requests_processed, 8)
def test_start_hook(self):
proxy = yield self.spawn(start=create_echo_server(('127.0.0.1', 0)))
address = None
start = default_timer()
while not address:
info = yield send(proxy, 'info')
address = info['extra'].get('echo-address')
if default_timer() - start > 3:
break
self.assertTrue(address)
echo = Echo().client(address)
result = yield echo(b'Hello')
self.assertEqual(result, b'Hello')
yield self.stop_actors(proxy)
def test_event_loop(self):
client = Echo()
self.assertFalse(client.event_loop)
self.assertTrue(client.get_event_loop())
self.assertEqual(client.get_event_loop(), get_event_loop())
async def test_connection(self):
client = Echo(self.server_cfg.addresses[0], full_response=True)
response = await client(b'test connection')
self.assertEqual(response.buffer, b'test connection')
connection = response.connection
self.assertTrue(str(connection))
def sync_client(self):
return Echo(self.server_cfg.addresses[0], loop=new_event_loop())
def test_event_loop(self):
client = Echo()
self.assertFalse(client.event_loop)
self.assertTrue(client.get_event_loop())
self.assertEqual(client.get_event_loop(), get_event_loop())
def test_has_event_loop(self):
loop = get_event_loop()
client = Echo(event_loop=loop)
self.assertTrue(client.event_loop)
self.assertEqual(client.event_loop, loop)
self.assertEqual(client.get_event_loop(), loop)
def test_has_event_loop(self):
loop = get_event_loop()
client = Echo(event_loop=loop)
self.assertTrue(client.event_loop)
self.assertEqual(client.event_loop, loop)
self.assertEqual(client.get_event_loop(), loop)
def client(self, **params):
return Echo(**params)
def setUpClass(cls):
s = server(name=cls.__name__.lower(),
bind='127.0.0.1:0',
concurrency=get_actor().cfg.concurrency)
cls.server = yield pulsar.send('arbiter', 'run', s)
cls.client = Echo(force_sync=True)
async def setUpClass(cls):
await run_test_server(cls, server)
cls.client = Echo(cls.app_cfg.addresses[0])
