fix: jest test global env

test/global.d.ts

@@ -0,0 +1,16 @@
+import { ModelType } from '@typegoose/typegoose/lib/types'
+import { Consola } from 'consola'
+import { Document, PaginateModel } from 'mongoose'
+import 'zx/globals'
+declare global {
+  export type KV<T = any> = Record<string, T>
+
+  // @ts-ignore
+  export type MongooseModel<T> = ModelType<T> & PaginateModel<T & Document>
+
+  export const isDev: boolean
+
+  export const consola: Consola
+}
+
+export {}

test/helper/db-mock.helper.ts

@@ -1,3 +1,10 @@
+import { getModelForClass } from '@typegoose/typegoose'
+import {
+  AnyParamConstructor,
+  BeAnObject,
+  IModelOptions,
+  ReturnModelType,
+} from '@typegoose/typegoose/lib/types'
 import { MongoMemoryServer } from 'mongodb-memory-server'
 import mongoose from 'mongoose'
 
@@ -42,4 +49,11 @@ export const dbHelper = {
   connect,
   close: closeDatabase,
   clear: clearDatabase,
+
+  getModel<U extends AnyParamConstructor<any>, QueryHelpers = BeAnObject>(
+    cl: U,
+    options?: IModelOptions,
+  ): ReturnModelType<U, QueryHelpers> {
+    return getModelForClass(cl, options)
+  },
 }

test/helper/redis-mock.helper.ts

@@ -1,5 +1,6 @@
 import IORedis from 'ioredis'
 import RedisMemoryServer from 'redis-memory-server'
+import { CacheService } from '~/processors/cache/cache.service'
 
 export class MockCacheService {
   private client: IORedis.Redis
@@ -24,19 +25,24 @@ export class MockCacheService {
   }
 }
 
-export const createMockRedis = async () => {
-  const redisServer = new RedisMemoryServer()
+const createMockRedis = async () => {
+  const redisServer = new RedisMemoryServer({})
 
   const redisHost = await redisServer.getHost()
   const redisPort = await redisServer.getPort()
 
-  const service = new MockCacheService(redisPort, redisHost)
+  const cacheService = new MockCacheService(redisPort, redisHost)
 
   return {
-    service,
+    connect: () => null,
+    CacheService: cacheService,
+    // token: 'CacheService' as const,
+    token: CacheService,
     async close() {
-      await service.getClient().quit()
+      await cacheService.getClient().quit()
       await redisServer.stop()
     },
   }
 }
+
+export const redisHelper = createMockRedis()

test/register-global.ts

@@ -1,5 +0,0 @@
-Object.assign(global, {
-  isDev: true,
-})
-
-export const registerGlobal = () => null

test/src/modules/configs/configs.service.spec.ts

@@ -4,10 +4,7 @@ import { Test } from '@nestjs/testing'
 import { getModelForClass } from '@typegoose/typegoose'
 import { getModelToken } from 'nestjs-typegoose'
 import { dbHelper } from 'test/helper/db-mock.helper'
-import {
-  createMockRedis,
-  MockCacheService,
-} from 'test/helper/redis-mock.helper'
+import { MockCacheService, redisHelper } from 'test/helper/redis-mock.helper'
 import { RedisKeys } from '~/constants/cache.constant'
 import { OptionModel } from '~/modules/configs/configs.model'
 import { ConfigsService } from '~/modules/configs/configs.service'
@@ -17,18 +14,18 @@ import { getRedisKey } from '~/utils/redis.util'
 
 describe('Test ConfigsService', () => {
   let service: ConfigsService
-  let closeRedis: any
+
   let redisService: MockCacheService
   afterAll(async () => {
     await dbHelper.clear()
     await dbHelper.close()
-    await closeRedis()
+    await (await redisHelper).close()
   })
   const optionModel = getModelForClass(OptionModel)
   const mockEmitFn = jest.fn()
   beforeAll(async () => {
-    const { service: redisService$, close } = await createMockRedis()
-    closeRedis = close
+    const { CacheService: redisService$ } = await redisHelper
+
     redisService = redisService$
     await dbHelper.connect()
 

test/src/modules/markdown/markdown.service.spec.ts

@@ -45,7 +45,7 @@ describe('test Markdown Service', () => {
   })
 
   it('should render markdown to html', async () => {
-    const html = await service.renderMarkdownContent('# title')
+    const html = service.renderMarkdownContent('# title')
     expect(html).toBe('<h1 id="title">title</h1>\n')
   })
 })

test/src/modules/user/user.controller.e2e-spec.ts

@@ -1,7 +1,8 @@
 import { NestFastifyApplication } from '@nestjs/platform-fastify'
 import { Test } from '@nestjs/testing'
-import { hashSync } from 'bcrypt'
 import { getModelToken } from 'nestjs-typegoose'
+import { dbHelper } from 'test/helper/db-mock.helper'
+import { redisHelper } from 'test/helper/redis-mock.helper'
 import { fastifyApp } from '~/common/adapters/fastify.adapter'
 import { AuthService } from '~/modules/auth/auth.service'
 import { UserController } from '~/modules/user/user.controller'
@@ -11,44 +12,31 @@ import { UserService } from '~/modules/user/user.service'
 describe('AppController (e2e)', () => {
   let app: NestFastifyApplication
 
+  afterAll(async () => {
+    await dbHelper.close()
+    await (await redisHelper).close()
+  })
+
   beforeAll(async () => {
+    await dbHelper.connect()
+    const { CacheService, token } = await redisHelper
     const moduleRef = await Test.createTestingModule({
       controllers: [UserController],
       providers: [
+        UserService,
+        {
+          provide: getModelToken(UserModel.name),
+          useValue: dbHelper.getModel(UserModel),
+        },
+        { provide: token, useValue: CacheService },
         {
           provide: AuthService,
           useValue: {
-            signToken() {
-              return ''
+            signToken(val) {
+              return '' + val
             },
           },
         },
-        {
-          provide: UserService,
-          useValue: {
-            login() {
-              return {
-                username: 'test',
-                avatar: '',
-                email: 'tukon@gmail.com',
-              }
-            },
-            recordFootstep() {
-              return {}
-            },
-          },
-        },
-        {
-          provide: getModelToken(UserModel.name),
-          useValue: {
-            findOne: jest.fn().mockImplementationOnce(() => ({
-              select: jest.fn().mockResolvedValueOnce({
-                username: 'test',
-                password: hashSync('pwd', 2),
-              }),
-            })),
-          },
-        },
       ],
     }).compile()
 
@@ -57,14 +45,50 @@ describe('AppController (e2e)', () => {
     await app.getHttpAdapter().getInstance().ready()
   })
 
+  it('POST /master/register', () => {
+    return app
+      .inject({
+        method: 'POST',
+        url: '/master/register',
+        payload: {
+          email: '11@example.com',
+          username: '11',
+          name: '11',
+          password: '11',
+        },
+      })
+      .then((res) => {
+        expect(res.statusCode).toBe(201)
+        const json = JSON.parse(res.payload)
+        expect(json.username).toBe('11')
+        expect(json.password).toBeUndefined()
+        expect(json.authCode).toBeDefined()
+      })
+  })
+
+  it('should throw if register again', () => {
+    return app
+      .inject({
+        method: 'POST',
+        url: '/master/register',
+        payload: {
+          username: '111',
+          password: 'aaa',
+        },
+      })
+      .then((res) => {
+        expect(res.statusCode).toBe(400)
+      })
+  })
+
   it('GET /master/login', () => {
     return app
       .inject({
         method: 'POST',
         url: '/master/login',
         payload: {
-          username: 'test',
-          password: 'pwd',
+          username: '11',
+          password: '11',
         },
       })
       .then((res) => {

test/src/modules/user/user.controller.spec.ts

@@ -1,10 +1,9 @@
 import { Test } from '@nestjs/testing'
-import { registerGlobal } from 'test/register-global'
 import { AuthService } from '~/modules/auth/auth.service'
 import { UserController } from '~/modules/user/user.controller'
 import { UserService } from '~/modules/user/user.service'
 import { CacheService } from '~/processors/cache/cache.service'
-registerGlobal()
+
 describe('test UserModule controller', () => {
   let userController: UserController
 

test/src/modules/user/user.service.spec.ts

@@ -1,12 +1,10 @@
 import { BadRequestException } from '@nestjs/common'
 import { Test } from '@nestjs/testing'
 import { getModelToken } from 'nestjs-typegoose'
-import { registerGlobal } from 'test/register-global'
 import { AuthService } from '~/modules/auth/auth.service'
 import { UserModel } from '~/modules/user/user.model'
 import { UserService } from '~/modules/user/user.service'
 import { CacheService } from '~/processors/cache/cache.service'
-registerGlobal()
 
 describe('test UserModule service', () => {
   let userService: UserService