create-dp-koa 1.0.0

package/template/test/framework/databaseConfig.test.ts

@@ -0,0 +1,142 @@
+import { databaseConfigManager } from '../../src/framework/utils/databaseConfig';
+
+describe('数据库配置管理测试', () => {
+    beforeEach(() => {
+        // 重置环境变量
+        delete process.env.db_enable;
+        delete process.env.db_memory;
+    });
+
+    describe('数据库启用检查', () => {
+        test('应该正确检测数据库是否启用', () => {
+            process.env.db_enable = '1';
+            expect(databaseConfigManager.isDatabaseEnabled()).toBe(true);
+
+            process.env.db_enable = '0';
+            expect(databaseConfigManager.isDatabaseEnabled()).toBe(false);
+
+            delete process.env.db_enable;
+            expect(databaseConfigManager.isDatabaseEnabled()).toBe(false);
+        });
+    });
+
+    describe('内存数据库模式检查', () => {
+        test('应该正确检测内存数据库模式', () => {
+            process.env.db_memory = '1';
+            expect(databaseConfigManager.isMemoryDatabaseMode()).toBe(true);
+
+            process.env.db_memory = '0';
+            expect(databaseConfigManager.isMemoryDatabaseMode()).toBe(false);
+
+            delete process.env.db_memory;
+            expect(databaseConfigManager.isMemoryDatabaseMode()).toBe(false);
+        });
+    });
+
+    describe('数据库配置生成', () => {
+        test('应该生成内存数据库配置', () => {
+            process.env.db_memory = '1';
+            const entities = [{ name: 'TestEntity' }];
+            const config = databaseConfigManager.getDatabaseConfig(entities);
+
+            expect(config.type).toBe('sqlite');
+            expect(config.database).toBe(':memory:');
+            expect(config.entities).toEqual(entities);
+            expect(config.synchronize).toBe(true);
+            expect(config.dropSchema).toBe(true);
+        });
+
+        test('应该生成 PostgreSQL 数据库配置', () => {
+            process.env.db_memory = '0';
+            process.env.db_type = 'postgres';
+            process.env.db_host = 'localhost';
+            process.env.db_port = '5432';
+            process.env.db_username = 'testuser';
+            process.env.db_password = 'testpass';
+            process.env.db_database = 'testdb';
+
+            const entities = [{ name: 'TestEntity' }];
+            const config = databaseConfigManager.getDatabaseConfig(entities);
+
+            expect(config.type).toBe('postgres');
+            expect((config as any).host).toBe('localhost');
+            expect((config as any).port).toBe(5432);
+            expect((config as any).username).toBe('testuser');
+            expect((config as any).password).toBe('testpass');
+            expect((config as any).database).toBe('testdb');
+            expect(config.entities).toEqual(entities);
+            expect(config.synchronize).toBe(true);
+        });
+
+        test('应该生成 MySQL 数据库配置', () => {
+            process.env.db_memory = '0';
+            process.env.db_type = 'mysql';
+            process.env.db_host = 'localhost';
+            process.env.db_port = '3306';
+            process.env.db_username = 'testuser';
+            process.env.db_password = 'testpass';
+            process.env.db_database = 'testdb';
+
+            const entities = [{ name: 'TestEntity' }];
+            const config = databaseConfigManager.getDatabaseConfig(entities);
+
+            expect(config.type).toBe('mysql');
+            expect((config as any).host).toBe('localhost');
+            expect((config as any).port).toBe(3306);
+            expect((config as any).username).toBe('testuser');
+            expect((config as any).password).toBe('testpass');
+            expect((config as any).database).toBe('testdb');
+            expect(config.entities).toEqual(entities);
+            expect(config.synchronize).toBe(true);
+        });
+
+        test('应该使用默认 PostgreSQL 配置（未设置 db_type 时）', () => {
+            process.env.db_memory = '0';
+            delete process.env.db_type;
+            delete process.env.db_host;
+            delete process.env.db_port;
+            delete process.env.db_username;
+            delete process.env.db_password;
+            delete process.env.db_database;
+
+            const entities = [{ name: 'TestEntity' }];
+            const config = databaseConfigManager.getDatabaseConfig(entities);
+
+            expect(config.type).toBe('postgres');
+            expect((config as any).host).toBe('127.0.0.1');
+            expect((config as any).port).toBe(5432);
+            expect((config as any).username).toBe('admin');
+            expect((config as any).database).toBe('mydb');
+        });
+    });
+
+    describe('数据库类型描述', () => {
+        test('应该返回正确的数据库类型描述', () => {
+            process.env.db_memory = '1';
+            expect(databaseConfigManager.getDatabaseTypeDescription()).toBe('内存数据库（SQLite）');
+
+            process.env.db_memory = '0';
+            process.env.db_type = 'postgres';
+            expect(databaseConfigManager.getDatabaseTypeDescription()).toBe('PostgreSQL');
+
+            process.env.db_type = 'mysql';
+            expect(databaseConfigManager.getDatabaseTypeDescription()).toBe('MySQL');
+        });
+    });
+
+    describe('数据库监控检查', () => {
+        test('应该正确判断是否需要数据库监控', () => {
+            process.env.db_enable = '1';
+            process.env.db_memory = '1';
+            expect(databaseConfigManager.needsDatabaseMonitoring()).toBe(false);
+
+            process.env.db_enable = '1';
+            process.env.db_memory = '0';
+            expect(databaseConfigManager.needsDatabaseMonitoring()).toBe(true);
+
+            process.env.db_enable = '0';
+            process.env.db_memory = '0';
+            expect(databaseConfigManager.needsDatabaseMonitoring()).toBe(false);
+        });
+    });
+});

package/template/test/integration/integration.test.ts

@@ -0,0 +1,153 @@
+import { TestDatabaseHelper, TestUtils } from '../utils/testHelpers';
+import { testDataInitializer } from '../../src/utils/testDataInitializer';
+
+describe('集成测试', () => {
+    beforeAll(async () => {
+        await TestDatabaseHelper.initTestDatabase();
+    });
+
+    afterAll(async () => {
+        await TestDatabaseHelper.cleanupTestDatabase();
+    });
+
+    describe('测试数据初始化测试', () => {
+        test('应该能够初始化测试数据', async () => {
+            await TestDatabaseHelper.resetTestData();
+            
+            const dataSource = TestDatabaseHelper.getTestDataSource();
+            expect(dataSource).toBeDefined();
+
+            // 检查用户数据
+            const users = await dataSource!.query('SELECT * FROM yt_user');
+            expect(users.length).toBeGreaterThan(0);
+            expect(users[0].nickName).toBe('测试用户1');
+
+            // 检查店铺数据
+            const shops = await dataSource!.query('SELECT * FROM shop');
+            expect(shops.length).toBeGreaterThan(0);
+            expect(shops[0].name).toBe('测试店铺1');
+
+            // 检查商品数据
+            const goods = await dataSource!.query('SELECT * FROM yt_goods');
+            expect(goods.length).toBeGreaterThan(0);
+            expect(goods[0].name).toBe('测试商品1');
+
+            // 检查解锁密钥数据
+            const unlockKeys = await dataSource!.query('SELECT * FROM goods_images_unlock_key');
+            expect(unlockKeys.length).toBeGreaterThan(0);
+            expect(unlockKeys[0].key).toBe('TEST_KEY_001');
+        });
+
+        test('应该能够清空测试数据', async () => {
+            await testDataInitializer.clearTestData();
+            
+            const dataSource = TestDatabaseHelper.getTestDataSource();
+            
+            // 检查所有表都应该为空
+            const users = await dataSource!.query('SELECT COUNT(*) as count FROM yt_user');
+            const shops = await dataSource!.query('SELECT COUNT(*) as count FROM shop');
+            const goods = await dataSource!.query('SELECT COUNT(*) as count FROM yt_goods');
+            const unlockKeys = await dataSource!.query('SELECT COUNT(*) as count FROM goods_images_unlock_key');
+
+            expect(users[0].count).toBe(0);
+            expect(shops[0].count).toBe(0);
+            expect(goods[0].count).toBe(0);
+            expect(unlockKeys[0].count).toBe(0);
+        });
+
+        test('应该能够重新初始化测试数据', async () => {
+            // 先清空
+            await testDataInitializer.clearTestData();
+            
+            // 再初始化
+            await testDataInitializer.initializeTestData();
+            
+            const dataSource = TestDatabaseHelper.getTestDataSource();
+            
+            // 检查数据是否重新创建
+            const users = await dataSource!.query('SELECT COUNT(*) as count FROM yt_user');
+            const shops = await dataSource!.query('SELECT COUNT(*) as count FROM shop');
+            const goods = await dataSource!.query('SELECT COUNT(*) as count FROM yt_goods');
+
+            expect(users[0].count).toBeGreaterThan(0);
+            expect(shops[0].count).toBeGreaterThan(0);
+            expect(goods[0].count).toBeGreaterThan(0);
+        });
+    });
+
+    describe('数据库连接测试', () => {
+        test('应该能够建立数据库连接', () => {
+            const dataSource = TestDatabaseHelper.getTestDataSource();
+            expect(dataSource).toBeDefined();
+            expect(dataSource!.isInitialized).toBe(true);
+        });
+
+        test('应该能够执行SQL查询', async () => {
+            const dataSource = TestDatabaseHelper.getTestDataSource();
+            const result = await dataSource!.query('SELECT 1 as test');
+            expect(result).toBeDefined();
+            expect(result[0].test).toBe(1);
+        });
+
+        test('应该能够执行复杂查询', async () => {
+            const dataSource = TestDatabaseHelper.getTestDataSource();
+            
+            // 查询用户和店铺的关联信息
+            const result = await dataSource!.query(`
+                SELECT 
+                    u.nickName,
+                    s.name as shopName
+                FROM yt_user u
+                JOIN shop_and_user su ON u.id = su.userId
+                JOIN shop s ON su.shopId = s.id
+                WHERE u.id = 1
+            `);
+            
+            expect(result).toBeDefined();
+            expect(result.length).toBeGreaterThan(0);
+            expect(result[0].nickName).toBe('测试用户1');
+            expect(result[0].shopName).toBe('测试店铺1');
+        });
+    });
+
+    describe('缓存集成测试', () => {
+        test('应该能够与数据库配合使用缓存', async () => {
+            const { createCache, CacheType } = require('../../src/framework/utils/cache');
+            const cache = createCache('integration-test', CacheType.TEMP);
+            
+            // 从数据库获取数据
+            const dataSource = TestDatabaseHelper.getTestDataSource();
+            const users = await dataSource!.query('SELECT * FROM yt_user LIMIT 1');
+            
+            // 将数据存入缓存
+            const cacheKey = `user_${users[0].id}`;
+            cache.set(cacheKey, users[0]);
+            
+            // 从缓存获取数据
+            const cachedUser = cache.get(cacheKey);
+            expect(cachedUser).toBeDefined();
+            expect(cachedUser.id).toBe(users[0].id);
+            expect(cachedUser.nickName).toBe(users[0].nickName);
+        });
+    });
+
+    describe('错误处理测试', () => {
+        test('应该能够处理数据库错误', async () => {
+            const dataSource = TestDatabaseHelper.getTestDataSource();
+            
+            // 尝试执行无效的SQL
+            await expect(
+                dataSource!.query('SELECT * FROM non_existent_table')
+            ).rejects.toThrow();
+        });
+
+        test('应该能够处理无效的数据操作', async () => {
+            const dataSource = TestDatabaseHelper.getTestDataSource();
+            
+            // 尝试插入无效数据
+            await expect(
+                dataSource!.query('INSERT INTO yt_user (invalid_column) VALUES (?)', ['test'])
+            ).rejects.toThrow();
+        });
+    });
+});

package/template/test/plugins/weboffice/http.routes.int.test.ts

@@ -0,0 +1,61 @@
+jest.mock("uuid", () => ({ v4: () => "test-uuid" }));
+
+import Koa from "koa";
+import Router from "koa-router";
+import request from "supertest";
+import { TestDatabaseHelper } from "../../utils/testHelpers";
+import { plugin as webofficePlugin } from "@src/plugins/weboffice";
+import { WebofficeFileEntity, WebofficeFileVersionEntity } from "@src/plugins/weboffice/entities";
+
+describe("weboffice http/routes (integration)", () => {
+  beforeAll(async () => {
+    await TestDatabaseHelper.initTestDatabase({
+      extraEntities: [WebofficeFileEntity, WebofficeFileVersionEntity],
+    });
+  });
+
+  afterAll(async () => {
+    await TestDatabaseHelper.cleanupTestDatabase();
+  });
+
+  it("GET /v3/3rd/files/:file_id/permission should return permissions", async () => {
+    const ds = TestDatabaseHelper.getTestDataSource();
+    if (!ds) throw new Error("test datasource not initialized");
+
+    const fileRepo = ds.getRepository(WebofficeFileEntity);
+    const versionRepo = ds.getRepository(WebofficeFileVersionEntity);
+
+    const file = await fileRepo.save({
+      fileId: "testfile01",
+      name: "测试文档.docx",
+      creatorId: "seed",
+      modifierId: "seed",
+      currentVersion: 1,
+      projectId: null,
+    });
+    await versionRepo.save({
+      webofficeFileId: file.id,
+      version: 1,
+      size: 0,
+      digest: "",
+      cosKey: "",
+      creatorId: "seed",
+    });
+
+    const app = new Koa();
+    const router = new Router();
+    webofficePlugin.registerRoutes?.(router);
+    app.use(router.routes()).use(router.allowedMethods());
+
+    const res = await request(app.callback())
+      .get("/v3/3rd/files/testfile01/permission")
+      .set("X-WebOffice-Token", "test-token")
+      .set("X-App-ID", "app");
+
+    expect(res.status).toBe(200);
+    expect(res.body.code).toBe(0);
+    expect(res.body.data.user_id).toBe("test_token");
+    expect(res.body.data.read).toBe(1);
+  });
+});
+

package/template/test/service/business.test.ts

@@ -0,0 +1,87 @@
+import { TestDatabaseHelper, TestUtils } from '../utils/testHelpers';
+import { YtUserService } from '../../src/service/ytUser.service';
+import { YtShopService } from '../../src/service/ytShop.service';
+import { YtGoodsService } from '../../src/service/ytGoods.service';
+import { Provider } from 'dp-ioc2';
+
+describe('业务服务测试', () => {
+    beforeAll(async () => {
+        await TestDatabaseHelper.initTestDatabase();
+    });
+
+    afterAll(async () => {
+        await TestDatabaseHelper.cleanupTestDatabase();
+    });
+
+    beforeEach(async () => {
+        await TestDatabaseHelper.resetTestData();
+    });
+
+    describe('店铺服务测试', () => {
+        let shopService: YtShopService;
+
+        beforeEach(() => {
+            shopService = Provider(YtShopService);
+        });
+
+        test('应该能够获取店铺商品列表', async () => {
+            const result = await shopService.getGoodsListByShopId(1, 1, 10);
+            expect(result.code).toBe('SUCCESS');
+            expect(result.data).toBeDefined();
+            expect(Array.isArray(result.data?.[0])).toBe(true);
+            expect(typeof result.data?.[1]).toBe('number');
+        });
+
+        test('应该能够获取店铺用户信息', async () => {
+            const result = await shopService.getShopUserInfo(1);
+            expect(result.code).toBe('SUCCESS');
+            expect(result.data).toBeDefined();
+            expect(result.data?.id).toBeDefined();
+            expect(result.data?.nickName).toBeDefined();
+        });
+
+        test('应该能够检查用户是否有店铺', async () => {
+            const result = await shopService.checkHasShop(1);
+            expect(result.code).toBe('SUCCESS');
+            expect(result.data).toBeDefined();
+            expect(typeof result.data).toBe('number');
+        });
+
+        test('应该返回null当用户没有店铺时', async () => {
+            const result = await shopService.checkHasShop(999);
+            expect(result.code).toBe('SUCCESS');
+            expect(result.data).toBeNull();
+        });
+    });
+
+    describe('商品服务测试', () => {
+        let goodsService: YtGoodsService;
+
+        beforeEach(() => {
+            goodsService = Provider(YtGoodsService);
+        });
+
+        test('应该能够解锁商品图片', async () => {
+            const result = await goodsService.unlockGoodsImage(1, 1, 'TEST_KEY_001');
+            expect(result.code).toBe('SUCCESS');
+            expect(result.data).toBe(true);
+        });
+
+        test('应该拒绝无效的解锁密钥', async () => {
+            const result = await goodsService.unlockGoodsImage(1, 1, 'INVALID_KEY');
+            expect(result.code).toBe('FAIL');
+            expect(result.data).toBe(false);
+            expect(result.message).toBe('无效的解锁key');
+        });
+
+        test('应该拒绝已使用的解锁密钥', async () => {
+            // 先使用一次密钥
+            await goodsService.unlockGoodsImage(3, 1, 'USED_KEY_001');
+            
+            // 再次使用应该失败
+            const result = await goodsService.unlockGoodsImage(3, 1, 'USED_KEY_001');
+            expect(result.code).toBe('FAIL');
+            expect(result.data).toBe(false);
+        });
+    });
+});

package/template/test/service/paramValidateTest.service.test.ts

@@ -0,0 +1,184 @@
+/**
+ * 参数校验测试
+ * 测试 dp-ioc2 的 @ParamValidate 装饰器功能
+ */
+
+import { Provider } from 'dp-ioc2';
+import { ParamValidateTestService, CreateTestUserDto, UpdateTestUserDto } from '../../src/service/paramValidateTest.service';
+import { TestDatabaseHelper } from '../utils/testHelpers';
+import { IOCValidationError } from 'dp-ioc2';
+
+describe('ParamValidate 参数校验测试', () => {
+    let service: ParamValidateTestService;
+
+    beforeAll(async () => {
+        // 初始化测试数据库
+        await TestDatabaseHelper.initTestDatabase();
+        
+        // 使用 Provider 实例化 Service（dp-ioc2 要求）
+        service = Provider<ParamValidateTestService>(ParamValidateTestService);
+    });
+
+    afterAll(async () => {
+        await TestDatabaseHelper.cleanupTestDatabase();
+    });
+
+    describe('测试1：对象参数校验（class-validator）', () => {
+        test('应该能够成功创建用户（参数有效）', async () => {
+            const dto: CreateTestUserDto = {
+                name: '测试用户',
+                email: 'test@example.com',
+                age: 25
+            };
+
+            const result = await service.createUser(dto);
+
+            expect(result.code).toBe('SUCCESS');
+            expect(result.data).toBeDefined();
+            expect(result.data?.name).toBe('测试用户');
+            expect(result.data?.email).toBe('test@example.com');
+            expect(result.data?.age).toBe(25);
+        });
+
+        test('应该拒绝无效的用户名（长度不足）', async () => {
+            const dto: CreateTestUserDto = {
+                name: 'ab', // 长度不足3
+                email: 'test@example.com',
+                age: 25
+            };
+
+            // @ParamValidate 在方法调用前就抛出异常，需要在调用方捕获
+            await expect(service.createUser(dto)).rejects.toThrow(IOCValidationError);
+        });
+
+        test('应该拒绝无效的邮箱格式', async () => {
+            const dto: CreateTestUserDto = {
+                name: '测试用户',
+                email: 'invalid-email', // 无效邮箱
+                age: 25
+            };
+
+            await expect(service.createUser(dto)).rejects.toThrow(IOCValidationError);
+        });
+
+        test('应该拒绝年龄小于18', async () => {
+            const dto: CreateTestUserDto = {
+                name: '测试用户',
+                email: 'test@example.com',
+                age: 17 // 小于18
+            };
+
+            await expect(service.createUser(dto)).rejects.toThrow(IOCValidationError);
+        });
+
+        test('应该拒绝年龄大于100', async () => {
+            const dto: CreateTestUserDto = {
+                name: '测试用户',
+                email: 'test@example.com',
+                age: 101 // 大于100
+            };
+
+            await expect(service.createUser(dto)).rejects.toThrow(IOCValidationError);
+        });
+
+        test('应该支持普通对象自动转换为 DTO 实例', async () => {
+            // 传入普通对象，dp-ioc2 会自动转换为 DTO 实例
+            const plainObject = {
+                name: '测试用户',
+                email: 'test@example.com',
+                age: 25
+            };
+
+            const result = await service.createUser(plainObject as any);
+
+            expect(result.code).toBe('SUCCESS');
+            expect(result.data).toBeDefined();
+        });
+    });
+
+    describe('测试2：基本类型参数校验（Joi）', () => {
+        test('应该能够成功获取用户（有效ID）', async () => {
+            const result = await service.getUserById(123);
+
+            expect(result.code).toBe('SUCCESS');
+            expect(result.data).toBeDefined();
+            expect(result.data?.id).toBe(123);
+        });
+
+        test('应该拒绝负数ID', async () => {
+            await expect(service.getUserById(-1)).rejects.toThrow(IOCValidationError);
+        });
+
+        test('应该拒绝零值ID', async () => {
+            await expect(service.getUserById(0)).rejects.toThrow(IOCValidationError);
+        });
+
+        test('应该拒绝非整数ID', async () => {
+            // TypeScript 类型检查会阻止传入非数字，但运行时可能传入
+            await expect(service.getUserById(1.5 as any)).rejects.toThrow(IOCValidationError);
+        });
+    });
+
+    describe('测试3：混合参数校验', () => {
+        test('应该能够成功更新用户（所有参数有效）', async () => {
+            const dto: UpdateTestUserDto = {
+                name: '更新后的用户名',
+                email: 'updated@example.com'
+            };
+
+            const result = await service.updateUser(123, dto);
+
+            expect(result.code).toBe('SUCCESS');
+            expect(result.data).toBeDefined();
+            expect(result.data?.id).toBe(123);
+            expect(result.data?.name).toBe('更新后的用户名');
+            expect(result.data?.email).toBe('updated@example.com');
+        });
+
+        test('应该拒绝无效的用户ID（负数）', async () => {
+            const dto: UpdateTestUserDto = {
+                name: '更新后的用户名'
+            };
+
+            await expect(service.updateUser(-1, dto)).rejects.toThrow(IOCValidationError);
+        });
+
+        test('应该拒绝无效的邮箱格式', async () => {
+            const dto: UpdateTestUserDto = {
+                email: 'invalid-email'
+            };
+
+            await expect(service.updateUser(123, dto)).rejects.toThrow(IOCValidationError);
+        });
+    });
+
+    describe('测试4：无校验参数（对比测试）', () => {
+        test('无校验的方法应该接受任何参数', async () => {
+            // 这个方法没有 @ParamValidate，所以不会进行校验
+            const result = await service.getUserWithoutValidation(-1);
+
+            expect(result.code).toBe('SUCCESS');
+            // 即使传入负数，方法也会执行（因为没有校验）
+            expect(result.data?.id).toBe(-1);
+        });
+    });
+
+    describe('测试5：异常信息验证', () => {
+        test('应该包含详细的校验错误信息', async () => {
+            const invalidDto = {
+                name: 'ab', // 无效
+                email: 'invalid',
+                age: 10
+            };
+
+            try {
+                await service.createUser(invalidDto as any);
+                fail('应该抛出 IOCValidationError');
+            } catch (error) {
+                expect(error).toBeInstanceOf(IOCValidationError);
+                expect((error as IOCValidationError).message).toContain('Validation failed');
+            }
+        });
+    });
+});
+