# Tests for the additive HR/Admin desk APIs + candidate registration / auto-save.
#   python manage.py test Recruitment.tests_desk
import io
from datetime import timedelta

from django.core.files.uploadedfile import SimpleUploadedFile
from django.test import override_settings
from django.utils import timezone
from openpyxl import Workbook, load_workbook
from rest_framework.test import APIClient

from Employee.models import EmployeeDocument, EmployeeDT
from Recruitment.models import CandidateProfile, DocumentReview, InterviewRound, JobRequisition
from Recruitment.models_register import CandidatePortalAccount
from Recruitment.tests_hiring_plus import Base, _n, client, mk_company, mk_emp, mk_role

PDF = b"%PDF-1.4\n1 0 obj<<>>endobj\ntrailer<<>>\n%%EOF"
D = "/api/recruitment/desk/"
PUB = "/api/recruitment/hiring-plus/public/candidate/{}/"
OLD = "/api/recruitment/hiring-plus/public/portal/{}/"
L = "/api/recruitment/hiring-plus/candidate-links/"


def upload(name, data, ctype="text/csv"):
    return SimpleUploadedFile(name, data, content_type=ctype)


def xlsx_bytes(rows):
    wb = Workbook()
    ws = wb.active
    for r in rows:
        ws.append(r)
    b = io.BytesIO()
    wb.save(b)
    return b.getvalue()


@override_settings(CANDIDATE_PORTAL_BASE_URL="https://app.example.com",
                   EMAIL_BACKEND="django.core.mail.backends.locmem.EmailBackend")
class DeskBase(Base):
    def setUp(self):
        super().setUp()
        self.iv1 = mk_emp(self.co, "Ivan One")
        self.iv2 = mk_emp(self.co, "Ivy Two")
        self.req_eng = JobRequisition.objects.create(company=self.co, requisition_id="REQ-1", position_title="Django Dev",
                                                     department_name="Engineering")
        self.req_hr = JobRequisition.objects.create(company=self.co, requisition_id="REQ-2", position_title="HR Exec",
                                                    department_name="People")
        self.c1 = self.cand("Asha Verma", self.req_eng)
        self.c2 = self.cand("Bilal Khan", self.req_hr)
        self.c3 = self.cand("Chitra Nair", self.req_eng)

    def cand(self, name, req):
        c = self.mk_candidate(name=name, applied_position=req.position_title)
        CandidateProfile.objects.filter(candidate_id=c["id"]).update(requisition=req)
        return c

    def interview(self, c, iv, name="Technical Round 1", hours=48):
        when = (timezone.now() + timedelta(hours=hours)).isoformat()
        r = self.admin.post("/api/recruitment/interviews/", {
            "candidate": c["id"], "round_name": name, "scheduled_at": when, "interviewer": iv.employee_code}, format="json")
        self.assertEqual(r.status_code, 201, r.content)
        return r.json()["data"]

    def feedback(self, rid, reco):
        r = self.admin.post("/api/recruitment/feedback/", {
            "interview": rid, "technical_skills": 4, "problem_solving": 4, "communication": 3, "culture_fit": 4,
            "recommendation": reco}, format="json")
        self.assertEqual(r.status_code, 201, r.content)


class InterviewDeskTests(DeskBase):
    def setUp(self):
        super().setUp()
        self.i1 = self.interview(self.c1, self.iv1)
        self.i2 = self.interview(self.c2, self.iv2, "HR Screening", 50)
        self.i3 = self.interview(self.c3, self.iv1, "Technical Round 2", 60)
        self.feedback(self.i1["id"], "Hire")
        self.feedback(self.i3["id"], "No Hire")

    def test_list_pagination_search_and_summary(self):
        r = self.admin.get(D + "interviews/?page_size=2").json()
        self.assertEqual(r["pagination"], {"page": 1, "page_size": 2, "total": 3, "total_pages": 2,
                                           "has_next": True, "has_prev": False})
        self.assertEqual(len(r["data"]), 2)
        r2 = self.admin.get(D + "interviews/?page_size=2&page=2").json()
        self.assertEqual(len(r2["data"]), 1)
        self.assertEqual(self.admin.get(D + "interviews/?page=999&page_size=2").json()["pagination"]["page"], 2)
        self.assertEqual(self.admin.get(D + "interviews/?page_size=abc").json()["pagination"]["page_size"], 20)
        self.assertEqual(self.admin.get(D + "interviews/?page_size=5000").json()["pagination"]["page_size"], 100)
        s = self.admin.get(D + "interviews/?search=bilal").json()
        self.assertEqual([x["candidate"]["name"] for x in s["data"]], ["Bilal Khan"])
        self.assertEqual(self.admin.get(D + "interviews/?search=" + self.iv1.employee_code).json()["pagination"]["total"], 2)
        self.assertEqual(r["outcome_summary"], {"Strong Hire": 0, "Hire": 1, "Hold": 0, "No Hire": 1,
                                                "Strong No Hire": 0, "Pending": 1})

    def test_filters_department_role_interviewer_outcome(self):
        def ids(qs):
            return sorted(x["interview_id"] for x in self.admin.get(D + "interviews/?" + qs).json()["data"])
        self.assertEqual(len(ids("department=Engineering")), 2)
        self.assertEqual(ids("department=people"), [self.i2["interview_id"]])          # case-insensitive
        self.assertEqual(len(ids("role=Django Dev")), 2)
        self.assertEqual(len(ids("interviewer=" + self.iv1.employee_code)), 2)
        self.assertEqual(ids("outcome=Pending"), [self.i2["interview_id"]])
        self.assertEqual(ids("outcome=Hire"), [self.i1["interview_id"]])
        self.assertEqual(ids("outcome=Hire,No Hire,Pending").__len__(), 3)
        self.assertEqual(ids("department=Engineering&outcome=No Hire"), [self.i3["interview_id"]])
        self.assertEqual(ids("status=Completed").__len__(), 2)
        self.assertEqual(self.admin.get(D + "interviews/?date_from=bad").status_code, 400)

    def test_ordering_whitelist(self):
        names = [x["candidate"]["name"] for x in self.admin.get(D + "interviews/?ordering=candidate").json()["data"]]
        self.assertEqual(names, sorted(names))
        self.assertEqual(self.admin.get(D + "interviews/?ordering=;drop").status_code, 200)

    def test_detail_full_view(self):
        d = self.admin.get(D + f"interviews/{self.i1['id']}/").json()["data"]
        self.assertEqual(d["outcome"], "Hire")
        self.assertEqual(d["scorecard"]["recommendation"], "Hire")
        self.assertEqual(d["requisition"]["department"], "Engineering")
        self.assertEqual(d["candidate_detail"]["name"], "Asha Verma")
        self.assertEqual(self.admin.get(D + "interviews/99999/").status_code, 404)

    def test_export_csv_and_xlsx_use_same_filters(self):
        r = self.admin.get(D + "interviews/export/?department=Engineering&outcome=Hire")
        self.assertEqual(r.status_code, 200)
        self.assertIn("text/csv", r["Content-Type"])
        text = r.content.decode("utf-8-sig").strip().splitlines()
        self.assertEqual(len(text), 2)                       # header + 1 row
        self.assertIn("Asha Verma", text[1])
        x = self.admin.get(D + "interviews/export/?file=xlsx")
        ws = load_workbook(io.BytesIO(x.content)).active
        self.assertEqual(ws.max_row, 4)
        self.assertEqual(ws.cell(1, 1).value, "Interview ID")

    def test_filter_options(self):
        o = self.admin.get(D + "filter-options/").json()["data"]
        self.assertEqual(o["departments"], ["Engineering", "People"])
        self.assertIn("Django Dev", o["roles"])
        self.assertEqual({i["value"] for i in o["interviewers"]}, {self.iv1.employee_code, self.iv2.employee_code})
        self.assertIn("Pending", o["outcomes"])
        self.assertEqual(self.admin.get(D + "interviews/filter-options/").json()["data"]["outcomes"], o["outcomes"])

    def test_import_dry_run_real_and_bad_rows(self):
        when = (timezone.now() + timedelta(days=5)).strftime("%Y-%m-%d %H:%M")
        csv_data = ("candidate_id,round_name,scheduled_at,interviewer_code,duration_minutes\n"
                    f"{self.c1['candidate_id']},Managerial Round,{when},{self.iv2.employee_code},45\n"
                    f"NOPE-1,Managerial Round,{when},,30\n"
                    f"{self.c2['candidate_id']},,{when},,30\n").encode()
        before = InterviewRound.objects.count()
        dry = self.admin.post(D + "interviews/import/", {"file": upload("a.csv", csv_data), "dry_run": "true"},
                              format="multipart").json()["data"]
        self.assertEqual((dry["created"], dry["failed"]), (1, 2))
        self.assertEqual(InterviewRound.objects.count(), before)                 # nothing saved
        real = self.admin.post(D + "interviews/import/", {"file": upload("a.csv", csv_data)}, format="multipart")
        self.assertEqual(real.status_code, 200, real.content)
        self.assertEqual(InterviewRound.objects.count(), before + 1)
        self.assertEqual({e["row"] for e in real.json()["data"]["errors"]}, {3, 4})
        x = xlsx_bytes([["candidate_id", "round_name", "scheduled_at"],
                        [self.c3["candidate_id"], "HR Round", when]])
        ok = self.admin.post(D + "interviews/import/", {"file": upload("a.xlsx", x)}, format="multipart")
        self.assertEqual(ok.json()["data"]["created"], 1)
        bad = self.admin.post(D + "interviews/import/", {"file": upload("a.exe", b"x")}, format="multipart")
        self.assertEqual(bad.status_code, 400)
        self.assertEqual(self.admin.post(D + "interviews/import/", {}, format="multipart").status_code, 400)

    def test_permissions_and_company_isolation(self):
        anon = APIClient()
        self.assertIn(anon.get(D + "interviews/").status_code, (401, 403))
        self.assertIn(anon.get(D + "interviews/export/").status_code, (401, 403))
        # hiring manager role = view only
        hm = client(self.hm)
        self.assertEqual(hm.get(D + "interviews/").status_code, 200)
        self.assertEqual(hm.post(D + "interviews/import/", {"file": upload("a.csv", b"a\n1")}, format="multipart").status_code, 403)
        # HR with edit/create rights is the same API as admin
        self.assertEqual(self.maker.get(D + "interviews/").json()["pagination"]["total"], 3)
        other_admin = client(mk_company("o"))                                          # another company's admin
        for ep in ("interviews", "candidates", "documents", "onboarding"):
            self.assertEqual(other_admin.get(D + ep + "/").json()["pagination"]["total"], 0, ep)
        self.assertEqual(other_admin.get(D + f"interviews/{self.i1['id']}/").status_code, 404)
        self.assertEqual(other_admin.get(D + "filter-options/").json()["data"]["departments"], [])


class CandidateDeskTests(DeskBase):
    def test_list_filters_search_summary_export(self):
        r = self.admin.get(D + "candidates/").json()
        self.assertEqual(r["pagination"]["total"], 3)
        self.assertEqual(r["stage_summary"]["APPLIED"], 3)
        f = lambda q: {x["name"] for x in self.admin.get(D + "candidates/?" + q).json()["data"]}
        self.assertEqual(f("department=Engineering"), {"Asha Verma", "Chitra Nair"})
        self.assertEqual(f("role=HR Exec"), {"Bilal Khan"})
        self.assertEqual(f("search=chitra"), {"Chitra Nair"})
        self.assertEqual(f("requisition=REQ-2"), {"Bilal Khan"})
        self.assertEqual(f("stage=applied&department=People"), {"Bilal Khan"})
        self.assertEqual(f("registered=true"), set())
        x = self.admin.get(D + "candidates/export/?department=Engineering")
        self.assertEqual(len(x.content.decode("utf-8-sig").strip().splitlines()), 3)

    def test_import_with_links_duplicates_and_template(self):
        csv_data = ("name,email,phone_number,applied_position,requisition,current_company,total_experience_years,notice_period_days,priority\n"
                    "Dev Patel,dev@x.com,9999999999,Django Dev,REQ-1,Acme,3.5,30,High\n"
                    f"Dup,{self.c1['email']},,,,,,,\n"
                    "NoMail,,,,,,,,\n"
                    "Bad Pri,bp@x.com,,,,,,,Huge\n"
                    "Bad Req,br@x.com,,,REQ-404,,,,\n").encode()
        r = self.admin.post(D + "candidates/import/", {"file": upload("c.csv", csv_data), "create_links": "true"},
                            format="multipart")
        self.assertEqual(r.status_code, 200, r.content)
        d = r.json()["data"]
        self.assertEqual((d["created"], d["failed"]), (1, 4))
        self.assertIn("/candidate-portal/", d["candidates"][0]["frontend_url"])
        c = EmployeeDT.objects.get(email="dev@x.com")
        self.assertEqual(c.recruitment_profile.current_company, "Acme")
        self.assertEqual(c.recruitment_profile.priority, "High")
        # bad-priority row was rolled back, not half created
        self.assertFalse(EmployeeDT.objects.filter(email="bp@x.com").exists())
        self.assertFalse(EmployeeDT.objects.filter(email="br@x.com").exists())
        t = self.admin.get(D + "candidates/import-template/?file=csv")
        self.assertEqual(t.status_code, 200)
        self.assertTrue(t.content.decode("utf-8-sig").startswith("name,email"))

    def test_detail_full_view(self):
        d = self.admin.get(D + f"candidates/{self.c1['id']}/").json()["data"]
        self.assertEqual(d["department"], "Engineering")
        for k in ("education", "experience", "documents", "interviews", "portal", "documents_summary", "history"):
            self.assertIn(k, d)
        self.assertEqual(self.admin.get(D + "candidates/99999/").status_code, 404)


class DocumentDeskTests(DeskBase):
    def invite(self, c):
        r = self.admin.post(L, {"candidate": c["id"], "document_types": ["PAN"]}, format="json")
        self.assertEqual(r.status_code, 201, r.content)
        return r.json()["data"]["frontend_path"].rsplit("/", 1)[1]

    def put_doc(self, token, dtype):
        r = APIClient().post(OLD.format(token) + "documents/", {"document_type": dtype, "file": upload("a.pdf", PDF, "application/pdf")},
                             format="multipart")
        self.assertEqual(r.status_code, 201, r.content)

    def setUp(self):
        super().setUp()
        self.t1, self.t2 = self.invite(self.c1), self.invite(self.c2)
        self.put_doc(self.t1, "RESUME")
        self.put_doc(self.t1, "PAN")
        self.put_doc(self.t2, "RESUME")

    def test_list_search_filter_detail(self):
        r = self.admin.get(D + "documents/").json()
        self.assertEqual(r["pagination"]["total"], 3)
        self.assertEqual(r["status_summary"], {"Pending": 3, "Verified": 0, "Rejected": 0})
        f = lambda q: self.admin.get(D + "documents/?" + q).json()["data"]
        self.assertEqual(len(f("document_type=PAN")), 1)
        self.assertEqual(len(f("search=bilal")), 1)
        self.assertEqual(len(f("department=Engineering")), 2)
        self.assertEqual(len(f("uploaded_by=candidate")), 3)
        self.assertEqual(len(f("uploaded_by=hr")), 0)
        self.assertEqual(len(f("status=Verified")), 0)
        did = f("document_type=PAN")[0]["id"]
        d = self.admin.get(D + f"documents/{did}/").json()["data"]
        self.assertEqual(d["status"], "Pending")
        self.assertEqual(len(d["other_documents"]), 1)

    def test_bulk_review_export_import(self):
        ids = [x["id"] for x in self.admin.get(D + "documents/").json()["data"]]
        r = self.admin.post(D + "documents/bulk-review/", {"ids": ids[:2], "action": "verify"}, format="json")
        self.assertEqual(r.json()["data"]["updated"], ids[:2][::1] if False else r.json()["data"]["updated"])
        self.assertEqual(len(r.json()["data"]["updated"]), 2)
        self.assertEqual(self.admin.get(D + "documents/?status=Verified").json()["pagination"]["total"], 2)
        rej = self.admin.post(D + "documents/bulk-review/", {"ids": ids[2:], "action": "reject"}, format="json")
        self.assertEqual(rej.status_code, 400)                                       # reason required
        self.assertEqual(self.admin.post(D + "documents/bulk-review/", {"ids": [], "action": "verify"}, format="json").status_code, 400)
        self.assertEqual(self.admin.post(D + "documents/bulk-review/", {"ids": ids, "action": "boom"}, format="json").status_code, 400)
        self.admin.post(D + "documents/bulk-review/", {"ids": ids[2:], "action": "reject", "reason": "Blurry"}, format="json")
        ex = self.admin.get(D + "documents/export/?status=Rejected").content.decode("utf-8-sig")
        self.assertIn("Blurry", ex)
        # import a review sheet: flip one back to Pending, one unknown id
        sheet = f"id,status,remarks\n{ids[0]},Pending,\n99999,Verified,\n{ids[1]},Maybe,\n".encode()
        out = self.admin.post(D + "documents/import/", {"file": upload("r.csv", sheet)}, format="multipart").json()["data"]
        self.assertEqual((out["updated"], out["failed"]), (1, 2))
        self.assertEqual(DocumentReview.objects.get(document_id=ids[0]).status, "Pending")

    def test_missing_report(self):
        r = self.admin.get(D + "documents/missing/").json()
        by = {x["name"]: x for x in r["data"]}
        self.assertIn("AADHAAR", by["Asha Verma"]["missing_types"])
        self.assertNotIn("PAN", by["Asha Verma"]["missing_types"])
        self.assertIn("RESUME", by["Chitra Nair"]["missing_types"])
        self.assertEqual(len(self.admin.get(D + "documents/missing/?search=chitra").json()["data"]), 1)
        self.assertEqual(self.admin.get(D + "documents/missing/?export=1&file=xlsx")["Content-Type"],
                         "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")


class RegistrationFlowTests(DeskBase):
    def setUp(self):
        super().setUp()
        r = self.admin.post(L, {"name": "Nita Roy", "email": "nita@x.com", "phone_number": "9876543210",
                                "applied_position": "Django Dev"}, format="json")
        self.assertEqual(r.status_code, 201, r.content)
        self.link = r.json()["data"]
        self.token = self.link["frontend_path"].rsplit("/", 1)[1]
        self.u = PUB.format(self.token)
        self.anon = APIClient()

    def register(self, pw="Secret123", email="nita@x.com"):
        return self.anon.post(self.u + "register/", {"email": email, "password": pw}, format="json")

    def session(self):
        r = self.register()
        self.assertEqual(r.status_code, 201, r.content)
        return {"HTTP_X_CANDIDATE_SESSION": r.json()["data"]["session"]}

    def test_status_register_login_rules(self):
        s = self.anon.get(self.u + "status/").json()["data"]
        self.assertEqual((s["registered"], s["next"]), (False, "register"))
        self.assertTrue(s["email_hint"].endswith("@x.com"))
        self.assertEqual(self.register(email="other@x.com").status_code, 403)
        self.assertEqual(self.register(pw="short").status_code, 400)
        self.assertEqual(self.register(pw="allletters").status_code, 400)
        self.assertEqual(self.register().status_code, 201)
        self.assertEqual(self.register().status_code, 409)
        self.assertEqual(self.anon.get(self.u + "status/").json()["data"]["next"], "login")
        acc = CandidatePortalAccount.objects.get()
        self.assertNotIn("Secret123", acc.password)                                   # hashed
        ok = self.anon.post(self.u + "login/", {"email": "NITA@x.com", "password": "Secret123"}, format="json")
        self.assertEqual(ok.status_code, 200, ok.content)
        self.assertEqual(self.anon.post(self.u + "login/", {"email": "nita@x.com", "password": "nope"}, format="json").status_code, 401)
        self.assertEqual(self.anon.get("/api/recruitment/hiring-plus/public/candidate/bad-token/status/").status_code, 404)

    def test_lockout_after_wrong_attempts(self):
        self.register()
        for _ in range(5):
            self.anon.post(self.u + "login/", {"email": "nita@x.com", "password": "bad"}, format="json")
        r = self.anon.post(self.u + "login/", {"email": "nita@x.com", "password": "Secret123"}, format="json")
        self.assertEqual(r.status_code, 429)

    def test_endpoints_need_session(self):
        for path in ("me/", "home/", "draft/", "education/", "documents/", "experience/"):
            self.assertEqual(self.anon.get(self.u + path).status_code, 401, path)
        self.assertEqual(self.anon.get(self.u + "me/", HTTP_X_CANDIDATE_SESSION="junk").status_code, 401)
        # a session from another candidate's link does not work here
        other = self.admin.post(L, {"name": "Zed", "email": "zed@x.com"}, format="json").json()["data"]
        tok2 = other["frontend_path"].rsplit("/", 1)[1]
        s2 = self.anon.post(PUB.format(tok2) + "register/", {"email": "zed@x.com", "password": "Secret123"}, format="json").json()["data"]["session"]
        self.assertEqual(self.anon.get(self.u + "me/", HTTP_X_CANDIDATE_SESSION=s2).status_code, 401)

    def test_autosave_resume_commit_and_submit(self):
        h = self.session()
        me = self.anon.get(self.u + "me/", **h).json()["data"]
        self.assertEqual(me["resume_step"], "profile")
        # auto-save partial, not-yet-valid data: nothing lands in the real row, nothing is lost
        p = self.anon.put(self.u + "draft/profile/", {"data": {"gender": "Female", "current_address": "Pune", "date_of_birth": "2030-01-01"},
                                                     "version": 2}, format="json", **h)
        self.assertEqual(p.status_code, 200, p.content)
        self.assertIsNone(EmployeeDT.objects.get(email="nita@x.com").Gender)
        old = self.anon.put(self.u + "draft/profile/", {"data": {"gender": "Male"}, "version": 1}, format="json", **h).json()
        self.assertTrue(old["ignored"])                                                # stale tab does not overwrite
        self.assertEqual(self.anon.get(self.u + "draft/", **h).json()["data"][0]["data"]["gender"], "Female")
        bad = self.anon.post(self.u + "draft/commit/", {}, format="json", **h)
        self.assertEqual(bad.status_code, 400)                                        # invalid DOB is caught on commit
        self.anon.put(self.u + "draft/profile/", {"data": {"gender": "Female", "current_address": "Pune",
                                                          "permanent_address": "Pune", "date_of_birth": "1995-04-01"}, "version": 3}, format="json", **h)
        ok = self.anon.post(self.u + "draft/commit/", {"steps": ["profile"]}, format="json", **h)
        self.assertEqual(ok.status_code, 200, ok.content)
        self.assertEqual(ok.json()["data"]["resume_step"], "education")
        self.assertEqual(EmployeeDT.objects.get(email="nita@x.com").Gender, "Female")
        self.assertEqual(self.anon.get(self.u + "draft/", **h).json()["data"], [])      # draft consumed
        # id numbers are never kept in drafts
        n = self.anon.put(self.u + "draft/profile/", {"data": {"pan_number": "ABCDE1234F", "gender": "Female"}}, format="json", **h).json()
        self.assertEqual(n["not_stored"], ["pan_number"])
        self.assertNotIn("pan_number", n["data"]["data"])
        self.assertEqual(self.anon.post(self.u + "draft/commit/", {"steps": ["hack"]}, format="json", **h).status_code, 400)
        self.assertEqual(self.anon.put(self.u + "draft/Bad Step/", {"data": {}}, format="json", **h).status_code, 400)
        # education + document through the gated routes, then submit
        e = self.anon.post(self.u + "education/", {"highest_qualification": "B.Tech", "college_institute": "COEP", "passing_year": 2017}, format="json", **h)
        self.assertEqual(e.status_code, 201, e.content)
        d = self.anon.post(self.u + "documents/", {"document_type": "RESUME", "file": upload("cv.pdf", PDF, "application/pdf")}, format="multipart", **h)
        self.assertEqual(d.status_code, 201, d.content)
        self.assertEqual(self.anon.get(self.u + "me/", **h).json()["data"]["resume_step"], "submit")
        sub = self.anon.post(self.u + "submit/", {}, format="json", **h)
        self.assertEqual(sub.status_code, 200, sub.content)
        # HR / Admin see all of it, same pipeline, in the desks
        ob = self.admin.get(D + "onboarding/").json()
        row = [x for x in ob["data"] if x["candidate_detail"]["email"] == "nita@x.com"][0]
        self.assertEqual((row["status"], row["registered"], row["progress_percent"]), ("Submitted", True, 100))
        self.assertEqual(self.maker.get(D + "onboarding/?status=Submitted&registered=true").json()["pagination"]["total"], 1)
        det = self.admin.get(D + f"onboarding/{row['id']}/").json()["data"]
        self.assertEqual(det["account"]["email"], "nita@x.com")
        self.assertEqual(len(det["documents"]), 1)
        cd = self.admin.get(D + "candidates/?registered=true&submitted=true").json()
        self.assertEqual([x["email"] for x in cd["data"]], ["nita@x.com"])
        self.assertEqual(self.admin.get(D + "documents/?search=nita").json()["pagination"]["total"], 1)
        self.assertIn("Submitted", self.admin.get(D + "onboarding/export/").content.decode("utf-8-sig"))

    def test_reset_account_and_hr_permissions(self):
        self.register()
        row = self.admin.get(D + "onboarding/").json()["data"][0]
        hm = client(self.hm)                                                           # view-only role
        self.assertEqual(hm.post(D + f"onboarding/{row['id']}/reset-account/").status_code, 403)
        r = self.maker.post(D + f"onboarding/{row['id']}/reset-account/")
        self.assertEqual(r.status_code, 200, r.content)
        self.assertEqual(self.register(pw="NewPass999").status_code, 201)

    def test_old_portal_urls_still_work_without_login(self):
        self.assertEqual(self.anon.get(OLD.format(self.token)).status_code, 200)
