def test_release_acquire(self):
pool = Pool("ws://localhost:8182/",
maxsize=2,
username="******",
password="******")
c1 = yield pool.acquire()
yield pool.release(c1)
c2 = yield pool.acquire()
self.assertEqual(c1, c2)
def test_release_acquire(self):
pool = Pool("ws://localhost:8182/",
maxsize=2,
username="******",
password="******")
c1 = yield pool.acquire()
yield pool.release(c1)
c2 = yield pool.acquire()
self.assertEqual(c1, c2)
def test_release(self):
pool = Pool("ws://localhost:8182/",
maxsize=2,
username="******",
password="******")
self.assertEqual(len(pool.pool), 0)
c1 = yield pool.acquire()
self.assertEqual(len(pool._acquired), 1)
yield pool.release(c1)
self.assertEqual(len(pool.pool), 1)
self.assertEqual(len(pool._acquired), 0)
def test_release(self):
pool = Pool("ws://localhost:8182/",
maxsize=2,
username="******",
password="******")
self.assertEqual(len(pool.pool), 0)
c1 = yield pool.acquire()
self.assertEqual(len(pool._acquired), 1)
yield pool.release(c1)
self.assertEqual(len(pool.pool), 1)
self.assertEqual(len(pool._acquired), 0)
def test_close(self):
pool = Pool("ws://localhost:8182/",
maxsize=2,
username="******",
password="******")
c1 = yield pool.acquire()
c2 = yield pool.acquire()
yield pool.release(c2)
pool.close()
self.assertTrue(c2.conn.closed)
self.assertFalse(c1.conn.closed)
c1.close()
self.assertTrue(pool.closed)
def test_self_release(self):
pool = Pool("ws://localhost:8182/",
maxsize=2,
username="******",
password="******",
force_release=True)
self.assertEqual(len(pool.pool), 0)
c1 = yield pool.acquire()
self.assertEqual(len(pool._acquired), 1)
stream = c1.send("1 + 1")
resp = yield stream.read()
self.assertEqual(len(pool.pool), 1)
self.assertEqual(len(pool._acquired), 0)
def test_maxsize(self):
pool = Pool("ws://localhost:8182/",
maxsize=2,
username="******",
password="******")
c1 = yield pool.acquire()
c2 = yield pool.acquire()
c3 = pool.acquire()
self.assertIsInstance(c3, Future)
with self.assertRaises(tornado.gen.TimeoutError):
yield gen.with_timeout(timedelta(seconds=0.1), c3)
c1.conn.close()
c2.conn.close()
def test_maxsize(self):
pool = Pool("ws://localhost:8182/",
maxsize=2,
username="******",
password="******")
c1 = yield pool.acquire()
c2 = yield pool.acquire()
c3 = pool.acquire()
self.assertIsInstance(c3, Future)
with self.assertRaises(tornado.gen.TimeoutError):
yield gen.with_timeout(timedelta(seconds=0.1), c3)
c1.conn.close()
c2.conn.close()
def test_release_closed(self):
pool = Pool("ws://localhost:8182/",
maxsize=2,
username="******",
password="******",
log_level=LOG_LEVEL)
self.assertEqual(len(pool.pool), 0)
c1 = yield pool.acquire()
self.assertEqual(len(pool._acquired), 1)
c1.close()
yield pool.release(c1)
self.assertEqual(len(pool.pool), 0)
self.assertEqual(len(pool._acquired), 0)
def test_cancelled(self):
pool = Pool("ws://localhost:8182/",
maxsize=2,
username="******",
password="******")
c1 = yield pool.acquire()
c2 = yield pool.acquire()
c3 = pool.acquire()
pool.close()
# Tornado futures do not support cancellation!
# self.assertTrue(c3.cancelled())
c1.close()
c2.close()
def test_self_release(self):
pool = Pool("ws://localhost:8182/",
maxsize=2,
username="******",
password="******",
force_release=True)
self.assertEqual(len(pool.pool), 0)
c1 = yield pool.acquire()
self.assertEqual(len(pool._acquired), 1)
stream = c1.send("1 + 1")
resp = yield stream.read()
self.assertEqual(len(pool.pool), 1)
self.assertEqual(len(pool._acquired), 0)
def test_acquire_send(self):
pool = Pool("ws://localhost:8182/",
maxsize=2,
username="******",
password="******")
connection = yield pool.acquire()
resp = connection.send("1 + 1")
while True:
msg = yield resp.read()
if msg is None:
break
self.assertEqual(msg.status_code, 200)
self.assertEqual(msg.data[0], 2)
connection.conn.close()
def test_acquire_send(self):
pool = Pool("ws://localhost:8182/",
maxsize=2,
username="******",
password="******")
connection = yield pool.acquire()
resp = connection.send("1 + 1")
while True:
msg = yield resp.read()
if msg is None:
break
self.assertEqual(msg.status_code, 200)
self.assertEqual(msg.data[0], 2)
connection.conn.close()
def test_acquire(self):
pool = Pool("ws://localhost:8182/",
maxsize=2,
username="******",
password="******",
loop=self.loop,
future_class=Future)
async def go():
connection = await pool.acquire()
conn = connection.conn
self.assertFalse(conn.closed)
self.assertIsInstance(conn, Response)
self.assertEqual(pool.size, 1)
self.assertTrue(connection in pool._acquired)
connection2 = await pool.acquire()
conn2 = connection.conn
self.assertFalse(conn2.closed)
self.assertIsInstance(conn2, Response)
self.assertEqual(pool.size, 2)
self.assertTrue(connection2 in pool._acquired)
conn.close()
conn2.close()
self.loop.run_sync(go)
def test_acquire(self):
pool = Pool(url="ws://localhost:8182/",
maxsize=2,
username="******",
password="******",
loop=self.loop,
future_class=Future)
@trollius.coroutine
def go():
connection = yield From(pool.acquire())
conn = connection.conn
self.assertFalse(conn.closed)
self.assertIsInstance(conn, Response)
self.assertEqual(pool.size, 1)
self.assertTrue(connection in pool._acquired)
connection2 = yield From(pool.acquire())
conn2 = connection.conn
self.assertFalse(conn2.closed)
self.assertIsInstance(conn2, Response)
self.assertEqual(pool.size, 2)
self.assertTrue(connection2 in pool._acquired)
conn.close()
conn2.close()
self.loop.run_until_complete(go())
def test_future_class(self):
pool = Pool(url="ws://localhost:8182/",
maxsize=2,
username="******",
password="******")
self.assertTrue(hasattr(pool, 'future_class'))
self.assertEqual(pool.future_class, Future)
async def go():
pool1 = Pool(url="ws://localhost:8182/",
maxsize=2,
username="******",
password="******",
future_class=Future)
pool2 = Pool(url="ws://localhost:8182/",
username="******",
password="******",
future_class=Future)
conn1 = await pool1.acquire()
conn2 = await pool2.acquire()
conn3 = await pool2.acquire()
conn4 = await pool2.acquire()
pool1.pool.append(conn2)
pool1.pool.append(conn3)
pool1.pool.append(conn4)
await pool1.release(conn1)
self.assertTrue(conn1.closed)
def test_acquire(self):
pool = Pool("ws://localhost:8182/",
maxsize=2,
username="******",
password="******")
connection = yield pool.acquire()
conn = connection.conn
self.assertFalse(conn.closed)
self.assertIsInstance(conn, Response)
self.assertEqual(pool.size, 1)
self.assertTrue(connection in pool._acquired)
connection2 = yield pool.acquire()
conn2 = connection2.conn
self.assertFalse(conn2.closed)
self.assertIsInstance(conn2, Response)
self.assertEqual(pool.size, 2)
self.assertTrue(connection2 in pool._acquired)
self.assertNotEqual(conn, conn2)
conn.close()
conn2.close()
def test_acquire(self):
pool = Pool("ws://localhost:8182/",
maxsize=2,
username="******",
password="******")
connection = yield pool.acquire()
conn = connection.conn
self.assertFalse(conn.closed)
self.assertIsInstance(conn, Response)
self.assertEqual(pool.size, 1)
self.assertTrue(connection in pool._acquired)
connection2 = yield pool.acquire()
conn2 = connection2.conn
self.assertFalse(conn2.closed)
self.assertIsInstance(conn2, Response)
self.assertEqual(pool.size, 2)
self.assertTrue(connection2 in pool._acquired)
self.assertNotEqual(conn, conn2)
conn.close()
conn2.close()
def test_release_acquire(self):
pool = Pool(url="ws://localhost:8182/",
maxsize=2,
username="******",
password="******",
future_class=Future)
async def go():
c1 = await pool.acquire()
await pool.release(c1)
c2 = await pool.acquire()
self.assertEqual(c1, c2)
self.loop.run_until_complete(go())
def test_release_acquire(self):
pool = Pool(url="ws://localhost:8182/",
maxsize=2,
username="******",
password="******",
future_class=Future)
@trollius.coroutine
def go():
c1 = yield From(pool.acquire())
yield From(pool.release(c1))
c2 = yield From(pool.acquire())
self.assertEqual(c1, c2)
self.loop.run_until_complete(go())
def test_pool_too_big(self):
pool1 = Pool("ws://localhost:8182/",
maxsize=2,
username="******",
password="******")
pool2 = Pool("ws://localhost:8182/",
username="******",
password="******")
conn1 = yield pool1.acquire()
conn2 = yield pool2.acquire()
conn3 = yield pool2.acquire()
conn4 = yield pool2.acquire()
pool1.pool.append(conn2)
pool1.pool.append(conn3)
pool1.pool.append(conn4)
yield pool1.release(conn1)
self.assertTrue(conn1.closed)
def test_release_closed(self):
pool = Pool(url="ws://localhost:8182/",
maxsize=2,
username="******",
password="******",
future_class=Future)
self.assertEqual(len(pool.pool), 0)
@asyncio.coroutine
def go():
c1 = yield from pool.acquire()
self.assertEqual(len(pool._acquired), 1)
c1.close()
yield from pool.release(c1)
self.assertEqual(len(pool.pool), 0)
self.assertEqual(len(pool._acquired), 0)
self.loop.run_until_complete(go())
def test_close(self):
pool = Pool(url="ws://localhost:8182/",
maxsize=2,
username="******",
password="******",
future_class=Future)
async def go():
c1 = await pool.acquire()
c2 = await pool.acquire()
await pool.release(c2)
pool.close()
self.assertTrue(c2.conn.closed)
self.assertFalse(c1.conn.closed)
c1.close()
self.loop.run_until_complete(go())
def test_cancelled(self):
pool = Pool(url="ws://localhost:8182/",
maxsize=2,
username="******",
password="******",
future_class=Future)
async def go():
c1 = await pool.acquire()
c2 = await pool.acquire()
c3 = pool.acquire()
pool.close()
self.assertTrue(c3.cancelled())
c1.close()
c2.close()
self.loop.run_until_complete(go())
def test_release_closed(self):
pool = Pool("ws://localhost:8182/",
maxsize=2,
username="******",
password="******",
future_class=Future)
self.assertEqual(len(pool.pool), 0)
async def go():
c1 = await pool.acquire()
self.assertEqual(len(pool._acquired), 1)
c1.close()
await pool.release(c1)
self.assertEqual(len(pool.pool), 0)
self.assertEqual(len(pool._acquired), 0)
self.loop.run_sync(go)
def test_release(self):
pool = Pool(url="ws://localhost:8182/",
maxsize=2,
username="******",
password="******",
loop=self.loop,
future_class=Future)
async def go():
self.assertEqual(len(pool.pool), 0)
c1 = await pool.acquire()
self.assertEqual(len(pool._acquired), 1)
await pool.release(c1)
self.assertEqual(len(pool.pool), 1)
self.assertEqual(len(pool._acquired), 0)
self.loop.run_until_complete(go())
def test_cancelled(self):
pool = Pool("ws://localhost:8182/",
maxsize=2,
username="******",
password="******",
future_class=Future)
async def go():
c1 = await pool.acquire()
c2 = await pool.acquire()
c3 = pool.acquire()
pool.close()
# Tornado futures don't support cancellation
# self.assertTrue(c3.cancelled())
c1.close()
c2.close()
self.loop.run_sync(go)
def test_close(self):
pool = Pool(url="ws://localhost:8182/",
maxsize=2,
username="******",
password="******",
future_class=Future)
@trollius.coroutine
def go():
c1 = yield From(pool.acquire())
c2 = yield From(pool.acquire())
yield From(pool.release(c2))
pool.close()
self.assertTrue(c2.conn.closed)
self.assertFalse(c1.conn.closed)
c1.close()
self.loop.run_until_complete(go())
def test_close(self):
pool = Pool("ws://localhost:8182/",
maxsize=2,
username="******",
password="******")
c1 = yield pool.acquire()
c2 = yield pool.acquire()
yield pool.release(c2)
pool.close()
self.assertTrue(c2.conn.closed)
self.assertFalse(c1.conn.closed)
c1.close()
self.assertTrue(pool.closed)
def test_cancelled(self):
pool = Pool("ws://localhost:8182/",
maxsize=2,
username="******",
password="******")
c1 = yield pool.acquire()
c2 = yield pool.acquire()
c3 = pool.acquire()
pool.close()
# Tornado futures do not support cancellation!
# self.assertTrue(c3.cancelled())
c1.close()
c2.close()
def test_maxsize(self):
pool = Pool("ws://localhost:8182/",
maxsize=2,
username="******",
password="******",
loop=self.loop,
future_class=Future)
async def go():
c1 = await pool.acquire()
c2 = await pool.acquire()
c3 = pool.acquire()
self.assertIsInstance(c3, Future)
with self.assertRaises(gen.TimeoutError):
await gen.with_timeout(timedelta(seconds=0.1), c3)
c1.conn.close()
c2.conn.close()
self.loop.run_sync(go)
def test_self_release(self):
pool = Pool(url="ws://localhost:8182/",
maxsize=2,
username="******",
password="******",
force_release=True,
future_class=Future,
loop=self.loop)
async def go():
self.assertEqual(len(pool.pool), 0)
c1 = await pool.acquire()
self.assertEqual(len(pool._acquired), 1)
stream = c1.send("1 + 1")
resp = await stream.read()
self.assertEqual(len(pool.pool), 1)
self.assertEqual(len(pool._acquired), 0)
self.loop.run_until_complete(go())
def test_maxsize(self):
pool = Pool(url="ws://localhost:8182/",
maxsize=2,
username="******",
password="******",
loop=self.loop,
future_class=Future)
async def go():
c1 = await pool.acquire()
c2 = await pool.acquire()
c3 = pool.acquire()
self.assertIsInstance(c3, Future)
with self.assertRaises(asyncio.TimeoutError):
await asyncio.wait_for(c3, 0.1)
c1.conn.close()
c2.conn.close()
self.loop.run_until_complete(go())
def go():
pool1 = Pool(
url="ws://localhost:8182/", maxsize=2, username="******", password="******", future_class=Future
)
pool2 = Pool(url="ws://localhost:8182/", username="******", password="******", future_class=Future)
conn1 = yield From(pool1.acquire())
conn2 = yield From(pool2.acquire())
conn3 = yield From(pool2.acquire())
conn4 = yield From(pool2.acquire())
pool1.pool.append(conn2)
pool1.pool.append(conn3)
pool1.pool.append(conn4)
yield From(pool1.release(conn1))
self.assertTrue(conn1.closed)
def test_acquire_send(self):
pool = Pool(url="ws://localhost:8182/",
maxsize=2,
username="******",
password="******",
loop=self.loop,
future_class=Future)
async def go():
connection = await pool.acquire()
resp = connection.send("1 + 1")
while True:
msg = await resp.read()
if msg is None:
break
self.assertEqual(msg.status_code, 200)
self.assertEqual(msg.data[0], 2)
connection.conn.close()
self.loop.run_until_complete(go())
def test_maxsize(self):
pool = Pool(url="ws://localhost:8182/",
maxsize=2,
username="******",
password="******",
loop=self.loop,
future_class=Future)
@trollius.coroutine
def go():
c1 = yield From(pool.acquire())
c2 = yield From(pool.acquire())
c3 = pool.acquire()
self.assertIsInstance(c3, Future)
with self.assertRaises(trollius.TimeoutError):
yield From(trollius.wait_for(c3, 0.1))
c1.conn.close()
c2.conn.close()
self.loop.run_until_complete(go())
def test_pool_too_big(self):
pool1 = Pool("ws://localhost:8182/",
maxsize=2,
username="******",
password="******")
pool2 = Pool("ws://localhost:8182/",
username="******",
password="******")
conn1 = yield pool1.acquire()
conn2 = yield pool2.acquire()
conn3 = yield pool2.acquire()
conn4 = yield pool2.acquire()
pool1.pool.append(conn2)
pool1.pool.append(conn3)
pool1.pool.append(conn4)
yield pool1.release(conn1)
self.assertTrue(conn1.closed)
def test_maxsize_release(self):
pool = Pool(url="ws://localhost:8182/",
maxsize=2,
username="******",
password="******",
future_class=Future)
async def go():
c1 = await pool.acquire()
c2 = await pool.acquire()
c3 = pool.acquire()
self.assertIsInstance(c3, Future)
with self.assertRaises(asyncio.TimeoutError):
shielded_fut = asyncio.shield(c3)
await asyncio.wait_for(shielded_fut, 0.1)
await pool.release(c2)
c3 = await c3
self.assertEqual(c2, c3)
c1.conn.close()
c2.conn.close()
c3.conn.close()
self.loop.run_until_complete(go())
def setUp(self):
super(TornadoCallbackStyleTest, self).setUp()
self.pool = Pool("ws://localhost:8182/")
