bottleneckcrm/backend/common/tests/test_saved_views.py
Ashwin dd6ca2958d Add unit tests for organization admin checks and saved views provider
- Implement tests for `isOrgAdminProvider` to validate admin roles based on organization membership and role.
- Create tests for `saved_views_provider` to ensure correct API interactions for saving, renaming, and deleting saved views.
- Enhance ticket tree tests to accurately reflect inactive and merged ticket handling.
- Update CSV import tests to verify error handling and file saving functionality.
- Introduce tests for deal cards to ensure correct display of next steps and task statuses.
2026-09-26 20:38:32 +05:30

354 lines
13 KiB
Python

"""Saved list views (G29): private to their owner, and only what the list reads.
Run with: pytest common/tests/test_saved_views.py -v
"""
import uuid
from types import SimpleNamespace
import pytest
from django.http import QueryDict
from rest_framework import status as http
from common.models import Profile, SavedView, User
from common.saved_views import LISTS, MAX_VIEWS_PER_LIST
from common.testing import _make_authenticated_client
URL = "/api/saved-views/"
def detail(pk):
return f"{URL}{pk}/"
def create(client, **body):
payload = {"module": "leads", "name": "Hot", "filters": {}}
payload.update(body)
return client.post(URL, payload, format="json")
@pytest.fixture
def colleague(org_a):
"""A second member of org A, with a client of their own."""
user = User.objects.create_user(email="colleague@test.com", password="x")
profile = Profile.objects.create(user=user, org=org_a, role="USER", is_active=True)
return SimpleNamespace(
profile=profile, client=_make_authenticated_client(user, org_a, profile)
)
# ---------------------------------------------------------------- owner CRUD
def test_owner_creates_lists_reads_renames_and_deletes(user_client, user_profile):
tag = str(uuid.uuid4())
created = create(
user_client,
name=" Hot leads ",
filters={"status": ["assigned", "in process"], "tags": tag, "search": ""},
)
assert created.status_code == http.HTTP_201_CREATED, created.data
view_id = created.data["id"]
assert created.data["name"] == "Hot leads"
# One value becomes a list of one; a blank is dropped with its key.
assert created.data["filters"] == {
"status": ["assigned", "in process"],
"tags": [tag],
}
stored = SavedView.objects.get(pk=view_id)
assert stored.profile == user_profile
assert stored.org == user_profile.org
listed = user_client.get(URL, {"module": "leads"})
assert listed.status_code == 200
assert [v["id"] for v in listed.data["saved_views"]] == [view_id]
assert listed.data["limit"] == MAX_VIEWS_PER_LIST
assert user_client.get(detail(view_id)).data["name"] == "Hot leads"
renamed = user_client.patch(detail(view_id), {"name": "Warm"}, format="json")
assert renamed.status_code == 200, renamed.data
assert renamed.data["name"] == "Warm"
assert renamed.data["filters"]["tags"] == [tag]
refiltered = user_client.patch(
detail(view_id), {"filters": {"source": "call"}}, format="json"
)
assert refiltered.status_code == 200, refiltered.data
assert refiltered.data["filters"] == {"source": ["call"]}
assert user_client.delete(detail(view_id)).status_code == 204
assert not SavedView.objects.filter(pk=view_id).exists()
def test_list_without_module_returns_every_list_and_bad_module_is_400(user_client):
create(user_client, module="leads", name="A")
create(user_client, module="cases", name="B")
everything = user_client.get(URL)
assert sorted(v["module"] for v in everything.data["saved_views"]) == [
"cases",
"leads",
]
assert user_client.get(URL, {"module": "tasks"}).status_code == 400
assert create(user_client, module="tasks").status_code == 400
def test_every_one_of_the_six_lists_takes_a_view(user_client):
for module in LISTS:
response = create(user_client, module=module, name=f"{module} view")
assert response.status_code == 201, (module, response.data)
def test_anonymous_is_refused(unauthenticated_client):
assert unauthenticated_client.get(URL).status_code in (401, 403)
assert create(unauthenticated_client).status_code in (401, 403)
assert not SavedView.objects.exists()
# ------------------------------------------------------------- private views
def test_another_members_view_is_404_on_every_verb(user_client, colleague):
theirs = create(colleague.client, name="Theirs").data["id"]
missing = str(uuid.uuid4())
# Hidden from the list, and every verb answers exactly as for a missing id.
assert user_client.get(URL).data["saved_views"] == []
for verb, kwargs in (
("get", {}),
("patch", {"data": {"name": "Mine now"}, "format": "json"}),
("delete", {}),
):
hidden = getattr(user_client, verb)(detail(theirs), **kwargs)
absent = getattr(user_client, verb)(detail(missing), **kwargs)
assert hidden.status_code == absent.status_code == 404, verb
assert hidden.data == absent.data, verb
view = SavedView.objects.get(pk=theirs)
assert view.name == "Theirs"
# The owner still reads it: the check refuses one person, not everyone.
assert colleague.client.get(detail(theirs)).status_code == 200
def test_an_admin_cannot_read_a_members_view_either(admin_client, user_client):
member_view = create(user_client, name="Private").data["id"]
assert admin_client.get(detail(member_view)).status_code == 404
assert admin_client.get(URL).data["saved_views"] == []
def test_another_orgs_view_is_invisible(user_client, org_b_client):
other = create(org_b_client, name="Org B view").data["id"]
assert user_client.get(URL).data["saved_views"] == []
assert user_client.get(detail(other)).status_code == 404
assert user_client.delete(detail(other)).status_code == 404
assert SavedView.objects.filter(pk=other).exists()
def test_org_and_profile_in_the_body_are_refused(user_client, colleague, org_b):
response = create(user_client, profile=str(colleague.profile.id))
assert response.status_code == 400
assert "profile" in response.data
response = create(user_client, org=str(org_b.id))
assert response.status_code == 400
assert "org" in response.data
assert not SavedView.objects.exists()
mine = create(user_client).data["id"]
moved = user_client.patch(
detail(mine), {"profile": str(colleague.profile.id)}, format="json"
)
assert moved.status_code == 400
assert SavedView.objects.get(pk=mine).profile.user.email == "user@test.com"
def test_a_view_cannot_move_to_another_list(user_client):
mine = create(user_client).data["id"]
response = user_client.patch(detail(mine), {"module": "cases"}, format="json")
assert response.status_code == 400
assert "module" in response.data
# Naming its own list again is not a move.
same = user_client.patch(detail(mine), {"module": "leads"}, format="json")
assert same.status_code == 200
# ------------------------------------------------------------ what it holds
@pytest.mark.parametrize(
"module, filters",
[
("leads", {"limit": "10"}),
("leads", {"junk": "x"}),
("leads", {"pipeline": str(uuid.uuid4())}), # a deal param, not a lead one
("invoices", {"due_date__gte": "2026-01-01"}), # invoices use one underscore
("cases", {"cf_": "x"}),
("cases", {"cf_bad-key": "x"}),
("leads", ["status", "assigned"]),
("leads", "status=assigned"),
("leads", {"status": 5}),
("leads", {"status": ["assigned", None]}),
("leads", {"status": {"nested": "x"}}),
("leads", {"search": "x" * 201}),
("leads", {"status": ["assigned"] * 51}),
("leads", {f"cf_k{i}": "x" for i in range(31)}),
# Malformed values are refused by the list's own parsing.
("leads", {"assigned_to": "not-a-uuid"}),
("contacts", {"tags": ["x"]}),
("accounts", {"created_at__gte": "2026-02-30"}),
("opportunities", {"amount__gte": "lots"}),
("opportunities", {"amount__lte": "NaN"}),
("cases", {"account": "nope"}),
("invoices", {"due_date_gte": "yesterday"}),
],
)
def test_junk_filters_are_400(user_client, module, filters):
response = create(user_client, module=module, filters=filters)
assert response.status_code == 400, response.data
assert "filters" in response.data
assert not SavedView.objects.exists()
def test_junk_filters_are_400_on_update_too(user_client):
mine = create(user_client, filters={"source": "call"}).data["id"]
response = user_client.patch(
detail(mine), {"filters": {"assigned_to": "x"}}, format="json"
)
assert response.status_code == 400
assert SavedView.objects.get(pk=mine).filters == {"source": ["call"]}
def _sample(key):
"""A well-formed value for list parameter ``key``."""
if key in {
"assigned_to",
"tags",
"account",
"contact",
"opportunity",
"pipeline",
"created_by",
}:
return str(uuid.uuid4())
if key.startswith("amount"):
return "10.5"
if "date" in key or "created_at" in key or "closed_on" in key:
return "2026-01-02"
if key == "next_follow_up":
return "2026-01-02"
return "true"
def test_every_param_the_lists_read_is_accepted(user_client):
for module, (_build, accepted) in LISTS.items():
filters = {key: _sample(key) for key in accepted}
filters["cf_region"] = "EMEA"
response = create(user_client, module=module, name=module, filters=filters)
assert response.status_code == 201, (module, response.data)
class _Recorder(QueryDict):
"""A query string that remembers every key it was asked for."""
def __init__(self):
super().__init__(mutable=True)
# Non-empty, so a list that returns early on no params still reads on.
self.setlist("__probe__", ["x"])
self.read = set()
def __getitem__(self, key):
self.read.add(key)
return super().__getitem__(key)
def get(self, key, default=None):
self.read.add(key)
return super().get(key, default)
def getlist(self, key, default=None):
self.read.add(key)
return super().getlist(key, default)
@pytest.mark.parametrize("module", sorted(LISTS))
def test_accepted_params_match_what_the_list_reads(module, admin_user, admin_profile):
"""The written-out sets drift from the list functions the day one of them
grows a filter. Asked both ways, so a param a list stops reading is caught
as well as one it starts reading."""
build, accepted = LISTS[module]
params = _Recorder()
build(SimpleNamespace(profile=admin_profile, user=admin_user), params)
assert params.read - {"__probe__"} == accepted
# ------------------------------------------------------------ names and cap
def test_duplicate_name_is_400_case_insensitively(user_client, colleague):
assert create(user_client, name="Hot").status_code == 201
duplicate = create(user_client, name=" hot ")
assert duplicate.status_code == 400
assert "name" in duplicate.data
# Another list, or another person, may use the same name.
assert create(user_client, module="cases", name="Hot").status_code == 201
assert create(colleague.client, name="Hot").status_code == 201
other = create(user_client, name="Cold").data["id"]
clash = user_client.patch(detail(other), {"name": "HOT"}, format="json")
assert clash.status_code == 400
# Renaming a view to its own name, in another case, is not a clash.
assert (
user_client.patch(detail(other), {"name": "COLD"}, format="json").status_code
== 200
)
def test_name_is_required_and_bounded(user_client):
assert create(user_client, name=" ").status_code == 400
assert create(user_client, name="x" * 101).status_code == 400
assert create(user_client, name="x" * 100).status_code == 201
body = {"module": "leads", "filters": {}}
assert user_client.post(URL, body, format="json").status_code == 400
def test_cap_per_list_is_enforced(user_client, colleague):
for i in range(MAX_VIEWS_PER_LIST):
assert create(user_client, name=f"View {i}").status_code == 201
over = create(user_client, name="One too many")
assert over.status_code == 400
assert SavedView.objects.filter(module="leads").count() == MAX_VIEWS_PER_LIST
# The cap is per person and per list.
assert create(user_client, module="cases", name="Fine").status_code == 201
assert create(colleague.client, name="Fine").status_code == 201
# A full list can still be renamed.
first = SavedView.objects.filter(name="View 0").first()
assert (
user_client.patch(
detail(first.id), {"name": "Renamed"}, format="json"
).status_code
== 200
)
def test_a_save_that_loses_the_race_is_a_400_not_a_500(user_profile, regular_user):
"""Two saves can both pass the name check; the constraint catches the second."""
from rest_framework.exceptions import ValidationError
from common.saved_views import SavedViewSerializer
request = SimpleNamespace(profile=user_profile, user=regular_user)
serializer = SavedViewSerializer(
data={"module": "leads", "name": "Hot"}, context={"request": request}
)
assert serializer.is_valid(), serializer.errors
SavedView.objects.create(
org=user_profile.org, profile=user_profile, module="leads", name="HOT"
)
with pytest.raises(ValidationError) as caught:
serializer.save(org=user_profile.org, profile=user_profile)
assert "name" in caught.value.detail
assert SavedView.objects.count() == 1
def test_a_refused_value_reads_as_one_sentence_per_param(user_client):
response = create(user_client, filters={"assigned_to": "nope"})
assert response.status_code == 400
assert response.data["filters"] == ["assigned_to: 'nope' is not a valid id."]