class BaseIMAPFilterTest(unittest.TestCase):
def setUp(self):
IMAPSession.timeout = 5
self.imap = IMAPSession("localhost:%d" % IMAP_PORT)
def tearDown(self):
try:
self.imap.logout()
except IMAPError:
pass
class BaseIMAPFilterTest(unittest.TestCase):
def setUp(self):
# shorten for testing so we don't wait forever
IMAPSession.timeout = 5
self.imap = IMAPSession("localhost:%d" % IMAP_PORT)
def tearDown(self):
try:
self.imap.logout()
except IMAPError:
pass
class BaseIMAPFilterTest(unittest.TestCase):
def setUp(self):
# shorten for testing so we don't wait forever
IMAPSession.timeout = 5
self.imap = IMAPSession("localhost:%d" % IMAP_PORT)
def tearDown(self):
try:
self.imap.logout()
except IMAPError:
pass
def setUp(self):
# shorten for testing so we don't wait forever
IMAPSession.timeout = 5
self.imap = IMAPSession("localhost:%d" % IMAP_PORT)
def setUp(self):
IMAPSession.timeout = 5
self.imap = IMAPSession("localhost:%d" % IMAP_PORT)
def setUp(self):
# shorten for testing so we don't wait forever
IMAPSession.timeout = 5
self.imap = IMAPSession("localhost:%d" % IMAP_PORT)
class BaseIMAPFilterTest (unittest.TestCase) :
def setUp(self):
IMAPSession.timeout = 5
self.imap = IMAPSession("localhost:%d" % IMAP_PORT)
def tearDown(self):
try:
self.imap.logout()
except IMAPError:
pass
class IMAPSessionTest (BaseIMAPFilterTest) :
def testConnection(self):
self.assert_(self.imap.connected)
def testGoodLogin(self):
self.imap.login(IMAP_USERNAME, IMAP_PASSWORD)
self.assert_(self.imap.logged_in)
def testBadLogin(self):
self.assertRaises(LoginFailure, self.imap.login, IMAP_USERNAME,
"wrong password")
def test_check_response(self):
test_data = "IMAP response data"
response = ("OK", test_data)
data = self.imap.check_response("", response)
self.assertEqual(data, test_data)
response = ("NO", test_data)
self.assertRaises(BadIMAPResponseError, self.imap.check_response,
"", response)
def testSelectFolder(self):
self.imap.login(IMAP_USERNAME, IMAP_PASSWORD)
self.assertRaises(BadIMAPResponseError, self.imap.SelectFolder, "")
self.imap.SelectFolder("Inbox")
response = self.imap.response('OK')
self.assertEquals(response[0], "OK")
self.assert_(response[1] != [None])
self.imap.SelectFolder("Inbox")
response = self.imap.response('OK')
self.assertEquals(response[0], "OK")
self.assertEquals(response[1], [None])
def test_folder_list(self):
global FAIL_NEXT
self.imap.login(IMAP_USERNAME, IMAP_PASSWORD)
folders = self.imap.folder_list()
correct = IMAP_FOLDER_LIST[:]
correct.sort()
self.assertEqual(folders, correct)
print("\nYou should see a message indicating that getting the " \
"folder list failed.")
FAIL_NEXT = True
self.assertEqual(self.imap.folder_list(), [])
def test_extract_fetch_data(self):
response = "bad response"
self.assertRaises(BadIMAPResponseError,
self.imap.extract_fetch_data, response)
message_number = "123"
uid = "5432"
response = ("%s (UID %s)" % (message_number, uid),)
data = self.imap.extract_fetch_data(response)
self.assertEqual(data[message_number]["message_number"],
message_number)
self.assertEqual(data[message_number]["UID"], uid)
flags = r"(\Seen \Deleted)"
date = '"27-Jul-2004 13:11:56 +1200"'
response = ("%s (FLAGS %s INTERNALDATE %s)" % \
(message_number, flags, date),)
data = self.imap.extract_fetch_data(response)
self.assertEqual(data[message_number]["message_number"],
message_number)
self.assertEqual(data[message_number]["FLAGS"], flags)
self.assertEqual(data[message_number]["INTERNALDATE"], date)
rfc = "Subject: Test\r\n\r\nThis is a test message."
response = (("%s (RFC822 {%s}" % (message_number, len(rfc)), rfc),)
data = self.imap.extract_fetch_data(response)
self.assertEqual(data[message_number]["message_number"],
message_number)
self.assertEqual(data[message_number]["RFC822"], rfc)
headers = "Subject: Foo\r\nX-SpamBayes-ID: 1231-1\r\n"
response = (("%s (RFC822.HEADER {%s}" % (message_number,
len(headers)), headers),)
data = self.imap.extract_fetch_data(response)
self.assertEqual(data[message_number]["RFC822.HEADER"], headers)
peek = "Subject: Test2\r\n\r\nThis is another test message."
response = (("%s (BODY[] {%s}" % (message_number, len(peek)),
peek),)
data = self.imap.extract_fetch_data(response)
self.assertEqual(data[message_number]["BODY[]"], peek)
uid = '3018'
flags = '(\\Seen \\Deleted)'
headers = "Return-Path: <*****@*****.**>\r\nX-Original-To" \
": [email protected]\r\nDelivered-To: dleinbac@ma" \
"il2.majro.dhs.org\r\nReceived: from its-mail1.mass" \
"ey.ac.nz (its-mail1.massey.ac.nz [130.123.128.11])" \
"\r\n\tby mail2.majro.dhs.org (Postfix) with ESMTP " \
"id 7BC5018FE22\r\n\tfor <*****@*****.**>; Mon" \
", 13 Dec 2004 22:46:05 -0800 (PST)\r\nReceived: fr" \
"om its-mm1.massey.ac.nz (its-mm1 [130.123.128.45])" \
"\r\n\tby its-mail1.massey.ac.nz (8.9.3/8.9.3) with" \
"ESMTP id TAA12081;\r\n\tTue, 14 Dec 2004 19:45:56 " \
"+1300 (NZDT)\r\nReceived: from its-campus2.massey." \
"ac.nz (Not Verified[130.123.48.254]) by its-mm1.ma" \
"ssey.ac.nz with NetIQ MailMarshal\r\n\tid <B003745" \
"788>; Tue, 14 Dec 2004 19:45:56 +1300\r\nReceived:" \
"from it029048 (it029048.massey.ac.nz [130.123.238." \
"51])\r\n\tby its-campus2.massey.ac.nz (8.9.3/8.9.3" \
") with ESMTP id TAA05881;\r\n\tTue, 14 Dec 2004 19" \
':45:55 +1300 (NZDT)\r\nFrom: "Tony Meyer" <tameye' \
'*****@*****.**>\r\nTo: "\'David Leinbach\'" <david@l' \
"einbach.name>, <*****@*****.**>\r\nSubject: " \
"RE: [Spambayes] KeyError in sp_imapfilter\r\nDate:" \
"Tue, 14 Dec 2004 19:45:25 +1300\r\nMessage-ID: <EC" \
"*****@*****.**" \
"sey.ac.nz>\r\nMIME-Version: 1.0\r\nContent-Type: t" \
'ext/plain;\r\n\tcharset="us-ascii"\r\nContent-Tran' \
"sfer-Encoding: quoted-printable\r\nX-Priority: 3 (" \
"Normal)\r\nX-MSMail-Priority: Normal\r\nX-Mailer: " \
"Microsoft Outlook, Build 10.0.4510\r\nIn-Reply-To:" \
"<ECBA357DDED63B4995F5C1F5CBE5B1E801A49168@its-xchg" \
".massey.ac.nz>\r\nX-Habeas-SWE-1: winter into spri" \
"ng\r\nX-Habeas-SWE-2: brightly anticipated\r\nX-Ha" \
"beas-SWE-3: like Habeas SWE (tm)\r\nX-Habeas-SWE-4" \
": Copyright 2002 Habeas (tm)\r\nX-Habeas-SWE-5: Se" \
"nder Warranted Email (SWE) (tm). The sender of thi" \
"s\r\nX-Habeas-SWE-6: email in exchange for a licen" \
"se for this Habeas\r\nX-Habeas-SWE-7: warrant mark" \
"warrants that this is a Habeas Compliant\r\nX-Habe" \
"as-SWE-8: Message (HCM) and not spam. Please repo" \
"rt use of this\r\nX-Habeas-SWE-9: mark in spam to " \
"<http://www.habeas.com/report/>.\r\nX-MimeOLE: Pro" \
"duced By Microsoft MimeOLE V6.00.2900.2180\r\nImpo" \
"rtance: Normal\r\n\r\n"
response = ['1 (FLAGS %s)' % flags,
('2 (UID %s RFC822.HEADER {%d}' % (uid, len(headers)),
headers), ')']
data = self.imap.extract_fetch_data(response)
self.assertEqual(data['1']["message_number"], '1')
self.assertEqual(data['2']["message_number"], '2')
self.assertEqual(data['1']["FLAGS"], flags)
self.assertEqual(data['2']["UID"], uid)
self.assertEqual(data['2']["RFC822.HEADER"], headers)
headers = 'Return-Path: <*****@*****.**>\r\n' \
'X-Original-To: [email protected]\r\n' \
'Delivered-To: [email protected]\r\n' \
'Received: from cressida (unknown [70.70.206.137])' \
'\r\n\tby mail2.majro.dhs.org (Postfix) with ESMTP' \
'id AAD451CD28E\r\n\tfor <*****@*****.**>; Mo' \
'n, 6 Dec 2004 11:49:41 -0800 (PST)\r\n' \
'From: "Erin Leinbach" <*****@*****.**>\r\n' \
'To: "Dave" <*****@*****.**>\r\n' \
'Subject: Goo goo dolls songs\r\n' \
'Date: Mon, 6 Dec 2004 11:51:07 -0800\r\n' \
'Message-ID: <000001c4dbcc$ed6188a0$6801a8c0@cre' \
'ssida>\r\nMIME-Version: 1.0\r\n' \
'Content-Type: text/plain;\r\n' \
'\tcharset="Windows-1252"\r\n' \
'Content-Transfer-Encoding: 7bit\r\n' \
'X-Priority: 3 (Normal)\r\n' \
'X-MSMail-Priority: Normal\r\n' \
'X-Mailer: Microsoft Outlook, Build 10.0.2616\r\n' \
'Importance: Normal\r\n' \
'X-MimeOLE: Produced By Microsoft MimeOLE V6.00.29' \
'00.2180\r\nX-Spambayes-Classification: ham\r\n' \
'X-Spambayes-MailId: 000001\r\n\r\n'
uid = '3086'
flags = '(\\Seen \\Deleted)'
response = [('5 (UID %s RFC822.HEADER {839}' % (uid,), headers),
')', '5 (FLAGS %s)' % (flags,)]
data = self.imap.extract_fetch_data(response)
self.assertEqual(data['5']["message_number"], '5')
self.assertEqual(data['5']["FLAGS"], flags)
self.assertEqual(data['5']["UID"], uid)
self.assertEqual(data['5']["RFC822.HEADER"], headers)
def _counter(self, size):
self._count += 1
return self._imap_file_read(size)
def test_safe_read(self):
saved_file = self.imap.file
self.imap.file = io.StringIO()
self.imap.file.write("".join(list(IMAP_MESSAGES.values())*10))
self.imap.file.seek(0)
try:
self.assertEqual(len(self.imap.read(\
self.imap.MAXIMUM_SAFE_READ-1)),
self.imap.MAXIMUM_SAFE_READ-1)
self.assertEqual(len(self.imap.read(\
self.imap.MAXIMUM_SAFE_READ+1)),
self.imap.MAXIMUM_SAFE_READ+1)
self._count = 0
self._imap_file_read = self.imap.file.read
self.imap.file.read = self._counter
self.imap.read(self.imap.MAXIMUM_SAFE_READ-1)
self.assertEqual(self._count, 1)
self._count = 0
self.imap.read(self.imap.MAXIMUM_SAFE_READ+1)
self.assertEqual(self._count, 2)
finally:
self.imap.file = saved_file
class IMAPMessageTest (BaseIMAPFilterTest) :
def setUp(self):
BaseIMAPFilterTest.setUp(self)
self.msg = IMAPMessage()
self.msg.imap_server = self.imap
def test_extract_time_no_date(self):
date = self.msg.extractTime()
self.assertEqual(date, imaplib.Time2Internaldate(time.time()))
def test_extract_time_date(self):
self.msg["Date"] = "Wed, 19 May 2004 20:05:15 +1200"
date = self.msg.extractTime()
self.assertEqual(date, '"19-May-2004 20:05:15 +1200"')
def test_extract_time_bad_date(self):
self.msg["Date"] = "Mon, 06 May 0102 10:51:16 -0100"
date = self.msg.extractTime()
self.assertEqual(date, imaplib.Time2Internaldate(time.time()))
def test_as_string_invalid(self):
content = "This is example content.\nThis is more\r\n"
self.msg.invalid = True
self.msg.invalid_content = content
as_string = self.msg.as_string()
self.assertEqual(self.msg._force_CRLF(content), as_string)
def testMoveTo(self):
fol1 = "Folder1"
fol2 = "Folder2"
self.msg.MoveTo(fol1)
self.assertEqual(self.msg.folder, fol1)
self.msg.MoveTo(fol2)
self.assertEqual(self.msg.previous_folder, fol1)
self.assertEqual(self.msg.folder, fol2)
def test_get_full_message(self):
self.assertRaises(AssertionError, self.msg.get_full_message)
self.msg.id = "unittest"
self.assertRaises(AttributeError, self.msg.get_full_message)
self.msg.imap_server.login(IMAP_USERNAME, IMAP_PASSWORD)
self.msg.imap_server.select()
response = self.msg.imap_server.fetch(1, "UID")
self.assertEqual(response[0], "OK")
self.msg.uid = response[1][0][7:-1]
self.msg.folder = IMAPFolder("Inbox", self.msg.imap_server, None)
new_msg = self.msg.get_full_message()
self.assertEqual(new_msg.folder, self.msg.folder)
self.assertEqual(new_msg.previous_folder, self.msg.previous_folder)
self.assertEqual(new_msg.uid, self.msg.uid)
self.assertEqual(new_msg.id, self.msg.id)
self.assertEqual(new_msg.rfc822_key, self.msg.rfc822_key)
self.assertEqual(new_msg.rfc822_command, self.msg.rfc822_command)
self.assertEqual(new_msg.imap_server, self.msg.imap_server)
id_header = options["Headers", "mailid_header_name"]
self.assertEqual(new_msg[id_header], self.msg.id)
new_msg2 = new_msg.get_full_message()
self.assert_(new_msg is new_msg2)
def test_get_bad_message(self):
self.msg.id = "unittest"
self.msg.imap_server.login(IMAP_USERNAME, IMAP_PASSWORD)
self.msg.imap_server.select()
self.msg.uid = 103
self.msg.folder = IMAPFolder("Inbox", self.msg.imap_server, None)
print("\nWith email package versions less than 3.0, you should " \
"see an error parsing the message.")
new_msg = self.msg.get_full_message()
has_header = new_msg.as_string().find("X-Spambayes-Exception: ") != -1
has_defect = hasattr(new_msg, "defects") and len(new_msg.defects) > 0
self.assert_(has_header or has_defect)
def test_get_memory_error_message(self):
pass
def test_Save(self):
pass
class IMAPFolderTest (BaseIMAPFilterTest) :
def setUp(self):
BaseIMAPFilterTest.setUp(self)
self.imap.login(IMAP_USERNAME, IMAP_PASSWORD)
self.folder = IMAPFolder("testfolder", self.imap, None)
def test_cmp(self):
folder2 = IMAPFolder("testfolder", self.imap, None)
folder3 = IMAPFolder("testfolder2", self.imap, None)
self.assertEqual(self.folder, folder2)
self.assertNotEqual(self.folder, folder3)
def test_iter(self):
keys = list(self.folder.keys())
for msg in self.folder:
msg = msg.get_full_message()
msg_correct = email.message_from_string(IMAP_MESSAGES[int(keys[0])],
_class=message.Message)
id_header_name = options["Headers", "mailid_header_name"]
if msg_correct[id_header_name] is None:
msg_correct[id_header_name] = msg.id
self.assertEqual(msg.as_string(), msg_correct.as_string())
keys = keys[1:]
def test_keys(self):
keys = list(self.folder.keys())
correct_keys = [str(IMAP_UIDS[id]) for id in UNDELETED_IDS]
self.assertEqual(keys, correct_keys)
def test_getitem_new_style(self):
id_header_name = options["Headers", "mailid_header_name"]
msg1 = self.folder[101]
self.assertEqual(msg1.id, SB_ID_1)
msg1 = msg1.get_full_message()
msg1_correct = email.message_from_string(IMAP_MESSAGES[101],
message.Message)
self.assertNotEqual(msg1[id_header_name], None)
msg1_correct[id_header_name] = SB_ID_1
self.assertEqual(msg1.as_string(), msg1_correct.as_string())
def test_getitem_old_style(self):
id_header_name = options["Headers", "mailid_header_name"]
msg2 = self.folder[102]
self.assertEqual(msg2.id, SB_ID_2)
msg2 = msg2.get_full_message()
self.assertNotEqual(msg2[id_header_name], None)
self.assertEqual(msg2.as_string(), IMAP_MESSAGES[102])
def test_getitem_new_id(self):
id_header_name = options["Headers", "mailid_header_name"]
msg3 = self.folder[104]
self.assertNotEqual(msg3[id_header_name], None)
msg_correct = email.message_from_string(IMAP_MESSAGES[104],
message.Message)
msg_correct[id_header_name] = msg3.id
self.assertEqual(msg3.as_string(), msg_correct.as_string())
def test_generate_id(self):
id1 = self.folder._generate_id()
id2 = self.folder._generate_id()
id3 = self.folder._generate_id()
time.sleep(1)
id4 = self.folder._generate_id()
self.assertEqual(id2, id1 + "-2")
self.assertEqual(id3, id1 + "-3")
self.assertNotEqual(id1, id4)
self.assertNotEqual(id2, id4)
self.assertNotEqual(id3, id4)
self.assert_('-' not in id4)
def test_Train(self):
pass
def test_Filter(self):
pass
class IMAPFilterTest (BaseIMAPFilterTest) :
def setUp(self):
BaseIMAPFilterTest.setUp(self)
self.imap.login(IMAP_USERNAME, IMAP_PASSWORD)
classifier = Classifier()
self.filter = IMAPFilter(classifier, None)
options["imap", "ham_train_folders"] = ("ham_to_train",)
options["imap", "spam_train_folders"] = ("spam_to_train",)
def test_Train(self):
pass
def test_Filter(self):
pass
class SFBugsTest (BaseIMAPFilterTest) :
def test_802545(self):
pass
def test_816400(self):
pass
def test_818552(self):
pass
def test_842984(self):
pass
def test_886133(self):
pass
class InterfaceTest (unittest.TestCase) :
def setUp(self):
self.saved_server = options["imap", "server"]
options["imap", "server"] = ""
self._server = threading.Thread(target=run, args=(True,))
self._server.setDaemon(True)
self._server.start()
time.sleep(1)
def tearDown(self):
options["imap", "server"] = self.saved_server
from urllib.request import urlopen
from urllib.parse import urlencode
urlopen('http://localhost:%d/save' % options["html_ui", "port"],
urlencode({'how': _('Save & shutdown')})).read()
def test_UI(self):
httpServer = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
httpServer.connect(('localhost', options["html_ui", "port"]))
httpServer.send("get / HTTP/1.0\r\n\r\n")
response = ''
while 1:
packet = httpServer.recv(1024)
if not packet: break
response += packet
self.assert_(re.search(r"(?s)<html>.*SpamBayes IMAP Filter.*</html>",
response))
def suite():
suite = unittest.TestSuite()
for cls in (IMAPSessionTest,
IMAPMessageTest,
IMAPFolderTest,
IMAPFilterTest,
SFBugsTest,
InterfaceTest,
):
suite.addTest(unittest.makeSuite(cls))
return suite
if __name__=='__main__':
def runTestServer():
TestListener()
asyncore.loop()
server = threading.Thread(target=runTestServer, args=())
server.setDaemon(True)
server.start()
time.sleep(2)
sb_test_support.unittest_main(argv=sys.argv + ['suite'])
if __name__=='__main__':
def runTestServer():
TestListener()
asyncore.loop()
server = threading.Thread(target=runTestServer, args=())
server.setDaemon(True)
server.start()
time.sleep(2)
sb_test_support.unittest_main(argv=sys.argv + ['suite'])
try:
IMAPError = imaplib.error
except AttributeError:
IMAPError = imaplib.IMAP4.error