def test_getter_already_done(self):
channel = Channel(2, loop=self.loop)
@asyncio.coroutine
def test_done_first_then_put():
yield from asyncio.sleep(0.01, loop=self.loop)
channel.put_nowait("foo")
channel.put_nowait("foo")
self.rucgather(channel.get(), channel.get(), test_done_first_then_put())
def test_getter_already_done(self):
channel = Channel(2, loop=self.loop)
@asyncio.coroutine
def test_done_first_then_put():
yield from asyncio.sleep(0.01, loop=self.loop)
channel.put_nowait("foo")
channel.put_nowait("foo")
self.rucgather(channel.get(), channel.get(),
test_done_first_then_put())
def test_join(self):
"""
Test that a channel is joinable (when closed, and queue empty)
"""
channel = Channel(1000, loop=self.loop)
[channel.put_nowait(i) for i in range(1000)]
self.assertTrue(channel.full())
# create 1000 gets, should complete the queue
gets = [channel.get() for _ in range(1000)]
@asyncio.coroutine
def runner():
# sleep a bit, then call 1000 gets on channel, calling channel.close() in the middle
yield from asyncio.sleep(0.01, loop=self.loop)
n = 0
for c in gets:
n += 1
if n == 500:
channel.close()
yield from c
@asyncio.coroutine
def test():
self.loop.create_task(runner()) # run the getters in the backgrund
yield from asyncio.wait_for(channel.join(),
timeout=2,
loop=self.loop)
self.ruc(test())
async def request(self,
srv,
method,
*params,
req_id=None,
timeout=DEFAULT_TIMEOUT_SECS):
if not self.connected:
raise ConnectionError('websocket closed')
method = srv + '::' + method
if not req_id:
req_id = uuid.uuid4().hex
payload = {
'jsonrpc': '2.0',
'id': req_id,
'method': method,
'params': params
}
channel = Channel(1)
self.waiters[req_id] = channel
try:
await self.ws.send_json(payload)
r = await asyncio.wait_for(channel.get(), timeout=timeout)
return r
except ChannelClosed:
raise ConnectionError('websocket closed on sending req')
finally:
channel.close()
def test_join(self):
"""
Test that a channel is joinable (when closed, and queue empty)
"""
channel = Channel(1000, loop=self.loop)
[channel.put_nowait(i) for i in range(1000)]
self.assertTrue(channel.full())
# create 1000 gets, should complete the queue
gets = [channel.get() for _ in range(1000)]
@asyncio.coroutine
def runner():
# sleep a bit, then call 1000 gets on channel, calling channel.close() in the middle
yield from asyncio.sleep(0.01, loop=self.loop)
n = 0
for c in gets:
n += 1
if n == 500:
channel.close()
yield from c
@asyncio.coroutine
def test():
self.loop.create_task(runner()) # run the getters in the backgrund
yield from asyncio.wait_for(channel.join(), timeout=2, loop=self.loop)
self.ruc(test())
def test_get_throws_channel_closed(self):
"""
Test that even though a blocking .get() is pending
on an empty queue, a close() to that queue will make
the .get() throw a ChannelClosed error
"""
channel = Channel(1, loop=self.loop)
@asyncio.coroutine
def wait_close():
yield from asyncio.sleep(0.01, loop=self.loop)
channel.close()
(get_return, _) = self.rucgather(channel.get(), wait_close(), return_exceptions=True)
self.assertIsInstance(get_return, ChannelClosed)
def test_put_get(self):
"""
Simple put/get test
"""
testitem = {"foo": "bar"}
channel = Channel(1, loop=self.loop)
self.ruc(channel.put(testitem))
self.assertEqual(channel.qsize(), 1)
self.assertTrue(channel.full())
self.assertFalse(channel.empty())
item = self.ruc(channel.get())
self.assertEqual(item, testitem)
self.assertEqual(channel.qsize(), 0)
self.assertFalse(channel.full())
self.assertTrue(channel.empty())
def test_get_throws_channel_closed(self):
"""
Test that even though a blocking .get() is pending
on an empty queue, a close() to that queue will make
the .get() throw a ChannelClosed error
"""
channel = Channel(1, loop=self.loop)
@asyncio.coroutine
def wait_close():
yield from asyncio.sleep(0.01, loop=self.loop)
channel.close()
(get_return, _) = self.rucgather(channel.get(),
wait_close(),
return_exceptions=True)
self.assertIsInstance(get_return, ChannelClosed)
def test_put_get(self):
"""
Simple put/get test
"""
testitem = {"foo": "bar"}
channel = Channel(1, loop=self.loop)
self.ruc(channel.put(testitem))
self.assertEqual(channel.qsize(), 1)
self.assertTrue(channel.full())
self.assertFalse(channel.empty())
item = self.ruc(channel.get())
self.assertEqual(item, testitem)
self.assertEqual(channel.qsize(), 0)
self.assertFalse(channel.full())
self.assertTrue(channel.empty())
def test_multiple_blocking_gets(self):
"""
Test that a channel with multiple running get() still works
out fine when the channel is closed
"""
channel = Channel(1, loop=self.loop)
@asyncio.coroutine
def wait_close():
yield from asyncio.sleep(0.01, loop=self.loop)
channel.close()
futures = [channel.get() for _ in range(100)]
futures.insert(50, wait_close())
result = self.rucgather(*futures, return_exceptions=True)
result.pop(50) # pop the result for wait_close()
for res in result:
self.assertIsInstance(res, ChannelClosed)
def test_multiple_blocking_gets(self):
"""
Test that a channel with multiple running get() still works
out fine when the channel is closed
"""
channel = Channel(1, loop=self.loop)
@asyncio.coroutine
def wait_close():
yield from asyncio.sleep(0.01, loop=self.loop)
channel.close()
futures = [channel.get() for _ in range(100)]
futures.insert(50, wait_close())
result = self.rucgather(*futures, return_exceptions=True)
result.pop(50) # pop the result for wait_close()
for res in result:
self.assertIsInstance(res, ChannelClosed)
