def test_yahoo_pass():
with patch.object(validate, 'mail_exchanger_lookup') as mock_method:
mock_method.side_effect = mock_exchanger_lookup
# valid length range
for i in range(4, 33):
localpart = ''.join(
random.choice(string.ascii_letters) for x in range(i))
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# start must be letter
for i in string.ascii_letters:
localpart = str(i) + 'aaa'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# end must be letter or number
for i in string.ascii_letters + string.digits:
localpart = 'aaa' + str(i)
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# must be letter, num, and underscore
for i in string.ascii_letters + string.digits + '_':
localpart = 'aa' + str(i) + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# only zero or one dot (.) allowed
for i in range(0, 2):
localpart = 'aa' + '.' * i + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
def test_yahoo_disposable_fail():
with patch.object(validate, 'mail_exchanger_lookup') as mock_method:
mock_method.side_effect = mock_exchanger_lookup
# invalid base length range
for i in range(0) + range(33, 40):
base = ''.join(
random.choice(string.ascii_letters) for x in range(i))
localpart = base + '-aa'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid keyword length range
for i in range(0) + range(33, 40):
keyword = ''.join(
random.choice(string.ascii_letters) for x in range(i))
localpart = 'aa-' + keyword
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid base (must be letter, num, underscore)
invalid_chars = string.punctuation
invalid_chars = invalid_chars.replace('_', '')
for i in invalid_chars:
localpart = 'aa' + str(i) + '-00'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid keyword (must be letter, num)
invalid_chars = string.punctuation
for i in invalid_chars:
localpart = 'aa-' + str(i) + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
def test_mx_lookup(ld, cmx):
# has MX, has MX server
ld.return_value = ['mx1.fake.mailgun.com', 'mx2.fake.mailgun.com']
cmx.return_value = 'mx1.fake.mailgun.com'
addr = address.validate_address('*****@*****.**')
assert_not_equal(addr, None)
# has fallback A, has MX server
ld.return_value = ['domain.com']
cmx.return_value = 'domain.com'
addr = address.validate_address('*****@*****.**')
assert_not_equal(addr, None)
# has MX, no server answers
ld.return_value = ['mx.example.com']
cmx.return_value = None
addr = address.validate_address('*****@*****.**')
assert_equal(addr, None)
# no MX
ld.return_value = []
cmx.return_value = None
addr = address.validate_address('*****@*****.**')
assert_equal(addr, None)
def test_abridged_mailbox_valid_set():
for line in ABRIDGED_LOCALPART_VALID_TESTS.split('\n'):
# strip line, skip over empty lines
line = line.strip()
if line == '':
continue
# skip over comments or empty lines
match = COMMENT.match(line)
if match:
continue
# mocked valid dns lookup for tests
with patch.object(address, 'mail_exchanger_lookup') as mock_method:
mock_method.side_effect = mock_exchanger_lookup
addr = line + '@ai'
mbox = address.validate_address(addr)
assert_not_equal(mbox, None)
# domain
addr = line + '@mailgun.org'
mbox = address.validate_address(addr)
assert_not_equal(mbox, None)
# subdomain
addr = line + '@fakecompany.mailgun.org'
mbox = address.validate_address(addr)
assert_not_equal(mbox, None)
def test_mx_lookup(ld, cmx):
# has MX, has MX server
ld.return_value = ['mx1.fake.mailgun.com', 'mx2.fake.mailgun.com']
cmx.return_value = 'mx1.fake.mailgun.com'
addr = address.validate_address('*****@*****.**')
assert_not_equal(addr, None)
# has fallback A, has MX server
ld.return_value = ['domain.com']
cmx.return_value = 'domain.com'
addr = address.validate_address('*****@*****.**')
assert_not_equal(addr, None)
# has MX, no server answers
ld.return_value = ['mx.example.com']
cmx.return_value = None
addr = address.validate_address('*****@*****.**')
assert_equal(addr, None)
# no MX
ld.return_value = []
cmx.return_value = None
addr = address.validate_address('*****@*****.**')
assert_equal(addr, None)
def test_yahoo_disposable_fail():
with patch.object(address, 'mail_exchanger_lookup') as mock_method:
mock_method.side_effect = mock_exchanger_lookup
# invalid base length range
for i in list(range(0)) + list(range(33, 40)):
base = ''.join(random.choice(string.ascii_letters) for x in range(i))
localpart = base + '-aa'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid keyword length range
for i in list(range(0)) + list(range(33, 40)):
keyword = ''.join(random.choice(string.ascii_letters) for x in range(i))
localpart = 'aa-' + keyword
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid base (must be letter, num, underscore)
invalid_chars = string.punctuation
invalid_chars = invalid_chars.replace('_', '')
for i in invalid_chars:
localpart = 'aa' + str(i) + '-00'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid keyword (must be letter, num)
invalid_chars = string.punctuation
for i in invalid_chars:
localpart = 'aa-' + str(i) + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
def test_yahoo_pass():
with patch.object(address, 'mail_exchanger_lookup') as mock_method:
mock_method.side_effect = mock_exchanger_lookup
# valid length range
for i in range(4, 33):
localpart = ''.join(random.choice(string.ascii_letters) for x in range(i))
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# start must be letter
for i in string.ascii_letters:
localpart = str(i) + 'aaa'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# end must be letter or number
for i in string.ascii_letters + string.digits:
localpart = 'aaa' + str(i)
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# must be letter, num, and underscore
for i in string.ascii_letters + string.digits + '_':
localpart = 'aa' + str(i) + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# only zero or one dot (.) allowed
for i in range(0, 2):
localpart = 'aa' + '.'*i + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
def test_abridged_mailbox_valid_set():
for line in ABRIDGED_LOCALPART_VALID_TESTS.split('\n'):
# strip line, skip over empty lines
line = line.strip()
if line == '':
continue
# skip over comments or empty lines
match = COMMENT.match(line)
if match:
continue
# mocked valid dns lookup for tests
with patch.object(validate, 'mail_exchanger_lookup') as mock_method:
mock_method.side_effect = mock_exchanger_lookup
addr = line + '@ai'
mbox = address.validate_address(addr)
assert_not_equal(mbox, None)
# domain
addr = line + '@mailgun.org'
mbox = address.validate_address(addr)
assert_not_equal(mbox, None)
# subdomain
addr = line + '@fakecompany.mailgun.org'
mbox = address.validate_address(addr)
assert_not_equal(mbox, None)
def test_yahoo_disposable_pass():
with patch.object(validate, 'mail_exchanger_lookup') as mock_method:
mock_method.side_effect = mock_exchanger_lookup
# valid length range
for i in range(1, 32):
base = ''.join(
random.choice(string.ascii_letters) for x in range(i))
keyword = ''.join(
random.choice(string.ascii_letters) for x in range(i))
localpart = base + '-' + keyword
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# base must be letter, number, underscore
for i in string.ascii_letters + string.digits + '_':
localpart = 'aa' + str(i) + '-00'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# keyword must be letter, number
for i in string.ascii_letters + string.digits:
localpart = 'aa-' + str(i) + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
def test_mx_connect():
# skip network tests during development
skip_if_asked()
# connect
addr = address.validate_address("*****@*****.**")
assert_not_equal(addr, None)
# don't connect
addr = address.validate_address("*****@*****.**")
assert_equal(addr, None)
def test_mx_connect():
# skip network tests during development
skip_if_asked()
# connect
addr = address.validate_address('*****@*****.**')
assert_not_equal(addr, None)
# don't connect
addr = address.validate_address('*****@*****.**')
assert_equal(addr, None)
def test_bad_tld():
# con is not a valid TLD
addr_spec = '*****@*****.**'
addr_obj, metrics = address.validate_address(addr_spec, skip_remote_checks=True, metrics=True)
assert_equal(addr_obj, None)
assert_not_equal(metrics['tld_lookup'], 0)
# example is not a valid TLD
addr_spec = 'test@example'
addr_obj, metrics = address.validate_address(addr_spec, skip_remote_checks=True, metrics=True)
assert_equal(addr_obj, None)
assert_not_equal(metrics['tld_lookup'], 0)
def test_metrics_validate_address():
# validate
with patch.object(validate, 'mail_exchanger_lookup') as mock_method:
mock_method.side_effect = mock_exchanger_lookup
assert_equal(len(address.validate_address('*****@*****.**', metrics=True)), 2)
p, m = address.validate_address('*****@*****.**', metrics=True)
assert_equal('parsing' in m, True)
assert_equal('mx_lookup' in m, True)
assert_equal('dns_lookup' in m, True)
assert_equal('mx_conn' in m, True)
assert_equal('custom_grammar' in m, True)
assert_equal(isinstance(address.validate_address('*****@*****.**', metrics=False), address.EmailAddress), True)
assert_equal(isinstance(address.validate_address('*****@*****.**'), address.EmailAddress), True)
def test_metrics_validate_address():
# validate
with patch.object(validate, 'mail_exchanger_lookup') as mock_method:
mock_method.side_effect = mock_exchanger_lookup
assert_equal(len(address.validate_address('*****@*****.**', metrics=True)), 2)
p, m = address.validate_address('*****@*****.**', metrics=True)
assert_equal('parsing' in m, True)
assert_equal('mx_lookup' in m, True)
assert_equal('dns_lookup' in m, True)
assert_equal('mx_conn' in m, True)
assert_equal('custom_grammar' in m, True)
assert_equal(isinstance(address.validate_address('*****@*****.**', metrics=False), address.EmailAddress), True)
assert_equal(isinstance(address.validate_address('*****@*****.**'), address.EmailAddress), True)
def validate_user_data(data):
validation_error = validate_user_data_present(data)
if validation_error != "":
return validation_error
addr = address.validate_address(data["email"], skip_remote_checks=True)
if addr == None:
return "Email address has invalid format, or MX domain does not exist"
password = data["password"]
special_characters = '!"@#$%^&*()-+?_=,/'
rules = [lambda s: any(x.isupper() for x in s), # must have at least one uppercase
# must have at least one lowercase
lambda s: any(x.islower() for x in s),
lambda s: any(x.isdigit()
for x in s), # must have at least one digit
# must be at least 8 characters
lambda s: len(s) >= 8,
lambda s: any(x in special_characters for x in s),
]
if not all(rule(password) for rule in rules):
return "Password must have at least 8 characters, 1 uppercase character, 1 lowercase, 1 digit and 1 special character"
return ""
def test_bad_tld():
# con is not a valid TLD
addr_spec = '*****@*****.**'
addr_obj, metrics = address.validate_address(
addr_spec, skip_remote_checks=True, metrics=True
)
assert_equal(addr_obj, None)
assert_not_equal(metrics['tld_lookup'], 0)
# example is not a valid TLD
addr_spec = 'test@example'
addr_obj, metrics = address.validate_address(
addr_spec, skip_remote_checks=True, metrics=True
)
assert_equal(addr_obj, None)
assert_not_equal(metrics['tld_lookup'], 0)
def validate_user_data_present(data):
if "email" not in data or data["email"] == "":
return "Missing email field"
if "password" not in data or data["password"] == "":
return "Missing password field"
addr = address.validate_address(data["email"])
if addr == None:
return "Email address has invalid format, or MX domain does not exist"
return ""
def test_mx_lookup_has_no_mx(dns, cmx):
# no MX
domain_name = 'example.com'
email_address = 'username@%s' % domain_name
dns.return_value = fake_dns_lookup(domain_name, [])
cmx.return_value = None
addr = address.validate_address(email_address)
assert_equal(addr, None)
def test_yahoo_fail():
with patch.object(validate, 'mail_exchanger_lookup') as mock_method:
mock_method.side_effect = mock_exchanger_lookup
# invalid length range
for i in range(0, 4) + range(33, 40):
localpart = ''.join(
random.choice(string.ascii_letters) for x in range(i))
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid start char (must start with letter)
for i in string.punctuation + string.digits:
localpart = str(i) + 'aaa'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid end char (must end with letter or digit)
for i in string.punctuation:
localpart = 'aaa' + str(i)
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid chars (must be letter, num, underscore, or dot)
# addresses containing a dash may be a valid disposable address
invalid_chars = string.punctuation
invalid_chars = invalid_chars.replace('-', '')
invalid_chars = invalid_chars.replace('.', '')
invalid_chars = invalid_chars.replace('_', '')
for i in invalid_chars:
localpart = 'aa' + str(i) + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# no more than 1 dot (.) allowed
for i in range(2, 4):
localpart = 'aa' + '.' * i + 'a' + '.' * i + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# no consecutive: underscore (_) or dot-underscore (._)
# or underscore-dot (_.)
for i in range(1, 4):
localpart = 'aa' + '__' * i + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
localpart = 'aa' + '._' * i + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
localpart = 'aa' + '._' * i + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
def test_mx_lookup():
# skip network tests during development
skip_if_asked()
# has MX, has MX server
addr = address.validate_address("*****@*****.**")
assert_not_equal(addr, None)
# has fallback A, has MX server
addr = address.validate_address("*****@*****.**")
assert_not_equal(addr, None)
# has MX, no server answers
addr = address.validate_address("*****@*****.**")
assert_equal(addr, None)
# no MX
addr = address.validate_address("*****@*****.**")
assert_equal(addr, None)
def test_validate_address_metrics():
with patch.object(validate, 'mail_exchanger_lookup') as mock_method:
mock_method.side_effect = mock_exchanger_lookup
parse, metrics = address.validate_address('*****@*****.**', metrics=True)
assert_not_equal(metrics, None)
assert_equal(metrics['mx_lookup'], 10)
assert_equal(metrics['dns_lookup'], 20)
assert_equal(metrics['mx_conn'], 30)
def __call__(self, value):
validate_email(value)
value = force_text(value)
if value and address.validate_address(value) is None:
suggestion = validate.suggest_alternate(value)
if suggestion:
raise ValidationError(self.message_typo, code=self.code_typo,
params={'suggestion': suggestion})
raise ValidationError(self.message_invalid, code=self.code_invalid)
def test_mx_lookup():
# skip network tests during development
skip_if_asked()
# has MX, has MX server
addr = address.validate_address('*****@*****.**')
assert_not_equal(addr, None)
# has fallback A, has MX server
addr = address.validate_address('*****@*****.**')
assert_not_equal(addr, None)
# has MX, no server answers
addr = address.validate_address('*****@*****.**')
assert_equal(addr, None)
# no MX
addr = address.validate_address('*****@*****.**')
assert_equal(addr, None)
def test_validate_address_metrics():
with patch.object(address, 'mail_exchanger_lookup') as mock_method:
mock_method.side_effect = mock_exchanger_lookup
parse, metrics = address.validate_address('*****@*****.**', metrics=True)
assert_not_equal(metrics, None)
assert_equal(metrics['mx_lookup'], 10)
assert_equal(metrics['dns_lookup'], 20)
assert_equal(metrics['mx_conn'], 30)
def test_yahoo_fail():
with patch.object(address, 'mail_exchanger_lookup') as mock_method:
mock_method.side_effect = mock_exchanger_lookup
# invalid length range
for i in list(range(0, 4)) + list(range(33, 40)):
localpart = ''.join(random.choice(string.ascii_letters) for x in range(i))
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid start char (must start with letter)
for i in string.punctuation + string.digits:
localpart = str(i) + 'aaa'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid end char (must end with letter or digit)
for i in string.punctuation:
localpart = 'aaa' + str(i)
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid chars (must be letter, num, underscore, or dot)
# addresses containing a dash may be a valid disposable address
invalid_chars = string.punctuation
invalid_chars = invalid_chars.replace('-', '')
invalid_chars = invalid_chars.replace('.', '')
invalid_chars = invalid_chars.replace('_', '')
for i in invalid_chars:
localpart = 'aa' + str(i) + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# no more than 1 dot (.) allowed
for i in range(2, 4):
localpart = 'aa' + '.'*i + 'a' + '.'*i + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# no consecutive: underscore (_) or dot-underscore (._)
# or underscore-dot (_.)
for i in range(1, 4):
localpart = 'aa' + '__'*i + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
localpart = 'aa' + '._'*i + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
localpart = 'aa' + '._'*i + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
def __call__(self, value):
super(FlankerValidator, self).__call__(value)
if address.validate_address(value) is None:
suggestion = validate.suggest_alternate(value)
if suggestion:
message = string_concat(self.message, ' ', self.suggest_fragment)
raise ValidationError(message, code=self.code, params={
'suggestion': suggestion
})
raise ValidationError(self.message, code=self.code)
def test_mx_lookup_has_mx_no_server_answer(dns, cmx):
# has MX, no server answers
domain_name = 'example.com'
mx_records = ['mx.example.com']
email_address = 'username@%s' % domain_name
dns.return_value = fake_dns_lookup(domain_name, mx_records)
cmx.return_value = None
addr = address.validate_address(email_address)
assert_equal(addr, None)
def ValidateEmails(sEmails, sOutputFile, bMX=False, bVerbose=False):
bFile = False
if len(sOutputFile) > 0:
fOut = open(sOutputFile, "w")
bFile = True
iCnt = 0
for sEmail in sEmails:
iCnt = iCnt + 1
try:
print("\r%i" % (iCnt))
sOutputLine = ""
sEmail_1 = ""
# email_validator
try:
v = validate_email(sEmail) # validate and get info
sEmail_1 = v["email"] # replace with normalized form
except EmailNotValidError as e:
sEmail_1 = ""
# is_email
try:
if is_email(sEmail, check_dns=True):
sEmail_2 = sEmail
else:
sEmail_2 = ""
except:
sEmail_2 = ""
# flanker
try:
sEmail_3 = ""
if bMX:
sEmail_3 = address.validate_address(sEmail).address
else:
sEmail_3 = address.parse(sEmail).address
if sEmail_3 is None:
sEmail_3 = ""
except:
sEmail_3 = ""
# Resultado
if bVerbose:
print('Procesando: %s - 1: %s - 2: %s - 3: %s' %
(sEmail, sEmail_1, sEmail_2, sEmail_3))
sOutputLine = sEmail + '|' + sEmail_1 + '|' + sEmail_2 + '|' + sEmail_3 + '\n'
if len(sOutputFile) > 0:
#print(sOutputLine);
fOut.write(sOutputLine)
else:
print(sOutputLine)
except Exception as e:
sEmail = ""
print(e)
if len(sOutputFile) > 0:
fOut.close()
return
def test_mx_lookup(dns, cmx):
domain_name = 'mailgun.com'
mx_records = ['mx1.fake.mailgun.com', 'mx2.fake.mailgun.com']
email_address = 'username@%s' % domain_name
expected_address = email_address
dns.return_value = fake_dns_lookup(domain_name, mx_records)
cmx.return_value = 'mx1.fake.mailgun.com'
validated_address = address.validate_address(email_address)
assert_not_equal(validated_address, None)
assert_equal(validated_address, expected_address)
def test_exchanger_lookup():
'''
Test if exchanger lookup is occuring correctly. If this simple test
fails that means custom grammar was hit. Then the rest of the tests
can be mocked. Should always be run during deployment, can be skipped
during development.
'''
skip_if_asked()
# very simple test that should fail Yahoo! custom grammar
addr_string = '!mailgun' + DOMAIN
addr = address.validate_address(addr_string)
assert_equal(addr, None)
def test_exchanger_lookup():
'''
Test if exchanger lookup is occuring correctly. If this simple test
fails that means custom grammar was hit. Then the rest of the tests
can be mocked. Should always be run during deployment, can be skipped
during development.
'''
skip_if_asked()
# very simple test that should fail Gmail custom grammar
addr_string = '!mailgun' + DOMAIN
addr = address.validate_address(addr_string)
assert_equal(addr, None)
def test_mx_lookup_has_mx_has_fallback(dns, cmx):
# has fallback A, has MX server
domain_name = 'domain.com'
mx_records = ['domain.com']
email_address = 'username@%s' % domain_name
expected_address = email_address
dns.return_value = fake_dns_lookup(domain_name, mx_records)
cmx.return_value = 'domain.com'
addr = address.validate_address(email_address)
assert_not_equal(addr, None)
assert_equal(addr, expected_address)
def test_mx_yahoo_dual_lookup(ld, cmx):
ld.return_value = ['mta7.am0.yahoodns.net', 'mta6.am0.yahoodns.net']
cmx.return_value = 'mta5.am0.yahoodns.net'
# Invalidate managed email response out of pattern
mailbox = '*****@*****.**'
addr = address.validate_address(mailbox)
assert_equal(type(addr), type(None))
# Same test but with validate_list
addr = address.validate_list([mailbox])
expected = 'flanker.addresslib.address:'
assert_equal(addr, [])
# Allow Yahoo MX unmanaged mailboxes to pass remaining patterns
mailbox = '*****@*****.**'
addr = address.validate_address(mailbox)
assert_equal(addr, mailbox)
# Same test but with validate_list
expected = 'flanker.addresslib.address:'
addr = address.validate_list([mailbox])
assert_equal(addr, mailbox)
def test_mx_aol_dual_lookup(ld, cmx):
ld.return_value = ['mailin-01.mx.aol.com', 'mailin-02.mx.aol.com']
cmx.return_value = 'mailin-03.mx.aol.com'
# Invalidate managed email response out of pattern
mailbox = '*****@*****.**'
addr = address.validate_address(mailbox)
assert_equal(type(addr), type(None))
# Same test but with validate_list
addr = address.validate_list([mailbox])
expected = 'flanker.addresslib.address:'
assert_equal(addr, [])
# Allow AOL MX unmanaged mailboxes to pass remaining patterns
mailbox = '*****@*****.**'
addr = address.validate_address(mailbox)
assert_equal(addr, mailbox)
# Same test but with validate_list
expected = 'flanker.addresslib.address:'
addr = address.validate_list([mailbox])
assert_equal(addr, mailbox)
def test_mx_aol_dual_lookup(ld, cmx):
ld.return_value = ['mailin-01.mx.aol.com', 'mailin-02.mx.aol.com']
cmx.return_value = 'mailin-03.mx.aol.com'
# Invalidate managed email response out of pattern
mailbox = '*****@*****.**'
addr = address.validate_address(mailbox)
assert_equal(type(addr), type(None))
# Same test but with validate_list
addr = address.validate_list([mailbox])
expected = 'flanker.addresslib.address:'
assert_equal(addr, [])
# Allow AOL MX unmanaged mailboxes to pass remaining patterns
mailbox = '*****@*****.**'
addr = address.validate_address(mailbox)
assert_equal(addr, mailbox)
# Same test but with validate_list
expected = 'flanker.addresslib.address:'
addr = address.validate_list([mailbox])
assert_equal(addr, mailbox)
def test_mx_yahoo_dual_lookup(ld, cmx):
ld.return_value = ['mta7.am0.yahoodns.net', 'mta6.am0.yahoodns.net']
cmx.return_value = 'mta5.am0.yahoodns.net'
# Invalidate managed email response out of pattern
mailbox = '*****@*****.**'
addr = address.validate_address(mailbox)
assert_equal(type(addr), type(None))
# Same test but with validate_list
addr = address.validate_list([mailbox])
expected = 'flanker.addresslib.address:'
assert_equal(addr, [])
# Allow Yahoo MX unmanaged mailboxes to pass remaining patterns
mailbox = '*****@*****.**'
addr = address.validate_address(mailbox)
assert_equal(addr, mailbox)
# Same test but with validate_list
expected = 'flanker.addresslib.address:'
addr = address.validate_list([mailbox])
assert_equal(addr, mailbox)
def test_yahoo_disposable_pass():
with patch.object(address, 'mail_exchanger_lookup') as mock_method:
mock_method.side_effect = mock_exchanger_lookup
# valid length range
for i in range(1, 32):
base = ''.join(random.choice(string.ascii_letters) for x in range(i))
keyword = ''.join(random.choice(string.ascii_letters) for x in range(i))
localpart = base + '-' + keyword
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# base must be letter, number, underscore
for i in string.ascii_letters + string.digits + '_':
localpart = 'aa' + str(i) + '-00'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# keyword must be letter, number
for i in string.ascii_letters + string.digits:
localpart = 'aa-' + str(i) + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
def test_icloud_fail():
with patch.object(address, 'mail_exchanger_lookup') as mock_method:
mock_method.side_effect = mock_exchanger_lookup
# invalid length range
for i in list(range(0, 3)) + list(range(21, 30)):
localpart = ''.join(
random.choice(string.ascii_letters) for x in range(i))
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid start char (must start with letter)
for i in string.punctuation + string.digits:
localpart = str(i) + 'aa'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid end char (must end with letter or digit)
for i in string.punctuation:
localpart = 'aa' + str(i)
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid chars (must be letter, num, underscore, or dot)
invalid_chars = string.punctuation
invalid_chars = invalid_chars.replace('.', '')
invalid_chars = invalid_chars.replace('_', '')
for i in invalid_chars:
localpart = 'aa' + str(i) + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# no more than one dot (.) or underscore (_) allowed
for i in range(2, 4):
localpart = 'aa' + '.' * i + 'a' + '.' * i + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
localpart = 'aa' + '_' * i + 'a' + '_' * i + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# no ending plus (+)
for i in range(2, 4):
localpart = 'aaa' + '+' * i
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
def test_icloud_fail():
with patch.object(validate, 'mail_exchanger_lookup') as mock_method:
mock_method.side_effect = mock_exchanger_lookup
# invalid length range
for i in range(0, 3) + range(21, 30):
localpart = ''.join(random.choice(string.ascii_letters) for x in range(i))
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid start char (must start with letter)
for i in string.punctuation + string.digits:
localpart = str(i) + 'aa'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid end char (must end with letter or digit)
for i in string.punctuation:
localpart = 'aa' + str(i)
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid chars (must be letter, num, underscore, or dot)
invalid_chars = string.punctuation
invalid_chars = invalid_chars.replace('.', '')
invalid_chars = invalid_chars.replace('_', '')
for i in invalid_chars:
localpart = 'aa' + str(i) + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# no more than one dot (.) or underscore (_) allowed
for i in range(2, 4):
localpart = 'aa' + '.'*i + 'a' + '.'*i + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
localpart = 'aa' + '_'*i + 'a' + '_'*i + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# no ending plus (+)
for i in range(2, 4):
localpart = 'aaa' + '+'*i
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
def test_icloud_pass():
with patch.object(address, 'mail_exchanger_lookup') as mock_method:
mock_method.side_effect = mock_exchanger_lookup
# valid length range
for i in range(3, 21):
localpart = ''.join(
random.choice(string.ascii_letters) for x in range(i))
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# start must be letter
for i in string.ascii_letters:
localpart = str(i) + 'aa'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# end must be letter or number
for i in string.ascii_letters + string.digits:
localpart = 'aa' + str(i)
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# must be letter, num, and underscore
for i in string.ascii_letters + string.digits + '._':
localpart = 'aa' + str(i) + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# only zero or one dot (.) or underscore (_) allowed
for i in range(0, 2):
localpart = 'aa' + '.' * i + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
localpart = 'aa' + '_' * i + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# everything after plus (+) is ignored
for localpart in ['aaa+tag', 'aaa+tag+tag', 'aaa++tag']:
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
def get_valid_email(email):
"""Return (valid email address or None, True if email is a suggestion).
It uses flanker to correct commonly misspelled domains (e.g. gmil.com)
and to check to make sure MX records exist for the domain.
"""
if not email:
return None, None
# returns None if it has no alternate or if the email is invalid
good_email = validate.suggest_alternate(email) or email
suggestion = False
if email != good_email:
log.info('Using suggested alternate email')
suggestion = True
good_email = address.validate_address(good_email)
if isinstance(good_email, address.EmailAddress):
good_email = good_email.address
# returns None if the email is invalid, or the email if all's well
return good_email, suggestion
def get_valid_email(email):
"""Return (valid email address or None, True if email is a suggestion).
It uses flanker to correct commonly misspelled domains (e.g. gmil.com)
and to check to make sure MX records exist for the domain.
"""
if not email:
return None, None
# returns None if it has no alternate or if the email is invalid
good_email = validate.suggest_alternate(email) or email
suggestion = False
if email != good_email:
log.info('Using suggested alternate email')
suggestion = True
good_email = address.validate_address(good_email)
if isinstance(good_email, address.EmailAddress):
good_email = good_email.address
# returns None if the email is invalid, or the email if all's well
return good_email, suggestion
def test_icloud_pass():
with patch.object(validate, 'mail_exchanger_lookup') as mock_method:
mock_method.side_effect = mock_exchanger_lookup
# valid length range
for i in range(3, 21):
localpart = ''.join(random.choice(string.ascii_letters) for x in range(i))
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# start must be letter
for i in string.ascii_letters:
localpart = str(i) + 'aa'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# end must be letter or number
for i in string.ascii_letters + string.digits:
localpart = 'aa' + str(i)
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# must be letter, num, and underscore
for i in string.ascii_letters + string.digits + '._':
localpart = 'aa' + str(i) + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# only zero or one dot (.) or underscore (_) allowed
for i in range(0, 2):
localpart = 'aa' + '.'*i + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
localpart = 'aa' + '_'*i + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# everything after plus (+) is ignored
for localpart in ['aaa+tag', 'aaa+tag+tag','aaa++tag']:
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
def test_hotmail_fail():
with patch.object(address, 'mail_exchanger_lookup') as mock_method:
mock_method.side_effect = mock_exchanger_lookup
# invalid length range
for i in range(0, 0) + range(65, 70):
localpart = ''.join(
random.choice(string.ascii_letters) for x in range(i))
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid start char (must start with letter)
for i in string.punctuation:
localpart = str(i) + 'a'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid end char (must end with letter or num, hyphen, or underscore)
invalid_end_chars = string.punctuation
invalid_end_chars = invalid_end_chars.replace('-', '')
invalid_end_chars = invalid_end_chars.replace('_', '')
invalid_end_chars = invalid_end_chars.replace('+', '')
for i in invalid_end_chars:
localpart = 'a' + str(i)
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid chars (must be letter, num, underscore, or dot)
invalid_chars = string.punctuation
invalid_chars = invalid_chars.replace('.', '')
invalid_chars = invalid_chars.replace('-', '')
invalid_chars = invalid_chars.replace('_', '')
invalid_chars = invalid_chars.replace('+', '')
for i in invalid_chars:
localpart = 'a' + str(i) + '0'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# no more than 1 consecutive dot (.) or plus (+) allowed
for i in range(2, 4):
localpart = 'aa' + '.' * i + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
localpart = 'aa' + '+' * i + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
def test_hotmail_fail():
with patch.object(address, 'mail_exchanger_lookup') as mock_method:
mock_method.side_effect = mock_exchanger_lookup
# invalid length range
for i in range(0, 0) + range(65, 70):
localpart = ''.join(random.choice(string.ascii_letters) for x in range(i))
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid start char (must start with letter)
for i in string.punctuation:
localpart = str(i) + 'a'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid end char (must end with letter or num, hyphen, or underscore)
invalid_end_chars = string.punctuation
invalid_end_chars = invalid_end_chars.replace('-', '')
invalid_end_chars = invalid_end_chars.replace('_', '')
invalid_end_chars = invalid_end_chars.replace('+', '')
for i in invalid_end_chars:
localpart = 'a' + str(i)
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid chars (must be letter, num, underscore, or dot)
invalid_chars = string.punctuation
invalid_chars = invalid_chars.replace('.', '')
invalid_chars = invalid_chars.replace('-', '')
invalid_chars = invalid_chars.replace('_', '')
invalid_chars = invalid_chars.replace('+', '')
for i in invalid_chars:
localpart = 'a' + str(i) + '0'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# no more than 1 consecutive dot (.) or plus (+) allowed
for i in range(2, 4):
localpart = 'aa' + '.'*i + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
localpart = 'aa' + '+'*i + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
def main_view():
if request.method == 'POST':
email = request.form['input']
list_email = list(set(email.split("\r\n"))) #remove duplicate emails and split each email from the new line
#sort out the emails with commas, colons and spaces and the ones without
list_without_problems, list_with_problems = [], []
for email in list_email:
if ' ' in email or ';' in email or ',' in email:
list_with_problems.append(email)
else:
list_without_problems.append(email)
unique_emails = ','.join(list_without_problems) #transform list to string
#validate the good list of emails
valid = address.validate_list(unique_emails, as_tuple=True)
valids = valid[0] #first list in tuple is valid emails
invalids = valid[1] #second is invalid emails
#individually check the list with commas, colons, and spaces
if len(list_with_problems) != 0:
for email in list_with_problems:
if address.validate_address(email):
valids.append(valids)
else:
invalids.append(email)
#add suggestions if there are invalid emails
suggests = []
if len(invalids) != 0:
invalids = [unique_emails.encode("ascii") for unique_emails in invalids] #invalid emails come out as unicode - change to regular str and replace @@@ back to space
suggests = [str(validate.suggest_alternate(unique_emails)).replace(" ", "") for unique_emails in invalids] #suggest alternate returns None - cast None to str
return render_template('home.html', invalids=invalids, valids=valids, suggests=suggests, valid_length=len(valids), invalid_length=len(invalids))
else:
return render_template('home.html')
def test_gmail_fail():
with patch.object(address, 'mail_exchanger_lookup') as mock_method:
mock_method.side_effect = mock_exchanger_lookup
# invalid length range
for i in range(0, 6) + range(31, 40):
localpart = ''.join(
random.choice(string.ascii_letters) for x in range(i))
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid start char (must start with letter)
for i in string.punctuation:
localpart = str(i) + 'aaaaa'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid end char (must end with letter or digit)
for i in string.punctuation:
localpart = 'aaaaa' + str(i)
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid chars (must be letter, num, or dot)
invalid_chars = string.punctuation
invalid_chars = invalid_chars.replace('.', '')
for i in invalid_chars:
localpart = 'aaa' + str(i) + '000'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid consecutive dots (.)
for localpart in [
'aaaaaa......', '......aaaaaa', 'aaa......aaa', 'aa...aa...aa'
]:
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# everything after plus (+) is ignored
for localpart in [
'+t1', 'a+t1', 'aa+', 'aaa+t1', 'aaaa+t1+t2', 'aaaaa++t1'
]:
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
def test_gmail_pass():
with patch.object(validate, 'mail_exchanger_lookup') as mock_method:
mock_method.side_effect = mock_exchanger_lookup
# valid length range
for i in range(6, 31):
localpart = ''.join(
random.choice(string.ascii_letters) for x in range(i))
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# start must be letter or num
for i in string.ascii_letters + string.digits:
localpart = str(i) + 'aaaaa'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# end must be letter or number
for i in string.ascii_letters + string.digits:
localpart = 'aaaaa' + str(i)
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# must be letter, num, or dots
for i in string.ascii_letters + string.digits + '.':
localpart = 'aaa' + str(i) + '000'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# all dots (.) are ignored
for localpart in [
'aaaaaa......', '......aaaaaa', 'aaa......aaa', 'aa...aa...aa'
]:
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# everything after plus (+) is ignored
for localpart in [
'aaaaaa+', 'aaaaaa+tag', 'aaaaaa+tag+tag', 'aaaaaa++tag',
'aaaaaa+' + ATOM_STR
]:
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
def test_google_pass():
with patch.object(validate, 'mail_exchanger_lookup') as mock_method:
mock_method.side_effect = mock_exchanger_lookup
# if single character, must be alphanum, underscore, or apostrophe
for i in string.ascii_letters + string.digits + '_\'':
localpart = str(i)
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# valid length range
for i in range(1, 65):
localpart = ''.join(
random.choice(string.ascii_letters) for x in range(i))
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# start must be alphanum, underscore, dash, or apostrophe
for i in string.ascii_letters + string.digits + '_-\'':
localpart = str(i) + 'aaaaa'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# end must be alphanum, underscore, dash, or apostrophe
for i in string.ascii_letters + string.digits + '_-\'':
localpart = 'aaaaa' + str(i)
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# must be alphanum, underscore, dash, apostrophe, dots
for i in string.ascii_letters + string.digits + '_-\'.':
localpart = 'aaa' + str(i) + '000'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# everything after plus (+) is ignored
for localpart in [
'aa+', 'aa+tag', 'aa+tag+tag', 'aa++tag', 'aa+' + ATOM_STR
]:
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
def test_gmail_fail():
with patch.object(validate, 'mail_exchanger_lookup') as mock_method:
mock_method.side_effect = mock_exchanger_lookup
# invalid length range
for i in range(0, 6) + range(31, 40):
localpart = ''.join(random.choice(string.ascii_letters) for x in range(i))
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid start char (must start with letter)
for i in string.punctuation:
localpart = str(i) + 'aaaaa'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid end char (must end with letter or digit)
for i in string.punctuation:
localpart = 'aaaaa' + str(i)
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid chars (must be letter, num, or dot)
invalid_chars = string.punctuation
invalid_chars = invalid_chars.replace('.', '')
for i in invalid_chars:
localpart = 'aaa' + str(i) + '000'
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# invalid consecutive dots (.)
for localpart in ['aaaaaa......', '......aaaaaa', 'aaa......aaa','aa...aa...aa']:
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
# everything after plus (+) is ignored
for localpart in ['+t1', 'a+t1', 'aa+', 'aaa+t1', 'aaaa+t1+t2','aaaaa++t1']:
addr = address.validate_address(localpart + DOMAIN)
assert_equal(addr, None)
def test_hotmail_pass():
with patch.object(address, 'mail_exchanger_lookup') as mock_method:
mock_method.side_effect = mock_exchanger_lookup
# valid length range
for i in range(1, 65):
localpart = ''.join(
random.choice(string.ascii_letters) for x in range(i))
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# start must be letter or number
for i in string.ascii_letters + string.digits:
localpart = str(i) + 'a'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# end must be letter or number
for i in string.ascii_letters + string.digits + '-_':
localpart = 'a' + str(i)
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# must be letter, num, period, hyphen, or underscore
for i in string.ascii_letters + string.digits + '.-_':
localpart = 'a' + str(i) + '0'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# only zero or one plus allowed
for i in range(0, 2):
localpart = 'aa' + '+' * i + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# allow multiple periods
localpart = 'aa.bb.00'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
def test_google_pass():
with patch.object(validate, 'mail_exchanger_lookup') as mock_method:
mock_method.side_effect = mock_exchanger_lookup
# if single character, must be alphanum, underscore, or apostrophe
for i in string.ascii_letters + string.digits + '_\'':
localpart = str(i)
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# valid length range
for i in range(1, 65):
localpart = ''.join(random.choice(string.ascii_letters) for x in range(i))
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# start must be alphanum, underscore, dash, or apostrophe
for i in string.ascii_letters + string.digits + '_-\'':
localpart = str(i) + 'aaaaa'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# end must be alphanum, underscore, dash, or apostrophe
for i in string.ascii_letters + string.digits + '_-\'':
localpart = 'aaaaa' + str(i)
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# must be alphanum, underscore, dash, apostrophe, dots
for i in string.ascii_letters + string.digits + '_-\'.':
localpart = 'aaa' + str(i) + '000'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# everything after plus (+) is ignored
for localpart in ['aa+', 'aa+tag', 'aa+tag+tag', 'aa++tag', 'aa+' + ATOM_STR]:
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
def test_hotmail_pass():
with patch.object(address, 'mail_exchanger_lookup') as mock_method:
mock_method.side_effect = mock_exchanger_lookup
# valid length range
for i in range(1, 65):
localpart = ''.join(random.choice(string.ascii_letters) for x in range(i))
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# start must be letter or number
for i in string.ascii_letters + string.digits:
localpart = str(i) + 'a'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# end must be letter or number
for i in string.ascii_letters + string.digits + '-_':
localpart = 'a' + str(i)
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# must be letter, num, period, hyphen, or underscore
for i in string.ascii_letters + string.digits + '.-_':
localpart = 'a' + str(i) + '0'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# only zero or one plus allowed
for i in range(0, 2):
localpart = 'aa' + '+'*i + '00'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# allow multiple periods
localpart = 'aa.bb.00'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
def test_gmail_pass():
with patch.object(validate, 'mail_exchanger_lookup') as mock_method:
mock_method.side_effect = mock_exchanger_lookup
# valid length range
for i in range(6, 31):
localpart = ''.join(random.choice(string.ascii_letters) for x in range(i))
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# start must be letter or num
for i in string.ascii_letters + string.digits:
localpart = str(i) + 'aaaaa'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# end must be letter or number
for i in string.ascii_letters + string.digits:
localpart = 'aaaaa' + str(i)
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# must be letter, num, or dots
for i in string.ascii_letters + string.digits + '.':
localpart = 'aaa' + str(i) + '000'
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# non-consecutive dots (.) within an address are legal
for localpart in ['a.aaaaa', 'aa.aaaa', 'aaa.aaa','aa.aa.aa']:
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
# everything after plus (+) is ignored
for localpart in ['aaaaaa+', 'aaaaaa+tag', 'aaaaaa+tag+tag','aaaaaa++tag', 'aaaaaa+' + ATOM_STR]:
addr = address.validate_address(localpart + DOMAIN)
assert_not_equal(addr, None)
def checkmail(mail):
return bool(address.validate_address(mail))
def checkmail(mail):
return bool(address.validate_address(mail))
