Speakr is a personal, self-hosted web application designed for transcribing audio recordings
Python
Paginated list: payload parity test against the per-row path and a statement counter (D#483)
Murtaza Nasirfde0e229d209
diff --git a/tests/test_recording_list_batch.py b/tests/test_recording_list_batch.pynew file mode 100644index 00000000..80aeb1a9--- /dev/null+++ b/tests/test_recording_list_batch.py@@ -0,0 +1,355 @@+"""GET /api/recordings: SQL cost per page and payload parity (D#483).++The paginated list used to run several queries per row while serializing+it. The payload test compares the route against a frozen copy of the+per-row enrichment as it stood before the batching (``_legacy_rows``, which+also exercises the per-row fallback of ``Recording.to_list_dict``), over a+fixture with every kind of row the list serves: owned, shared with and+without edit, editable through a group-admin role, tagged (personal, group,+hidden group), foldered, duplicated (owner-scoped on shared rows) and+inbox / highlighted / archived for the owner and for a recipient.++SHARED-DB: everything is created under fresh users and removed afterwards;+assertions are scoped to this module's viewers.+"""++import json+import os+import sys+import uuid+from contextlib import contextmanager+from datetime import datetime, timedelta+from unittest.mock import patch++import pytest+from sqlalchemy import event++sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))++import src.api.recordings as rec_module+from src.app import app, db+from src.models import (+ ExportTemplate, Folder, Group, GroupMembership, InternalShare, NamingTemplate, Recording,+ RecordingTag, Share, SharedRecordingState, Tag, User,+)++app.config["WTF_CSRF_ENABLED"] = False++_PREFIX = "lstb"+++# --------------------------------------------------------------------------- #+# Helpers+# --------------------------------------------------------------------------- #++@contextmanager+def count_statements():+ """Collect every SQL statement sent to the database inside the block."""+ statements = []++ def _before(conn, cursor, statement, parameters, context, executemany):+ statements.append(statement)++ with app.app_context():+ engine = db.engine+ event.listen(engine, "before_cursor_execute", _before)+ try:+ yield statements+ finally:+ event.remove(engine, "before_cursor_execute", _before)+++@contextmanager+def sharing_on():+ with patch("src.app.ENABLE_INTERNAL_SHARING", True), \+ patch.object(rec_module, "ENABLE_INTERNAL_SHARING", True):+ yield+++def _user(tag):+ s = uuid.uuid4().hex[:8]+ u = User(username=f"{_PREFIX}{tag}_{s}"[:20], email=f"{_PREFIX}{tag}_{s}@local.test", password="x")+ db.session.add(u)+ db.session.flush()+ return u+++def _rec(user, title, marker, **kw):+ kw.setdefault("status", "COMPLETED")+ kw.setdefault("audio_path", "local://lstb/a.mp3")+ rec = Recording(user_id=user.id, title=title, participants=marker,+ transcription="hello", summary="sum", original_filename="a.mp3", **kw)+ db.session.add(rec)+ db.session.flush()+ return rec+++def _tag(rec, tag, order):+ db.session.add(RecordingTag(recording_id=rec.id, tag_id=tag.id, order=order))+++def _share(rec, recipient, **kw):+ share = InternalShare(recording_id=rec.id, owner_id=rec.user_id, shared_with_user_id=recipient.id, **kw)+ db.session.add(share)+ return share+++def _cleanup(user_ids, group_ids):+ with app.app_context():+ db.session.rollback()+ rec_ids = [r for (r,) in db.session.query(Recording.id).filter(Recording.user_id.in_(user_ids))]+ if rec_ids:+ for model in (RecordingTag, Share, InternalShare, SharedRecordingState):+ model.query.filter(model.recording_id.in_(rec_ids)).delete(synchronize_session=False)+ Recording.query.filter(Recording.id.in_(rec_ids)).delete(synchronize_session=False)+ Tag.query.filter(Tag.user_id.in_(user_ids)).delete(synchronize_session=False)+ Folder.query.filter(Folder.user_id.in_(user_ids)).delete(synchronize_session=False)+ GroupMembership.query.filter(GroupMembership.user_id.in_(user_ids)).delete(synchronize_session=False)+ if group_ids:+ Group.query.filter(Group.id.in_(group_ids)).delete(synchronize_session=False)+ NamingTemplate.query.filter(NamingTemplate.user_id.in_(user_ids)).delete(synchronize_session=False)+ ExportTemplate.query.filter(ExportTemplate.user_id.in_(user_ids)).delete(synchronize_session=False)+ User.query.filter(User.id.in_(user_ids)).delete(synchronize_session=False)+ db.session.commit()+++def _client(user_id):+ c = app.test_client()+ with c.session_transaction() as sess:+ sess["_user_id"] = str(user_id)+ sess["_fresh"] = True+ return c+++def _page(user_id, **params):+ params.setdefault("per_page", 100)+ resp = _client(user_id).get("/api/recordings", query_string=params)+ assert resp.status_code == 200, resp.get_json()+ return resp.get_json()+++def _legacy_rows(viewer_id, ids):+ """The route's per-row enrichment as it was before D#483, verbatim.++ It calls to_list_dict without page lookups, so it also runs the per-row+ fallback that single-row callers keep using.+ """+ from src.app import get_user_recording_status, has_recording_access+ from src.services.recording_state import get_user_archived++ with app.app_context():+ current_user = db.session.get(User, viewer_id)+ recordings = [db.session.get(Recording, rid) for rid in ids]+ share_map = {}+ for s in InternalShare.query.filter(+ InternalShare.recording_id.in_(ids),+ InternalShare.shared_with_user_id == current_user.id+ ).all():+ share_map[s.recording_id] = s++ enriched_recordings = []+ for recording in recordings:+ rec_dict = recording.to_list_dict(viewer_user=current_user, share_map=share_map)+ is_owner = recording.user_id == current_user.id+ rec_dict['is_owner'] = is_owner+ user_inbox, user_highlighted = get_user_recording_status(recording, current_user)+ rec_dict['is_inbox'] = user_inbox+ rec_dict['is_highlighted'] = user_highlighted+ rec_dict['is_archived'] = get_user_archived(recording, current_user)+ rec_dict['can_edit'] = has_recording_access(recording, current_user, require_edit=True)+ rec_dict['can_delete'] = is_owner and (rec_module.USERS_CAN_DELETE or current_user.is_admin)+ if not is_owner:+ owner = db.session.get(User, recording.user_id)+ rec_dict['owner_username'] = owner.username if owner else "Unknown"+ rec_dict['is_shared'] = True+ rec_dict['shared_with_count'] = 0+ rec_dict['public_share_count'] = 0+ share = share_map.get(recording.id)+ if share:+ rec_dict['share_info'] = {+ 'share_id': share.id,+ 'owner_username': owner.username if owner else "Unknown",+ 'can_edit': share.can_edit,+ 'can_reshare': share.can_reshare,+ 'shared_at': share.created_at.isoformat()+ }+ else:+ rec_dict['share_info'] = {+ 'can_edit': False,+ 'can_reshare': False+ }+ else:+ rec_dict['is_shared'] = False+ visible_tags = recording.get_visible_tags(current_user)+ rec_dict['has_group_tags'] = any(tag.is_group_tag for tag in visible_tags)+ enriched_recordings.append(rec_dict)+ return json.loads(json.dumps(enriched_recordings))+++# --------------------------------------------------------------------------- #+# Rich fixture+# --------------------------------------------------------------------------- #+[email protected](scope="module")+def world():+ marker = f"lstbmark{uuid.uuid4().hex[:8]}"+ with app.app_context():+ viewer, o1, o2, x = _user("v"), _user("o1"), _user("o2"), _user("x")+ sfx = uuid.uuid4().hex[:6]+ g_admin, g_member, g_lead_off, g_out = (Group(name=f"{_PREFIX}_{n}_{sfx}")+ for n in ("admin", "member", "leadoff", "out"))+ db.session.add_all([g_admin, g_member, g_lead_off, g_out])+ db.session.flush()+ db.session.add_all([+ GroupMembership(group_id=g_admin.id, user_id=viewer.id, role="admin"),+ GroupMembership(group_id=g_admin.id, user_id=o1.id, role="member"),+ GroupMembership(group_id=g_member.id, user_id=viewer.id, role="member"),+ GroupMembership(group_id=g_member.id, user_id=o1.id, role="admin"),+ GroupMembership(group_id=g_lead_off.id, user_id=viewer.id, role="admin"),+ GroupMembership(group_id=g_out.id, user_id=x.id, role="admin"),+ ])+ nt = NamingTemplate(user_id=viewer.id, name="Naming T", template="{{ai_title}}")+ et = ExportTemplate(user_id=viewer.id, name="Export T", template="{{title}}")+ db.session.add_all([nt, et])+ db.session.flush()++ t_personal = Tag(name="Personal", user_id=viewer.id, color="#111111",+ naming_template_id=nt.id, export_template_id=et.id)+ t_member = Tag(name="TeamTag", user_id=o1.id, group_id=g_member.id)+ t_out = Tag(name="Outsiders", user_id=x.id, group_id=g_out.id)+ t_o1_private = Tag(name="O1Private", user_id=o1.id)+ t_admin = Tag(name="AdminTag", user_id=o1.id, group_id=g_admin.id, auto_share_on_apply=True)+ t_lead_off = Tag(name="LeadOff", user_id=o1.id, group_id=g_lead_off.id,+ auto_share_on_apply=False, share_with_group_lead=False)+ f_personal = Folder(name="MyFolder", user_id=viewer.id, naming_template_id=nt.id,+ export_template_id=et.id)+ f_o1 = Folder(name="O1Folder", user_id=o1.id)+ f_group = Folder(name="TeamFolder", user_id=o2.id, group_id=g_member.id)+ db.session.add_all([t_personal, t_member, t_out, t_o1_private, t_admin, t_lead_off,+ f_personal, f_o1, f_group])+ db.session.flush()++ base = datetime(2026, 3, 1, 9, 0, 0)+ when = iter(base + timedelta(minutes=i) for i in range(100))++ # --- owned by the viewer+ a = _rec(viewer, "A", marker, folder_id=f_personal.id, file_hash="h1" + sfx, created_at=next(when),+ is_inbox=False, is_highlighted=True, notes="owner notes", meeting_date=base,+ audio_duration_seconds=61.5, mime_type="audio/mpeg", file_size=1234)+ b = _rec(viewer, None, marker, folder_id=f_personal.id, file_hash="h1" + sfx, created_at=next(when),+ is_archived=True)+ c = _rec(viewer, "C", marker, created_at=next(when), audio_deleted_at=base, mime_type="video/mp4",+ deletion_exempt=True, keep_audio_only=True)+ d = _rec(viewer, "D", marker, file_hash="h2" + sfx, created_at=next(when), completed_at=base)+ v1 = _rec(viewer, "V1", marker, file_hash="h3" + sfx, created_at=next(when))+ v2 = _rec(viewer, "V2", marker, file_hash="h3" + sfx, created_at=next(when))+ _tag(a, t_personal, 0)+ _tag(a, t_member, 1)+ _tag(a, t_out, 2)+ _tag(b, t_personal, 0)+ _share(a, o1, can_edit=True)+ _share(a, o2)+ db.session.add(Share(recording_id=a.id, user_id=viewer.id))++ # --- shared with the viewer+ s1 = _rec(o1, "S1", marker, folder_id=f_o1.id, file_hash="h3" + sfx, created_at=next(when))+ s1_copy = _rec(o1, "S1 copy", marker, file_hash="h3" + sfx, created_at=next(when))+ _tag(s1, t_o1_private, 0)+ _share(s1, viewer, can_edit=True, can_reshare=True)+ db.session.add(SharedRecordingState(recording_id=s1.id, user_id=viewer.id,+ is_inbox=False, is_highlighted=True, is_archived=False))+ db.session.add(Share(recording_id=s1.id, user_id=o1.id))+ _share(s1, x)++ s2 = _rec(o1, "S2", marker, created_at=next(when))+ _tag(s2, t_admin, 0)+ _tag(s2, t_o1_private, 1)+ _share(s2, viewer, can_edit=False, source_type="group_tag", source_tag_id=t_admin.id)++ s3 = _rec(o1, "S3", marker, created_at=next(when))+ _tag(s3, t_member, 0)+ _share(s3, viewer, can_edit=False)++ s4 = _rec(o1, "S4", marker, created_at=next(when))+ _tag(s4, t_lead_off, 0)+ _share(s4, viewer, can_edit=False, source_type="group_tag", source_tag_id=t_lead_off.id)++ s5 = _rec(o2, "S5", marker, folder_id=f_group.id, created_at=next(when))+ _rec(o2, "S5 sibling", marker, folder_id=f_group.id, created_at=next(when))+ _share(s5, viewer, source_type="group_folder", source_folder_id=f_group.id)+ db.session.add(SharedRecordingState(recording_id=s5.id, user_id=viewer.id, is_archived=True,+ personal_notes="mine"))++ s6 = _rec(o2, "S6", marker, created_at=next(when), file_hash="h4" + sfx)+ _share(s6, viewer, can_reshare=True)+ db.session.add(SharedRecordingState(recording_id=s6.id, user_id=viewer.id,+ is_inbox=True, is_highlighted=False))+ db.session.commit()++ ids = dict(viewer=viewer.id, o1=o1.id, o2=o2.id, x=x.id, a=a.id, b=b.id, c=c.id, d=d.id,+ v1=v1.id, v2=v2.id, s1=s1.id, s1_copy=s1_copy.id, s2=s2.id, s3=s3.id, s4=s4.id,+ s5=s5.id, s6=s6.id, marker=marker,+ t_personal=t_personal.id, t_member=t_member.id, t_admin=t_admin.id,+ f_personal=f_personal.id, f_group=f_group.id)+ groups = [g_admin.id, g_member.id, g_lead_off.id, g_out.id]+ with sharing_on():+ yield ids+ _cleanup([ids["viewer"], ids["o1"], ids["o2"], ids["x"]], groups)+++VIEWS = [+ pytest.param({}, id="default"),+ pytest.param({"archived": "true"}, id="archived"),+ pytest.param({"q": "MARKER"}, id="search"),+ pytest.param({"shared": "true"}, id="shared"),+ pytest.param({"starred": "true"}, id="starred"),+ pytest.param({"inbox": "true"}, id="inbox"),+ pytest.param({"per_page": 3, "page": 2}, id="page2"),+ pytest.param({"q": "tag:teamtag"}, id="tag-filter"),+]++[email protected]("params", VIEWS)+def test_payload_matches_the_per_row_path(world, params):+ params = {k: (world["marker"] if v == "MARKER" else v) for k, v in params.items()}+ body = _page(world["viewer"], **params)+ rows = body["recordings"]+ assert rows, "every view of the fixture lists something"+ assert rows == _legacy_rows(world["viewer"], [r["id"] for r in rows])+++def test_fixture_covers_every_kind_of_row(world):+ """Guards the parity test against a fixture that stopped exercising a case."""+ w = world+ rows = {r["id"]: r for r in _page(w["viewer"], q=w["marker"])["recordings"]}+ assert set(rows) == {w[k] for k in ("a", "b", "c", "d", "v1", "v2", "s1", "s2", "s3", "s4", "s5", "s6")}+ default_ids = {r["id"] for r in _page(w["viewer"])["recordings"]}+ assert default_ids == set(rows) - {w["b"], w["s5"]} # archived by owner / by recipient++ a, b, s1, s2, s3, s4, s5, s6 = (rows[w[k]] for k in ("a", "b", "s1", "s2", "s3", "s4", "s5", "s6"))+ # owned: tags in order, hidden group tag dropped, counts over all recordings+ assert [t["name"] for t in a["tags"]] == ["Personal", "TeamTag"]+ assert a["tags"][0]["recording_count"] == 2 and a["tags"][0]["naming_template_name"] == "Naming T"+ assert a["tags"][1]["group_name"].startswith(f"{_PREFIX}_member_") and a["tags"][1]["recording_count"] == 2+ assert a["folder"]["recording_count"] == 2 and a["folder"]["export_template_name"] == "Export T"+ assert (a["shared_with_count"], a["public_share_count"]) == (2, 1)+ assert (a["is_inbox"], a["is_highlighted"], a["has_group_tags"]) == (False, True, True)+ assert [c["id"] for c in a["duplicate_info"]["copies"]] == [w["a"], w["b"]]+ assert b["duplicate_info"]["copies"][1]["title"] == f"#{w['b']}" and b["is_archived"] is True+ # shared: owner-scoped duplicates, recipient state, edit rights+ assert [c["id"] for c in s1["duplicate_info"]["copies"]] == [w["s1"], w["s1_copy"]]+ assert [c["id"] for c in rows[w["v1"]]["duplicate_info"]["copies"]] == [w["v1"], w["v2"]]+ assert (s1["is_inbox"], s1["is_highlighted"], s1["can_edit"]) == (False, True, True)+ assert s1["tags"] == [] and s1["folder"] is None+ assert (s1["shared_with_count"], s1["public_share_count"]) == (0, 0)+ assert s1["share_info"]["can_reshare"] is True and s1["owner_username"].startswith(f"{_PREFIX}o1")+ assert (s2["can_edit"], s2["share_info"]["can_edit"]) == (True, False) # group admin+ assert [t["name"] for t in s2["tags"]] == ["AdminTag"] and s2["tags"][0]["is_foreign"] is True+ assert (s3["can_edit"], s3["tags"], s3["has_group_tags"]) == (False, [], True) # member only+ assert s4["can_edit"] is False # lead flags off+ assert s5["folder"]["is_foreign"] is True and s5["folder"]["recording_count"] == 2+ assert (s5["is_archived"], s5["is_inbox"]) == (True, True)+ assert (s6["is_inbox"], s6["is_highlighted"], s6["duplicate_info"]) == (True, False, None)+ assert s6["owner_username"].startswith(f"{_PREFIX}o2")+ assert all(r["can_delete"] == r["is_owner"] for r in rows.values())+