def test_update_smsAddress(self):
'Make sure that updating smsAddresses works'
url = self.get_url('user_update')
db.query(SMSAddress).delete()
userSID, userSCode, userSEmail = db.query(User.id, User.code, User.email).filter_by(username=self.userS['username']).first()
userAID, userACode, userAEmail = db.query(User.id, User.code, User.email).filter_by(username=self.userA['username']).first()
userIID, userICode, userIEmail = db.query(User.id, User.code, User.email).filter_by(username=self.userI['username']).first()
imapServer = sms.connect(self.router.registry.settings)
# Register an invalid email address
imapServer.revive('inbox', imapIO.build_message(subject='%s-%s' % (userSID, userSCode), fromWhom=''))
# Register using an invalid userID or userCode
imapServer.revive('inbox', imapIO.build_message(subject='%s-%s' % (-1, userSCode), fromWhom='sms_' + userSEmail))
imapServer.revive('inbox', imapIO.build_message(subject='%s-%s' % (userSID, -1), fromWhom='sms_' + userSEmail))
# Register three email addresses
imapServer.revive('inbox', imapIO.build_message(subject='%s-%s' % (userSID, userSCode), fromWhom='sms_' + userSEmail))
imapServer.revive('inbox', imapIO.build_message(subject='%s-%s' % (userAID, userACode), fromWhom='sms_' + userAEmail))
imapServer.revive('inbox', imapIO.build_message(subject='%s-%s' % (userIID, userICode), fromWhom='sms_' + userIEmail))
# Register an address that already exists for the given user
imapServer.revive('inbox', imapIO.build_message(subject='%s-%s' % (userSID, userSCode), fromWhom='sms_' + userSEmail))
# Remove an email address
imapServer.revive('inbox', imapIO.build_message(subject='%s-%s' % (0, 'xxx'), fromWhom='sms_' + userSEmail))
# Process
sms.process(self.router.registry.settings)
# Make sure we only have two registered SMS address
self.assertEqual(2, db.query(SMSAddress).count())
smsAddressA = db.query(SMSAddress).filter_by(user_id=userAID).first()
smsAddressI = db.query(SMSAddress).filter_by(user_id=userIID).first()
# Get token
self.login(self.userI)
token = get_token(self.get(url).unicode_body)
params = ReplaceableDict(token=token, smsAddressAction='activate', smsAddressID=smsAddressI.id)
# Activate an smsAddress that doesn't belong to the user
self.assert_json(self.post(url, params.replace(smsAddressID=smsAddressA.id)), 0)
# Activate an smsAddress
self.assert_json(self.post(url, params), 1)
self.assertEqual(db.query(SMSAddress.is_active).filter_by(user_id=userIID).first()[0], True)
params = ReplaceableDict(token=token, smsAddressAction='deactivate', smsAddressID=smsAddressI.id)
# Deactivate an smsAddress that doesn't belong to the user
self.assert_json(self.post(url, params.replace(smsAddressID=smsAddressA.id)), 0)
# Deactivate an smsAddress
self.assert_json(self.post(url, params), 1)
self.assertEqual(db.query(SMSAddress.is_active).filter_by(user_id=userIID).first()[0], False)
params = ReplaceableDict(token=token, smsAddressAction='remove', smsAddressID=smsAddressI.id)
# Remove an smsAddress that doesn't belong to the user
self.assert_json(self.post(url, params.replace(smsAddressID=smsAddressA.id)), 0)
# Remove an smsAddress that does belong to the user
self.assert_json(self.post(url, params), 1)
self.assertEqual(db.query(SMSAddress).filter_by(id=smsAddressI.id).count(), 0)
params = ReplaceableDict(token=token)
# Send an invalid command
self.assert_json(self.post(url, params.replace(smsAddressAction='')), 0)
self.assert_json(self.post(url, params.replace(smsAddressAction='xxx')), 0)
def test_update_smsAddress(self):
'Make sure that updating smsAddresses works'
url = self.get_url('user_update')
db.query(SMSAddress).delete()
userSID, userSCode, userSEmail = db.query(User.id, User.code, User.email).filter_by(username=self.userS['username']).first()
userAID, userACode, userAEmail = db.query(User.id, User.code, User.email).filter_by(username=self.userA['username']).first()
userIID, userICode, userIEmail = db.query(User.id, User.code, User.email).filter_by(username=self.userI['username']).first()
imapServer = sms.connect(self.router.registry.settings)
# Register an invalid email address
imapServer.revive('inbox', imapIO.build_message(subject='%s-%s' % (userSID, userSCode), fromWhom=''))
# Register using an invalid userID or userCode
imapServer.revive('inbox', imapIO.build_message(subject='%s-%s' % (-1, userSCode), fromWhom='sms_' + userSEmail))
imapServer.revive('inbox', imapIO.build_message(subject='%s-%s' % (userSID, -1), fromWhom='sms_' + userSEmail))
# Register three email addresses
imapServer.revive('inbox', imapIO.build_message(subject='%s-%s' % (userSID, userSCode), fromWhom='sms_' + userSEmail))
imapServer.revive('inbox', imapIO.build_message(subject='%s-%s' % (userAID, userACode), fromWhom='sms_' + userAEmail))
imapServer.revive('inbox', imapIO.build_message(subject='%s-%s' % (userIID, userICode), fromWhom='sms_' + userIEmail))
# Register an address that already exists for the given user
imapServer.revive('inbox', imapIO.build_message(subject='%s-%s' % (userSID, userSCode), fromWhom='sms_' + userSEmail))
# Remove an email address
imapServer.revive('inbox', imapIO.build_message(subject='%s-%s' % (0, 'xxx'), fromWhom='sms_' + userSEmail))
# Process
sms.process(self.router.registry.settings)
# Make sure we only have two registered SMS address
self.assertEqual(2, db.query(SMSAddress).count())
smsAddressA = db.query(SMSAddress).filter_by(user_id=userAID).first()
smsAddressI = db.query(SMSAddress).filter_by(user_id=userIID).first()
# Get token
self.login(self.userI)
token = get_token(self.get(url).unicode_body)
params = ReplaceableDict(token=token, smsAddressAction='activate', smsAddressID=smsAddressI.id)
# Activate an smsAddress that doesn't belong to the user
self.assert_json(self.post(url, params.replace(smsAddressID=smsAddressA.id)), 0)
# Activate an smsAddress
self.assert_json(self.post(url, params), 1)
self.assertEqual(db.query(SMSAddress.is_active).filter_by(user_id=userIID).first()[0], True)
params = ReplaceableDict(token=token, smsAddressAction='deactivate', smsAddressID=smsAddressI.id)
# Deactivate an smsAddress that doesn't belong to the user
self.assert_json(self.post(url, params.replace(smsAddressID=smsAddressA.id)), 0)
# Deactivate an smsAddress
self.assert_json(self.post(url, params), 1)
self.assertEqual(db.query(SMSAddress.is_active).filter_by(user_id=userIID).first()[0], False)
params = ReplaceableDict(token=token, smsAddressAction='remove', smsAddressID=smsAddressI.id)
# Remove an smsAddress that doesn't belong to the user
self.assert_json(self.post(url, params.replace(smsAddressID=smsAddressA.id)), 0)
# Remove an smsAddress that does belong to the user
self.assert_json(self.post(url, params), 1)
self.assertEqual(db.query(SMSAddress).filter_by(id=smsAddressI.id).count(), 0)
params = ReplaceableDict(token=token)
# Send an invalid command
self.assert_json(self.post(url, params.replace(smsAddressAction='')), 0)
self.assert_json(self.post(url, params.replace(smsAddressAction='xxx')), 0)
def test_revive(self):
self.server.cd = lambda a='': None
self.server.list = lambda: ('OK', ['() "/" aaa'])
self.server.create = lambda a: None
self.server.append = lambda a, b, c, d: ('xxx', [])
with self.assertRaises(imapIO.IMAPError):
self.server.revive('bbb', imapIO.build_message())
def test_revive(self):
self.server.cd = lambda a='': None
self.server.list = lambda: ('OK', ['() "/" aaa'])
self.server.create = lambda a: None
self.server.append = lambda a, b, c, d: ('xxx', [])
with self.assertRaises(imapIO.IMAPError):
self.server.revive('bbb', imapIO.build_message())
def test_build_message():
imapIO.mimetypes.guess_type = lambda a: (None, None)
imapIO.build_message(attachmentPaths=['MANIFEST.in'])
imapIO.mimetypes.guess_type = lambda a: ('image/xxx', None)
imapIO.build_message(attachmentPaths=['MANIFEST.in'])
imapIO.mimetypes.guess_type = lambda a: ('audio/xxx', None)
imapIO.build_message(attachmentPaths=['MANIFEST.in'])
imapIO.mimetypes.guess_type = lambda a: ('xxx/xxx', None)
imapIO.build_message(attachmentPaths=['MANIFEST.in'])
def test_build_message():
imapIO.mimetypes.guess_type = lambda a: (None, None)
imapIO.build_message(attachmentPaths=['MANIFEST.in'])
imapIO.mimetypes.guess_type = lambda a: ('image/xxx', None)
imapIO.build_message(attachmentPaths=['MANIFEST.in'])
imapIO.mimetypes.guess_type = lambda a: ('audio/xxx', None)
imapIO.build_message(attachmentPaths=['MANIFEST.in'])
imapIO.mimetypes.guess_type = lambda a: ('xxx/xxx', None)
imapIO.build_message(attachmentPaths=['MANIFEST.in'])
def test_revive(self):
folder = 'inbox'
self.server.cd(folder)
baseCase = dict(whenUTC=datetime.datetime(2005, 1, 23, 1, 0),
subject='Test',
fromWhom='*****@*****.**',
toWhom='*****@*****.**',
ccWhom='*****@*****.**',
bccWhom='*****@*****.**',
bodyText='Yes',
bodyHTML='<html>No</html>',
attachmentPaths=[
'CHANGES.rst',
'README.rst',
])
# Clear previous cases
for email in self.server.walk(folder):
if [email.fromWhom, email.toWhom
] == [baseCase['fromWhom'], baseCase['toWhom']]:
email.deleted = True
self.server.expunge()
# Run cases
cases = [
baseCase,
dict(baseCase, bodyHTML=''),
dict(baseCase, bodyText=''),
dict(baseCase, attachmentPaths=None),
dict(baseCase, attachmentPaths=None, bodyHTML=''),
dict(baseCase, attachmentPaths=None, bodyText=''),
]
self.temporaryPaths = []
for caseIndex, case in enumerate(cases):
subject = case['subject'] + str(caseIndex)
# Revive
self.server.revive(
folder, imapIO.build_message(**dict(case, subject=subject)))
# Make sure the revived email exists
for email in self.server.walk(folder):
def test_revive(self):
folder = 'inbox'
self.server.cd(folder)
baseCase = dict(
whenUTC=datetime.datetime(2005, 1, 23, 1, 0),
subject='Test',
fromWhom='*****@*****.**',
toWhom='*****@*****.**',
ccWhom='*****@*****.**',
bccWhom='*****@*****.**',
bodyText='Yes',
bodyHTML='<html>No</html>',
attachmentPaths=[
'CHANGES.rst',
'README.rst',
])
# Clear previous cases
for email in self.server.walk(folder):
if [email.fromWhom, email.toWhom] == [baseCase['fromWhom'], baseCase['toWhom']]:
email.deleted = True
self.server.expunge()
# Run cases
cases = [
baseCase,
dict(baseCase, bodyHTML=''),
dict(baseCase, bodyText=''),
dict(baseCase, attachmentPaths=None),
dict(baseCase, attachmentPaths=None, bodyHTML=''),
dict(baseCase, attachmentPaths=None, bodyText=''),
]
self.temporaryPaths = []
for caseIndex, case in enumerate(cases):
subject = case['subject'] + str(caseIndex)
# Revive
self.server.revive(folder, imapIO.build_message(**dict(case, subject=subject)))
# Make sure the revived email exists
for email in self.server.walk(folder):
if [email.fromWhom, email.toWhom, email.subject] == [baseCase['fromWhom'], baseCase['toWhom'], subject]:
break
else:
raise AssertionError('Could not find revived message on server')
self.assertEqual(email.seen, False)
self.assertEqual(email.whenUTC, case['whenUTC'])
email.flags = r'\Seen'
self.assertEqual(
set([r'\Seen']),
set(x for x in email.flags).difference([r'\Recent']))
# Save
targetPath = tempfile.mkstemp(suffix='.gz')[1]
self.temporaryPaths.append(targetPath)
email.save(targetPath)
partPacks = imapIO.extract_parts(targetPath, [100])
partPacks = imapIO.extract_parts(targetPath)
attachmentPathByName = dict((os.path.basename(x), x) for x in case['attachmentPaths'] or [])
# Make sure the email contains all attachments
self.assertEqual(set(attachmentPathByName) - set(x[1] for x in partPacks), set())
# Make sure attachment contents match
for partIndex, partName, contentType, payload in partPacks:
if partName in attachmentPathByName:
attachmentData = open(attachmentPathByName[partName], 'rb').read()
if contentType.startswith('text'):
payload = payload.replace('\r\n', '\n')
self.assertEqual(payload, attachmentData)
elif contentType == 'text/plain':
self.assertEqual(payload, case['bodyText'])
elif contentType == 'text/html':
self.assertEqual(payload, case['bodyHTML'])
else:
raise Exception('Unexpect part: %s' % (partIndex, partName, contentType))
# Duplicate an email directly
for email in self.server.walk(folder):
if [email.fromWhom, email.toWhom] == [baseCase['fromWhom'], baseCase['toWhom']]:
self.server.revive(folder, email)
break
# Clear cases
self.server.format_error('xxx', '')
for email in self.server.walk(folder):
email.format_error('xxx', '')
if [email.fromWhom, email.toWhom] == [baseCase['fromWhom'], baseCase['toWhom']]:
email.deleted = True
self.server.expunge()
