test: add case for jwt

src/modules/serverless/serverless.service.ts

@@ -15,6 +15,7 @@ import { Interval } from '@nestjs/schedule'
 
 import { RedisKeys } from '~/constants/cache.constant'
 import { DATA_DIR, NODE_REQUIRE_PATH } from '~/constants/path.constant'
+import { isTest } from '~/global/env.global'
 import { CacheService } from '~/processors/cache/cache.service'
 import { DatabaseService } from '~/processors/database/database.service'
 import { AssetService } from '~/processors/helper/helper.asset.service'
@@ -369,7 +370,7 @@ export class ServerlessService {
     if (!res) {
       throw new InternalServerErrorException('convert code error')
     }
-    console.debug(res.code)
+    !isTest && console.debug(res.code)
     return res.code
   }
 

src/processors/helper/helper.jwt.service.ts

@@ -6,6 +6,7 @@ import { Injectable } from '@nestjs/common'
 
 import { CLUSTER, SECURITY } from '~/app.config'
 import { RedisKeys } from '~/constants/cache.constant'
+import { isTest } from '~/global/env.global'
 import { getRedisKey, md5 } from '~/utils'
 
 import { CacheService } from '../cache/cache.service'
@@ -50,7 +51,7 @@ export class JWTService {
   async verify(token: string) {
     try {
       verify(token, this.secret)
-      return isDev ? true : await this.isTokenInRedis(token)
+      return isDev && !isTest ? true : await this.isTokenInRedis(token)
     } catch (er) {
       console.debug(er, token)
 

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

@@ -2,6 +2,8 @@ import { Test } from '@nestjs/testing'
 
 import { AuthService } from '~/modules/auth/auth.service'
 import { UserModel } from '~/modules/user/user.model'
+import { CacheService } from '~/processors/cache/cache.service'
+import { JWTService } from '~/processors/helper/helper.jwt.service'
 import { getModelToken } from '~/transformers/model.transformer'
 
 describe('Test AuthService', () => {
@@ -17,6 +19,15 @@ describe('Test AuthService', () => {
   beforeAll(async () => {
     const moduleRef = Test.createTestingModule({
       providers: [
+        { provide: CacheService, useValue: {} },
+        {
+          provide: JWTService,
+          useValue: {
+            sign() {
+              return 'fake token'
+            },
+          },
+        },
         AuthService,
         {
           provide: getModelToken(UserModel.name),

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

@@ -34,8 +34,10 @@ describe('AppController (e2e)', () => {
         {
           provide: AuthService,
           useValue: {
-            signToken(val) {
-              return `${val}`
+            jwtServicePublic: {
+              sign() {
+                return 'fake token'
+              },
             },
           },
         },
@@ -64,7 +66,6 @@ describe('AppController (e2e)', () => {
         const json = JSON.parse(res.payload)
         expect(json.username).toBe('11')
         expect(json.password).toBeUndefined()
-        expect(json.authCode).toBeDefined()
       })
   })
 

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

@@ -1,20 +1,25 @@
 import { BadRequestException } from '@nestjs/common'
 import { Test } from '@nestjs/testing'
-import { getModelToken } from '~/transformers/model.transformer'
+
 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'
+import { JWTService } from '~/processors/helper/helper.jwt.service'
+import { getModelToken } from '~/transformers/model.transformer'
 
 describe('test UserModule service', () => {
   let userService: UserService
+
   beforeEach(async () => {
     const storedUserList = []
     const module = await Test.createTestingModule({
+      imports: [CacheService],
       providers: [
         UserService,
         AuthService,
         CacheService,
+        JWTService,
         {
           provide: getModelToken(UserModel.name),
           useValue: {
@@ -44,13 +49,18 @@ describe('test UserModule service', () => {
     })
       .overrideProvider(AuthService)
       .useValue({
-        signToken() {
-          return 'fake token'
+        jwtServicePublic: {
+          sign() {
+            return 'fake token'
+          },
         },
       })
       .overrideProvider(CacheService)
       .useValue({})
+      .overrideProvider(JWTService)
+      .useValue({})
       .compile()
+
     userService = module.get<UserService>(UserService)
   })
 

test/src/processors/helper/helper.jwt.service.spec.ts

@@ -0,0 +1,70 @@
+import { redisHelper } from 'test/helper/redis-mock.helper'
+
+import { Test } from '@nestjs/testing'
+
+import { CacheService } from '~/processors/cache/cache.service'
+import { JWTService } from '~/processors/helper/helper.jwt.service'
+
+describe('test jwt service', () => {
+  let service: JWTService
+
+  afterAll(async () => {
+    await (await redisHelper).close()
+  })
+
+  beforeAll(async () => {
+    const { CacheService: MCacheService } = await redisHelper
+    const moduleRef = Test.createTestingModule({
+      providers: [JWTService, CacheService],
+    })
+      .overrideProvider(CacheService)
+      .useValue(MCacheService)
+
+    const module = await moduleRef.compile()
+    service = module.get(JWTService)
+  })
+
+  let token1 = ''
+
+  it('should sign token', async () => {
+    const _token = service.sign('1')
+    expect(_token).toBeDefined()
+
+    token1 = _token
+  })
+
+  it('should verify token', async () => {
+    const res = await service.verify(token1)
+    expect(res).toBeDefined()
+
+    const has = await service.isTokenInRedis(token1)
+    expect(has).toBeTruthy()
+  })
+
+  it('should remove token', async () => {
+    await service.revokeToken(token1)
+    const has = await service.isTokenInRedis(token1)
+    expect(has).toBeFalsy()
+
+    const res = await service.verify(token1)
+    expect(res).toBeFalsy()
+  })
+
+  it('should revoke all token', async () => {
+    const token1 = service.sign('1')
+    expect(token1).toBeDefined()
+    const token2 = service.sign('2')
+    expect(token2).toBeDefined()
+    const token3 = service.sign('2')
+    expect(token3).toBeDefined()
+
+    await service.revokeAll()
+
+    const res1 = await service.verify(token1)
+    expect(res1).toBeFalsy()
+    const res2 = await service.verify(token2)
+    expect(res2).toBeFalsy()
+    const res3 = await service.verify(token3)
+    expect(res3).toBeFalsy()
+  })
+})