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