yunke/yunke-server/tests/test_api_groups.py

"""Tests for GET /api/groups and /api/groups/{room_id}/members.

Seeds 2 groups (one wechat, one whatsapp) with one member each on the wechat
group, plus a second wechat group owned by another account, then asserts list
filters + member-list shape + 404 for unknown room.
"""

from __future__ import annotations

from sqlalchemy.ext.asyncio import AsyncSession

from app.db.models import ChatGroup, GroupMember


async def _seed(session: AsyncSession) -> None:
    session.add_all(
        [
            ChatGroup(
                room_id="room_a@chatroom",
                channel="wechat",
                room_name="Team A",
                owner_account_id="wx_owner_1",
                owner_account_nickname="WxOne",
                owner_user_id="u_wx_1",
                member_count=2,
                message_count=10,
                last_chat_time=2000,
            ),
            ChatGroup(
                room_id="room_b@chatroom",
                channel="wechat",
                room_name="Team B",
                owner_account_id="wx_owner_2",
                owner_user_id="u_wx_2",
                member_count=1,
                last_chat_time=1000,
            ),
            ChatGroup(
                room_id="wa_room_x@s.whatsapp.net",
                channel="whatsapp",
                room_name="WA Team",
                owner_account_id="wa_owner_1",
                owner_user_id="u_wa_1",
                member_count=3,
                last_chat_time=None,
            ),
            GroupMember(
                channel="wechat",
                room_id="room_a@chatroom",
                member_id="mem1",
                nickname="Alice",
                display_name="Alice",
            ),
            GroupMember(
                channel="wechat",
                room_id="room_a@chatroom",
                member_id="mem2",
                nickname="Bob",
                display_name="Bob",
            ),
        ]
    )
    await session.commit()


async def test_default_list_returns_all_ordered_desc(make_client):
    """No filters -> 3 groups, ordered by ``last_chat_time desc`` (nulls last)."""
    client = await make_client(_seed)
    r = await client.get("/api/groups")
    assert r.status_code == 200
    body = r.json()
    assert body["total"] == 3
    # 2000, 1000, null -> [room_a, room_b, wa_room_x]
    assert [it["room_id"] for it in body["items"]] == [
        "room_a@chatroom",
        "room_b@chatroom",
        "wa_room_x@s.whatsapp.net",
    ]
    for key in (
        "room_id",
        "channel",
        "room_name",
        "owner_account_id",
        "owner_account_nickname",
        "member_count",
        "message_count",
        "last_chat_time",
        "raw_json",
    ):
        assert key in body["items"][0]


async def test_raw_json_serializes_verbatim(make_client):
    """``raw_json`` round-trips the verbatim upstream chatroom record.

    Seeded blobs must come back unmolested (every camelCase key preserved) so
    the all-fields drawer can render every column the 云客 群管理 page shows.
    Rows without a blob serialize as JSON null.
    """

    async def seed(session: AsyncSession) -> None:
        await _seed(session)
        session.add(
            ChatGroup(
                room_id="room_raw@chatroom",
                channel="wechat",
                room_name="Raw Team",
                owner_account_id="wx_owner_1",
                member_count=4,
                last_chat_time=9000,
                raw_json={
                    "chatRoomId": "room_raw@chatroom",
                    "chatRoomName": "Raw Team",
                    "memberCount": 4,
                    "memberIds": "wx_a;wx_b;wx_c;wx_d",
                    "headImageUrl": "https://oss/raw.jpg",
                    "wechatId": "wx_owner_1",
                    "wechatNickName": "WxOne",
                    "userName": "owner_login",
                    "userPhone": "13800000000",
                    "userId": "u_owner",
                    "messageCount": 42,
                    "ownMessageCount": 7,
                    "lossMembers": 1,
                    "addMembers": 2,
                    "lastChatTime": 9000,
                    "updateTime": 9999,
                },
            )
        )
        await session.commit()

    client = await make_client(seed)
    r = await client.get("/api/groups", params={"owner_account_id": "wx_owner_1"})
    assert r.status_code == 200
    by_id = {it["room_id"]: it for it in r.json()["items"]}

    raw = by_id["room_raw@chatroom"]["raw_json"]
    assert raw == {
        "chatRoomId": "room_raw@chatroom",
        "chatRoomName": "Raw Team",
        "memberCount": 4,
        "memberIds": "wx_a;wx_b;wx_c;wx_d",
        "headImageUrl": "https://oss/raw.jpg",
        "wechatId": "wx_owner_1",
        "wechatNickName": "WxOne",
        "userName": "owner_login",
        "userPhone": "13800000000",
        "userId": "u_owner",
        "messageCount": 42,
        "ownMessageCount": 7,
        "lossMembers": 1,
        "addMembers": 2,
        "lastChatTime": 9000,
        "updateTime": 9999,
    }

    # Seeded without an explicit raw_json -> JSON null (not omitted, not error).
    assert by_id["room_a@chatroom"]["raw_json"] is None


async def test_filter_by_channel_whatsapp(make_client):
    """``?channel=whatsapp`` -> the single WA group."""
    client = await make_client(_seed)
    r = await client.get("/api/groups", params={"channel": "whatsapp"})
    assert r.status_code == 200
    body = r.json()
    assert body["total"] == 1
    assert body["items"][0]["room_id"] == "wa_room_x@s.whatsapp.net"


async def test_filter_by_owner_account_id(make_client):
    """``?owner_account_id=wx_owner_1`` -> only Team A."""
    client = await make_client(_seed)
    r = await client.get("/api/groups", params={"owner_account_id": "wx_owner_1"})
    assert r.status_code == 200
    body = r.json()
    assert body["total"] == 1
    assert body["items"][0]["room_id"] == "room_a@chatroom"


async def test_filter_by_user_id(make_client):
    """``?user_id=u_wx_1`` -> only Team A (param maps to owner_user_id column)."""
    client = await make_client(_seed)
    r = await client.get("/api/groups", params={"user_id": "u_wx_1"})
    assert r.status_code == 200
    body = r.json()
    assert body["total"] == 1
    assert body["items"][0]["room_id"] == "room_a@chatroom"
    # Sanity: a different user_id matches a different single group.
    r2 = await client.get("/api/groups", params={"user_id": "u_wa_1"})
    assert r2.status_code == 200
    body2 = r2.json()
    assert body2["total"] == 1
    assert body2["items"][0]["room_id"] == "wa_room_x@s.whatsapp.net"
    # Sanity: an unknown user_id matches nothing.
    r3 = await client.get("/api/groups", params={"user_id": "nobody"})
    assert r3.status_code == 200
    assert r3.json()["total"] == 0


async def test_pagination(make_client):
    """``page_size=1`` -> 1 item, total 3."""
    client = await make_client(_seed)
    r = await client.get("/api/groups", params={"page": 1, "page_size": 1})
    assert r.status_code == 200
    body = r.json()
    assert body["total"] == 3
    assert len(body["items"]) == 1


async def test_members_returns_list(make_client):
    """``/api/groups/room_a@chatroom/members`` -> 2 members (plain list)."""
    client = await make_client(_seed)
    r = await client.get("/api/groups/room_a@chatroom/members")
    assert r.status_code == 200
    items = r.json()
    assert isinstance(items, list)
    assert len(items) == 2
    assert {it["member_id"] for it in items} == {"mem1", "mem2"}
    for key in ("channel", "room_id", "member_id", "nickname", "display_name", "avatar"):
        assert key in items[0]


async def test_members_unknown_room_404(make_client):
    """Unknown room_id -> 404 (distinguishes missing vs empty)."""
    client = await make_client(_seed)
    r = await client.get("/api/groups/nope@chatroom/members")
    assert r.status_code == 404


async def test_members_empty_room_is_200(make_client):
    """Known room with no seeded members -> 200 + empty list (not 404)."""
    client = await make_client(_seed)
    r = await client.get("/api/groups/room_b@chatroom/members")
    assert r.status_code == 200
    assert r.json() == []


# ---------------------------------------------------------------------------
# room_id 精确过滤（2026-08-20：群聊页群名单行直查,替代超上限的大页拉取）
# ---------------------------------------------------------------------------

async def test_room_id_filter_returns_matching_groups(make_client):
    async def seed(session):
        session.add_all([
            ChatGroup(room_id="r1@chatroom", channel="wechat", room_name="群一", owner_account_id="o1"),
            ChatGroup(room_id="r2@chatroom", channel="wechat", room_name="群二", owner_account_id="o1"),
        ])
        await session.commit()

    client = await make_client(seed)
    r = await client.get("/api/groups", params={"room_id": "r2@chatroom"})
    assert r.status_code == 200
    body = r.json()
    assert body["total"] == 1
    assert body["items"][0]["room_name"] == "群二"


async def test_room_id_filter_multi_owner_one_row_per_owner(make_client):
    """同 room_id 多群主(复合 PK 允许)→ room_id 精确过滤返回每个群主一行。"""
    async def seed(session):
        session.add_all([
            ChatGroup(room_id="shared@chatroom", channel="wechat", room_name="共享群",
                      owner_account_id="owner_1", owner_user_id="u1"),
            ChatGroup(room_id="shared@chatroom", channel="wechat", room_name="共享群",
                      owner_account_id="owner_2", owner_user_id="u2"),
        ])
        await session.commit()

    client = await make_client(seed)
    r = await client.get("/api/groups", params={"room_id": "shared@chatroom"})
    assert r.status_code == 200
    body = r.json()
    assert body["total"] == 2
    assert {it["owner_account_id"] for it in body["items"]} == {"owner_1", "owner_2"}


# ---------------------------------------------------------------------------
# 群主/建群补充列（2026-08-25 对齐云客员工聊天窗口·微信群 tab）
# raw_json 键 ownerName/ownerWchatId/ownerAlias/ownerImage/friendCount/createTime
# 由 scraper(_normalize_chat_group) 与 scripts/backfill_chat_group_fields.py
# 提取进同名列;API 直接输出列值。
# ---------------------------------------------------------------------------

async def test_groups_owner_fields(make_client):
    async def seed(session):
        session.add(ChatGroup(room_id="123@chatroom", channel="wechat", room_name="测试群",
            owner_account_id="wxid_x", member_count=10,
            owner_name="Q**e", owner_wxid="RL3*****108", owner_alias="Fr******er",
            owner_avatar="https://wx.qlogo.cn/o/0", friend_count=22,
            create_time=1740000000000,
            raw_json={"ownerName": "Q**e", "ownerWchatId": "RL3*****108", "ownerAlias": "Fr******er",
                      "ownerImage": "https://wx.qlogo.cn/o/0", "friendCount": 22,
                      "createTime": 1740000000000}))
        await session.commit()

    client = await make_client(seed)
    r = await client.get("/api/groups", params={"room_id": "123@chatroom"})
    assert r.status_code == 200
    item = r.json()["items"][0]
    assert item["owner_name"] == "Q**e"
    assert item["owner_wxid"] == "RL3*****108"
    assert item["owner_alias"] == "Fr******er"
    assert item["owner_avatar"] == "https://wx.qlogo.cn/o/0"
    assert item["friend_count"] == 22
    assert item["create_time"] == 1740000000000


async def test_groups_owner_fields_default_null(make_client):
    """未回填/上游缺失的行走 schema 默认值 null(不报错、不缺 key)。"""

    async def seed(session):
        session.add(ChatGroup(room_id="old@chatroom", channel="wechat",
                              owner_account_id="wxid_y"))
        await session.commit()

    client = await make_client(seed)
    r = await client.get("/api/groups", params={"room_id": "old@chatroom"})
    assert r.status_code == 200
    item = r.json()["items"][0]
    for key in ("owner_name", "owner_wxid", "owner_alias",
                "owner_avatar", "friend_count", "create_time"):
        assert item[key] is None


# ---------------------------------------------------------------------------
# GET /api/groups?q= — 群名称模糊搜索(通讯录群 tab 搜索框,LIKE 通配转义)
# ---------------------------------------------------------------------------

async def test_q_room_name_substring_filter(make_client):
    """``?q=Team A`` -> 群名子串匹配(LIKE 默认大小写敏感);q 空串不过滤。"""
    client = await make_client(_seed)
    r = await client.get("/api/groups", params={"q": "Team A"})
    assert r.status_code == 200
    body = r.json()
    assert body["total"] == 1
    assert body["items"][0]["room_id"] == "room_a@chatroom"
    # 子串跨行命中: "Team" 同时出现在 Team A / Team B / WA Team
    r2 = await client.get("/api/groups", params={"q": "Team"})
    assert {it["room_id"] for it in r2.json()["items"]} == {
        "room_a@chatroom", "room_b@chatroom", "wa_room_x@s.whatsapp.net",
    }
    # 空串 -> 不过滤
    r3 = await client.get("/api/groups", params={"q": ""})
    assert r3.json()["total"] == 3