typespeed 2.3.3 → 2.3.5

package/.github/workflows/test.yml

@@ -0,0 +1,50 @@
+name: Tests
+'on': 
+  push:
+    branches:
+      - main
+
+jobs:
+  test:
+    name: 'Test TypeSpeed'
+    runs-on: ubuntu-latest
+    services:
+      redis:
+        image: redis
+        ports:
+          - 6379:6379
+      rabbitmq:
+        image: rabbitmq:3.8
+        env:
+          RABBITMQ_DEFAULT_USER: guest
+          RABBITMQ_DEFAULT_PASS: guest
+        ports:
+          - 5672
+    steps:
+      - uses: actions/setup-node@v1
+        with:
+          node-version: 16
+      - uses: actions/checkout@v2
+      - name: Setup MySQL
+        run: |
+          sudo /etc/init.d/mysql start
+          mysql -e 'CREATE DATABASE test;USE test; \
+          CREATE TABLE `user` (`id` int(11) NOT NULL AUTO_INCREMENT,`name` varchar(100) DEFAULT NULL,PRIMARY KEY (`id`)) \
+          ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;SHOW TABLES;' -uroot -proot
+      - name: 'Cache node_modules'
+        uses: actions/cache@v2
+        with:
+          path: ~/.npm
+          key: ${{ runner.os }}-node-v18-${{ hashFiles('**/package.json') }}
+          restore-keys: |
+            ${{ runner.os }}-node-v18-
+      - name: Install Dependencies
+        run: npm install
+      - name: Run Tests with Coverage
+        run: npm run test-with-coverage
+        env:
+          LOCAL_HOST: localhost
+      - name: Upload coverage reports to Codecov
+        uses: codecov/codecov-action@v3
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

package/README.md

@@ -2,14 +2,16 @@
 
 [![typescript](https://badgen.net/badge/icon/TypeScript?icon=typescript&label)](https://www.npmjs.com/package/typespeed)
 [![npm](https://badgen.net/npm/v/typespeed?color=cyan)](https://www.npmjs.com/package/typespeed)
-[![last commit](https://img.shields.io/github/last-commit/speedphp/typespeed)](https://github.com/SpeedPHP/typespeed/commits/main)
 [![downloads](https://badgen.net/npm/dt/typespeed?color=pink)](https://www.npmjs.com/package/typespeed)
 [![license](https://badgen.net/github/license/speedphp/typespeed)](https://github.com/SpeedPHP/typespeed/blob/main/LICENSE)
+[![GitHub Build Status](https://img.shields.io/github/actions/workflow/status/speedphp/typespeed/test.yml)](https://github.com/SpeedPHP/typespeed/commits/main)
+[![Codecov](https://img.shields.io/codecov/c/github/speedphp/typespeed)
+](https://codecov.io/gh/SpeedPHP/typespeed)
 
 ### 特点
 
 - 遵循 MIT 许可的开源项目。
-- 提供 22 个 TypeScript 装饰器，这些装饰器构成了完整的 Web 框架功能，包括对象管理、Web 路由、数据库操作等。
+- 提供 31 个 TypeScript 装饰器，这些装饰器构成了完整的 Web 框架功能，包括对象管理、Web 路由、数据库操作等。
 - 通过命令行脚手架，可以快速创建项目，零配置启动。
 - 基于依赖注入、AOP、中间件和启动扫描等编程理念开发实现。
 - 底层采用 ExpressJS 实现，提供稳定、快速的 Web 服务。

package/app/src/aop-test.class.ts

@@ -1,4 +1,4 @@
-import { before, log, component, after } from "../../";
+import { before, log, component, after } from "../../src/typespeed";
 import FirstPage from "./first-page.class";
 
 @component

package/app/src/config-development.json

@@ -1,20 +1,23 @@
 {
-    "server": {
-        "port": "8081"
-    },
-    "database": {
-        "host": "localhost",
-        "port": "4455",
-        "name": "test"
-    },
     "view": {
         "engine": "mustache",
         "path": "/app/src/views",
         "suffix": "html"
     },
+    "mysql": {
+        "host": "127.0.0.1",
+        "user": "root",
+        "password": "root",
+        "database": "test"
+    },
+    "redis": {
+        "host": "127.0.0.1",
+        "port": "6379",
+        "db": 0
+    },
     "rabbitmq": {
         "protocol": "amqp",
-        "hostname": "localhost",
+        "hostname": "127.0.0.1",
         "port": 5672,
         "username": "guest",
         "password": "guest"

package/app/src/custom-log.class.ts

@@ -1,5 +1,5 @@
 import * as tracer from "tracer";
-import { bean, LogFactory } from "../../";
+import { bean, LogFactory } from "../../src/typespeed";
 
 export default class CustomLog extends LogFactory {
     private logger = tracer.console({
@@ -17,7 +17,8 @@ export default class CustomLog extends LogFactory {
     }
 
     public log(message?: any, ...optionalParams: any[]) : void{
-        //this.logger.log(message, ...optionalParams);
+        if(process.env.LOG === "CLOSE") return;
+        this.logger.log(message, ...optionalParams);
     }
 
     public error(message?: any, ...optionalParams: any[]) : void {

package/app/src/first-page.class.ts

@@ -1,5 +1,5 @@
 //import * as jwttoken from "jsonwebtoken";
-import { log, component, getMapping } from "../../";
+import { log, component, getMapping } from "../../src/typespeed";
 
 @component
 export default class FirstPage {

package/app/src/jwt-authentication.class.ts

@@ -1,4 +1,4 @@
-import { AuthenticationFactory, bean, config } from "../../";
+import { AuthenticationFactory, bean, config } from "../../src/typespeed";
 import express from "express";
 import { expressjwt, GetVerificationKey } from "express-jwt";
 import * as jwt from 'jsonwebtoken';
@@ -23,8 +23,8 @@ export default class JwtAuthentication extends AuthenticationFactory {
                 if (err) {
                     //next(err);
                 }
-                next();
             });
         }
+        next();
     }
 }

package/app/src/main.ts

@@ -1,4 +1,4 @@
-import { app, log, autoware, ServerFactory } from "../../";
+import { app, log, autoware, ServerFactory } from "../../src/typespeed";
 //import * as basicAuth from "express-basic-auth"
 let appServer = null;
 

package/app/src/second-page.class.ts

@@ -1,4 +1,4 @@
-import { getMapping, postMapping, upload, jwt, log, component } from "../../";
+import { getMapping, postMapping, upload, jwt, log, component } from "../../src/typespeed";
 
 @component
 export default class SecondPage {

package/app/src/test-database.class.ts

@@ -1,4 +1,4 @@
-import { insert, update, select, param, resultType, cache, CacheFactory, getMapping, component, log, autoware } from "../../";
+import { insert, update, select, param, resultType, cache, CacheFactory, getMapping, component, log, autoware } from "../../src/typespeed";
 import UserDto from "./entities/user-dto.class";
 
 @component
@@ -11,24 +11,22 @@ export default class TestDatabase {
     async insert(req, res) {
         const id = req.query.id || 1;
         const newId = await this.addRow("new name " + id, id);
-        log("Insert newId: " + newId);
-        res.send("Insert success");
+        res.send("Insert success: " + newId);
     }
 
     @getMapping("/db/insert2")
     async insertByObject(req, res) {
         const newId = await this.addRowByObject({
-            "id": Math.ceil(Math.random() * 1000), "name": "new name 25"
+            "id": req.query.id, "name": "new name " + req.query.id
         });
-        log("Insert newId: " + newId);
-        res.send("Insert success");
+        res.send("Insert success: " + newId);
     }
 
     @getMapping("/db/update")
     async update(req, res) {
-        const affectedRows = await this.editRow();
+        const affectedRows = await this.editRow(req.query.id);
         log("Update rows: " + affectedRows);
-        res.send("update success");
+        res.send("update success: " + affectedRows);
     }
 
     @getMapping("/db/select")
@@ -38,17 +36,15 @@ export default class TestDatabase {
         res.send(rows);
     }
 
-    @getMapping("/db/select1")
+    @getMapping("/db/select-row")
     async selectById(req, res) {
-        const row = await this.findRow(req.query.id || 1);
-        log("select rows: " + row);
+        const row = await this.findRow(req.query.id);
         res.send(row);
     }
 
     @getMapping("/db/select-user")
     async selectUser(req, res) {
         const users: UserDto[] = await this.findUsers();
-        log("select users: " + users);
         res.send(users);
     }
 
@@ -69,8 +65,8 @@ export default class TestDatabase {
     @insert("Insert into `user` (id, name) values (#{id}, #{name})")
     private async addRowByObject(myParams: object) { }
 
-    @update("Update `user` set `name` = 'test5' where id = 5")
-    private async editRow() { }
+    @update("Update `user` set `name` = 'test5' where id = #{id}")
+    private async editRow(@param("id") id: number) { }
 
     @select("Select * from `user`")
     private async selectRow() { }

package/app/src/test-log.class.ts

@@ -1,4 +1,4 @@
-import { component, getMapping, error } from "../../";
+import { component, getMapping, error } from "../../src/typespeed";
 
 @component
 export default class TestLog {

package/app/src/test-mq.class.ts

@@ -1,4 +1,4 @@
-import { component, getMapping, autoware, log, RabbitMQ, rabbitListener } from "../../";
+import { component, getMapping, autoware, log, RabbitMQ, rabbitListener } from "../../src/typespeed";
 import { connect } from "amqplib";
 
 
@@ -16,51 +16,6 @@ export default class TestMq {
     @getMapping("/mq/sendByMQClass")
     async sendByMQClass() {
         this.rabbitMQ.send("myqueues", "hello world, by MQClass");
-        return "sent by MQClass";
-    }
-
-    @getMapping("/mq/sendByQueue")
-    async sendMq() {
-        const queue = 'myqueues';
-        const text = "hello world, by queue";
-        const connection = await connect({
-            protocol: 'amqp',
-            hostname: 'localhost',
-            port: 5672,
-            username: 'guest',
-            password: 'guest'
-        });
-        const channel = await connection.createChannel();
-        await channel.assertQueue(queue);
-        channel.sendToQueue(queue, Buffer.from(text));
-        await channel.close();
-        return "sent by queue";
-    }
-
-    @getMapping("/mq/sendByExchange")
-    async sendMq2() {
-        const exchange = 'myexchanges';
-        const text = "hello world, by exchange";
-        const connection = await connect('amqp://localhost');
-        const channel = await connection.createChannel();
-        await channel.checkExchange(exchange);
-        channel.publish(exchange, '', Buffer.from(text));
-        await channel.close();
-        return "sent by exchange";
-    }
-
-    @getMapping("/mq/listen")
-    async testMq() {
-        const connection = await connect('amqp://localhost');
-        const channel = await connection.createChannel();
-        const queue = 'myqueues';
-        const queue2 = 'myqueues2';
-        await channel.checkQueue(queue);
-        await channel.checkQueue(queue2);
-        await channel.consume(queue, (message) => {
-        }, { noAck: true });
-        await channel.consume(queue2, (message) => {
-        }, { noAck: true });
-        return "ok";
+        return "Sent by MQClass";
     }
 }

package/app/src/test-orm.class.ts

@@ -1,4 +1,4 @@
-import { resource, component, log, autoware, schedule, getMapping, postMapping, Redis } from "../../";
+import { resource, component, log, autoware, schedule, getMapping, postMapping, Redis } from "../../src/typespeed";
 import UserModel from "./user-model.class";
 
 @component
@@ -7,17 +7,6 @@ export default class TestOrm {
     @resource("user")
     private userModel: UserModel;
 
-    @autoware
-    private redisObj: Redis;
-
-    @getMapping("/redis")
-    async redisTest() {
-        await this.redisObj.set("redisKey", "Hello World");
-        const value = await this.redisObj.get("redisKey");
-        log(value)
-        return "get from redis: " + value;
-    }
-
     @getMapping("/orm/first")
     async firstTest(req, res) {
         const results = await this.userModel.getUsers();

package/app/src/test-redis.class.ts

@@ -0,0 +1,45 @@
+import { Redis, component, redisSubscriber, autoware, getMapping, log, reqQuery } from "../../src/typespeed";
+
+@component
+export default class TestRedis {
+    @autoware
+    private redisObj: Redis;
+
+    @redisSubscriber("mychannel")
+    public listen(message) {
+        log("Received by Decorator '%s'", message);
+    }
+
+    @getMapping("/redis/publish")
+    async redisPublish() {
+        await this.redisObj.publish("mychannel", "Hello World");
+        return "Published!";
+    }
+
+    @getMapping("/redis")
+    async redisString() {
+        await this.redisObj.set("redisKey", "Hello World");
+        const value = await this.redisObj.get("redisKey");
+        return "get from redis: " + value;
+    }
+
+    @getMapping("/redis/add")
+    async addZset(@reqQuery name: string, @reqQuery score: number) {
+        log("add zset: %s, %s", name, score)
+        await this.redisObj.zadd("scoreSet", score, name);
+        return "add zset success";
+    }
+
+    @getMapping("/redis/ranking")
+    async listRanking() {
+        const list = await this.redisObj.zrevranking("scoreSet", 0, -1);
+        return Object.fromEntries(list);
+    }
+
+    @getMapping("/redis/list")
+    async listZset() {
+        const list = await this.redisObj.zranking("scoreSet", 0, -1);
+        log("list zset: %s", JSON.stringify(Object.fromEntries(list)));
+        return Object.fromEntries(list);
+    }
+}

package/app/src/test-request.class.ts

@@ -1,4 +1,4 @@
-import { component, getMapping, postMapping, log, req, res, reqQuery, reqBody, reqForm, reqParam } from "../../";
+import { component, getMapping, postMapping, log, req, res, reqQuery, reqBody, reqForm, reqParam } from "../../src/typespeed";
 import MutilUsers from "./entities/mutil-users.class";
 import UserDto from "./entities/user-dto.class";
 

package/app/src/user-model.class.ts

@@ -1,4 +1,4 @@
-import { log, Model } from "../../";
+import { log, Model } from "../../src/typespeed";
 import UserDto from "./entities/user-dto.class";
 
 export default class UserModel extends Model {
@@ -20,7 +20,7 @@ export default class UserModel extends Model {
     }
 
     async newUsers() {
-        const newId = Math.ceil(Math.random() * 1000);
+        const newId = this.random(1000, 2000);
         await this.create([
             new UserDto(newId, "UserDto " + newId),
             new UserDto(newId+1, "UserDto " + (newId+1)),
@@ -43,4 +43,8 @@ export default class UserModel extends Model {
         const effectRows = await this.update({ id: id }, { name: name });
         return effectRows;
     }
+
+    private random(min, max) {
+        return Math.round(Math.random() * (max - min)) + min;
+    }
 }

package/dist/default/express-server.class.js

@@ -138,7 +138,7 @@ __decorate([
 ], ExpressServer.prototype, "redisConfig", void 0);
 __decorate([
     core_decorator_1.autoware,
-    __metadata("design:type", redis_class_1.default)
+    __metadata("design:type", redis_class_1.Redis)
 ], ExpressServer.prototype, "redisClient", void 0);
 __decorate([
     core_decorator_1.autoware,

package/dist/default/redis.class.js

@@ -9,24 +9,73 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.redisSubscriber = exports.Redis = void 0;
 const core_decorator_1 = require("../core.decorator");
 const ioredis_1 = require("ioredis");
 const typespeed_1 = require("../typespeed");
-class Redis extends ioredis_1.default {
+const redisSubscribers = {};
+class Redis extends ioredis_1.Redis {
     getRedis() {
+        return Redis.getInstanceOfRedis("pub");
+    }
+    async zrevranking(key, start, stop) {
+        const list = await this.zrevrange(key, start, stop, "WITHSCORES");
+        const map = new Map();
+        for (let i = 0; i < list.length; i = i + 2) {
+            map.set(list[i], Number(list[i + 1]));
+        }
+        return map;
+    }
+    async zranking(key, start, stop) {
+        const list = await this.zrange(key, start, stop, "WITHSCORES");
+        const map = new Map();
+        for (let i = 0; i < list.length; i = i + 2) {
+            map.set(list[i], Number(list[i + 1]));
+        }
+        return map;
+    }
+    static getInstanceOfRedis(mode) {
         if (!(0, typespeed_1.config)("redis")) {
             return null;
         }
-        return new Redis((0, typespeed_1.config)("redis"));
-    }
-    constructor(config) {
-        super(config);
+        if (mode === "sub") {
+            this.pubObj = this.pubObj || new Redis((0, typespeed_1.config)("redis"));
+            return this.pubObj;
+        }
+        else {
+            this.subObj = this.subObj || new Redis((0, typespeed_1.config)("redis"));
+            return this.subObj;
+        }
     }
 }
+Redis.pubObj = null;
+Redis.subObj = null;
 __decorate([
     core_decorator_1.bean,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Redis)
 ], Redis.prototype, "getRedis", null);
-exports.default = Redis;
+exports.Redis = Redis;
+function redisSubscriber(channel) {
+    if (!(0, typespeed_1.config)("redis"))
+        return;
+    Redis.getInstanceOfRedis("sub").subscribe(channel, function (err, count) {
+        if (err) {
+            console.error(err);
+        }
+    });
+    return function (target, propertyKey) {
+        redisSubscribers[channel] = target[propertyKey];
+    };
+}
+exports.redisSubscriber = redisSubscriber;
+if ((0, typespeed_1.config)("redis")) {
+    Redis.getInstanceOfRedis("sub").on("message", function (channel, message) {
+        redisSubscribers[channel](message);
+    });
+}
+process.once('SIGINT', () => {
+    Redis.getInstanceOfRedis("sub") || Redis.getInstanceOfRedis("sub").disconnect();
+    Redis.getInstanceOfRedis("pub") || Redis.getInstanceOfRedis("pub").disconnect();
+});

package/dist/typespeed.d.ts

@@ -1,5 +1,5 @@
 import * as express from "express";
-import IoRedis from "ioredis";
+import { Redis as IoRedis, RedisKey } from "ioredis";
 import "reflect-metadata";
 
 /**设置路由中间件 */
@@ -139,7 +139,7 @@ declare class Model {
  * 被装饰的类将作为应用程序入口，框架将启动该类的 main 方法
  */
 declare function app<T extends {
-    new (...args: any[]): {};
+    new(...args: any[]): {};
 }>(constructor: T): void;
 /**获取配置文件中的配置项 */
 declare function config(node: string): any;
@@ -169,20 +169,22 @@ declare function after(constructorFunction: any, methodName: string): (target: a
 declare function schedule(cronTime: string | Date): (target: any, propertyKey: string) => void;
 /**RabbitMQ 监听装饰器，参数是监听的队列名称，当接受到消息时将执行被装饰方法 */
 declare function rabbitListener(queue: string): (target: any, propertyKey: string) => void;
+/**Redis 监听装饰器，参数是监听的队列名称，当接受到消息时将执行被装饰方法 */
+declare function redisSubscriber(target: any, propertyKey: string): void;
 /** request 对象装饰器，作为路由页面方法参数，获取 request 对象 */
-declare function req(target: any, propertyKey: string, parameterIndex: number) : void;
+declare function req(target: any, propertyKey: string, parameterIndex: number): void;
 /** response 对象装饰器，作为路由页面方法参数，获取 response 对象 */
-declare function res(target: any, propertyKey: string, parameterIndex: number) : void;
+declare function res(target: any, propertyKey: string, parameterIndex: number): void;
 /** next 函数装饰器，作为路由页面方法参数，获取  next 函数 */
-declare function next(target: any, propertyKey: string, parameterIndex: number) : void;
+declare function next(target: any, propertyKey: string, parameterIndex: number): void;
 /** request.body 对象装饰器，作为路由页面方法参数，获取 request.body 对象 */
-declare function reqBody(target: any, propertyKey: string, parameterIndex: number) : void;
+declare function reqBody(target: any, propertyKey: string, parameterIndex: number): void;
 /** request.param 值装饰器，作为路由页面方法参数，获取 request.params 内容 */
-declare function reqParam(target: any, propertyKey: string, parameterIndex: number) : void;
+declare function reqParam(target: any, propertyKey: string, parameterIndex: number): void;
 /** request.query 值装饰器，作为路由页面方法参数，获取 request.query 内容 */
-declare function reqQuery(target: any, propertyKey: string, parameterIndex: number) : void;
+declare function reqQuery(target: any, propertyKey: string, parameterIndex: number): void;
 /** request 表单值装饰器，作为路由页面方法参数，获取 request.body 表单内容 */
-declare function reqForm(paramName: string) : (target: any, propertyKey: string, parameterIndex: number) => void;
+declare function reqForm(paramName: string): (target: any, propertyKey: string, parameterIndex: number) => void;
 
 /**框架 Web 服务工厂类 */
 declare abstract class ServerFactory {
@@ -275,7 +277,22 @@ declare abstract class AuthenticationFactory {
 declare class Redis extends IoRedis {
     /**获取 Redis 实例 */
     getRedis(): Redis;
-    constructor(config: any);
+    /**
+     * 获取有序集合（sorted set），按照分数从大到小排序，返回 Map 对象
+     * @param key 键
+     * @param start 开始位置，0 表示第一个元素，-1 表示最后一个元素
+     * @param stop 结束位置，0 表示第一个元素，-1 表示最后一个元素
+     * @returns Map 对象，key 为有序集合的成员，value 为成员的分数
+     */
+    zrevranking(key: RedisKey, start: number | string, stop: number | string): Promise<Map<string, number>>;
+    /**
+     * 获取有序集合（sorted set），按照分数从小到大排序，返回 Map 对象
+     * @param key 键
+     * @param start 开始位置，0 表示第一个元素，-1 表示最后一个元素
+     * @param stop 结束位置，0 表示第一个元素，-1 表示最后一个元素
+     * @returns Map 对象，key 为有序集合的成员，value 为成员的分数
+     */
+    zranking(key: RedisKey, start: number | string, stop: number | string): Promise<Map<string, number>>;
 }
 /**读写数据源实现类 */
 declare class ReadWriteDb extends DataSourceFactory {
@@ -359,4 +376,4 @@ declare class ExpressServer extends ServerFactory {
     private setDefaultMiddleware;
 }
 
-export { ExpressServer, LogDefault, NodeCache, RabbitMQ, rabbitListener, ReadWriteDb, Redis, CacheFactory, DataSourceFactory, LogFactory, ServerFactory, AuthenticationFactory, next, reqBody, reqQuery, reqForm, reqParam, req, req as request, res, res as response, component, bean, resource, log, app, before, after, value, error, config, autoware, getBean, getComponent, schedule, getMapping, postMapping, requestMapping, setRouter, upload, jwt, insert, update, remove, select, param, resultType, cache, Model};
+export { ExpressServer, LogDefault, NodeCache, RabbitMQ, rabbitListener, redisSubscriber, ReadWriteDb, Redis, CacheFactory, DataSourceFactory, LogFactory, ServerFactory, AuthenticationFactory, next, reqBody, reqQuery, reqForm, reqParam, req, req as request, res, res as response, component, bean, resource, log, app, before, after, value, error, config, autoware, getBean, getComponent, schedule, getMapping, postMapping, requestMapping, setRouter, upload, jwt, insert, update, remove, select, param, resultType, cache, Model };

package/dist/typespeed.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReadWriteDb = exports.Redis = exports.NodeCache = exports.LogDefault = exports.ExpressServer = exports.AuthenticationFactory = exports.ServerFactory = exports.DataSourceFactory = exports.CacheFactory = exports.LogFactory = exports.config = exports.value = exports.app = void 0;
+exports.ReadWriteDb = exports.redisSubscriber = exports.Redis = exports.NodeCache = exports.LogDefault = exports.ExpressServer = exports.AuthenticationFactory = exports.ServerFactory = exports.DataSourceFactory = exports.CacheFactory = exports.LogFactory = exports.config = exports.value = exports.app = void 0;
 require("reflect-metadata");
 const fs = require("fs");
 const path = require("path");
@@ -119,7 +119,8 @@ Object.defineProperty(exports, "LogDefault", { enumerable: true, get: function (
 var node_cache_class_1 = require("./default/node-cache.class");
 Object.defineProperty(exports, "NodeCache", { enumerable: true, get: function () { return node_cache_class_1.default; } });
 var redis_class_1 = require("./default/redis.class");
-Object.defineProperty(exports, "Redis", { enumerable: true, get: function () { return redis_class_1.default; } });
+Object.defineProperty(exports, "Redis", { enumerable: true, get: function () { return redis_class_1.Redis; } });
+Object.defineProperty(exports, "redisSubscriber", { enumerable: true, get: function () { return redis_class_1.redisSubscriber; } });
 var read_write_db_class_1 = require("./default/read-write-db.class");
 Object.defineProperty(exports, "ReadWriteDb", { enumerable: true, get: function () { return read_write_db_class_1.default; } });
 __exportStar(require("./default/rabbitmq.class"), exports);

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "typespeed",
-  "version": "2.3.3",
+  "version": "2.3.5",
   "description": "A new Framework for TypeScript.",
   "author": "speedphp",
   "license": "MIT License",
   "scripts": {
     "test": "mocha --require ts-node/register test/**/*.ts --exit",
-    "test-with-coverage": "nyc --reporter=text npm test",
+    "test-with-coverage": "nyc --reporter=lcov npm test",
     "start": "ts-node --transpile-only app/src/main.ts",
     "build": "tsc -p .",
     "postbuild": "cp src/typespeed.d.ts dist/typespeed.d.ts && cp -r src/default/pages dist/default/pages && cp -r src/scaffold/templates dist/scaffold/templates",

package/src/default/express-server.class.ts

@@ -10,7 +10,7 @@ import ServerFactory from "../factory/server-factory.class";
 import { setRouter } from "../route.decorator";
 import { value } from "../typespeed";
 import { bean, log, error, autoware } from "../core.decorator";
-import Redis from "./redis.class";
+import { Redis } from "./redis.class";
 import AuthenticationFactory from "../factory/authentication-factory.class";
 
 export default class ExpressServer extends ServerFactory {

package/src/default/redis.class.ts

@@ -1,18 +1,70 @@
 import { bean } from "../core.decorator";
-import IoRedis from "ioredis";
+import { Redis as IoRedis, RedisKey} from "ioredis";
 import { config } from "../typespeed";
-export default class Redis extends IoRedis {
+const redisSubscribers = {};
+
+class Redis extends IoRedis {
+    private static pubObj: Redis = null;
+    private static subObj: Redis = null;
 
     @bean
     public getRedis(): Redis {
+        return Redis.getInstanceOfRedis("pub");
+    }
+
+    public async zrevranking(key: RedisKey, start: number | string, stop: number | string): Promise<Map<string, number>> {
+        const list = await this.zrevrange(key, start, stop, "WITHSCORES");
+        const map = new Map<string, number>();
+        for (let i = 0; i < list.length; i = i + 2) {
+            map.set(list[i], Number(list[i + 1]));
+        }
+        return map;
+    }
+
+    public async zranking(key: RedisKey, start: number | string, stop: number | string): Promise<Map<string, number>> {
+        const list = await this.zrange(key, start, stop, "WITHSCORES");
+        const map = new Map<string, number>();
+        for (let i = 0; i < list.length; i = i + 2) {
+            map.set(list[i], Number(list[i + 1]));
+        }
+        return map;
+    }
+
+    static getInstanceOfRedis(mode: "sub" | "pub") {
         if (!config("redis")) {
             return null;
         }
-        return new Redis(config("redis"));
+        if (mode === "sub") {
+            this.pubObj = this.pubObj || new Redis(config("redis"));
+            return this.pubObj;
+        } else {
+            this.subObj = this.subObj || new Redis(config("redis"));
+            return this.subObj;
+        }
     }
+}
 
-    constructor(config: any) {
-        super(config);
-    }
+function redisSubscriber(channel: string) {
+    if (!config("redis")) return;
+    Redis.getInstanceOfRedis("sub").subscribe(channel, function (err, count) {
+        if (err) {
+            console.error(err);
+        }
+    });
+    return function (target: any, propertyKey: string) {
+        redisSubscribers[channel] = target[propertyKey];
+    };
+}
+
+if (config("redis")) {
+    Redis.getInstanceOfRedis("sub").on("message", function (channel, message) {
+        redisSubscribers[channel](message);
+    });
+}
+
+process.once('SIGINT', () => { 
+    Redis.getInstanceOfRedis("sub") || Redis.getInstanceOfRedis("sub").disconnect();
+    Redis.getInstanceOfRedis("pub") || Redis.getInstanceOfRedis("pub").disconnect();
+});
 
-}
+export { Redis, redisSubscriber };

package/src/typespeed.d.ts

@@ -1,5 +1,5 @@
 import * as express from "express";
-import IoRedis from "ioredis";
+import { Redis as IoRedis, RedisKey } from "ioredis";
 import "reflect-metadata";
 
 /**设置路由中间件 */
@@ -139,7 +139,7 @@ declare class Model {
  * 被装饰的类将作为应用程序入口，框架将启动该类的 main 方法
  */
 declare function app<T extends {
-    new (...args: any[]): {};
+    new(...args: any[]): {};
 }>(constructor: T): void;
 /**获取配置文件中的配置项 */
 declare function config(node: string): any;
@@ -169,20 +169,22 @@ declare function after(constructorFunction: any, methodName: string): (target: a
 declare function schedule(cronTime: string | Date): (target: any, propertyKey: string) => void;
 /**RabbitMQ 监听装饰器，参数是监听的队列名称，当接受到消息时将执行被装饰方法 */
 declare function rabbitListener(queue: string): (target: any, propertyKey: string) => void;
+/**Redis 监听装饰器，参数是监听的队列名称，当接受到消息时将执行被装饰方法 */
+declare function redisSubscriber(target: any, propertyKey: string): void;
 /** request 对象装饰器，作为路由页面方法参数，获取 request 对象 */
-declare function req(target: any, propertyKey: string, parameterIndex: number) : void;
+declare function req(target: any, propertyKey: string, parameterIndex: number): void;
 /** response 对象装饰器，作为路由页面方法参数，获取 response 对象 */
-declare function res(target: any, propertyKey: string, parameterIndex: number) : void;
+declare function res(target: any, propertyKey: string, parameterIndex: number): void;
 /** next 函数装饰器，作为路由页面方法参数，获取  next 函数 */
-declare function next(target: any, propertyKey: string, parameterIndex: number) : void;
+declare function next(target: any, propertyKey: string, parameterIndex: number): void;
 /** request.body 对象装饰器，作为路由页面方法参数，获取 request.body 对象 */
-declare function reqBody(target: any, propertyKey: string, parameterIndex: number) : void;
+declare function reqBody(target: any, propertyKey: string, parameterIndex: number): void;
 /** request.param 值装饰器，作为路由页面方法参数，获取 request.params 内容 */
-declare function reqParam(target: any, propertyKey: string, parameterIndex: number) : void;
+declare function reqParam(target: any, propertyKey: string, parameterIndex: number): void;
 /** request.query 值装饰器，作为路由页面方法参数，获取 request.query 内容 */
-declare function reqQuery(target: any, propertyKey: string, parameterIndex: number) : void;
+declare function reqQuery(target: any, propertyKey: string, parameterIndex: number): void;
 /** request 表单值装饰器，作为路由页面方法参数，获取 request.body 表单内容 */
-declare function reqForm(paramName: string) : (target: any, propertyKey: string, parameterIndex: number) => void;
+declare function reqForm(paramName: string): (target: any, propertyKey: string, parameterIndex: number) => void;
 
 /**框架 Web 服务工厂类 */
 declare abstract class ServerFactory {
@@ -275,7 +277,22 @@ declare abstract class AuthenticationFactory {
 declare class Redis extends IoRedis {
     /**获取 Redis 实例 */
     getRedis(): Redis;
-    constructor(config: any);
+    /**
+     * 获取有序集合（sorted set），按照分数从大到小排序，返回 Map 对象
+     * @param key 键
+     * @param start 开始位置，0 表示第一个元素，-1 表示最后一个元素
+     * @param stop 结束位置，0 表示第一个元素，-1 表示最后一个元素
+     * @returns Map 对象，key 为有序集合的成员，value 为成员的分数
+     */
+    zrevranking(key: RedisKey, start: number | string, stop: number | string): Promise<Map<string, number>>;
+    /**
+     * 获取有序集合（sorted set），按照分数从小到大排序，返回 Map 对象
+     * @param key 键
+     * @param start 开始位置，0 表示第一个元素，-1 表示最后一个元素
+     * @param stop 结束位置，0 表示第一个元素，-1 表示最后一个元素
+     * @returns Map 对象，key 为有序集合的成员，value 为成员的分数
+     */
+    zranking(key: RedisKey, start: number | string, stop: number | string): Promise<Map<string, number>>;
 }
 /**读写数据源实现类 */
 declare class ReadWriteDb extends DataSourceFactory {
@@ -359,4 +376,4 @@ declare class ExpressServer extends ServerFactory {
     private setDefaultMiddleware;
 }
 
-export { ExpressServer, LogDefault, NodeCache, RabbitMQ, rabbitListener, ReadWriteDb, Redis, CacheFactory, DataSourceFactory, LogFactory, ServerFactory, AuthenticationFactory, next, reqBody, reqQuery, reqForm, reqParam, req, req as request, res, res as response, component, bean, resource, log, app, before, after, value, error, config, autoware, getBean, getComponent, schedule, getMapping, postMapping, requestMapping, setRouter, upload, jwt, insert, update, remove, select, param, resultType, cache, Model};
+export { ExpressServer, LogDefault, NodeCache, RabbitMQ, rabbitListener, redisSubscriber, ReadWriteDb, Redis, CacheFactory, DataSourceFactory, LogFactory, ServerFactory, AuthenticationFactory, next, reqBody, reqQuery, reqForm, reqParam, req, req as request, res, res as response, component, bean, resource, log, app, before, after, value, error, config, autoware, getBean, getComponent, schedule, getMapping, postMapping, requestMapping, setRouter, upload, jwt, insert, update, remove, select, param, resultType, cache, Model };

package/src/typespeed.ts

@@ -97,6 +97,6 @@ export { default as AuthenticationFactory} from "./factory/authentication-factor
 export { default as ExpressServer} from "./default/express-server.class";
 export { default as LogDefault} from "./default/log-default.class";
 export { default as NodeCache} from "./default/node-cache.class";
-export { default as Redis} from "./default/redis.class";
+export { Redis, redisSubscriber } from "./default/redis.class";
 export { default as ReadWriteDb} from "./default/read-write-db.class";
 export * from "./default/rabbitmq.class";

package/test/database.test.ts

@@ -1,19 +1,22 @@
+
 const chaiObj = require('chai');
 chaiObj.use(require("chai-http"));
 const expect = chaiObj.expect;
 describe("Test Database", () => {
+    const randomId = random(3000, 5000);
+    const testAddr = `http://${process.env.LOCAL_HOST || "localhost"}:8081`;
     const testDatabase = [
         {
-            "url": "/db/insert?id=" + Math.ceil(Math.random() * 1000),
-            "expect": "Insert success",
+            "url": "/db/insert?id=" + randomId,
+            "expect": "Insert success: " + randomId,
         },
         {
-            "url": "/db/insert2",
-            "expect": "Insert success",
+            "url": "/db/insert2?id=" + (randomId + 1),
+            "expect": "Insert success: " + (randomId + 1),
         },
         {
-            "url": "/db/update",
-            "expect": "update success",
+            "url": "/db/update?id=" + randomId,
+            "expect": "update success: 1",
         },
         {
             "url": "/db/set-cache?value=zzz",
@@ -26,22 +29,22 @@ describe("Test Database", () => {
     ]
     testDatabase.forEach((testRequest) => {
         it(testRequest.url, (done) => {
-            chaiObj.request("http://localhost:8081").get(testRequest.url).end((err, res) => {
+            chaiObj.request(testAddr).get(testRequest.url).end((err, res) => {
                 chaiObj.assert.equal(testRequest.expect, res.text);
                 return done();
             });
         });
     });
-    it("/db/select1", (done) => {
-        chaiObj.request("http://localhost:8081").get("/db/select1").end((err, res) => {
+    it("/db/select-row", (done) => {
+        chaiObj.request(testAddr).get("/db/select-row?id=" + randomId).end((err, res) => {
             const dataList = JSON.parse(res.text);
             expect(dataList).to.be.an('array');
-            expect(dataList[0]).to.have.property("id").which.is.a("number").equal(1);
+            expect(dataList[0]).to.have.property("id").which.is.a("number").equal(randomId);
             done();
         });
     });
     it("/db/select", (done) => {
-        chaiObj.request("http://localhost:8081").get("/db/select").end((err, res) => {
+        chaiObj.request(testAddr).get("/db/select").end((err, res) => {
             const dataList = JSON.parse(res.text);
             expect(dataList).to.be.an('array');
             expect(dataList[0]).to.have.property('id');
@@ -49,7 +52,7 @@ describe("Test Database", () => {
         });
     });
     it("/db/select-user", (done) => {
-        chaiObj.request("http://localhost:8081").get("/db/select-user").end((err, res) => {
+        chaiObj.request(testAddr).get("/db/select-user").end((err, res) => {
             const dataList = JSON.parse(res.text);
             expect(dataList).to.be.an('array');
             expect(dataList[0]).to.have.property('id');
@@ -58,4 +61,8 @@ describe("Test Database", () => {
     });
 });
 
+function random(min, max) {
+    return Math.round(Math.random() * (max - min)) + min;
+}
+
 export {};

package/test/first-page.test.ts

@@ -2,6 +2,7 @@ const chaiObj = require('chai');
 chaiObj.use(require("chai-http"));
 
 describe("Test First page", () => {
+    const testAddr = `http://${process.env.LOCAL_HOST || "localhost"}:8081`;
     const firstPageRequests = [
         {
             "url": "/first",
@@ -29,7 +30,7 @@ describe("Test First page", () => {
     ]
     firstPageRequests.forEach((testRequest) => {
         it(testRequest.url, (done) => {
-            chaiObj.request("http://localhost:8081").get(testRequest.url).end((err, res) => {
+            chaiObj.request(testAddr).get(testRequest.url).end((err, res) => {
                 chaiObj.assert.equal(testRequest.expect, res.text);
                 return done();
             });

package/test/hooks.ts

@@ -1,10 +1,13 @@
 let appClose;
-before(() => {
+before(function () {
+    this.timeout(50000);
+    process.env["LOG"] = "CLOSE";
     appClose = require("../app/src/main");
 });
 
-after(() => {
+after((done) => {
     if(appClose != null){
         appClose.default();
     }
+    done();
 });

package/test/mq.test.ts

@@ -5,27 +5,10 @@ chaiObj.use(require("chai-http"));
 const expect = chaiObj.expect;
 
 describe("Test RabbitMQ", () => {
-    it("/mq/listen", (done) => {
-        chaiObj.request("http://localhost:8081").get("/mq/listen").end((err, res) => {
-            expect(res.text).to.be.equal("ok");
-            done();
-        });
-    });
+    const testAddr = `http://${process.env.LOCAL_HOST || "localhost"}:8081`;
     it("/mq/sendByMQClass", (done) => {
-        chaiObj.request("http://localhost:8081").get("/mq/sendByMQClass").end((err, res) => {
-            expect(res.text).to.be.equal("sent by MQClass");
-            done();
-        });
-    });
-    it("/mq/sendByQueue", (done) => {
-        chaiObj.request("http://localhost:8081").get("/mq/sendByQueue").end((err, res) => {
-            expect(res.text).to.be.equal("sent by queue");
-            done();
-        });
-    });
-    it("/mq/sendByExchange", (done) => {
-        chaiObj.request("http://localhost:8081").get("/mq/sendByExchange").end((err, res) => {
-            expect(res.text).to.be.equal("sent by exchange");
+        chaiObj.request(testAddr).get("/mq/sendByMQClass").end((err, res) => {
+            expect(res.text).to.be.equal("Sent by MQClass");
             done();
         });
     });

package/test/orm.test.ts

@@ -3,56 +3,57 @@ chaiObj.use(require("chai-http"));
 const expect = chaiObj.expect;
 
 describe("Test Request Paramters", () => {
+    const testAddr = `http://${process.env.LOCAL_HOST || "localhost"}:8081`;
     it("/redis", (done) => {
-        chaiObj.request("http://localhost:8081").get("/redis").end((err, res) => {
+        chaiObj.request(testAddr).get("/redis").end((err, res) => {
             expect(res.text).to.be.equal("get from redis: " + "Hello World");
             done();
         });
     });
     it("/orm/first", (done) => {
-        chaiObj.request("http://localhost:8081").get("/orm/first").end((err, res) => {
+        chaiObj.request(testAddr).get("/orm/first").end((err, res) => {
             expect(res.text).to.be.equal("first test, to getUsers");
             done();
         });
     });
     it("/orm/one", (done) => {
-        chaiObj.request("http://localhost:8081").get("/orm/one?id=1").end((err, res) => {
+        chaiObj.request(testAddr).get("/orm/one?id=1").end((err, res) => {
             expect(res.text).to.be.equal("find one test, to getUser");
             done();
         });
     });
     it("/orm/delete", (done) => {
-        chaiObj.request("http://localhost:8081").get("/orm/delete?id=0").end((err, res) => {
+        chaiObj.request(testAddr).get("/orm/delete?id=0").end((err, res) => {
             expect(res.text).to.be.equal("remove user, results: remove rows: 0");
             done();
         });
     });
     it("/orm/count", (done) => {
-        chaiObj.request("http://localhost:8081").get("/orm/count").end((err, res) => {
+        chaiObj.request(testAddr).get("/orm/count").end((err, res) => {
             expect(JSON.parse(res.text)).to.have.property("count").which.is.a("number").above(0);
             done();
         });
     });
     it("/orm/new", (done) => {
-        chaiObj.request("http://localhost:8081").get("/orm/new").end((err, res) => {
+        chaiObj.request(testAddr).get("/orm/new").end((err, res) => {
             expect(JSON.parse(res.text)).to.have.property("newId").which.is.a("number").above(0);
             done();
         });
     });
     it("/orm/page/calculate", (done) => {
-        chaiObj.request("http://localhost:8081").get("/orm/page/calculate").end((err, res) => {
+        chaiObj.request(testAddr).get("/orm/page/calculate").end((err, res) => {
             expect(JSON.parse(res.text)).to.have.property("totalPage").which.is.a("number").equal(38);
             done();
         });
     });
     it("/orm/pages", (done) => {
-        chaiObj.request("http://localhost:8081").get("/orm/pages/1").end((err, res) => {
+        chaiObj.request(testAddr).get("/orm/pages/1").end((err, res) => {
             expect(JSON.parse(res.text)).is.a("array").lengthOf(3);
             done();
         });
     });
     it("/orm/edit", (done) => {
-        chaiObj.request("http://localhost:8081").post("/orm/edit")
+        chaiObj.request(testAddr).post("/orm/edit")
             .type("form")
             .send({ id: 1, name: "new name" })
             .end((err, res) => {

package/test/redis.test.ts

@@ -0,0 +1,48 @@
+const chaiObj = require('chai');
+chaiObj.use(require("chai-http"));
+const expect = chaiObj.expect;
+
+describe("Test Redis", () => {
+    const testAddr = `http://${process.env.LOCAL_HOST || "localhost"}:8081`;
+    const ranking = {
+        "zhangsan": 93, "lisi": 99, "wangwu": 96, "zhaoliu": 97, "qianqi": 98, "sunba": 92, "zhoujiu": 94, "wushi": 95
+    };
+    it("/redis", (done) => {
+        chaiObj.request(testAddr).get("/redis").end((err, res) => {
+            expect(res.text).to.be.equal("get from redis: " + "Hello World");
+            done();
+        });
+    });
+    it("/redis/publish", (done) => {
+        chaiObj.request(testAddr).get("/redis/publish").end((err, res) => {
+            expect(res.text).to.be.equal("Published!");
+            done();
+        });
+    });
+    Object.keys(ranking).forEach((item) => {
+        it("/redis/add " + item, (done) => {
+            chaiObj.request(testAddr).get(`/redis/add?name=${item}&score=${ranking[item]}`).end((err, res) => {
+                expect(res.text).to.be.equal("add zset success");
+                done();
+            });
+        });
+    });
+    it("/redis/list", (done) => {
+        chaiObj.request(testAddr).get("/redis/list").end((err, res) => {
+            const dataList = JSON.parse(res.text);
+            const rankingAsc = Object.fromEntries(Object.entries(ranking).sort((a, b) => a[1] - b[1]));
+            expect(JSON.stringify(dataList)).to.be.equal(JSON.stringify(rankingAsc));
+            done();
+        });
+    });
+    it("/redis/ranking", (done) => {
+        chaiObj.request(testAddr).get("/redis/ranking").end((err, res) => {
+            const dataList = JSON.parse(res.text);
+            const rankingDesc = Object.fromEntries(Object.entries(ranking).sort((a, b) => b[1] - a[1]));
+            expect(JSON.stringify(dataList)).to.be.equal(JSON.stringify(rankingDesc));
+            done();
+        });
+    });
+});
+
+export { };

package/test/request.test.ts

@@ -5,14 +5,15 @@ chaiObj.use(require("chai-http"));
 const expect = chaiObj.expect;
 
 describe("Test Request Paramters", () => {
+    const testAddr = `http://${process.env.LOCAL_HOST || "localhost"}:8081`;
     it("/request/res", (done) => {
-        chaiObj.request("http://localhost:8081").get("/request/res").end((err, res) => {
+        chaiObj.request(testAddr).get("/request/res").end((err, res) => {
             expect(res.text).to.be.equal("test res");
             done();
         });
     });
     it("/request/query", (done) => {
-        chaiObj.request("http://localhost:8081").get("/request/query?id=100").end((err, res) => {
+        chaiObj.request(testAddr).get("/request/query?id=100").end((err, res) => {
             expect(res.text).to.be.equal(JSON.stringify(
                 new MutilUsers("group", [new UserDto(1, "name"), new UserDto(2, "name")]
             )));
@@ -21,7 +22,7 @@ describe("Test Request Paramters", () => {
     });
     it("/request/body", (done) => {
         const sendUser = new UserDto(100, "name100");
-        chaiObj.request("http://localhost:8081").post("/request/body")
+        chaiObj.request(testAddr).post("/request/body")
             .send(sendUser)
             .end((err, res) => {
             expect(res.text).to.be.equal(JSON.stringify(new MutilUsers("group", [sendUser])));
@@ -30,7 +31,7 @@ describe("Test Request Paramters", () => {
     });
     it("/request/form", (done) => {
         const sendName = "name200";
-        chaiObj.request("http://localhost:8081").post("/request/form")
+        chaiObj.request(testAddr).post("/request/form")
             .type("form")
             .send({ name: sendName })
             .end((err, res) => {
@@ -40,7 +41,7 @@ describe("Test Request Paramters", () => {
     });
     it("/request/param", (done) => {
         const sendId = 200;
-        chaiObj.request("http://localhost:8081").get("/request/param/" + sendId).end((err, res) => {
+        chaiObj.request(testAddr).get("/request/param/" + sendId).end((err, res) => {
             expect(res.text).to.be.equal("test param: " + sendId);
             done();
         });

package/test/second-page.test.ts

@@ -1,34 +1,33 @@
 import * as jwttoken from "jsonwebtoken";
 import * as fs from "fs";
 const chaiObj = require('chai');
-
 chaiObj.use(require("chai-http"));
 
-
 describe("Test Sencond Page", () => {
+    const testAddr = `http://${process.env.LOCAL_HOST || "localhost"}:8081`;
     it("/second/setCookie", (done) => {
-        chaiObj.request("http://localhost:8081").get("/second/setCookie").end((err, res) => {
+        chaiObj.request(testAddr).get("/second/setCookie").end((err, res) => {
             chaiObj.assert.equal(res.headers["set-cookie"].includes("name=zzz; Path=/"), true);
             done();
         });
     });
     it("/second/getCookie", (done) => {
         const cookieSet = "mycookie"
-        chaiObj.request("http://localhost:8081").get("/second/getCookie")
+        chaiObj.request(testAddr).get("/second/getCookie")
             .set("Cookie", "name=" + cookieSet).end((err, res) => {
                 chaiObj.assert.equal(res.text, "getCookie: " + cookieSet);
                 done();
             });
     });
     it("/second/testSession", (done) => {
-        chaiObj.request("http://localhost:8081").get("/second/testSession").end((err, res) => {
+        chaiObj.request(testAddr).get("/second/testSession").end((err, res) => {
             chaiObj.assert.equal(res.text, "testForSession: 1");
             done();
         });
     });
     it("/upload", (done) => {
         const uploadfile = "./app/static/k.jpg";
-        chaiObj.request("http://localhost:8081").post("/upload")
+        chaiObj.request(testAddr).post("/upload")
             .set('Content-Type', 'multipart/form-data')
             .attach("file", uploadfile)
             .end((err, res) => {
@@ -39,7 +38,7 @@ describe("Test Sencond Page", () => {
     it("/form", (done) => {
         const token = jwttoken.sign({ foo: 'bar' }, 'shhhhhhared-secret');
         const fileContents = fs.readFileSync("./app/src/views/upload.html", "utf8");
-        chaiObj.request("http://localhost:8081").post("/form")
+        chaiObj.request(testAddr).post("/form")
             .set({ "Authorization": `Bearer ${token}` })
             .end((err, res) => {
                 chaiObj.assert.equal(res.text, fileContents);