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))