Skip to content

Speakr is a personal, self-hosted web application designed for transcribing audio recordings

Python
24.1 KB
Raw Blame
"""Authorization tests for folder + group surfaces.

Covers the previously-untested authz boundaries in:
  - src/api/folders.py  (personal folders, group folders, recording-folder
                          assignment, bulk folder move)
  - src/api/groups.py   (sync-shares, admin group CRUD + members)

Focus is on negatives / IDOR: a user must not be able to read or mutate
another user's folders, move recordings they don't own, move their own
recordings into folders they have no access to, or reach admin-only group
endpoints. The bulk folder-move IDOR (#287 pattern) is exercised directly.

Folders are gated by an admin SystemSetting ('enable_folders'); these tests
flip it on (and one test verifies the gate when it is off).

Run:
  HOME=/tmp /tmp/speakr_testvenv/bin/python -m pytest \
      tests/test_folders_groups_authz.py -p no:cacheprovider -q
"""
import os
import sys
import uuid
from unittest.mock import patch

sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

import src.api.folders as folders_module
import src.api.groups as groups_module
from src.app import app, db
from src.models import (
    User,
    Recording,
    Folder,
    Group,
    GroupMembership,
    SystemSetting,
)

app.config["WTF_CSRF_ENABLED"] = False


# --------------------------------------------------------------------------
# Helpers
# --------------------------------------------------------------------------

def _setup_user(prefix, is_admin=False):
    suffix = uuid.uuid4().hex[:8]
    user = User(
        username=f"{prefix[:11]}_{suffix}",
        email=f"{prefix}_{suffix}@local.test",
        password="x",
        is_admin=is_admin,
    )
    db.session.add(user)
    db.session.commit()
    return user


def _login(client, user):
    with client.session_transaction() as sess:
        sess["_user_id"] = str(user.id)
        sess["_fresh"] = True
    # These tests wrap setup + multiple HTTP requests inside a single outer
    # app.app_context(). Flask-Login caches the resolved user on `g._login_user`
    # for the lifetime of that context, so a request made as user A leaves a
    # stale cached identity that shadows a later request made as user B. Clear
    # it so each request re-resolves current_user from its own session cookie.
    from flask import g
    for attr in ("_login_user", "_flask_login_user"):
        if hasattr(g, attr):
            try:
                delattr(g, attr)
            except (AttributeError, KeyError):
                pass


def _make_recording(user_id, title="r"):
    rec = Recording(
        user_id=user_id,
        title=title,
        audio_path="/tmp/x.mp3",
        status="COMPLETED",
    )
    db.session.add(rec)
    db.session.commit()
    return rec


def _make_folder(user_id, name=None, group_id=None):
    folder = Folder(
        name=name or f"f_{uuid.uuid4().hex[:8]}",
        user_id=user_id,
        group_id=group_id,
    )
    db.session.add(folder)
    db.session.commit()
    return folder


def _make_group(name=None):
    group = Group(name=name or f"g_{uuid.uuid4().hex[:8]}")
    db.session.add(group)
    db.session.commit()
    return group


def _enable_folders():
    SystemSetting.set_setting("enable_folders", "true", setting_type="boolean")


def _disable_folders():
    SystemSetting.set_setting("enable_folders", "false", setting_type="boolean")


def _cleanup(*objs):
    for obj in objs:
        if obj is None:
            continue
        try:
            existing = db.session.get(type(obj), obj.id)
            if existing is not None:
                db.session.delete(existing)
        except Exception:
            pass
    db.session.commit()


# ==========================================================================
# Personal folders: cross-user IDOR
# ==========================================================================

def test_list_folders_returns_only_own_personal_folders():
    with app.app_context():
        _enable_folders()
        alice = _setup_user("fld_a")
        bob = _setup_user("fld_b")
        alice_folder = _make_folder(alice.id, "alice-private")
        bob_folder = _make_folder(bob.id, "bob-private")

        client = app.test_client()
        _login(client, alice)
        resp = client.get("/api/folders")
        assert resp.status_code == 200
        names = {f["name"] for f in resp.get_json()}
        assert "alice-private" in names
        assert "bob-private" not in names, (
            "Folder listing leaked another user's personal folder"
        )

        _cleanup(alice_folder, bob_folder, alice, bob)


def test_user_cannot_update_other_users_folder():
    with app.app_context():
        _enable_folders()
        alice = _setup_user("fld_upd_a")
        bob = _setup_user("fld_upd_b")
        bob_folder = _make_folder(bob.id, "bob-secret")

        client = app.test_client()
        _login(client, alice)
        resp = client.put(
            f"/api/folders/{bob_folder.id}",
            json={"name": "hijacked"},
        )
        assert resp.status_code == 403, (
            f"Expected 403 editing another user's folder, got {resp.status_code}"
        )
        assert "permission" in resp.get_json()["error"].lower()
        # Ensure the folder was not actually renamed.
        db.session.expire_all()
        assert db.session.get(Folder, bob_folder.id).name == "bob-secret"

        _cleanup(bob_folder, alice, bob)


def test_user_cannot_delete_other_users_folder():
    with app.app_context():
        _enable_folders()
        alice = _setup_user("fld_del_a")
        bob = _setup_user("fld_del_b")
        bob_folder = _make_folder(bob.id, "bob-keep")

        client = app.test_client()
        _login(client, alice)
        resp = client.delete(f"/api/folders/{bob_folder.id}")
        assert resp.status_code == 403, (
            f"Expected 403 deleting another user's folder, got {resp.status_code}"
        )
        assert "permission" in resp.get_json()["error"].lower()
        assert db.session.get(Folder, bob_folder.id) is not None, (
            "Another user's folder was deleted (IDOR)"
        )

        _cleanup(bob_folder, alice, bob)


def test_update_nonexistent_folder_returns_404():
    with app.app_context():
        _enable_folders()
        alice = _setup_user("fld_404")
        client = app.test_client()
        _login(client, alice)
        resp = client.put("/api/folders/999999999", json={"name": "x"})
        assert resp.status_code == 404
        _cleanup(alice)


def test_create_personal_folder_succeeds_for_self():
    with app.app_context():
        _enable_folders()
        alice = _setup_user("fld_create")
        client = app.test_client()
        _login(client, alice)
        resp = client.post("/api/folders", json={"name": "my-folder"})
        assert resp.status_code == 201
        created = resp.get_json()
        assert created["name"] == "my-folder"
        folder = db.session.get(Folder, created["id"])
        assert folder is not None and folder.user_id == alice.id

        _cleanup(folder, alice)


# ==========================================================================
# Folders feature gate
# ==========================================================================

def test_folder_endpoints_refuse_when_feature_disabled():
    with app.app_context():
        _disable_folders()
        alice = _setup_user("fld_gate")
        folder = _make_folder(alice.id, "gated")
        client = app.test_client()
        _login(client, alice)

        # POST create is rejected with 403 (specifically the feature gate, not
        # an incidental CSRF/auth 403).
        resp = client.post("/api/folders", json={"name": "nope"})
        assert resp.status_code == 403
        assert "not enabled" in resp.get_json()["error"]

        # PUT update is rejected with 403.
        resp = client.put(f"/api/folders/{folder.id}", json={"name": "x"})
        assert resp.status_code == 403
        assert "not enabled" in resp.get_json()["error"]

        # DELETE is rejected with 403.
        resp = client.delete(f"/api/folders/{folder.id}")
        assert resp.status_code == 403
        assert "not enabled" in resp.get_json()["error"]

        # GET list returns an empty array (feature-off sentinel, not an error).
        resp = client.get("/api/folders")
        assert resp.status_code == 200
        assert resp.get_json() == []

        _cleanup(folder, alice)
        _enable_folders()


# ==========================================================================
# Move recording to folder: ownership + folder-access checks
# ==========================================================================

def test_cannot_move_recording_you_dont_own():
    with app.app_context():
        _enable_folders()
        alice = _setup_user("mv_own_a")
        bob = _setup_user("mv_own_b")
        bob_rec = _make_recording(bob.id, "bob rec")
        alice_folder = _make_folder(alice.id, "alice-target")

        client = app.test_client()
        _login(client, alice)
        resp = client.put(
            f"/api/recordings/{bob_rec.id}/folder",
            json={"folder_id": alice_folder.id},
        )
        assert resp.status_code == 403, (
            f"Expected 403 moving another user's recording, got {resp.status_code}"
        )
        db.session.expire_all()
        assert db.session.get(Recording, bob_rec.id).folder_id is None

        _cleanup(bob_rec, alice_folder, alice, bob)


def test_cannot_move_own_recording_into_other_users_folder():
    with app.app_context():
        _enable_folders()
        alice = _setup_user("mv_fld_a")
        bob = _setup_user("mv_fld_b")
        alice_rec = _make_recording(alice.id, "alice rec")
        bob_folder = _make_folder(bob.id, "bob-folder")

        client = app.test_client()
        _login(client, alice)
        resp = client.put(
            f"/api/recordings/{alice_rec.id}/folder",
            json={"folder_id": bob_folder.id},
        )
        assert resp.status_code == 403, (
            f"Expected 403 targeting another user's folder, got {resp.status_code}"
        )
        db.session.expire_all()
        assert db.session.get(Recording, alice_rec.id).folder_id is None, (
            "Recording was moved into a folder the user has no access to (IDOR)"
        )

        _cleanup(alice_rec, bob_folder, alice, bob)


def test_move_own_recording_into_own_folder_succeeds():
    with app.app_context():
        _enable_folders()
        alice = _setup_user("mv_ok")
        rec = _make_recording(alice.id, "rec")
        folder = _make_folder(alice.id, "target")

        client = app.test_client()
        _login(client, alice)
        resp = client.put(
            f"/api/recordings/{rec.id}/folder",
            json={"folder_id": folder.id},
        )
        assert resp.status_code == 200
        db.session.expire_all()
        assert db.session.get(Recording, rec.id).folder_id == folder.id

        _cleanup(rec, folder, alice)


# ==========================================================================
# Bulk folder move: the #287 IDOR surface
# ==========================================================================

def test_bulk_folder_move_only_affects_own_recordings():
    """Bulk move must silently skip recordings the caller can't edit, while
    still moving the caller's own. A victim's recording id slipped into the
    list must not be moved into the attacker's folder."""
    with app.app_context():
        _enable_folders()
        attacker = _setup_user("bulk_att")
        victim = _setup_user("bulk_vic")
        attacker_rec = _make_recording(attacker.id, "attacker rec")
        victim_rec = _make_recording(victim.id, "victim rec")
        attacker_folder = _make_folder(attacker.id, "attacker-folder")

        client = app.test_client()
        _login(client, attacker)
        resp = client.post(
            "/api/recordings/bulk/folder",
            json={
                "recording_ids": [attacker_rec.id, victim_rec.id],
                "folder_id": attacker_folder.id,
            },
        )
        assert resp.status_code == 200
        body = resp.get_json()
        # Only the attacker's own recording should have been updated.
        assert body["updated_count"] == 1, (
            f"Expected 1 updated, got {body['updated_count']} — victim record "
            "may have been moved (IDOR)"
        )
        db.session.expire_all()
        assert db.session.get(Recording, attacker_rec.id).folder_id == attacker_folder.id
        assert db.session.get(Recording, victim_rec.id).folder_id is None, (
            "Victim's recording was moved into the attacker's folder (IDOR)"
        )

        _cleanup(attacker_rec, victim_rec, attacker_folder, attacker, victim)


def test_bulk_folder_move_rejects_other_users_target_folder():
    """If the target folder belongs to another user, the whole bulk op is
    rejected with 403 before any recording is touched."""
    with app.app_context():
        _enable_folders()
        attacker = _setup_user("bulk_tgt_att")
        victim = _setup_user("bulk_tgt_vic")
        attacker_rec = _make_recording(attacker.id, "attacker rec")
        victim_folder = _make_folder(victim.id, "victim-folder")

        client = app.test_client()
        _login(client, attacker)
        resp = client.post(
            "/api/recordings/bulk/folder",
            json={
                "recording_ids": [attacker_rec.id],
                "folder_id": victim_folder.id,
            },
        )
        assert resp.status_code == 403, (
            f"Expected 403 targeting another user's folder, got {resp.status_code}"
        )
        db.session.expire_all()
        assert db.session.get(Recording, attacker_rec.id).folder_id is None

        _cleanup(attacker_rec, victim_folder, attacker, victim)


# ==========================================================================
# Group folders: membership / admin gating
# ==========================================================================

def test_non_admin_member_cannot_create_group_folder_via_api_folders():
    """POST /api/folders with a group_id requires the caller to be an *admin*
    of that group. A plain member is rejected with 403."""
    with app.app_context():
        _enable_folders()
        member = _setup_user("gf_member")
        group = _make_group("gf-group")
        db.session.add(GroupMembership(user_id=member.id, group_id=group.id, role="member"))
        db.session.commit()

        client = app.test_client()
        _login(client, member)
        resp = client.post(
            "/api/folders",
            json={"name": "team-folder", "group_id": group.id},
        )
        assert resp.status_code == 403, (
            f"Expected 403 for non-admin creating group folder, got {resp.status_code}"
        )

        _cleanup(
            GroupMembership.query.filter_by(group_id=group.id).first(),
            group, member,
        )


def test_outsider_cannot_create_group_folder():
    """A user who is not a member at all cannot create a group folder."""
    with app.app_context():
        _enable_folders()
        outsider = _setup_user("gf_outsider")
        group = _make_group("gf-group2")

        client = app.test_client()
        _login(client, outsider)
        resp = client.post(
            "/api/folders",
            json={"name": "team-folder", "group_id": group.id},
        )
        assert resp.status_code == 403

        _cleanup(group, outsider)


def test_group_admin_can_create_group_folder():
    with app.app_context():
        _enable_folders()
        admin = _setup_user("gf_admin")
        group = _make_group("gf-group3")
        db.session.add(GroupMembership(user_id=admin.id, group_id=group.id, role="admin"))
        db.session.commit()

        client = app.test_client()
        _login(client, admin)
        resp = client.post(
            "/api/folders",
            json={"name": "team-folder", "group_id": group.id},
        )
        assert resp.status_code == 201
        created = resp.get_json()
        folder = db.session.get(Folder, created["id"])
        assert folder is not None and folder.group_id == group.id

        _cleanup(
            folder,
            GroupMembership.query.filter_by(group_id=group.id).first(),
            group, admin,
        )


def test_get_group_folders_requires_membership():
    """GET /api/groups/<gid>/folders returns 403 for a non-member, 200 for a
    member."""
    with app.app_context():
        _enable_folders()
        member = _setup_user("ggf_member")
        outsider = _setup_user("ggf_outsider")
        group = _make_group("ggf-group")
        db.session.add(GroupMembership(user_id=member.id, group_id=group.id, role="member"))
        db.session.commit()
        group_folder = _make_folder(member.id, "team-shared", group_id=group.id)

        # Outsider: 403. (Use a dedicated client — reusing one client across
        # two logged-in identities does not reliably switch current_user.)
        outsider_client = app.test_client()
        _login(outsider_client, outsider)
        resp = outsider_client.get(f"/api/groups/{group.id}/folders")
        assert resp.status_code == 403, (
            f"Non-member reached group folders, got {resp.status_code}"
        )

        # Member: 200 and sees the folder.
        member_client = app.test_client()
        _login(member_client, member)
        resp = member_client.get(f"/api/groups/{group.id}/folders")
        assert resp.status_code == 200
        names = {f["name"] for f in resp.get_json()["folders"]}
        assert "team-shared" in names

        _cleanup(
            group_folder,
            GroupMembership.query.filter_by(group_id=group.id).first(),
            group, member, outsider,
        )


def test_create_group_folder_route_requires_admin_membership():
    """POST /api/groups/<gid>/folders (the dedicated route, gated by
    ENABLE_INTERNAL_SHARING) rejects non-admins with 403."""
    with app.app_context():
        _enable_folders()
        member = _setup_user("cgf_member")
        group = _make_group("cgf-group")
        db.session.add(GroupMembership(user_id=member.id, group_id=group.id, role="member"))
        db.session.commit()

        client = app.test_client()
        _login(client, member)
        with patch.object(folders_module, "ENABLE_INTERNAL_SHARING", True):
            resp = client.post(
                f"/api/groups/{group.id}/folders",
                json={"name": "team-folder"},
            )
        assert resp.status_code == 403

        _cleanup(
            GroupMembership.query.filter_by(group_id=group.id).first(),
            group, member,
        )


# ==========================================================================
# groups.py: sync-shares authz
# ==========================================================================

def test_sync_shares_requires_group_admin():
    """POST /api/groups/<gid>/sync-shares: a plain member gets 403."""
    with app.app_context():
        member = _setup_user("ss_member")
        group = _make_group("ss-group")
        db.session.add(GroupMembership(user_id=member.id, group_id=group.id, role="member"))
        db.session.commit()

        client = app.test_client()
        _login(client, member)
        with patch.object(groups_module, "ENABLE_INTERNAL_SHARING", True):
            resp = client.post(f"/api/groups/{group.id}/sync-shares")
        assert resp.status_code == 403, (
            f"Non-admin reached sync-shares, got {resp.status_code}"
        )

        _cleanup(
            GroupMembership.query.filter_by(group_id=group.id).first(),
            group, member,
        )


def test_sync_shares_outsider_gets_403():
    with app.app_context():
        outsider = _setup_user("ss_outsider")
        group = _make_group("ss-group2")

        client = app.test_client()
        _login(client, outsider)
        with patch.object(groups_module, "ENABLE_INTERNAL_SHARING", True):
            resp = client.post(f"/api/groups/{group.id}/sync-shares")
        assert resp.status_code == 403

        _cleanup(group, outsider)


# ==========================================================================
# Admin group endpoints: site-admin gating
# ==========================================================================

def test_create_group_requires_site_admin():
    """POST /api/admin/groups: a normal authenticated user gets 403."""
    with app.app_context():
        normal = _setup_user("ag_normal")
        client = app.test_client()
        _login(client, normal)
        with patch.object(groups_module, "ENABLE_INTERNAL_SHARING", True):
            resp = client.post("/api/admin/groups", json={"name": "x"})
        assert resp.status_code == 403, (
            f"Non-admin reached admin group creation, got {resp.status_code}"
        )
        _cleanup(normal)


def test_create_group_succeeds_for_site_admin():
    with app.app_context():
        admin = _setup_user("ag_admin", is_admin=True)
        client = app.test_client()
        _login(client, admin)
        name = f"admin-group-{uuid.uuid4().hex[:6]}"
        with patch.object(groups_module, "ENABLE_INTERNAL_SHARING", True):
            resp = client.post("/api/admin/groups", json={"name": name})
        assert resp.status_code == 201
        group = Group.query.filter_by(name=name).first()
        assert group is not None

        _cleanup(group, admin)


def test_delete_group_requires_site_admin():
    """DELETE /api/admin/groups/<gid> is site-admin only. Even a *group*
    admin (but not site admin) must be rejected with 403."""
    with app.app_context():
        group_admin = _setup_user("dg_groupadmin")
        group = _make_group("dg-group")
        db.session.add(GroupMembership(user_id=group_admin.id, group_id=group.id, role="admin"))
        db.session.commit()

        client = app.test_client()
        _login(client, group_admin)
        resp = client.delete(f"/api/admin/groups/{group.id}")
        assert resp.status_code == 403, (
            f"Group admin (non-site-admin) deleted a group, got {resp.status_code}"
        )
        assert db.session.get(Group, group.id) is not None

        _cleanup(
            GroupMembership.query.filter_by(group_id=group.id).first(),
            group, group_admin,
        )


def test_add_member_requires_admin():
    """POST /api/admin/groups/<gid>/members: a normal non-member user gets
    403 (not site admin, not group admin)."""
    with app.app_context():
        normal = _setup_user("am_normal")
        target = _setup_user("am_target")
        group = _make_group("am-group")

        client = app.test_client()
        _login(client, normal)
        with patch.object(groups_module, "ENABLE_INTERNAL_SHARING", True):
            resp = client.post(
                f"/api/admin/groups/{group.id}/members",
                json={"user_id": target.id, "role": "member"},
            )
        assert resp.status_code == 403
        assert GroupMembership.query.filter_by(group_id=group.id).first() is None

        _cleanup(group, normal, target)


def test_group_admin_can_add_member():
    """A group admin (not site admin) CAN add members to their own group."""
    with app.app_context():
        group_admin = _setup_user("gam_admin")
        target = _setup_user("gam_target")
        group = _make_group("gam-group")
        db.session.add(GroupMembership(user_id=group_admin.id, group_id=group.id, role="admin"))
        db.session.commit()

        client = app.test_client()
        _login(client, group_admin)
        with patch.object(groups_module, "ENABLE_INTERNAL_SHARING", True):
            resp = client.post(
                f"/api/admin/groups/{group.id}/members",
                json={"user_id": target.id, "role": "member"},
            )
        assert resp.status_code == 201
        assert GroupMembership.query.filter_by(
            group_id=group.id, user_id=target.id
        ).first() is not None

        _cleanup(
            GroupMembership.query.filter_by(group_id=group.id, user_id=target.id).first(),
            GroupMembership.query.filter_by(group_id=group.id, user_id=group_admin.id).first(),
            group, group_admin, target,
        )


def test_get_teams_requires_admin_or_group_admin():
    """GET /api/admin/groups: a plain user with no admin role gets 403."""
    with app.app_context():
        normal = _setup_user("gt_normal")
        client = app.test_client()
        _login(client, normal)
        resp = client.get("/api/admin/groups")
        assert resp.status_code == 403
        _cleanup(normal)