def setUp(self):
self.moderator = ModeratorFactory()
self.standard_user = UserFactory(
full_name='Firsto Namo',
)
self.invited_pending = InvitedPendingFactory()
self.requested_pending = RequestedPendingFactory()
def test_string_method(self):
user1 = UserFactory(full_name='a b')
user2 = UserFactory(full_name='c d')
report = AbuseReportFactory(logged_against=user2,
logged_by=user1)
self.assertEqual(report.__str__(), 'Reported by a b against c d')
def setUp(self):
site = get_current_site(self.client.request)
site.config = SiteConfigFactory(site=site)
self.closed_user = UserFactory(
email='*****@*****.**',
is_closed=True,
)
self.existing_user = UserFactory(email='*****@*****.**', )
def setUp(self):
self.standard_user = UserFactory(email='*****@*****.**')
self.factory = RequestFactory()
self.site = get_current_site(self.client.request)
self.site.config = SiteConfigFactory(site=self.site)
self.closed_user = UserFactory(
full_name='Closed',
email='*****@*****.**',
is_closed=True,
)
def setUp(self):
# Setup Roles
self.mentor = RoleFactory(name='mentor')
self.mentee = RoleFactory(name='mentee')
self.standard_user = UserFactory()
self.client.login(username=self.standard_user.email, password='******')
def test_can_send_connect_email(self):
subject = 'Test email'
template = 'emails/email_base.html'
recipient = UserFactory(email='*****@*****.**')
site = SiteFactory(domain='mydomain.com')
site.config = SiteConfigFactory(site=site)
# Sender != from email, but rather the user who has sent the message
sender = UserFactory(email='*****@*****.**')
url = 'http://testurl.com'
comments = 'comment',
logged_against = UserFactory(email='*****@*****.**')
email = send_connect_email(subject, template, recipient, site, sender,
url, comments, logged_against)
self.assertEqual(email, 1) # send_email returns no. of emails sent
def setUp(self):
site = get_current_site(self.client.request)
site.config = SiteConfigFactory(site=site)
self.standard_user = UserFactory()
# Setup skills
self.django = SkillFactory(name='django')
self.rails = SkillFactory(name='rails')
self.jquery = SkillFactory(name='jquery')
self.client.login(username=self.standard_user.email, password='******')
def setUp(self):
self.site = get_current_site(self.client.request)
self.site.config = SiteConfigFactory(site=self.site)
self.reporting_user = UserFactory()
self.accused_user = UserFactory()
self.moderator = ModeratorFactory()
factory.create_batch(
ModeratorFactory,
10,
moderator=self.moderator,
)
def setUp(self):
self.standard_user = UserFactory()
# Setup users with skills
self.django = SkillFactory(name='django')
self.rails = SkillFactory(name='rails')
self.jquery = SkillFactory(name='jquery')
self.mentor = RoleFactory(name='mentor')
self.mentee = RoleFactory(name='mentee')
self.user_1 = UserFactory(roles=[self.mentor,])
UserSkillFactory(user=self.user_1, skill=self.django)
self.user_2 = UserFactory(roles=[self.mentee,])
UserSkillFactory(user=self.user_2, skill=self.django)
UserSkillFactory(user=self.user_2, skill=self.rails)
self.user_3 = UserFactory(roles=[self.mentor, self.mentee])
UserSkillFactory(user=self.user_3, skill=self.rails)
UserSkillFactory(user=self.user_3, skill=self.jquery)
def test_can_log_moderation_event(self):
msg_type = ModerationLogMsg.INVITATION
user = UserFactory()
moderator = ModeratorFactory()
comment = 'This is my comment'
log = log_moderator_event(msg_type=user,
user=user,
moderator=moderator,
comment=comment)
logs = ModerationLogMsg.objects.all()
self.assertIn(log, logs)
def test_can_match_link_to_brand(self):
github = BrandFactory()
link_user = UserFactory()
link = UserLinkFactory(
user=link_user,
anchor='Github',
url='http://github.com/myaccount/',
)
userlinks = [link]
match_link_to_brand(userlinks)
link = UserLink.objects.get(user=link_user)
self.assertEqual(link.icon, github)
def setUp(self):
self.site = get_current_site(self.client.request)
self.site.config = SiteConfigFactory(site=self.site)
self.standard_user = UserFactory()
self.reporting_user = UserFactory()
self.accused_user = UserFactory()
self.moderator = ModeratorFactory()
self.abuse_report = AbuseReportFactory(
logged_against=self.accused_user,
logged_by=self.reporting_user
)
self.abuse_warning = AbuseWarningFactory(
logged_against=self.accused_user
)
def impl(context):
role1 = Role.objects.get(name='role1')
role2 = Role.objects.get(name='role2')
skill1 = Skill.objects.get(name='skill1')
skill2 = Skill.objects.get(name='skill2')
user1 = UserFactory(email='*****@*****.**')
user1_skill1 = UserSkillFactory(user=user1, skill=skill1)
user1_skill2 = UserSkillFactory(user=user1, skill=skill2)
user2 = UserFactory(email='*****@*****.**', roles=[role1, role2])
user3 = UserFactory(email='*****@*****.**', roles=[
role1,
])
user3_skill1 = UserSkillFactory(user=user3, skill=skill1)
user4 = UserFactory(email='*****@*****.**')
user4_skill2 = UserSkillFactory(user=user4, skill=skill2)
user5 = UserFactory(email='*****@*****.**', roles=[
role2,
])
user5_skill1 = UserSkillFactory(user=user5, skill=skill1)
user5_skill2 = UserSkillFactory(user=user5, skill=skill2)
user6 = UserFactory(email='*****@*****.**', roles=[role1, role2])
user6_skill1 = UserSkillFactory(user=user6, skill=skill1)
user6_skill2 = UserSkillFactory(user=user6, skill=skill2)
user7 = UserFactory(email='*****@*****.**', roles=[
role1,
])
user7_skill2 = UserSkillFactory(user=user7, skill=skill2)
def impl(context):
context.execute_steps('''
given there is a standard user in the database
''')
context.standard_user2 = UserFactory(full_name='Another User',
email='*****@*****.**')
def test_string_method(self):
user = UserFactory(full_name='a b')
skill = SkillFactory(name='MySkill')
user_skill = UserSkillFactory(user=user, skill=skill)
self.assertEqual(user_skill.__str__(), 'a b - MySkill')
def impl(context):
context.closed_user = UserFactory(full_name='Closed User',
email='*****@*****.**',
is_active=False,
is_closed=True)
class UserModelTest(TestCase):
fixtures = ['group_perms']
def setUp(self):
self.moderator = ModeratorFactory()
self.standard_user = UserFactory(
full_name='Firsto Namo',
)
self.invited_pending = InvitedPendingFactory()
self.requested_pending = RequestedPendingFactory()
def test_string_method(self):
self.assertEqual(self.standard_user.__str__(), 'Firsto Namo')
def test_get_full_name(self):
full_name = self.standard_user.get_full_name()
self.assertEqual(full_name, 'Firsto Namo')
def test_get_short_name(self):
short_name = self.standard_user.get_short_name()
self.assertEqual(short_name, 'Firsto')
def test_is_pending_activation(self):
self.assertFalse(self.standard_user.is_pending_activation())
self.assertTrue(self.invited_pending.is_pending_activation())
def test_is_invited_pending_activation(self):
self.assertFalse(self.standard_user.is_invited_pending_activation())
self.assertTrue(self.invited_pending.is_invited_pending_activation())
def test_is_pending_approval(self):
self.assertFalse(self.standard_user.is_pending_approval())
self.assertTrue(self.requested_pending.is_pending_approval())
def test_moderator_can_invite_new_user(self):
user = self.moderator.invite_new_user(email='*****@*****.**',
full_name='standard_user user')
self.assertEqual(user.email, '*****@*****.**')
self.assertEqual(user.full_name, 'standard_user user')
self.assertEqual(user.registration_method, CustomUser.INVITED)
self.assertEqual(user.moderator, self.moderator)
self.assertEqual(user.moderator_decision, CustomUser.PRE_APPROVED)
self.assertIsNotNone(user.decision_datetime)
self.assertIsNotNone(user.auth_token)
def test_standard_user_user_cannot_invite_new_user(self):
with self.assertRaises(PermissionDenied):
self.standard_user.invite_new_user(
email='*****@*****.**',
full_name='standard_user user'
)
def test_moderator_can_reinvite_user(self):
decision_datetime = self.invited_pending.decision_datetime
auth_token = self.invited_pending.auth_token
self.moderator.reinvite_user(user=self.invited_pending,
email='*****@*****.**')
self.assertEqual(self.invited_pending.email, '*****@*****.**')
self.assertNotEqual(self.invited_pending.decision_datetime,
decision_datetime)
self.assertNotEqual(self.invited_pending.auth_token, auth_token)
def test_standard_user_user_cannot_reinvite_user(self):
with self.assertRaises(PermissionDenied):
self.standard_user.reinvite_user(user=self.invited_pending,
email='*****@*****.**')
def test_moderator_can_approve_user_application(self):
self.moderator.approve_user_application(self.requested_pending)
self.assertEqual(self.requested_pending.moderator, self.moderator)
self.assertEqual(self.requested_pending.moderator_decision,
CustomUser.APPROVED)
self.assertIsNotNone(self.requested_pending.decision_datetime)
self.assertIsNotNone(self.requested_pending.auth_token)
def test_standard_user_user_cannot_approve_user_application(self):
with self.assertRaises(PermissionDenied):
self.standard_user.approve_user_application(self.requested_pending)
def test_moderator_can_reject_user_application(self):
self.moderator.reject_user_application(self.requested_pending)
self.assertEqual(self.requested_pending.moderator, self.moderator)
self.assertEqual(self.requested_pending.moderator_decision,
CustomUser.REJECTED)
self.assertIsNotNone(self.requested_pending.decision_datetime)
self.assertIsNotNone(self.requested_pending.auth_token)
def test_standard_user_user_cannot_reject_user_application(self):
with self.assertRaises(PermissionDenied):
self.standard_user.reject_user_application(self.requested_pending)
def setUp(self):
self.user = UserFactory(email='*****@*****.**')
class CustomCustomPasswordResetFormTest(TestCase):
"""
Test our cutomised reset password form.
These tests are a modified version of those found at
django.contrib.auth.tests.testforms
"""
def setUp(self):
self.user = UserFactory(email='*****@*****.**')
def test_invalid_email(self):
form = CustomPasswordResetForm({'email': 'not valid'})
self.assertFalse(form.is_valid())
self.assertEqual(form['email'].errors,
[_('Please enter a valid email address.')])
def test_nonexistent_email(self):
"""
Test nonexistent email address. This should not fail because it would
expose information about registered users.
"""
form = CustomPasswordResetForm({'email': '*****@*****.**'})
self.assertTrue(form.is_valid())
self.assertEqual(len(mail.outbox), 0)
def test_cleaned_data(self):
form = CustomPasswordResetForm({'email': self.user.email})
self.assertTrue(form.is_valid())
form.save(domain_override='example.com')
self.assertEqual(form.cleaned_data['email'], self.user.email)
self.assertEqual(len(mail.outbox), 1)
def test_custom_email_subject(self):
data = {'email': '*****@*****.**'}
form = CustomPasswordResetForm(data)
self.assertTrue(form.is_valid())
# Since we're not providing a request object, we must provide a
# domain_override to prevent the save operation from failing in the
# potential case where contrib.sites is not installed. Refs #16412.
form.save(domain_override='example.com')
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].subject,
'Reset your example.com password')
def test_inactive_user(self):
"""
Test that inactive user cannot receive password reset email.
"""
self.user.is_active = False
self.user.save()
form = CustomPasswordResetForm({'email': self.user.email})
self.assertTrue(form.is_valid())
form.save()
self.assertEqual(len(mail.outbox), 0)
def test_unusable_password(self):
data = {"email": "*****@*****.**"}
form = CustomPasswordResetForm(data)
self.assertTrue(form.is_valid())
self.user.set_unusable_password()
self.user.save()
form = CustomPasswordResetForm(data)
# The form itself is valid, but no email is sent
self.assertTrue(form.is_valid())
form.save()
self.assertEqual(len(mail.outbox), 0)
def setUp(self):
self.standard_user = UserFactory(email='*****@*****.**')
self.existing_user = UserFactory(email='*****@*****.**')
class ReviewAbuseTest(TestCase):
fixtures = ['group_perms']
def setUp(self):
self.site = get_current_site(self.client.request)
self.site.config = SiteConfigFactory(site=self.site)
self.standard_user = UserFactory()
self.reporting_user = UserFactory()
self.accused_user = UserFactory()
self.moderator = ModeratorFactory()
self.abuse_report = AbuseReportFactory(
logged_against=self.accused_user,
logged_by=self.reporting_user
)
self.abuse_warning = AbuseWarningFactory(
logged_against=self.accused_user
)
def post_data(self, decision, comments, report_id=''):
if not report_id:
report_id = self.abuse_report.id
return self.client.post(
reverse('moderation:review-abuse'),
data={
'report_id': report_id,
'decision': decision,
'comments': comments,
},
)
def dismiss_report(self):
return self.post_data(AbuseReport.DISMISS, 'Spam Report')
def warn_user(self):
return self.post_data(AbuseReport.WARN, 'This is a warning')
def ban_user(self):
return self.post_data(AbuseReport.BAN, 'You are banned')
def test_review_abuse_url(self):
self.check_url('/moderation/review-abuse-reports/', review_abuse)
def test_unauthenticated_users_cannot_access_reports(self):
response = self.client.get(reverse('moderation:review-abuse'))
# Unauthenticated user is redirected to login page
self.assertRedirects(
response,
'/accounts/login/?next=/moderation/review-abuse-reports/',
status_code=302
)
def test_authenticated_standard_users_cannot_access_reports(self):
self.client.login(username=self.standard_user.email, password='******')
response = self.client.get(reverse('moderation:review-abuse'))
# User lacking relevant permissions is redirected to login page
self.assertRedirects(
response,
'/accounts/login/?next=/moderation/review-abuse-reports/')
def test_authenticated_moderators_can_access_reports(self):
self.client.login(username=self.moderator.email, password='******')
response = self.client.get(reverse('moderation:review-abuse'))
# User in moderation group can view the page
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'moderation/review_abuse.html')
def test_only_undecided_abuse_reports_in_response(self):
self.client.login(username=self.moderator.email, password='******')
response = self.client.get(reverse('moderation:review-abuse'))
context_reports = response.context['reports']
self.assertEqual(len(context_reports), 1)
self.assertIn(self.abuse_report, context_reports)
def test_previous_warnings_are_attached_to_abuse_report(self):
self.client.login(username=self.moderator.email, password='******')
response = self.client.get(reverse('moderation:review-abuse'))
context_reports = response.context['reports']
self.assertEqual(len(context_reports), 1)
context_report = context_reports[0]
self.assertEqual(len(context_report.prior_warnings), 1)
self.assertIn(self.abuse_warning, context_report.prior_warnings)
def test_moderator_cannot_see_abuse_reports_about_themself(self):
moderator_abuse_report = AbuseReportFactory(
logged_against=self.moderator
)
self.client.login(username=self.moderator.email, password='******')
response = self.client.get(reverse('moderation:review-abuse'))
# We should only see self.abuse_report - as this is the only undecided
# abuse report that is not about the logged in moderator
context_reports = response.context['reports']
self.assertEqual(len(context_reports), 1)
self.assertIn(self.abuse_report, context_reports)
def test_moderator_cannot_see_abuse_reports_when_they_have_made_complaint(self):
moderator_abuse_report = AbuseReportFactory(
logged_by=self.moderator
)
self.client.login(username=self.moderator.email, password='******')
response = self.client.get(reverse('moderation:review-abuse'))
# We should only see self.abuse_report - as this is the only undecided
# abuse report that is not made by the logged in moderator
context_reports = response.context['reports']
self.assertEqual(len(context_reports), 1)
self.assertIn(self.abuse_report, context_reports)
def test_invalid_report_id_raises_404(self):
self.client.login(username=self.moderator.email, password='******')
response = self.post_data(AbuseReport.BAN, 'comment',
report_id='7777777')
self.assertEqual(response.status_code, 404)
def test_can_dismiss_abuse_report(self):
self.client.login(username=self.moderator.email, password='******')
response = self.dismiss_report()
report = AbuseReport.objects.get(id=self.abuse_report.id)
self.assertEqual(report.moderator, self.moderator)
self.assertEqual(report.moderator_decision, AbuseReport.DISMISS)
self.assertEqual(report.moderator_comment, 'Spam Report')
self.assertTrue(report.decision_datetime)
def test_can_log_dismissal(self):
self.client.login(username=self.moderator.email, password='******')
response = self.dismiss_report()
log = ModerationLogMsg.objects.get(comment='Spam Report')
self.assertIsInstance(log, ModerationLogMsg)
self.assertEqual(log.msg_type, ModerationLogMsg.DISMISSAL)
self.assertEqual(log.pertains_to, self.accused_user)
self.assertEqual(log.logged_by, self.moderator)
def test_can_send_dismissal_email_to_reporting_user(self):
self.client.login(username=self.moderator.email, password='******')
response = self.dismiss_report()
expected_subject = ('Your {} Abuse Report has'
' been dismissed'.format(self.site.name))
expected_intro = 'Hi {},'.format('Hello')
expected_content = 'against {} at {}'.format(
self.accused_user.get_full_name(),
self.site.name
)
expected_email = self.site.config.email
expected_footer = 'logged an abuse report at {}'.format(self.site.name)
email = mail.outbox[0]
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(email.subject, expected_subject)
self.assertEqual(email.to[0], self.reporting_user.email)
self.assertIn(expected_content, email.body)
self.assertIn('Spam Report', email.body)
self.assertIn(expected_email, email.body)
self.assertIn(expected_footer, email.body)
def test_can_issue_warning(self):
self.client.login(username=self.moderator.email, password='******')
response = self.warn_user()
report = AbuseReport.objects.get(id=self.abuse_report.id)
self.assertEqual(report.moderator, self.moderator)
self.assertEqual(report.moderator_decision, AbuseReport.WARN)
self.assertEqual(report.moderator_comment, 'This is a warning')
self.assertTrue(report.decision_datetime)
def test_can_log_warning(self):
self.client.login(username=self.moderator.email, password='******')
response = self.warn_user()
log = ModerationLogMsg.objects.get(comment='This is a warning')
self.assertIsInstance(log, ModerationLogMsg)
self.assertEqual(log.msg_type, ModerationLogMsg.WARNING)
self.assertEqual(log.pertains_to, self.accused_user)
self.assertEqual(log.logged_by, self.moderator)
def test_can_send_warning_emails(self):
"""
Test that both the accused user and user who made the report receive
an email.
"""
self.client.login(username=self.moderator.email, password='******')
response = self.warn_user()
self.assertEqual(len(mail.outbox), 2)
# Reporting user's email
reporting_subject = ('{} has been issued a formal '
'warning from {}'.format(
self.accused_user.get_full_name(),
self.site.name,
))
reporting_intro = 'Hi {},'.format(
self.reporting_user.full_name,
)
reporting_content = 'against {} at {}'.format(
self.accused_user.get_full_name(),
self.site.name
)
reporting_content_2 = "{}'s profile and will be flagged".format(
self.accused_user.get_full_name()
)
reporting_footer = 'an abuse report at {}'.format(self.site.name)
email = mail.outbox[0]
self.assertEqual(email.subject, reporting_subject)
self.assertEqual(email.to[0], self.reporting_user.email)
self.assertIn(reporting_content, email.body)
self.assertIn(reporting_content_2, email.body)
self.assertIn(reporting_footer, email.body)
# Offending user's email
offending_subject = 'A formal warning from {}'.format(self.site.name)
offending_intro = 'Hi {},'.format(
self.accused_user.full_name,
)
offending_content = 'against you at {}'.format(self.site.name)
offending_url = self.site.config.email
offending_footer = 'logged against you at {}'.format(self.site.name)
email = mail.outbox[1]
self.assertEqual(email.subject, offending_subject)
self.assertEqual(email.to[0], self.accused_user.email)
self.assertIn(offending_content, email.body)
self.assertIn('This is a warning', email.body)
self.assertIn(offending_url, email.body)
self.assertIn(offending_footer, email.body)
def test_can_ban_user(self):
self.client.login(username=self.moderator.email, password='******')
response = self.ban_user()
report = AbuseReport.objects.get(id=self.abuse_report.id)
user = report.logged_against
self.assertEqual(report.moderator, self.moderator)
self.assertEqual(report.moderator_decision, AbuseReport.BAN)
self.assertEqual(report.moderator_comment, 'You are banned')
self.assertTrue(report.decision_datetime)
self.assertFalse(user.is_active)
def test_can_log_ban(self):
self.client.login(username=self.moderator.email, password='******')
response = self.ban_user()
log = ModerationLogMsg.objects.get(comment='You are banned')
self.assertIsInstance(log, ModerationLogMsg)
self.assertEqual(log.msg_type, ModerationLogMsg.BANNING)
self.assertEqual(log.pertains_to, self.accused_user)
self.assertEqual(log.logged_by, self.moderator)
def test_can_send_ban_emails(self):
"""
Test that both the accused user and user who made the report receive
an email.
"""
self.client.login(username=self.moderator.email, password='******')
response = self.ban_user()
self.assertEqual(len(mail.outbox), 2)
# Reporting user's email
reporting_subject = '{} has been banned from {}'.format(
self.accused_user.get_full_name(),
self.site.name
)
reporting_intro = 'Hi {},'.format(
self.reporting_user.full_name,
)
reporting_content = 'against {} at {}'.format(
self.accused_user.get_full_name(),
self.site.name
)
reporting_content_2 = "decision to ban {}".format(
self.accused_user.get_full_name()
)
reporting_footer = 'an abuse report at {}'.format(self.site.name)
email = mail.outbox[0]
self.assertEqual(email.subject, reporting_subject)
self.assertEqual(email.to[0], self.reporting_user.email)
self.assertIn(reporting_content, email.body)
self.assertIn(reporting_content_2, email.body)
self.assertIn('You are banned', email.body)
self.assertIn(reporting_footer, email.body)
# Offending user's email
offending_subject = ('Your {} account has been terminated'
.format(self.site.name))
offending_intro = 'Hi {},'.format(
self.accused_user.full_name,
)
offending_content = 'against you at {}'.format(self.site.name)
offending_content_2 = "ban you from future use of {}".format(
self.site.name
)
offending_url = self.site.config.email
offending_footer = 'logged against you at {}'.format(self.site.name)
email = mail.outbox[1]
self.assertEqual(email.subject, offending_subject)
self.assertEqual(email.to[0], self.accused_user.email)
self.assertIn(offending_content, email.body)
self.assertIn(offending_content_2, email.body)
self.assertIn('You are banned', email.body)
self.assertIn(offending_url, email.body)
self.assertIn(offending_footer, email.body)
class CustomCustomPasswordResetFormTest(TestCase):
"""
Test our cutomised reset password form.
These tests are a modified version of those found at
django.contrib.auth.tests.testforms
"""
def setUp(self):
self.user = UserFactory(email='*****@*****.**')
def test_invalid_email(self):
form = CustomPasswordResetForm({'email': 'not valid'})
self.assertFalse(form.is_valid())
self.assertEqual(form['email'].errors,
[_('Please enter a valid email address.')])
def test_nonexistent_email(self):
"""
Test nonexistent email address. This should not fail because it would
expose information about registered users.
"""
form = CustomPasswordResetForm({'email': '*****@*****.**'})
self.assertTrue(form.is_valid())
self.assertEqual(len(mail.outbox), 0)
def test_cleaned_data(self):
form = CustomPasswordResetForm({'email': self.user.email})
self.assertTrue(form.is_valid())
form.save(domain_override='example.com')
self.assertEqual(form.cleaned_data['email'], self.user.email)
self.assertEqual(len(mail.outbox), 1)
def test_custom_email_subject(self):
data = {'email': '*****@*****.**'}
form = CustomPasswordResetForm(data)
self.assertTrue(form.is_valid())
# Since we're not providing a request object, we must provide a
# domain_override to prevent the save operation from failing in the
# potential case where contrib.sites is not installed. Refs #16412.
form.save(domain_override='example.com')
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].subject,
'Reset your example.com password')
def test_inactive_user(self):
"""
Test that inactive user cannot receive password reset email.
"""
self.user.is_active = False
self.user.save()
form = CustomPasswordResetForm({'email': self.user.email})
self.assertTrue(form.is_valid())
form.save()
self.assertEqual(len(mail.outbox), 0)
def test_unusable_password(self):
data = {"email": "*****@*****.**"}
form = CustomPasswordResetForm(data)
self.assertTrue(form.is_valid())
self.user.set_unusable_password()
self.user.save()
form = CustomPasswordResetForm(data)
# The form itself is valid, but no email is sent
self.assertTrue(form.is_valid())
form.save()
self.assertEqual(len(mail.outbox), 0)
class ReportAbuseTest(TestCase):
fixtures = ['group_perms']
def setUp(self):
self.site = get_current_site(self.client.request)
self.site.config = SiteConfigFactory(site=self.site)
self.reporting_user = UserFactory()
self.accused_user = UserFactory()
self.moderator = ModeratorFactory()
factory.create_batch(
ModeratorFactory,
10,
moderator=self.moderator,
)
def get_page(self):
return self.client.get(reverse(
'moderation:report-abuse',
kwargs={'user_id': self.accused_user.id}
))
def post_data(self, logged_against, comments):
return self.client.post(
reverse(
'moderation:report-abuse',
kwargs={'user_id': logged_against},
),
data={
'logged_by': self.reporting_user.id,
'logged_against': logged_against,
'comments': comments,
},
)
def report_standard_user(self):
return self.post_data(self.accused_user.id, 'User is a spam account')
def test_url(self):
url = '/moderation/{}/report-abuse/'.format(self.accused_user.id)
self.check_url(url, report_abuse)
def test_unauthenticated_users_cannot_report_abuse(self):
response = self.get_page()
# Unauthenticated user is redirected to login page
self.assertRedirects(
response,
'/accounts/login/?next=/moderation/{}/report-abuse/'.format(
self.accused_user.id
))
def test_authenticated_users_can_report_abuse(self):
self.client.login(username=self.reporting_user.email, password='******')
response = self.get_page()
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'moderation/report_abuse.html')
def test_report_abuse_form_called_in_view(self):
self.client.login(username=self.reporting_user.email, password='******')
response = self.get_page()
expected_html = ('<legend>Log an abuse report '
'against {}</legend>'.format(
self.accused_user.get_full_name()
))
self.assertInHTML(expected_html, response.content.decode("utf-8"))
def test_can_report_abuse(self):
self.client.login(username=self.reporting_user.email, password='******')
response = self.report_standard_user()
report = AbuseReport.objects.get(logged_against=self.accused_user)
self.assertIsInstance(report, AbuseReport)
self.assertEqual(report.logged_by, self.reporting_user)
self.assertEqual(report.logged_against, self.accused_user)
self.assertEqual(report.abuse_comment, 'User is a spam account')
def test_moderators_emailed_about_new_abuse_report(self):
self.client.login(username=self.reporting_user.email, password='******')
response = self.report_standard_user()
expected_subject = 'New abuse report at {}'.format(self.site.name)
expected_intro = 'Hi {},'.format('Hello')
expected_url = ('href="http://testserver/moderation/review-'
'abuse-reports/"')
expected_footer = 'you are a moderator at {}'.format(self.site.name)
email = mail.outbox[0]
recipients = [message.to[0] for message in mail.outbox]
self.assertEqual(len(mail.outbox), 11)
self.assertEqual(email.subject, expected_subject)
self.assertIn(self.moderator.email, recipients)
self.assertIn(expected_url, email.alternatives[0][0])
self.assertIn(expected_footer, email.body)
def test_moderator_not_sent_email_regarding_report_about_themself(self):
"""
Test that a moderator cannot receive an email regarding a report
made against themself.
"""
self.client.login(username=self.reporting_user.email, password='******')
response = self.post_data(self.moderator.id, 'This moderator is nasty')
recipients = []
for email in mail.outbox:
recipients.append(email.to[0])
self.assertEqual(len(mail.outbox), 10) # There are 10 other moderators
self.assertNotIn(self.moderator.email, recipients)
def test_moderator_not_sent_email_when_they_report_abuse(self):
"""
Test that a moderator does not receive an email when they made a
complaint regarding another user.
"""
self.client.login(username=self.moderator.email, password='******')
response = self.post_data(self.accused_user.id, 'This user is nasty')
recipients = []
for email in mail.outbox:
recipients.append(email.to[0])
self.assertEqual(len(mail.outbox), 10) # There are 10 other moderators
self.assertNotIn(self.moderator.email, recipients)
def setUp(self):
self.user = UserFactory(email='*****@*****.**')
def impl(context):
context.standard_user = UserFactory(full_name='Standard User',
email='*****@*****.**',
auth_token='123456')
def setUp(self):
self.standard_user = UserFactory(email='*****@*****.**')
def setUp(self):
self.standard_user = UserFactory()
def setUp(self):
self.existing_user = UserFactory(email='*****@*****.**')
def setUp(self):
site = get_current_site(self.client.request)
site.config = SiteConfigFactory(site=site)
self.standard_user = UserFactory()
self.client.login(username=self.standard_user.email, password='******')
