def test_clean_pole_emploi_fields(self): User = get_user_model() job_seeker = JobSeekerFactory(pole_emploi_id="", lack_of_pole_emploi_id_reason="") # Both fields cannot be empty. with self.assertRaises(ValidationError): User.clean_pole_emploi_fields( job_seeker.pole_emploi_id, job_seeker.lack_of_pole_emploi_id_reason) # Both fields cannot be present at the same time. job_seeker = JobSeekerFactory( pole_emploi_id="69970749", lack_of_pole_emploi_id_reason=User.REASON_FORGOTTEN, ) with self.assertRaises(ValidationError): User.clean_pole_emploi_fields( job_seeker.pole_emploi_id, job_seeker.lack_of_pole_emploi_id_reason) # No exception should be raised for the following cases. job_seeker = JobSeekerFactory(pole_emploi_id="62723349", lack_of_pole_emploi_id_reason="") User.clean_pole_emploi_fields(job_seeker.pole_emploi_id, job_seeker.lack_of_pole_emploi_id_reason) job_seeker = JobSeekerFactory( pole_emploi_id="", lack_of_pole_emploi_id_reason=User.REASON_FORGOTTEN) User.clean_pole_emploi_fields(job_seeker.pole_emploi_id, job_seeker.lack_of_pole_emploi_id_reason)
def test_get_or_create_from_valid(self): # With an existing valid `PoleEmploiApproval`. user = JobSeekerFactory() valid_pe_approval = PoleEmploiApprovalFactory( pole_emploi_id=user.pole_emploi_id, birthdate=user.birthdate, number="625741810182A01" ) approvals_wrapper = ApprovalsWrapper(user) approval = Approval.get_or_create_from_valid(approvals_wrapper) self.assertTrue(isinstance(approval, Approval)) self.assertEqual(approval.start_at, valid_pe_approval.start_at) self.assertEqual(approval.end_at, valid_pe_approval.end_at) self.assertEqual(approval.number, valid_pe_approval.number[:12]) self.assertEqual(approval.user, user) self.assertEqual(approval.created_by, None) # With an existing valid `Approval`. user = JobSeekerFactory() valid_approval = ApprovalFactory(user=user, start_at=datetime.date.today() - relativedelta(days=1)) approvals_wrapper = ApprovalsWrapper(user) approval = Approval.get_or_create_from_valid(approvals_wrapper) self.assertTrue(isinstance(approval, Approval)) self.assertEqual(approval, valid_approval)
def test_has_valid_eligibility_diagnosis(self): # No diagnosis. job_seeker = JobSeekerFactory() self.assertFalse(job_seeker.has_valid_eligibility_diagnosis) # Has Itou diagnosis. job_seeker = JobSeekerFactory() EligibilityDiagnosisFactory(job_seeker=job_seeker) self.assertTrue(job_seeker.has_valid_eligibility_diagnosis) # Has valid Pôle emploi diagnosis. job_seeker = JobSeekerFactory() PoleEmploiApprovalFactory(pole_emploi_id=job_seeker.pole_emploi_id, birthdate=job_seeker.birthdate) self.assertTrue(job_seeker.has_valid_eligibility_diagnosis) # Has expired Pôle emploi diagnosis. job_seeker = JobSeekerFactory() end_at = datetime.date.today() - relativedelta(years=2) start_at = end_at - relativedelta(years=2) PoleEmploiApprovalFactory( pole_emploi_id=job_seeker.pole_emploi_id, birthdate=job_seeker.birthdate, start_at=start_at, end_at=end_at ) self.assertFalse(job_seeker.has_valid_eligibility_diagnosis) # Has an expired diagnosis job_seeker = JobSeekerFactory() ExpiredEligibilityDiagnosisFactory(job_seeker=job_seeker) self.assertFalse(job_seeker.has_valid_eligibility_diagnosis)
def test_one_account_no_nir(self): """ No account with this NIR is found. A search by email is proposed. An account is found for this email. This NIR account is empty. An update is expected. """ job_seeker = JobSeekerFactory(nir="") # Create an approval to bypass the eligibility diagnosis step. PoleEmploiApprovalFactory(birthdate=job_seeker.birthdate, pole_emploi_id=job_seeker.pole_emploi_id) siae, user = self.create_test_data() 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_check_job_seeker_nir", kwargs={"siae_pk": siae.pk})) # Enter an a non-existing NIR. # ---------------------------------------------------------------------- nir = "141068078200557" post_data = {"nir": nir, "confirm": 1} response = self.client.post(last_url, data=post_data) next_url = reverse("apply:step_job_seeker", kwargs={"siae_pk": siae.pk}) self.assertRedirects(response, next_url) # Enter an existing email. # ---------------------------------------------------------------------- post_data = {"email": job_seeker.email, "save": "1"} response = self.client.post(next_url, data=post_data) next_url = reverse("apply:step_check_job_seeker_info", kwargs={"siae_pk": siae.pk}) self.assertRedirects(response, next_url, target_status_code=302) # Follow all redirections until the end. # ---------------------------------------------------------------------- response = self.client.get(next_url, follow=True) self.assertTrue(response.status_code, 200) next_url = reverse("apply:step_application", kwargs={"siae_pk": siae.pk}) 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, follow=True) expected_url = reverse("apply:step_application_sent", kwargs={"siae_pk": siae.pk}) last_url = response.redirect_chain[-1][0] self.assertEqual(expected_url, last_url) # Make sure the job seeker NIR is now filled in. # ---------------------------------------------------------------------- job_seeker.refresh_from_db() self.assertEqual(job_seeker.nir, nir)
def test_find_or_create_job_seeker__find(self): developer = UserFactory( email=settings.AI_EMPLOYEES_STOCK_DEVELOPER_EMAIL) CommuneFactory(code=getattr(CleanedAiCsvFileMock, CITY_INSEE_COL)) command = self.command # Find existing user with NIR. nir = getattr(CleanedAiCsvFileMock(), NIR_COL) JobSeekerFactory(nir=nir) df = pandas.DataFrame([CleanedAiCsvFileMock()]) created, job_seeker = command.find_or_create_job_seeker( row=df.iloc[0], created_by=developer) self.assertFalse(created) self.assertTrue(job_seeker) self.assertEqual(job_seeker.nir, nir) self.assertEqual(User.objects.all().count(), 2) # Clean job_seeker.delete() # Find existing user with email address. email = getattr(CleanedAiCsvFileMock(), EMAIL_COL) JobSeekerFactory(nir="", email=email) df = pandas.DataFrame([CleanedAiCsvFileMock()]) created, job_seeker = command.find_or_create_job_seeker( row=df.iloc[0], created_by=developer) self.assertFalse(created) self.assertTrue(job_seeker) self.assertEqual(job_seeker.email, email) self.assertEqual(User.objects.all().count(), 2) # Clean job_seeker.delete() # Find existing user created previously by this script. base_data = CleanedAiCsvFileMock() first_name = getattr(base_data, FIRST_NAME_COL).title() last_name = getattr(base_data, LAST_NAME_COL).title() birthdate = getattr(base_data, BIRTHDATE_COL) nir = getattr(base_data, NIR_COL) JobSeekerFactory( first_name=first_name, last_name=last_name, birthdate=birthdate, nir=nir, created_by=developer, date_joined=settings.AI_EMPLOYEES_STOCK_IMPORT_DATE, ) df = pandas.DataFrame([CleanedAiCsvFileMock()]) created, job_seeker = command.find_or_create_job_seeker( row=df.iloc[0], created_by=developer) self.assertFalse(created) self.assertTrue(job_seeker) self.assertEqual(job_seeker.birthdate, birthdate.date()) self.assertEqual(User.objects.all().count(), 2) # Clean job_seeker.delete()
def test_has_external_data(self, m): _status_ok(m) user1 = JobSeekerFactory() user2 = JobSeekerFactory() import_user_pe_data(user1, FOO_TOKEN) user1.refresh_from_db() self.assertTrue(user1.has_external_data) self.assertFalse(user2.has_external_data)
def test_import_failed(self, m): _status_failed(m) user = JobSeekerFactory() import_user_pe_data(user, FOO_TOKEN) user.refresh_from_db() self.assertTrue(user.has_external_data) data = user.jobseekerexternaldata self.assertIsNone(data.is_pe_jobseeker) self.assertIsNone(data.has_minimal_social_allowance)
def test_apply_as_job_seeker_temporary_nir(self): """ Full path is tested above. See test_apply_as_job_seeker. """ siae = SiaeWithMembershipAndJobsFactory(romes=("N1101", "N1105")) user = JobSeekerFactory(nir="") 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, follow=True) self.assertEqual(response.status_code, 200) next_url = reverse("apply:step_check_job_seeker_nir", kwargs={"siae_pk": siae.pk}) # Follow all redirections until NIR. # ---------------------------------------------------------------------- nir = "123456789KLOIU" post_data = {"nir": nir} response = self.client.post(next_url, data=post_data) self.assertEqual(response.status_code, 200) self.assertFalse(response.context["form"].is_valid()) # Temporary number should be skipped. post_data = {"nir": nir, "skip": 1} response = self.client.post(next_url, data=post_data, follow=True) last_url = response.redirect_chain[-1][0] expected_url = reverse("apply:step_application", kwargs={"siae_pk": siae.pk}) self.assertEqual(last_url, expected_url) self.assertEqual(response.status_code, 200) # Step application. # ---------------------------------------------------------------------- response = self.client.get(last_url) self.assertEqual(response.status_code, 200) post_data = { "selected_jobs": [siae.job_description_through.first().pk], "message": "Lorem ipsum dolor sit amet, consectetur adipiscing elit.", "resume_link": "https://server.com/rocky-balboa.pdf", } response = self.client.post(last_url, data=post_data, follow=True) self.assertEqual(response.status_code, 200) last_url = response.redirect_chain[-1][0] next_url = reverse("apply:step_application_sent", kwargs={"siae_pk": siae.pk}) self.assertEqual(last_url, next_url) user.refresh_from_db() self.assertFalse(user.nir)
def test_apply_as_jobseeker_with_approval_in_waiting_period(self): """Apply as jobseeker with an approval in waiting period.""" siae = SiaeWithMembershipAndJobsFactory(romes=("N1101", "N1105")) user = JobSeekerFactory() end_at = datetime.date.today() - relativedelta(days=30) start_at = end_at - relativedelta(years=2) PoleEmploiApprovalFactory( pole_emploi_id=user.pole_emploi_id, birthdate=user.birthdate, start_at=start_at, end_at=end_at, ) 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 the expected 403. self.assertEqual(response.status_code, 403) self.assertEqual( response.context["exception"], ApprovalsWrapper.ERROR_CANNOT_OBTAIN_NEW_FOR_USER, ) last_url = response.redirect_chain[-1][0] self.assertEqual( last_url, reverse("apply:step_check_job_seeker_info", kwargs={"siae_pk": siae.pk}), )
def test_import_partial(self, m): _status_partial(m) user = JobSeekerFactory() import_user_pe_data(user, FOO_TOKEN) user.refresh_from_db() self.assertTrue(user.has_external_data) data = user.jobseekerexternaldata self.assertIsNone(data.has_minimal_social_allowance) self.assertTrue(data.is_pe_jobseeker) self.assertEqual(user.address_line_1, "4, Privet Drive") self.assertEqual(user.address_line_2, "The cupboard under the stairs") self.assertNotEqual(str(user.birthdate), "1970-01-01")
def test_edit(self): user = JobSeekerFactory() self.client.login(username=user.email, password=DEFAULT_PASSWORD) url = reverse("dashboard:edit_user_info") response = self.client.get(url) self.assertEqual(response.status_code, 200) post_data = { "email": "*****@*****.**", "first_name": "Bob", "last_name": "Saint Clar", "birthdate": "20/12/1978", "phone": "0610203050", "lack_of_pole_emploi_id_reason": user.REASON_NOT_REGISTERED, } response = self.client.post(url, data=post_data) self.assertEqual(response.status_code, 302) user = User.objects.get(id=user.id) self.assertEqual(user.first_name, post_data["first_name"]) self.assertEqual(user.last_name, post_data["last_name"]) self.assertEqual(user.phone, post_data["phone"]) self.assertEqual(user.birthdate.strftime("%d/%m/%Y"), post_data["birthdate"]) # Ensure that the job seeker cannot edit email here. self.assertNotEqual(user.email, post_data["email"])
def test_merge_approvals(self): user = JobSeekerFactory() # Create Approval. start_at = datetime.date.today() - relativedelta(years=4) end_at = start_at + relativedelta(years=2) approval = ApprovalFactory(user=user, start_at=start_at, end_at=end_at) # Create PoleEmploiApproval. start_at = datetime.date.today() end_at = start_at + relativedelta(years=2) pe_approval = PoleEmploiApprovalFactory( pole_emploi_id=user.pole_emploi_id, birthdate=user.birthdate, start_at=start_at, end_at=end_at, ) # Check timeline. self.assertTrue(approval.start_at < pe_approval.start_at) approvals_wrapper = ApprovalsWrapper(user) self.assertEqual(len(approvals_wrapper.merged_approvals), 2) self.assertEqual(approvals_wrapper.merged_approvals[0], pe_approval) self.assertEqual(approvals_wrapper.merged_approvals[1], approval)
def test_new_job_seeker_is_redirected_after_welcoming_tour_test(self): siae = SiaeWithMembershipFactory() job_seeker = JobSeekerFactory.build() # First signup step: job seeker NIR. next_to = reverse("apply:start", kwargs={"siae_pk": siae.pk}) url = f"{reverse('signup:job_seeker_nir')}?next={next_to}" self.client.post(url, {"nir": job_seeker.nir, "confirm": 1}) # Second signup step: job seeker credentials. url = f"{reverse('signup:job_seeker')}?next={next_to}" post_data = { "first_name": job_seeker.first_name, "last_name": job_seeker.last_name, "email": job_seeker.email, "password1": PASSWORD, "password2": PASSWORD, } response = self.client.post(url, data=post_data) response = self.verify_email(job_seeker.email, response.wsgi_request) # The user should not be redirected to the welcoming path if he wanted to perform # another action before signing up. self.assertNotIn(response.wsgi_request.path, reverse("welcoming_tour:index")) # The user is redirected to "apply:step_check_job_seeker_info" # as birthdate and pole_emploi_id are missing from the signup form. # This is a valid behavior that may change in the future so # let's avoid too specific tests. self.assertTrue(response.wsgi_request.path.startswith("/apply")) content = mail.outbox[0].body self.assertIn(next_to, content)
def test_email_approval_number(self): job_seeker = JobSeekerFactory() approval = ApprovalFactory(user=job_seeker) job_application = JobApplicationSentByAuthorizedPrescriberOrganizationFactory( job_seeker=job_seeker, state=JobApplicationWorkflow.STATE_ACCEPTED, approval=approval, ) accepted_by = job_application.to_siae.members.first() email = job_application.email_approval_number(accepted_by) # To. self.assertIn(accepted_by.email, email.to) self.assertEqual(len(email.to), 1) # Body. self.assertIn(approval.user.get_full_name(), email.subject) self.assertIn(approval.number_with_spaces, email.body) self.assertIn(approval.user.last_name, email.body) self.assertIn(approval.user.first_name, email.body) self.assertIn(approval.user.birthdate.strftime("%d/%m/%Y"), email.body) self.assertIn(job_application.hiring_start_at.strftime("%d/%m/%Y"), email.body) self.assertIn(job_application.hiring_end_at.strftime("%d/%m/%Y"), email.body) self.assertIn(job_application.to_siae.display_name, email.body) self.assertIn(job_application.to_siae.get_kind_display(), email.body) self.assertIn(job_application.to_siae.address_line_1, email.body) self.assertIn(job_application.to_siae.address_line_2, email.body) self.assertIn(job_application.to_siae.post_code, email.body) self.assertIn(job_application.to_siae.city, email.body) self.assertIn(settings.ITOU_EMAIL_CONTACT, email.body)
def test_accept_job_application_sent_by_authorized_prescriber_with_approval_in_waiting_period( self ): user = JobSeekerFactory() # Ended 1 year ago. end_at = datetime.date.today() - relativedelta(years=1) start_at = end_at - relativedelta(years=2) approval = PoleEmploiApprovalFactory( pole_emploi_id=user.pole_emploi_id, birthdate=user.birthdate, start_at=start_at, end_at=end_at, ) self.assertTrue(approval.is_in_waiting_period) job_application = JobApplicationSentByAuthorizedPrescriberOrganizationFactory( job_seeker=user, state=JobApplicationWorkflow.STATE_PROCESSING ) # A valid Pôle emploi ID should trigger an automatic approval delivery. self.assertNotEqual(job_application.job_seeker.pole_emploi_id, "") job_application.accept(user=job_application.to_siae.members.first()) self.assertIsNotNone(job_application.approval) self.assertTrue(job_application.approval_number_sent_by_email) self.assertEqual( job_application.approval_delivery_mode, job_application.APPROVAL_DELIVERY_MODE_AUTOMATIC, ) # Check sent email. self.assertEqual(len(mail.outbox), 2) self.assertIn("Candidature acceptée", mail.outbox[0].subject) self.assertIn("Délivrance d'un PASS IAE pour", mail.outbox[1].subject)
def test_apply_as_jobseeker_to_siae_with_approval_in_waiting_period(self): """ Apply as jobseeker to a SIAE (not a GEIQ) with an approval in waiting period. Waiting period cannot be bypassed. """ # Avoid COVID lockdown specific cases now_date = PoleEmploiApproval.LOCKDOWN_START_AT - relativedelta(months=1) now = timezone.datetime(year=now_date.year, month=now_date.month, day=now_date.day, tzinfo=timezone.utc) with mock.patch("django.utils.timezone.now", side_effect=lambda: now): siae = SiaeWithMembershipAndJobsFactory(romes=("N1101", "N1105")) user = JobSeekerFactory() end_at = now_date - relativedelta(days=30) start_at = end_at - relativedelta(years=2) PoleEmploiApprovalFactory( pole_emploi_id=user.pole_emploi_id, birthdate=user.birthdate, start_at=start_at, end_at=end_at ) 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 the expected 403. self.assertEqual(response.status_code, 403) self.assertEqual(response.context["exception"], ApprovalsWrapper.ERROR_CANNOT_OBTAIN_NEW_FOR_USER) last_url = response.redirect_chain[-1][0] self.assertEqual(last_url, reverse("apply:step_check_job_seeker_info", kwargs={"siae_pk": siae.pk}))
def test_status_without_approval(self): user = JobSeekerFactory() approvals_wrapper = ApprovalsWrapper(user) self.assertEqual(approvals_wrapper.status, ApprovalsWrapper.NONE_FOUND) self.assertFalse(approvals_wrapper.has_valid) self.assertFalse(approvals_wrapper.has_in_waiting_period) self.assertEqual(approvals_wrapper.latest_approval, None)
def test_create_diagnosis_with_administrative_criteria(self): job_seeker = JobSeekerFactory() prescriber_organization = AuthorizedPrescriberOrganizationWithMembershipFactory() user = prescriber_organization.members.first() user_info = UserInfo( user=user, kind=KIND_PRESCRIBER, prescriber_organization=prescriber_organization, is_authorized_prescriber=True, siae=None, ) level1 = AdministrativeCriteria.Level.LEVEL_1 level2 = AdministrativeCriteria.Level.LEVEL_2 criteria1 = AdministrativeCriteria.objects.get(level=level1, name="Bénéficiaire du RSA") criteria2 = AdministrativeCriteria.objects.get(level=level2, name="Niveau d'étude 3 ou infra") criteria3 = AdministrativeCriteria.objects.get(level=level2, name="Senior (+50 ans)") diagnosis = EligibilityDiagnosis.create_diagnosis( job_seeker, user_info, administrative_criteria=[criteria1, criteria2, criteria3] ) self.assertEqual(diagnosis.job_seeker, job_seeker) self.assertEqual(diagnosis.author, user) self.assertEqual(diagnosis.author_kind, KIND_PRESCRIBER) self.assertEqual(diagnosis.author_siae, None) self.assertEqual(diagnosis.author_prescriber_organization, prescriber_organization) administrative_criteria = diagnosis.administrative_criteria.all() self.assertEqual(3, administrative_criteria.count()) self.assertIn(criteria1, administrative_criteria) self.assertIn(criteria2, administrative_criteria) self.assertIn(criteria3, administrative_criteria)
def test_merge_approvals(self): user = JobSeekerFactory() # Approval. approval = ApprovalFactory(user=user, start_at=datetime.date(2016, 12, 20), end_at=datetime.date(2018, 12, 20)) # PoleEmploiApproval 1. pe_approval_1 = PoleEmploiApprovalFactory( pole_emploi_id=user.pole_emploi_id, birthdate=user.birthdate, start_at=datetime.date(2018, 12, 20), end_at=datetime.date(2020, 12, 20), ) # PoleEmploiApproval 2. # Same `start_at` as PoleEmploiApproval 1. # But `end_at` earlier than PoleEmploiApproval 1. pe_approval_2 = PoleEmploiApprovalFactory( pole_emploi_id=user.pole_emploi_id, birthdate=user.birthdate, start_at=datetime.date(2018, 12, 20), end_at=datetime.date(2019, 12, 19), ) # Check timeline. approvals_wrapper = ApprovalsWrapper(user) self.assertEqual(len(approvals_wrapper.merged_approvals), 3) self.assertEqual(approvals_wrapper.merged_approvals[0], pe_approval_1) self.assertEqual(approvals_wrapper.merged_approvals[1], pe_approval_2) self.assertEqual(approvals_wrapper.merged_approvals[2], approval)
def test_has_matching_pass_iae_that_belongs_to_another_siae(self): """ Make sure to NOT to redirect to job applications belonging to other SIAEs, as this would produce a 404. """ # Initial approvals (PE and PASS) self.set_up_pe_approval() # Create a job application with a PASS IAE created from a `PoleEmploiApproval` # that belongs to another siae. job_seeker = JobSeekerFactory() pe_approval = PoleEmploiApprovalFactory() job_application = JobApplicationWithApprovalFactory( state=JobApplicationWorkflow.STATE_ACCEPTED, approval__number=pe_approval.number, approval__user=job_seeker, job_seeker=job_seeker, ) another_siae = job_application.to_siae self.assertNotEqual(another_siae, self.siae) # This is the current user (NOT a member of `another_siae`). self.client.login(username=self.siae_user.email, password=DEFAULT_PASSWORD) # The current user should not be able to use the PASS IAE used by another SIAE. response = self.client.get(self.url, {"number": job_application.approval.number}) self.assertNotContains(response, "Continuer")
def test_apply_as_prescriber_for_approval_in_waiting_period(self): """Apply as 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) user = PrescriberFactory() 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_check_job_seeker_nir", kwargs={"siae_pk": siae.pk})) # …choose one, then follow all redirections… post_data = {"nir": job_seeker.nir, "confirm": 1} response = self.client.post(last_url, data=post_data, follow=True) # …until the expected 403. self.assertEqual(response.status_code, 403) self.assertEqual(response.context["exception"], ApprovalsWrapper.ERROR_CANNOT_OBTAIN_NEW_FOR_PROXY) last_url = response.redirect_chain[-1][0] self.assertEqual(last_url, reverse("apply:step_check_job_seeker_info", kwargs={"siae_pk": siae.pk}))
def test_password_change_flow(self): """ Ensure that the default allauth account_change_password URL is overridden and redirects to the right place. """ user = JobSeekerFactory() self.assertTrue( self.client.login(username=user.email, password=DEFAULT_PASSWORD)) # Change password. url = reverse("account_change_password") response = self.client.get(url) self.assertEqual(response.status_code, 200) post_data = { "oldpassword": DEFAULT_PASSWORD, "password1": "mlkjhgfdsq2", "password2": "mlkjhgfdsq2", } response = self.client.post(url, data=post_data) self.assertEqual(response.status_code, 302) self.assertRedirects(response, reverse("dashboard:index")) # User can log in with his new password. self.client.logout() self.assertTrue( self.client.login(username=user.email, password="******")) self.client.logout()
def test_status_with_valid_pole_emploi_approval(self): user = JobSeekerFactory() approval = PoleEmploiApprovalFactory(pole_emploi_id=user.pole_emploi_id, birthdate=user.birthdate) approvals_wrapper = ApprovalsWrapper(user) self.assertEqual(approvals_wrapper.status, ApprovalsWrapper.VALID) self.assertFalse(approvals_wrapper.has_in_waiting_period) self.assertTrue(approvals_wrapper.has_valid) self.assertEqual(approvals_wrapper.latest_approval, approval)
def test_status_with_valid_approval(self): user = JobSeekerFactory() approval = ApprovalFactory(user=user, start_at=datetime.date.today() - relativedelta(days=1)) approvals_wrapper = ApprovalsWrapper(user) self.assertEqual(approvals_wrapper.status, ApprovalsWrapper.VALID) self.assertTrue(approvals_wrapper.has_valid) self.assertFalse(approvals_wrapper.has_in_waiting_period) self.assertEqual(approvals_wrapper.latest_approval, approval)
def test_find_for(self): user = JobSeekerFactory() pe_approval = PoleEmploiApprovalFactory(pole_emploi_id=user.pole_emploi_id, birthdate=user.birthdate) search_results = PoleEmploiApproval.objects.find_for(user) self.assertEqual(search_results.count(), 1) self.assertEqual(search_results.first(), pe_approval) PoleEmploiApproval.objects.all().delete()
def test_not_existing_address(self, _mock): job_seeker = JobSeekerFactory(address_line_1="9, avenue de Huet", post_code="32531", city="MalletVille", department="32") result, error = format_address(job_seeker) self.assertFalse(result) self.assertEqual( error, "Erreur de geocoding, impossible d'obtenir un résultat")
def test_invite_existing_user_is_job_seeker(self): guest = JobSeekerFactory() 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) self.assertEqual(response.status_code, 200) self.assert_invalid_user(response, "Cet utilisateur n'est pas un prescripteur.")
def test_status_approval_with_elapsed_waiting_period(self): user = JobSeekerFactory() end_at = datetime.date.today() - relativedelta(years=3) start_at = end_at - relativedelta(years=2) approval = ApprovalFactory(user=user, start_at=start_at, end_at=end_at) approvals_wrapper = ApprovalsWrapper(user) self.assertEqual(approvals_wrapper.status, ApprovalsWrapper.WAITING_PERIOD_HAS_ELAPSED) self.assertFalse(approvals_wrapper.has_valid) self.assertFalse(approvals_wrapper.has_in_waiting_period) self.assertEqual(approvals_wrapper.latest_approval, approval)
def test_status_failed(self, m): user = JobSeekerFactory() _status_failed(m) result = import_user_pe_data(user, FOO_TOKEN) self.assertEqual(result.status, ExternalDataImport.STATUS_FAILED) report = result.report self.assertEqual(0, len(report.get("fields_updated"))) self.assertEqual(0, len(report.get("fields_fetched"))) self.assertEqual(0, len(report.get("fields_failed")))
def test_get_unique_fk_objects(self): # Create 3 job applications for 2 candidates to check # that `get_unique_fk_objects` returns 2 candidates. JobApplicationSentByJobSeekerFactory() job_seeker = JobSeekerFactory() JobApplicationSentByJobSeekerFactory.create_batch(2, job_seeker=job_seeker) unique_job_seekers = JobApplication.objects.get_unique_fk_objects("job_seeker") self.assertEqual(JobApplication.objects.count(), 3) self.assertEqual(len(unique_job_seekers), 2) self.assertEqual(type(unique_job_seekers[0]), get_user_model())