# Smoke + flow tests for the People (Employees workspace) API.   python manage.py test People
from datetime import timedelta

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 Department, EmployeeDT, EmployeeRole

MEDIA = override_settings(MEDIA_ROOT="/tmp/people_test_media")


def mk_company(email):
    return company_details.objects.create(email=email, password="x", contact_no=str(abs(hash(email)))[:10],
                                          Registered_Company_Name="Zenith Corp", Company_address="Pune")


def client(user):
    c = APIClient()
    c.force_authenticate(user=user)
    return c


@MEDIA
class PeopleApiTests(TestCase):
    def setUp(self):
        self.co, self.other = mk_company("a@x.com"), mk_company("b@x.com")
        self.a = client(self.co)
        self.dept = Department.objects.create(company=self.co, name="Technology")
        self.dept2 = Department.objects.create(company=self.co, name="Finance")
        P = self.post = lambda url, data=None, fmt="json": self.a.post(url, data or {}, format=fmt)
        self.pune = P("/api/people/branches/", {"name": "Pune Tech HQ", "city": "Pune"}).json()["data"]
        self.mum = P("/api/people/branches/", {"name": "Mumbai Hub"}).json()["data"]
        self.boss = P("/api/people/directory/", {
            "name": "Amit Joshi", "email": "amit@x.com", "designation": "Principal Architect", "department": "Technology",
            "branch": self.pune["id"], "date_of_joining": "2020-01-01", "grade_band": "L7"}).json()["data"]
        self.rahul = P("/api/people/directory/", {
            "name": "Rahul Sharma", "email": "rahul@x.com", "designation": "Senior Full Stack Engineer",
            "department": self.dept.id, "branch": "Pune Tech HQ", "reporting_manager": self.boss["employee_code"],
            "date_of_joining": str(timezone.localdate() - timedelta(days=30)), "probation_period": "3 months",
            "grade_band": "L4", "pan_number": "ABCPK9981D", "create_login": True, "password": "pw123456"}).json()["data"]

    def j(self, r, code=None):
        if code:
            self.assertEqual(r.status_code, code, r.content)
        return r.json()

    # ---------- 1 + 2 ----------
    def test_directory_and_profile360(self):
        a = self.a
        d = self.j(a.get("/api/people/directory/"), 200)
        self.assertEqual(len(d["data"]), 2)
        row = [r for r in d["data"] if r["name"] == "Rahul Sharma"][0]
        self.assertEqual(row["reporting_manager"]["name"], "Amit Joshi")
        self.assertEqual(row["branch"]["name"], "Pune Tech HQ")
        self.assertEqual(row["status"], "On Probation")
        self.assertEqual(len(self.j(a.get("/api/people/directory/?search=rahul"))["data"]), 1)
        self.assertEqual(len(self.j(a.get("/api/people/directory/?status=Confirmed"))["data"]), 1)   # Amit (2020)
        self.assertEqual(len(self.j(a.get("/api/people/directory/?status=Probation"))["data"]), 1)
        legacy = EmployeeDT.objects.create(company=self.co, name="Legacy", email="l@x.com", Employee_Status="Activate",
                                           Date_of_Joining="2018-05-01")          # created before this module existed
        self.assertEqual(len(self.j(a.get("/api/people/directory/?status=Confirmed"))["data"]), 2)
        legacy.delete()
        code = row["employee_code"]
        p = self.j(a.get(f"/api/people/profile360/{code}/"), 200)["data"]
        self.assertEqual(p["overview"]["grade_band"], "L4")
        self.assertEqual(p["overview"]["pan_number"], "ABCPK9981D")
        up = self.j(self.post(f"/api/people/profile360/{code}/update/", {
            "grade_band": "L5", "emergency_contact_name": "Sunita Sharma", "emergency_contact_relation": "Spouse",
            "emergency_contact_phone": "+91 98220 55667", "uan_number": "100918237412"}), 200)["data"]
        self.assertEqual(up["overview"]["emergency_contact"]["name"], "Sunita Sharma")
        self.assertEqual(up["overview"]["uan_pf"], "100918237412")
        for tab in ("recruitment-history", "salary", "attendance", "leave", "assets", "performance", "documents", "exit"):
            self.j(a.get(f"/api/people/profile360/{code}/{tab}/"), 200)
        self.assertEqual(self.j(a.get(f"/api/people/profile360/{code}/leave/"))["data"]["balances"][0]["balance"], 12.0)
        self.assertEqual(a.get("/api/people/profile360/NOPE/").status_code, 404)
        # candidates are not employees
        EmployeeDT.objects.create(company=self.co, name="Cand", email="c@x.com", Employee_Status="Candidate")
        self.assertEqual(len(self.j(a.get("/api/people/directory/"))["data"]), 2)
        # history was written for the join + grade change
        types = [h["event_type"] for h in self.j(a.get(f"/api/people/history/?employee={code}"))["data"]]
        self.assertIn("JOINED", types)
        self.assertIn("DESIGNATION_CHANGE", types)
        # deactivate / reactivate
        self.j(self.post(f"/api/people/directory/{code}/deactivate/"), 200)
        self.assertEqual(len(self.j(a.get("/api/people/directory/"))["data"]), 1)
        self.assertEqual(len(self.j(a.get("/api/people/directory/?include_inactive=true"))["data"]), 2)
        self.j(self.post(f"/api/people/directory/{code}/reactivate/"), 200)

    def test_exit_flow(self):
        code = self.rahul["employee_code"]
        a, P = self.a, self.post
        x = self.j(P(f"/api/people/profile360/{code}/exit/initiate/", {"reason": "Better offer", "last_working_day": "2026-12-31"}), 201)["data"]
        self.assertEqual(x["total_items"], 5)
        self.assertEqual(self.j(a.get(f"/api/people/directory/{code}/"))["data"]["status"], "Serving Notice Period (Resigned)")
        self.assertEqual(P(f"/api/people/profile360/{code}/exit/complete/").status_code, 400)
        for dept in ("IT", "Finance", "HR", "Admin", "Reporting Manager"):
            r = self.j(P(f"/api/people/profile360/{code}/exit/clear-item/", {"department": dept}), 200)
        self.assertEqual(r["data"]["status"], "Cleared")
        self.j(P(f"/api/people/profile360/{code}/exit/complete/"), 200)
        self.assertFalse(EmployeeDT.objects.get(employee_code=code).is_active)

    # ---------- 3 ----------
    def test_onboarding(self):
        a, P = self.a, self.post
        code = self.rahul["employee_code"]
        lst = self.j(a.get("/api/people/onboarding/"), 200)["data"]       # directory create auto-started both
        self.assertEqual(lst["summary"]["active_onboardings"], 2)
        rec = [r for r in lst["rows"] if r["employee"]["employee_code"] == code][0]
        self.assertEqual(P("/api/people/onboarding/", {"employee_code": code}).status_code, 409)
        det = self.j(a.get(f"/api/people/onboarding/{rec['id']}/"))["data"]
        self.assertEqual(len(det["tasks"]), 8)
        t = self.j(P(f"/api/people/onboarding/{rec['id']}/tasks/{det['tasks'][0]['id']}/toggle/"), 200)["data"]
        self.assertEqual(t["progress_percent"], 12)
        self.j(P(f"/api/people/onboarding/{rec['id']}/update/", {"buddy": self.boss["employee_code"], "it_kit_dispatched": True}), 200)
        self.j(P(f"/api/people/onboarding/{rec['id']}/tasks/", {"title": "Extra task"}), 201)
        self.j(P("/api/people/onboarding/trigger-checkins/"), 200)
        self.assertEqual(self.j(P(f"/api/people/onboarding/{rec['id']}/complete/"), 200)["data"]["progress_percent"], 100)

    # ---------- 4 ----------
    def test_documents(self):
        a, P = self.a, self.post
        code = self.rahul["employee_code"]
        f = lambda n: SimpleUploadedFile(n, b"%PDF-1.4 test", content_type="application/pdf")
        up = self.j(P("/api/people/documents/upload/", {"employee_code": code, "document_type": "aadhaar", "file": f("a.pdf")}, "multipart"), 201)["data"]
        self.assertEqual(up["status"], "Verified")
        pan = self.j(P("/api/people/documents/upload/", {"employee_code": code, "document_type": "EDUCATION", "file": f("e.pdf"), "verified": "false"}, "multipart"), 201)["data"]
        row = [r for r in self.j(a.get("/api/people/documents/"))["data"] if r["employee"]["employee_code"] == code][0]
        self.assertEqual((row["government_id"], row["education_certificate"], row["previous_relieving"]), ("Verified", "Pending", "Missing"))
        self.assertEqual(row["compliance_status"], "33% Compliant")
        self.assertEqual(P(f"/api/people/documents/{pan['id']}/reject/").status_code, 400)
        self.j(P(f"/api/people/documents/{pan['id']}/reject/", {"remarks": "Blurry"}), 200)
        self.j(P(f"/api/people/documents/{pan['id']}/verify/"), 200)
        self.j(P("/api/people/documents/upload/", {"employee_code": code, "document_type": "EXPERIENCE", "file": f("r.pdf")}, "multipart"), 201)
        row = [r for r in self.j(a.get("/api/people/documents/"))["data"] if r["employee"]["employee_code"] == code][0]
        self.assertEqual(row["compliance_status"], "100% Compliant")
        v = self.j(a.get(f"/api/people/documents/{code}/vault/"), 200)["data"]
        self.assertEqual(len(v["documents"]), 3)
        self.j(P(f"/api/people/documents/{up['id']}/delete/"), 200)
        self.assertEqual(len(self.j(a.get(f"/api/people/documents/{code}/vault/"))["data"]["documents"]), 2)
        self.assertEqual(P("/api/people/documents/upload/", {"employee_code": code, "document_type": "BAD"}, "multipart").status_code, 400)

    # ---------- 5 ----------
    def test_assets(self):
        a, P = self.a, self.post
        code = self.rahul["employee_code"]
        asset = self.j(P("/api/people/assets/", {"asset_tag": "ZH-IT-2026-081", "device_name": 'MacBook Pro 16" M3', "category": "Hardware"}), 201)["data"]
        self.assertEqual(P("/api/people/assets/", {"asset_tag": "zh-it-2026-081", "device_name": "x"}).status_code, 400)
        al = self.j(P("/api/people/asset-allocations/", {"asset_tag": "ZH-IT-2026-081", "employee_code": code}), 201)["data"]
        self.assertEqual(al["status"], "Allocated")
        self.assertEqual(P("/api/people/asset-allocations/", {"asset_id": asset["id"], "employee_code": code}).status_code, 400)
        self.assertEqual(self.j(a.get(f"/api/people/assets/{asset['id']}/"))["data"]["current_custodian"]["employee_code"], code)
        self.assertEqual(P(f"/api/people/assets/{asset['id']}/delete/").status_code, 409)
        self.j(P(f"/api/people/asset-allocations/{al['id']}/audit/", {"condition": "Good"}), 201)
        self.assertEqual(len(self.j(a.get(f"/api/people/asset-allocations/{al['id']}/audits/"))["data"]), 1)
        self.assertEqual(len(self.j(a.get(f"/api/people/profile360/{code}/assets/"))["data"]), 1)
        self.j(P(f"/api/people/asset-allocations/{al['id']}/return/", {"condition_in": "Good"}), 200)
        self.assertEqual(P(f"/api/people/asset-allocations/{al['id']}/return/").status_code, 409)
        self.assertEqual(self.j(a.get(f"/api/people/assets/{asset['id']}/"))["data"]["status"], "Available")
        self.j(P(f"/api/people/assets/{asset['id']}/delete/"), 200)

    # ---------- 7 ----------
    def test_transfers(self):
        a, P = self.a, self.post
        code = self.rahul["employee_code"]
        t = self.j(P("/api/people/transfers/", {"employee_code": code, "to_department": "Finance", "to_branch": self.mum["id"],
                    "effective_date": "2026-10-15", "reason": "Restructure"}), 201)["data"]
        self.assertEqual(t["current"], "Technology • Pune Tech HQ")
        self.assertEqual(t["proposed_destination"], "Finance • Mumbai Hub")
        self.assertEqual(t["hod_approval"], "Pending HOD")
        self.assertEqual(P("/api/people/transfers/", {"employee_code": code, "to_branch": "Mumbai Hub", "effective_date": "2026-10-20"}).status_code, 400)
        self.assertEqual(P(f"/api/people/transfers/{t['id']}/execute/").status_code, 400)
        self.assertTrue(self.j(P(f"/api/people/transfers/{t['id']}/remind/"), 200)["data"]["reminded_at"])
        self.j(P(f"/api/people/transfers/{t['id']}/approve/", {"remarks": "ok"}), 200)
        ex = self.j(P(f"/api/people/transfers/{t['id']}/execute/"), 200)["data"]
        self.assertEqual(ex["status"], "Executed")
        row = self.j(a.get(f"/api/people/directory/{code}/"))["data"]
        self.assertEqual((row["department"], row["branch"]["name"]), ("Finance", "Mumbai Hub"))
        self.assertEqual(P(f"/api/people/transfers/{t['id']}/execute/").status_code, 409)
        self.assertIn("TRANSFER", [h["event_type"] for h in self.j(a.get(f"/api/people/history/?employee={code}"))["data"]])
        t2 = self.j(P("/api/people/transfers/", {"employee_code": code, "to_manager": self.boss["employee_code"], "effective_date": "2026-11-01"}), 201)["data"]
        self.j(P(f"/api/people/transfers/{t2['id']}/reject/", {"remarks": "no"}), 200)

    # ---------- 8 + 10 ----------
    def test_promotions_and_letters(self):
        a, P = self.a, self.post
        code = self.rahul["employee_code"]
        pr = self.j(P("/api/people/promotions/", {"employee_code": code, "proposed_designation": "Lead Solutions Architect",
                    "proposed_grade": "L5", "hike_percent": 18.5, "manager_rating": 4.9}), 201)["data"]
        self.assertEqual((pr["salary_band_hike"], pr["manager_review_label"], pr["status"]), ("+18.5%", "4.9/5.0", "Nominated"))
        self.assertEqual(pr["current_designation"], "Senior Full Stack Engineer")
        self.assertEqual(P(f"/api/people/promotions/{pr['id']}/letter/").status_code, 400)
        self.assertEqual(P(f"/api/people/promotions/{pr['id']}/execute/").status_code, 400)
        EmployeeDT.objects.filter(employee_code=code).update(Basic_Salary=50000)
        self.j(P(f"/api/people/promotions/{pr['id']}/approve/", {"remarks": "Strong"}), 200)
        ex = self.j(P(f"/api/people/promotions/{pr['id']}/execute/", {"apply_salary_hike": True}), 200)["data"]
        self.assertEqual(ex["status"], "Executed")
        self.assertTrue(ex["letter"]["pdf_url"])
        e = EmployeeDT.objects.get(employee_code=code)
        self.assertEqual((e.Designation, float(e.Basic_Salary)), ("Lead Solutions Architect", 59250.0))
        self.assertEqual(self.j(a.get(f"/api/people/profile360/{code}/"))["data"]["overview"]["grade_band"], "L5")
        # letters center
        self.assertEqual(len(self.j(a.get("/api/people/letters/types/"))["data"]), 4)
        lst = self.j(a.get("/api/people/letters/?letter_type=PROMOTION"))["data"]
        self.assertEqual(len(lst), 1)
        dl = a.get(lst[0]["download_url"])
        self.assertEqual(dl.status_code, 200)
        self.assertTrue(b"".join(dl.streaming_content).startswith(b"%PDF"))
        pv = self.j(P("/api/people/letters/preview/", {"employee_code": code, "letter_type": "APPOINTMENT"}), 200)["data"]
        self.assertIn("Zenith Corp", pv["body"])
        l = self.j(P("/api/people/letters/generate/", {"employee_code": code, "letter_type": "RELIEVING_EXPERIENCE",
                   "variables": {"last_working_day": "31 December 2026"}}), 201)["data"]
        self.assertTrue(l["letter_no"].startswith("REL-"))
        self.assertIn("31 December 2026", l["body"])
        self.j(P(f"/api/people/letters/{l['id']}/update/", {"body": "Edited body text"}), 200)
        self.assertEqual(self.j(a.get(f"/api/people/letters/{l['id']}/"))["data"]["body"], "Edited body text")
        self.j(P(f"/api/people/letters/{l['id']}/revoke/"), 200)
        self.assertEqual(P(f"/api/people/letters/{l['id']}/update/", {"body": "x"}).status_code, 400)
        self.assertEqual(P("/api/people/letters/generate/", {"employee_code": code, "letter_type": "BAD"}).status_code, 400)

    # ---------- 9 ----------
    def test_confirmation(self):
        a, P = self.a, self.post
        code = self.rahul["employee_code"]
        lst = self.j(a.get("/api/people/confirmation/"), 200)
        self.assertEqual(lst["summary"]["label"], "1 Under Probation")          # boss joined 2020 => confirmed
        rv = lst["data"][0]
        self.assertEqual(rv["employee"]["employee_code"], code)
        self.assertTrue(rv["probation_due_date"])
        s = self.j(P(f"/api/people/confirmation/{rv['id']}/assess/", {"manager_rating": 4.2}), 200)["data"]
        self.assertEqual((s["manager_assessment"], s["recommendation"]), ("Meets Expectations (4.2/5)", "Confirm Permanent"))
        self.assertEqual(P(f"/api/people/confirmation/{rv['id']}/extend/", {"extended_until": "2000-01-01"}).status_code, 400)
        c = self.j(P(f"/api/people/confirmation/{rv['id']}/confirm/"), 200)["data"]
        self.assertEqual(c["status"], "Confirmed")
        self.assertTrue(c["letter"]["letter_no"].startswith("CNF-"))
        self.assertEqual(self.j(a.get(f"/api/people/directory/{code}/"))["data"]["status"], "Permanent Confirmed")
        self.assertEqual(self.j(a.get("/api/people/confirmation/"))["summary"]["under_probation"], 0)
        self.assertEqual(P(f"/api/people/confirmation/{rv['id']}/confirm/").status_code, 409)
        # extension path
        e2 = self.j(self.post("/api/people/directory/", {"name": "New Joiner", "email": "n@x.com", "probation_period": "6 months"}), 201)["data"]
        r2 = [r for r in self.j(a.get("/api/people/confirmation/"))["data"] if r["employee"]["employee_code"] == e2["employee_code"]][0]
        until = str(timezone.localdate() + timedelta(days=400))
        self.j(P(f"/api/people/confirmation/{r2['id']}/extend/", {"extended_until": until}), 200)
        again = [r for r in self.j(a.get("/api/people/confirmation/"))["data"] if r["employee"]["employee_code"] == e2["employee_code"]]
        self.assertEqual(again[0]["probation_due_date"], until)
        self.j(P(f"/api/people/confirmation/{again[0]['id']}/terminate/", {"remarks": "x"}), 200)

    # ---------- permissions / isolation ----------
    def test_permissions_and_isolation(self):
        code = self.rahul["employee_code"]
        b = client(self.other)
        self.assertEqual(len(self.j(b.get("/api/people/directory/"))["data"]), 0)
        self.assertEqual(b.get(f"/api/people/profile360/{code}/").status_code, 404)
        self.assertEqual(b.post("/api/people/transfers/", {"employee_code": code, "to_branch": "X", "effective_date": "2026-10-10"}, format="json").status_code, 400)
        # employee without role -> 403 ; HR role with view only -> read ok, write 403 ; HR manage -> full
        emp = EmployeeDT.objects.get(employee_code=code)
        emp.role = None
        self.assertEqual(client(emp).get("/api/people/directory/").status_code, 403)
        role = EmployeeRole.objects.create(company=self.co, role_name="HR", role_code="hr",
                                           can_view_employees=True, can_create_employees=False)
        emp.role = role
        hr = client(emp)
        self.assertEqual(hr.get("/api/people/directory/").status_code, 200)
        self.assertEqual(hr.post("/api/people/branches/", {"name": "Z"}, format="json").status_code, 403)
        role.can_manage_employees = True
        emp.role = role
        hr = client(emp)
        self.assertEqual(hr.post("/api/people/branches/", {"name": "Z"}, format="json").status_code, 201)
        self.assertEqual(hr.get("/api/people/meta/").status_code, 200)
        self.assertEqual(APIClient().get("/api/people/directory/").status_code, 401)
        meta = self.j(self.a.get("/api/people/meta/"), 200)["data"]
        self.assertEqual(len(meta["tabs"]), 10)


@MEDIA
class CrudMatrixTests(TestCase):
    """Create / Read / Update / Delete on every resource, REST verbs (PATCH, DELETE)."""

    def test_rest_verbs_everywhere(self):
        co = mk_company("m@x.com")
        a = client(co)
        J = lambda r, c: (self.assertEqual(r.status_code, c, r.content), r.json())[1]
        emp = J(a.post("/api/people/directory/", {"name": "E1", "email": "e1@x.com", "designation": "Dev"}, format="json"), 201)["data"]
        code = emp["employee_code"]
        mgr = J(a.post("/api/people/directory/", {"name": "M1", "email": "m1@x.com"}, format="json"), 201)["data"]
        # directory: C R U D
        J(a.patch(f"/api/people/directory/{code}/", {"designation": "Sr Dev"}, format="json"), 200)
        self.assertEqual(J(a.get(f"/api/people/directory/{code}/"), 200)["data"]["designation"], "Sr Dev")
        J(a.patch(f"/api/people/profile360/{code}/", {"grade_band": "L2"}, format="json"), 200)
        # simple CrudBase resources: (url, create payload, patch payload)
        specs = [
            ("branches", {"name": "B1"}, {"city": "Pune"}),
            ("assets", {"asset_tag": "T1", "device_name": "Laptop"}, {"device_name": "Laptop 2"}),
            ("history", {"employee_code": code, "title": "Note"}, {"title": "Note 2"}),
            ("transfers", {"employee_code": code, "to_manager": mgr["employee_code"], "effective_date": "2026-12-01"}, {"reason": "r"}),
            ("promotions", {"employee_code": code, "proposed_designation": "Lead"}, {"hike_percent": 10}),
            ("confirmation", {"employee_code": code}, {"manager_rating": 4}),
        ]
        for name, create, patch in specs:
            r = J(a.post(f"/api/people/{name}/", create, format="json"), 201)["data"]
            J(a.get(f"/api/people/{name}/{r['id']}/"), 200)
            J(a.patch(f"/api/people/{name}/{r['id']}/", patch, format="json"), 200)
            J(a.put(f"/api/people/{name}/{r['id']}/", patch, format="json"), 200)
            J(a.delete(f"/api/people/{name}/{r['id']}/"), 200)
            self.assertEqual(a.get(f"/api/people/{name}/{r['id']}/").status_code, 404, name)   # soft-deleted
        # allocation C R U D
        asset = J(a.post("/api/people/assets/", {"asset_tag": "T2", "device_name": "Mouse"}, format="json"), 201)["data"]
        al = J(a.post("/api/people/asset-allocations/", {"asset_id": asset["id"], "employee_code": code}, format="json"), 201)["data"]
        J(a.get(f"/api/people/asset-allocations/{al['id']}/"), 200)
        J(a.patch(f"/api/people/asset-allocations/{al['id']}/", {"notes": "n"}, format="json"), 200)
        J(a.delete(f"/api/people/asset-allocations/{al['id']}/"), 200)
        self.assertEqual(J(a.get(f"/api/people/assets/{asset['id']}/"), 200)["data"]["status"], "Available")
        # onboarding C R U D
        ob = J(a.post("/api/people/onboarding/", {"employee_code": mgr["employee_code"]}, format="json"), 409) if False else None
        recs = J(a.get("/api/people/onboarding/"), 200)["data"]["rows"]
        J(a.patch(f"/api/people/onboarding/{recs[0]['id']}/", {"status": "At Risk"}, format="json"), 200)
        J(a.delete(f"/api/people/onboarding/{recs[0]['id']}/"), 200)
        # letters C R U D
        l = J(a.post("/api/people/letters/", {"employee_code": code, "letter_type": "APPOINTMENT"}, format="json"), 201)["data"]
        J(a.get(f"/api/people/letters/{l['id']}/"), 200)
        J(a.patch(f"/api/people/letters/{l['id']}/", {"body": "New body"}, format="json"), 200)
        J(a.delete(f"/api/people/letters/{l['id']}/"), 200)
        # documents C R U D
        f = SimpleUploadedFile("a.pdf", b"%PDF-1.4", content_type="application/pdf")
        d = J(a.post("/api/people/documents/upload/", {"employee_code": code, "document_type": "PAN", "file": f}, format="multipart"), 201)["data"]
        J(a.get(f"/api/people/documents/{d['id']}/"), 200)
        J(a.patch(f"/api/people/documents/{d['id']}/", {"document_name": "PAN card"}, format="json"), 200)
        J(a.delete(f"/api/people/documents/{d['id']}/"), 200)
        self.assertEqual(a.get(f"/api/people/documents/{d['id']}/").status_code, 404)
        # directory delete (soft)
        J(a.delete(f"/api/people/directory/{code}/"), 200)
