# Tests for the additive Hiring Plus module.
#   python manage.py test Recruitment.tests_hiring_plus People.tests_org
from datetime import date, timedelta
from decimal import Decimal

from django.core import mail
from django.core.files.uploadedfile import SimpleUploadedFile
from django.test import TestCase, override_settings
from django.utils import timezone
from rest_framework.test import APIClient

from Company.models import company_details
from Employee.models import (CandidateCompensation, CandidateExperience, Department, EmployeeAccount,
                             EmployeeDT, EmployeeRole)
from Recruitment import hiring_plus as hp
from Recruitment.models import CandidateProfile, JobRequisition, Offer

_n = [0]


def mk_company(tag="a"):
    _n[0] += 1
    return company_details.objects.create(email=f"{tag}{_n[0]}@x.com", password="x", contact_no=f"90000{_n[0]:05d}")


def mk_role(co, code, **flags):
    return EmployeeRole.objects.create(company=co, role_name=code.title(), role_code=code, **flags)


def mk_emp(co, name, role=None, **kw):
    _n[0] += 1
    e = EmployeeDT.objects.create(company=co, name=name, email=f"{name.lower().replace(' ', '')}{_n[0]}@x.com",
                                  Employee_Status="Activate", is_active=True, **kw)
    if role is not None:
        EmployeeAccount.objects.create(employee=e, role=role)
        e.role = role                      # what the JWT authenticator puts on request.user
    return e


def client(user):
    c = APIClient()
    c.force_authenticate(user=user)
    return c


def valid_aadhaar(prefix="23456789012"):
    return next(prefix + str(d) for d in range(10) if hp.verhoeff_valid(prefix + str(d)))


class Base(TestCase):
    def setUp(self):
        self.co = mk_company()
        self.admin = client(self.co)
        # an HR maker with recruitment rights but NOT M-level, and an M-level checker
        self.r_hr = mk_role(self.co, "hr_exec", can_create_recruitment=True, can_edit_recruitment=True,
                            can_view_recruitment=True)
        self.r_m = mk_role(self.co, "hr_manager", can_manage_recruitment=True)
        self.r_hm = mk_role(self.co, "hiring_manager", can_view_recruitment=True)
        self.hr = mk_emp(self.co, "Maker Hr", self.r_hr)
        self.mgr = mk_emp(self.co, "Checker Mgr", self.r_m)
        self.hm = mk_emp(self.co, "Hiring Mgr", self.r_hm)
        self.maker, self.checker = client(self.hr), client(self.mgr)

    def mk_candidate(self, who=None, **extra):
        body = {"name": "Meera Sharma", "email": f"meera{_n[0]}@x.com", "applied_position": "Dev"}
        _n[0] += 1
        body.update(extra)
        r = (who or self.maker).post("/api/recruitment/candidates/", body, format="json")
        self.assertEqual(r.status_code, 201, r.content)
        return r.json()["data"]


class HiringManagerTests(Base):
    def test_only_hiring_manager_role_is_eligible(self):
        rows = self.admin.get("/api/recruitment/hiring-managers/").json()["data"]
        self.assertEqual([r["employee_code"] for r in rows], [self.hm.employee_code])
        ok = self.admin.post("/api/recruitment/requisitions/", {
            "position_title": "CEO", "hiring_manager": self.hm.employee_code}, format="json")
        self.assertEqual(ok.status_code, 201, ok.content)
        bad = self.admin.post("/api/recruitment/requisitions/", {
            "position_title": "CEO", "hiring_manager": self.mgr.employee_code}, format="json")
        self.assertEqual(bad.status_code, 400)

    def test_requisition_role_map_and_post_hire(self):
        r = self.admin.post("/api/recruitment/requisitions/", {
            "position_title": "Dev", "hiring_manager": self.hm.employee_code,
            "hcm": self.mgr.employee_code, "reporting_manager": self.hm.employee_code,
            "performance_reviewer": self.mgr.employee_code}, format="json")
        self.assertEqual(r.status_code, 201, r.content)
        roles = r.json()["data"]["roles"]
        self.assertEqual(roles["hcm"]["employee_code"], self.mgr.employee_code)
        rid = r.json()["data"]["id"]
        up = self.admin.patch(f"/api/recruitment/hiring-plus/requisitions/{rid}/roles/",
                              {"performance_reviewer": self.hm.employee_code}, format="json")
        self.assertEqual(up.json()["data"]["performance_reviewer"]["employee_code"], self.hm.employee_code)
        bad = self.admin.patch(f"/api/recruitment/hiring-plus/requisitions/{rid}/roles/",
                               {"hcm": "NOPE0000"}, format="json")
        self.assertEqual(bad.status_code, 400)


class MakerCheckerTests(Base):
    def test_candidate_needs_checker_before_interview(self):
        c = self.mk_candidate()
        self.assertEqual(c["creation_approval"], "Pending")
        self.assertEqual(c["candidate_type"], "Fresher")
        # can still be screened / shortlisted, but not sent to interview
        self.assertEqual(self.maker.post(f"/api/recruitment/candidates/{c['id']}/move/",
                                         {"stage": "SHORTLISTED"}, format="json").status_code, 200)
        r = self.maker.post(f"/api/recruitment/candidates/{c['id']}/move/", {"stage": "INTERVIEW"}, format="json")
        self.assertEqual(r.status_code, 409)
        self.assertEqual(r.json()["code"], "APPROVAL_REQUIRED")
        ap = self.maker.get("/api/recruitment/hiring-plus/approvals/?status=Pending").json()
        self.assertFalse(ap["can_decide"])
        aid = ap["data"][0]["id"]
        # maker is not M-level
        self.assertEqual(self.maker.post(f"/api/recruitment/hiring-plus/approvals/{aid}/approve/", {},
                                         format="json").status_code, 403)
        # checker approves
        self.assertEqual(self.checker.post(f"/api/recruitment/hiring-plus/approvals/{aid}/approve/",
                                           {"remarks": "ok"}, format="json").status_code, 200)
        self.assertEqual(self.maker.post(f"/api/recruitment/candidates/{c['id']}/move/",
                                         {"stage": "INTERVIEW"}, format="json").status_code, 200)

    def test_self_approval_blocked_and_reject_needs_remarks(self):
        c = self.mk_candidate(who=self.checker)       # M-level user is the maker
        aid = self.checker.get("/api/recruitment/hiring-plus/approvals/").json()["data"][0]["id"]
        r = self.checker.post(f"/api/recruitment/hiring-plus/approvals/{aid}/approve/", {}, format="json")
        self.assertEqual(r.status_code, 403)
        self.assertEqual(r.json()["code"], "SELF_APPROVAL")

    def test_rejected_then_resubmit(self):
        c = self.mk_candidate()
        aid = self.checker.get("/api/recruitment/hiring-plus/approvals/").json()["data"][0]["id"]
        url = f"/api/recruitment/hiring-plus/approvals/{aid}/"
        self.assertEqual(self.checker.post(url + "reject/", {}, format="json").status_code, 400)
        self.assertEqual(self.checker.post(url + "reject/", {"remarks": "docs missing"}, format="json").status_code, 200)
        self.assertEqual(self.maker.post(f"/api/recruitment/candidates/{c['id']}/move/",
                                         {"stage": "INTERVIEW"}, format="json").status_code, 409)
        self.assertEqual(self.maker.post(url + "resubmit/", {}, format="json").status_code, 200)

    def test_legacy_candidate_without_record_is_not_blocked(self):
        c = self.mk_candidate()
        from Recruitment.models_plus import CandidateApproval
        CandidateApproval.objects.all().delete()
        self.assertEqual(self.maker.post(f"/api/recruitment/candidates/{c['id']}/move/",
                                         {"stage": "INTERVIEW"}, format="json").status_code, 200)


class NoticeAndExperienceTests(Base):
    def test_notice_period_30_60_90(self):
        r = self.maker.post("/api/recruitment/candidates/", {
            "name": "N P", "email": "np@x.com", "notice_period_days": 45}, format="json")
        self.assertEqual(r.status_code, 400)
        c = self.mk_candidate(notice_period_days=60)
        self.assertEqual(c["notice_period_label"], "60 Days")

    def test_experience_table_and_fresher_flag(self):
        c = self.mk_candidate(experience=[
            {"company_name": "Wipro", "designation": "Dev", "start_date": "2020-01-01", "end_date": "2022-01-01",
             "previous_ctc": 600000},
            {"company_name": "TCS", "designation": "Sr Dev", "start_date": "2022-02-01", "end_date": "2024-02-01",
             "previous_ctc": 900000}])
        self.assertEqual(c["candidate_type"], "Experienced")
        t = self.maker.get(f"/api/recruitment/hiring-plus/candidates/{c['id']}/experience/").json()["data"]
        self.assertEqual(len(t["rows"]), 2)
        self.assertEqual(t["rows"][0]["company_name"], "TCS")         # latest first
        self.assertGreater(t["total_experience_years"], 3.9)
        self.assertEqual(t["candidate_type"], "Experienced")
        f = self.mk_candidate()
        t2 = self.maker.get(f"/api/recruitment/hiring-plus/candidates/{f['id']}/experience/").json()["data"]
        self.assertEqual((t2["candidate_type"], t2["rows"]), ("Fresher", []))

    def test_click_to_view_jd(self):
        req = self.admin.post("/api/recruitment/requisitions/", {
            "position_title": "Dev", "job_description": {"required_skills": ["Django"]}}, format="json").json()["data"]
        c = self.mk_candidate(requisition=req["requisition_id"])
        self.assertTrue(c["jd"]["has_jd"])
        jd = self.maker.get(f"/api/recruitment/hiring-plus/candidates/{c['id']}/jd/")
        self.assertEqual(jd.status_code, 200, jd.content)
        no = self.mk_candidate()
        self.assertEqual(self.maker.get(f"/api/recruitment/hiring-plus/candidates/{no['id']}/jd/").status_code, 404)


class HikePolicyTests(Base):
    def _candidate_with_ctc(self, last_lpa):
        c = self.mk_candidate(current_ctc_lpa=last_lpa)
        self.assertEqual(c["last_ctc_lpa"] if "last_ctc_lpa" in c else c["hike"]["last_ctc_lpa"], last_lpa)
        return c

    def test_hike_above_10_percent_needs_management_approval(self):
        c = self._candidate_with_ctc(10)
        cid = c["id"]
        off = self.maker.post("/api/recruitment/offers/", {"candidate": cid, "offered_ctc_lpa": 12}, format="json")
        self.assertEqual(off.status_code, 201, off.content)
        o = off.json()["data"]
        self.assertTrue(o["hike"]["policy_violation"])
        self.assertEqual(o["hike"]["hike_percent"], 20.0)
        send = self.maker.post(f"/api/recruitment/offers/{o['id']}/send/", {"send_email": "false"}, format="json")
        self.assertEqual(send.status_code, 409)
        self.assertEqual(send.json()["code"], "HIKE_APPROVAL_REQUIRED")
        notices = self.checker.get("/api/recruitment/hiring-plus/hike-approvals/notices/").json()
        self.assertEqual(notices["pending"], 1)
        self.assertIn("management approval required", notices["data"][0]["notice"])
        hid = notices["data"][0]["id"]
        self.assertEqual(self.maker.post(f"/api/recruitment/hiring-plus/hike-approvals/{hid}/approve/",
                                         {"remarks": "x"}, format="json").status_code, 403)
        self.assertEqual(self.checker.post(f"/api/recruitment/hiring-plus/hike-approvals/{hid}/approve/",
                                           {}, format="json").status_code, 400)       # remarks required
        self.assertEqual(self.checker.post(f"/api/recruitment/hiring-plus/hike-approvals/{hid}/approve/",
                                           {"remarks": "critical skill"}, format="json").status_code, 200)
        self.assertEqual(self.maker.post(f"/api/recruitment/offers/{o['id']}/send/", {"send_email": "false"},
                                         format="json").status_code, 200)

    def test_within_limit_and_fresher_are_not_blocked(self):
        c = self._candidate_with_ctc(10)
        o = self.maker.post("/api/recruitment/offers/", {"candidate": c["id"], "offered_ctc_lpa": 10.5},
                            format="json").json()["data"]
        self.assertFalse(o["hike"]["policy_violation"])
        self.assertEqual(self.maker.post(f"/api/recruitment/offers/{o['id']}/send/", {"send_email": "false"},
                                         format="json").status_code, 200)
        f = self.mk_candidate()
        o2 = self.maker.post("/api/recruitment/offers/", {"candidate": f["id"], "offered_ctc_lpa": 30},
                             format="json").json()["data"]
        self.assertIsNone(o2["hike"]["hike_percent"])
        self.assertEqual(self.maker.post(f"/api/recruitment/offers/{o2['id']}/send/", {"send_email": "false"},
                                         format="json").status_code, 200)

    def test_editing_offer_down_clears_violation(self):
        c = self._candidate_with_ctc(10)
        o = self.maker.post("/api/recruitment/offers/", {"candidate": c["id"], "offered_ctc_lpa": 15},
                            format="json").json()["data"]
        up = self.maker.patch(f"/api/recruitment/offers/{o['id']}/", {"offered_ctc_lpa": 10.8}, format="json")
        self.assertEqual(up.status_code, 200, up.content)
        self.assertEqual(self.maker.post(f"/api/recruitment/offers/{o['id']}/send/", {"send_email": "false"},
                                         format="json").status_code, 200)


class AadhaarTests(Base):
    V = "/api/recruitment/hiring-plus/verifications/"

    def test_validate_number_offline(self):
        c = self.mk_candidate()
        good = valid_aadhaar()
        r = self.maker.post(self.V + "aadhaar-validate/", {"aadhaar_number": good, "candidate": c["id"]},
                            format="json").json()["data"]
        self.assertTrue(r["valid"])
        self.assertEqual(r["masked"], "XXXX XXXX " + good[-4:])
        bad = good[:-1] + str((int(good[-1]) + 1) % 10)
        self.assertFalse(self.maker.post(self.V + "aadhaar-validate/", {"aadhaar_number": bad},
                                         format="json").json()["data"]["valid"])
        self.assertFalse(self.maker.post(self.V + "aadhaar-validate/", {"aadhaar_number": "12345"},
                                         format="json").json()["data"]["valid"])

    @override_settings(HIRING_AADHAAR_PROVIDER="mock")
    def test_otp_flow_links_number_and_verifies(self):
        c = self.mk_candidate()
        n = valid_aadhaar()
        # consent is mandatory
        self.assertEqual(self.maker.post(self.V + "aadhaar-send-otp/", {"candidate": c["id"], "aadhaar_number": n},
                                         format="json").json()["code"], "CONSENT_REQUIRED")
        r = self.maker.post(self.V + "aadhaar-send-otp/", {"candidate": c["id"], "aadhaar_number": n,
                                                           "consent": True}, format="json")
        self.assertEqual(r.status_code, 200, r.content)
        self.assertEqual(r.json()["data"]["status"], "OTP Sent")
        self.assertEqual(EmployeeDT.objects.get(pk=c["id"]).aadhaar_number, n)          # linked to the candidate
        self.assertNotIn(n, r.content.decode())                                         # never echoed back
        self.assertEqual(self.maker.post(self.V + "aadhaar-verify-otp/", {"candidate": c["id"], "otp": "000000"},
                                         format="json").status_code, 400)
        ok = self.maker.post(self.V + "aadhaar-verify-otp/", {"candidate": c["id"], "otp": "123456"}, format="json")
        self.assertEqual(ok.json()["data"]["status"], "Verified", ok.content)
        from Recruitment.models_plus import IdentityVerification
        v = IdentityVerification.objects.get(candidate_id=c["id"], id_type="AADHAAR")
        self.assertEqual(v.id_last4, n[-4:])
        self.assertNotIn(n, " ".join(str(x) for x in (v.id_hash, v.meta, v.remarks, v.provider_ref)))

    @override_settings(HIRING_AADHAAR_PROVIDER="mock", HIRING_MOCK_AADHAAR_NAME="Totally Different")
    def test_name_mismatch_is_flagged(self):
        c = self.mk_candidate()
        self.maker.post(self.V + "aadhaar-send-otp/", {"candidate": c["id"], "aadhaar_number": valid_aadhaar(),
                                                       "consent": True}, format="json")
        r = self.maker.post(self.V + "aadhaar-verify-otp/", {"candidate": c["id"], "otp": "123456"}, format="json")
        self.assertEqual(r.json()["data"]["status"], "Mismatch")

    @override_settings(HIRING_AADHAAR_PROVIDER="mock")
    def test_duplicate_and_number_mismatch(self):
        n = valid_aadhaar()
        a, b = self.mk_candidate(), self.mk_candidate()
        EmployeeDT.objects.filter(pk=a["id"]).update(aadhaar_number=n)
        dup = self.maker.post(self.V + "aadhaar-send-otp/", {"candidate": b["id"], "aadhaar_number": n,
                                                             "consent": True}, format="json")
        self.assertEqual(dup.status_code, 409)
        self.assertEqual(dup.json()["code"], "DUPLICATE_AADHAAR")
        other = valid_aadhaar("34567890123")
        mism = self.maker.post(self.V + "aadhaar-send-otp/", {"candidate": a["id"], "aadhaar_number": other,
                                                              "consent": True}, format="json")
        self.assertEqual(mism.json()["code"], "NUMBER_MISMATCH")

    def test_without_provider_clear_message(self):
        c = self.mk_candidate()
        r = self.maker.post(self.V + "aadhaar-send-otp/", {"candidate": c["id"], "aadhaar_number": valid_aadhaar(),
                                                           "consent": True}, format="json")
        self.assertEqual(r.status_code, 503)
        self.assertEqual(r.json()["code"], "PROVIDER_UNAVAILABLE")

    def test_initiate_all_four_and_manual_verify(self):
        n = valid_aadhaar()
        c = self.mk_candidate(aadhaar_number=n, pan_number="ABCPE1234F")
        r = self.maker.post(self.V + "initiate/", {"candidate": c["id"]}, format="json")
        self.assertEqual(r.status_code, 200, r.content)
        st = {x["id_type"]: x["status"] for x in r.json()["data"]}
        self.assertEqual(st, {"AADHAAR": "Pending", "PAN": "Pending", "EDUCATION": "Pending",
                              "EXPERIENCE": "Not Applicable"})          # fresher
        vid = {x["id_type"]: x["id"] for x in r.json()["data"]}
        # manual verify needs remarks and an uploaded document (HR with edit rights may verify, like documents)
        self.assertEqual(self.maker.post(f"{self.V}{vid['PAN']}/verify/", {}, format="json").status_code, 400)
        e = self.checker.post(f"{self.V}{vid['PAN']}/verify/", {"remarks": "seen"}, format="json")
        self.assertEqual(e.json()["code"], "DOCUMENT_REQUIRED")
        EmployeeDT.objects.filter(pk=c["id"]).update(pan_card=SimpleUploadedFile("p.pdf", b"x").name)
        okr = self.checker.post(f"{self.V}{vid['PAN']}/verify/", {"remarks": "original seen"}, format="json")
        self.assertEqual(okr.status_code, 200, okr.content)
        self.assertEqual(okr.json()["data"]["status"], "Verified")

    def test_bad_numbers_fail_on_initiate(self):
        c = self.mk_candidate(aadhaar_number="123456789012", pan_number="XXXXX")
        r = self.maker.post(self.V + "initiate/", {"candidate": c["id"], "types": ["AADHAAR", "PAN"]}, format="json")
        self.assertEqual({x["id_type"]: x["status"] for x in r.json()["data"]}, {"AADHAAR": "Failed", "PAN": "Failed"})

    @override_settings(HIRING_REQUIRE_ID_VERIFICATION=True)
    def test_verification_gate_can_be_switched_on(self):
        c = self.mk_candidate()
        from Recruitment.models import CandidateProfile
        EmployeeDT.objects.filter(pk=c["id"]).update(candidate_status="BGV")
        from Recruitment.models_plus import CandidateApproval
        CandidateApproval.objects.update(status="Approved")
        r = self.admin.post(f"/api/recruitment/candidates/{c['id']}/move/", {"stage": "READY_TO_JOIN"}, format="json")
        self.assertEqual(r.json()["code"], "VERIFICATION_REQUIRED")


class KitUploadOnboardingTests(Base):
    def test_kit_checklist_questions_panel(self):
        c = self.mk_candidate()
        kit = self.maker.get(f"/api/recruitment/hiring-plus/candidates/{c['id']}/kit/").json()["data"]
        self.assertGreaterEqual(len(kit["todo_checklist"]), 4)
        self.assertEqual({i["doc_type"] for i in kit["documentation_checklist"]} >= {"PAN", "AADHAAR", "EDUCATION"}, True)
        iid = kit["todo_checklist"][0]["id"]
        t = self.maker.post(f"/api/recruitment/hiring-plus/checklist/{iid}/toggle/", {}, format="json").json()
        self.assertTrue(t["data"]["is_done"])
        q = self.maker.post("/api/recruitment/hiring-plus/questions/", {
            "candidate": c["id"], "question": "Why leaving?", "category": "Culture"}, format="json")
        self.assertEqual(q.status_code, 201, q.content)
        self.assertEqual(self.maker.post("/api/recruitment/hiring-plus/questions/", {"question": "x"},
                                         format="json").status_code, 400)
        p = self.maker.post("/api/recruitment/hiring-plus/interviewers/", {
            "candidate": c["id"], "interviewer": self.hm.employee_code, "round_name": "Tech 1"}, format="json")
        self.assertEqual(p.status_code, 201, p.content)
        self.assertEqual(self.maker.post("/api/recruitment/hiring-plus/interviewers/", {
            "candidate": c["id"], "interviewer": self.hm.employee_code, "round_name": "Tech 1"},
            format="json").status_code, 409)
        self.assertEqual(self.maker.post("/api/recruitment/hiring-plus/interviewers/", {
            "candidate": c["id"], "interviewer": "NOPE0000"}, format="json").status_code, 400)

    def test_public_upload_link(self):
        c = self.mk_candidate()
        r = self.maker.post("/api/recruitment/hiring-plus/upload-links/", {
            "candidate": c["id"], "document_types": ["PAN", "AADHAAR"], "send_email": True}, format="json")
        self.assertEqual(r.status_code, 201, r.content)
        self.assertTrue(r.json()["email_sent"])
        self.assertEqual(len(mail.outbox), 1)
        token = r.json()["data"]["upload_url"].rstrip("/").rsplit("/", 1)[1]
        anon = APIClient()
        url = f"/api/recruitment/hiring-plus/public/upload/{token}/"
        info = anon.get(url).json()["data"]
        self.assertEqual([d["code"] for d in info["documents"]], ["PAN", "AADHAAR"])
        self.assertNotIn("email", info)
        self.assertEqual(anon.post(url, {"document_type": "BANK", "file": SimpleUploadedFile("a.pdf", b"x")},
                                   format="multipart").status_code, 400)
        self.assertEqual(anon.post(url, {"document_type": "PAN", "file": SimpleUploadedFile("a.exe", b"x")},
                                   format="multipart").status_code, 400)
        up = anon.post(url, {"document_type": "PAN", "file": SimpleUploadedFile("pan.pdf", b"%PDF-1")},
                       format="multipart")
        self.assertEqual(up.status_code, 201, up.content)
        from Employee.models import EmployeeDocument
        self.assertEqual(EmployeeDocument.objects.filter(employee_id=c["id"], document_type="PAN").count(), 1)
        from Recruitment.models_plus import HiringChecklistItem
        self.assertTrue(HiringChecklistItem.objects.get(candidate_id=c["id"], doc_type="PAN").is_done)
        self.assertEqual(anon.get("/api/recruitment/hiring-plus/public/upload/bogus/").status_code, 404)
        link_id = r.json()["data"]["id"]
        self.maker.post(f"/api/recruitment/hiring-plus/upload-links/{link_id}/revoke/", {}, format="json")
        self.assertEqual(anon.get(url).status_code, 410)

    def test_onboarding_trigger_and_post_hire_roles(self):
        req = self.admin.post("/api/recruitment/requisitions/", {
            "position_title": "Dev", "hiring_manager": self.hm.employee_code,
            "hcm": self.mgr.employee_code, "performance_reviewer": self.mgr.employee_code}, format="json").json()["data"]
        c = self.mk_candidate(requisition=req["requisition_id"])
        early = self.maker.post(f"/api/recruitment/hiring-plus/candidates/{c['id']}/onboarding/", {}, format="json")
        self.assertEqual(early.json()["code"], "NOT_READY")
        EmployeeDT.objects.filter(pk=c["id"]).update(candidate_status="OFFER_ACCEPTED")
        r = self.maker.post(f"/api/recruitment/hiring-plus/candidates/{c['id']}/onboarding/", {}, format="json")
        self.assertEqual(r.status_code, 201, r.content)
        self.assertEqual({t["category"] for t in r.json()["data"]["tasks"]},
                         {"Asset", "Email", "Desk", "Kit", "Documentation", "NDA"})
        again = self.maker.post(f"/api/recruitment/hiring-plus/candidates/{c['id']}/onboarding/", {}, format="json")
        self.assertEqual(again.json()["data"]["tasks_added"], 0)                         # idempotent
        # conversion applies HCM / reporting manager / performance reviewer
        from People.org_models import EmployeeHrRoles
        cand = EmployeeDT.objects.get(pk=c["id"])
        hp.on_converted(self.co, cand, "t")
        roles = EmployeeHrRoles.objects.get(employee=cand)
        self.assertEqual(roles.hcm_id, self.mgr.id)
        self.assertEqual(roles.reporting_manager_id, self.hm.id)       # falls back to hiring manager
        self.assertEqual(roles.performance_reviewer_id, self.mgr.id)
        self.assertEqual(cand.people_profile.reporting_manager_id, self.hm.id)


class TenantIsolationTests(Base):
    def test_other_company_cannot_see_or_act(self):
        c = self.mk_candidate()
        other = mk_company("o")
        oc = client(other)
        self.assertEqual(oc.get(f"/api/recruitment/hiring-plus/candidates/{c['id']}/kit/").status_code, 404)
        self.assertEqual(oc.post("/api/recruitment/hiring-plus/verifications/initiate/", {"candidate": c["id"]},
                                 format="json").status_code, 404)
        self.assertEqual(oc.get("/api/recruitment/hiring-plus/approvals/").json()["data"], [])


class AuditCoverageTests(Base):
    """Every marked image point reachable and present in the response."""

    def test_cards_and_dashboard_carry_new_keys(self):
        c = self.mk_candidate(current_ctc_lpa=10, notice_period_days=30)
        for url in ("/api/recruitment/candidates/", "/api/recruitment/pipeline/"):
            body = self.maker.get(url).json()
            blob = str(body)
            for key in ("candidate_type", "hike", "jd", "creation_approval", "verification", "notice_period_label"):
                self.assertIn(f"'{key}'", blob, (url, key))
        self.maker.post("/api/recruitment/offers/", {"candidate": c["id"], "offered_ctc_lpa": 13}, format="json")
        d = self.maker.get("/api/recruitment/dashboard/").json()["data"]
        self.assertEqual(len(d["chro_notices"]), 1)
        self.assertEqual(d["pending_candidate_approvals"], 1)

    def test_existing_hr_dashboard_birthdays_have_department(self):
        dep = Department.objects.create(company=self.co, name="Design")
        today = timezone.localdate()
        mk_emp(self.co, "Birthday Boy", department=dep, Date_of_Birth=today.replace(year=1990))
        r = self.admin.get("/company/dashboard/")
        self.assertEqual(r.status_code, 200, r.content[:300])
        rows = str(r.json())
        self.assertIn("Birthday Boy", rows)
        self.assertIn("'department__name': 'Design'", rows)


class TokenExposureTests(Base):
    def test_upload_link_tokens_hidden_from_view_only_users(self):
        c = self.mk_candidate()
        self.maker.post("/api/recruitment/hiring-plus/upload-links/", {"candidate": c["id"]}, format="json")
        viewer = mk_emp(self.co, "View Only", mk_role(self.co, "viewer", can_view_recruitment=True,
                                                       can_view_employees=False))
        v = client(viewer)
        kit = v.get(f"/api/recruitment/hiring-plus/candidates/{c['id']}/kit/").json()["data"]
        self.assertEqual(kit["upload_links"], [])
        self.assertEqual(v.get(f"/api/recruitment/hiring-plus/upload-links/?candidate={c['id']}").status_code, 403)
        kit2 = self.maker.get(f"/api/recruitment/hiring-plus/candidates/{c['id']}/kit/").json()["data"]
        self.assertEqual(len(kit2["upload_links"]), 1)


class DiagnosticsAndFileTests(Base):
    H = "/api/recruitment/hiring-plus/"

    def test_health_is_public_and_whoami_resolves_roles(self):
        h = APIClient().get(self.H + "health/")
        self.assertEqual(h.status_code, 200)
        self.assertTrue(h.json()["data"]["tables_ready"])
        self.assertEqual(APIClient().get(self.H + "whoami/").status_code, 401)
        a = self.admin.get(self.H + "whoami/").json()["data"]
        self.assertEqual((a["login_type"], a["actor"]), ("company_admin", "admin"))
        m = self.maker.get(self.H + "whoami/").json()["data"]
        self.assertEqual((m["login_type"], m["actor"], m["employee"]["role_code"]), ("employee", "hr", "hr_exec"))
        self.assertTrue(m["recruitment_access"]["edit"])
        self.assertFalse(m["m_level_checker"])
        self.assertTrue(self.checker.get(self.H + "whoami/").json()["data"]["m_level_checker"])

    def test_verification_and_kit_work_for_existing_employee_ids(self):
        emp = mk_emp(self.co, "Old Employee", aadhaar_number=valid_aadhaar())
        by_id = self.maker.get(self.H + f"candidates/{emp.id}/kit/")
        self.assertEqual(by_id.status_code, 200, by_id.content)
        by_code = self.maker.post(self.H + "verifications/initiate/", {"candidate": emp.employee_code}, format="json")
        self.assertEqual(by_code.status_code, 200, by_code.content)

    def test_404_is_clear_and_company_scoped(self):
        c = self.mk_candidate()
        other = client(mk_company("zz"))
        r = other.get(self.H + f"candidates/{c['id']}/kit/")
        self.assertEqual(r.status_code, 404)
        self.assertIn("same company", r.json()["message"])
        self.assertEqual(self.maker.get(self.H + "candidates/99999/kit/").status_code, 404)

    def test_verification_document_upload_multipart(self):
        n = valid_aadhaar()
        c = self.mk_candidate(aadhaar_number=n)
        v = self.H + "verifications/"
        self.maker.post(v + "initiate/", {"candidate": c["id"]}, format="json")
        up = self.maker.post(v + "upload-document/", {"candidate": c["id"], "id_type": "AADHAAR",
                             "file": SimpleUploadedFile("aadhaar.pdf", b"%PDF-1.4 x")}, format="multipart")
        self.assertEqual(up.status_code, 201, up.content)
        self.assertTrue(up.json()["data"]["readiness"]["has_document"])
        self.assertEqual(self.maker.post(v + "upload-document/", {"candidate": c["id"], "id_type": "PAN",
                         "file": SimpleUploadedFile("pan.exe", b"x")}, format="multipart").status_code, 400)
        self.assertEqual(self.maker.post(v + "upload-document/", {"candidate": c["id"], "id_type": "PAN"},
                                         format="multipart").status_code, 400)
        self.assertEqual(self.maker.post(v + "upload-document/", {"candidate": c["id"], "id_type": "XYZ",
                         "file": SimpleUploadedFile("a.pdf", b"x")}, format="multipart").status_code, 400)
        # a viewer without edit rights cannot upload
        viewer = client(mk_emp(self.co, "Viewer", mk_role(self.co, "viewer2", can_view_recruitment=True,
                                                          can_view_employees=False)))
        self.assertEqual(viewer.post(v + "upload-document/", {"candidate": c["id"], "id_type": "AADHAAR",
                         "file": SimpleUploadedFile("a.pdf", b"x")}, format="multipart").status_code, 403)
        # now the manual verify is allowed because the document exists
        rec = [x for x in self.maker.get(v + f"?candidate={c['id']}").json()["data"]["records"] if x["id_type"] == "AADHAAR"][0]
        ok = self.checker.post(v + f"{rec['id']}/verify/", {"remarks": "original seen"}, format="json")
        self.assertEqual(ok.json()["data"]["status"], "Verified", ok.content)
