def test_read_exception(self):
buffer = parsers.DataQueue(loop=self.loop)
buffer.feed_data(object())
buffer.set_exception(ValueError())
self.assertRaises(ValueError, self.loop.run_until_complete,
buffer.read())
def test_exception(self):
buffer = parsers.DataQueue(loop=self.loop)
self.assertIsNone(buffer.exception())
exc = ValueError()
buffer.set_exception(exc)
self.assertIs(buffer.exception(), exc)
def test_exception_waiter(self):
stream = parsers.StreamParser()
stream._parser = self.lines_parser
buf = stream._output = parsers.DataQueue(loop=self.loop)
exc = ValueError()
stream.set_exception(exc)
self.assertIs(buf.exception(), exc)
def test_read_until_eof(self):
item = object()
buffer = parsers.DataQueue(loop=self.loop)
buffer.feed_data(item)
buffer.feed_eof()
data = self.loop.run_until_complete(buffer.read())
self.assertIs(data, item)
self.assertRaises(parsers.EofStream, self.loop.run_until_complete,
buffer.read())
def test_read_eof(self):
buffer = parsers.DataQueue(loop=self.loop)
read_task = asyncio.Task(buffer.read(), loop=self.loop)
def cb():
buffer.feed_eof()
self.loop.call_soon(cb)
self.assertRaises(parsers.EofStream, self.loop.run_until_complete,
read_task)
def test_read(self):
item = object()
buffer = parsers.DataQueue(loop=self.loop)
read_task = asyncio.Task(buffer.read(), loop=self.loop)
def cb():
buffer.feed_data(item)
self.loop.call_soon(cb)
data = self.loop.run_until_complete(read_task)
self.assertIs(item, data)
def test_exception_waiter(self):
buffer = parsers.DataQueue(loop=self.loop)
@asyncio.coroutine
def set_err():
buffer.set_exception(ValueError())
t1 = asyncio.Task(buffer.read(), loop=self.loop)
t2 = asyncio.Task(set_err(), loop=self.loop)
self.loop.run_until_complete(asyncio.wait([t1, t2], loop=self.loop))
self.assertRaises(ValueError, t1.result)
def test_read_cancelled(self):
buffer = parsers.DataQueue(loop=self.loop)
read_task = asyncio.Task(buffer.read(), loop=self.loop)
test_utils.run_briefly(self.loop)
self.assertIsInstance(buffer._waiter, asyncio.Future)
read_task.cancel()
self.assertRaises(asyncio.CancelledError, self.loop.run_until_complete,
read_task)
self.assertTrue(buffer._waiter.cancelled())
buffer.feed_data(b'test')
self.assertIsNone(buffer._waiter)
def test_stream(self):
item = object()
buffer = parsers.DataQueue(self.stream, loop=self.loop)
read_task = asyncio.Task(buffer.read(), loop=self.loop)
def cb():
buffer.feed_data(item)
self.loop.call_soon(cb)
self.loop.run_until_complete(read_task)
self.assertTrue(self.stream.resume_stream.called)
self.assertTrue(self.stream.pause_stream.called)
def test_chunks_parser(self):
out = parsers.DataQueue(loop=self.loop)
buf = self._make_one()
p = parsers.ChunksParser(5)(out, buf)
next(p)
for d in (b'line1', b'lin', b'e2d', b'ata'):
p.send(d)
self.assertEqual(
[bytearray(b'line1'), bytearray(b'line2')], list(out._buffer))
try:
p.throw(parsers.EofStream())
except parsers.EofStream:
pass
self.assertEqual(bytes(buf), b'data')
def test_lines_parser(self):
out = parsers.DataQueue(self.stream, loop=self.loop)
buf = self._make_one()
p = parsers.LinesParser()(out, buf)
next(p)
for d in (b'line1', b'\r\n', b'lin', b'e2\r', b'\ndata'):
p.send(d)
self.assertEqual([bytearray(b'line1\r\n'),
bytearray(b'line2\r\n')], list(out._buffer))
try:
p.throw(parsers.EofStream())
except parsers.EofStream:
pass
self.assertEqual(bytes(buf), b'data')
def test_feed_eof(self):
buffer = parsers.DataQueue(loop=self.loop)
buffer.feed_eof()
self.assertTrue(buffer._eof)
def test_feed_data(self):
buffer = parsers.DataQueue(loop=self.loop)
item = object()
buffer.feed_data(item)
self.assertEqual([item], list(buffer._buffer))
