create-aiko 0.1.0

package/template/packages/api/examples/security/complete/tests/run-tests.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const TEST_RESULTS_DIR = path.join(__dirname, '../test-results');
+const COVERAGE_DIR = path.join(__dirname, '../coverage');
+
+function ensureDirectoryExists(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+function runCommand(command, description) {
+  console.log(`\n${description}...`);
+  try {
+    execSync(command, { stdio: 'inherit', cwd: __dirname });
+    console.log(`✓ ${description} 完成`);
+    return true;
+  } catch (error) {
+    console.error(`✗ ${description} 失败`);
+    return false;
+  }
+}
+
+function generateTestReport() {
+  ensureDirectoryExists(TEST_RESULTS_DIR);
+  ensureDirectoryExists(COVERAGE_DIR);
+
+  console.log('========================================');
+  console.log('  Aiko Boot Security 测试报告生成器');
+  console.log('========================================\n');
+
+  const results = {
+    timestamp: new Date().toISOString(),
+    environment: process.env.NODE_ENV || 'development',
+    tests: {
+      unit: { passed: 0, failed: 0, total: 0 },
+      integration: { passed: 0, failed: 0, total: 0 },
+      overall: { passed: 0, failed: 0, total: 0, duration: 0 },
+    },
+    coverage: {
+      statements: 0,
+      branches: 0,
+      functions: 0,
+      lines: 0,
+    },
+    details: [],
+  };
+
+  console.log('1. 运行单元测试...');
+  const unitSuccess = runCommand(
+    'npm run test:unit',
+    '单元测试'
+  );
+
+  console.log('\n2. 运行集成测试...');
+  const integrationSuccess = runCommand(
+    'npm run test:integration',
+    '集成测试'
+  );
+
+  console.log('\n3. 生成覆盖率报告...');
+  const coverageSuccess = runCommand(
+    'npm run test:coverage',
+    '覆盖率报告'
+  );
+
+  console.log('\n4. 收集测试结果...');
+
+  try {
+    const coverageSummaryPath = path.join(COVERAGE_DIR, 'coverage-summary.json');
+    if (fs.existsSync(coverageSummaryPath)) {
+      const coverageData = JSON.parse(fs.readFileSync(coverageSummaryPath, 'utf8'));
+      results.coverage = coverageData.total;
+    }
+  } catch (error) {
+    console.warn('无法读取覆盖率数据');
+  }
+
+  console.log('\n5. 生成测试报告...');
+  const reportPath = path.join(TEST_RESULTS_DIR, 'test-report.json');
+  fs.writeFileSync(reportPath, JSON.stringify(results, null, 2));
+
+  console.log('\n========================================');
+  console.log('  测试摘要');
+  console.log('========================================');
+  console.log(`单元测试: ${unitSuccess ? '✓ 通过' : '✗ 失败'}`);
+  console.log(`集成测试: ${integrationSuccess ? '✓ 通过' : '✗ 失败'}`);
+  console.log(`覆盖率报告: ${coverageSuccess ? '✓ 已生成' : '✗ 失败'}`);
+  console.log(`报告路径: ${reportPath}`);
+  console.log('========================================\n');
+
+  if (unitSuccess && integrationSuccess && coverageSuccess) {
+    console.log('✓ 所有测试通过！');
+    process.exit(0);
+  } else {
+    console.log('✗ 部分测试失败');
+    process.exit(1);
+  }
+}
+
+generateTestReport();

package/template/packages/api/examples/security/complete/tests/setup.ts

@@ -0,0 +1,19 @@
+import { jest } from '@jest/globals';
+
+jest.setTimeout(10000);
+
+beforeAll(() => {
+  console.log('开始测试套件...');
+});
+
+afterAll(() => {
+  console.log('测试套件完成');
+});
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});

package/template/packages/api/examples/security/complete/tests/unit/auth.service.test.ts

@@ -0,0 +1,199 @@
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import { AuthService } from '../../service/auth.service.js';
+import { UserService } from '../../service/user.service.js';
+import { OAuthService } from '../../service/oauth.service.js';
+import { SecurityContext } from '@ai-partner-x/aiko-boot-starter-security';
+
+describe('AuthService', () => {
+    let authService: AuthService;
+    let userService: UserService;
+    let oauthService: OAuthService;
+
+    beforeEach(() => {
+        authService = new AuthService();
+        userService = new UserService();
+        oauthService = new OAuthService();
+
+        (authService as any).securityAuthService = {
+            login: jest.fn(),
+            register: jest.fn(),
+            refreshToken: jest.fn(),
+            logout: jest.fn(),
+            changePassword: jest.fn(),
+        };
+
+        (authService as any).userService = userService;
+        (authService as any).oauthService = oauthService;
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    describe('login', () => {
+        it('应该成功登录用户', async () => {
+            const mockResponse = {
+                accessToken: 'mock-access-token',
+                refreshToken: 'mock-refresh-token',
+                expiresIn: 3600,
+                user: {
+                    id: 1,
+                    username: 'testuser',
+                    email: 'test@example.com',
+                },
+            };
+
+            ((authService as any).securityAuthService.login as jest.Mock).mockResolvedValue(mockResponse);
+
+            const result = await authService.login('testuser', 'password123');
+
+            expect(result).toEqual(mockResponse);
+            expect(((authService as any).securityAuthService.login as jest.Mock)).toHaveBeenCalledWith({
+                username: 'testuser',
+                password: 'password123',
+            });
+        });
+
+        it('应该处理登录失败', async () => {
+            const mockError = new Error('用户名或密码错误');
+            ((authService as any).securityAuthService.login as jest.Mock).mockRejectedValue(mockError);
+
+            await expect(authService.login('testuser', 'wrongpassword')).rejects.toThrow('用户名或密码错误');
+        });
+    });
+
+    describe('register', () => {
+        it('应该成功注册新用户', async () => {
+            const mockUserData = {
+                username: 'newuser',
+                email: 'new@example.com',
+                password: 'Password123!',
+            };
+
+            const mockResponse = {
+                user: {
+                    id: 2,
+                    username: 'newuser',
+                    email: 'new@example.com',
+                },
+                accessToken: 'new-access-token',
+                refreshToken: 'new-refresh-token',
+            };
+
+            ((authService as any).securityAuthService.register as jest.Mock).mockResolvedValue(mockResponse);
+
+            const result = await authService.register(mockUserData);
+
+            expect(result).toEqual(mockResponse);
+            expect(((authService as any).securityAuthService.register as jest.Mock)).toHaveBeenCalledWith(mockUserData);
+        });
+
+        it('应该处理注册失败（用户已存在）', async () => {
+            const mockUserData = {
+                username: 'existinguser',
+                email: 'existing@example.com',
+                password: 'Password123!',
+            };
+
+            const mockError = new Error('用户名已存在');
+            ((authService as any).securityAuthService.register as jest.Mock).mockRejectedValue(mockError);
+
+            await expect(authService.register(mockUserData)).rejects.toThrow('用户名已存在');
+        });
+    });
+
+    describe('refreshToken', () => {
+        it('应该成功刷新 token', async () => {
+            const mockResponse = {
+                accessToken: 'new-access-token',
+                refreshToken: 'new-refresh-token',
+                expiresIn: 3600,
+            };
+
+            ((authService as any).securityAuthService.refreshToken as jest.Mock).mockResolvedValue(mockResponse);
+
+            const result = await authService.refreshToken('old-refresh-token');
+
+            expect(result).toEqual(mockResponse);
+            expect(((authService as any).securityAuthService.refreshToken as jest.Mock)).toHaveBeenCalledWith('old-refresh-token');
+        });
+
+        it('应该处理无效的 refresh token', async () => {
+            const mockError = new Error('无效的 refresh token');
+            ((authService as any).securityAuthService.refreshToken as jest.Mock).mockRejectedValue(mockError);
+
+            await expect(authService.refreshToken('invalid-token')).rejects.toThrow('无效的 refresh token');
+        });
+    });
+
+    describe('logout', () => {
+        it('应该成功登出用户', async () => {
+            const mockResponse = { success: true };
+            ((authService as any).securityAuthService.logout as jest.Mock).mockResolvedValue(mockResponse);
+
+            const result = await authService.logout('access-token');
+
+            expect(result).toEqual(mockResponse);
+            expect(((authService as any).securityAuthService.logout as jest.Mock)).toHaveBeenCalledWith('access-token');
+        });
+    });
+
+    describe('changePassword', () => {
+        it('应该成功修改密码', async () => {
+            const mockResponse = { success: true };
+            ((authService as any).securityAuthService.changePassword as jest.Mock).mockResolvedValue(mockResponse);
+
+            SecurityContext.getInstance().setCurrentUser({ id: 1, username: 'testuser' });
+
+            const result = await authService.changePassword(1, 'oldpassword', 'newpassword');
+
+            expect(result).toEqual(mockResponse);
+            expect(((authService as any).securityAuthService.changePassword as jest.Mock)).toHaveBeenCalledWith(
+                1,
+                'oldpassword',
+                'newpassword'
+            );
+        });
+
+        it('应该处理未登录用户的密码修改', async () => {
+            SecurityContext.getInstance().setCurrentUser(null);
+
+            await expect(authService.changePassword(1, 'oldpassword', 'newpassword')).rejects.toThrow('未登录');
+        });
+    });
+
+    describe('handleOAuthCallback', () => {
+        it('应该成功处理 OAuth 回调', async () => {
+            const mockProfile = {
+                id: 'github-123',
+                username: 'githubuser',
+                email: 'github@example.com',
+                avatar: 'https://github.com/avatar.png',
+                provider: 'github',
+            };
+
+            const mockTokens = {
+                access_token: 'github-access-token',
+                refresh_token: 'github-refresh-token',
+                expires_at: 1234567890,
+            };
+
+            const mockResponse = {
+                user: {
+                    id: 3,
+                    username: 'githubuser',
+                    email: 'github@example.com',
+                },
+                accessToken: 'app-access-token',
+                refreshToken: 'app-refresh-token',
+            };
+
+            (oauthService.handleOAuthCallback as jest.Mock).mockResolvedValue(mockResponse);
+
+            const result = await authService.handleOAuthCallback(mockProfile, mockTokens);
+
+            expect(result).toEqual(mockResponse);
+            expect(oauthService.handleOAuthCallback).toHaveBeenCalledWith(mockProfile, mockTokens);
+        });
+    });
+});

package/template/packages/api/examples/security/complete/tests/unit/permission.service.test.ts

@@ -0,0 +1,377 @@
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import { PermissionService } from '../../service/permission.service.js';
+import { Permission, Role, User } from '../../entity/index.js';
+
+describe('PermissionService', () => {
+  let permissionService: PermissionService;
+
+  beforeEach(() => {
+    permissionService = new PermissionService();
+
+    (permissionService as any).permissionMapper = {
+      selectById: jest.fn(),
+      selectList: jest.fn(),
+      insert: jest.fn(),
+      updateById: jest.fn(),
+      deleteById: jest.fn(),
+    };
+
+    (permissionService as any).roleMapper = {
+      selectById: jest.fn(),
+    };
+
+    (permissionService as any).userMapper = {
+      selectById: jest.fn(),
+    };
+
+    (permissionService as any).rolePermissionMapper = {
+      selectList: jest.fn(),
+    };
+
+    (permissionService as any).userRoleMapper = {
+      selectList: jest.fn(),
+    };
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('getUserPermissions', () => {
+    it('应该获取用户的所有权限', async () => {
+      const mockUserRoles = [
+        { id: 1, userId: 1, roleId: 1, createdAt: new Date() },
+      ];
+
+      const mockRolePermissions = [
+        { id: 1, roleId: 1, permissionId: 1, createdAt: new Date() },
+        { id: 2, roleId: 1, permissionId: 2, createdAt: new Date() },
+      ];
+
+      const mockPermissions: Permission[] = [
+        {
+          id: 1,
+          name: 'user:view',
+          description: '查看用户',
+          resource: 'user',
+          action: 'view',
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+        {
+          id: 2,
+          name: 'user:create',
+          description: '创建用户',
+          resource: 'user',
+          action: 'create',
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+      ];
+
+      ((permissionService as any).userMapper.selectById as jest.Mock).mockResolvedValue({ id: 1 });
+      ((permissionService as any).userRoleMapper.selectList as jest.Mock).mockResolvedValue(mockUserRoles);
+      ((permissionService as any).rolePermissionMapper.selectList as jest.Mock).mockResolvedValue(mockRolePermissions);
+      ((permissionService as any).permissionMapper.selectById as jest.Mock)
+        .mockResolvedValueOnce(mockPermissions[0])
+        .mockResolvedValueOnce(mockPermissions[1]);
+
+      const result = await permissionService.getUserPermissions(1);
+
+      expect(result).toHaveLength(2);
+      expect(result[0].name).toBe('user:view');
+      expect(result[1].name).toBe('user:create');
+    });
+
+    it('当用户不存在时应该返回空数组', async () => {
+      ((permissionService as any).userMapper.selectById as jest.Mock).mockResolvedValue(null);
+
+      const result = await permissionService.getUserPermissions(999);
+
+      expect(result).toEqual([]);
+    });
+
+    it('应该去重权限', async () => {
+      const mockUserRoles = [
+        { id: 1, userId: 1, roleId: 1, createdAt: new Date() },
+        { id: 2, userId: 1, roleId: 2, createdAt: new Date() },
+      ];
+
+      const mockRolePermissions1 = [
+        { id: 1, roleId: 1, permissionId: 1, createdAt: new Date() },
+      ];
+
+      const mockRolePermissions2 = [
+        { id: 2, roleId: 2, permissionId: 1, createdAt: new Date() },
+      ];
+
+      const mockPermission: Permission = {
+        id: 1,
+        name: 'user:view',
+        description: '查看用户',
+        resource: 'user',
+        action: 'view',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      };
+
+      ((permissionService as any).userMapper.selectById as jest.Mock).mockResolvedValue({ id: 1 });
+      ((permissionService as any).userRoleMapper.selectList as jest.Mock).mockResolvedValue(mockUserRoles);
+      ((permissionService as any).rolePermissionMapper.selectList as jest.Mock)
+        .mockResolvedValueOnce(mockRolePermissions1)
+        .mockResolvedValueOnce(mockRolePermissions2);
+      ((permissionService as any).permissionMapper.selectById as jest.Mock).mockResolvedValue(mockPermission);
+
+      const result = await permissionService.getUserPermissions(1);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].name).toBe('user:view');
+    });
+  });
+
+  describe('hasPermission', () => {
+    it('应该检查用户是否拥有指定权限', async () => {
+      const mockPermissions: Permission[] = [
+        {
+          id: 1,
+          name: 'user:view',
+          description: '查看用户',
+          resource: 'user',
+          action: 'view',
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+      ];
+
+      (permissionService.getUserPermissions as jest.Mock).mockResolvedValue(mockPermissions);
+
+      const result = await permissionService.hasPermission(1, 'user:view');
+
+      expect(result).toBe(true);
+    });
+
+    it('当用户没有指定权限时应该返回 false', async () => {
+      (permissionService.getUserPermissions as jest.Mock).mockResolvedValue([]);
+
+      const result = await permissionService.hasPermission(1, 'user:delete');
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('hasAnyPermission', () => {
+    it('应该检查用户是否拥有任一指定权限', async () => {
+      const mockPermissions: Permission[] = [
+        {
+          id: 1,
+          name: 'user:view',
+          description: '查看用户',
+          resource: 'user',
+          action: 'view',
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+      ];
+
+      (permissionService.getUserPermissions as jest.Mock).mockResolvedValue(mockPermissions);
+
+      const result = await permissionService.hasAnyPermission(1, ['user:delete', 'user:view']);
+
+      expect(result).toBe(true);
+    });
+
+    it('当用户没有任何指定权限时应该返回 false', async () => {
+      (permissionService.getUserPermissions as jest.Mock).mockResolvedValue([]);
+
+      const result = await permissionService.hasAnyPermission(1, ['user:delete', 'user:update']);
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('hasAllPermissions', () => {
+    it('应该检查用户是否拥有所有指定权限', async () => {
+      const mockPermissions: Permission[] = [
+        {
+          id: 1,
+          name: 'user:view',
+          description: '查看用户',
+          resource: 'user',
+          action: 'view',
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+        {
+          id: 2,
+          name: 'user:create',
+          description: '创建用户',
+          resource: 'user',
+          action: 'create',
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+      ];
+
+      (permissionService.getUserPermissions as jest.Mock).mockResolvedValue(mockPermissions);
+
+      const result = await permissionService.hasAllPermissions(1, ['user:view', 'user:create']);
+
+      expect(result).toBe(true);
+    });
+
+    it('当用户缺少任一权限时应该返回 false', async () => {
+      const mockPermissions: Permission[] = [
+        {
+          id: 1,
+          name: 'user:view',
+          description: '查看用户',
+          resource: 'user',
+          action: 'view',
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+      ];
+
+      (permissionService.getUserPermissions as jest.Mock).mockResolvedValue(mockPermissions);
+
+      const result = await permissionService.hasAllPermissions(1, ['user:view', 'user:delete']);
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('findById', () => {
+    it('应该根据 ID 找到权限', async () => {
+      const mockPermission: Permission = {
+        id: 1,
+        name: 'user:view',
+        description: '查看用户',
+        resource: 'user',
+        action: 'view',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      };
+
+      ((permissionService as any).permissionMapper.selectById as jest.Mock).mockResolvedValue(mockPermission);
+
+      const result = await permissionService.findById(1);
+
+      expect(result).toEqual(mockPermission);
+    });
+
+    it('当权限不存在时应该返回 null', async () => {
+      ((permissionService as any).permissionMapper.selectById as jest.Mock).mockResolvedValue(null);
+
+      const result = await permissionService.findById(999);
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('findAll', () => {
+    it('应该获取所有权限', async () => {
+      const mockPermissions: Permission[] = [
+        {
+          id: 1,
+          name: 'user:view',
+          description: '查看用户',
+          resource: 'user',
+          action: 'view',
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+        {
+          id: 2,
+          name: 'user:create',
+          description: '创建用户',
+          resource: 'user',
+          action: 'create',
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+      ];
+
+      ((permissionService as any).permissionMapper.selectList as jest.Mock).mockResolvedValue(mockPermissions);
+
+      const result = await permissionService.findAll();
+
+      expect(result).toHaveLength(2);
+      expect(result[0].name).toBe('user:view');
+      expect(result[1].name).toBe('user:create');
+    });
+  });
+
+  describe('create', () => {
+    it('应该成功创建新权限', async () => {
+      const permissionData = {
+        name: 'user:delete',
+        description: '删除用户',
+        resource: 'user',
+        action: 'delete',
+      };
+
+      const mockCreatedPermission: Permission = {
+        id: 3,
+        name: 'user:delete',
+        description: '删除用户',
+        resource: 'user',
+        action: 'delete',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      };
+
+      ((permissionService as any).permissionMapper.insert as jest.Mock).mockResolvedValue(3);
+      ((permissionService as any).permissionMapper.selectById as jest.Mock).mockResolvedValue(mockCreatedPermission);
+
+      const result = await permissionService.create(permissionData);
+
+      expect(result).toEqual(mockCreatedPermission);
+      expect(((permissionService as any).permissionMapper.insert as jest.Mock)).toHaveBeenCalled();
+    });
+  });
+
+  describe('update', () => {
+    it('应该成功更新权限', async () => {
+      const updateData = {
+        description: '更新后的描述',
+      };
+
+      const mockUpdatedPermission: Permission = {
+        id: 1,
+        name: 'user:view',
+        description: '更新后的描述',
+        resource: 'user',
+        action: 'view',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      };
+
+      ((permissionService as any).permissionMapper.updateById as jest.Mock).mockResolvedValue(1);
+      ((permissionService as any).permissionMapper.selectById as jest.Mock).mockResolvedValue(mockUpdatedPermission);
+
+      const result = await permissionService.update(1, updateData);
+
+      expect(result).toEqual(mockUpdatedPermission);
+      expect(((permissionService as any).permissionMapper.updateById as jest.Mock)).toHaveBeenCalledWith(1, expect.any(Object));
+    });
+  });
+
+  describe('delete', () => {
+    it('应该成功删除权限', async () => {
+      ((permissionService as any).permissionMapper.deleteById as jest.Mock).mockResolvedValue(1);
+
+      const result = await permissionService.delete(1);
+
+      expect(result).toBe(true);
+      expect(((permissionService as any).permissionMapper.deleteById as jest.Mock)).toHaveBeenCalledWith(1);
+    });
+
+    it('当权限不存在时应该返回 false', async () => {
+      ((permissionService as any).permissionMapper.deleteById as jest.Mock).mockResolvedValue(0);
+
+      const result = await permissionService.delete(999);
+
+      expect(result).toBe(false);
+    });
+  });
+});