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;微信排序=员工分组(list_order NULL 按 owner asc)
    +组内 room_id 字符串升序(云客群统计同款,2026-09-10)。
    seed 无 wechat_account 行 → list_order 全 NULL → owner 字符串序:
    wa_owner_1 < wx_owner_1 < wx_owner_2 → [wa_room_x, room_a, room_b]。
    """
    client = await make_client(_seed)
    r = await client.get("/api/groups")
    assert r.status_code == 200
    body = r.json()
    assert body["total"] == 3
    assert [it["room_id"] for it in body["items"]] == [
        "wa_room_x@s.whatsapp.net",
        "room_a@chatroom",
        "room_b@chatroom",
    ]
    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


# ---------------------------------------------------------------------------
# 微信群统计扩展(2026-09-09):统计时段窗聚合 + 员工列 + 群备注/最新消息筛选
# ---------------------------------------------------------------------------

async def _seed_stat(session: AsyncSession) -> None:
    from app.db.models import ChatGroupMemberStats, MsgDailyStats, Staff, WechatAccount

    session.add_all([
        WechatAccount(wx_id="wx_owner_1", nick_name="玉", alias="Nancyjade",
                      user_id="u_wx_1", raw_json={"headImageUrl": "http://a/h.png"}),
        Staff(user_id="u_wx_1", name="聂玉婷", phone="18500000000"),
        ChatGroup(room_id="stat_room@chatroom", channel="wechat", room_name="统计群",
                  owner_account_id="wx_owner_1", owner_user_id="u_wx_1",
                  member_count=46, group_remark="VIP群", last_chat_time=5000),
        # 窗内两天日行(0907+0908):沟通 3+4=7 条
        MsgDailyStats(channel="wechat", owner_account_id="wx_owner_1", peer_kind="room",
                      peer_id="stat_room@chatroom", day=20260907, send_cnt=1, recv_cnt=2),
        MsgDailyStats(channel="wechat", owner_account_id="wx_owner_1", peer_kind="room",
                      peer_id="stat_room@chatroom", day=20260908, send_cnt=2, recv_cnt=2),
        # 窗外日行(0901)不应计入
        MsgDailyStats(channel="wechat", owner_account_id="wx_owner_1", peer_kind="room",
                      peer_id="stat_room@chatroom", day=20260901, send_cnt=99, recv_cnt=99),
        # 窗内进出:0907 +2/-1
        ChatGroupMemberStats(channel="wechat", owner_account_id="wx_owner_1",
                             room_id="stat_room@chatroom", day=20260907, added=2, lost=1),
    ])
    await session.commit()


async def test_group_window_aggregates_and_staff_columns(make_client):
    """msg_start/msg_end 窗内三聚合 + 员工微信/员工信息关联列。"""
    client = await make_client(_seed_stat)
    # 2026-09-07 ~ 2026-09-09(上海日 20260907..20260909,UTC ms)
    r = await client.get("/api/groups", params={
        "channel": "wechat", "room_id": "stat_room@chatroom",
        "msg_start": 1788758400000, "msg_end": 1789017600000,
    })
    assert r.status_code == 200
    it = r.json()["items"][0]
    assert it["window_msg_count"] == 7      # 窗内日行求和,0901 排除
    assert it["window_added"] == 2
    assert it["window_lost"] == 1
    assert it["group_remark"] == "VIP群"
    assert it["staff_nickname"] == "玉"
    assert it["staff_wx_alias"] == "Nancyjade"
    assert it["staff_avatar"] == "http://a/h.png"
    assert it["staff_name"] == "聂玉婷"
    assert it["staff_phone"] == "18500000000"

    # 无窗请求 → 聚合三列为 None(不误显 0)
    r2 = await client.get("/api/groups", params={
        "channel": "wechat", "room_id": "stat_room@chatroom"})
    it2 = r2.json()["items"][0]
    assert it2["window_msg_count"] is None
    assert it2["window_added"] is None


async def test_group_remark_and_last_window_filters(make_client):
    """群备注子串 + 最新消息时间段过滤。"""
    client = await make_client(_seed_stat)
    r = await client.get("/api/groups", params={
        "channel": "wechat", "group_remark": "VIP"})
    assert [i["room_id"] for i in r.json()["items"]] == ["stat_room@chatroom"]
    r2 = await client.get("/api/groups", params={
        "channel": "wechat", "group_remark": "不存在"})
    assert r2.json()["total"] == 0

    # last_chat_time=5000 → last_start=4000 命中,last_start=6000 排除
    r3 = await client.get("/api/groups", params={
        "channel": "wechat", "last_start": 4000, "last_end": 9999})
    assert "stat_room@chatroom" in [i["room_id"] for i in r3.json()["items"]]
    r4 = await client.get("/api/groups", params={
        "channel": "wechat", "last_start": 6000, "last_end": 9999})
    assert r4.json()["total"] == 0