def test_client_failure_response(self, mocked_submit):
mocked_submit.return_value = RecaptchaResponse(
is_valid=False, error_codes=["410"]
)
form_params = {"g-recaptcha-response": "PASSED"}
form = DefaultForm(form_params)
self.assertFalse(form.is_valid())
def test_contact_form_posts(
client, mocker, name, email, phone, subject, message, captcha, validity
):
"""Contact Form Tests on the template"""
mocker.patch("captcha.fields.client.submit")
mocker.return_value = RecaptchaResponse(is_valid=True)
response = client.post(
"/contact/",
{
"name": name,
"email": email,
"phone": phone,
"subject": subject,
"message": message,
"g-recaptcha-response": captcha,
},
follow=True,
)
assert response.status_code == 200
# check that emails were sent
assert len(mail.outbox) == 2
assert f"<hr> <br> <br><strong>Sent by:</strong> {name}" in mail.outbox[0].body
assert f"Dear <strong>{name}</strong>" in mail.outbox[1].body
def test_attend_with_payment_creates_paymentdelay(self, mocked_submit):
mocked_submit.return_value = RecaptchaResponse(is_valid=True)
event = G(Event)
G(
AttendanceEvent,
event=event,
registration_start=timezone.now() - timedelta(days=1),
registration_end=timezone.now() + timedelta(days=1),
)
self.event_payment = generate_payment(event,
payment_type=3,
delay=timedelta(days=2))
G(PaymentPrice, price=200, payment=self.event_payment)
url = reverse("attend_event", args=(event.id, ))
form_params = {"g-recaptcha-response": "PASSED"}
G(
Membership,
username=self.user.ntnu_username,
expiration_date=timezone.now() + timedelta(days=1),
)
MarkRuleSet.accept_mark_rules(self.user)
self.client.post(url, form_params, follow=True)
self.assertTrue(PaymentDelay.objects.filter(user=self.user).exists())
def test_attend_twice(self, mocked_submit):
mocked_submit.return_value = RecaptchaResponse(is_valid=True)
event = G(Event)
G(
AttendanceEvent,
event=event,
registration_start=timezone.now() - timedelta(days=1),
registration_end=timezone.now() + timedelta(days=1),
)
url = reverse("attend_event", args=(event.id, ))
form_params = {"g-recaptcha-response": "PASSED"}
G(
Membership,
username=self.user.ntnu_username,
expiration_date=timezone.now() + timedelta(days=1),
)
MarkRuleSet.accept_mark_rules(self.user)
self.client.post(url, form_params, follow=True)
response = self.client.post(url, form_params, follow=True)
self.assertRedirects(response, event.get_absolute_url())
self.assertInMessages("Du er allerede meldt på dette arrangementet.",
response)
def captcha_stub():
stub = mock.patch('captcha.fields.client.submit')
stub.return_value = RecaptchaResponse(is_valid=False,
extra_data={'score': 1.0})
stub.start()
yield 'PASSED'
stub.stop()
def test_required_score_bot_setting(self, mocked_submit):
class VThreeDomainForm(forms.Form):
captcha = fields.ReCaptchaField(widget=widgets.ReCaptchaV3())
mocked_submit.return_value = RecaptchaResponse(is_valid=True,
extra_data={'score': 0})
form_params = {"captcha": "PASSED"}
form = VThreeDomainForm(form_params)
self.assertFalse(form.is_valid())
def test_client_empty_score_threshold_v3(self, mocked_submit):
class VThreeDomainForm(forms.Form):
captcha = fields.ReCaptchaField(widget=widgets.ReCaptchaV3())
mocked_submit.return_value = RecaptchaResponse(
is_valid=True, extra_data={'score': 0.1})
form_params = {"captcha": "PASSED"}
form = VThreeDomainForm(form_params)
self.assertTrue(form.is_valid())
def test_can_signup(self, mocked_submit):
mocked_submit.return_value = RecaptchaResponse(is_valid=True)
response = self.client.post(reverse('signup'),
{'username':'******',
'password1':'aolswontgetme',
'password2':'aolswontgetme',
'g-recaptcha-response': 'PASSED'},
follow=True)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.redirect_chain[0][0], reverse('pool:index'))
def test_login_without_captcha_passed(self, mocked_submit):
mocked_submit.return_value = RecaptchaResponse(is_valid=False)
# send login data to form directly
form = CustomLoginForm(
data={
"username": self.user.email,
"password": self.password,
"g-recaptcha-response": "FAIL",
}
)
self.assertFalse(form.is_valid())
def test_login_without_staff_user(self, mocked_submit):
mocked_submit.return_value = RecaptchaResponse(is_valid=True)
# send login data to form directly
self.user.is_staff = False
self.user.save()
form = CustomLoginForm(
data={
"username": self.user.email,
"password": self.password,
"g-recaptcha-response": "PASSED",
}
)
self.assertFalse(form.is_valid())
def test_attend_invalid_captcha(self, mocked_submit):
mocked_submit.return_value = RecaptchaResponse(is_valid=False)
url = reverse('attend_event', args=(self.event.id,))
form_params = {'g-recaptcha-response': 'WRONG'}
G(AllowedUsername, username=self.user.ntnu_username,
expiration_date=timezone.now() + timedelta(days=1))
self.user.mark_rules = True
self.user.save()
response = self.client.post(url, form_params, follow=True)
self.assertRedirects(response, self.event.get_absolute_url())
self.assertInMessages(
'Du klarte ikke captchaen! Er du en bot?', response)
def test_user_can_contribute(self, mocked_submit):
self.client.login(username=self.user.username, password='******')
feedback_img = create_image(None, 'feedback.jpg')
feedback_file = SimpleUploadedFile('feedback.jpg', feedback_img.getvalue())
mocked_submit.return_value = RecaptchaResponse(is_valid=True)
response = self.client.post(self.contribute_url,
{'level': 'BEGINNER',
'target_description': 'This is a test',
'additional_feedback': 'Yes.. just a test.',
'tasking': 'This is a test',
'feedback_image': feedback_file,
'g-recaptcha-response': 'PASSED'},
follow=True)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.redirect_chain[0][0], '/pool/thanks/')
def test_triggers_the_sending_of_a_contact_email(self, mocked_submit,
client):
mocked_submit.return_value = RecaptchaResponse(is_valid=True)
post_data = {
'first_name': 'John',
'last_name': 'Doe',
'email': '*****@*****.**',
'subject': 'Contact',
'message': 'Hello',
'g-recaptcha-response': 'PASSED',
}
response = client.post(reverse('contact'), post_data, follow=False)
assert response.status_code == 302
assert len(mail.outbox) == 1
assert mail.outbox[0].to[0] == settings.PROJECT_CONTACT_EMAIL
def test_contact_form(mocker, name, email, phone, subject, message, captcha, validity):
"""Contact Form Tests at lower level"""
mocker.patch("captcha.fields.client.submit")
mocker.return_value = RecaptchaResponse(is_valid=True)
form = ContactUs(
{
"name": name,
"email": email,
"phone": phone,
"subject": subject,
"message": message,
"g-recaptcha-response": captcha,
}
)
assert form.is_valid() is validity
def test_attend_invalid_captcha(self, mocked_submit):
mocked_submit.return_value = RecaptchaResponse(is_valid=False)
url = reverse("attend_event", args=(self.event.id, ))
form_params = {"g-recaptcha-response": "WRONG"}
G(
Membership,
username=self.user.ntnu_username,
expiration_date=timezone.now() + timedelta(days=1),
)
MarkRuleSet.accept_mark_rules(self.user)
response = self.client.post(url, form_params, follow=True)
self.assertRedirects(response, self.event.get_absolute_url())
self.assertInMessages("Du klarte ikke captchaen! Er du en bot?",
response)
def test_field_instantiate_values(self, mocked_submit):
mocked_submit.return_value = RecaptchaResponse(is_valid=True)
class NonDefaultForm(forms.Form):
captcha = fields.ReCaptchaField(private_key="NewUpdatedKey",
public_key="NewPubKey")
form_params = {"g-recaptcha-response": "PASSED"}
form = NonDefaultForm(form_params)
self.assertTrue(form.is_valid())
mocked_submit.assert_called_with(
private_key="NewUpdatedKey",
recaptcha_response="PASSED",
remoteip=None,
)
html = form.as_p()
self.assertIn('data-sitekey="NewPubKey"', html)
def test_requires_recaptcha(captcha_submit_mock, settings):
"""
This test creates a new form
that should contain a (required) recaptcha field.
"""
captcha_submit_mock.return_value = RecaptchaResponse(is_valid=True)
settings.RECAPTCHA_PUBLIC_KEY = recaptcha_constants.TEST_PUBLIC_KEY
settings.RECAPTCHA_PRIVATE_KEY = recaptcha_constants.TEST_PRIVATE_KEY
class TestForm(Form, FormWithReCaptcha):
pass
form = TestForm({})
assert not form.is_valid()
form = TestForm({"g-recaptcha-response": "PASSED"})
assert form.is_valid()
def test_attend_before_registration_start(self, mocked_submit):
mocked_submit.return_value = RecaptchaResponse(is_valid=True)
event = G(Event)
G(AttendanceEvent, event=event,
registration_start=timezone.now() + timedelta(days=1),
registration_end=timezone.now() + timedelta(days=2))
url = reverse('attend_event', args=(event.id,))
form_params = {'g-recaptcha-response': 'PASSED'}
G(AllowedUsername, username=self.user.ntnu_username,
expiration_date=timezone.now() + timedelta(days=1))
self.user.mark_rules = True
self.user.save()
response = self.client.post(url, form_params, follow=True)
self.assertRedirects(response, event.get_absolute_url())
self.assertInMessages('Påmeldingen har ikke åpnet enda.', response)
def test_send_mail_bad_header_error(
client, mocker, name, email, phone, subject, message, captcha, validity
):
"""Contact Form: we raise a BadHeaderError when sending mail"""
# Empty the test outbox before we proceed
mail.outbox = []
mocker.patch(
"captcha.fields.client.submit", return_value=RecaptchaResponse(is_valid=True)
)
# mocker.patch('django.core.mail.send_mail', autospec=True, side_effect=BadHeaderError)
mocker.patch(
"{{cookiecutter.project_slug}}.contact.models.send_mail", autospec=True, side_effect=BadHeaderError()
)
response = client.post(
"/contact/",
{
"name": name,
"email": email,
"phone": phone,
"subject": subject,
"message": message,
"g-recaptcha-response": captcha,
},
follow=True,
)
assert response.status_code == 200
# check that emails were not sent (due to BadHeaderError)
assert len(mail.outbox) == 0
# get message from context and check that expected text is there
message = list(response.context.get("messages"))[0]
assert message.tags == "error"
assert "Oops! Something went wrong, please try again" in message.message
def test_client_success_response(self, mocked_submit):
mocked_submit.return_value = RecaptchaResponse(is_valid=True)
form_params = {'recaptcha_response_field': 'PASSED'}
form = TestForm(form_params)
self.assertTrue(form.is_valid())
def test_client_success_response(self, mocked_submit):
mocked_submit.return_value = RecaptchaResponse(is_valid=True)
form_params = {"g-recaptcha-response": "PASSED"}
form = DefaultForm(form_params)
self.assertTrue(form.is_valid())
def test_client_failure_response(self, mocked_submit):
mocked_submit.return_value = RecaptchaResponse(is_valid=False,
error_code="410")
form_params = {'recaptcha_response_field': 'PASSED'}
form = TestForm(form_params)
self.assertFalse(form.is_valid())