bottleneckcrm/backend/tasks/tests/test_boards.py
Ashwin 794ff2dbd4 Refactor ticket and contact handling to improve visibility and access control
- Updated task views to utilize new access functions for accounts and contacts, ensuring users only see what they can access.
- Enhanced contact editing to maintain linked accounts even when not visible in the picker, preventing accidental unlinking.
- Introduced tests for contact form to verify linked account behavior.
- Implemented parent ticket handling to correctly display restricted tickets, ensuring hidden parents are represented accurately in the UI.
- Added tests for ticket parent visibility and interaction, confirming that restricted parents do not allow navigation.
- Improved ticket tree structure to handle restricted nodes, ensuring proper functionality during close operations.
2026-09-26 12:17:45 +05:30

729 lines
28 KiB
Python

import uuid
import pytest
from tasks.models import Board, BoardColumn, BoardMember, BoardTask
@pytest.mark.django_db
class TestBoardListView:
"""Tests for GET /api/boards/ and POST /api/boards/."""
def test_list_boards(self, admin_client, admin_profile, org_a):
board = Board.objects.create(name="Test Board", owner=admin_profile, org=org_a)
BoardMember.objects.create(board=board, profile=admin_profile, role="owner")
response = admin_client.get("/api/boards/")
assert response.status_code == 200
data = response.json()
assert "results" in data
assert data["count"] >= 1
def test_create_board(self, admin_client, org_a):
response = admin_client.post(
"/api/boards/",
{"name": "New Board", "create_default_columns": False},
format="json",
)
assert response.status_code == 201
data = response.json()
assert data["name"] == "New Board"
assert Board.objects.filter(name="New Board", org=org_a).exists()
def test_create_board_with_default_columns(self, admin_client, org_a):
"""Creating a board with default columns creates 3 columns."""
response = admin_client.post(
"/api/boards/",
{"name": "Default Cols Board", "create_default_columns": True},
format="json",
)
assert response.status_code == 201
board = Board.objects.get(name="Default Cols Board")
assert board.columns.count() == 3
# Owner should be added as member
assert BoardMember.objects.filter(board=board, role="owner").exists()
def test_list_boards_search(self, admin_client, admin_profile, org_a):
"""Search filter on board name."""
board = Board.objects.create(name="Alpha Board", owner=admin_profile, org=org_a)
BoardMember.objects.create(board=board, profile=admin_profile, role="owner")
board2 = Board.objects.create(name="Beta Board", owner=admin_profile, org=org_a)
BoardMember.objects.create(board=board2, profile=admin_profile, role="owner")
response = admin_client.get("/api/boards/?search=Alpha")
assert response.status_code == 200
data = response.json()
assert data["count"] == 1
assert data["results"][0]["name"] == "Alpha Board"
def test_list_boards_filter_archived(self, admin_client, admin_profile, org_a):
"""Filter by archived status."""
board = Board.objects.create(
name="Active Board",
owner=admin_profile,
org=org_a,
is_archived=False,
)
BoardMember.objects.create(board=board, profile=admin_profile, role="owner")
archived_board = Board.objects.create(
name="Archived Board",
owner=admin_profile,
org=org_a,
is_archived=True,
)
BoardMember.objects.create(
board=archived_board, profile=admin_profile, role="owner"
)
response = admin_client.get("/api/boards/?archived=true")
assert response.status_code == 200
data = response.json()
names = [b["name"] for b in data["results"]]
assert "Archived Board" in names
assert "Active Board" not in names
def test_list_boards_reports_owner_role(self, admin_client, admin_profile, org_a):
"""The requester's own role rides on each row as ``my_role``."""
board = Board.objects.create(name="Owned Board", owner=admin_profile, org=org_a)
BoardMember.objects.create(board=board, profile=admin_profile, role="owner")
response = admin_client.get("/api/boards/")
assert response.status_code == 200
row = next(b for b in response.json()["results"] if b["id"] == str(board.id))
assert row["my_role"] == "owner"
def test_list_boards_reports_member_role(
self, user_client, admin_profile, user_profile, org_a
):
"""A plain member sees ``my_role == 'member'``. The frontend uses this
to hide the owner/admin-only column controls it could never use."""
board = Board.objects.create(
name="Shared Board", owner=admin_profile, org=org_a
)
BoardMember.objects.create(board=board, profile=admin_profile, role="owner")
BoardMember.objects.create(board=board, profile=user_profile, role="member")
response = user_client.get("/api/boards/")
assert response.status_code == 200
row = next(b for b in response.json()["results"] if b["id"] == str(board.id))
assert row["my_role"] == "member"
def test_my_role_is_derived_not_client_supplied(
self, user_client, admin_profile, user_profile, org_a
):
"""``my_role`` is server-derived: a member cannot inflate it to owner."""
board = Board.objects.create(name="Role Board", owner=admin_profile, org=org_a)
BoardMember.objects.create(board=board, profile=admin_profile, role="owner")
BoardMember.objects.create(board=board, profile=user_profile, role="member")
# Even if the client sends its own my_role, the field is read-only.
response = user_client.get("/api/boards/?my_role=owner")
row = next(b for b in response.json()["results"] if b["id"] == str(board.id))
assert row["my_role"] == "member"
@pytest.mark.django_db
class TestBoardDetailView:
"""Tests for GET/PUT/DELETE /api/boards/<pk>/."""
def test_get_board(self, admin_client, admin_profile, admin_user, org_a):
board = Board.objects.create(
name="Detail Board",
owner=admin_profile,
org=org_a,
created_by=admin_user,
)
BoardMember.objects.create(board=board, profile=admin_profile, role="owner")
response = admin_client.get(f"/api/boards/{board.id}/")
assert response.status_code == 200
data = response.json()
assert data["name"] == "Detail Board"
def test_update_board(self, admin_client, admin_profile, admin_user, org_a):
board = Board.objects.create(
name="Old Board Name",
owner=admin_profile,
org=org_a,
created_by=admin_user,
)
BoardMember.objects.create(board=board, profile=admin_profile, role="owner")
response = admin_client.put(
f"/api/boards/{board.id}/",
{"name": "Updated Board Name"},
format="json",
)
assert response.status_code == 200
data = response.json()
assert data["name"] == "Updated Board Name"
def test_delete_board(self, admin_client, admin_profile, admin_user, org_a):
board = Board.objects.create(
name="Delete Board",
owner=admin_profile,
org=org_a,
created_by=admin_user,
)
BoardMember.objects.create(board=board, profile=admin_profile, role="owner")
response = admin_client.delete(f"/api/boards/{board.id}/")
assert response.status_code == 204
assert not Board.objects.filter(id=board.id).exists()
def test_get_board_non_member_denied(
self, user_client, admin_profile, admin_user, org_a
):
"""Non-member should get 404 when accessing a board."""
board = Board.objects.create(
name="Private Board",
owner=admin_profile,
org=org_a,
created_by=admin_user,
)
BoardMember.objects.create(board=board, profile=admin_profile, role="owner")
response = user_client.get(f"/api/boards/{board.id}/")
assert response.status_code == 404
def test_update_board_member_role_forbidden(
self, user_client, admin_profile, admin_user, user_profile, org_a
):
"""Member with 'member' role should get 403 when trying to update board."""
board = Board.objects.create(
name="Member Board",
owner=admin_profile,
org=org_a,
created_by=admin_user,
)
BoardMember.objects.create(board=board, profile=admin_profile, role="owner")
BoardMember.objects.create(board=board, profile=user_profile, role="member")
response = user_client.put(
f"/api/boards/{board.id}/",
{"name": "Should Fail"},
format="json",
)
assert response.status_code == 403
def test_delete_board_non_owner_forbidden(
self, user_client, admin_profile, admin_user, user_profile, org_a
):
"""Only the owner should be able to delete a board."""
board = Board.objects.create(
name="Owner Delete Board",
owner=admin_profile,
org=org_a,
created_by=admin_user,
)
BoardMember.objects.create(board=board, profile=admin_profile, role="owner")
BoardMember.objects.create(board=board, profile=user_profile, role="admin")
response = user_client.delete(f"/api/boards/{board.id}/")
assert response.status_code == 403
assert Board.objects.filter(id=board.id).exists()
def test_patch_board(self, admin_client, admin_profile, admin_user, org_a):
"""PATCH should allow partial board update."""
board = Board.objects.create(
name="Patch Board",
description="Old desc",
owner=admin_profile,
org=org_a,
created_by=admin_user,
)
BoardMember.objects.create(board=board, profile=admin_profile, role="owner")
response = admin_client.patch(
f"/api/boards/{board.id}/",
{"description": "New desc"},
format="json",
)
assert response.status_code == 200
assert response.json()["description"] == "New desc"
assert response.json()["name"] == "Patch Board"
def test_patch_board_non_member_denied(
self, user_client, admin_profile, admin_user, org_a
):
"""PATCH by non-member should return 404."""
board = Board.objects.create(
name="Patch Deny Board",
owner=admin_profile,
org=org_a,
created_by=admin_user,
)
BoardMember.objects.create(board=board, profile=admin_profile, role="owner")
response = user_client.patch(
f"/api/boards/{board.id}/",
{"name": "Should Fail"},
format="json",
)
assert response.status_code == 404
@pytest.mark.django_db
class TestBoardColumns:
"""Tests for GET/POST /api/boards/<board_pk>/columns/."""
def test_create_column(self, admin_client, admin_profile, admin_user, org_a):
board = Board.objects.create(
name="Column Board",
owner=admin_profile,
org=org_a,
created_by=admin_user,
)
BoardMember.objects.create(board=board, profile=admin_profile, role="owner")
response = admin_client.post(
f"/api/boards/{board.id}/columns/",
{"name": "Backlog", "order": 0, "color": "#6B7280"},
format="json",
)
assert response.status_code == 201
data = response.json()
assert data["name"] == "Backlog"
assert BoardColumn.objects.filter(board=board, name="Backlog").exists()
def test_list_columns(self, admin_client, admin_profile, admin_user, org_a):
board = Board.objects.create(
name="List Column Board",
owner=admin_profile,
org=org_a,
created_by=admin_user,
)
BoardMember.objects.create(board=board, profile=admin_profile, role="owner")
BoardColumn.objects.create(board=board, name="To Do", order=1, org=org_a)
BoardColumn.objects.create(board=board, name="Done", order=2, org=org_a)
response = admin_client.get(f"/api/boards/{board.id}/columns/")
assert response.status_code == 200
data = response.json()
assert len(data) == 2
def test_create_column_member_forbidden(
self, user_client, admin_profile, admin_user, user_profile, org_a
):
"""Member with 'member' role should not be able to create columns."""
board = Board.objects.create(
name="Member Col Board",
owner=admin_profile,
org=org_a,
created_by=admin_user,
)
BoardMember.objects.create(board=board, profile=admin_profile, role="owner")
BoardMember.objects.create(board=board, profile=user_profile, role="member")
response = user_client.post(
f"/api/boards/{board.id}/columns/",
{"name": "Should Fail", "order": 0},
format="json",
)
assert response.status_code == 403
def test_list_columns_non_member_forbidden(
self, user_client, admin_profile, admin_user, org_a
):
"""Non-member should get 404 when listing columns."""
board = Board.objects.create(
name="Private Col Board",
owner=admin_profile,
org=org_a,
created_by=admin_user,
)
BoardMember.objects.create(board=board, profile=admin_profile, role="owner")
response = user_client.get(f"/api/boards/{board.id}/columns/")
assert response.status_code == 404
def test_create_duplicate_column_name_returns_400(
self, admin_client, admin_profile, admin_user, org_a
):
"""A second column with the same name is a clean 400, not a 500.
``BoardColumn`` has ``unique_together = (board, name)``; without an
explicit guard the duplicate hits the DB constraint and 500s, because
``board`` is read-only on the serializer so DRF cannot auto-validate it.
"""
board = Board.objects.create(
name="Dup Col Board",
owner=admin_profile,
org=org_a,
created_by=admin_user,
)
BoardMember.objects.create(board=board, profile=admin_profile, role="owner")
BoardColumn.objects.create(board=board, name="To Do", order=1, org=org_a)
response = admin_client.post(
f"/api/boards/{board.id}/columns/",
{"name": "To Do", "order": 2},
format="json",
)
assert response.status_code == 400
assert "name" in response.json()["errors"]
# Only the original column survives.
assert BoardColumn.objects.filter(board=board, name="To Do").count() == 1
@pytest.mark.django_db
class TestBoardTasks:
"""Tests for board task endpoints."""
def _create_board_with_column(self, admin_profile, admin_user, org_a):
"""Helper to create a board with one column and owner membership."""
board = Board.objects.create(
name="Task Board",
owner=admin_profile,
org=org_a,
created_by=admin_user,
)
BoardMember.objects.create(board=board, profile=admin_profile, role="owner")
column = BoardColumn.objects.create(
board=board, name="To Do", order=1, org=org_a
)
return board, column
def test_create_board_task(self, admin_client, admin_profile, admin_user, org_a):
_board, column = self._create_board_with_column(
admin_profile, admin_user, org_a
)
response = admin_client.post(
f"/api/boards/columns/{column.id}/tasks/",
{"title": "New Card", "priority": "medium"},
format="json",
)
assert response.status_code == 201
data = response.json()
assert data["title"] == "New Card"
assert BoardTask.objects.filter(column=column, title="New Card").exists()
def test_get_board_task(self, admin_client, admin_profile, admin_user, org_a):
"""Verify a board task appears in the column task list."""
_board, column = self._create_board_with_column(
admin_profile, admin_user, org_a
)
BoardTask.objects.create(
column=column,
title="Existing Card",
priority="high",
org=org_a,
created_by=admin_user,
)
response = admin_client.get(f"/api/boards/columns/{column.id}/tasks/")
assert response.status_code == 200
data = response.json()
titles = [t["title"] for t in data]
assert "Existing Card" in titles
def test_delete_board_task(self, admin_client, admin_profile, admin_user, org_a):
_board, column = self._create_board_with_column(
admin_profile, admin_user, org_a
)
task = BoardTask.objects.create(
column=column,
title="Delete Card",
priority="low",
org=org_a,
created_by=admin_user,
)
response = admin_client.delete(f"/api/boards/tasks/{task.id}/")
assert response.status_code == 204
assert not BoardTask.objects.filter(id=task.id).exists()
def test_create_board_task_with_assigned_to_ids(
self, admin_client, admin_profile, admin_user, org_a
):
"""A card created with ``assigned_to_ids`` is created with its assignee.
This test used to create the card without the key and assign it by PUT,
with a docstring recording that POST with ``assigned_to_ids`` failed.
"""
_board, column = self._create_board_with_column(
admin_profile, admin_user, org_a
)
response = admin_client.post(
f"/api/boards/columns/{column.id}/tasks/",
{
"title": "Assigned Card",
"priority": "high",
"assigned_to_ids": [str(admin_profile.id)],
},
format="json",
)
assert response.status_code == 201, response.data
task = BoardTask.objects.get(title="Assigned Card")
assert list(task.assigned_to.all()) == [admin_profile]
assert [p["id"] for p in response.json()["assigned_to"]] == [
str(admin_profile.id)
]
def test_update_board_task(self, admin_client, admin_profile, admin_user, org_a):
"""PUT on a board task should update it."""
_board, column = self._create_board_with_column(
admin_profile, admin_user, org_a
)
task = BoardTask.objects.create(
column=column,
title="Update Card",
priority="medium",
org=org_a,
created_by=admin_user,
)
response = admin_client.put(
f"/api/boards/tasks/{task.id}/",
{"title": "Updated Card", "priority": "high"},
format="json",
)
assert response.status_code == 200
assert response.json()["title"] == "Updated Card"
task.refresh_from_db()
assert task.title == "Updated Card"
def test_update_board_task_non_member_forbidden(
self, user_client, admin_profile, admin_user, org_a
):
"""Non-member should get 404, as GET answers them, when updating a board task."""
board = Board.objects.create(
name="Private Task Board",
owner=admin_profile,
org=org_a,
created_by=admin_user,
)
BoardMember.objects.create(board=board, profile=admin_profile, role="owner")
column = BoardColumn.objects.create(board=board, name="Col", order=1, org=org_a)
task = BoardTask.objects.create(
column=column,
title="Private Card",
priority="low",
org=org_a,
created_by=admin_user,
)
response = user_client.put(
f"/api/boards/tasks/{task.id}/",
{"title": "Hacked Card"},
format="json",
)
assert response.status_code == 404
def test_get_tasks_non_member_forbidden(
self, user_client, admin_profile, admin_user, org_a
):
"""Non-member should get 404 when listing column tasks."""
board = Board.objects.create(
name="Private Task List Board",
owner=admin_profile,
org=org_a,
created_by=admin_user,
)
BoardMember.objects.create(board=board, profile=admin_profile, role="owner")
column = BoardColumn.objects.create(board=board, name="Col", order=1, org=org_a)
response = user_client.get(f"/api/boards/columns/{column.id}/tasks/")
assert response.status_code == 404
def test_create_task_non_member_forbidden(
self, user_client, admin_profile, admin_user, org_a
):
"""Non-member should get 404, as GET answers them, when creating a task in a column."""
board = Board.objects.create(
name="No Access Task Board",
owner=admin_profile,
org=org_a,
created_by=admin_user,
)
BoardMember.objects.create(board=board, profile=admin_profile, role="owner")
column = BoardColumn.objects.create(board=board, name="Col", order=1, org=org_a)
response = user_client.post(
f"/api/boards/columns/{column.id}/tasks/",
{"title": "Blocked Card", "priority": "low"},
format="json",
)
assert response.status_code == 404
def test_update_board_task_with_assigned_to(
self, admin_client, admin_profile, admin_user, org_a
):
"""PUT on a board task should update assigned_to when assigned_to_ids is provided."""
_board, column = self._create_board_with_column(
admin_profile, admin_user, org_a
)
task = BoardTask.objects.create(
column=column,
title="Assign Update Card",
priority="medium",
org=org_a,
created_by=admin_user,
)
response = admin_client.put(
f"/api/boards/tasks/{task.id}/",
{
"title": "Assign Update Card",
"assigned_to_ids": [str(admin_profile.id)],
},
format="json",
)
assert response.status_code == 200
task.refresh_from_db()
assert task.assigned_to.count() == 1
def _board_with_two_columns(self, admin_profile, admin_user, org_a):
"""Board (owner membership) with two ordered columns for move tests."""
board = Board.objects.create(
name="Move Board", owner=admin_profile, org=org_a, created_by=admin_user
)
BoardMember.objects.create(board=board, profile=admin_profile, role="owner")
todo = BoardColumn.objects.create(board=board, name="To Do", order=1, org=org_a)
doing = BoardColumn.objects.create(
board=board, name="Doing", order=2, org=org_a
)
return board, todo, doing
def test_move_board_task_to_another_column(
self, admin_client, admin_profile, admin_user, org_a
):
"""PUT with a sibling column id relocates the card. The core kanban move.
Regression: ``column`` was read-only on the serializer, so the change was
silently dropped and the card never left its lane (200, but no move)."""
_board, todo, doing = self._board_with_two_columns(
admin_profile, admin_user, org_a
)
task = BoardTask.objects.create(
column=todo,
title="Drag me",
priority="medium",
order=0,
org=org_a,
created_by=admin_user,
)
response = admin_client.put(
f"/api/boards/tasks/{task.id}/",
{"column": str(doing.id), "order": 0},
format="json",
)
assert response.status_code == 200
task.refresh_from_db()
assert task.column_id == doing.id
assert task.order == 0
def test_move_to_column_on_another_board_rejected(
self, admin_client, admin_profile, admin_user, org_a
):
"""A card cannot be moved into a column that belongs to another board."""
_board, todo, _doing = self._board_with_two_columns(
admin_profile, admin_user, org_a
)
other_board = Board.objects.create(
name="Other Board", owner=admin_profile, org=org_a, created_by=admin_user
)
BoardMember.objects.create(
board=other_board, profile=admin_profile, role="owner"
)
foreign_col = BoardColumn.objects.create(
board=other_board, name="Elsewhere", order=1, org=org_a
)
task = BoardTask.objects.create(
column=todo,
title="Stay put",
priority="low",
org=org_a,
created_by=admin_user,
)
response = admin_client.put(
f"/api/boards/tasks/{task.id}/",
{"column": str(foreign_col.id)},
format="json",
)
assert response.status_code == 400
task.refresh_from_db()
assert task.column_id == todo.id # unchanged
def test_move_to_nonexistent_column_rejected(
self, admin_client, admin_profile, admin_user, org_a
):
"""A random column id is a 400, not a silent no-op."""
_board, todo, _doing = self._board_with_two_columns(
admin_profile, admin_user, org_a
)
task = BoardTask.objects.create(
column=todo,
title="Stay",
priority="low",
org=org_a,
created_by=admin_user,
)
response = admin_client.put(
f"/api/boards/tasks/{task.id}/",
{"column": str(uuid.uuid4())},
format="json",
)
assert response.status_code == 400
task.refresh_from_db()
assert task.column_id == todo.id
def test_reorder_within_column_resequences(
self, admin_client, admin_profile, admin_user, org_a
):
"""Dropping a card at the top of its own lane renumbers to a contiguous
0..n-1 with no duplicate order values."""
_board, todo, _doing = self._board_with_two_columns(
admin_profile, admin_user, org_a
)
a = BoardTask.objects.create(
column=todo, title="A", order=0, org=org_a, created_by=admin_user
)
b = BoardTask.objects.create(
column=todo, title="B", order=1, org=org_a, created_by=admin_user
)
c = BoardTask.objects.create(
column=todo, title="C", order=2, org=org_a, created_by=admin_user
)
response = admin_client.put(
f"/api/boards/tasks/{c.id}/",
{"order": 0},
format="json",
)
assert response.status_code == 200
a.refresh_from_db()
b.refresh_from_db()
c.refresh_from_db()
assert c.order == 0
assert a.order == 1
assert b.order == 2
def test_move_recompacts_source_column(
self, admin_client, admin_profile, admin_user, org_a
):
"""When a card leaves a lane, the cards left behind close the gap."""
_board, todo, doing = self._board_with_two_columns(
admin_profile, admin_user, org_a
)
a = BoardTask.objects.create(
column=todo, title="A", order=0, org=org_a, created_by=admin_user
)
b = BoardTask.objects.create(
column=todo, title="B", order=1, org=org_a, created_by=admin_user
)
c = BoardTask.objects.create(
column=todo, title="C", order=2, org=org_a, created_by=admin_user
)
response = admin_client.put(
f"/api/boards/tasks/{b.id}/",
{"column": str(doing.id), "order": 0},
format="json",
)
assert response.status_code == 200
a.refresh_from_db()
b.refresh_from_db()
c.refresh_from_db()
assert b.column_id == doing.id and b.order == 0
assert sorted([a.order, c.order]) == [0, 1] # no gap where B was
def test_cannot_overwrite_created_by_on_update(
self, admin_client, admin_profile, admin_user, org_a, user_b
):
"""created_by is a server-derived audit fact. It FKs common.User, which
RLS does not org-scope, so it must not be mass-assignable from the body."""
_board, todo, _doing = self._board_with_two_columns(
admin_profile, admin_user, org_a
)
task = BoardTask.objects.create(
column=todo,
title="Owned",
priority="low",
org=org_a,
)
# Seed created_by directly (BaseModel.save() derives it from the request
# user, so it can't be set through the ORM in a test).
BoardTask.objects.filter(pk=task.pk).update(created_by=admin_user)
response = admin_client.put(
f"/api/boards/tasks/{task.id}/",
{"title": "Owned", "created_by": str(user_b.id)},
format="json",
)
assert response.status_code == 200
task.refresh_from_db()
assert task.created_by_id == admin_user.id # unchanged
assert task.created_by_id != user_b.id # the mass-assignment was rejected