def envoi_mail_admin_nouveau_membre(sender, instance, created, **kwargs):
"""
Fonction qui permet d'envoyer un mail à l'admin pour l'informer qu'un nouveau membre a été créé
:param sender: le modèle qui émet le signal (la classe de modèle)
:type sender: django.db.models.base.ModelBase
:param instance: l'instance en cours d'enregistrement
:type instance: lyre_d_alliez.models.Membre
:param created: booléen qui permet de savoir si un nouvel enrgistrement est créé
:type created: bool
"""
if created:
sujet = " Inscription d'un nouveau membre"
message = (
"{} vient de remplir le formulaire d'inscription à la zone des membres.\n\n"
"Merci de vérifier les informations renseignées et de lui attribuer les accès en tant que : \n\n"
"- membre ;\n"
"- membre du bureau ;\n"
"- chef.".format(instance.username))
expediteur = ADMINS["default"]["login"]
destinataire = (ADMINS["default"]["login"], )
try:
send_mail(sujet,
message,
expediteur,
destinataire,
fail_silently=False)
except SMTPException as e:
msg = (
"Problème lors de l'envoi de mail après la création d'un compte membre"
"\n{}".format(e))
raise SMTPException(msg)
def test_send_email_exceptions(self) -> None:
hamlet = self.example_user("hamlet")
from_name = FromAddress.security_email_from_name(language="en")
# Used to check the output
mail = build_email(
"zerver/emails/password_reset",
to_emails=[hamlet],
from_name=from_name,
from_address=FromAddress.NOREPLY,
language="en",
)
self.assertEqual(mail.extra_headers["From"],
f"{from_name} <{FromAddress.NOREPLY}>")
# We test the two cases that should raise an EmailNotDeliveredException
errors = {
f"Unknown error sending password_reset email to {mail.to}": [0],
f"Error sending password_reset email to {mail.to}":
[SMTPException()],
}
for message, side_effect in errors.items():
with mock.patch.object(EmailBackend,
"send_messages",
side_effect=side_effect):
with self.assertLogs(logger=logger) as info_log:
with self.assertRaises(EmailNotDeliveredException):
send_email(
"zerver/emails/password_reset",
to_emails=[hamlet],
from_name=from_name,
from_address=FromAddress.NOREPLY,
language="en",
)
self.assert_length(info_log.records, 2)
self.assertEqual(
info_log.output[0],
f"INFO:{logger.name}:Sending password_reset email to {mail.to}",
)
self.assertTrue(info_log.output[1].startswith(
f"ERROR:zulip.send_email:{message}"))
def test_password_reset_code( # pylint: disable=unused-argument
self, smtp_mock, api, user1, mocker):
# Given
mocker.spy(api, 'email_password_reset_code')
mocker.spy(api.logger, 'error')
# When
api.password_reset_code("*****@*****.**")
# Then
assert (api.email_password_reset_code # pylint: disable=no-member
.call_count == 0)
# When
api.password_reset_code(user1.email)
# Then
assert (api.email_password_reset_code # pylint: disable=no-member
.call_count == 1)
# When
smtp_mock.side_effect = SMTPException()
api.password_reset_code(user1.email)
# Then
assert (api.email_password_reset_code # pylint: disable=no-member
.call_count == 2)
assert (api.logger.error.call_count == 1)
def ntlm_authenticate(smtp, username, password, domain_name=None):
code, response = smtp.docmd(
"AUTH",
"NTLM " + ntlm.create_NTLM_NEGOTIATE_MESSAGE(username).decode('utf-8'))
if code != 334:
raise SMTPException(
"Server did not respond as exected to NTLM negotiate message")
challenge, flags = ntlm.parse_NTLM_CHALLENGE_MESSAGE(
response.decode('utf-8'))
code, response = smtp.docmd(
"",
ntlm.create_NTLM_AUTHENTICATE_MESSAGE(challenge, username, domain_name,
password, flags).decode('utf-8'))
if code != 235:
raise SMTPAuthenticationError(code, response)
def test_add_master_course_staff_to_ccx_with_exception(self):
"""
When exception raise from ``enroll_email`` assert that enrollment skipped for that staff or
instructor.
"""
staff = self.make_staff()
self.assertTrue(CourseStaffRole(self.course.id).has_user(staff))
# adding instructor to master course.
instructor = self.make_instructor()
self.assertTrue(
CourseInstructorRole(self.course.id).has_user(instructor))
with mock.patch.object(CourseEnrollment,
'enroll_by_email',
side_effect=CourseEnrollmentException()):
add_master_course_staff_to_ccx(self.course, self.ccx_locator,
self.ccx.display_name)
self.assertFalse(
CourseEnrollment.objects.filter(course_id=self.ccx_locator,
user=staff).exists())
self.assertFalse(
CourseEnrollment.objects.filter(course_id=self.ccx_locator,
user=instructor).exists())
with mock.patch.object(CourseEnrollment,
'enroll_by_email',
side_effect=SMTPException()):
add_master_course_staff_to_ccx(self.course, self.ccx_locator,
self.ccx.display_name)
self.assertFalse(
CourseEnrollment.objects.filter(course_id=self.ccx_locator,
user=staff).exists())
self.assertFalse(
CourseEnrollment.objects.filter(course_id=self.ccx_locator,
user=instructor).exists())
def envoi_mail(dico_des_donnees):
"""
Fonction qui permet d'envoyer un mail
:param dico_des_donnees: liste des paramètres nommés (sujet, message)
::type dico_des_donnees: dict
"""
expediteur = ADMINS["default"]["login"]
destinataire = (ADMINS["default"]["login"], )
try:
send_mail(dico_des_donnees["sujet"],
dico_des_donnees["message"],
expediteur,
destinataire,
fail_silently=False)
except SMTPException:
msg = dico_des_donnees["message_d_erreur"]
raise SMTPException(msg)
def send_success_message(recipient_name: str,
recipient_email: str,
addon_id: str,
addon_version: str,
pull_request_url: str) -> None:
"""
Send email notification about successful creation of a pull request
:param recipient_name: addon submitter's name
:param recipient_email: addon submitter's email
:param addon_id: addon ID
:param addon_version: addon version
:param pull_request_url: the URL of the pull request
:raises smtplib.SMTPException: on sending failure
"""
html_mesage = render_to_string(
'addon_submitter/emails/success.html',
{
'name': recipient_name,
'addon_id': addon_id,
'addon_version': addon_version,
'pull_request_url': pull_request_url
}
)
try:
send_mail(
subject='Your addon has been accepted',
message=strip_tags(html_mesage),
from_email=settings.EMAIL_FROM_ADDRESS,
recipient_list=[recipient_email],
html_message=html_mesage
)
except SMTPException as ex:
raise SMTPException('Failed to send email to {name} <{email}>!'.format(
name=recipient_name,
email=recipient_email
)) from ex
def ntlm_authenticate(smtp, username, password):
# Send the NTLM Type 1 message -- Authentication Request
msg = ntlm.create_NTLM_NEGOTIATE_MESSAGE(username)
print(msg)
code, response = smtp.docmd(
"AUTH",
"NTLM " + ntlm.create_NTLM_NEGOTIATE_MESSAGE(username).decode())
if code != SMTP_AUTH_CHALLENGE:
raise SMTPException(
"Server did not respond as expected to NTLM negotiate message")
challenge, flags = ntlm.parse_NTLM_CHALLENGE_MESSAGE(response)
user_parts = username.split("\\", 1)
DomainName = user_parts[0].upper()
UserName = user_parts[1]
msg = ntlm.create_NTLM_AUTHENTICATE_MESSAGE(challenge, UserName,
DomainName, password, flags)
print(msg)
code, response = smtp.docmd(
"",
ntlm.create_NTLM_AUTHENTICATE_MESSAGE(challenge, UserName, DomainName,
password, flags).decode())
print(code)
if code != SMTP_AUTH_OKAY:
raise SMTPAuthenticationError(code, response)
def test_catches_smtp_exception(self, mock_send_mail):
mock_send_mail.side_effect = SMTPException()
self.client.post('/accounts/send_login_email', data={
'email': '*****@*****.**'
})
def _on_starttls(self, SMTP_instance):
if self.exception:
raise SMTPException("MOCK TLS ERROR")
if not self.support_tls:
raise SMTPException("The SMTP Server does not support TLS.")
return None
class TestProfile(ViewTestCase):
"""
Tests to make sure the view is properly connected, renders the form
correctly and starts the actual address activation process if a valid
form is submitted.
"""
def setUp(self):
super(TestProfile, self).setUp()
# We create a new user and log that user in.
# We don't use Client().login because it triggers the browserid dance.
self.user = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
self.client.post(reverse('user_login'), {
'username': '******',
'password': '******'
})
def test_view_contains_form(self):
# The view context should contain a form.
response = self.client.get(reverse('user_profile'))
self.assertContains(response,
'You can add other addresses to your profile')
def test_post_invalid_form_shows_error_msg(self):
# Entering an invalid email address should render an error message.
response = self.client.post(reverse('user_profile'), {
'email': 'invalid_email',
'user_email': self.user.email
})
self.assertContains(response, 'Enter a valid email address.')
@patch.object(AddressConfirmationProfile, 'send_confirmation_link')
def test_post_valid_form_shows_success_message(
self, mock_send_confirmation_link):
# Entering a valid email should render the activation_sent template.
response = self.client.post(reverse('user_profile'), {
'email': '*****@*****.**',
'user_email': self.user.email
},
follow=True)
self.assertEqual(mock_send_confirmation_link.call_count, 1)
self.assertContains(
response, 'Please follow the instructions sent '
'via email to confirm the address')
@patch.object(AddressConfirmationProfile, 'send_confirmation_link')
def test_post_valid_form_redirects_on_success(self,
mock_send_confirmation_link):
# Entering a valid email should render the activation_sent template.
response = self.client.post(reverse('user_profile'), {
'email': '*****@*****.**',
'user_email': self.user.email
})
self.assertEqual(mock_send_confirmation_link.call_count, 1)
self.assertRedirects(response, reverse('user_profile'))
@patch.object(AddressConfirmationProfile,
'send_confirmation_link',
side_effect=SMTPException())
def test_post_form_with_smtp_exception(self, mock_send_confirmation_link):
# If a smtp exception occurs display error
response = self.client.post(reverse('user_profile'), {
'email': '*****@*****.**',
'user_email': self.user.email
},
follow=True)
self.assertEqual(mock_send_confirmation_link.call_count, 1)
self.assertContains(
response, 'Currently emails can not be added, '
'please try again later')
def test_change_display_name(self):
# We create a Mailman user, from the django user object.
self.mm_user = MailmanUser.objects.create_from_django(self.user)
self.client.post(reverse('user_profile'), {
'formname': 'displayname',
'display_name': 'testname'
})
# The Mailman user's display name, must have been changed correctly.
self.assertEqual(self.mm_user.display_name, 'testname')
def send_messages(messages):
print("message sent")
raise SMTPException(messages)
class TestAuth(TestCase):
smfhcp_utils = utils.SmfhcpUtils()
es_dao = DummyObject()
es_mapper = DummyObject()
dummy_smfhcp_utils = DummyObject()
dummy_function = MagicMock()
index_general_user_return_false = MagicMock(return_value=False)
index_general_user_return_true = MagicMock(return_value=True)
send_mail_raises_error = MagicMock(side_effect=SMTPException())
send_mail_runs_correctly = MagicMock()
check_email_existence_returns_true = MagicMock(return_value=(True, constants.SENT_INVITE))
check_email_existence_returns_false = MagicMock(return_value=(False, constants.USER_ALREADY_INVITED))
send_invitation_email_returns_false = MagicMock(return_value=False)
send_invitation_email_returns_true = MagicMock(return_value=True)
save_profile_picture_runs_ok = MagicMock(return_value='test_path')
def setUp(self):
self.factory = RequestFactory()
for k in list(self.es_dao.__dict__):
self.es_dao.__delattr__(k)
for k in list(self.es_mapper.__dict__):
self.es_mapper.__delattr__(k)
for k in list(self.dummy_smfhcp_utils.__dict__):
self.dummy_smfhcp_utils.__delattr__(k)
def permission_denied_test(self, url, function):
request1 = self.factory.get(url)
request2 = self.factory.put(url)
request3 = self.factory.delete(url)
request4 = self.factory.head(url)
with self.assertRaises(PermissionDenied):
_ = function(request1)
_ = function(request2)
_ = function(request3)
_ = function(request4)
def login_user_valid_test(self, is_doctor):
self.dummy_smfhcp_utils.find_user = MagicMock(return_value=({
'user_name': TEST_USER_NAME,
'password_hash': TEST_PASSWORD_HASH,
'email': TEST_EMAIL
}, is_doctor))
self.dummy_smfhcp_utils.find_hash = MagicMock(return_value=TEST_PASSWORD_HASH)
post_data = {
'user_name': TEST_USER_NAME,
'password': TEST_PASSWORD
}
request = self.factory.post('/login/signup_email', post_data)
request.session = dict()
response = auth.login_user(request)
self.assertEqual(request.session['user_name'], TEST_USER_NAME)
self.assertEqual(request.session['email'], TEST_EMAIL)
self.assertEqual(request.session['is_authenticated'], True)
self.assertEqual(request.session['is_doctor'], is_doctor)
self.assertEqual(json.loads(response.content.decode(constants.UTF_8))['redirect'], True)
self.assertEqual(json.loads(response.content.decode(constants.UTF_8))['redirect_url'], '/')
self.dummy_smfhcp_utils.find_user.assert_called_with(TEST_USER_NAME, self.es_dao)
self.dummy_smfhcp_utils.find_hash.assert_called_with(TEST_PASSWORD)
def test_login_view_when_user_authenticated(self):
request = self.factory.get('/login')
request.session = dict()
request.session['is_authenticated'] = True
response = auth.login_view(request)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.url, '/')
def test_login_view_when_user_not_authenticated(self):
request = self.factory.get('/login')
request.session = dict()
request.session['is_authenticated'] = False
response = auth.login_view(request)
self.assertEqual(response.status_code, 200)
self.assertGreater(len(response.content.decode(constants.UTF_8)), 0)
request.session = dict()
response = auth.login_view(request)
self.assertEqual(response.status_code, 200)
self.assertGreater(len(response.content.decode(constants.UTF_8)), 0)
@patch('smfhcp.views.auth.es_dao', es_dao)
@patch('smfhcp.views.auth.es_mapper', es_mapper)
@patch('smfhcp.views.auth.index_general_user', dummy_function)
def test_index_when_user_not_present(self):
self.es_dao.get_general_user_by_user_name = MagicMock(side_effect=elasticsearch.NotFoundError())
self.es_mapper.map_general_user = MagicMock(return_value={"test": "body"})
request = self.factory.get('/login_info')
request.session = dict()
request.user = DummyObject()
request.user.username = TEST_USER_NAME
request.user.email = TEST_EMAIL
response = auth.index(request)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.url, '/')
self.es_dao.get_general_user_by_user_name.assert_called_with(TEST_USER_NAME)
self.es_mapper.map_general_user.assert_called_with(TEST_USER_NAME, TEST_EMAIL)
self.dummy_function.assert_called_with({"test": "body"})
@patch('smfhcp.views.auth.es_dao', es_dao)
def test_index_when_user_present(self):
self.es_dao.get_general_user_by_user_name = MagicMock(return_value=True)
request = self.factory.get('/login_info')
request.session = dict()
request.user = DummyObject()
request.user.username = TEST_USER_NAME
request.user.email = TEST_EMAIL
response = auth.index(request)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.url, '/')
self.es_dao.get_general_user_by_user_name.assert_called_with(TEST_USER_NAME)
@patch('smfhcp.views.auth.es_dao', es_dao)
def test_index_general_user_when_third_party_user(self):
body = {
"test": "data",
}
self.es_dao.index_general_user = MagicMock()
self.es_dao.search_users_by_email = MagicMock()
_ = auth.index_general_user(body)
self.es_dao.index_general_user.assert_called_with(body)
self.es_dao.search_users_by_email.assert_not_called()
@patch('smfhcp.views.auth.es_dao', es_dao)
def test_index_general_user_when_custom_user_and_user_exists(self):
body = {
"user_name": TEST_USER_NAME,
"email": TEST_EMAIL,
"password_hash": "test_password_hash"
}
self.es_dao.search_users_by_email = MagicMock(return_value={
"hits": {
"total": {
"value": 1
}
}
})
response = auth.index_general_user(body)
self.assertFalse(response)
self.es_dao.search_users_by_email.assert_called_with(TEST_EMAIL)
self.es_dao.search_users_by_email = MagicMock(return_value={
"hits": {
"total": {
"value": 0
}
}
})
self.es_dao.get_general_user_by_user_name = MagicMock()
response = auth.index_general_user(body)
self.assertFalse(response)
self.es_dao.search_users_by_email.assert_called_with(TEST_EMAIL)
self.es_dao.get_general_user_by_user_name.assert_called_with(TEST_USER_NAME)
self.es_dao.search_users_by_email = MagicMock(return_value={
"hits": {
"total": {
"value": 0
}
}
})
self.es_dao.get_general_user_by_user_name = MagicMock(side_effect=elasticsearch.NotFoundError())
self.es_dao.get_doctor_by_user_name = MagicMock()
response = auth.index_general_user(body)
self.assertFalse(response)
self.es_dao.search_users_by_email.assert_called_with(TEST_EMAIL)
self.es_dao.get_general_user_by_user_name.assert_called_with(TEST_USER_NAME)
self.es_dao.get_doctor_by_user_name.assert_called_with(TEST_USER_NAME)
@patch('smfhcp.views.auth.es_dao', es_dao)
def test_index_general_user_when_custom_user_and_user_does_not_exist(self):
body = {
"user_name": TEST_USER_NAME,
"email": TEST_EMAIL,
"password_hash": "test_password_hash"
}
self.es_dao.search_users_by_email = MagicMock(return_value={
"hits": {
"total": {
"value": 0
}
}
})
self.es_dao.get_general_user_by_user_name = MagicMock(side_effect=elasticsearch.NotFoundError())
self.es_dao.get_doctor_by_user_name = MagicMock(side_effect=elasticsearch.NotFoundError())
self.es_dao.index_general_user = MagicMock()
response = auth.index_general_user(body)
self.assertTrue(response)
self.es_dao.search_users_by_email.assert_called_with(TEST_EMAIL)
self.es_dao.get_general_user_by_user_name.assert_called_with(TEST_USER_NAME)
self.es_dao.get_doctor_by_user_name.assert_called_with(TEST_USER_NAME)
self.es_dao.index_general_user.assert_called_with(body)
def test_signup_email_when_request_not_post(self):
self.permission_denied_test('/login/signup_email', auth.signup_email)
@patch('smfhcp.views.auth.es_mapper', es_mapper)
@patch('smfhcp.views.auth.index_general_user', index_general_user_return_false)
def test_signup_email_when_user_already_exists(self):
self.es_mapper.map_general_user = MagicMock(return_value={"test": "data"})
post_data = {
'user_name': TEST_USER_NAME,
'password': TEST_PASSWORD,
'email': TEST_EMAIL
}
request = self.factory.post('/login/signup_email', post_data)
response = auth.signup_email(request)
self.assertEqual(json.loads(response.content.decode(constants.UTF_8))['message'],
constants.USER_OR_EMAIL_ALREADY_EXISTS_MESSAGE)
self.index_general_user_return_false.assert_called_with({"test": "data"})
self.es_mapper.map_general_user.assert_called_with(TEST_USER_NAME, TEST_EMAIL, password=TEST_PASSWORD)
@patch('smfhcp.views.auth.es_mapper', es_mapper)
@patch('smfhcp.views.auth.index_general_user', index_general_user_return_true)
def test_signup_email_when_user_does_not_exist(self):
self.es_mapper.map_general_user = MagicMock(return_value={"test": "data"})
post_data = {
'user_name': TEST_USER_NAME,
'password': TEST_PASSWORD,
'email': TEST_EMAIL
}
request = self.factory.post('/login/signup_email', post_data)
request.session = dict()
response = auth.signup_email(request)
self.assertEqual(request.session['user_name'], TEST_USER_NAME)
self.assertEqual(request.session['email'], TEST_EMAIL)
self.assertEqual(request.session['is_authenticated'], True)
self.assertEqual(request.session['is_doctor'], False)
self.assertEqual(json.loads(response.content.decode(constants.UTF_8))['redirect'], True)
self.assertEqual(json.loads(response.content.decode(constants.UTF_8))['redirect_url'], '/')
self.index_general_user_return_true.assert_called_with({"test": "data"})
self.es_mapper.map_general_user.assert_called_with(TEST_USER_NAME, TEST_EMAIL, password=TEST_PASSWORD)
def test_login_user_when_request_not_post(self):
self.permission_denied_test('/login/login_user', auth.login_user)
@patch('smfhcp.views.auth.smfhcp_utils', dummy_smfhcp_utils)
@patch('smfhcp.views.auth.es_dao', es_dao)
def test_login_user_when_user_not_valid(self):
self.dummy_smfhcp_utils.find_user = MagicMock(return_value=(None, False))
post_data = {
'user_name': TEST_USER_NAME,
'password': TEST_PASSWORD
}
request = self.factory.post('/login/signup_email', post_data)
request.session = dict()
response = auth.login_user(request)
self.assertEqual(json.loads(response.content.decode(constants.UTF_8))['message'],
constants.USERNAME_AND_PASSWORD_DO_NOT_MATCH)
self.dummy_smfhcp_utils.find_user.assert_called_with(TEST_USER_NAME, self.es_dao)
@patch('smfhcp.views.auth.smfhcp_utils', dummy_smfhcp_utils)
@patch('smfhcp.views.auth.es_dao', es_dao)
def test_login_user_when_user_valid_and_is_doctor(self):
self.login_user_valid_test(True)
@patch('smfhcp.views.auth.smfhcp_utils', dummy_smfhcp_utils)
@patch('smfhcp.views.auth.es_dao', es_dao)
def test_login_user_when_user_valid_and_is_general_user(self):
self.login_user_valid_test(False)
@patch('smfhcp.views.auth.es_dao', es_dao)
def test_check_email_existence_when_email_already_exists(self):
self.es_dao.search_users_by_email = MagicMock(return_value={
"hits": {
"total": {
"value": 1
}
}
})
response = auth.check_email_existence(TEST_EMAIL)
self.assertFalse(response[0])
self.assertEqual(response[1], constants.USER_ALREADY_EXISTS)
self.es_dao.search_users_by_email.assert_called_with(TEST_EMAIL)
@patch('smfhcp.views.auth.es_dao', es_dao)
def test_check_email_existence_when_email_already_invited(self):
self.es_dao.search_users_by_email = MagicMock(return_value={
"hits": {
"total": {
"value": 0
}
}
})
self.es_dao.get_doctor_activation_by_email_id = MagicMock(return_value=True)
response = auth.check_email_existence(TEST_EMAIL)
self.assertFalse(response[0])
self.assertEqual(response[1], constants.USER_ALREADY_INVITED)
self.es_dao.search_users_by_email.assert_called_with(TEST_EMAIL)
self.es_dao.get_doctor_activation_by_email_id.assert_called_with(TEST_EMAIL)
@patch('smfhcp.views.auth.es_dao', es_dao)
def test_check_email_existence_when_email_valid_for_invite(self):
self.es_dao.search_users_by_email = MagicMock(return_value={
"hits": {
"total": {
"value": 0
}
}
})
self.es_dao.get_doctor_activation_by_email_id = MagicMock(side_effect=elasticsearch.NotFoundError())
response = auth.check_email_existence(TEST_EMAIL)
self.assertTrue(response[0])
self.assertEqual(response[1], constants.SENT_INVITE)
self.es_dao.search_users_by_email.assert_called_with(TEST_EMAIL)
self.es_dao.get_doctor_activation_by_email_id.assert_called_with(TEST_EMAIL)
@patch('smfhcp.views.auth.send_mail', send_mail_raises_error)
def test_send_invitation_email_when_error_in_sending_mail(self):
test_email = TEST_EMAIL
test_token = 123
response = auth.send_invitation_email(test_email, test_token)
self.send_mail_raises_error.assert_called_with(constants.INVITE_EMAIL_SUBJECT,
from_email=settings.EMAIL_HOST_USER,
recipient_list=[test_email],
html_message=ANY,
fail_silently=False,
message='')
self.assertFalse(response)
@patch('smfhcp.views.auth.send_mail', send_mail_runs_correctly)
def test_send_invitation_email_when_sent_mail(self):
test_email = TEST_EMAIL
test_token = 123
response = auth.send_invitation_email(test_email, test_token)
self.send_mail_runs_correctly.assert_called_with(constants.INVITE_EMAIL_SUBJECT,
from_email=settings.EMAIL_HOST_USER,
recipient_list=[test_email],
html_message=ANY,
fail_silently=False,
message='')
self.assertTrue(response)
@patch('smfhcp.views.auth.check_email_existence', check_email_existence_returns_false)
def test_send_invite_when_email_invalid(self):
post_data = {
'email': TEST_EMAIL
}
request = self.factory.post('/send_invite', post_data)
response = auth.send_invite(request)
self.assertEqual(json.loads(response.content.decode(constants.UTF_8))['message'],
constants.USER_ALREADY_INVITED)
self.assertEqual(json.loads(response.content.decode(constants.UTF_8))['success'],
False)
self.check_email_existence_returns_false.assert_called_with(TEST_EMAIL)
@patch('smfhcp.views.auth.send_invitation_email', send_invitation_email_returns_false)
@patch('smfhcp.views.auth.check_email_existence', check_email_existence_returns_true)
def test_send_invite_when_mail_not_sent(self):
post_data = {
'email': TEST_EMAIL
}
request = self.factory.post('/send_invite', post_data)
response = auth.send_invite(request)
self.assertEqual(json.loads(response.content.decode(constants.UTF_8))['message'],
constants.COULD_NOT_SEND_EMAIL)
self.assertEqual(json.loads(response.content.decode(constants.UTF_8))['success'],
False)
self.send_invitation_email_returns_false.assert_called_with(TEST_EMAIL, ANY)
self.check_email_existence_returns_true.assert_called_with(TEST_EMAIL)
@patch('smfhcp.views.auth.send_invitation_email', send_invitation_email_returns_true)
@patch('smfhcp.views.auth.check_email_existence', check_email_existence_returns_true)
def test_send_invite_when_mail_sent(self):
post_data = {
'email': TEST_EMAIL
}
request = self.factory.post('/send_invite', post_data)
response = auth.send_invite(request)
self.assertEqual(json.loads(response.content.decode(constants.UTF_8))['message'],
constants.INVITATION_SENT_SUCCESSFULLY)
self.assertEqual(json.loads(response.content.decode(constants.UTF_8))['success'],
True)
self.send_invitation_email_returns_true.assert_called_with(TEST_EMAIL, ANY)
self.check_email_existence_returns_true.assert_called_with(TEST_EMAIL)
def test_doctor_signup_when_user_already_logged_in(self):
request = self.factory.get('/doctor_signup/123')
request.session = dict()
request.session['is_authenticated'] = True
response = auth.doctor_signup(request, 123)
self.assertFalse(response.content.decode(constants.UTF_8).__contains__('value="123"'))
def test_doctor_signup_when_user_not_logged_in(self):
request = self.factory.get('/doctor_signup/123')
request.session = dict()
response = auth.doctor_signup(request, 123)
self.assertTrue(response.content.decode(constants.UTF_8).__contains__('value="123"'))
@patch('smfhcp.views.auth.es_dao', es_dao)
def test_index_doctor(self):
self.es_dao.index_doctor = MagicMock()
post_data = {
'user_name': TEST_USER_NAME,
'email': TEST_EMAIL
}
request = self.factory.post('/create_profile', post_data)
request.session = dict()
auth.index_doctor(request, post_data, 'test_profile_picture')
self.assertEqual(request.session['user_name'], TEST_USER_NAME)
self.assertEqual(request.session['email'], TEST_EMAIL)
self.assertEqual(request.session['is_authenticated'], True)
self.assertEqual(request.session['is_doctor'], True)
self.es_dao.index_doctor.assert_called_with(post_data, 'test_profile_picture')
@patch('smfhcp.views.auth.logout_user', dummy_function)
def test_logout(self):
request = self.factory.get('/logout')
request.session = dict()
response = auth.logout(request)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.url, '/')
self.assertEqual(request.session['user_name'], None)
self.assertEqual(request.session['email'], None)
self.assertEqual(request.session['is_authenticated'], False)
self.assertEqual(request.session['is_doctor'], None)
self.dummy_function.assert_called_with(request)
def test_create_profile_when_request_not_post(self):
self.permission_denied_test('/create_profile', auth.create_profile)
@patch('smfhcp.views.auth.smfhcp_utils', dummy_smfhcp_utils)
@patch('smfhcp.views.auth.es_dao', es_dao)
def test_create_profile_when_user_already_exists(self):
self.dummy_smfhcp_utils.find_user = MagicMock(return_value=('not_none', False))
post_data = {
'user_name': TEST_USER_NAME
}
request = self.factory.post('/create_profile', post_data)
response = auth.create_profile(request)
self.dummy_smfhcp_utils.find_user.assert_called_with(TEST_USER_NAME, self.es_dao)
self.assertEqual(json.loads(response.content.decode(constants.UTF_8))['message'],
constants.USERNAME_ALREADY_EXISTS)
@patch('smfhcp.views.auth.smfhcp_utils', dummy_smfhcp_utils)
@patch('smfhcp.views.auth.es_dao', es_dao)
def test_create_profile_when_user_not_invited(self):
self.dummy_smfhcp_utils.find_user = MagicMock(return_value=(None, False))
self.es_dao.get_doctor_activation_by_email_id = MagicMock(side_effect=elasticsearch.NotFoundError())
post_data = {
'user_name': TEST_USER_NAME,
'email': TEST_EMAIL
}
request = self.factory.post('/create_profile', post_data)
response = auth.create_profile(request)
self.dummy_smfhcp_utils.find_user.assert_called_with(TEST_USER_NAME, self.es_dao)
self.es_dao.get_doctor_activation_by_email_id.assert_called_with(TEST_EMAIL)
self.assertEqual(json.loads(response.content.decode(constants.UTF_8))['message'],
constants.EMAIL_DOES_NOT_HAVE_INVITE)
@patch('smfhcp.views.auth.smfhcp_utils', dummy_smfhcp_utils)
@patch('smfhcp.views.auth.es_dao', es_dao)
def test_create_profile_when_otp_does_not_match(self):
self.dummy_smfhcp_utils.find_user = MagicMock(return_value=(None, False))
self.es_dao.get_doctor_activation_by_email_id = MagicMock(return_value={
'_source': {
'token': '123'
}
})
post_data = {
'user_name': TEST_USER_NAME,
'email': TEST_EMAIL,
'otp': 1234
}
request = self.factory.post('/create_profile', post_data)
response = auth.create_profile(request)
self.dummy_smfhcp_utils.find_user.assert_called_with(TEST_USER_NAME, self.es_dao)
self.es_dao.get_doctor_activation_by_email_id.assert_called_with(TEST_EMAIL)
self.assertEqual(json.loads(response.content.decode(constants.UTF_8))['message'],
constants.OTP_EMAIL_PAIR_DOES_NOT_MATCH)
@patch('smfhcp.views.auth.smfhcp_utils', dummy_smfhcp_utils)
@patch('smfhcp.views.auth.es_dao', es_dao)
@patch('smfhcp.views.auth.index_doctor', dummy_function)
@patch('smfhcp.views.auth.save_profile_picture', save_profile_picture_runs_ok)
def test_create_profile_when_profile_created(self):
self.dummy_smfhcp_utils.find_user = MagicMock(return_value=(None, False))
self.es_dao.get_doctor_activation_by_email_id = MagicMock(return_value={
'_source': {
'token': '123'
}
})
post_data = {
'user_name': TEST_USER_NAME,
'email': TEST_EMAIL,
'otp': 123
}
request = self.factory.post('/create_profile', post_data)
response = auth.create_profile(request)
self.dummy_smfhcp_utils.find_user.assert_called_with(TEST_USER_NAME, self.es_dao)
self.es_dao.get_doctor_activation_by_email_id.assert_called_with(TEST_EMAIL)
self.save_profile_picture_runs_ok.assert_called_with(request)
self.dummy_function.assert_called_with(request, request.POST, 'test_path')
self.assertEqual(json.loads(response.content.decode(constants.UTF_8))['redirect'], True)
self.assertEqual(json.loads(response.content.decode(constants.UTF_8))['redirect_url'], '/')
def sendmail(self, *args, **kwargs):
if with_exc_on_send:
raise SMTPException()
pass
def handle(self, *args, **options):
users_processed = 0
primaries_set = 0
email_errors = 0
user_errors = 0
for user in BadgeUser.objects.all():
users_processed += 1
try:
emails = CachedEmailAddress.objects.filter(user=user)
# handle users who don't have an EmailAddress record
if emails.count() < 1:
try:
existing_email = CachedEmailAddress.objects.get(
email=user.email)
except CachedEmailAddress.DoesNotExist:
new_primary = CachedEmailAddress(user=user,
email=user.email,
verified=False,
primary=True)
new_primary.save()
new_primary.send_confirmation(signup="canvas")
else:
user.delete(
) # User record has no email addresses and email address has been added under another account
continue
emails = CachedEmailAddress.objects.filter(user=user)
# User has emails but none marked primary
elif len([e for e in emails if e.primary is True]) == 0:
new_primary = emails.first()
new_primary.set_as_primary(conditional=True)
self.stdout.write("Set {} as primary for user {}".format(
new_primary.email, user.pk))
primaries_set += 1
prior_confirmations = EmailConfirmation.objects.filter(
email_address=new_primary)
if new_primary.verified is False and not prior_confirmations.exists(
):
try:
new_primary.send_confirmation(signup="canvas")
except SMTPException as e:
raise e
except Exception as e:
raise SMTPException(
"Error sending mail to {} -- {}".format(
new_primary.email, e.message))
except IntegrityError as e:
user_errors += 1
self.stdout.write("Error in user {} record: {}".format(
user.pk, e.message))
continue
except SMTPException as e:
email_errors += 1
self.stdout.write("Could not send mail: {}".format(e.message))
self.stdout.write(
"Done cleaning email: {} users, {} updated primaries, {} user errors, {} email errors."
.format(users_processed, primaries_set, user_errors, email_errors))
send_op = SendEmail(login, password)
assert send_op.auth == (login, password)
def test_send_email_default_init():
empty_values = ("", "")
send_op = SendEmail(*empty_values)
assert send_op.auth == (default_login, default_password)
@patch('smtp_server.test_2_7.smtplib.SMTP')
def test_send_email_run(SMTP_mock):
server = MagicMock()
SMTP_mock.return_value = server
message = Message()
send_op = SendEmail(login, password)
send_op.run(message)
SMTP_mock.assert_called_once_with(default_host, default_port)
server.login.assert_called_once_with(*send_op.auth)
server.sendmail.assert_called_once_with(message.sender, message.receiver,
message.message)
server.quit.assert_called_once_with()
@patch('smtp_server.test_2_7.smtplib.SMTP', side_effect=SMTPException())
def test_send_email_run_error_caught(SMTP_mock):
message = Message()
send_op = SendEmail(login, password)
value = send_op.run(message)
assert value is None
def send_messages(self, email_messages):
raise SMTPException('Dummy')
def raise_error(*args):
raise SMTPException()
def test_send_cr_attachment_available_email_raise_error(
self, MockEmailMultiAlternatives):
MockEmailMultiAlternatives().send.side_effect = [
None, SMTPException('Sending failed'), None
]
EmailTemplateFactory(
subject='To {name}',
body='This message is related to crid {pk} with url {url}',
from_email='*****@*****.**',
type=CR_ATTACHMENT_AVAILABLE)
allegation_123 = AllegationFactory(crid='123')
allegation_456 = AllegationFactory(crid='456')
allegation_789 = AllegationFactory(crid='789')
AttachmentRequestFactory(allegation=allegation_123,
email='*****@*****.**',
noti_email_sent=False)
AttachmentRequestFactory(allegation=allegation_456,
email='*****@*****.**',
noti_email_sent=False)
AttachmentRequestFactory(allegation=allegation_789,
email='*****@*****.**',
noti_email_sent=False)
AttachmentFileFactory.create_batch(2, allegation=allegation_123)
AttachmentFileFactory.create_batch(2, allegation=allegation_456)
AttachmentFileFactory(allegation=allegation_789)
new_attachments = AttachmentFile.objects.all()
send_cr_attachment_available_email(new_attachments)
expect(AttachmentRequest.objects.filter(
noti_email_sent=True).count()).to.eq(2)
expect(
AttachmentRequest.objects.filter(
noti_email_sent=False).count()).to.eq(1)
expect(MockEmailMultiAlternatives).to.be.any_call(
subject='To to.be.notified',
body=
'This message is related to crid 123 with url http://foo.com/complaint/123/\n',
from_email='*****@*****.**',
to=['*****@*****.**'],
cc=['*****@*****.**'],
)
expect(MockEmailMultiAlternatives().attach_alternative).to.be.any_call(
'<p>This message is related to crid 123 with url http://foo.com/complaint/123/</p>\n',
'text/html')
expect(MockEmailMultiAlternatives).to.be.any_call(
subject='To to.be.notified',
body=
'This message is related to crid 456 with url http://foo.com/complaint/456/\n',
from_email='*****@*****.**',
to=['*****@*****.**'],
cc=['*****@*****.**'],
)
expect(MockEmailMultiAlternatives().attach_alternative).to.be.any_call(
'<p>This message is related to crid 456 with url http://foo.com/complaint/456/</p>\n',
'text/html')
expect(MockEmailMultiAlternatives).to.be.any_call(
subject='To to.be.notified',
body=
'This message is related to crid 789 with url http://foo.com/complaint/789/\n',
from_email='*****@*****.**',
to=['*****@*****.**'],
cc=['*****@*****.**'],
)
expect(MockEmailMultiAlternatives().attach_alternative).to.be.any_call(
'<p>This message is related to crid 789 with url http://foo.com/complaint/789/</p>\n',
'text/html')
expect(MockEmailMultiAlternatives().send.call_count).to.be.eq(3)
def broken_send(*args, **kwargs):
"""
Broken send function for email_broken step
"""
raise SMTPException("Failure mocked by aloe_django")
def _on_starttls(self, SMTP_instance):
if self.exception:
raise SMTPException("MOCK TLS ERROR")
return None
def test_send_test_email_does_not_invoke_send_mail_for_empty_email(
self, send_mail):
send_mail.side_effect = SMTPException()
url = reverse('des-test-email')
self.client.post(url, {})
self.assertEqual(send_mail.call_count, 0)
class TestPassword(TestCase):
smfhcp_utils = utils.SmfhcpUtils()
es_dao = DummyObject()
dummy_smfhcp_utils = DummyObject()
send_mail_raises_error = MagicMock(side_effect=SMTPException())
send_mail_runs_correctly = MagicMock()
send_password_reset_email_success = MagicMock()
get_random_string_test = MagicMock(return_value='123456')
def setUp(self):
self.factory = RequestFactory()
for k in list(self.es_dao.__dict__):
self.es_dao.__delattr__(k)
for k in list(self.smfhcp_utils.__dict__):
self.smfhcp_utils.__delattr__(k)
def permission_denied_test(self, url, function):
request1 = self.factory.get(url)
request2 = self.factory.put(url)
request3 = self.factory.delete(url)
request4 = self.factory.head(url)
with self.assertRaises(PermissionDenied):
_ = function(request1)
_ = function(request2)
_ = function(request3)
_ = function(request4)
@patch('smfhcp.views.password.send_mail', send_mail_runs_correctly)
def test_send_password_reset_email_success(self):
res = {'user_name': TEST_USER_NAME, 'email': TEST_EMAIL}
response = password.send_password_reset_email(res, TEST_OTP)
self.send_mail_runs_correctly.assert_called_with(
constants.PASSWORD_RESET_REQUEST_SUBJECT,
from_email=settings.EMAIL_HOST_USER,
recipient_list=[TEST_EMAIL],
html_message=ANY,
fail_silently=False,
message='')
self.assertTrue(response)
@patch('smfhcp.views.password.send_mail', send_mail_raises_error)
def test_send_password_reset_email_failure(self):
res = {'user_name': TEST_USER_NAME, 'email': TEST_EMAIL}
response = password.send_password_reset_email(res, TEST_OTP)
self.send_mail_raises_error.assert_called_with(
constants.PASSWORD_RESET_REQUEST_SUBJECT,
from_email=settings.EMAIL_HOST_USER,
recipient_list=[TEST_EMAIL],
html_message=ANY,
fail_silently=False,
message='')
self.assertFalse(response)
def test_forgot_password_when_request_not_Post(self):
self.permission_denied_test('/forgot_password',
password.forgot_password)
@patch('smfhcp.views.password.es_dao', es_dao)
@patch('smfhcp.views.password.smfhcp_utils', dummy_smfhcp_utils)
def test_forgot_password_when_request_is_Post_but_res_None(self):
self.dummy_smfhcp_utils.find_user = MagicMock(return_value=(None,
None))
post_data = {'user_name': TEST_USER_NAME}
request = self.factory.post('/forgot_password', post_data)
request.session = dict()
response = password.forgot_password(request)
self.assertEqual(
json.loads(response.content.decode(constants.UTF_8))['message'],
'User does not exist')
self.assertEqual(
json.loads(response.content.decode(constants.UTF_8))['success'],
False)
self.dummy_smfhcp_utils.find_user.assert_called_with(
TEST_USER_NAME, self.es_dao)
@patch('smfhcp.views.password.es_dao', es_dao)
@patch('smfhcp.views.password.smfhcp_utils', dummy_smfhcp_utils)
def test_forgot_password_when_password_hash_not_present(self):
self.dummy_smfhcp_utils.find_user = MagicMock(return_value=('not_none',
False))
post_data = {'user_name': TEST_USER_NAME}
request = self.factory.post('/forgot_password', post_data)
request.session = dict()
response = password.forgot_password(request)
self.assertEqual(
json.loads(response.content.decode(constants.UTF_8))['message'],
'User has signed up through a third-party service.')
self.assertEqual(
json.loads(response.content.decode(constants.UTF_8))['success'],
False)
self.dummy_smfhcp_utils.find_user.assert_called_with(
TEST_USER_NAME, self.es_dao)
@patch('smfhcp.views.password.es_dao', es_dao)
@patch('smfhcp.views.password.smfhcp_utils', dummy_smfhcp_utils)
@patch('smfhcp.views.password.send_password_reset_email',
send_password_reset_email_success)
def test_forgot_password_when_user_already_present(self):
self.es_dao.get_forgot_password_token_by_user_name = MagicMock()
self.es_dao.add_token_to_forgot_password_token_list = MagicMock()
self.dummy_smfhcp_utils.find_user = MagicMock(
return_value=({
'user_name': TEST_USER_NAME,
'password_hash': TEST_PASSWORD_HASH,
'email': TEST_EMAIL
}, False))
post_data = {'user_name': TEST_USER_NAME}
request = self.factory.post('/forgot_password', post_data)
request.session = dict()
response = password.forgot_password(request)
self.assertEqual(
json.loads(response.content.decode(constants.UTF_8))['message'],
'A password reset conformation mail has been sent to {}'.format(
TEST_EMAIL))
self.assertEqual(
json.loads(response.content.decode(constants.UTF_8))['success'],
True)
self.es_dao.get_forgot_password_token_by_user_name.assert_called_with(
TEST_USER_NAME)
@patch('smfhcp.views.password.es_dao', es_dao)
@patch('smfhcp.views.password.smfhcp_utils', dummy_smfhcp_utils)
@patch('smfhcp.views.password.send_password_reset_email',
send_password_reset_email_success)
def test_forgot_password_when_user_not_present(self):
self.es_dao.get_forgot_password_token_by_user_name = MagicMock(
side_effect=elasticsearch.NotFoundError)
self.es_dao.index_forgot_password_token = MagicMock()
self.dummy_smfhcp_utils.find_user = MagicMock(
return_value=({
'user_name': TEST_USER_NAME,
'password_hash': TEST_PASSWORD_HASH,
'email': TEST_EMAIL
}, False))
post_data = {'user_name': TEST_USER_NAME}
request = self.factory.post('/forgot_password', post_data)
request.session = dict()
response = password.forgot_password(request)
self.assertEqual(
json.loads(response.content.decode(constants.UTF_8))['message'],
'A password reset conformation mail has been sent to {}'.format(
TEST_EMAIL))
self.assertEqual(
json.loads(response.content.decode(constants.UTF_8))['success'],
True)
self.es_dao.get_forgot_password_token_by_user_name.assert_called_with(
TEST_USER_NAME)
@patch('smfhcp.views.password.es_dao', es_dao)
def test_reset_password_get_user_not_found(self):
self.es_dao.get_forgot_password_token_by_user_name = MagicMock(
side_effect=elasticsearch.NotFoundError)
request = self.factory.get('/reset_password/test_user_name/test_otp')
request.session = dict()
response = password.reset_password(request, TEST_USER_NAME, TEST_OTP)
self.assertEqual(response.status_code, 404)
@patch('smfhcp.views.password.es_dao', es_dao)
def test_reset_password_get_otp_not_found(self):
self.es_dao.get_forgot_password_token_by_user_name = MagicMock()
request = self.factory.get('/reset_password/test_user_name/test_otp')
request.session = dict()
response = password.reset_password(request, TEST_USER_NAME, TEST_OTP)
self.assertEqual(response.status_code, 404)
@patch('smfhcp.views.password.es_dao', es_dao)
def test_reset_password_get_success(self):
self.es_dao.get_forgot_password_token_by_user_name = MagicMock(
return_value={'_source': {
'token': [TEST_OTP]
}})
request = self.factory.get('/reset_password/test_user_name/test_otp')
request.session = dict()
response = password.reset_password(request, TEST_USER_NAME, TEST_OTP)
self.assertEqual(response.status_code, 200)
@patch('smfhcp.views.password.es_dao', es_dao)
@patch('smfhcp.views.password.smfhcp_utils', dummy_smfhcp_utils)
def test_reset_password_post_when_doctor(self):
self.es_dao.delete_forgot_password_token = MagicMock()
self.es_dao.update_password_by_user_name = MagicMock()
self.dummy_smfhcp_utils.find_user = MagicMock(
return_value=({
'user_name': TEST_USER_NAME,
'password_hash': TEST_PASSWORD_HASH,
'email': TEST_EMAIL
}, True))
post_data = {'new_password': '******'}
request = self.factory.post('/reset_password/test_user/test_otp',
post_data)
request.session = dict()
request.session['is_doctor'] = True
request.session['user_name'] = TEST_USER_NAME
request.session['email'] = TEST_EMAIL
request.session['is_authenticated'] = True
response = password.reset_password(request, TEST_USER_NAME, TEST_OTP)
self.assertEqual(response.status_code, 302)
self.es_dao.delete_forgot_password_token.assert_called_with(
TEST_USER_NAME)
self.dummy_smfhcp_utils.find_user.assert_called_with(
TEST_USER_NAME, self.es_dao)
self.es_dao.update_password_by_user_name.asser_called_with(
TEST_USER_NAME, 'new_password', True)
@patch('smfhcp.views.password.es_dao', es_dao)
@patch('smfhcp.views.password.smfhcp_utils', dummy_smfhcp_utils)
def test_reset_password_post_when_general_user(self):
self.es_dao.delete_forgot_password_token = MagicMock()
self.es_dao.update_password_by_user_name = MagicMock()
self.dummy_smfhcp_utils.find_user = MagicMock(
return_value=({
'user_name': TEST_USER_NAME,
'password_hash': TEST_PASSWORD_HASH,
'email': TEST_EMAIL
}, False))
post_data = {'new_password': '******'}
request = self.factory.post('/reset_password/test_user/test_otp',
post_data)
request.session = dict()
request.session['is_doctor'] = False
request.session['user_name'] = TEST_USER_NAME
request.session['email'] = TEST_EMAIL
request.session['is_authenticated'] = True
response = password.reset_password(request, TEST_USER_NAME, TEST_OTP)
self.assertEqual(response.status_code, 302)
self.es_dao.delete_forgot_password_token.assert_called_with(
TEST_USER_NAME)
self.dummy_smfhcp_utils.find_user.assert_called_with(
TEST_USER_NAME, self.es_dao)
self.es_dao.update_password_by_user_name.asser_called_with(
TEST_USER_NAME, 'new_password', False)
def test_reset_password_when_request_not_get_or_post(self):
request = self.factory.put('/reset_password/test_user/test_otp')
with self.assertRaises(PermissionDenied):
_ = password.reset_password(request, TEST_USER_NAME, TEST_OTP)
def send(self, bulk=True):
if getattr(self, 'raise_on_send', False):
raise SMTPException('boom')
else:
super(RaisingMailController, self).send(bulk)
def send(self, msg):
raise SMTPException('some smtp error')
def login(self, user, password, initial_response_ok=True):
"""Log in on an SMTP server that requires authentication.
The arguments are:
- user: The user name to authenticate with.
- password: The password for the authentication.
Keyword arguments:
- initial_response_ok: Allow sending the RFC 4954 initial-response
to the AUTH command, if the authentication methods supports it.
If there has been no previous EHLO or HELO command this session, this
method tries ESMTP EHLO first.
This method will return normally if the authentication was successful.
This method may raise the following exceptions:
SMTPHeloError The server didn't reply properly to
the helo greeting.
SMTPAuthenticationError The server didn't accept the username/
password combination.
SMTPNotSupportedError The AUTH command is not supported by the
server.
SMTPException No suitable authentication method was
found.
"""
self.ehlo_or_helo_if_needed()
if not self.has_extn("auth"):
raise SMTPNotSupportedError(
"SMTP AUTH extension not supported by server.")
# Authentication methods the server claims to support
advertised_authlist = self.esmtp_features["auth"].split()
# Authentication methods we can handle in our preferred order:
preferred_auths = ['CRAM-MD5', 'PLAIN', 'LOGIN']
# We try the supported authentications in our preferred order, if
# the server supports them.
authlist = [
auth for auth in preferred_auths if auth in advertised_authlist
]
if not authlist:
raise SMTPException("No suitable authentication method found.")
# Some servers advertise authentication methods they don't really
# support, so if authentication fails, we continue until we've tried
# all methods.
self.user, self.password = user, password
for authmethod in authlist:
method_name = 'auth_' + authmethod.lower().replace('-', '_')
try:
(code,
resp) = self.auth(authmethod,
getattr(self, method_name),
initial_response_ok=initial_response_ok)
# 235 == 'Authentication successful'
# 503 == 'Error: already authenticated'
if code in (235, 503):
return (code, resp)
except SMTPAuthenticationError as e:
last_exception = e
# We could not login successfully. Return result of last attempt.
raise last_exception
def send_message(msg, reporter, recipients):
if 'dodgy' in str(msg):
raise SMTPException('Oh noes!')
else:
pass
def explode(self):
raise SMTPException('Have you in fact got any cheese here at all? ')