How to use IMAPClient - 10 common examples

def _test(self, to_parse, expected, wrap=True):
        if wrap:
            # convenience - expected value should be wrapped in another tuple
            expected = (expected,)
        if not isinstance(to_parse, list):
            to_parse = [to_parse]
        output = parse_response(to_parse)
        self.assertSequenceEqual(output, expected)

def test_no_tls(server):
    """No login should be possible over non-TLS"""
    conn = imapclient.IMAPClient(server, 143, ssl=False)
    assert login_error_code("obiwan@jedi.local", conn=conn) == "PRIVACYREQUIRED"

def testserver(aserver, aport, auser, apassword):
    """Do work"""
    server = IMAPClient(aserver, aport, use_uid=True, ssl=False)
    print "Logging in"
    try:
        server.login(auser, apassword)
    except Exception: 
        print "\n *** Something has gone horribly wrong ***\n"
    else:
        print "\n Great Success !\n"
        pass

    select_info = server.select_folder('INBOX')
    print '%d messages in INBOX' % select_info['EXISTS']

    messages = server.search(['NOT DELETED'])
    print "%d messages that aren't deleted" % len(messages)

    print "\n Message Summary:"

def test_none_special_case(self):
        self.assertEqual(parse_fetch_response([None]), {})

def test_FLAGS(self):
        self.assertEqual(parse_fetch_response([b'23 (FLAGS (\Seen Stuff))']),
                         {23: {b'SEQ': 23, b'FLAGS': (br'\Seen', b'Stuff')}})

def test_ENVELOPE(self):
        envelope_str = (b'1 (ENVELOPE ( '
                        b'"Sun, 24 Mar 2013 22:06:10 +0200" '
                        b'"subject" '
                        b'(("name" NIL "address1" "domain1.com")) '     # from (name and address)
                        b'((NIL NIL "address2" "domain2.com")) '        # sender (just address)
                        b'(("name" NIL "address3" "domain3.com") NIL) '  # reply to
                        b'NIL'                                          # to (no address)
                        b'((NIL NIL "address4" "domain4.com") '         # cc
                        b'("person" NIL "address4b" "domain4b.com")) '
                        b'NIL '                                         # bcc
                        b'"" '
                        b'""))')

        output = parse_fetch_response([envelope_str], normalise_times=False)

        self.assertSequenceEqual(output[1][b'ENVELOPE'],
                                 Envelope(
            datetime(2013, 3, 24, 22, 6, 10, tzinfo=FixedOffset(120)),
            b"subject",
            (Address(b"name", None, b"address1", b"domain1.com"),),
            (Address(None, None, b"address2", b"domain2.com"),),
            (Address(b"name", None, b"address3", b"domain3.com"),),
            None,
            (Address(None, None, b"address4", b"domain4.com"),
             Address(b"person", None, b"address4b", b"domain4b.com")),
            None, b"", b""
        )

def test_ENVELOPE_with_empty_addresses(self):
        envelope_str = (b'1 (ENVELOPE ( '
                        b'NIL '
                        b'"subject" '
                        b'(("name" NIL "address1" "domain1.com") NIL) '
                        b'(NIL (NIL NIL "address2" "domain2.com")) '
                        b'(("name" NIL "address3" "domain3.com") NIL ("name" NIL "address3b" "domain3b.com")) '
                        b'NIL'
                        b'((NIL NIL "address4" "domain4.com") '
                        b'("person" NIL "address4b" "domain4b.com")) '
                        b'NIL "" ""))')

        output = parse_fetch_response([envelope_str], normalise_times=False)

        self.assertSequenceEqual(output[1][b'ENVELOPE'],
                                 Envelope(
            None,
            b"subject",
            (Address(b"name", None, b"address1", b"domain1.com"),),
            (Address(None, None, b"address2", b"domain2.com"),),
            (Address(b"name", None, b"address3", b"domain3.com"),
             Address(b"name", None, b"address3b", b"domain3b.com")),
            None,
            (Address(None, None, b"address4", b"domain4.com"),
             Address(b"person", None, b"address4b", b"domain4b.com")),
            None, b"", b""
        )

def test_simple_pairs(self):
        self.assertEqual(parse_fetch_response([b'23 (ABC 123 StUfF "hello")']),
                         {23: {b'ABC': 123,
                               b'STUFF': b'hello',
                               b'SEQ': 23}})

def _test_parse_error(self, to_parse, expected_msg):
        if not isinstance(to_parse, list):
            to_parse = [to_parse]
        self.assertRaisesRegex(ProtocolError, expected_msg,
                               parse_response, to_parse)

def test_Address_str(self):
        self.assertEqual(str(Address(b"Mary Jane", None, b"mary", b"jane.org")),
                         "Mary Jane ")

        self.assertEqual(str(Address("Mary Jane", None, "mary", "jane.org")),
                         "Mary Jane ")

        self.assertEqual(str(Address("Anonymous", None, "undisclosed-recipients", None)),
                         "Anonymous ")

        self.assertEqual(str(Address(None, None, None, "undisclosed-recipients")),
                         "undisclosed-recipients")