第一次

tests/pages/LongiMainPage.js

@@ -108,79 +108,7 @@ class LongiMainPage extends BasePage {
 
             // 检查是否成功加载数据
             if (menuItems && Array.isArray(menuItems) && menuItems.length > 0) {
-                console.log(`从文件 ${process.env.MENU_DATA_FILE_PATH} 成功加载了 ${menuItems.length} 个菜单项`);
+                console.log(`从文件 ${process.env.BASE_URL} 成功加载了 ${menuItems.length} 个菜单项`);
-
-                //这里因为是序列化回来的，所以没有对应每个menu的element元素，需要补充回来。
-                console.log('开始恢复菜单项的element元素...');
-
-                // 等待菜单加载完成
-                await this.page.waitForSelector(this.selectors.sideNav, {
-                    timeout: parseInt(process.env.MENU_TIME_OUT || '30000', 10)
-                });
-
-                // 获取当前页面上的所有菜单元素
-                const currentMenuElements = await this.page.locator(this.selectors.menuItems).all();
-                console.log(`当前页面上找到 ${currentMenuElements.length} 个菜单元素`);
-
-                // 为每个菜单项恢复element元素
-                for (const menuItem of menuItems) {
-                    let foundElement = null;
-                    let sameTextElements = [];
-
-                    // 首先找到所有文本匹配的元素
-                    for (const element of currentMenuElements) {
-                        const elementText = await element.textContent();
-                        if (elementText.trim() === menuItem.text) {
-                            // 检查是否是一级菜单
-                            const isTopMenu = await element.locator(this.selectors.firstLevelIndicator).count() > 0;
-                            if (!isTopMenu) {
-                                sameTextElements.push(element);
-                            }
-                        }
-                    }
-
-                    // 如果找到多个同名菜单，根据是否有三级菜单来区分
-                    if (sameTextElements.length > 0) {
-                        for (const element of sameTextElements) {
-                            // 检查是否有三级菜单指示器
-                            const hasThirdMenu = await element.evaluate(el => {
-                                return el.classList.contains('el-sub-menu__title') ||
-                                    el.querySelector('.el-submenu__icon-arrow') !== null;
-                            });
-
-                            if (hasThirdMenu === menuItem.hasThirdMenu) {
-                                foundElement = element;
-                                break;
-                            }
-                        }
-
-                        // 如果还没找到，就用第一个匹配的元素
-                        if (!foundElement && sameTextElements.length > 0) {
-                            foundElement = sameTextElements[0];
-                        }
-                    }
-
-                    if (foundElement) {
-                        menuItem.element = foundElement;
-                        console.log(`✅ 成功恢复菜单项 "${menuItem.text}" (${menuItem.hasThirdMenu ? '有' : '无'}三级菜单) 的element元素`);
-                    } else {
-                        console.warn(`⚠️ 无法恢复菜单项 "${menuItem.text}" (${menuItem.hasThirdMenu ? '有' : '无'}三级菜单) 的element元素`);
-                    }
-                }
-
-                // 检查是否所有菜单项都恢复了element元素
-                const missingElementCount = menuItems.filter(item => !item.element).length;
-                if (missingElementCount > 0) {
-                    console.warn(`⚠️ 有 ${missingElementCount} 个菜单项未能恢复element元素`);
-
-                    // 如果大部分菜单项都没有恢复element元素，可能需要重新查找
-                    if (missingElementCount > menuItems.length / 2) {
-                        console.log('由于大部分菜单项未能恢复element元素，将重新查找所有菜单项');
-                        await this.expandSideMenu();
-                        return await this.findAndSaveMenuItems();
-                    }
-                }
-
                 return menuItems;
             } else {
                 await this.expandSideMenu();
@@ -559,8 +487,76 @@ class LongiMainPage extends BasePage {
         }
     }
 
+    /**
+     * 恢复菜单项的element元素
+     * @param {Object} menuItem 需要恢复element的菜单项
+     * @returns {Promise<Object>} 返回更新后的菜单项
+     * @private
+     */
+    async restoreMenuElement(menuItem) {
+        try {
+            // 获取当前页面上的所有菜单元素
+            const currentMenuElements = await this.page.locator(this.selectors.menuItems).all();
+            let foundElement = null;
+            let sameTextElements = [];
+
+            // 首先找到所有文本匹配的元素
+            for (const element of currentMenuElements) {
+                const elementText = await element.textContent();
+                if (elementText.trim() === menuItem.text) {
+                    // 检查是否是一级菜单
+                    const isTopMenu = await element.locator(this.selectors.firstLevelIndicator).count() > 0;
+                    if (!isTopMenu) {
+                        sameTextElements.push(element);
+                    }
+                }
+            }
+
+            // 如果找到多个同名菜单，根据是否有三级菜单来区分
+            if (sameTextElements.length > 0) {
+                for (const element of sameTextElements) {
+                    // 检查是否有三级菜单指示器
+                    const hasThirdMenu = await element.evaluate(el => {
+                        return el.classList.contains('el-sub-menu__title') ||
+                            el.querySelector('.el-submenu__icon-arrow') !== null;
+                    });
+
+                    if (hasThirdMenu === menuItem.hasThirdMenu) {
+                        foundElement = element;
+                        break;
+                    }
+                }
+
+                // 如果还没找到，就用第一个匹配的元素
+                if (!foundElement && sameTextElements.length > 0) {
+                    foundElement = sameTextElements[0];
+                }
+            }
+
+            if (foundElement) {
+                menuItem.element = foundElement;
+                console.log(`✅ 成功恢复菜单项 "${menuItem.text}" (${menuItem.hasThirdMenu ? '有' : '无'}三级菜单) 的element元素`);
+            } else {
+                console.warn(`⚠️ 无法恢复菜单项 "${menuItem.text}" (${menuItem.hasThirdMenu ? '有' : '无'}三级菜单) 的element元素`);
+            }
+
+            return menuItem;
+        } catch (error) {
+            console.error(`恢复菜单项element时出错 [${menuItem.text}]:`, error.message);
+            return menuItem;
+        }
+    }
+
     async handleSingleMenu(menu) {
         await this.expandSideMenu();
+        // 在处理菜单前重新获取最新的element
+        menu = await this.restoreMenuElement(menu);
+
+        if (!menu.element) {
+            console.error(`无法找到菜单项 "${menu.text}" 的element，跳过处理`);
+            return;
+        }
+
         if (menu.hasThirdMenu) {
             await this.handleThreeLevelMenu(menu);
         } else {
@@ -713,7 +709,7 @@ class LongiMainPage extends BasePage {
         try {
             // 检查三级菜单是否存在
             const elements = await this.page.locator('.el-popper.is-light.el-popover .menuTitle.canClick').all();
-            
+
             if (elements.length === 0) {
                 return [];
             }
@@ -723,7 +719,7 @@ class LongiMainPage extends BasePage {
             for (let i = 0; i < elements.length; i++) {
                 const element = elements[i];
                 const text = await element.textContent();
-                
+
                 thirdMenus.push({
                     index: i,
                     text: text.trim(),
@@ -749,7 +745,7 @@ class LongiMainPage extends BasePage {
         try {
             console.log(`正在处理 ${menu.text} 菜单`);
             await menu.element.click();
-            
+
             // 等待一个短暂的时间让弹出层出现
             await this.page.waitForTimeout(500);
 
@@ -770,7 +766,7 @@ class LongiMainPage extends BasePage {
             // 比如点击每个三级菜单项并等待页面加载
             for (const thirdMenu of thirdMenus) {
                 await this.handleMenuClick(thirdMenu, menu.text);
-                
+
                 // 如果不是最后一个菜单项，需要重新点击父菜单展开三级菜单
                 if (thirdMenu !== thirdMenus[thirdMenus.length - 1]) {
                     await menu.element.click();
@@ -834,17 +830,17 @@ class LongiMainPage extends BasePage {
         try {
             const menuPath = parentMenu.path || parentMenu.text;
             console.log(`🔹 处理TAB页: ${menuPath} > ${tabInfo.text}`);
-            
+
             // 直接使用传入的element点击
             await tabInfo.element.click();
-            
+
             // 等待页面加载
             const loadResult = await this.waitForPageLoadWithRetry(parentMenu, tabInfo.text);
             if (!loadResult.success) {
                 console.warn(`TAB页 ${tabInfo.text} 加载失败: ${loadResult.error}`);
                 return false;
             }
-            
+
             return true;
         } catch (error) {
             console.error(`处理TAB页失败 [${parentMenu.text} > ${tabInfo.text}]:`, error.message);
@@ -862,7 +858,7 @@ class LongiMainPage extends BasePage {
         try {
             // 等待TAB容器加载
             await this.page.waitForTimeout(1000);
-            
+
             // 使用更精确的选择器获取工作区的TAB页
             const tabs = await this.page.locator('.workSpaceBaseTab .el-tabs__item').all();
             if (tabs.length === 0) {
@@ -871,7 +867,7 @@ class LongiMainPage extends BasePage {
             }
 
             console.log(`📑 ${menu.text} 找到 ${tabs.length} 个TAB页`);
-            
+
             // 获取所有TAB页的完整信息（文本、激活状态和元素引用）
             const tabInfos = await Promise.all(
                 tabs.map(async element => ({
@@ -880,7 +876,7 @@ class LongiMainPage extends BasePage {
                     element: element // 保存元素引用
                 }))
             );
-            
+
             // 处理每个非激活的TAB页
             for (const tabInfo of tabInfos) {
                 // 跳过当前激活的TAB页，因为它已经是默认加载的
@@ -890,7 +886,7 @@ class LongiMainPage extends BasePage {
                     console.log(`⏭️ 跳过当前激活的TAB页: ${menu.text} > ${tabInfo.text}`);
                 }
             }
-            
+
             return true;
         } catch (error) {
             console.error(`处理TAB页失败 [${menu.text}]:`, error.message);