def test_save(self):
organisation: OrganisationRequest = DraftOrganisationRequestFactory()
manager_data = get_form(ManagerForm).clean()
aidants_form = get_form(AidantRequestFormSet)
aidants_data = aidants_form.data
cleaned_data = {
**{
f"{PersonnelForm.MANAGER_FORM_PREFIX}-{k}": v
for k, v in manager_data.items()
},
**{
k.replace("form-", f"{PersonnelForm.AIDANTS_FORMSET_PREFIX}-"): v
for k, v in aidants_data.items()
},
}
form = PersonnelForm(data=cleaned_data)
self.assertTrue(form.is_valid())
self.assertIs(organisation.manager, None)
self.assertEqual(organisation.aidant_requests.count(), 0)
form.save(organisation)
self.assertEqual(organisation.manager.email, manager_data["email"])
self.assertEqual(organisation.aidant_requests.count(),
len(aidants_form.forms))
self.assertNotEqual(organisation.aidant_requests.count(), 0)
def test_redirect_valid_post_to_validation(self):
organisation: OrganisationRequest = DraftOrganisationRequestFactory()
manager_data = utils.get_form(ManagerForm).data
aidants_data = utils.get_form(AidantRequestFormSet).data
# Logic to manually put prefix on form data
# See https://docs.djangoproject.com/fr/4.0/ref/forms/api/#django.forms.Form.prefix # noqa:E501
cleaned_data = {
**{f"manager-{k}": v for k, v in manager_data.items()},
**{k.replace("form-", "aidants-"): v for k, v in aidants_data.items()},
}
response = self.client.post(
self.get_url(organisation.issuer.issuer_id, organisation.uuid),
cleaned_data,
)
self.assertRedirects(
response,
reverse(
"habilitation_validation",
kwargs={
"issuer_id": str(organisation.issuer.issuer_id),
"uuid": str(organisation.uuid),
},
),
)
def test_is_empty(self):
form: AidantRequestFormSet = get_form(AidantRequestFormSet,
formset_extra=0)
self.assertEqual(form.is_empty(), True)
form: AidantRequestFormSet = get_form(AidantRequestFormSet)
self.assertEqual(form.is_empty(), False)
# Correctly handle erroneous subform case
data = get_form(AidantRequestFormSet, formset_extra=1).data
data["form-0-email"] = " "
form = AidantRequestFormSet(data=data)
self.assertFalse(form.is_valid())
self.assertEqual(form.is_empty(), False)
def test_redirect_valid_post_to_new_aidants(self):
cleaned_data = utils.get_form(
OrganisationRequestForm, type_id=RequestOriginConstants.MEDIATHEQUE.value
).clean()
cleaned_data["type"] = cleaned_data["type"].id
cleaned_data.pop("is_private_org")
cleaned_data.pop("france_services_label")
response = self.client.post(
reverse(
self.pattern_name,
kwargs={"issuer_id": self.issuer.issuer_id},
),
cleaned_data,
)
self.assertTrue(
OrganisationRequest.objects.filter(issuer=self.issuer).exists(),
"No organisationrequest was created in DB",
)
self.assertRedirects(
response,
reverse(
"habilitation_new_aidants",
kwargs={
"issuer_id": self.issuer.issuer_id,
"uuid": self.issuer.organisation_requests.first().uuid,
},
),
)
def test_non_private_org_clears_partner_administration(self):
form = get_form(
OrganisationRequestForm,
is_private_org=False,
partner_administration="Beta.Gouv",
)
self.assertTrue(form.is_valid())
self.assertEqual("", form.cleaned_data["partner_administration"])
def test_no_france_services_label_clears_fs_number(self):
form = get_form(
OrganisationRequestForm,
france_services_label=False,
france_services_number=444666999,
)
self.assertTrue(form.is_valid())
self.assertEqual("", form.cleaned_data["france_services_number"])
def test_get_base_model_form_set(self):
formset: AidantRequestFormSet = get_form(AidantRequestFormSet)
self.assertEqual(len(formset), 10)
self.assertTrue(formset.is_valid())
formset = AidantRequestFormSet(data=formset.data)
self.assertEqual(len(formset), 10)
self.assertTrue(formset.is_valid())
def test_clean_type_other_returns_blank_on_specific_org_type(self):
form = get_form(
OrganisationRequestForm,
type_id=RequestOriginConstants.MEDIATHEQUE.value,
type_other="L'organisation des travaillleurs",
)
self.assertTrue(form.is_valid())
self.assertEqual(form.cleaned_data["type_other"], "")
def test_render_warning_when_issuer_already_exists(self):
issuer: Issuer = IssuerFactory()
data = utils.get_form(IssuerForm).clean()
data["email"] = issuer.email
response = self.client.post(reverse(self.pattern_name), data)
self.assertTemplateUsed(response, "issuer_already_exists_warning.html")
def test_private_org_requires_partner_administration(self):
form = get_form(
OrganisationRequestForm,
ignore_errors=True,
is_private_org=True,
partner_administration="",
)
self.assertFalse(form.is_valid())
self.assertIn("merci de renseigner",
form.errors["partner_administration"][0])
def test_clean_type_other_returns_user_value(self):
form = get_form(
OrganisationRequestForm,
type_id=RequestOriginConstants.OTHER.value,
type_other="L'organisation des travaillleurs",
)
self.assertTrue(form.is_valid())
self.assertEqual(form.cleaned_data["type_other"],
"L'organisation des travaillleurs")
def test_clean_type_zipcode_number_passes(self):
form = get_form(
OrganisationRequestForm,
ignore_errors=True,
type_id=RequestOriginConstants.OTHER.value,
zipcode="01700",
)
self.assertTrue(form.is_valid())
self.assertEqual(form.errors, {})
def test_france_services_label_requires_fs_number(self):
form = get_form(
OrganisationRequestForm,
france_services_label=True,
france_services_number=None,
ignore_errors=True,
)
self.assertFalse(form.is_valid())
self.assertIn("merci de renseigner son numéro",
form.errors["france_services_number"][0])
def test_clean_type_zipcode_not_number_raises_error(self):
form = get_form(
OrganisationRequestForm,
ignore_errors=True,
type_id=RequestOriginConstants.OTHER.value,
zipcode="La Commune",
)
self.assertFalse(form.is_valid())
self.assertEqual(form.errors["zipcode"],
["Veuillez entrer un code postal valide"])
def test_404_on_bad_uuid(self):
response = self.client.get(self.get_url(self.issuer.issuer_id, uuid4()))
self.assertEqual(response.status_code, 404)
cleaned_data = utils.get_form(OrganisationRequestForm).clean()
cleaned_data["type"] = cleaned_data["type"].id
response = self.client.post(
self.get_url(self.issuer.issuer_id, uuid4()),
cleaned_data,
)
self.assertEqual(response.status_code, 404)
def test_404_on_bad_issuer_id(self):
response = self.client.get(
reverse(self.pattern_name, kwargs={"issuer_id": uuid4()})
)
self.assertEqual(response.status_code, 404)
form = utils.get_form(IssuerForm)
response = self.client.post(
reverse(self.pattern_name, kwargs={"issuer_id": uuid4()}),
form.clean(),
)
self.assertEqual(response.status_code, 404)
def test_clean_type_passes(self):
form = get_form(
OrganisationRequestForm,
type_id=RequestOriginConstants.MEDIATHEQUE.value,
)
self.assertTrue(form.is_valid())
self.assertEqual(
form.cleaned_data["type"],
OrganisationType.objects.get(
pk=RequestOriginConstants.MEDIATHEQUE.value),
)
def test_form_submit_modify_multiple_aidants(self):
issuer: Issuer = IssuerFactory()
manager: Manager = ManagerFactory()
organisation: OrganisationRequest = DraftOrganisationRequestFactory(
issuer=issuer,
manager=manager,
)
for _ in range(4):
AidantRequestFactory(organisation=organisation)
self.__open_form_url(issuer, organisation)
modified_aidant_idx = 2
modified_aidant_email = self.selenium.find_element(
By.CSS_SELECTOR,
f"#id_{PersonnelForm.AIDANTS_FORMSET_PREFIX}-{modified_aidant_idx}-email",
).get_attribute("value")
new_aidant_form: AidantRequestForm = get_form(AidantRequestForm)
aidant_data = new_aidant_form.cleaned_data
for field_name in new_aidant_form.fields:
element: WebElement = self.selenium.find_element(
By.CSS_SELECTOR,
f"#id_{PersonnelForm.AIDANTS_FORMSET_PREFIX}-"
f"{modified_aidant_idx}-{field_name}",
)
element.clear()
element.send_keys(aidant_data[field_name])
self.selenium.find_element(By.CSS_SELECTOR, "#add-aidant-btn").click()
self.selenium.find_element(By.CSS_SELECTOR, '[type="submit"]').click()
path = reverse(
"habilitation_validation",
kwargs={
"issuer_id": str(organisation.issuer.issuer_id),
"uuid": str(organisation.uuid),
},
)
WebDriverWait(self.selenium, 10).until(url_matches(f"^.+{path}$"))
organisation.refresh_from_db()
self.assertEqual(organisation.aidant_requests.count(), 4)
with self.assertRaises(AidantRequest.DoesNotExist):
AidantRequest.objects.get(email=modified_aidant_email)
saved_aidant = organisation.aidant_requests.get(email=aidant_data["email"])
for field_name in new_aidant_form.fields:
self.assertEqual(getattr(saved_aidant, field_name), aidant_data[field_name])
def test_404_on_bad_issuer_id(self):
uuid = uuid4()
response: HttpResponse = self.client.get(
reverse(self.pattern_name, kwargs={"issuer_id": uuid})
)
self.assertEqual(response.status_code, 404)
cleaned_data = utils.get_form(OrganisationRequestForm).clean()
response: HttpResponse = self.client.post(
reverse(self.pattern_name, kwargs={"issuer_id": uuid}), cleaned_data
)
self.assertEqual(response.status_code, 404)
def test_404_on_unrelated_issuer_id(self):
unrelated_issuer = IssuerFactory()
response: HttpResponse = self.client.get(
self.get_url(unrelated_issuer.issuer_id, self.organisation.uuid)
)
self.assertEqual(response.status_code, 404)
cleaned_data = utils.get_form(OrganisationRequestForm).clean()
response = self.client.post(
self.get_url(unrelated_issuer.issuer_id, self.organisation.uuid),
cleaned_data,
)
self.assertEqual(response.status_code, 404)
def test_send_email_when_issuer_already_exists(self, send_mail_mock: Mock):
issuer: Issuer = IssuerFactory()
data = utils.get_form(IssuerForm).clean()
data["email"] = issuer.email
self.client.post(reverse(self.pattern_name), data)
send_mail_mock.assert_called_with(
from_email=settings.EMAIL_HABILITATION_ISSUER_EMAIL_ALREADY_EXISTS_FROM,
recipient_list=[issuer.email],
subject=settings.EMAIL_HABILITATION_ISSUER_EMAIL_ALREADY_EXISTS_SUBJECT,
message=ANY,
html_message=ANY,
)
def test_404_on_bad_issuer_id(self):
issuer_id = uuid4()
response: HttpResponse = self.client.get(
self.get_url(issuer_id, self.organisation.uuid)
)
self.assertEqual(response.status_code, 404)
uuid = uuid4()
cleaned_data = utils.get_form(OrganisationRequestForm).clean()
response = self.client.post(
self.get_url(self.organisation.issuer.issuer_id, uuid),
cleaned_data,
)
self.assertEqual(response.status_code, 404)
def test_clean_type_other_unspecified_raises_error(self):
form = get_form(
OrganisationRequestForm,
ignore_errors=True,
type_id=RequestOriginConstants.OTHER.value,
type_other=None,
)
self.assertFalse(form.is_valid())
self.assertEqual(
form.errors["type_other"],
[
f"Le champ « Type de structure si autre » doit être rempli "
f"si la structure est de type {RequestOriginConstants.OTHER.label}."
],
)
def test_redirect_valid_post_to_email_confirmation_wait(self):
temp_uuid = "d6cc0622-b525-41ee-a8dc-c65de9536dba"
with patch(
"aidants_connect_habilitation.models.uuid4",
return_value=UUID(temp_uuid),
):
form = utils.get_form(IssuerForm)
response = self.client.post(reverse(self.pattern_name), form.clean())
self.assertRedirects(
response,
reverse(
"habilitation_issuer_email_confirmation_waiting",
kwargs={"issuer_id": temp_uuid},
),
)
def test_redirect_valid_post_creates_an_email_confirmation(self):
temp_uuid = "d6cc0622-b525-41ee-a8dc-c65de9536dba"
with patch(
"aidants_connect_habilitation.models.uuid4",
return_value=UUID(temp_uuid),
):
with self.assertRaises(IssuerEmailConfirmation.DoesNotExist):
IssuerEmailConfirmation.objects.get(issuer__issuer_id=temp_uuid)
form = utils.get_form(IssuerForm)
self.client.post(reverse(self.pattern_name), form.clean())
try:
IssuerEmailConfirmation.objects.get(issuer__issuer_id=temp_uuid)
except IssuerEmailConfirmation.DoesNotExist:
self.fail(
"Request should have created an instance of IssuerEmailConfirmation"
)
def test_404_on_bad_uuid(self):
response = self.client.get(
self.get_url(self.organisation.issuer.issuer_id, uuid4())
)
self.assertEqual(response.status_code, 404)
cleaned_data = utils.get_form(OrganisationRequestForm).clean()
cleaned_data["type"] = cleaned_data["type"].id
response = self.client.post(
reverse(
self.pattern_name,
kwargs={
"issuer_id": self.organisation.issuer.issuer_id,
"uuid": uuid4(),
},
),
cleaned_data,
)
self.assertEqual(response.status_code, 404)
def test_form_submit_multiple_aidants(self):
issuer: Issuer = IssuerFactory()
manager: Manager = ManagerFactory()
organisation: OrganisationRequest = DraftOrganisationRequestFactory(
issuer=issuer,
manager=manager,
)
# Setup 2 initial requests
AidantRequestFactory(organisation=organisation)
AidantRequestFactory(organisation=organisation)
self.__open_form_url(issuer, organisation)
for i in range(2, 6):
aidant_form: AidantRequestForm = get_form(AidantRequestForm)
aidant_data = aidant_form.cleaned_data
for field_name in aidant_form.fields:
element: WebElement = self.selenium.find_element(
By.CSS_SELECTOR,
f"#id_{PersonnelForm.AIDANTS_FORMSET_PREFIX}-{i}-{field_name}",
)
element.clear()
element.send_keys(aidant_data[field_name])
self.selenium.find_element(By.CSS_SELECTOR, "#add-aidant-btn").click()
self.selenium.find_element(By.CSS_SELECTOR, '[type="submit"]').click()
path = reverse(
"habilitation_validation",
kwargs={
"issuer_id": str(organisation.issuer.issuer_id),
"uuid": str(organisation.uuid),
},
)
WebDriverWait(self.selenium, 10).until(url_matches(f"^.+{path}$"))
organisation.refresh_from_db()
self.assertEqual(organisation.aidant_requests.count(), 6)
def test_can_correctly_add_new_aidants(self):
organisation: OrganisationRequest = OrganisationRequestFactory(
status=RequestStatusConstants.NEW.name, post__aidants_count=2)
self.assertEqual(organisation.aidant_requests.count(), 2)
self.__open_form_url(organisation)
for i in range(2):
aidant_form: AidantRequestForm = get_form(AidantRequestForm)
aidant_data = aidant_form.cleaned_data
for field_name in aidant_form.fields:
element = self.selenium.find_element(
By.CSS_SELECTOR,
f"#id_form-{i}-{field_name}",
)
element.clear()
element.send_keys(aidant_data[field_name])
self.selenium.find_element(By.CSS_SELECTOR,
"#add-aidant-btn").click()
self.selenium.find_element(By.CSS_SELECTOR, '[type="submit"]').click()
path = reverse(
"habilitation_organisation_view",
kwargs={
"issuer_id": str(organisation.issuer.issuer_id),
"uuid": str(organisation.uuid),
},
)
WebDriverWait(self.selenium, 10).until(url_matches(f"^.+{path}$"))
organisation.refresh_from_db()
self.assertEqual(organisation.aidant_requests.count(), 4)
def test_is_not_valid_if_no_aidant_was_declared(self):
manager_data = get_form(ManagerForm, is_aidant=False).clean()
aidants_form = get_form(AidantRequestFormSet, formset_extra=0)
aidants_data = aidants_form.data
cleaned_data = {
**{
f"{PersonnelForm.MANAGER_FORM_PREFIX}-{k}": v
for k, v in manager_data.items()
},
**{
k.replace("form-", f"{PersonnelForm.AIDANTS_FORMSET_PREFIX}-"): v
for k, v in aidants_data.items()
},
}
form = PersonnelForm(data=cleaned_data)
self.assertFalse(form.is_valid())
self.assertEqual(
form.errors,
[
"Vous devez déclarer au moins 1 aidant si le ou la responsable de "
"l'organisation n'est pas elle-même déclarée comme aidante"
],
)
manager_data = get_form(ManagerForm, is_aidant=True).clean()
aidants_form = get_form(AidantRequestFormSet, formset_extra=0)
aidants_data = aidants_form.data
cleaned_data = {
**{
f"{PersonnelForm.MANAGER_FORM_PREFIX}-{k}": v
for k, v in manager_data.items()
},
**{
k.replace("form-", f"{PersonnelForm.AIDANTS_FORMSET_PREFIX}-"): v
for k, v in aidants_data.items()
},
}
form = PersonnelForm(data=cleaned_data)
self.assertTrue(form.is_valid())
self.assertEqual(form.errors, [])
manager_data = get_form(ManagerForm, is_aidant=True).clean()
aidants_form = get_form(AidantRequestFormSet)
aidants_data = aidants_form.data
cleaned_data = {
**{
f"{PersonnelForm.MANAGER_FORM_PREFIX}-{k}": v
for k, v in manager_data.items()
},
**{
k.replace("form-", f"{PersonnelForm.AIDANTS_FORMSET_PREFIX}-"): v
for k, v in aidants_data.items()
},
}
form = PersonnelForm(data=cleaned_data)
self.assertTrue(form.is_valid())
self.assertEqual(form.errors, [])
