create-fullstack-scaffold 0.1.0

package/template/src/server/module-permission/__tests__/permission-service-impl.test.ts

@@ -0,0 +1,388 @@
+import { describe, it, expect, beforeEach, beforeAll, afterAll } from 'vitest'
+import { PermissionService } from '../services/permission-service-impl'
+import { roleService } from '../services/role-service'
+import { setupTestDatabase, cleanupTestDatabase } from '@server/db/test-setup'
+
+describe('Permission Service', () => {
+  let service: PermissionService
+
+  beforeAll(async () => {
+    await setupTestDatabase()
+  })
+
+  afterAll(async () => {
+    await cleanupTestDatabase()
+  })
+
+  beforeEach(async () => {
+    service = new PermissionService()
+    // Reset role_user permissions to default state
+    const currentPermissions = await service.getRolePermissions('role_user')
+    for (const perm of currentPermissions) {
+      if (perm.id !== 'perm_content_view' && perm.id !== 'perm_order_view') {
+        await service.revokePermissionFromRole('role_user', perm.id)
+      }
+    }
+  })
+
+  describe('getAll', () => {
+    it('should return all active permissions', async () => {
+      const permissions = await service.getAll()
+      expect(permissions.length).toBeGreaterThan(0)
+      expect(permissions.every(p => p.isActive)).toBe(true)
+    })
+
+    it('should return permissions with correct structure', async () => {
+      const permissions = await service.getAll()
+      const permission = permissions[0]
+      expect(permission).toHaveProperty('id')
+      expect(permission).toHaveProperty('code')
+      expect(permission).toHaveProperty('name')
+      expect(permission).toHaveProperty('label')
+      expect(permission).toHaveProperty('category')
+    })
+
+    it('should return permissions with valid categories', async () => {
+      const permissions = await service.getAll()
+      const validCategories = [
+        'user',
+        'content',
+        'system',
+        'data',
+        'order',
+        'ticket',
+        'dispute',
+        'role',
+      ]
+      expect(permissions.every(p => validCategories.includes(p.category))).toBe(true)
+    })
+  })
+
+  describe('getById', () => {
+    it('should return permission by id', async () => {
+      const permission = await service.getById('perm_user_view')
+      expect(permission).toBeDefined()
+      expect(permission?.code).toBe('user:view')
+    })
+
+    it('should return undefined for non-existent id', async () => {
+      const permission = await service.getById('non-existent-id')
+      expect(permission).toBeUndefined()
+    })
+
+    it('should return permission with all required fields', async () => {
+      const permission = await service.getById('perm_user_view')
+      expect(permission?.id).toBe('perm_user_view')
+      expect(permission?.name).toBe('查看用户')
+      expect(permission?.label).toBe('查看用户')
+      expect(permission?.category).toBe('user')
+    })
+  })
+
+  describe('getByCode', () => {
+    it('should return permission by code', async () => {
+      const permission = await service.getByCode('user:view')
+      expect(permission).toBeDefined()
+      expect(permission?.id).toBe('perm_user_view')
+    })
+
+    it('should return undefined for non-existent code', async () => {
+      const permission = await service.getByCode('non:existent')
+      expect(permission).toBeUndefined()
+    })
+
+    it('should find permission by exact code match', async () => {
+      const permission = await service.getByCode('content:view')
+      expect(permission?.id).toBe('perm_content_view')
+    })
+  })
+
+  describe('getByCategory', () => {
+    it('should return permissions by category', async () => {
+      const permissions = await service.getByCategory('user')
+      expect(permissions.length).toBeGreaterThan(0)
+      expect(permissions.every(p => p.category === 'user')).toBe(true)
+    })
+
+    it('should return empty array for non-existent category', async () => {
+      const permissions = await service.getByCategory('non-existent')
+      expect(permissions).toEqual([])
+    })
+
+    it('should return all permissions for each valid category', async () => {
+      const categories = ['user', 'content', 'system', 'data', 'order', 'ticket']
+      for (const category of categories) {
+        const permissions = await service.getByCategory(category)
+        expect(permissions.length).toBeGreaterThan(0)
+      }
+    })
+  })
+
+  describe('getRolePermissions', () => {
+    it('should return permissions for super admin role', async () => {
+      const permissions = await service.getRolePermissions('role_super_admin')
+      expect(permissions.length).toBeGreaterThan(0)
+    })
+
+    it('should return permissions for customer service role', async () => {
+      const permissions = await service.getRolePermissions('role_customer_service')
+      expect(permissions.length).toBeGreaterThan(0)
+    })
+
+    it('should return permissions for user role', async () => {
+      const permissions = await service.getRolePermissions('role_user')
+      expect(permissions.length).toBeGreaterThan(0)
+    })
+
+    it('should return empty array for non-existent role', async () => {
+      const permissions = await service.getRolePermissions('non-existent')
+      expect(permissions).toEqual([])
+    })
+
+    it('should return only active permissions', async () => {
+      const permissions = await service.getRolePermissions('role_super_admin')
+      expect(permissions.every(p => p.isActive)).toBe(true)
+    })
+
+    it('should return permissions with correct permission IDs', async () => {
+      const permissions = await service.getRolePermissions('role_customer_service')
+      const permissionIds = permissions.map(p => p.id)
+      expect(permissionIds).toContain('perm_user_view')
+      expect(permissionIds).toContain('perm_content_view')
+    })
+  })
+
+  describe('getUserPermissions', () => {
+    it('should return empty array when roleCode is not provided', async () => {
+      const permissions = await service.getUserPermissions('user-123')
+      expect(permissions).toEqual([])
+    })
+
+    it('should return empty array when roleCode is empty string', async () => {
+      const permissions = await service.getUserPermissions('user-123', '')
+      expect(permissions).toEqual([])
+    })
+
+    it('should return permissions for valid role code', async () => {
+      const permissions = await service.getUserPermissions('user-123', 'customer_service')
+      expect(permissions.length).toBeGreaterThan(0)
+    })
+
+    it('should return empty array for non-existent role code', async () => {
+      const permissions = await service.getUserPermissions('user-123', 'non-existent')
+      expect(permissions).toEqual([])
+    })
+
+    it('should return same permissions as getRolePermissions', async () => {
+      const role = await roleService.getByCode('customer_service')
+      const userPermissions = await service.getUserPermissions('user-123', 'customer_service')
+      const rolePermissions = await service.getRolePermissions(role?.id as string)
+      expect(userPermissions.length).toBe(rolePermissions.length)
+    })
+
+    it('should return all permissions for super admin', async () => {
+      const permissions = await service.getUserPermissions('user-123', 'super_admin')
+      expect(permissions.length).toBeGreaterThan(0)
+    })
+
+    it('should return limited permissions for user role', async () => {
+      const permissions = await service.getUserPermissions('user-123', 'user')
+      expect(permissions.length).toBeGreaterThan(0)
+      expect(permissions.length).toBeLessThan(20)
+    })
+  })
+
+  describe('hasPermission', () => {
+    it('should return true when user has permission', async () => {
+      const hasPermission = await service.hasPermission(
+        'test-customer-service-1',
+        'user:view',
+        'customer_service'
+      )
+      expect(hasPermission).toBe(true)
+    })
+
+    it('should return false when user does not have permission', async () => {
+      const hasPermission = await service.hasPermission('test-user-1', 'user:view', 'user')
+      expect(hasPermission).toBe(false)
+    })
+
+    it('should check permission by code', async () => {
+      const hasPermission = await service.hasPermission(
+        'test-customer-service-1',
+        'content:view',
+        'customer_service'
+      )
+      expect(hasPermission).toBe(true)
+    })
+  })
+
+  describe('assignPermissionToRole', () => {
+    it('should assign permission to role', async () => {
+      await service.assignPermissionToRole('role_user', 'perm_user_create')
+      const permissions = await service.getRolePermissions('role_user')
+      const permissionIds = permissions.map(p => p.id)
+      expect(permissionIds).toContain('perm_user_create')
+    })
+
+    it('should not duplicate permission assignment', async () => {
+      await service.assignPermissionToRole('role_user', 'perm_user_view')
+      await service.assignPermissionToRole('role_user', 'perm_user_view')
+      const permissions = await service.getRolePermissions('role_user')
+      const viewPermissions = permissions.filter(p => p.id === 'perm_user_view')
+      expect(viewPermissions.length).toBe(1)
+    })
+
+    it('should allow assigning multiple permissions', async () => {
+      await service.assignPermissionToRole('role_user', 'perm_user_create')
+      await service.assignPermissionToRole('role_user', 'perm_user_update')
+      const permissions = await service.getRolePermissions('role_user')
+      const permissionIds = permissions.map(p => p.id)
+      expect(permissionIds).toContain('perm_user_create')
+      expect(permissionIds).toContain('perm_user_update')
+    })
+  })
+
+  describe('revokePermissionFromRole', () => {
+    it('should revoke permission from role', async () => {
+      await service.assignPermissionToRole('role_user', 'perm_user_create')
+      await service.revokePermissionFromRole('role_user', 'perm_user_create')
+      const permissions = await service.getRolePermissions('role_user')
+      const permissionIds = permissions.map(p => p.id)
+      expect(permissionIds).not.toContain('perm_user_create')
+    })
+
+    it('should handle revoking non-existent permission', async () => {
+      await service.revokePermissionFromRole('role_user', 'non-existent-permission')
+      const permissions = await service.getRolePermissions('role_user')
+      expect(permissions).toBeDefined()
+    })
+
+    it('should only revoke specified permission', async () => {
+      await service.assignPermissionToRole('role_user', 'perm_user_create')
+      await service.assignPermissionToRole('role_user', 'perm_user_update')
+      await service.revokePermissionFromRole('role_user', 'perm_user_create')
+      const permissions = await service.getRolePermissions('role_user')
+      const permissionIds = permissions.map(p => p.id)
+      expect(permissionIds).not.toContain('perm_user_create')
+      expect(permissionIds).toContain('perm_user_update')
+    })
+  })
+
+  describe('Permission Dependencies', () => {
+    it('should have user:view permission for customer service', async () => {
+      const permissions = await service.getRolePermissions('role_customer_service')
+      const permissionCodes = permissions.map(p => p.code)
+      expect(permissionCodes).toContain('user:view')
+    })
+
+    it('should have content:view permission for customer service', async () => {
+      const permissions = await service.getRolePermissions('role_customer_service')
+      const permissionCodes = permissions.map(p => p.code)
+      expect(permissionCodes).toContain('content:view')
+    })
+
+    it('should have order permissions for customer service', async () => {
+      const permissions = await service.getRolePermissions('role_customer_service')
+      const permissionCodes = permissions.map(p => p.code)
+      expect(permissionCodes).toContain('order:view')
+      expect(permissionCodes).toContain('order:process')
+    })
+
+    it('should have ticket permissions for customer service', async () => {
+      const permissions = await service.getRolePermissions('role_customer_service')
+      const permissionCodes = permissions.map(p => p.code)
+      expect(permissionCodes).toContain('ticket:view')
+      expect(permissionCodes).toContain('ticket:reply')
+      expect(permissionCodes).toContain('ticket:close')
+    })
+
+    it('should have limited permissions for user role', async () => {
+      const permissions = await service.getRolePermissions('role_user')
+      const permissionCodes = permissions.map(p => p.code)
+      expect(permissionCodes).toContain('content:view')
+      expect(permissionCodes).toContain('order:view')
+      expect(permissionCodes).not.toContain('user:view')
+    })
+
+    it('should have all permissions for super admin', async () => {
+      const permissions = await service.getRolePermissions('role_super_admin')
+      const permissionCodes = permissions.map(p => p.code)
+      expect(permissionCodes).toContain('user:view')
+      expect(permissionCodes).toContain('user:create')
+      expect(permissionCodes).toContain('content:view')
+      expect(permissionCodes).toContain('system:settings')
+    })
+  })
+
+  describe('Permission Categories', () => {
+    it('should have correct number of user permissions', async () => {
+      const permissions = await service.getByCategory('user')
+      expect(permissions.length).toBe(4)
+    })
+
+    it('should have correct number of content permissions', async () => {
+      const permissions = await service.getByCategory('content')
+      expect(permissions.length).toBe(4)
+    })
+
+    it('should have correct number of system permissions', async () => {
+      const permissions = await service.getByCategory('system')
+      expect(permissions.length).toBe(3)
+    })
+
+    it('should have correct number of order permissions', async () => {
+      const permissions = await service.getByCategory('order')
+      expect(permissions.length).toBe(5)
+    })
+
+    it('should have correct number of ticket permissions', async () => {
+      const permissions = await service.getByCategory('ticket')
+      expect(permissions.length).toBe(6)
+    })
+
+    it('should have correct number of data permissions', async () => {
+      const permissions = await service.getByCategory('data')
+      expect(permissions.length).toBe(2)
+    })
+  })
+
+  describe('Edge Cases', () => {
+    it('should handle empty role permissions', async () => {
+      const permissions = await service.getRolePermissions('non-existent-role')
+      expect(permissions).toEqual([])
+    })
+
+    it('should handle assigning permission to non-existent role gracefully', async () => {
+      // 由于外键约束，无法向不存在的角色分配权限
+      // 测试应该验证服务层是否正确处理这种情况
+      try {
+        await service.assignPermissionToRole('non-existent-role', 'perm_user_view')
+        // 如果成功，验证权限是否被分配
+        const permissions = await service.getRolePermissions('non-existent-role')
+        expect(permissions.length).toBe(0)
+      } catch (error) {
+        // 如果抛出错误，验证是外键约束错误
+        expect(error).toBeDefined()
+      }
+    })
+
+    it('should handle revoking from empty role', async () => {
+      await service.revokePermissionFromRole('non-existent-role', 'perm_user_view')
+      const permissions = await service.getRolePermissions('non-existent-role')
+      expect(permissions).toEqual([])
+    })
+
+    it('should handle multiple assignments and revocations', async () => {
+      await service.assignPermissionToRole('role_user', 'perm_user_view')
+      await service.assignPermissionToRole('role_user', 'perm_user_create')
+      await service.assignPermissionToRole('role_user', 'perm_user_update')
+      await service.revokePermissionFromRole('role_user', 'perm_user_create')
+      const permissions = await service.getRolePermissions('role_user')
+      const permissionIds = permissions.map(p => p.id)
+      expect(permissionIds).toContain('perm_user_view')
+      expect(permissionIds).toContain('perm_user_update')
+      expect(permissionIds).not.toContain('perm_user_create')
+    })
+  })
+})

package/template/src/server/module-permission/__tests__/permission-service.test.ts

@@ -0,0 +1,190 @@
+import { describe, it, expect } from 'vitest'
+import * as service from '../services/permission-service'
+import { Role } from '@shared/modules/permission'
+import * as fs from 'fs'
+import * as path from 'path'
+
+describe('Permission Service', () => {
+  describe('getAllRoles', () => {
+    it('should return all roles', () => {
+      const result = service.getAllRoles()
+      expect(Array.isArray(result)).toBe(true)
+      expect(result.length).toBe(3)
+      expect(result[0]).toHaveProperty('role')
+      expect(result[0]).toHaveProperty('label')
+      expect(result[0]).toHaveProperty('permissions')
+    })
+
+    it('should contain correct role values', () => {
+      const result = service.getAllRoles()
+      const roles = result.map(r => r.role)
+      expect(roles).toContain(Role.SUPER_ADMIN)
+      expect(roles).toContain(Role.CUSTOMER_SERVICE)
+      expect(roles).toContain(Role.USER)
+    })
+  })
+
+  describe('getAllPermissions', () => {
+    it('should return all permissions', () => {
+      const result = service.getAllPermissions()
+      expect(Array.isArray(result)).toBe(true)
+      expect(result.length).toBeGreaterThan(0)
+      expect(result[0]).toHaveProperty('permission')
+      expect(result[0]).toHaveProperty('label')
+      expect(result[0]).toHaveProperty('category')
+    })
+
+    it('should have valid category values', () => {
+      const result = service.getAllPermissions()
+      const categories = result.map(r => r.category)
+      // 从 PERMISSION_CATEGORIES 中提取的所有有效分类
+      const validCategories = [
+        'user',
+        'content',
+        'system',
+        'data',
+        'order',
+        'ticket',
+        'role',
+        'dispute',
+        'notification',
+        'todo',
+        'chat',
+        'other',
+      ]
+      categories.forEach(cat => {
+        expect(validCategories).toContain(cat)
+      })
+    })
+  })
+
+  describe('getUserPermissions', () => {
+    it('should return user permissions for super admin', () => {
+      const result = service.getUserPermissions('user-1', Role.SUPER_ADMIN)
+      expect(result).toHaveProperty('userId', 'user-1')
+      expect(result).toHaveProperty('role', Role.SUPER_ADMIN)
+      expect(result.permissions.length).toBeGreaterThan(0)
+    })
+
+    it('should return user permissions for customer service', () => {
+      const result = service.getUserPermissions('user-2', Role.CUSTOMER_SERVICE)
+      expect(result).toHaveProperty('userId', 'user-2')
+      expect(result).toHaveProperty('role', Role.CUSTOMER_SERVICE)
+      expect(result.permissions.length).toBeGreaterThan(0)
+    })
+
+    it('should return user permissions for regular user', () => {
+      const result = service.getUserPermissions('user-3', Role.USER)
+      expect(result).toHaveProperty('userId', 'user-3')
+      expect(result).toHaveProperty('role', Role.USER)
+      expect(result.permissions.length).toBeGreaterThan(0)
+    })
+
+    it('should return different permission counts for different roles', () => {
+      const superAdminPermissions = service.getUserPermissions('user-1', Role.SUPER_ADMIN)
+      const customerServicePermissions = service.getUserPermissions('user-2', Role.CUSTOMER_SERVICE)
+      const userPermissions = service.getUserPermissions('user-3', Role.USER)
+
+      expect(superAdminPermissions.permissions.length).toBeGreaterThan(
+        customerServicePermissions.permissions.length
+      )
+      expect(customerServicePermissions.permissions.length).toBeGreaterThan(
+        userPermissions.permissions.length
+      )
+    })
+  })
+
+  describe('Error Scenarios', () => {
+    it('should handle empty userId gracefully', () => {
+      const result = service.getUserPermissions('', Role.USER)
+      expect(result).not.toBeNull()
+      expect(result.userId).toBe('')
+      expect(result.permissions.length).toBeGreaterThan(0)
+    })
+
+    it('should handle unknown role gracefully', () => {
+      const result = service.getUserPermissions('user-unknown', 'unknown_role' as Role)
+      expect(result).not.toBeNull()
+      expect(result).toHaveProperty('userId')
+      expect(result).toHaveProperty('role')
+      expect(Array.isArray(result.permissions)).toBe(true)
+    })
+
+    it('should return empty permissions for invalid role', () => {
+      const result = service.getUserPermissions('user-test', 'invalid' as Role)
+      expect(result).toBeDefined()
+      expect(result.permissions).toBeDefined()
+      expect(Array.isArray(result.permissions)).toBe(true)
+    })
+
+    it('should handle null role parameter', () => {
+      expect(() => {
+        service.getUserPermissions('user-test', null as unknown as Role)
+      }).not.toThrow()
+    })
+  })
+
+  describe('Naming Convention Compliance', () => {
+    it('should not use "-new" or "-old" suffix in service file names', () => {
+      const servicesDir = path.join(__dirname, '../services')
+      const files = fs.readdirSync(servicesDir)
+
+      const invalidPatterns = ['-new', '-old', 'new-', 'old-', '.new.', '.old.']
+      const invalidFiles: string[] = []
+
+      files.forEach(file => {
+        const lowerFile = file.toLowerCase()
+        invalidPatterns.forEach(pattern => {
+          if (lowerFile.includes(pattern)) {
+            invalidFiles.push(file)
+          }
+        })
+      })
+
+      expect(invalidFiles).toEqual([])
+    })
+
+    it('should use V1, V2, V3 naming convention instead of new/old', () => {
+      const servicesDir = path.join(__dirname, '../services')
+      const files = fs.readdirSync(servicesDir)
+
+      const validVersionPattern = /V[1-9][0-9]?/
+      const invalidNamingFiles: string[] = []
+
+      files.forEach(file => {
+        const lowerFile = file.toLowerCase()
+        if (lowerFile.includes('new') || lowerFile.includes('old')) {
+          if (!validVersionPattern.test(file)) {
+            invalidNamingFiles.push(file)
+          }
+        }
+      })
+
+      expect(invalidNamingFiles).toEqual([])
+    })
+
+    it('should not contain forbidden naming patterns in any service file content', () => {
+      const servicesDir = path.join(__dirname, '../services')
+      const files = fs.readdirSync(servicesDir).filter(f => f.endsWith('.ts'))
+
+      // 使用字符拼接构造检查模式，避免 ESLint 误报
+      const pattern1 = '干' + 'new'
+      const pattern2 = '干' + 'old'
+      const forbiddenPatterns = [pattern1, pattern2]
+      const violations: { file: string; pattern: string }[] = []
+
+      files.forEach(file => {
+        const filePath = path.join(servicesDir, file)
+        const content = fs.readFileSync(filePath, 'utf-8')
+
+        forbiddenPatterns.forEach(pattern => {
+          if (content.includes(pattern)) {
+            violations.push({ file, pattern })
+          }
+        })
+      })
+
+      expect(violations).toEqual([])
+    })
+  })
+})