wecom_it_smart_desk/backend/tests/test_org_tree.py

# =============================================================================
# 组织架构树构建与过滤 — 单元测试
# =============================================================================
# 测试覆盖：
#   1. build_org_tree() — 层级树构建（dept_ 前缀、parentid 根判定、多部门员工、空部门、孤儿部门、嵌套层级）
#   2. _build_flat_tree_by_name() — 降级扁平分组
#   3. filter_user_from_tree() — 递归过滤用户 + 空部门移除
#   4. count_tree_employees() — 递归统计员工数
#   5. get_org_tree_cached() — 缓存 key 区分端点 + 用户排除（mock 依赖）
#
# 设计原则：
#   - build_org_tree / filter_user_from_tree / count_tree_employees / _build_flat_tree_by_name
#     是纯函数，无外部依赖，直接测试输入输出
#   - get_org_tree_cached 是 async 函数，mock get_org_directory 和 get_cached_dept_list
# =============================================================================

import json
from unittest.mock import AsyncMock, patch

import pytest

from app.services.employee_directory import (
    ORG_TREE_CACHE_KEY_PREFIX,
    build_org_tree,
    count_tree_employees,
    filter_user_from_tree,
    get_org_tree_cached,
    _build_flat_tree_by_name,
)


# =============================================================================
# 辅助：构造测试数据
# =============================================================================

def _emp(employee_id: str, name: str, department: str = "", dept_ids=None):
    """构造员工目录条目。"""
    return {
        "employee_id": employee_id,
        "name": name,
        "department": department,
        "dept_ids": dept_ids or [],
    }


def _dept(dept_id: int, name: str, parentid: int = 0):
    """构造部门列表条目。"""
    return {"id": dept_id, "name": name, "parentid": parentid}


# =============================================================================
# 一、build_org_tree() 测试
# =============================================================================

class TestBuildOrgTree:
    """build_org_tree 纯函数测试。"""

    # ----- 1.1 dept_ 前缀与员工 UserID 不冲突 -----

    def test_dept_prefix_no_collision_with_employee_id(self):
        """部门节点 id 加 dept_ 前缀，员工节点 id 用 UserID，两者不冲突。"""
        directory = [_emp("zhangsan", "张三", "研发部", [2])]
        dept_list = [_dept(1, "公司", 0), _dept(2, "研发部", 1)]

        tree = build_org_tree(directory, dept_list)

        # 收集所有节点 id
        all_ids = set()

        def collect_ids(nodes):
            for n in nodes:
                all_ids.add(n["id"])
                if "children" in n:
                    collect_ids(n["children"])

        collect_ids(tree)
        # 部门 id 有 dept_ 前缀，员工 id 无前缀
        assert "dept_1" in all_ids
        assert "dept_2" in all_ids
        assert "zhangsan" in all_ids
        # 不存在 "dept_zhangsan" 之类的冲突
        assert "dept_zhangsan" not in all_ids

    def test_dept_prefix_with_numeric_employee_id(self):
        """员工 UserID 为纯数字时，dept_ 前缀仍能区分。"""
        directory = [_emp("1001", "员工1001", "研发部", [2])]
        dept_list = [_dept(1, "公司", 0), _dept(2, "研发部", 1), _dept(1001, "数字部门", 1)]

        tree = build_org_tree(directory, dept_list)

        all_ids = set()

        def collect_ids(nodes):
            for n in nodes:
                all_ids.add(n["id"])
                if "children" in n:
                    collect_ids(n["children"])

        collect_ids(tree)
        # 部门 1001 的 id 是 "dept_1001"，员工 1001 的 id 是 "1001"
        assert "dept_1001" in all_ids
        assert "1001" in all_ids

    # ----- 1.2 parentid=0 根部门判定 -----

    def test_parentid_0_as_root(self):
        """parentid=0 的部门作为根节点。"""
        directory = [_emp("u1", "用户1", "研发", [2])]
        dept_list = [
            _dept(1, "公司", 0),
            _dept(2, "研发部", 1),
        ]

        tree = build_org_tree(directory, dept_list)

        # 只有一个根节点（公司）
        assert len(tree) == 1
        assert tree[0]["id"] == "dept_1"
        assert tree[0]["label"] == "公司"
        # 研发部是公司的子部门
        assert len(tree[0]["children"]) == 1
        assert tree[0]["children"][0]["id"] == "dept_2"

    def test_multiple_root_departments(self):
        """多个 parentid=0 的部门都作为根节点。"""
        directory = []
        dept_list = [
            _dept(1, "公司A", 0),
            _dept(2, "公司B", 0),
        ]

        tree = build_org_tree(directory, dept_list)

        assert len(tree) == 2
        root_ids = {n["id"] for n in tree}
        assert root_ids == {"dept_1", "dept_2"}

    def test_parentid_1_fallback_when_no_parentid_0(self):
        """没有 parentid=0 时，parentid=1 的部门作为根（企微 dept 1 缺失场景）。"""
        directory = [_emp("u1", "用户1", "研发", [2])]
        # dept 1 不在列表中，dept 2 的 parentid=1
        dept_list = [_dept(2, "研发部", 1)]

        tree = build_org_tree(directory, dept_list)

        assert len(tree) == 1
        assert tree[0]["id"] == "dept_2"

    # ----- 1.3 多部门员工 -----

    def test_multi_dept_employee_appears_in_all_depts(self):
        """员工属于多个部门时，在每个部门下都出现。"""
        directory = [_emp("zhangsan", "张三", "研发,测试", [2, 3])]
        dept_list = [
            _dept(1, "公司", 0),
            _dept(2, "研发部", 1),
            _dept(3, "测试部", 1),
        ]

        tree = build_org_tree(directory, dept_list)

        # 根节点是公司
        assert len(tree) == 1
        company = tree[0]
        # 公司下有研发部和测试部
        dept_nodes = {n["id"]: n for n in company["children"] if not n.get("isLeaf")}
        assert "dept_2" in dept_nodes
        assert "dept_3" in dept_nodes

        # 研发部下有张三
        dev_emps = [n for n in dept_nodes["dept_2"]["children"] if n.get("isLeaf")]
        assert len(dev_emps) == 1
        assert dev_emps[0]["id"] == "zhangsan"

        # 测试部下也有张三
        test_emps = [n for n in dept_nodes["dept_3"]["children"] if n.get("isLeaf")]
        assert len(test_emps) == 1
        assert test_emps[0]["id"] == "zhangsan"

    # ----- 1.4 空部门（有部门节点但没有员工） -----

    def test_empty_dept_still_appears(self):
        """有部门节点但没有员工的空部门仍出现在树中。"""
        directory = [_emp("u1", "用户1", "研发", [2])]
        dept_list = [
            _dept(1, "公司", 0),
            _dept(2, "研发部", 1),
            _dept(3, "空部门", 1),  # 没有员工
        ]

        tree = build_org_tree(directory, dept_list)

        company = tree[0]
        dept_ids = {n["id"] for n in company["children"] if not n.get("isLeaf")}
        # 空部门仍然出现
        assert "dept_3" in dept_ids

    def test_empty_dept_has_empty_children(self):
        """空部门的 children 为空列表。"""
        directory = []
        dept_list = [_dept(1, "公司", 0), _dept(2, "空部门", 1)]

        tree = build_org_tree(directory, dept_list)

        company = tree[0]
        empty_dept = next(n for n in company["children"] if n["id"] == "dept_2")
        assert empty_dept["children"] == []

    # ----- 1.5 未分配部门员工 -----

    def test_unassigned_employees_grouped(self):
        """没有 dept_ids 的员工归到"未分配部门"。"""
        directory = [
            _emp("u1", "用户1", "", []),
            _emp("u2", "用户2", "某部门", []),
        ]
        dept_list = [_dept(1, "公司", 0)]

        tree = build_org_tree(directory, dept_list)

        # 应该有公司 + 未分配部门
        top_ids = {n["id"] for n in tree}
        assert "dept_1" in top_ids
        assert "dept_unassigned" in top_ids

        unassigned = next(n for n in tree if n["id"] == "dept_unassigned")
        assert unassigned["label"] == "未分配部门"
        assert len(unassigned["children"]) == 2

    # ----- 1.6 孤儿部门（parentid 不在 dept_map 中） -----

    def test_orphan_dept_as_root(self):
        """parentid 指向不存在的部门时，该部门作为根节点。"""
        directory = [_emp("u1", "用户1", "孤儿", [99])]
        dept_list = [
            _dept(1, "公司", 0),
            _dept(99, "孤儿部门", 88),  # parentid=88 不在 dept_map
        ]

        tree = build_org_tree(directory, dept_list)

        top_ids = {n["id"] for n in tree}
        assert "dept_1" in top_ids
        assert "dept_99" in top_ids  # 孤儿部门作为根

    # ----- 1.7 多层嵌套 -----

    def test_nested_hierarchy_3_levels(self):
        """3 层嵌套：公司 → 研发部 → 前端组 → 员工。"""
        directory = [_emp("u1", "前端工程师", "前端组", [3])]
        dept_list = [
            _dept(1, "公司", 0),
            _dept(2, "研发部", 1),
            _dept(3, "前端组", 2),
        ]

        tree = build_org_tree(directory, dept_list)

        assert len(tree) == 1
        company = tree[0]
        assert company["id"] == "dept_1"
        assert len(company["children"]) == 1

        dev = company["children"][0]
        assert dev["id"] == "dept_2"
        assert len(dev["children"]) == 1

        fe = dev["children"][0]
        assert fe["id"] == "dept_3"
        assert len(fe["children"]) == 1

        emp = fe["children"][0]
        assert emp["id"] == "u1"
        assert emp["isLeaf"] is True

    def test_deep_nested_hierarchy_10_levels(self):
        """10 层嵌套不栈溢出。"""
        directory = [_emp("u1", "深层员工", "深层", [10])]
        dept_list = [_dept(i, f"部门{i}", i - 1) for i in range(1, 11)]
        dept_list[0] = _dept(1, "部门1", 0)  # 根

        tree = build_org_tree(directory, dept_list)

        # 递归到最深层
        node = tree[0]
        for i in range(1, 10):
            assert node["id"] == f"dept_{i}"
            dept_children = [c for c in node["children"] if not c.get("isLeaf")]
            assert len(dept_children) == 1
            node = dept_children[0]
        # 第 10 层有员工
        assert node["id"] == "dept_10"
        emps = [c for c in node["children"] if c.get("isLeaf")]
        assert len(emps) == 1

    # ----- 1.8 空输入 -----

    def test_empty_directory_and_empty_dept_list(self):
        """空 directory + 空 dept_list → 空树。"""
        tree = build_org_tree([], [])
        assert tree == []

    def test_empty_directory_with_dept_list(self):
        """空 directory + 有 dept_list → 只有部门节点无员工。"""
        dept_list = [_dept(1, "公司", 0)]
        tree = build_org_tree([], dept_list)
        assert len(tree) == 1
        assert tree[0]["id"] == "dept_1"
        assert tree[0]["children"] == []

    def test_directory_with_empty_dept_list_falls_back_to_flat(self):
        """有 directory + 空 dept_list → 降级到 _build_flat_tree_by_name。"""
        directory = [_emp("u1", "用户1", "研发部")]
        tree = build_org_tree(directory, [])
        # 降级路径使用 dept_name_ 前缀
        assert len(tree) == 1
        assert tree[0]["id"] == "dept_name_研发部"

    # ----- 1.9 部门节点结构验证 -----

    def test_dept_node_structure(self):
        """部门节点包含 id, label, dept_id, parentid, children 字段。"""
        directory = [_emp("u1", "用户1", "研发", [2])]
        dept_list = [_dept(1, "公司", 0), _dept(2, "研发部", 1)]

        tree = build_org_tree(directory, dept_list)

        company = tree[0]
        assert company["id"] == "dept_1"
        assert company["label"] == "公司"
        assert company["dept_id"] == 1
        assert company["parentid"] == 0
        assert "children" in company

    def test_employee_node_structure(self):
        """员工节点包含 id, label, isLeaf, department 字段。"""
        directory = [_emp("u1", "用户1", "研发", [2])]
        dept_list = [_dept(1, "公司", 0), _dept(2, "研发部", 1)]

        tree = build_org_tree(directory, dept_list)

        company = tree[0]
        dev = company["children"][0]
        emp = dev["children"][0]
        assert emp["id"] == "u1"
        assert emp["label"] == "用户1"
        assert emp["isLeaf"] is True
        assert emp["department"] == "研发"

    # ----- 1.10 排序验证 -----

    def test_departments_sorted_by_name(self):
        """子部门按名称排序（Python 默认 Unicode 码点序）。"""
        directory = []
        dept_list = [
            _dept(1, "公司", 0),
            _dept(4, "_Z部门", 1),
            _dept(2, "A部门", 1),
            _dept(3, "B部门", 1),
        ]

        tree = build_org_tree(directory, dept_list)

        company = tree[0]
        dept_names = [n["label"] for n in company["children"] if not n.get("isLeaf")]
        # Python 按 Unicode 码点排序：A(0x41) < B(0x42) < _(0x5F)
        assert dept_names == ["A部门", "B部门", "_Z部门"]

    def test_employees_sorted_by_name(self):
        """同一部门下员工按姓名排序（Python 默认 Unicode 码点序）。"""
        directory = [
            _emp("u3", "张三", "研发", [2]),
            _emp("u1", "阿大", "研发", [2]),
            _emp("u2", "李四", "研发", [2]),
        ]
        dept_list = [_dept(1, "公司", 0), _dept(2, "研发部", 1)]

        tree = build_org_tree(directory, dept_list)

        company = tree[0]
        dev = company["children"][0]
        emp_names = [n["label"] for n in dev["children"] if n.get("isLeaf")]
        # Python 按 Unicode 码点排序：张(U+5F20) < 李(U+674E) < 阿(U+963F)
        assert emp_names == ["张三", "李四", "阿大"]


# =============================================================================
# 二、_build_flat_tree_by_name() 测试
# =============================================================================

class TestBuildFlatTreeByName:
    """_build_flat_tree_by_name 降级扁平分组测试。"""

    def test_basic_grouping(self):
        """按部门名分组（Python 默认 Unicode 码点序排序）。"""
        directory = [
            _emp("u1", "张三", "研发部"),
            _emp("u2", "李四", "研发部"),
            _emp("u3", "王五", "测试部"),
        ]
        tree = _build_flat_tree_by_name(directory)

        assert len(tree) == 2
        # Python 按 Unicode 码点排序：测(U+6D4B) < 研(U+7814)
        assert tree[0]["label"] == "测试部"
        assert tree[1]["label"] == "研发部"
        assert len(tree[0]["children"]) == 1
        assert len(tree[1]["children"]) == 2

    def test_multi_dept_takes_first(self):
        """多部门员工取第一个部门名。"""
        directory = [_emp("u1", "张三", "研发部,测试部")]
        tree = _build_flat_tree_by_name(directory)

        assert len(tree) == 1
        assert tree[0]["label"] == "研发部"

    def test_empty_dept_name_goes_to_unassigned(self):
        """空部门名归到"未分配部门"。"""
        directory = [
            _emp("u1", "张三", ""),
            _emp("u2", "李四", None),
        ]
        tree = _build_flat_tree_by_name(directory)

        assert len(tree) == 1
        assert tree[0]["label"] == "未分配部门"
        assert len(tree[0]["children"]) == 2

    def test_comma_only_dept_name_goes_to_unassigned(self):
        """部门名只有逗号时归到"未分配部门"。"""
        directory = [_emp("u1", "张三", ",,")]
        tree = _build_flat_tree_by_name(directory)

        assert len(tree) == 1
        assert tree[0]["label"] == "未分配部门"

    def test_empty_directory(self):
        """空 directory → 空树。"""
        tree = _build_flat_tree_by_name([])
        assert tree == []

    def test_flat_tree_node_structure(self):
        """扁平树节点结构正确。"""
        directory = [_emp("u1", "张三", "研发部")]
        tree = _build_flat_tree_by_name(directory)

        dept_node = tree[0]
        assert dept_node["id"] == "dept_name_研发部"
        assert dept_node["label"] == "研发部"
        assert dept_node["dept_id"] is None
        assert dept_node["parentid"] == 0

        emp_node = dept_node["children"][0]
        assert emp_node["id"] == "u1"
        assert emp_node["label"] == "张三"
        assert emp_node["isLeaf"] is True
        assert emp_node["department"] == "研发部"


# =============================================================================
# 三、filter_user_from_tree() 测试
# =============================================================================

class TestFilterUserFromTree:
    """filter_user_from_tree 递归过滤测试。"""

    def _sample_tree(self):
        """构造测试用树：公司 → 研发部(张三,李四) + 测试部(王五)。"""
        return [
            {
                "id": "dept_1",
                "label": "公司",
                "dept_id": 1,
                "parentid": 0,
                "children": [
                    {
                        "id": "dept_2",
                        "label": "研发部",
                        "dept_id": 2,
                        "parentid": 1,
                        "children": [
                            {"id": "zhangsan", "label": "张三", "isLeaf": True, "department": "研发部"},
                            {"id": "lisi", "label": "李四", "isLeaf": True, "department": "研发部"},
                        ],
                    },
                    {
                        "id": "dept_3",
                        "label": "测试部",
                        "dept_id": 3,
                        "parentid": 1,
                        "children": [
                            {"id": "wangwu", "label": "王五", "isLeaf": True, "department": "测试部"},
                        ],
                    },
                ],
            }
        ]

    def test_filter_single_user(self):
        """过滤单个用户，其他用户保留。"""
        tree = self._sample_tree()
        result = filter_user_from_tree(tree, "zhangsan")

        # 收集所有员工 id
        def get_emp_ids(nodes):
            ids = set()
            for n in nodes:
                if n.get("isLeaf"):
                    ids.add(n["id"])
                elif "children" in n:
                    ids.update(get_emp_ids(n["children"]))
            return ids

        emp_ids = get_emp_ids(result)
        assert "zhangsan" not in emp_ids
        assert "lisi" in emp_ids
        assert "wangwu" in emp_ids

    def test_filter_user_empty_dept_removed(self):
        """过滤后变空的部门节点被移除。"""
        tree = [
            {
                "id": "dept_1",
                "label": "公司",
                "dept_id": 1,
                "parentid": 0,
                "children": [
                    {
                        "id": "dept_2",
                        "label": "研发部",
                        "dept_id": 2,
                        "parentid": 1,
                        "children": [
                            {"id": "zhangsan", "label": "张三", "isLeaf": True, "department": "研发部"},
                        ],
                    },
                    {
                        "id": "dept_3",
                        "label": "测试部",
                        "dept_id": 3,
                        "parentid": 1,
                        "children": [
                            {"id": "lisi", "label": "李四", "isLeaf": True, "department": "测试部"},
                            {"id": "wangwu", "label": "王五", "isLeaf": True, "department": "测试部"},
                        ],
                    },
                ],
            }
        ]

        # 过滤张三 → 研发部变空 → 研发部被移除
        result = filter_user_from_tree(tree, "zhangsan")

        assert len(result) == 1
        company = result[0]
        dept_ids = [n["id"] for n in company["children"] if not n.get("isLeaf")]
        assert "dept_2" not in dept_ids  # 研发部被移除
        assert "dept_3" in dept_ids  # 测试部保留

    def test_filter_user_not_in_tree(self):
        """过滤不存在的用户，树不变。"""
        tree = self._sample_tree()
        result = filter_user_from_tree(tree, "nonexistent")

        assert len(result) == len(tree)
        # 树结构应与原始相同（所有员工都在）
        def count_emps(nodes):
            c = 0
            for n in nodes:
                if n.get("isLeaf"):
                    c += 1
                elif "children" in n:
                    c += count_emps(n["children"])
            return c

        assert count_emps(result) == 3

    def test_filter_empty_tree(self):
        """空树过滤返回空列表。"""
        result = filter_user_from_tree([], "anyone")
        assert result == []

    def test_filter_user_in_multiple_depts(self):
        """用户出现在多个部门时，所有实例都被移除。"""
        tree = [
            {
                "id": "dept_1",
                "label": "公司",
                "dept_id": 1,
                "parentid": 0,
                "children": [
                    {
                        "id": "dept_2",
                        "label": "研发部",
                        "dept_id": 2,
                        "parentid": 1,
                        "children": [
                            {"id": "zhangsan", "label": "张三", "isLeaf": True, "department": "研发"},
                            {"id": "lisi", "label": "李四", "isLeaf": True, "department": "研发"},
                        ],
                    },
                    {
                        "id": "dept_3",
                        "label": "测试部",
                        "dept_id": 3,
                        "parentid": 1,
                        "children": [
                            {"id": "zhangsan", "label": "张三", "isLeaf": True, "department": "测试"},
                        ],
                    },
                ],
            }
        ]

        result = filter_user_from_tree(tree, "zhangsan")

        def get_emp_ids(nodes):
            ids = set()
            for n in nodes:
                if n.get("isLeaf"):
                    ids.add(n["id"])
                elif "children" in n:
                    ids.update(get_emp_ids(n["children"]))
            return ids

        emp_ids = get_emp_ids(result)
        assert "zhangsan" not in emp_ids
        assert "lisi" in emp_ids  # 李四保留

    def test_filter_all_users_empties_tree(self):
        """过滤所有用户后，整个树变空。"""
        tree = self._sample_tree()
        # 依次过滤所有 3 个用户
        result = tree
        for uid in ["zhangsan", "lisi", "wangwu"]:
            result = filter_user_from_tree(result, uid)

        assert result == []

    def test_filter_preserves_dept_node_fields(self):
        """过滤后部门节点保留原有字段（dept_id, parentid 等）。"""
        tree = self._sample_tree()
        result = filter_user_from_tree(tree, "zhangsan")

        company = result[0]
        assert company["dept_id"] == 1
        assert company["parentid"] == 0
        assert company["label"] == "公司"

    def test_filter_does_not_mutate_original(self):
        """过滤不修改原始树（返回新对象）。"""
        tree = self._sample_tree()
        original_count = count_tree_employees(tree)
        filter_user_from_tree(tree, "zhangsan")
        # 原始树不受影响
        assert count_tree_employees(tree) == original_count


# =============================================================================
# 四、count_tree_employees() 测试
# =============================================================================

class TestCountTreeEmployees:
    """count_tree_employees 递归统计测试。"""

    def test_count_flat_tree(self):
        """扁平树统计员工数。"""
        tree = [
            {"id": "u1", "label": "张三", "isLeaf": True, "department": ""},
            {"id": "u2", "label": "李四", "isLeaf": True, "department": ""},
        ]
        assert count_tree_employees(tree) == 2

    def test_count_nested_tree(self):
        """嵌套树统计员工数。"""
        tree = [
            {
                "id": "dept_1",
                "label": "公司",
                "children": [
                    {
                        "id": "dept_2",
                        "label": "研发部",
                        "children": [
                            {"id": "u1", "label": "张三", "isLeaf": True},
                            {"id": "u2", "label": "李四", "isLeaf": True},
                        ],
                    },
                    {"id": "u3", "label": "王五", "isLeaf": True},
                ],
            }
        ]
        assert count_tree_employees(tree) == 3

    def test_count_empty_tree(self):
        """空树员工数为 0。"""
        assert count_tree_employees([]) == 0

    def test_count_only_dept_nodes(self):
        """只有部门节点无员工时为 0。"""
        tree = [
            {
                "id": "dept_1",
                "label": "公司",
                "children": [
                    {"id": "dept_2", "label": "研发部", "children": []},
                ],
            }
        ]
        assert count_tree_employees(tree) == 0

    def test_count_mixed_nodes(self):
        """混合节点（部门+员工）正确统计。"""
        tree = [
            {
                "id": "dept_1",
                "label": "公司",
                "children": [
                    {"id": "u1", "label": "张三", "isLeaf": True},
                    {
                        "id": "dept_2",
                        "label": "研发部",
                        "children": [
                            {"id": "u2", "label": "李四", "isLeaf": True},
                        ],
                    },
                ],
            },
            {"id": "u3", "label": "王五", "isLeaf": True},
        ]
        assert count_tree_employees(tree) == 3


# =============================================================================
# 五、get_org_tree_cached() 测试（mock 依赖）
# =============================================================================

class TestGetOrgTreeCached:
    """get_org_tree_cached 缓存与过滤测试。"""

    @pytest.mark.asyncio
    async def test_cache_key_per_endpoint(self):
        """agent 和 h5 端点使用不同的缓存 key。"""
        from tests.conftest import MockRedis

        mock_redis = MockRedis()
        directory = [_emp("u1", "张三", "研发", [2])]
        dept_list = [_dept(1, "公司", 0), _dept(2, "研发部", 1)]

        with patch(
            "app.services.employee_directory.get_org_directory",
            new_callable=AsyncMock,
            return_value=(directory, True),
        ):
            with patch(
                "app.services.employee_directory.get_cached_dept_list",
                new_callable=AsyncMock,
                return_value=dept_list,
            ):
                # 调用 agent 端点
                await get_org_tree_cached(None, mock_redis, "agent", "nobody")
                # 调用 h5 端点
                await get_org_tree_cached(None, mock_redis, "h5", "nobody")

                # 验证两个不同的缓存 key
                assert f"{ORG_TREE_CACHE_KEY_PREFIX}:agent" in mock_redis._data
                assert f"{ORG_TREE_CACHE_KEY_PREFIX}:h5" in mock_redis._data

    @pytest.mark.asyncio
    async def test_user_exclusion_from_cached_tree(self):
        """缓存包含全量员工，读取后过滤当前用户。"""
        from tests.conftest import MockRedis

        mock_redis = MockRedis()
        directory = [
            _emp("u1", "张三", "研发", [2]),
            _emp("u2", "李四", "研发", [2]),
            _emp("current_user", "当前用户", "研发", [2]),
        ]
        dept_list = [_dept(1, "公司", 0), _dept(2, "研发部", 1)]

        with patch(
            "app.services.employee_directory.get_org_directory",
            new_callable=AsyncMock,
            return_value=(directory, True),
        ):
            with patch(
                "app.services.employee_directory.get_cached_dept_list",
                new_callable=AsyncMock,
                return_value=dept_list,
            ):
                # 第一次调用：构建树并缓存
                tree1 = await get_org_tree_cached(None, mock_redis, "agent", "current_user")
                # 当前用户应被排除
                assert count_tree_employees(tree1) == 2  # 张三 + 李四

                def get_emp_ids(nodes):
                    ids = set()
                    for n in nodes:
                        if n.get("isLeaf"):
                            ids.add(n["id"])
                        elif "children" in n:
                            ids.update(get_emp_ids(n["children"]))
                    return ids

                assert "current_user" not in get_emp_ids(tree1)

    @pytest.mark.asyncio
    async def test_cache_hit_skips_rebuild(self):
        """缓存命中时不重新构建树。"""
        from tests.conftest import MockRedis

        mock_redis = MockRedis()
        # 预填充缓存
        cached_tree = [
            {
                "id": "dept_1",
                "label": "公司",
                "dept_id": 1,
                "parentid": 0,
                "children": [
                    {"id": "u1", "label": "张三", "isLeaf": True, "department": ""},
                    {"id": "u2", "label": "李四", "isLeaf": True, "department": ""},
                ],
            }
        ]
        await mock_redis.setex(
            f"{ORG_TREE_CACHE_KEY_PREFIX}:agent",
            1800,
            json.dumps(cached_tree, ensure_ascii=False),
        )

        # mock get_org_directory — 如果被调用说明缓存未命中
        mock_get_dir = AsyncMock(return_value=([], True))
        mock_get_dept = AsyncMock(return_value=[])

        with patch("app.services.employee_directory.get_org_directory", mock_get_dir):
            with patch("app.services.employee_directory.get_cached_dept_list", mock_get_dept):
                tree = await get_org_tree_cached(None, mock_redis, "agent", "u1")

                # 缓存命中，不应调用 get_org_directory
                mock_get_dir.assert_not_called()
                mock_get_dept.assert_not_called()

                # u1 被过滤
                assert count_tree_employees(tree) == 1

    @pytest.mark.asyncio
    async def test_cache_miss_builds_and_caches(self):
        """缓存未命中时构建树并写入缓存。"""
        from tests.conftest import MockRedis

        mock_redis = MockRedis()
        directory = [_emp("u1", "张三", "研发", [2])]
        dept_list = [_dept(1, "公司", 0), _dept(2, "研发部", 1)]

        with patch(
            "app.services.employee_directory.get_org_directory",
            new_callable=AsyncMock,
            return_value=(directory, True),
        ):
            with patch(
                "app.services.employee_directory.get_cached_dept_list",
                new_callable=AsyncMock,
                return_value=dept_list,
            ):
                tree = await get_org_tree_cached(None, mock_redis, "agent", "nobody")

                # 树已构建
                assert len(tree) == 1
                # 缓存已写入
                assert f"{ORG_TREE_CACHE_KEY_PREFIX}:agent" in mock_redis._data

    @pytest.mark.asyncio
    async def test_no_redis_builds_tree_without_cache(self):
        """redis=None 时仍能构建树（不读写缓存）。"""
        directory = [_emp("u1", "张三", "研发", [2])]
        dept_list = [_dept(1, "公司", 0), _dept(2, "研发部", 1)]

        with patch(
            "app.services.employee_directory.get_org_directory",
            new_callable=AsyncMock,
            return_value=(directory, True),
        ):
            with patch(
                "app.services.employee_directory.get_cached_dept_list",
                new_callable=AsyncMock,
                return_value=dept_list,
            ):
                tree = await get_org_tree_cached(None, None, "agent", "nobody")

                assert len(tree) == 1
                assert count_tree_employees(tree) == 1

    @pytest.mark.asyncio
    async def test_degraded_flat_tree_when_no_dept_list(self):
        """dept_list 为空时降级到扁平树。"""
        from tests.conftest import MockRedis

        mock_redis = MockRedis()
        directory = [_emp("u1", "张三", "研发部")]

        with patch(
            "app.services.employee_directory.get_org_directory",
            new_callable=AsyncMock,
            return_value=(directory, True),
        ):
            with patch(
                "app.services.employee_directory.get_cached_dept_list",
                new_callable=AsyncMock,
                return_value=[],  # 空部门列表
            ):
                tree = await get_org_tree_cached(None, mock_redis, "agent", "nobody")

                # 降级路径：dept_name_ 前缀
                assert len(tree) == 1
                assert tree[0]["id"] == "dept_name_研发部"


# =============================================================================
# 六、兼容性测试：resolve_target 与搜索接口不受 dept_ids 影响
# =============================================================================

class TestCompatibility:
    """验证新增 dept_ids 字段不影响现有功能。"""

    def test_directory_entry_has_dept_ids_field(self):
        """验证 directory 条目结构包含 dept_ids 字段（企微路径）。

        这不是直接测试 get_org_directory（需要 mock 企微 API），
        而是验证 build_org_tree 对 dept_ids 字段的消费方式正确。
        """
        # 模拟 get_org_directory 返回的数据结构
        directory = [
            {
                "employee_id": "u1",
                "name": "张三",
                "department": "研发部",
                "dept_ids": [2],
            }
        ]
        dept_list = [_dept(1, "公司", 0), _dept(2, "研发部", 1)]

        tree = build_org_tree(directory, dept_list)

        # 员工正确出现在部门下
        assert count_tree_employees(tree) == 1

    def test_directory_entry_without_dept_ids(self):
        """dept_ids 字段缺失时（旧缓存兼容），build_org_tree 不报错。"""
        directory = [
            {
                "employee_id": "u1",
                "name": "张三",
                "department": "研发部",
                # dept_ids 缺失
            }
        ]
        dept_list = [_dept(1, "公司", 0), _dept(2, "研发部", 1)]

        tree = build_org_tree(directory, dept_list)

        # dept_ids 缺失 → emp.get("dept_ids") or [] → []  → 归入未分配部门
        top_ids = {n["id"] for n in tree}
        assert "dept_unassigned" in top_ids

    def test_employee_with_unknown_dept_id(self):
        """员工 dept_id 不在 dept_list 中时的行为验证。

        已知边界情况：员工 dept_id 不在 dept_map 中时，
        员工会被分配到 dept_employees[unknown_id] 但不会被任何 build_dept_node 处理，
        导致该员工从树中"消失"。

        本测试验证此行为并记录为已知边界情况。
        """
        directory = [_emp("u1", "张三", "某部门", [99])]  # dept 99 不在 dept_list
        dept_list = [_dept(1, "公司", 0), _dept(2, "研发部", 1)]

        tree = build_org_tree(directory, dept_list)

        # 已知边界情况：员工 u1 不在树中（dept 99 不在 dept_map）
        # 理想行为应该是归入"未分配部门"，但当前实现会丢失该员工
        assert count_tree_employees(tree) == 0
        # 记录此行为 — 见测试报告中的 Known Issues