600 lines
23 KiB
Python
600 lines
23 KiB
Python
"""Tests for the bulk update / bulk delete Case endpoints."""
|
|
|
|
import uuid
|
|
from unittest.mock import patch
|
|
|
|
import pytest
|
|
|
|
from cases.approvals import ApprovalRule
|
|
from cases.models import Case, CaseWatcher
|
|
from conftest import rls_org
|
|
|
|
|
|
@pytest.mark.django_db
|
|
class TestBulkUpdateCases:
|
|
def test_bulk_update_status(self, admin_client, case_a, case_b_same_org):
|
|
response = admin_client.post(
|
|
"/api/cases/bulk/update/",
|
|
{
|
|
"ids": [str(case_a.pk), str(case_b_same_org.pk)],
|
|
"fields": {"status": "Pending"},
|
|
},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 200
|
|
case_a.refresh_from_db()
|
|
case_b_same_org.refresh_from_db()
|
|
assert case_a.status == "Pending"
|
|
assert case_b_same_org.status == "Pending"
|
|
|
|
def test_bulk_update_priority(self, admin_client, case_a):
|
|
response = admin_client.post(
|
|
"/api/cases/bulk/update/",
|
|
{"ids": [str(case_a.pk)], "fields": {"priority": "Urgent"}},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 200
|
|
case_a.refresh_from_db()
|
|
assert case_a.priority == "Urgent"
|
|
|
|
def test_bulk_update_rejects_unknown_field(self, admin_client, case_a):
|
|
response = admin_client.post(
|
|
"/api/cases/bulk/update/",
|
|
{"ids": [str(case_a.pk)], "fields": {"name": "hacker"}},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 400
|
|
|
|
def test_bulk_update_skips_other_org(self, admin_client, case_a, case_b):
|
|
response = admin_client.post(
|
|
"/api/cases/bulk/update/",
|
|
{
|
|
"ids": [str(case_a.pk), str(case_b.pk)],
|
|
"fields": {"status": "Closed", "closed_on": "2026-05-09"},
|
|
},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 200
|
|
assert response.json()["updated"] == 1
|
|
# `case_b` belongs to the other tenant, so reading it back means
|
|
# looking as that tenant.
|
|
with rls_org(case_b.org):
|
|
case_b.refresh_from_db()
|
|
assert case_b.status != "Closed"
|
|
|
|
def test_bulk_update_empty_ids(self, admin_client):
|
|
response = admin_client.post(
|
|
"/api/cases/bulk/update/",
|
|
{"ids": [], "fields": {"status": "Pending"}},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 400
|
|
|
|
def test_bulk_update_rejects_off_enum_status(self, admin_client, case_a):
|
|
response = admin_client.post(
|
|
"/api/cases/bulk/update/",
|
|
{"ids": [str(case_a.pk)], "fields": {"status": "Hacked"}},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 400
|
|
case_a.refresh_from_db()
|
|
assert case_a.status == "New"
|
|
|
|
def test_bulk_update_rejects_nonstring_choice_value(self, admin_client, case_a):
|
|
# A crafted unhashable payload must be a clean 400, not a 500 from
|
|
# `value in valid_values` raising TypeError on a list.
|
|
response = admin_client.post(
|
|
"/api/cases/bulk/update/",
|
|
{"ids": [str(case_a.pk)], "fields": {"status": ["Closed"]}},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 400
|
|
case_a.refresh_from_db()
|
|
assert case_a.status == "New"
|
|
|
|
def test_bulk_update_rejects_nonstring_closed_on(self, admin_client, case_a):
|
|
# `closed_on` is a scalar date; a non-string payload must 400 here rather
|
|
# than reach `save()` and surface as a 500 DB error.
|
|
response = admin_client.post(
|
|
"/api/cases/bulk/update/",
|
|
{
|
|
"ids": [str(case_a.pk)],
|
|
"fields": {"status": "Closed", "closed_on": ["2026-05-09"]},
|
|
},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 400
|
|
case_a.refresh_from_db()
|
|
assert case_a.status == "New"
|
|
|
|
def test_bulk_update_malformed_id_is_not_500(self, admin_client):
|
|
# A malformed UUID in `ids` must not crash the query. It names no real
|
|
# case, so it drops out and the request reads as "no valid ids" (400),
|
|
# never a 500 from `pk__in` raising ValidationError.
|
|
response = admin_client.post(
|
|
"/api/cases/bulk/update/",
|
|
{"ids": ["not-a-uuid"], "fields": {"status": "Pending"}},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 400
|
|
|
|
def test_bulk_update_drops_malformed_id_keeps_valid(self, admin_client, case_a):
|
|
# A mix of one good and one malformed id processes the good one and
|
|
# silently ignores the garbage, matching how a nonexistent id behaves.
|
|
response = admin_client.post(
|
|
"/api/cases/bulk/update/",
|
|
{
|
|
"ids": [str(case_a.pk), "not-a-uuid"],
|
|
"fields": {"priority": "Urgent"},
|
|
},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 200
|
|
assert response.json()["updated"] == 1
|
|
case_a.refresh_from_db()
|
|
assert case_a.priority == "Urgent"
|
|
|
|
|
|
@pytest.mark.django_db
|
|
class TestBulkUpdateCasesAuthz:
|
|
"""A regular member may only bulk-edit cases they may write."""
|
|
|
|
def test_non_writer_cannot_modify(self, user_client, case_a):
|
|
# `case_a` was created by admin_user; the regular member is neither its
|
|
# creator nor an assignee, so it must be left untouched.
|
|
response = user_client.post(
|
|
"/api/cases/bulk/update/",
|
|
{"ids": [str(case_a.pk)], "fields": {"priority": "Urgent"}},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 200
|
|
assert response.json()["updated"] == 0
|
|
case_a.refresh_from_db()
|
|
assert case_a.priority == "High"
|
|
|
|
def test_creator_can_modify_own_case(self, user_client, regular_user, org_a):
|
|
case = Case.objects.create(
|
|
name="My own case",
|
|
status="New",
|
|
priority="Low",
|
|
created_by=regular_user,
|
|
org=org_a,
|
|
)
|
|
response = user_client.post(
|
|
"/api/cases/bulk/update/",
|
|
{"ids": [str(case.pk)], "fields": {"priority": "Urgent"}},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 200
|
|
assert response.json()["updated"] == 1
|
|
case.refresh_from_db()
|
|
assert case.priority == "Urgent"
|
|
|
|
|
|
@pytest.mark.django_db
|
|
class TestBulkUpdateCasesCloseGate:
|
|
"""Closing through the bulk path runs the same guard as the single case."""
|
|
|
|
def test_close_without_a_date_is_dated_by_the_server(self, admin_client, case_a):
|
|
# The server dates a close that sends none, today in the org's
|
|
# timezone; see `test_close_dated_by_server.py` for the org-day cases.
|
|
response = admin_client.post(
|
|
"/api/cases/bulk/update/",
|
|
{"ids": [str(case_a.pk)], "fields": {"status": "Closed"}},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 200
|
|
body = response.json()
|
|
assert body["updated"] == 1
|
|
assert body["results"][0]["status"] == "updated"
|
|
case_a.refresh_from_db()
|
|
assert case_a.status == "Closed"
|
|
assert case_a.closed_on is not None
|
|
|
|
def test_close_requires_approval_when_rule_matches(
|
|
self, admin_client, case_a, org_a
|
|
):
|
|
# A rule with no match filters applies to every case in the org. Per-
|
|
# record outcomes mean this is now a 200 with an `approval_required`
|
|
# outcome, not a request-level 400: see
|
|
# `TestBulkUpdatePerRecord.test_close_blocked_is_partial`.
|
|
ApprovalRule.objects.create(
|
|
name="Close gate",
|
|
org=org_a,
|
|
trigger_event="pre_close",
|
|
is_active=True,
|
|
)
|
|
response = admin_client.post(
|
|
"/api/cases/bulk/update/",
|
|
{
|
|
"ids": [str(case_a.pk)],
|
|
"fields": {"status": "Closed", "closed_on": "2026-05-09"},
|
|
},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 200
|
|
body = response.json()
|
|
assert body["updated"] == 0
|
|
assert body["results"][0]["status"] == "approval_required"
|
|
case_a.refresh_from_db()
|
|
assert case_a.status == "New"
|
|
|
|
|
|
@pytest.mark.django_db
|
|
class TestBulkUpdatePerRecord:
|
|
def test_mixed_access_reports_both(
|
|
self, user_client, regular_user, user_profile, org_a, case_a
|
|
):
|
|
# `case_a` was created by admin_user, so the regular member cannot write
|
|
# it; they watch it, so they may open it and hear `no_access`. A case
|
|
# they own can be written.
|
|
CaseWatcher.objects.create(case=case_a, profile=user_profile, org=org_a)
|
|
mine = Case.objects.create(
|
|
name="Mine",
|
|
status="New",
|
|
priority="Low",
|
|
created_by=regular_user,
|
|
org=org_a,
|
|
)
|
|
response = user_client.post(
|
|
"/api/cases/bulk/update/",
|
|
{"ids": [str(mine.pk), str(case_a.pk)], "fields": {"priority": "Urgent"}},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 200
|
|
body = response.json()
|
|
assert body["updated"] == 1
|
|
by_id = {r["id"]: r["status"] for r in body["results"]}
|
|
assert by_id[str(mine.pk)] == "updated"
|
|
assert by_id[str(case_a.pk)] == "no_access"
|
|
|
|
def test_close_blocked_is_partial(
|
|
self, admin_client, org_a, case_a, case_b_same_org
|
|
):
|
|
ApprovalRule.objects.create(
|
|
name="Close gate", org=org_a, trigger_event="pre_close", is_active=True
|
|
)
|
|
# A rule with no match filters applies to every case, so both closes are
|
|
# gated; both come back approval_required and neither is closed.
|
|
response = admin_client.post(
|
|
"/api/cases/bulk/update/",
|
|
{
|
|
"ids": [str(case_a.pk), str(case_b_same_org.pk)],
|
|
"fields": {"status": "Closed", "closed_on": "2026-05-09"},
|
|
},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 200
|
|
body = response.json()
|
|
assert body["updated"] == 0
|
|
assert {r["status"] for r in body["results"]} == {"approval_required"}
|
|
case_a.refresh_from_db()
|
|
assert case_a.status == "New"
|
|
|
|
def test_tags_append_not_replace(self, admin_client, org_a, case_a):
|
|
from common.models import Tags
|
|
|
|
keep = Tags.objects.create(name="keep", org=org_a)
|
|
add = Tags.objects.create(name="add", org=org_a)
|
|
case_a.tags.add(keep)
|
|
response = admin_client.post(
|
|
"/api/cases/bulk/update/",
|
|
{"ids": [str(case_a.pk)], "fields": {"tags": [str(add.pk)]}},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 200
|
|
case_a.refresh_from_db()
|
|
assert set(case_a.tags.values_list("name", flat=True)) == {"keep", "add"}
|
|
|
|
def test_empty_fields_rejected(self, admin_client, case_a):
|
|
response = admin_client.post(
|
|
"/api/cases/bulk/update/",
|
|
{"ids": [str(case_a.pk)], "fields": {}},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 400
|
|
|
|
|
|
@pytest.mark.django_db
|
|
class TestBulkDeleteCases:
|
|
def test_bulk_delete_soft(self, admin_client, case_a, case_b_same_org):
|
|
response = admin_client.post(
|
|
"/api/cases/bulk/delete/",
|
|
{"ids": [str(case_a.pk), str(case_b_same_org.pk)]},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 200
|
|
assert response.json()["deleted"] == 2
|
|
case_a.refresh_from_db()
|
|
case_b_same_org.refresh_from_db()
|
|
assert case_a.is_active is False
|
|
assert case_b_same_org.is_active is False
|
|
|
|
def test_bulk_delete_skips_other_org(self, admin_client, case_a, case_b):
|
|
response = admin_client.post(
|
|
"/api/cases/bulk/delete/",
|
|
{"ids": [str(case_a.pk), str(case_b.pk)]},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 200
|
|
assert response.json()["deleted"] == 1
|
|
# `case_b` belongs to the other tenant, so reading it back means
|
|
# looking as that tenant.
|
|
with rls_org(case_b.org):
|
|
case_b.refresh_from_db()
|
|
assert case_b.is_active is True
|
|
|
|
def test_bulk_delete_empty(self, admin_client):
|
|
response = admin_client.post(
|
|
"/api/cases/bulk/delete/",
|
|
{"ids": []},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 400
|
|
|
|
def test_bulk_delete_malformed_id_is_not_500(self, admin_client):
|
|
# Same malformed-id guard as bulk update: a bad UUID must 400, never
|
|
# 500 from the queryset raising ValidationError on `pk__in`.
|
|
response = admin_client.post(
|
|
"/api/cases/bulk/delete/",
|
|
{"ids": ["not-a-uuid"]},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 400
|
|
|
|
|
|
@pytest.mark.django_db
|
|
class TestBulkDeleteCasesAuthz:
|
|
"""Deleting is admin-or-creator only; an assignee is not enough."""
|
|
|
|
def test_non_creator_cannot_delete(self, user_client, case_a):
|
|
response = user_client.post(
|
|
"/api/cases/bulk/delete/",
|
|
{"ids": [str(case_a.pk)]},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 200
|
|
assert response.json()["deleted"] == 0
|
|
case_a.refresh_from_db()
|
|
assert case_a.is_active is True
|
|
|
|
def test_creator_can_delete_own_case(self, user_client, regular_user, org_a):
|
|
case = Case.objects.create(
|
|
name="My own case",
|
|
status="New",
|
|
priority="Low",
|
|
created_by=regular_user,
|
|
org=org_a,
|
|
)
|
|
response = user_client.post(
|
|
"/api/cases/bulk/delete/",
|
|
{"ids": [str(case.pk)]},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 200
|
|
assert response.json()["deleted"] == 1
|
|
case.refresh_from_db()
|
|
assert case.is_active is False
|
|
|
|
|
|
@pytest.mark.django_db
|
|
class TestBulkDeletePerRecord:
|
|
def test_reports_deleted_and_no_access(
|
|
self, user_client, regular_user, user_profile, org_a, case_a
|
|
):
|
|
# Watched, so readable: `no_access` is for a ticket the caller may open.
|
|
CaseWatcher.objects.create(case=case_a, profile=user_profile, org=org_a)
|
|
mine = Case.objects.create(
|
|
name="Mine",
|
|
status="New",
|
|
priority="Low",
|
|
created_by=regular_user,
|
|
org=org_a,
|
|
)
|
|
response = user_client.post(
|
|
"/api/cases/bulk/delete/",
|
|
{"ids": [str(mine.pk), str(case_a.pk)]},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 200
|
|
body = response.json()
|
|
assert body["deleted"] == 1
|
|
by_id = {r["id"]: r["status"] for r in body["results"]}
|
|
assert by_id[str(mine.pk)] == "deleted"
|
|
assert by_id[str(case_a.pk)] == "no_access"
|
|
case_a.refresh_from_db()
|
|
assert case_a.is_active is True
|
|
|
|
|
|
@pytest.mark.django_db
|
|
class TestBulkUpdateSharesTheTicketWrite:
|
|
"""The bulk edit writes through `cases.updates.update_case`, the PATCH's
|
|
own path. Its private copy had drifted: it assigned deactivated people and
|
|
archived tags, and emailed nobody it assigned."""
|
|
|
|
def _member(self, org, email, active=True):
|
|
from common.models import Profile, User
|
|
|
|
user = User.objects.create_user(email=email, password="x")
|
|
return Profile.objects.create(user=user, org=org, role="USER", is_active=active)
|
|
|
|
def test_a_deactivated_member_is_not_assigned(self, admin_client, org_a, case_a):
|
|
live = self._member(org_a, "live@a.test")
|
|
gone = self._member(org_a, "gone@a.test", active=False)
|
|
with patch("cases.updates.send_email_to_assigned_user"):
|
|
response = admin_client.post(
|
|
"/api/cases/bulk/update/",
|
|
{
|
|
"ids": [str(case_a.pk)],
|
|
"fields": {"assigned_to": [str(live.id), str(gone.id)]},
|
|
},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 200
|
|
assert list(case_a.assigned_to.all()) == [live]
|
|
|
|
def test_an_archived_tag_is_not_added(self, admin_client, org_a, case_a):
|
|
from common.models import Tags
|
|
|
|
live = Tags.objects.create(name="live", org=org_a)
|
|
old = Tags.objects.create(name="old", org=org_a, is_active=False)
|
|
response = admin_client.post(
|
|
"/api/cases/bulk/update/",
|
|
{"ids": [str(case_a.pk)], "fields": {"tags": [str(live.id), str(old.id)]}},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 200
|
|
assert list(case_a.tags.values_list("name", flat=True)) == ["live"]
|
|
|
|
def test_only_the_newly_assigned_are_emailed(
|
|
self,
|
|
admin_client,
|
|
org_a,
|
|
case_a,
|
|
case_b_same_org,
|
|
django_capture_on_commit_callbacks,
|
|
):
|
|
kept = self._member(org_a, "kept@a.test")
|
|
added = self._member(org_a, "added@a.test")
|
|
case_a.assigned_to.add(kept)
|
|
with patch("cases.updates.send_email_to_assigned_user") as task:
|
|
with django_capture_on_commit_callbacks(execute=True):
|
|
response = admin_client.post(
|
|
"/api/cases/bulk/update/",
|
|
{
|
|
"ids": [str(case_a.pk), str(case_b_same_org.pk)],
|
|
"fields": {"assigned_to": [str(kept.id), str(added.id)]},
|
|
},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 200
|
|
recipients = sorted(
|
|
(call.args[1], sorted(call.args[0])) for call in task.delay.call_args_list
|
|
)
|
|
assert recipients == sorted(
|
|
[
|
|
(case_a.pk, [added.id]),
|
|
(case_b_same_org.pk, sorted([kept.id, added.id])),
|
|
]
|
|
)
|
|
|
|
def test_the_email_is_queued_only_after_the_commit(
|
|
self, admin_client, org_a, case_a, django_capture_on_commit_callbacks
|
|
):
|
|
"""Queued inside the per-ticket `atomic()`, a worker could read the
|
|
ticket before its new assignees were committed."""
|
|
added = self._member(org_a, "added@a.test")
|
|
with patch("cases.updates.send_email_to_assigned_user") as task:
|
|
with django_capture_on_commit_callbacks(execute=False) as callbacks:
|
|
response = admin_client.post(
|
|
"/api/cases/bulk/update/",
|
|
{
|
|
"ids": [str(case_a.pk)],
|
|
"fields": {"assigned_to": [str(added.id)]},
|
|
},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 200
|
|
task.delay.assert_not_called()
|
|
assert len(callbacks) == 1
|
|
callbacks[0]()
|
|
task.delay.assert_called_once_with([added.id], case_a.pk, str(org_a.id))
|
|
|
|
def test_a_malformed_assignee_id_is_400_before_any_write(
|
|
self, admin_client, case_a, case_b_same_org
|
|
):
|
|
response = admin_client.post(
|
|
"/api/cases/bulk/update/",
|
|
{
|
|
"ids": [str(case_a.pk), str(case_b_same_org.pk)],
|
|
"fields": {"priority": "Low", "assigned_to": ["not-a-uuid"]},
|
|
},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 400
|
|
case_a.refresh_from_db()
|
|
assert case_a.priority == "High"
|
|
|
|
def test_a_malformed_closed_on_is_invalid_not_missing(self, admin_client, case_a):
|
|
response = admin_client.post(
|
|
"/api/cases/bulk/update/",
|
|
{
|
|
"ids": [str(case_a.pk)],
|
|
"fields": {"status": "Closed", "closed_on": "someday"},
|
|
},
|
|
content_type="application/json",
|
|
)
|
|
assert response.status_code == 200
|
|
assert response.json()["results"][0]["status"] == "invalid"
|
|
case_a.refresh_from_db()
|
|
assert case_a.status == "New"
|
|
|
|
|
|
@pytest.mark.django_db
|
|
class TestBulkBatchCap:
|
|
"""A batch carries at most 200 ids, on both endpoints (issue #829).
|
|
|
|
Each matched ticket gets the full single-ticket write, about 4 ms apiece in
|
|
the test DB, and Django's 2.5 MB body limit fits roughly 67,000 ids, so an
|
|
uncapped batch of a member's own tickets could hold a worker for minutes.
|
|
The web selects from one list page, 25 tickets by default.
|
|
"""
|
|
|
|
CAP = 200
|
|
REFUSAL = "Select at most 200 tickets at a time."
|
|
|
|
@staticmethod
|
|
def _ids(case, total):
|
|
"""`case` first, padded to `total` with ids that name no ticket."""
|
|
return [str(case.pk)] + [str(uuid.uuid4()) for _ in range(total - 1)]
|
|
|
|
def _update(self, client, ids):
|
|
return client.post(
|
|
"/api/cases/bulk/update/",
|
|
{"ids": ids, "fields": {"priority": "Urgent"}},
|
|
content_type="application/json",
|
|
)
|
|
|
|
def _delete(self, client, ids):
|
|
return client.post(
|
|
"/api/cases/bulk/delete/",
|
|
{"ids": ids},
|
|
content_type="application/json",
|
|
)
|
|
|
|
def test_update_at_the_cap_is_accepted(self, admin_client, case_a):
|
|
resp = self._update(admin_client, self._ids(case_a, self.CAP))
|
|
assert resp.status_code == 200, resp.content
|
|
case_a.refresh_from_db()
|
|
assert case_a.priority == "Urgent"
|
|
|
|
def test_update_over_the_cap_is_refused_and_writes_nothing(
|
|
self, admin_client, case_a
|
|
):
|
|
resp = self._update(admin_client, self._ids(case_a, self.CAP + 1))
|
|
assert resp.status_code == 400
|
|
assert resp.json()["errors"] == self.REFUSAL
|
|
case_a.refresh_from_db()
|
|
assert case_a.priority != "Urgent"
|
|
|
|
def test_delete_at_the_cap_is_accepted(self, admin_client, case_a):
|
|
resp = self._delete(admin_client, self._ids(case_a, self.CAP))
|
|
assert resp.status_code == 200, resp.content
|
|
case_a.refresh_from_db()
|
|
assert case_a.is_active is False
|
|
|
|
def test_delete_over_the_cap_is_refused_and_writes_nothing(
|
|
self, admin_client, case_a
|
|
):
|
|
resp = self._delete(admin_client, self._ids(case_a, self.CAP + 1))
|
|
assert resp.status_code == 400
|
|
assert resp.json()["errors"] == self.REFUSAL
|
|
case_a.refresh_from_db()
|
|
assert case_a.is_active is True
|
|
|
|
def test_malformed_ids_count_toward_the_cap(self, admin_client, case_a):
|
|
"""Counted before malformed ids are dropped, so junk cannot pad past it."""
|
|
resp = self._delete(admin_client, [str(case_a.pk)] + ["junk"] * self.CAP)
|
|
assert resp.status_code == 400
|
|
case_a.refresh_from_db()
|
|
assert case_a.is_active is True
|