@siven-li/elpis 1.0.0

package/elpis-core/loader/extend.js

@@ -0,0 +1,45 @@
+const glob = require('glob');
+const path = require('path');
+const { sep } = path;
+/*
+* extend loader
+* @param {object} app Koa实例
+* 
+* 加载所有extend，最终实现可通过”app.extend.${文件}“访问
+* 例子：
+  app/extend
+      |
+      | --  custom-extend.js
+  => app.extend.customExtend
+*
+*/
+module.exports = (app) => {
+  // 读取 elpis/app/extend/**.js 下所有文件
+  const elpisExtendPath = path.resolve(__dirname, `..${sep}..${sep}app${sep}extend`);
+  const elpisFileList = glob.sync(path.resolve(elpisExtendPath, `.${sep}**${sep}**.js`));
+  elpisFileList.forEach(file => handleFile(file));
+
+  // 读取 业务/app/extend/**.js 下所有文件
+  const businessExtendPath = path.resolve(app.businessPath, `.${sep}extend`);
+  const businessFileList = glob.sync(path.resolve(businessExtendPath, `.${sep}**${sep}**.js`));
+  businessFileList.forEach(file => handleFile(file));
+
+  // 把内容加载到 app.extend下
+  function handleFile(file) {
+    // 提取文件名称
+    let name = path.resolve(file);
+    // 截取路径 app/extend/custom-extend.js => custom-extend
+    name = name.substring(name.lastIndexOf(`extend${sep}`) + `extend${sep}`.length, name.lastIndexOf('.'));
+    // 把 '-' 统一改成驼峰式，custom-extend.js => customExtend
+    name = name.replace(/[_-][a-z]/ig, (s) => s.substring(1).toUpperCase());
+    // 过滤 app 已存在的 key
+    for (const key in app) {
+      if (name === key) {
+        console.log(`[extend loader error] name:${name} is already in app`);
+        return;
+      }
+    }
+    // 挂载 extend 到 app 上
+    app[name] = require(path.resolve(file))(app);
+  };
+}

package/elpis-core/loader/middleware.js

@@ -0,0 +1,58 @@
+const glob = require('glob');
+const path = require('path');
+const { sep } = path;
+/*
+* middleware loader
+* @param {object} app Koa实例
+* 
+* 加载所有middleware，最终实现可通过”app.middlewares.${目录}.${文件}“访问
+* 例子：
+  app/middleware
+    |
+    | --  custom-module
+            |
+            | --  custom-middleware.js
+  => app.middlewares.customModule.customMiddleware
+*
+*/
+module.exports = (app) => {
+  const middlewares = {};
+
+  // 读取 elpis/app/middleware/**/**.js 下所有文件
+  const elpisMiddlewarePath = path.resolve(__dirname, `..${sep}..${sep}app${sep}middleware`);
+  const elpisFileList = glob.sync(path.resolve(elpisMiddlewarePath, `.${sep}**${sep}**.js`));
+  elpisFileList.forEach(file => handleFile(file));
+
+  // 读取 业务/app/middleware/**/**.js 下所有文件
+  const businessMiddlewarePath = path.resolve(app.businessPath, `.${sep}middleware`);
+  const businessFileList = glob.sync(path.resolve(businessMiddlewarePath, `.${sep}**${sep}**.js`));
+  businessFileList.forEach(file => handleFile(file));
+
+  // 把内容加载到 app.middlewares下
+  function handleFile(file) {
+    // 提取文件名称
+    let name = path.resolve(file);
+    // 截取路径 app/middleware/custom-module/custom-middleware.js => custom-module/custom-middleware
+    name = name.substring(name.lastIndexOf(`middleware${sep}`) + `middleware${sep}`.length, name.lastIndexOf('.'));
+    // 把 '-' 统一改成驼峰式，custom-module/custom-middleware.js => customModule.customMiddleware
+    name = name.replace(/[_-][a-z]/ig, (s) => s.substring(1).toUpperCase());
+    // 把middleware挂在到内存 app 对象中
+    let tempMiddleware = middlewares;
+    const names = name.split(sep);
+    for (let i = 0, len = names.length; i < len; ++i) {
+      if (i === len - 1) {
+        tempMiddleware[names[i]] = require(path.resolve(file))(app);
+      } else {
+        if (!tempMiddleware[names[i]]) {
+          tempMiddleware[names[i]] = {};
+        }
+        tempMiddleware = tempMiddleware[names[i]]
+        // 以上逻辑涉及js对象引用 --- 首先 tempMiddleware = middlewares 使得tempMiddleware和middlewares指向同一对象；
+        // for循环里面使tempMiddleware添加新的属性为{}，此时middlewares同时也添加了相同的属性，然后又tempMiddleware = tempMiddleware[names[i]]，此时tempMiddleware指向新的属性的对象（也就是middlewares新添加属性的对象）；
+        // 这样middlewares就可以层层增加新的属性；
+        // 最终得到的数据格式 => middlewares为{ customModule: { customMiddleware: {} } }
+      }
+    }
+  }
+  app.middlewares = middlewares;
+}

package/elpis-core/loader/router-schema.js

@@ -0,0 +1,38 @@
+const glob = require('glob');
+const path = require('path');
+const { sep } = path;
+
+/* 
+* router-schema loader
+* @param {Object} app koa实例
+* 
+* 通过 ’json-schema & ajv'对 API 规则进行约束，配合 api-params-verify 中间件使用
+*
+* 读取 app/router-schema/**.js
+* 输出：
+  app.routerSchema = {
+    '${api1}': ${jsonSchema},
+    '${api2}': ${jsonSchema},
+    '${api3}': ${jsonSchema}
+  }
+*/
+module.exports = (app) => {
+  let routerSchema = {};
+
+  // 读取 elpis/app/router-schema/**/**.js 下所有文件
+  const elpisRouterSchemaPath = path.resolve(__dirname, `..${sep}..${sep}app${sep}router-schema`);
+  const elpisFileList = glob.sync(path.resolve(elpisRouterSchemaPath, `.${sep}**${sep}**.js`));
+  elpisFileList.forEach(file => handleFile(file));
+
+  // 读取 业务/app/router-schema/**/**.js 下所有文件
+  const businessRouterSchemaPath = path.resolve(app.businessPath, `.${sep}router-schema`);
+  const businessFileList = glob.sync(path.resolve(businessRouterSchemaPath, `.${sep}**${sep}**.js`));
+  businessFileList.forEach(file => handleFile(file));
+
+  // 注册所有 routerSchema，使得可以用 app.routerSchema 访问
+  function handleFile(file) {
+    routerSchema = {...routerSchema, ...require(path.resolve(file)) };
+  }
+
+  app.routerSchema = routerSchema;
+}

package/elpis-core/loader/router.js

@@ -0,0 +1,40 @@
+const KoaRouter = require('koa-router');
+const glob = require('glob');
+const path = require('path');
+const { sep } = path;
+
+/* 
+* router loader
+* @param {object} app koa 实例
+*
+* 解析 app/router/ 下所有 js 文件，加载到 KoaRouter 下
+*/
+module.exports = (app) => {
+  // 实例化 KoaRouter
+  const router = new KoaRouter();
+
+  // 找到 elpis 路由文件路径
+  const elpisRouterPath = path.resolve(__dirname, `..${sep}..${sep}app${sep}router`);
+  // 注册所有 elpis 路由
+  const elpisFileList = glob.sync(path.resolve(elpisRouterPath, `.${sep}**${sep}**.js`));
+  elpisFileList.forEach(file => {
+    require(path.resolve(file))(app, router);
+  })
+
+  // 找到业务路由文件路径
+  const businessFouterPath = path.resolve(app.businessPath, `.${sep}router`);
+  // 注册所有业务路由
+  const businessFileList = glob.sync(path.resolve(businessFouterPath, `.${sep}**${sep}**.js`));
+  businessFileList.forEach(file => {
+    require(path.resolve(file))(app, router);
+  })
+
+  // 路由兜底（健壮性）
+  router.get('*', async (ctx, next) => {
+    ctx.status = 302; // 临时重定向
+    ctx.redirect(`${app?.options?.homePage ?? '/'}`);
+  })
+  // 路由注册到 app 上
+  app.use(router.routes());
+  app.use(router.allowedMethods());
+}

package/elpis-core/loader/service.js

@@ -0,0 +1,56 @@
+const glob = require('glob');
+const path = require('path');
+const { sep } = path;
+/*
+* service loader
+* @param {object} app Koa实例
+* 
+* 加载所有service，最终实现可通过”app.service.${目录}.${文件}“访问
+* 例子：
+  app/service
+    |
+    | --  custom-module
+            |
+            | --  custom-service.js
+  => app.service.customModule.customService
+*
+*/
+module.exports = (app) => {
+  const service = {};
+
+  // 读取 elpis/app/service/**/**.js 下所有文件
+  const elpisServicePath = path.resolve(__dirname, `..${sep}..${sep}app${sep}service`);
+  const elpisFileList = glob.sync(path.resolve(elpisServicePath, `.${sep}**${sep}**.js`));
+  elpisFileList.forEach(file => handleFile(file));
+
+  // 读取 业务/app/service/**/**.js 下所有文件
+  const businessServicePath = path.resolve(app.businessPath, `.${sep}service`);
+  const businessFileList = glob.sync(path.resolve(businessServicePath, `.${sep}**${sep}**.js`));
+  businessFileList.forEach(file => handleFile(file));
+
+  // 把内容加载到 app.service下
+  function handleFile(file) {
+    // 提取文件名称
+    let name = path.resolve(file);
+    // 截取路径 app/service/custom-module/custom-service.js => custom-module/custom-service
+    name = name.substring(name.lastIndexOf(`service${sep}`) + `service${sep}`.length, name.lastIndexOf('.'));
+    // 把 '-' 统一改成驼峰式，custom-module/custom-service.js => customModule.customService
+    name = name.replace(/[_-][a-z]/ig, (s) => s.substring(1).toUpperCase());
+    // 把service挂在到内存 app 对象中
+    let tempService = service;
+    const names = name.split(sep);
+    for (let i = 0, len = names.length; i < len; ++i) {
+      if (i === len - 1) {
+        const ServiceModule = require(path.resolve(file))(app);
+        tempService[names[i]] = new ServiceModule();
+      } else {
+        if (!tempService[names[i]]) {
+          tempService[names[i]] = {};
+        }
+        tempService = tempService[names[i]]
+        // 最终得到的数据格式 => service为{ customModule: { customService: {} } }
+      }
+    }
+  };
+  app.service = service;
+}

package/index.js

@@ -0,0 +1,39 @@
+// 引入elpis-core
+const ElpisCore = require('./elpis-core');
+// 引入 前端工程化构建方法
+const FEBuildDev = require('./app/webpack/dev.js');
+const FEBuildProd = require('./app/webpack/prod.js');
+
+
+module.exports = {
+  /**
+   * 启动 elpis
+   * @param {*} options 项目配置，透传到 elpis-core
+   */
+  serverStart (options = {}) {
+    const app = ElpisCore.start(options);
+    return app; // 返回启动后的 Koa 实例
+  },
+
+  /**
+   * 编译构建前端工程
+   * @param {*} env 环境变量 local/prod
+   */
+  frontendBuild (env) {
+    if (env.trim() === 'local') {
+      FEBuildDev();
+    } else if (env.trim() === 'prod') {
+      FEBuildProd();
+    }
+  },
+
+  /**
+   * 服务端基础
+   */
+  Controller: {
+    Base: require('./app/controller/base.js')
+  },
+  Service: {
+    Base: require('./app/service/base.js')
+  }
+}

package/model/index.js

@@ -0,0 +1,104 @@
+const glob = require('glob');
+const path = require('path');
+const { sep } = path;
+const _ = require('lodash');
+
+// project 继承 model 方法
+const projectExtendModel = (model, project) => {
+  return _.mergeWith({}, model, project, (modelValue, projValue) => {
+    // 处理数组合并特殊情况
+    if (Array.isArray(modelValue) && Array.isArray(projValue)) {
+      let result = [];
+      // 因为 project 要继承 model，所以要处理一下几种情况
+      // 1.project 和 model 配置的相同的键值 => 修改（重载）
+      // 2.project 有的键值 model 没有 => 新增（拓展）
+      // 3.model 有的键值 project 没有 => 保留（继承）
+
+      // 处理修改和保留
+      for (let i = 0; i < modelValue.length; ++i) {
+        let modelItem = modelValue[i];
+        const projItem = projValue.find(projItem => projItem.key === modelItem.key);
+        if (projItem) {
+          // project有的键值，model也有，则递归调用 projectExtendModel 覆盖修改
+          result.push(projectExtendModel(modelItem, projItem))
+        } else {
+          // model 有的键值 project 没有 => 保留（继承）
+          result.push(modelItem)
+        }
+      }
+      // 处理新增
+      for (let i = 0; i < projValue.length; ++i) {
+        let projItem = projValue[i];
+        const modelItem = modelValue.find(modelItem => modelItem.key === projItem.key);
+        if (!modelItem) {
+          result.push(projItem);
+        }
+      }
+
+      return result;
+    }
+  })
+}
+
+/**
+ * 解析 model 配置，并返回组织且继承后的数据结构
+ * [{
+ *   model: ${model},
+ *   project: {
+ *     proj1: ${proj1},
+ *     proj2: ${proj2}
+ *   }
+ * }, ...]
+ */
+module.exports = (app) => {
+  const modelList = [];
+
+  // 遍历当前文件夹，构造模型数据结构，挂载到 modelList 上
+  const modelPath = path.resolve(app.baseDir, `.${sep}model`);
+  const modelFiles = glob.sync(path.resolve(modelPath, `.${sep}**${sep}**.js`));
+  modelFiles.forEach(file => {
+    if (file.indexOf('index.js') > -1) return;
+
+    // 统一将路径分隔符转换为正斜杠，便于匹配
+    const normalizedFile = file.replace(/\\/g, '/');
+    
+    // 区分配置类型（model / project）
+    const type = normalizedFile.includes('/project/') ? 'project' : 'model';
+    if (type === 'project') {
+      const modelKey = file.match(/\/model\/(.*?)\/project/)?.[1];
+      const projKey = file.match(/\/project\/(.*?)\.js/)?.[1];
+      let modelItem = modelList.find(item => item.model?.key === modelKey);
+      if (!modelItem) { // 初始化 model 数据结构
+        modelItem = {};
+        modelList.push(modelItem)
+      }
+      if (!modelItem.project) { // 初始化 project 数据结构
+        modelItem.project = {}
+      }
+      modelItem.project[projKey] = require(path.resolve(file));
+      modelItem.project[projKey].key = projKey; // 注入 projectKey
+      modelItem.project[projKey].modelKey = modelKey; // 注入 modelKey
+    }
+
+    if (type === 'model') {
+      const modelKey = file.match(/\/model\/(.*?)\/model\.js/)?.[1];
+      let modelItem = modelList.find(item => item.model?.key === modelKey);
+      if (!modelItem) { // 初始化 model 数据结构
+        modelItem = {};
+        modelList.push(modelItem);
+      }
+      modelItem.model = require(path.resolve(file));
+      modelItem.model.key = modelKey; // 注入 modelKey
+    }
+  });
+
+  // 数据进一步处理：project => 继承 model
+  modelList.forEach(item => {
+    const { model, project } = item;
+    for (const key in project) {
+      project[key] = projectExtendModel(model, project[key])
+    }
+  });
+
+  return modelList;
+}

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@siven-li/elpis",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "set _ENV=local && mocha 'test/**/*.js'",
+    "lint": "eslint --quiet --ext js,vue ."
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://git.code.tencent.com/sunflower-li/Elpis.git"
+  },
+  "author": "lsw",
+  "license": "ISC",
+  "dependencies": {
+    "@babel/core": "^7.24.0",
+    "@babel/runtime": "^7.24.0",
+    "@element-plus/icons-vue": "^2.3.2",
+    "ajv": "^6.10.2",
+    "axios": "^0.19.2",
+    "echarts": "^5.5.0",
+    "element-plus": "^2.3.7",
+    "generate-password": "^1.7.1",
+    "glob": "^7.1.4",
+    "jsonwebtoken": "^9.0.2",
+    "knex": "^0.19.0",
+    "koa": "2.7.0",
+    "koa-bodyparser": "^4.2.1",
+    "koa-nunjucks-2": "^3.0.2",
+    "koa-router": "^7.4.0",
+    "koa-static": "^5.0.0",
+    "koa-useragent": "2.0.0",
+    "koa2-cors": "^2.0.6",
+    "less": "^3.8.1",
+    "lodash": "^4.17.21",
+    "log4js": "^6.9.1",
+    "md5": "^2.2.1",
+    "moment": "^2.29.4",
+    "mysql": "^2.18.1",
+    "node-schedule": "^2.1.1",
+    "nodemon": "^1.19.2",
+    "path": "^0.12.7",
+    "pinia": "^2.1.6",
+    "regenerator-runtime": "^0.14.0",
+    "superagent": "^8.1.2",
+    "vue": "^3.3.4",
+    "vue-json-viewer": "^3.0.4",
+    "vue-router": "^4.2.4",
+    "vuex": "^4.1.0",
+    "@babel/plugin-transform-runtime": "^7.1.0",
+    "@babel/preset-env": "^7.4.5",
+    "babel-loader": "^8.0.4",
+    "clean-webpack-plugin": "^0.1.19",
+    "consoler": "^0.2.0",
+    "css-loader": "^0.23.1",
+    "css-minimizer-webpack-plugin": "^5.0.1",
+    "directory-named-webpack-plugin": "^4.0.1",
+    "express": "^4.18.2",
+    "file-loader": "^6.2.0",
+    "happypack": "^5.0.1",
+    "html-webpack-inject-attributes-plugin": "^1.0.1",
+    "html-webpack-plugin": "^5.5.3",
+    "less-loader": "^11.1.3",
+    "mini-css-extract-plugin": "^2.7.6",
+    "style-loader": "^0.14.1",
+    "terser-webpack-plugin": "^5.3.10",
+    "url-loader": "^4.1.1",
+    "vue-loader": "^17.2.2",
+    "vue-style-loader": "^4.1.2",
+    "webpack": "^5.88.1",
+    "webpack-dev-middleware": "^6.1.1",
+    "webpack-hot-middleware": "^2.25.4",
+    "webpack-merge": "^4.2.1"
+  },
+  "devDependencies": {
+    "assert": "^2.0.0",
+    "babel-eslint": "^10.0.2",
+    "eslint": "^7.32.0",
+    "eslint-plugin-import": "^2.28.1",
+    "eslint-plugin-vue": "^9.17.0",
+    "ghooks": "~1.0.3",
+    "mocha": "^6.1.4",
+    "supertest": "^4.0.2",
+    "validate-commit-msg": "~2.14.0"
+  },
+  "config": {
+    "ghooks": {
+      "commit-msg": "validate-commit-msg",
+      "pre-commit": "npm run lint"
+    }
+  }
+}

package/test/controll/project.test.js

@@ -0,0 +1,203 @@
+const assert = require('assert');
+const supertest = require('supertest');
+const md5 = require('md5');
+const elpisCore = require('../../elpis-core');
+
+const signKey = 'li11shi08z2cx3shi0wen920';
+const st = Date.now();
+
+describe('测试 project 相关接口', function() {
+  this.timeout(60000);
+
+  let modelList;
+  const projectList = [];
+
+  let request;
+
+  it('启动服务', async () => {
+    const app = await elpisCore.start();
+    
+    modelList = require('../../model/index.js')(app);
+    modelList.forEach(modelItem => {
+      const { project } = modelItem;
+      for(const projKey in project) {
+        projectList.push(project[projKey]);
+      };
+    });
+
+    request = supertest(app.listen());
+  })
+
+  it('GET /api/project without proj_key', async () => {
+    let temRequest = request.get('/api/project');
+    temRequest = temRequest.set('s_t', st);
+    temRequest = temRequest.set('s_sign', md5(`${signKey}_${st}`));
+    const res = await temRequest;
+    assert(res.body.success === false);
+
+    const resBody = res.body;
+    assert(resBody.code === 442);
+    assert(resBody.message.indexOf(`request validate fail: data should have required property 'proj_key'`) > -1);
+  })
+
+  it('GET /api/project fail', async () => {
+    let temRequest = request.get('/api/project');
+    temRequest = temRequest.set('s_t', st);
+    temRequest = temRequest.set('s_sign', md5(`${signKey}_${st}`));
+    temRequest = temRequest.query({ proj_key: 'not_exist_proj_key' });
+    const res = await temRequest;
+    assert(res.body.success === false);
+
+    const resBody = res.body;
+    assert(resBody.code === 50000);
+    assert(resBody.message.indexOf(`项目配置不存在`) > -1);
+  })
+
+  it('GET /api/project with proj_key', async () => {
+    for (let i = 0; i < projectList.length; ++i) {
+      const projItem = projectList[i];
+      const { key: projKey } = projItem;
+      
+      console.log(`---- GET /api/project with proj_key: ${projKey}`);
+
+      let temRequest = request.get('/api/project');
+      temRequest = temRequest.set('s_t', st);
+      temRequest = temRequest.set('s_sign', md5(`${signKey}_${st}`));
+      temRequest = temRequest.query({ proj_key: projKey });
+      const res = await temRequest;
+      assert(res.body.success === true);
+
+      const resData = res.body.data;
+      assert(resData.key === projKey);
+      assert(resData.modelKey);
+      assert(resData.name);
+      assert(resData.desc !== undefined);
+      assert(resData.homePage !== undefined);
+
+      const { menu } = resData;
+      menu.forEach(menuItem => {
+        checkMenuItem(menuItem);
+      })
+
+    }
+
+    // 校验 menu 菜单
+    function checkMenuItem(menuItem) {
+      console.log(`--- GET /api/project with proj_key--menuKey: ${menuItem.key}`);
+      assert(menuItem.key);
+      assert(menuItem.name);
+      assert(menuItem.menuType);
+
+      if (menuItem.menuType === 'group'){
+        assert(menuItem.subMenu !== undefined)
+        menuItem.subMenu.forEach(subMenuItem => {
+          checkMenuItem(subMenuItem);
+        })
+      }
+
+      if (menuItem.menuType === 'module'){
+        checkModule(menuItem);
+      }
+    }
+
+    // 检查 module 菜单配置
+    function checkModule(menuItem) {
+      const { moduleType } = menuItem;
+      assert(moduleType);
+
+      if (moduleType === 'sider') {
+        const { siderConfig } = menuItem;
+        assert(siderConfig);
+        assert(siderConfig.menu)
+        siderConfig.menu.forEach(siderMenuItem => {
+          checkMenuItem(siderMenuItem);
+        })
+      }
+
+      if (moduleType === 'iframe') {
+        const { iframeConfig } = menuItem;
+        assert(iframeConfig);
+        assert(iframeConfig.path !== undefined);
+      }
+
+      if (moduleType === 'custom') {
+        const { customConfig } = menuItem;
+        assert(customConfig);
+        assert(customConfig.path !== undefined);
+      }
+
+      if (moduleType === 'schema') {
+        const { schemaConfig } = menuItem;
+        assert(schemaConfig);
+        assert(schemaConfig.api !== undefined);
+        assert(schemaConfig.schema);
+      }
+    }
+  })
+
+
+  it('GET /api/project/list without proj_key', async () => {
+    let temRequest = request.get('/api/project/list');
+    temRequest = temRequest.set('s_t', st);
+    temRequest = temRequest.set('s_sign', md5(`${signKey}_${st}`));
+    const res = await temRequest;
+    assert(res.body.success === true);
+
+    const resData = res.body.data;
+    assert(resData.length === projectList.length);
+    for (let i = 0; i < resData.length; ++i) {
+      const item = resData[i];
+      assert(item.modelKey);
+      assert(item.key);
+      assert(item.name);
+      assert(item.desc !== undefined);
+      assert(item.homePage !== undefined);
+    }
+  })
+
+  it('GET /api/project/list with proj_key', async () => {
+    const { key: projKey } = projectList[Math.floor(Math.random() * projectList.length)];
+    const { modelKey } = projectList.find(item => item.key === projKey);
+
+    let temRequest = request.get('/api/project/list');
+    temRequest = temRequest.set('s_t', st);
+    temRequest = temRequest.set('s_sign', md5(`${signKey}_${st}`));
+    temRequest = temRequest.query({ proj_key: projKey });
+    const res = await temRequest;
+    assert(res.body.success === true);
+
+    const resData = res.body.data;
+    assert(projectList.filter(item => item.modelKey === modelKey).length === resData.length);
+    for (let i = 0; i < resData.length; ++i) {
+      const item = resData[i];
+      assert(item.modelKey);
+      assert(item.key);
+      assert(item.name);
+      assert(item.desc !== undefined);
+      assert(item.homePage !== undefined);
+    }
+  })
+
+  it('GET /api/project/model_list', async () => {
+    let temRequest = request.get('/api/project/model_list');
+    temRequest = temRequest.set('s_t', st);
+    temRequest = temRequest.set('s_sign', md5(`${signKey}_${st}`));
+    const res = await temRequest;
+    assert(res.body.success === true);
+
+    const resData = res.body.data;
+    assert(resData.length > 0);
+
+    for(let i = 0; i < resData.length; ++i) {
+      const item = resData[i];
+      assert(item.model);
+      assert(item.model.key);
+      assert(item.model.name);
+      assert(item.project);
+      for(const projKey in item.project) {
+        assert(item.project[projKey].key);
+        assert(item.project[projKey].name)
+      }
+    }
+  })
+})