def test_pool_size_growth(create_pool, server, loop):
pool = yield from create_pool(
server.tcp_address,
loop=loop,
minsize=1, maxsize=1)
done = set()
tasks = []
@asyncio.coroutine
def task1(i):
with (yield from pool):
assert pool.size <= pool.maxsize
assert pool.freesize == 0
yield from asyncio.sleep(0.2, loop=loop)
done.add(i)
@asyncio.coroutine
def task2():
with (yield from pool):
assert pool.size <= pool.maxsize
assert pool.freesize >= 0
assert done == {0, 1}
for _ in range(2):
tasks.append(async_task(task1(_), loop=loop))
tasks.append(async_task(task2(), loop=loop))
yield from asyncio.gather(*tasks, loop=loop)
def test_finished_waiter_cancelled(loop):
lock = Lock(loop=loop)
ta = async_task(lock.acquire(), loop=loop)
yield from asyncio.sleep(0, loop=loop)
assert lock.locked()
tb = async_task(lock.acquire(), loop=loop)
yield from asyncio.sleep(0, loop=loop)
assert len(lock._waiters) == 1
# Create a second waiter, wake up the first, and cancel it.
# Without the fix, the second was not woken up and the lock
# will never be locked
async_task(lock.acquire(), loop=loop)
yield from asyncio.sleep(0, loop=loop)
lock.release()
tb.cancel()
yield from asyncio.sleep(0, loop=loop)
assert ta.done()
assert tb.cancelled()
yield from asyncio.sleep(0, loop=loop)
assert lock.locked()
def test_close_cancelled_pubsub_channel(redis, loop):
ch, = yield from redis.subscribe('chan:1')
@asyncio.coroutine
def waiter(ch):
with pytest.raises(asyncio.CancelledError):
yield from ch.wait_message()
tsk = async_task(waiter(ch), loop=loop)
yield from asyncio.sleep(0, loop=loop)
tsk.cancel()
def test_close_pubsub_patterns(redis, loop):
ch, = yield from redis.psubscribe('chan:*')
@asyncio.coroutine
def waiter(ch):
assert not (yield from ch.wait_message())
tsk = async_task(waiter(ch), loop=loop)
redis.close()
yield from redis.wait_closed()
yield from tsk
def test_publish(create_connection, redis, server, loop):
out = asyncio.Queue(loop=loop)
fut = create_future(loop=loop)
conn = yield from create_connection(server.tcp_address, loop=loop)
sub = async_task(_reader('chan:1', out, fut, conn), loop=loop)
yield from fut
yield from redis.publish('chan:1', 'Hello')
msg = yield from out.get()
assert msg == b'Hello'
sub.cancel()
def test_cancel_wait_closed(self):
# Regression test: Don't throw error if wait_closed() is cancelled.
address = ('localhost', self.redis_port)
conn = yield from self.create_connection(address, loop=self.loop)
reader_task = conn._reader_task
conn.close()
task = async_task(conn.wait_closed(), loop=self.loop)
# Make sure the task is cancelled
# after it has been started by the loop.
self.loop.call_soon(task.cancel)
yield from conn.wait_closed()
self.assertTrue(reader_task.done())
def test_publish_json(create_connection, redis, server, loop):
out = asyncio.Queue(loop=loop)
fut = create_future(loop=loop)
conn = yield from create_connection(server.tcp_address, loop=loop)
sub = async_task(_reader('chan:1', out, fut, conn), loop=loop)
yield from fut
res = yield from redis.publish_json('chan:1', {"Hello": "world"})
assert res == 1 # recievers
msg = yield from out.get()
assert msg == b'{"Hello": "world"}'
sub.cancel()
def test_cancel_wait_closed(create_connection, loop, server):
# Regression test: Don't throw error if wait_closed() is cancelled.
address = server.tcp_address
conn = yield from create_connection(address, loop=loop)
reader_task = conn._reader_task
conn.close()
task = async_task(conn.wait_closed(), loop=loop)
# Make sure the task is cancelled
# after it has been started by the loop.
loop.call_soon(task.cancel)
yield from conn.wait_closed()
assert reader_task.done()
def test_cancel_wait_closed(create_connection, loop, server):
# Regression test: Don't throw error if wait_closed() is cancelled.
address = server.tcp_address
conn = yield from create_connection(address, loop=loop)
reader_task = conn._reader_task
conn.close()
task = async_task(conn.wait_closed(), loop=loop)
# Make sure the task is cancelled
# after it has been started by the loop.
loop.call_soon(task.cancel)
yield from conn.wait_closed()
assert reader_task.done()
def test_cancel_wait_closed(self):
# Regression test: Don't throw error if wait_closed() is cancelled.
address = ('localhost', self.redis_port)
conn = yield from self.create_connection(address, loop=self.loop)
reader_task = conn._reader_task
conn.close()
task = async_task(conn.wait_closed(), loop=self.loop)
# Make sure the task is cancelled
# after it has been started by the loop.
self.loop.call_soon(task.cancel)
yield from conn.wait_closed()
self.assertTrue(reader_task.done())
def test_wait_message(create_connection, server, loop):
sub = yield from create_connection(server.tcp_address, loop=loop)
pub = yield from create_connection(server.tcp_address, loop=loop)
mpsc = Listener(loop=loop)
yield from sub.execute_pubsub('subscribe', mpsc.channel('channel:1'))
fut = async_task(mpsc.wait_message(), loop=loop)
assert not fut.done()
yield from asyncio.sleep(0, loop=loop)
assert not fut.done()
yield from pub.execute('publish', 'channel:1', 'hello')
yield from asyncio.sleep(0, loop=loop) # read in connection
yield from asyncio.sleep(0, loop=loop) # call Future.set_result
assert fut.done()
res = yield from fut
assert res is True
def test_channel_get_after_close(create_redis, loop, server):
sub = yield from create_redis(server.tcp_address, loop=loop)
pub = yield from create_redis(server.tcp_address, loop=loop)
ch, = yield from sub.subscribe('chan:1')
@asyncio.coroutine
def waiter():
while True:
msg = yield from ch.get()
if msg is None:
break
assert msg == b'message'
tsk = async_task(waiter(), loop=loop)
yield from pub.publish('chan:1', 'message')
sub.close()
yield from tsk
def test_operations(pool_or_redis, test_case, pool_size, loop):
repeat = 100
redis = yield from pool_or_redis(pool_size)
done, pending = yield from asyncio.wait(
[async_task(test_case(redis, i, loop), loop=loop)
for i in range(repeat)], loop=loop)
assert not pending
success = 0
failures = []
for fut in done:
exc = fut.exception()
if exc is None:
success += 1
else:
failures.append(exc)
assert repeat == success, failures
assert not failures
