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())
