def test_structure_selector(self):
"""
Check that a deactivated member can't access the structure
from dashboard selector
"""
organization2 = PrescriberOrganizationWithMembershipFactory()
guest = organization2.members.first()
organization1 = PrescriberOrganizationWithMembershipFactory()
admin = organization1.members.first()
organization1.members.add(guest)
memberships = guest.prescribermembership_set.all()
self.assertEqual(len(memberships), 2)
# Admin remove guest from structure
self.client.login(username=admin.email, password=DEFAULT_PASSWORD)
url = reverse("prescribers_views:deactivate_member",
kwargs={"user_id": guest.id})
response = self.client.post(url)
self.assertEqual(response.status_code, 302)
self.client.logout()
# guest must be able to login
self.client.login(username=guest.email, password=DEFAULT_PASSWORD)
url = reverse("dashboard:index")
response = self.client.get(url)
# Wherever guest lands should give a 200 OK
self.assertEqual(response.status_code, 200)
# Check response context, only one prescriber organization should remain
self.assertEqual(len(response.context["user_prescriberorganizations"]),
1)
def setUp(self):
self.organization = PrescriberOrganizationWithMembershipFactory()
# Create a second member to make sure emails are also
# sent to regular members
self.organization.members.add(PrescriberFactory())
self.organization.save()
self.sender = self.organization.members.first()
def test_prescriber_organization_multiple_membership(self):
organization1 = PrescriberOrganizationWithMembershipFactory()
user = organization1.members.first()
self.assertTrue(user.prescribermembership_set.get(organization=organization1).is_admin)
organization2 = PrescriberOrganizationWithMembershipFactory()
organization2.members.add(user)
request = self.go_to_dashboard(
user=user,
establishment_session_key=settings.ITOU_SESSION_CURRENT_PRESCRIBER_ORG_KEY,
establishment_pk=organization1.pk,
)
with self.assertNumQueries(1):
result = get_current_organization_and_perms(request)
expected = self.default_result | {
"current_prescriber_organization": organization1,
"user_prescriberorganizations": [organization1, organization2],
"user_is_prescriber_org_admin": True,
"matomo_custom_variables": OrderedDict(
[
("is_authenticated", "yes"),
("account_type", "prescriber"),
("account_sub_type", "prescriber_with_unauthorized_org"),
]
),
}
self.assertDictEqual(expected, result)
def test_active_admin_members(self):
"""
Test that if a user is admin of org_1 and regular user
of org2 he is not considered as admin of org_2.
"""
org_1 = PrescriberOrganizationWithMembershipFactory()
org_1_admin_user = org_1.members.first()
org_2 = PrescriberOrganizationWithMembershipFactory()
org_2.members.add(org_1_admin_user)
self.assertIn(org_1_admin_user, org_1.active_admin_members)
self.assertNotIn(org_1_admin_user, org_2.active_admin_members)
def test_create_user_prescriber_with_existing_siren_other_department(
self, mock_call_ban_geocoding_api):
"""
Test the creation of a user of type prescriber with existing SIREN but in an other department
"""
siret1 = "26570134200056"
siret2 = "26570134200148"
# PrescriberOrganizationWithMembershipFactory.
PrescriberOrganizationWithMembershipFactory(
siret=siret1,
kind=PrescriberOrganization.Kind.SPIP,
department="01")
# Step 1: search organizations with SIRET
url = reverse("signup:prescriber_check_already_exists")
post_data = {
"siret": siret2,
"department": "67",
}
respx.get(f"{settings.API_ENTREPRISE_BASE_URL}/etablissements/{siret2}"
).mock(return_value=httpx.Response(
200, json=ETABLISSEMENT_API_RESULT_MOCK))
response = self.client.post(url, data=post_data)
mock_call_ban_geocoding_api.assert_called_once()
# Step 2: redirect to kind of organization selection.
url = reverse("signup:prescriber_choose_org")
self.assertRedirects(response, url)
def test_members(self):
organization = PrescriberOrganizationWithMembershipFactory()
user = organization.members.first()
self.client.login(username=user.email, password=DEFAULT_PASSWORD)
url = reverse("prescribers_views:members")
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
def create_test_data(self):
siae = SiaeWithMembershipAndJobsFactory(romes=("N1101", "N1105"))
# Only authorized prescribers can add a NIR.
# See User.can_add_nir
prescriber_organization = PrescriberOrganizationWithMembershipFactory(is_authorized=True)
user = prescriber_organization.members.first()
return siae, user
def test_edit(self):
"""Edit a prescriber organization."""
organization = PrescriberOrganizationWithMembershipFactory()
user = organization.members.first()
self.client.login(username=user.email, password=DEFAULT_PASSWORD)
url = reverse("prescribers_views:edit_organization")
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
post_data = {
"description":
"Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
"email": "",
"phone": "0610203050",
"website": "https://famous-siae.com",
}
response = self.client.post(url, data=post_data)
self.assertEqual(response.status_code, 302)
organization = PrescriberOrganization.objects.get(
siret=organization.siret)
self.assertEqual(organization.description, post_data["description"])
self.assertEqual(organization.email, post_data["email"])
self.assertEqual(organization.phone, post_data["phone"])
self.assertEqual(organization.website, post_data["website"])
def test_prescriber_organization_one_membership(self):
organization = PrescriberOrganizationWithMembershipFactory()
user = organization.members.first()
self.assertTrue(
user.prescribermembership_set.get(organization=organization).is_admin
)
factory = RequestFactory()
request = factory.get("/")
request.user = user
middleware = SessionMiddleware()
middleware.process_request(request)
request.session[
settings.ITOU_SESSION_CURRENT_PRESCRIBER_ORG_KEY
] = organization.pk
request.session.save()
with self.assertNumQueries(1):
result = get_current_organization_and_perms(request)
expected = {
"current_prescriber_organization": organization,
"current_siae": None,
"user_is_prescriber_org_admin": True,
"user_is_siae_admin": False,
"user_siae_set": [],
}
self.assertDictEqual(expected, result)
def test_prescriber_signup_with_code(self):
"""Prescriber signup with a code to join an organization."""
organization = PrescriberOrganizationWithMembershipFactory()
url = reverse("signup:prescriber")
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
post_data = {
"first_name": "John",
"last_name": "Doe",
"email": "*****@*****.**",
"password1": "!*p4ssw0rd123-",
"password2": "!*p4ssw0rd123-",
"secret_code": organization.secret_code,
}
response = self.client.post(url, data=post_data)
self.assertEqual(response.status_code, 302)
user = get_user_model().objects.get(email=post_data["email"])
self.assertFalse(user.is_job_seeker)
self.assertTrue(user.is_prescriber)
self.assertFalse(user.is_siae_staff)
self.assertIn(user, organization.members.all())
self.assertEqual(2, organization.members.count())
self.assertIn(organization, user.prescriberorganization_set.all())
self.assertEqual(1, user.prescriberorganization_set.count())
membership = user.prescribermembership_set.get(
organization=organization)
self.assertFalse(membership.is_admin)
def test_prescriber_signup_with_code_to_unauthorized_organization(self):
"""
Prescriber signup (orienter) with a code to join an unauthorized organization.
Organization has a pre-existing admin user who is notified of the signup.
"""
url = reverse("signup:prescriber_orienter")
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
organization = PrescriberOrganizationWithMembershipFactory()
password = "******"
# Ensures that the parent form's clean() method is called by testing
# with a password that does not comply with CNIL recommendations.
post_data = {
"first_name": "John",
"last_name": "Doe",
"email": "*****@*****.**",
"password1": "foofoofoo",
"password2": "foofoofoo",
"secret_code": organization.secret_code,
}
response = self.client.post(url, data=post_data)
self.assertEqual(response.status_code, 200)
self.assertIn(CnilCompositionPasswordValidator.HELP_MSG, response.context["form"].errors["password1"])
post_data = {
"first_name": "John",
"last_name": "Doe",
"email": "*****@*****.**",
"password1": password,
"password2": password,
"secret_code": organization.secret_code,
}
response = self.client.post(url, data=post_data)
self.assertEqual(response.status_code, 302)
self.assertRedirects(response, reverse("account_email_verification_sent"))
# Check `User` state.
user = get_user_model().objects.get(email=post_data["email"])
self.assertFalse(user.is_job_seeker)
self.assertTrue(user.is_prescriber)
self.assertFalse(user.is_siae_staff)
self.assertIn(user, organization.members.all())
self.assertEqual(2, organization.members.count())
membership = user.prescribermembership_set.get(organization=organization)
self.assertFalse(membership.is_admin)
# Check `EmailAddress` state.
self.assertEqual(user.emailaddress_set.count(), 1)
user_email = user.emailaddress_set.first()
self.assertFalse(user_email.verified)
# Check sent emails.
self.assertEqual(len(mail.outbox), 2)
subjects = [email.subject for email in mail.outbox]
self.assertIn("Un nouvel utilisateur vient de rejoindre votre organisation", subjects)
self.assertIn("Confirmer l'adresse email pour la Plateforme de l'inclusion", subjects)
def setUp(self):
self.organization = PrescriberOrganizationWithMembershipFactory(kind=PrescriberOrganization.Kind.CAP_EMPLOI)
self.sender = self.organization.members.first()
self.guest_data = {"first_name": "Léonie", "last_name": "Bathiat", "email": "*****@*****.**"}
self.post_data = POST_DATA | {
"form-0-first_name": self.guest_data["first_name"],
"form-0-last_name": self.guest_data["last_name"],
"form-0-email": self.guest_data["email"],
}
self.client.login(email=self.sender.email, password=DEFAULT_PASSWORD)
def test_edit_with_multiple_memberships_and_same_siret(
self, mock_call_ban_geocoding_api):
"""
Updating information of the prescriber organization must be possible
when user is member of multiple orgs with the same SIRET (and different types)
(was a regression)
"""
organization = PrescriberOrganizationWithMembershipFactory(
kind=PrescriberOrganization.Kind.ML)
siret = organization.siret
user = organization.members.first()
org2 = PrescriberOrganizationWithMembershipFactory(
kind=PrescriberOrganization.Kind.PLIE, siret=siret)
org2.members.add(user)
org2.save()
self.client.login(username=user.email, password=DEFAULT_PASSWORD)
url = reverse("prescribers_views:edit_organization")
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
post_data = {
"siret": siret,
"name": "foo",
"description":
"Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
"address_line_1": "2 Rue de Soufflenheim",
"address_line_2": "",
"city": "Betschdorf",
"post_code": "67660",
"department": "67",
"email": "",
"phone": "0610203050",
"website": "https://famous-siae.com",
}
response = self.client.post(url, data=post_data)
self.assertEqual(response.status_code, 302)
url = reverse("dashboard:index")
self.assertEqual(url, response.url)
def test_accept_existing_user_belongs_to_another_organization(self):
user = PrescriberOrganizationWithMembershipFactory().members.first()
invitation = PrescriberWithOrgSentInvitationFactory(
sender=self.sender,
organization=self.organization,
first_name=user.first_name,
last_name=user.last_name,
email=user.email,
)
self.client.login(email=user.email, password=DEFAULT_PASSWORD)
response = self.client.get(invitation.acceptance_link, follow=True)
self.assert_invitation_is_accepted(response, user, invitation)
def test_form_to_request_for_an_invitation(self,
mock_call_ban_geocoding_api):
siret = "26570134200148"
respx.get(f"{settings.API_ENTREPRISE_BASE_URL}/etablissements/{siret}"
).mock(return_value=httpx.Response(
200, json=ETABLISSEMENT_API_RESULT_MOCK))
prescriber_org = PrescriberOrganizationWithMembershipFactory(
siret=siret)
prescriber_membership = prescriber_org.prescribermembership_set.first()
url = reverse("signup:prescriber_check_already_exists")
post_data = {
"siret": prescriber_org.siret,
"department": prescriber_org.department,
}
response = self.client.post(url, data=post_data)
mock_call_ban_geocoding_api.assert_called_once()
self.assertContains(response, prescriber_org.display_name)
url = reverse("signup:prescriber_request_invitation",
kwargs={"membership_id": prescriber_membership.id})
response = self.client.get(url)
self.assertContains(response, prescriber_org.display_name)
response = self.client.post(url,
data={
"first_name": "Bertrand",
"last_name": "Martin",
"email": "beber"
})
self.assertContains(response, "Saisissez une adresse e-mail valide.")
requestor = {
"first_name": "Bertrand",
"last_name": "Martin",
"email": "*****@*****.**"
}
response = self.client.post(url, data=requestor)
self.assertEqual(response.status_code, 302)
self.assertEqual(len(mail.outbox), 1)
mail_subject = mail.outbox[0].subject
self.assertIn(f"Demande pour rejoindre {prescriber_org.display_name}",
mail_subject)
mail_body = mail.outbox[0].body
self.assertIn(prescriber_membership.user.get_full_name().title(),
mail_body)
self.assertIn(prescriber_membership.organization.display_name,
mail_body)
invitation_url = "%s?%s" % (
reverse("invitations_views:invite_prescriber_with_org"),
urlencode(requestor))
self.assertIn(invitation_url, mail_body)
def test_deactivate_with_no_perms(self):
"""
Non-admin user can't change memberships
"""
organization = PrescriberOrganizationWithMembershipFactory()
guest = PrescriberFactory()
organization.members.add(guest)
self.client.login(username=guest.email, password=DEFAULT_PASSWORD)
url = reverse("prescribers_views:deactivate_member",
kwargs={"user_id": guest.id})
response = self.client.post(url)
self.assertEqual(response.status_code, 403)
def test_accept_existing_user_is_not_employer(self):
user = PrescriberOrganizationWithMembershipFactory().members.first()
invitation = SentSiaeStaffInvitationFactory(
first_name=user.first_name,
last_name=user.last_name,
email=user.email,
)
self.client.login(email=user.email, password=DEFAULT_PASSWORD)
response = self.client.get(invitation.acceptance_link, follow=True)
self.assertEqual(response.status_code, 403)
self.assertFalse(invitation.accepted)
def test_invite_existing_user_is_prescriber(self):
guest = PrescriberOrganizationWithMembershipFactory().members.first()
self.client.login(email=self.sender.email, password=DEFAULT_PASSWORD)
self.post_data.update({
"form-0-first_name": guest.first_name,
"form-0-last_name": guest.last_name,
"form-0-email": guest.email,
})
response = self.client.post(INVITATION_URL, data=self.post_data)
# The form is invalid
self.assertFalse(response.context["formset"].is_valid())
self.assertIn("email", response.context["formset"].errors[0])
self.assertEqual(response.context["formset"].errors[0]["email"][0],
"Cet utilisateur n'est pas un employeur.")
self.assertEqual(SiaeStaffInvitation.objects.count(), 0)
def test_invite_existing_user_is_prescriber(self):
guest = PrescriberOrganizationWithMembershipFactory().members.first()
self.client.login(email=self.sender.email, password=DEFAULT_PASSWORD)
post_data = {
"form-TOTAL_FORMS": "1",
"form-INITIAL_FORMS": "0",
"form-MIN_NUM_FORMS": "",
"form-MAX_NUM_FORMS": "",
"form-0-first_name": guest.first_name,
"form-0-last_name": guest.last_name,
"form-0-email": guest.email,
}
response = self.client.post(self.send_invitation_url, data=post_data)
# Make sure form is not valid
self.assertFalse(response.context["formset"].is_valid())
self.assertTrue(response.context["formset"].errors[0].get("email"))
def test_get_user_info_for_authorized_prescriber(self):
prescriber_organization = PrescriberOrganizationWithMembershipFactory(is_authorized=True)
user = prescriber_organization.members.first()
factory = RequestFactory()
request = factory.get("/")
request.user = user
middleware = SessionMiddleware(get_response_for_middlewaremixin)
middleware.process_request(request)
# Simulate ItouCurrentOrganizationMiddleware.
request.session[settings.ITOU_SESSION_CURRENT_PRESCRIBER_ORG_KEY] = prescriber_organization.pk
request.session.save()
user_info = get_user_info(request)
self.assertEqual(user_info.user, user)
self.assertEqual(user_info.kind, KIND_PRESCRIBER)
self.assertEqual(user_info.prescriber_organization, prescriber_organization)
self.assertEqual(user_info.is_authorized_prescriber, True)
self.assertEqual(user_info.siae, None)
def test_self_deactivation(self):
"""
A user, even if admin, can't self-deactivate
(must be done by another admin)
"""
organization = PrescriberOrganizationWithMembershipFactory()
admin = organization.members.filter(
prescribermembership__is_admin=True).first()
memberships = admin.prescribermembership_set.all()
membership = memberships.first()
self.client.login(username=admin.email, password=DEFAULT_PASSWORD)
url = reverse("prescribers_views:deactivate_member",
kwargs={"user_id": admin.id})
response = self.client.post(url)
self.assertEqual(response.status_code, 403)
# Trying to change self membership is not allowed
# but does not raise an error (does nothing)
membership.refresh_from_db()
self.assertTrue(membership.is_active)
def test_apply_as_authorized_prescriber_for_approval_in_waiting_period(
self):
"""Apply as authorized prescriber for a job seeker with an approval in waiting period."""
siae = SiaeWithMembershipAndJobsFactory(romes=("N1101", "N1105"))
job_seeker = JobSeekerFactory()
# Create an approval in waiting period.
end_at = datetime.date.today() - relativedelta(days=30)
start_at = end_at - relativedelta(years=2)
ApprovalFactory(user=job_seeker, start_at=start_at, end_at=end_at)
prescriber_organization = PrescriberOrganizationWithMembershipFactory(
is_authorized=True)
user = prescriber_organization.members.first()
self.client.login(username=user.email, password=DEFAULT_PASSWORD)
url = reverse("apply:start", kwargs={"siae_pk": siae.pk})
# Follow all redirections…
response = self.client.get(url, follow=True)
# …until a job seeker has to be determined…
self.assertEqual(response.status_code, 200)
last_url = response.redirect_chain[-1][0]
self.assertEqual(
last_url,
reverse("apply:step_job_seeker", kwargs={"siae_pk": siae.pk}))
# …choose one, then follow all redirections…
post_data = {"email": job_seeker.email}
response = self.client.post(last_url, data=post_data, follow=True)
# …until the eligibility step which should trigger a 200 OK.
self.assertEqual(response.status_code, 200)
last_url = response.redirect_chain[-1][0]
self.assertEqual(
last_url,
reverse("apply:step_eligibility", kwargs={"siae_pk": siae.pk}))
def test_create_user_prescriber_with_existing_siren_same_department(
self, mock_call_ban_geocoding_api):
"""
Test the creation of a user of type prescriber with existing SIREN in a same department
"""
siret1 = "26570134200056"
siret2 = "26570134200148"
existing_org_with_siret = PrescriberOrganizationWithMembershipFactory(
siret=siret1,
kind=PrescriberOrganization.Kind.SPIP,
department="67")
# Search organizations with SIRET
url = reverse("signup:prescriber_check_already_exists")
post_data = {
"siret": siret2,
"department": "67",
}
respx.get(f"{settings.API_ENTREPRISE_BASE_URL}/etablissements/{siret2}"
).mock(return_value=httpx.Response(
200, json=ETABLISSEMENT_API_RESULT_MOCK))
response = self.client.post(url, data=post_data)
mock_call_ban_geocoding_api.assert_called_once()
self.assertContains(response, existing_org_with_siret.display_name)
# Request for an invitation link.
prescriber_membership = (PrescriberMembership.objects.filter(
organization=existing_org_with_siret).active().select_related(
"user").order_by("-is_admin", "joined_at").first())
self.assertContains(
response,
reverse("signup:prescriber_request_invitation",
kwargs={"membership_id": prescriber_membership.id}),
)
# New organization link.
self.assertContains(response, reverse("signup:prescriber_choose_org"))
def test_prescriber_organization_one_membership(self):
organization = PrescriberOrganizationWithMembershipFactory()
user = organization.members.first()
self.assertTrue(
user.prescribermembership_set.get(
organization=organization).is_admin)
factory = RequestFactory()
request = factory.get("/")
request.user = user
middleware = SessionMiddleware()
middleware.process_request(request)
request.session[
settings.ITOU_SESSION_CURRENT_PRESCRIBER_ORG_KEY] = organization.pk
request.session.save()
with self.assertNumQueries(1):
result = get_current_organization_and_perms(request)
expected = {
"current_prescriber_organization":
organization,
"current_siae":
None,
"user_is_prescriber_org_admin":
True,
"user_is_siae_admin":
False,
"user_siae_set": [],
"matomo_custom_variables":
OrderedDict([
("is_authenticated", "yes"),
("account_type", "prescriber"),
("account_sub_type", "prescriber_with_unauthorized_org"),
]),
}
self.assertDictEqual(expected, result)
def setUp(self):
"""
Create three organizations with two members each:
- pole_emploi: job seekers agency.
- l_envol: an emergency center for homeless people.
- hit_pit: a boxing gym looking for boxers.
Pole Emploi prescribers:
- Thibault
- laurie
L'envol prescribers:
- Audrey
- Manu
Hit Pit staff:
- Eddie
"""
# Pole Emploi
pole_emploi = AuthorizedPrescriberOrganizationWithMembershipFactory(
name="Pôle emploi", membership__user__first_name="Thibault"
)
PrescriberMembershipFactory(organization=pole_emploi, user__first_name="Laurie")
thibault_pe = pole_emploi.members.get(first_name="Thibault")
laurie_pe = pole_emploi.members.get(first_name="Laurie")
# L'Envol
l_envol = PrescriberOrganizationWithMembershipFactory(name="L'Envol", membership__user__first_name="Manu")
PrescriberMembershipFactory(organization=l_envol, user__first_name="Audrey")
audrey_envol = l_envol.members.get(first_name="Audrey")
# Hit Pit
hit_pit = SiaeWithMembershipAndJobsFactory(name="Hit Pit", membership__user__first_name="Eddie")
eddie_hit_pit = hit_pit.members.get(first_name="Eddie")
# Now send applications
for i, state in enumerate(JobApplicationWorkflow.states):
creation_date = timezone.now() - timezone.timedelta(days=i)
job_application = JobApplicationSentByPrescriberFactory(
to_siae=hit_pit,
state=state,
created_at=creation_date,
sender=thibault_pe,
sender_prescriber_organization=pole_emploi,
)
maggie = job_application.job_seeker
maggie.save(update_fields={"first_name": "Maggie"})
JobApplicationSentByPrescriberFactory(
to_siae=hit_pit, sender=laurie_pe, sender_prescriber_organization=pole_emploi, job_seeker=maggie
)
self.prescriber_base_url = reverse("apply:list_for_prescriber")
self.job_seeker_base_url = reverse("apply:list_for_job_seeker")
self.siae_base_url = reverse("apply:list_for_siae")
self.prescriber_exports_url = reverse("apply:list_for_prescriber_exports")
self.siae_exports_url = reverse("apply:list_for_siae_exports")
# Variables available for unit tests
self.pole_emploi = pole_emploi
self.hit_pit = hit_pit
self.l_envol = l_envol
self.thibault_pe = thibault_pe
self.laurie_pe = laurie_pe
self.eddie_hit_pit = eddie_hit_pit
self.audrey_envol = audrey_envol
self.maggie = maggie
def test_apply_to_a_geiq_as_authorized_prescriber(self):
"""Apply to a GEIQ as authorized prescriber."""
siae = SiaeWithMembershipAndJobsFactory(kind=Siae.KIND_GEIQ, romes=("N1101", "N1105"))
prescriber_organization = PrescriberOrganizationWithMembershipFactory(is_authorized=True)
user = prescriber_organization.members.first()
self.client.login(username=user.email, password=DEFAULT_PASSWORD)
job_seeker = JobSeekerFactory()
# Entry point.
# ----------------------------------------------------------------------
url = reverse("apply:start", kwargs={"siae_pk": siae.pk})
response = self.client.get(url)
self.assertEqual(response.status_code, 302)
session = self.client.session
session_data = session[settings.ITOU_SESSION_JOB_APPLICATION_KEY]
expected_session_data = self.default_session_data | {
"to_siae_pk": siae.pk,
}
self.assertDictEqual(session_data, expected_session_data)
next_url = reverse("apply:step_sender", kwargs={"siae_pk": siae.pk})
self.assertEqual(response.url, next_url)
# Step determine the sender.
# ----------------------------------------------------------------------
response = self.client.get(next_url)
self.assertEqual(response.status_code, 302)
session = self.client.session
session_data = session[settings.ITOU_SESSION_JOB_APPLICATION_KEY]
expected_session_data = self.default_session_data | {
"to_siae_pk": siae.pk,
"sender_pk": user.pk,
"sender_kind": JobApplication.SENDER_KIND_PRESCRIBER,
"sender_prescriber_organization_pk": prescriber_organization.pk,
}
self.assertDictEqual(session_data, expected_session_data)
next_url = reverse("apply:step_check_job_seeker_nir", kwargs={"siae_pk": siae.pk})
self.assertEqual(response.url, next_url)
# Step determine the job seeker.
# ----------------------------------------------------------------------
response = self.client.get(next_url)
self.assertEqual(response.status_code, 200)
post_data = {"nir": job_seeker.nir, "confirm": 1}
response = self.client.post(next_url, data=post_data)
self.assertEqual(response.status_code, 302)
next_url = reverse("apply:step_check_job_seeker_info", kwargs={"siae_pk": siae.pk})
self.assertEqual(response.url, next_url)
# Step eligibility (not required when applying to a GEIQ).
# ----------------------------------------------------------------------
# Follow all redirections…
response = self.client.post(next_url, follow=True)
self.assertEqual(response.status_code, 200)
self.assertFalse(EligibilityDiagnosis.objects.has_considered_valid(job_seeker, for_siae=siae))
# …until it hits the job application page.
last_url = response.redirect_chain[-1][0]
self.assertEqual(last_url, reverse("apply:step_application", kwargs={"siae_pk": siae.pk}))
# Step application.
# ----------------------------------------------------------------------
response = self.client.get(last_url)
self.assertEqual(response.status_code, 200)
post_data = {
"selected_jobs": [siae.job_description_through.first().pk, siae.job_description_through.last().pk],
"message": "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
"resume_link": "https://server.com/rockie-balboa.pdf",
}
response = self.client.post(last_url, data=post_data)
self.assertEqual(response.status_code, 302)
next_url = reverse("apply:step_application_sent", kwargs={"siae_pk": siae.pk})
self.assertEqual(response.url, next_url)
job_application = JobApplication.objects.get(job_seeker=job_seeker, sender=user, to_siae=siae)
self.assertEqual(job_application.sender_kind, JobApplication.SENDER_KIND_PRESCRIBER)
self.assertEqual(job_application.sender_siae, None)
self.assertEqual(job_application.sender_prescriber_organization, prescriber_organization)
self.assertEqual(job_application.state, job_application.state.workflow.STATE_NEW)
self.assertEqual(job_application.message, post_data["message"])
self.assertEqual(job_application.answer, "")
self.assertEqual(job_application.selected_jobs.count(), 2)
self.assertEqual(job_application.selected_jobs.first().pk, post_data["selected_jobs"][0])
self.assertEqual(job_application.selected_jobs.last().pk, post_data["selected_jobs"][1])
self.assertEqual(job_application.resume_link, post_data["resume_link"])
def test_apply_as_authorized_prescriber(self):
"""Apply as authorized prescriber."""
siae = SiaeWithMembershipAndJobsFactory(romes=("N1101", "N1105"))
prescriber_organization = PrescriberOrganizationWithMembershipFactory(is_authorized=True)
user = prescriber_organization.members.first()
self.client.login(username=user.email, password=DEFAULT_PASSWORD)
# Entry point.
# ----------------------------------------------------------------------
url = reverse("apply:start", kwargs={"siae_pk": siae.pk})
response = self.client.get(url)
self.assertEqual(response.status_code, 302)
session = self.client.session
session_data = session[settings.ITOU_SESSION_JOB_APPLICATION_KEY]
expected_session_data = self.default_session_data | {
"to_siae_pk": siae.pk,
}
self.assertDictEqual(session_data, expected_session_data)
next_url = reverse("apply:step_sender", kwargs={"siae_pk": siae.pk})
self.assertEqual(response.url, next_url)
# Step determine the sender.
# ----------------------------------------------------------------------
response = self.client.get(next_url)
self.assertEqual(response.status_code, 302)
session = self.client.session
session_data = session[settings.ITOU_SESSION_JOB_APPLICATION_KEY]
expected_session_data = self.default_session_data | {
"to_siae_pk": siae.pk,
"sender_pk": user.pk,
"sender_kind": JobApplication.SENDER_KIND_PRESCRIBER,
"sender_prescriber_organization_pk": prescriber_organization.pk,
}
self.assertDictEqual(session_data, expected_session_data)
next_url = reverse("apply:step_check_job_seeker_nir", kwargs={"siae_pk": siae.pk})
self.assertEqual(response.url, next_url)
# Step determine the job seeker with a NIR.
# ----------------------------------------------------------------------
response = self.client.get(next_url)
self.assertEqual(response.status_code, 200)
nir = "141068078200557"
post_data = {"nir": nir, "confirm": 1}
response = self.client.post(next_url, data=post_data)
self.assertEqual(response.status_code, 302)
session = self.client.session
session_data = session[settings.ITOU_SESSION_JOB_APPLICATION_KEY]
expected_session_data = self.default_session_data | {
"nir": nir,
"to_siae_pk": siae.pk,
"sender_pk": user.pk,
"sender_kind": JobApplication.SENDER_KIND_PRESCRIBER,
"sender_prescriber_organization_pk": prescriber_organization.pk,
}
next_url = reverse("apply:step_job_seeker", kwargs={"siae_pk": siae.pk})
self.assertEqual(response.url, next_url)
# Step get job seeker e-mail.
# ----------------------------------------------------------------------
response = self.client.get(next_url)
self.assertEqual(response.status_code, 200)
post_data = {"email": "*****@*****.**", "save": "1"}
response = self.client.post(next_url, data=post_data)
self.assertEqual(response.status_code, 302)
next_url = reverse("apply:step_create_job_seeker", kwargs={"siae_pk": siae.pk})
args = urlencode({"email": post_data["email"]})
self.assertEqual(response.url, f"{next_url}?{args}")
# Step create a job seeker.
# ----------------------------------------------------------------------
response = self.client.get(next_url)
self.assertEqual(response.status_code, 200)
post_data = {
"email": "*****@*****.**",
"first_name": "John",
"last_name": "Doe",
"birthdate": "20/12/1978",
"phone": "0610200305",
"pole_emploi_id": "12345678",
"address_line_1": "36, rue du 6 Mai 1956",
"post_code": self.city.post_codes[0],
"city": self.city.name,
"city_slug": self.city.slug,
}
response = self.client.post(next_url, data=post_data)
self.assertEqual(response.status_code, 302)
new_job_seeker = User.objects.get(email=post_data["email"])
session = self.client.session
session_data = session[settings.ITOU_SESSION_JOB_APPLICATION_KEY]
expected_session_data = self.default_session_data | {
"job_seeker_pk": new_job_seeker.pk,
"nir": new_job_seeker.nir,
"to_siae_pk": siae.pk,
"sender_pk": user.pk,
"sender_kind": JobApplication.SENDER_KIND_PRESCRIBER,
"sender_prescriber_organization_pk": prescriber_organization.pk,
}
self.assertDictEqual(session_data, expected_session_data)
next_url = reverse("apply:step_eligibility", kwargs={"siae_pk": siae.pk})
self.assertEqual(response.url, next_url)
# Step eligibility.
# ----------------------------------------------------------------------
response = self.client.get(next_url)
self.assertEqual(response.status_code, 200)
self.assertFalse(EligibilityDiagnosis.objects.has_considered_valid(new_job_seeker, for_siae=siae))
response = self.client.post(next_url)
self.assertEqual(response.status_code, 302)
self.assertTrue(EligibilityDiagnosis.objects.has_considered_valid(new_job_seeker, for_siae=siae))
next_url = reverse("apply:step_application", kwargs={"siae_pk": siae.pk})
self.assertEqual(response.url, next_url)
# Step application.
# ----------------------------------------------------------------------
response = self.client.get(next_url)
self.assertEqual(response.status_code, 200)
post_data = {
"selected_jobs": [siae.job_description_through.first().pk, siae.job_description_through.last().pk],
"message": "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
"resume_link": "https://server.com/rockie-balboa.pdf",
}
response = self.client.post(next_url, data=post_data)
self.assertEqual(response.status_code, 302)
next_url = reverse("apply:step_application_sent", kwargs={"siae_pk": siae.pk})
self.assertEqual(response.url, next_url)
job_application = JobApplication.objects.get(job_seeker=new_job_seeker, sender=user, to_siae=siae)
self.assertEqual(job_application.sender_kind, JobApplication.SENDER_KIND_PRESCRIBER)
self.assertEqual(job_application.sender_siae, None)
self.assertEqual(job_application.sender_prescriber_organization, prescriber_organization)
self.assertEqual(job_application.state, job_application.state.workflow.STATE_NEW)
self.assertEqual(job_application.message, post_data["message"])
self.assertEqual(job_application.answer, "")
self.assertEqual(job_application.selected_jobs.count(), 2)
self.assertEqual(job_application.selected_jobs.first().pk, post_data["selected_jobs"][0])
self.assertEqual(job_application.selected_jobs.last().pk, post_data["selected_jobs"][1])
self.assertEqual(job_application.resume_link, post_data["resume_link"])
class TestAcceptPrescriberWithOrgInvitation(TestCase):
def setUp(self):
self.organization = PrescriberOrganizationWithMembershipFactory()
# Create a second member to make sure emails are also
# sent to regular members
self.organization.members.add(PrescriberFactory())
self.organization.save()
self.sender = self.organization.members.first()
def assert_invitation_is_accepted(self, response, user, invitation):
self.assertRedirects(response, DASHBOARD_URL)
user.refresh_from_db()
invitation.refresh_from_db()
self.assertTrue(user.is_prescriber)
self.assertTrue(invitation.accepted)
self.assertTrue(invitation.accepted_at)
self.assertEqual(self.organization.members.count(), 3)
# Make sure there's a welcome message.
self.assertContains(
response, escape(f"Vous êtes désormais membre de l'organisation {self.organization.display_name}.")
)
# A confirmation e-mail is sent to the invitation sender.
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(len(mail.outbox[0].to), 1)
self.assertEqual(invitation.sender.email, mail.outbox[0].to[0])
# Assert the user sees his new organization dashboard.
current_org = get_current_org_or_404(response.wsgi_request)
# A user can be member of one or more organizations
self.assertTrue(current_org in user.prescriberorganization_set.all())
def test_accept_prescriber_org_invitation(self):
invitation = PrescriberWithOrgSentInvitationFactory(sender=self.sender, organization=self.organization)
post_data = {
"first_name": invitation.first_name,
"last_name": invitation.last_name,
"password1": "Erls92#32",
"password2": "Erls92#32",
}
response = self.client.post(invitation.acceptance_link, data=post_data, follow=True)
user = User.objects.get(email=invitation.email)
self.assert_invitation_is_accepted(response, user, invitation)
def test_accept_existing_user_is_prescriber_without_org(self):
user = PrescriberFactory()
invitation = PrescriberWithOrgSentInvitationFactory(
sender=self.sender,
organization=self.organization,
first_name=user.first_name,
last_name=user.last_name,
email=user.email,
)
self.client.login(email=user.email, password=DEFAULT_PASSWORD)
response = self.client.get(invitation.acceptance_link, follow=True)
self.assert_invitation_is_accepted(response, user, invitation)
def test_accept_existing_user_belongs_to_another_organization(self):
user = PrescriberOrganizationWithMembershipFactory().members.first()
invitation = PrescriberWithOrgSentInvitationFactory(
sender=self.sender,
organization=self.organization,
first_name=user.first_name,
last_name=user.last_name,
email=user.email,
)
self.client.login(email=user.email, password=DEFAULT_PASSWORD)
response = self.client.get(invitation.acceptance_link, follow=True)
self.assert_invitation_is_accepted(response, user, invitation)
def test_accept_existing_user_not_logged_in(self):
invitation = PrescriberWithOrgSentInvitationFactory(sender=self.sender, organization=self.organization)
user = PrescriberFactory()
# The user verified its email
EmailAddress(user_id=user.pk, email=user.email, verified=True, primary=True).save()
invitation = PrescriberWithOrgSentInvitationFactory(
sender=self.sender,
organization=self.organization,
first_name=user.first_name,
last_name=user.last_name,
email=user.email,
)
response = self.client.get(invitation.acceptance_link, follow=True)
self.assertIn(reverse("account_login"), response.wsgi_request.get_full_path())
self.assertFalse(invitation.accepted)
response = self.client.post(
response.wsgi_request.get_full_path(),
data={"login": user.email, "password": DEFAULT_PASSWORD},
follow=True,
)
self.assertTrue(response.context["user"].is_authenticated)
self.assert_invitation_is_accepted(response, user, invitation)
def setUp(self):
self.organization = PrescriberOrganizationWithMembershipFactory()
self.sender = self.organization.members.first()
def setUp(self):
self.organization = PrescriberOrganizationWithMembershipFactory(kind=PrescriberOrganization.Kind.CAP_EMPLOI)
self.sender = self.organization.members.first()
self.post_data = POST_DATA
