test：添加位置广播系统端到端测试

- 添加并发用户测试场景
- 实现数据库恢复集成测试
- 重命名登录测试文件以符合命名规范

test/location_broadcast/concurrent_users_validation.spec.ts

@@ -0,0 +1,275 @@
+/**
+ * 并发用户测试结构验证
+ * 
+ * 功能描述：
+ * - 验证并发用户测试的结构和逻辑正确性
+ * - 测试辅助函数和测试用例组织
+ * - 确保测试代码本身的质量
+ * 
+ * @author moyin
+ * @version 1.0.0
+ * @since 2026-01-08
+ */
+
+describe('并发用户测试结构验证', () => {
+  describe('测试辅助函数', () => {
+    it('应该正确定义TestUser接口', () => {
+      interface TestUser {
+        id: string;
+        client: any;
+        sessionId?: string;
+        position?: { x: number; y: number; mapId: string };
+        connected: boolean;
+        joined: boolean;
+      }
+
+      const testUser: TestUser = {
+        id: 'test-user-1',
+        client: null,
+        connected: false,
+        joined: false,
+      };
+
+      expect(testUser.id).toBe('test-user-1');
+      expect(testUser.connected).toBe(false);
+      expect(testUser.joined).toBe(false);
+    });
+
+    it('应该正确处理用户清理逻辑', () => {
+      const mockUsers = [
+        {
+          id: 'user1',
+          client: { connected: true, disconnect: jest.fn() },
+          connected: true,
+          joined: false,
+        },
+        {
+          id: 'user2',
+          client: { connected: false, disconnect: jest.fn() },
+          connected: false,
+          joined: false,
+        },
+      ];
+
+      // 模拟清理函数
+      const cleanupUsers = (users: any[]) => {
+        users.forEach(user => {
+          if (user.client && user.client.connected) {
+            user.client.disconnect();
+          }
+        });
+      };
+
+      cleanupUsers(mockUsers);
+
+      expect(mockUsers[0].client.disconnect).toHaveBeenCalled();
+      expect(mockUsers[1].client.disconnect).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('测试场景覆盖', () => {
+    it('应该包含大规模并发连接测试', () => {
+      const testScenarios = [
+        '应该支持100个用户同时连接',
+        '应该支持用户快速连接和断开',
+      ];
+
+      expect(testScenarios).toContain('应该支持100个用户同时连接');
+      expect(testScenarios).toContain('应该支持用户快速连接和断开');
+    });
+
+    it('应该包含并发会话管理测试', () => {
+      const testScenarios = [
+        '应该支持多用户同时加入同一会话',
+        '应该支持用户在多个会话间快速切换',
+      ];
+
+      expect(testScenarios).toContain('应该支持多用户同时加入同一会话');
+      expect(testScenarios).toContain('应该支持用户在多个会话间快速切换');
+    });
+
+    it('应该包含并发位置更新测试', () => {
+      const testScenarios = [
+        '应该正确处理大量并发位置更新',
+        '应该确保位置更新的数据一致性',
+      ];
+
+      expect(testScenarios).toContain('应该正确处理大量并发位置更新');
+      expect(testScenarios).toContain('应该确保位置更新的数据一致性');
+    });
+
+    it('应该包含会话范围广播测试', () => {
+      const testScenarios = [
+        '应该确保广播只在正确的会话范围内',
+      ];
+
+      expect(testScenarios).toContain('应该确保广播只在正确的会话范围内');
+    });
+
+    it('应该包含系统资源和稳定性测试', () => {
+      const testScenarios = [
+        '应该在高并发下保持系统稳定',
+        '应该正确处理内存使用和清理',
+      ];
+
+      expect(testScenarios).toContain('应该在高并发下保持系统稳定');
+      expect(testScenarios).toContain('应该正确处理内存使用和清理');
+    });
+  });
+
+  describe('性能指标验证', () => {
+    it('应该定义合理的性能指标', () => {
+      const performanceMetrics = {
+        maxConcurrentUsers: 100,
+        maxConnectionTimePerUser: 100, // ms
+        minSuccessRate: 80, // %
+        maxMemoryPerUser: 200 * 1024, // bytes
+        maxErrorRate: 5, // %
+      };
+
+      expect(performanceMetrics.maxConcurrentUsers).toBeGreaterThan(50);
+      expect(performanceMetrics.maxConnectionTimePerUser).toBeLessThan(200);
+      expect(performanceMetrics.minSuccessRate).toBeGreaterThan(70);
+      expect(performanceMetrics.maxMemoryPerUser).toBeLessThan(500 * 1024);
+      expect(performanceMetrics.maxErrorRate).toBeLessThan(10);
+    });
+
+    it('应该包含性能监控逻辑', () => {
+      const performanceMonitor = {
+        startTime: Date.now(),
+        endTime: 0,
+        totalOperations: 0,
+        successfulOperations: 0,
+        errors: 0,
+        
+        calculateMetrics() {
+          const duration = this.endTime - this.startTime;
+          const successRate = (this.successfulOperations / this.totalOperations) * 100;
+          const errorRate = (this.errors / this.totalOperations) * 100;
+          
+          return {
+            duration,
+            successRate,
+            errorRate,
+            operationsPerSecond: this.totalOperations / (duration / 1000),
+          };
+        }
+      };
+
+      performanceMonitor.totalOperations = 100;
+      performanceMonitor.successfulOperations = 85;
+      performanceMonitor.errors = 5;
+      performanceMonitor.endTime = performanceMonitor.startTime + 5000;
+
+      const metrics = performanceMonitor.calculateMetrics();
+
+      expect(metrics.successRate).toBe(85);
+      expect(metrics.errorRate).toBe(5);
+      expect(metrics.operationsPerSecond).toBe(20);
+    });
+  });
+
+  describe('测试数据生成', () => {
+    it('应该能生成测试用户ID', () => {
+      const generateUserId = (prefix: string, index: number) => `${prefix}-${index}`;
+      
+      const userId = generateUserId('concurrent-user', 42);
+      expect(userId).toBe('concurrent-user-42');
+    });
+
+    it('应该能生成随机位置数据', () => {
+      const generateRandomPosition = (mapId: string = 'plaza') => ({
+        x: Math.random() * 1000,
+        y: Math.random() * 1000,
+        mapId,
+      });
+
+      const position = generateRandomPosition();
+      
+      expect(position.x).toBeGreaterThanOrEqual(0);
+      expect(position.x).toBeLessThan(1000);
+      expect(position.y).toBeGreaterThanOrEqual(0);
+      expect(position.y).toBeLessThan(1000);
+      expect(position.mapId).toBe('plaza');
+    });
+
+    it('应该能生成会话ID', () => {
+      const generateSessionId = (prefix: string, index?: number) => 
+        index !== undefined ? `${prefix}-${index}` : `${prefix}-${Date.now()}`;
+
+      const sessionId1 = generateSessionId('test-session', 1);
+      const sessionId2 = generateSessionId('test-session');
+
+      expect(sessionId1).toBe('test-session-1');
+      expect(sessionId2).toMatch(/^test-session-\d+$/);
+    });
+  });
+
+  describe('错误处理验证', () => {
+    it('应该正确处理连接超时', async () => {
+      const createConnectionWithTimeout = (timeout: number = 5000) => {
+        return new Promise((resolve, reject) => {
+          const timer = setTimeout(() => {
+            reject(new Error('连接超时'));
+          }, timeout);
+
+          // 模拟连接成功
+          setTimeout(() => {
+            clearTimeout(timer);
+            resolve('连接成功');
+          }, timeout / 2);
+        });
+      };
+
+      const result = await createConnectionWithTimeout(100);
+      expect(result).toBe('连接成功');
+    });
+
+    it('应该正确处理连接失败', async () => {
+      const createFailingConnection = () => {
+        return new Promise((resolve, reject) => {
+          setTimeout(() => {
+            reject(new Error('连接失败'));
+          }, 10);
+        });
+      };
+
+      await expect(createFailingConnection()).rejects.toThrow('连接失败');
+    });
+  });
+
+  describe('并发控制验证', () => {
+    it('应该能正确管理并发Promise', async () => {
+      const createConcurrentTasks = (count: number) => {
+        return Array.from({ length: count }, (_, i) => 
+          new Promise(resolve => setTimeout(() => resolve(i), Math.random() * 100))
+        );
+      };
+
+      const tasks = createConcurrentTasks(10);
+      const results = await Promise.all(tasks);
+
+      expect(results).toHaveLength(10);
+      expect(results).toEqual(expect.arrayContaining([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));
+    });
+
+    it('应该能处理部分失败的并发任务', async () => {
+      const createMixedTasks = (count: number) => {
+        return Array.from({ length: count }, (_, i) => 
+          i % 3 === 0 
+            ? Promise.reject(new Error(`Task ${i} failed`))
+            : Promise.resolve(i)
+        );
+      };
+
+      const tasks = createMixedTasks(6);
+      const results = await Promise.allSettled(tasks);
+
+      const fulfilled = results.filter(r => r.status === 'fulfilled');
+      const rejected = results.filter(r => r.status === 'rejected');
+
+      expect(fulfilled).toHaveLength(4); // 1, 2, 4, 5
+      expect(rejected).toHaveLength(2);  // 0, 3
+    });
+  });
+});