def test_parse(self):
ret1, buf1 = Flag.parse(br'MyFlag \Seen ', Params())
self.assertEqual(b'MyFlag', ret1.value)
self.assertEqual(br' \Seen ', buf1)
ret2, buf2 = Flag.parse(buf1, Params())
self.assertEqual(br'\Seen', ret2.value)
self.assertEqual(b' ', buf2)
def test_parse_failure(self):
with self.assertRaises(NotParseable):
ListP.parse(b'{}', Params())
with self.assertRaises(NotParseable):
ListP.parse(b'("one"TWO)', Params(list_expected=[Atom, String]))
with self.assertRaises(NotParseable):
ListP.parse(b'(123 abc 456)', Params(list_expected=[Number]))
def test_parse_empty(self):
ret, buf = ExtensionOptions.parse(b'()', Params())
self.assertEqual({}, ret.value)
self.assertEqual(b'', buf)
ret, buf = ExtensionOptions.parse(b'', Params())
self.assertEqual({}, ret.value)
self.assertEqual(b'', buf)
def test_parse_prepared(self):
prepared1 = MagicMock(PreparedMessage)
prepared2 = MagicMock(PreparedMessage)
state = ParsingState(
continuations=[v(b'test test! {14}\n'),
v(b'second message\n ')],
prepared_messages=[])
with self.assertRaises(ParsingInterrupt) as raised:
AppendCommand.parse(b' inbox {10}\n', Params(state))
expected = raised.exception.expected
self.assertIsInstance(expected, ExpectPreparedMessage)
self.assertEqual('INBOX', expected.mailbox)
self.assertEqual(b'test test!', expected.message.literal)
self.assertFalse(expected.message.flag_set)
state = ParsingState(
continuations=[v(b'test test! {14}\n'),
v(b'second message\n ')],
prepared_messages=[prepared1])
with self.assertRaises(ParsingInterrupt) as raised:
AppendCommand.parse(b' inbox {10}\n', Params(state))
expected = raised.exception.expected
self.assertIsInstance(expected, ExpectPreparedMessage)
self.assertEqual('INBOX', expected.mailbox)
self.assertEqual(b'second message', expected.message.literal)
self.assertFalse(expected.message.flag_set)
state = ParsingState(
continuations=[v(b'test test! {14}\n'),
v(b'second message\n ')],
prepared_messages=[prepared1, prepared2])
ret, buf = AppendCommand.parse(b' inbox {10}\n', Params(state))
self.assertIsInstance(ret, AppendCommand)
self.assertEqual('INBOX', ret.mailbox)
self.assertEqual([prepared1, prepared2], ret.messages)
self.assertEqual(b' ', buf)
def test_parse_error(self):
with self.assertRaises(NotParseable):
SequenceSet.parse(b'*,test', Params())
with self.assertRaises(NotParseable):
SequenceSet.parse(b'*:test', Params())
with self.assertRaises(NotParseable):
SequenceSet.parse(b'', Params())
with self.assertRaises(NotParseable):
SequenceSet.parse(b'0:*', Params())
def test_parse_simple(self):
ret1, _ = FetchAttribute.parse(b'ENVELOPE', Params())
self.assertEqual(b'ENVELOPE', ret1.value)
self.assertIsNone(ret1.section)
self.assertIsNone(ret1.partial)
ret2, _ = FetchAttribute.parse(b'BODY', Params())
self.assertEqual(b'BODY', ret2.value)
self.assertIsNone(ret2.section)
self.assertIsNone(ret2.partial)
def test_quoted_parse_failure(self):
with self.assertRaises(NotParseable):
String.parse(b'test', Params())
with self.assertRaises(NotParseable):
String.parse(b'"one\r\ntwo"', Params())
with self.assertRaises(NotParseable):
String.parse(br'"one\ two"', Params())
with self.assertRaises(NotParseable):
String.parse(b'"test', Params())
def test_parse(self):
nil, _ = ExpectedParseable.parse(b'nil', Params(expected=[Nil]))
self.assertIsInstance(nil, Nil)
num, _ = ExpectedParseable.parse(b'123', Params(expected=[Number]))
self.assertIsInstance(num, Number)
atom, _ = ExpectedParseable.parse(b'ATOM', Params(expected=[Atom]))
self.assertIsInstance(atom, Atom)
qstr, _ = ExpectedParseable.parse(b'"test"', Params(expected=[String]))
self.assertIsInstance(qstr, QuotedString)
list_, _ = ExpectedParseable.parse(b'()', Params(expected=[ListP]))
self.assertIsInstance(list_, ListP)
def test_parse_list(self):
ret, buf = FetchCommand.parse(b' 1,2,3 (FLAGS ENVELOPE)\n ', Params())
self.assertEqual([1, 2, 3], ret.sequence_set.value)
self.assertListEqual(
[FetchAttribute(b'FLAGS'),
FetchAttribute(b'ENVELOPE')], ret.attributes)
self.assertEqual(b' ', buf)
def test_parse(self):
ret, buf = CopyCommand.parse(b' 1,2,3 mbx\n ', Params())
self.assertFalse(ret.uid)
self.assertFalse(ret.sequence_set.uid)
self.assertEqual([1, 2, 3], ret.sequence_set.value)
self.assertEqual('mbx', ret.mailbox)
self.assertEqual(b' ', buf)
def test_parse_simple(self):
ret, buf = StoreCommand.parse(b' 1,2,3 FLAGS \\Seen\n ', Params())
self.assertEqual([1, 2, 3], ret.sequence_set.value)
self.assertSetEqual({Flag(br'\Seen')}, ret.flag_set)
self.assertEqual(FlagOp.REPLACE, ret.mode)
self.assertFalse(ret.silent)
self.assertEqual(b' ', buf)
def test_literal_parse(self):
state = ParsingState(continuations=[v(b'test\x01abc')])
ret, buf = String.parse(b'{5}\r\n', Params(state))
self.assertIsInstance(ret, LiteralString)
self.assertEqual(b'test\x01', ret.value)
self.assertFalse(ret.binary)
self.assertEqual(b'abc', buf)
def test_literal_binary(self):
state = ParsingState(continuations=[v(b'\x00\x01\02abc')])
ret, buf = String.parse(b'~{3}\r\n', Params(state))
self.assertIsInstance(ret, LiteralString)
self.assertEqual(b'\x00\x01\x02', ret.value)
self.assertTrue(ret.binary)
self.assertEqual(b'abc', buf)
def test_parse(self):
ret, buf = FetchCommand.parse(b' 1,2,3 ENVELOPE\n ', Params())
self.assertFalse(ret.uid)
self.assertFalse(ret.sequence_set.uid)
self.assertEqual([1, 2, 3], ret.sequence_set.value)
self.assertEqual(1, len(ret.attributes))
self.assertListEqual([FetchAttribute(b'ENVELOPE')], ret.attributes)
self.assertEqual(b' ', buf)
def test_parse(self):
ret, buf = FetchAttribute.parse(
b'body.peek[1.2.HEADER.FIELDS (A B)]<4.5> ', Params())
self.assertEqual(b'BODY.PEEK', ret.value)
self.assertEqual([1, 2], ret.section.parts)
self.assertEqual(b'HEADER.FIELDS', ret.section.specifier)
self.assertEqual({b'A', b'B'}, ret.section.headers)
self.assertEqual((4, 5), ret.partial)
self.assertEqual(b' ', buf)
def test_parse_macro_fast(self):
ret, buf = FetchCommand.parse(b' 1,2,3 FAST\n ', Params())
self.assertEqual([1, 2, 3], ret.sequence_set.value)
self.assertListEqual([
FetchAttribute(b'FLAGS'),
FetchAttribute(b'INTERNALDATE'),
FetchAttribute(b'RFC822.SIZE')
], ret.attributes)
self.assertEqual(b' ', buf)
def test_parse(self):
ret, buf = StatusCommand.parse(b' mbx (MESSAGES UNSEEN)\n ', Params())
self.assertEqual('mbx', ret.mailbox)
self.assertEqual(2, len(ret.status_list))
self.assertIsInstance(ret.status_list[0], StatusAttribute)
self.assertEqual(b'MESSAGES', ret.status_list[0].value)
self.assertIsInstance(ret.status_list[1], StatusAttribute)
self.assertEqual(b'UNSEEN', ret.status_list[1].value)
self.assertEqual(b' ', buf)
def test_parse(self):
ret, buf = StoreCommand.parse(b' 1,2,3 +FLAGS.SILENT (\\Seen)\n ',
Params())
self.assertFalse(ret.uid)
self.assertFalse(ret.sequence_set.uid)
self.assertEqual([1, 2, 3], ret.sequence_set.value)
self.assertSetEqual({Flag(br'\Seen')}, ret.flag_set)
self.assertEqual(FlagOp.ADD, ret.mode)
self.assertTrue(ret.silent)
self.assertEqual(b' ', buf)
def test_parse(self):
ret, buf = DateTime.parse(b'"1-Jan-2000 01:02:03 +0500"', Params())
self.assertIsInstance(ret, DateTime)
self.assertEqual(1, ret.value.day)
self.assertEqual(1, ret.value.month)
self.assertEqual(2000, ret.value.year)
self.assertEqual(1, ret.value.hour)
self.assertEqual(2, ret.value.minute)
self.assertEqual(3, ret.value.second)
self.assertEqual(18000.0, ret.value.utcoffset().total_seconds())
def test_parse_sections(self):
ret1, _ = FetchAttribute.parse(b'BODY[1.2]', Params())
self.assertEqual(b'BODY', ret1.value)
self.assertEqual([1, 2], ret1.section.parts)
self.assertIsNone(ret1.section.specifier)
self.assertIsNone(ret1.section.headers)
self.assertIsNone(ret1.partial)
ret2, _ = FetchAttribute.parse(b'BODY[1.2.MIME]', Params())
self.assertEqual(b'BODY', ret2.value)
self.assertEqual([1, 2], ret2.section.parts)
self.assertEqual(b'MIME', ret2.section.specifier)
self.assertIsNone(ret2.section.headers)
self.assertIsNone(ret2.partial)
ret3, _ = FetchAttribute.parse(b'BODY[HEADER]', Params())
self.assertEqual(b'BODY', ret3.value)
self.assertEqual([], ret3.section.parts)
self.assertEqual(b'HEADER', ret3.section.specifier)
self.assertIsNone(ret3.section.headers)
self.assertIsNone(ret3.partial)
def test_parse(self):
state = ParsingState(continuations=[v(b'test test!\n ')])
with self.assertRaises(ParsingInterrupt) as raised:
AppendCommand.parse(
b' inbox (\\Seen) "01-Jan-1970 01:01:00 +0000" {10}\n',
Params(state))
expected = raised.exception.expected
self.assertIsInstance(expected, ExpectPreparedMessage)
self.assertEqual('INBOX', expected.mailbox)
self.assertEqual(b'test test!', expected.message.literal)
self.assertEqual({self._seen}, expected.message.flag_set)
self.assertEqual(self._epoch, expected.message.when)
def test_parse_list(self):
ret, buf = SearchKey.parse(b'(4,5,6 NOT 1,2,3)', Params())
self.assertEqual(b'KEYSET', ret.value)
self.assertIsInstance(ret.filter, list)
self.assertEqual(2, len(ret.filter))
self.assertEqual(b'SEQSET', ret.filter[0].value)
self.assertIsInstance(ret.filter[0].filter, SequenceSet)
self.assertEqual([4, 5, 6], ret.filter[0].filter.value)
self.assertFalse(ret.filter[0].inverse)
self.assertEqual(b'SEQSET', ret.filter[1].value)
self.assertIsInstance(ret.filter[1].filter, SequenceSet)
self.assertEqual([1, 2, 3], ret.filter[1].filter.value)
self.assertTrue(ret.filter[1].inverse)
def test_parse(self):
ret, buf = ListP.parse(
b' (ONE 2 (NIL) "four" ) ',
Params(list_expected=[Nil, Number, Atom, String, ListP]))
self.assertIsInstance(ret, ListP)
self.assertEqual(4, len(ret.value))
self.assertEqual(b' ', buf)
self.assertIsInstance(ret.value[0], Atom)
self.assertEqual(b'ONE', ret.value[0].value)
self.assertIsInstance(ret.value[1], Number)
self.assertEqual(2, ret.value[1].value)
self.assertIsInstance(ret.value[2], ListP)
self.assertIsNone(ret.value[2].value[0].value)
self.assertIsInstance(ret.value[3], QuotedString)
self.assertEqual(b'four', ret.value[3].value)
def test_parse_error(self):
with self.assertRaises(NotParseable):
FetchAttribute.parse(b'<>', Params())
with self.assertRaises(NotParseable):
FetchAttribute.parse(b'BODY[""]', Params())
with self.assertRaises(NotParseable):
FetchAttribute.parse(b'BODY[HEADER.FIELDS ()]', Params())
with self.assertRaises(NotParseable):
FetchAttribute.parse(b'BODY[TEST]', Params())
with self.assertRaises(NotParseable):
FetchAttribute.parse(b'TEST', Params())
with self.assertRaises(NotParseable):
FetchAttribute.parse(b'BODY.PEEK', Params())
with self.assertRaises(NotParseable):
FetchAttribute.parse(b'BODY[TEXT]<10.0>', Params())
def test_bytes(self):
ret, _ = ExtensionOptions.parse(b'()', Params())
self.assertEqual(b'()', bytes(ret))
ret, _ = ExtensionOptions.parse(b'(one two)', Params())
self.assertEqual(b'(ONE TWO)', bytes(ret))
ret, _ = ExtensionOptions.parse(b'(one 1 two 2)', Params())
self.assertEqual(b'(ONE 1 TWO 2)', bytes(ret))
ret, _ = ExtensionOptions.parse(b'(one 1:3 two 2)', Params())
self.assertEqual(b'(ONE 1:3 TWO 2)', bytes(ret))
ret, _ = ExtensionOptions.parse(b'(one (two) three)', Params())
self.assertEqual(b'(ONE (two) THREE)', bytes(ret))
ret, _ = ExtensionOptions.parse(b'(one (two (three)))', Params())
self.assertEqual(b'(ONE (two (three)))', bytes(ret))
def test_literal_parse_failure(self):
with self.assertRaises(NotParseable):
String.parse(b'{}\r\n', Params())
with self.assertRaises(NotParseable):
String.parse(b'{10}', Params())
with self.assertRaises(NotParseable):
String.parse(b'{10}\r\nabc', Params())
with self.assertRaises(NotParseable):
state = ParsingState(continuations=[v(b'a' * 9)])
String.parse(b'{10}\r\n', Params(state))
with self.assertRaises(NotParseable):
String.parse(b'{10+}\r\n' + (b'a' * 9), Params())
with self.assertRaises(ParsingInterrupt) as raised1:
String.parse(b'{10}\r\n', Params())
self.assertIsInstance(raised1.exception.expected, ExpectContinuation)
with self.assertRaises(NotParseable) as raised2:
String.parse(b'{4097}\r\n', Params())
self.assertEqual(b'[TOOBIG]', bytes(raised2.exception.code))
def test_parse_failure(self):
with self.assertRaises(NotParseable):
ObjectId.parse(b'?', Params())
def test_parse(self):
ret, buf = ObjectId.parse(b' one_2-three four', Params())
self.assertIsInstance(ret, ObjectId)
self.assertEqual(b'one_2-three', ret.value)
self.assertEqual(b' four', buf)
def test_parse_failure(self):
with self.assertRaises(NotParseable):
Mailbox.parse(b' ', Params())
def test_parse_quoted(self):
ret, buf = Mailbox.parse(b' "test mailbox \\"stuff\\"" ', Params())
self.assertIsInstance(ret, Mailbox)
self.assertEqual('test mailbox "stuff"', ret.value)
self.assertEqual(b' ', buf)
