added unit test cases

Author: LCcodder

jest.config.js

@@ -0,0 +1,7 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  setupFilesAfterEnv: ['./jest.setup.redis-mock.js'],
+  testMatch: ['**/*.test.ts']
+};

jest.setup.redis-mock.js

@@ -0,0 +1 @@
+jest.mock('redis', () => jest.requireActual('redis-mock'));

package-lock.json

@@ -3,7 +3,8 @@
   "version": "1.0.0",
   "description": "",
   "scripts": {
-    "start": "nodemon source/main.ts"
+    "start": "nodemon source/main.ts",
+    "test": "jest"
   },
   "keywords": [],
   "author": "",
@@ -21,14 +22,18 @@
     "pg": "^8.12.0",
     "redis": "^4.6.15",
     "reflect-metadata": "^0.2.2",
+    "ts-jest": "^29.2.5",
     "typeorm": "^0.3.20",
     "typing-assets": "^2.1.3"
   },
   "devDependencies": {
     "@types/bcrypt": "^5.0.2",
+    "@types/jest": "^29.5.14",
     "@types/jsonwebtoken": "^9.0.6",
     "@types/node": "^20.12.3",
+    "jest": "^29.7.0",
     "nodemon": "^3.1.0",
+    "redis-mock": "^0.56.3",
     "ts-node": "^10.9.2"
   }
 }

package.json

@@ -3,7 +3,7 @@ import { extractToken } from "../shared/utils/common/TokenExtractor";
 import { extractJwtPayload } from "./jwt/PayloadExtractor";
 import { validateSignature } from "./jwt/SignatureValidator";
 import { USER_EXCEPTIONS } from "../shared/exceptions/UserExceptions";
-import { IAuthService } from "../services/interfaces/AuthServiceInterface";
+import { IAuthService } from "../services/auth/AuthServiceInterface";
 import { isException } from "../shared/utils/guards/ExceptionGuard";
 
 export type AuthentificationPreHandler = (request: FastifyRequest, reply: FastifyReply, done: HookHandlerDoneFunction) => void

source/api/v1/auth/AuthPreHandler.ts

@@ -0,0 +1,18 @@
+import {describe, expect, test} from "@jest/globals";
+import { generateToken } from "./TokenGenerator";
+import * as jwt from "jsonwebtoken"
+
+describe("Token generator tests", () => {
+    test("Should generate different token twice", () => {
+        const token1 = generateToken("login")
+        const token2 = generateToken("login")
+
+        expect(token1).toEqual(token2)
+    });
+
+    test("Should have payload", () => {
+        const token = generateToken("login")
+        const { login } = jwt.decode(token) as any
+        expect(login).toEqual("login")
+    })
+});

source/api/v1/auth/jwt/TokenGenerator.test.ts

@@ -1,5 +1,5 @@
 import { FastifyInstance } from "fastify";
-import { IAuthService } from "../services/interfaces/AuthServiceInterface";
+import { IAuthService } from "../services/auth/AuthServiceInterface";
 import { UserCredentials } from "../database/entities/User";
 import { AUTH_EXCEPTIONS } from "../shared/exceptions/AuthExceptions";
 import { AuthUserSchema, ChangePasswordSchema } from "../validation/schemas/AuthSchemas";

source/api/v1/handlers/AuthHandlers.ts

@@ -1,5 +1,5 @@
 import { FastifyInstance } from "fastify";
-import { INotesService } from "../services/interfaces/NotesServiceInterface";
+import { INotesService } from "../services/notes/NotesServiceInterface";
 import { Note, NoteCollaborators, NotePreview, NoteUpdate, NoteWithoutMetadata } from "../database/entities/Note";
 import { NOTE_EXCEPTIONS } from "../shared/exceptions/NoteExceptions";
 import { extractJwtPayload } from "../auth/jwt/PayloadExtractor";

source/api/v1/handlers/NotesHandlers.ts

@@ -1,9 +1,9 @@
 import { FastifyInstance } from "fastify";
-import { IUsersService } from "../services/interfaces/UsersServiceInterface";
+import { IUsersService } from "../services/users/UsersServiceInterface";
 import { UserUpdate, UserWithoutMetadata, UserWithoutSensetives } from "../database/entities/User";
 import { USER_EXCEPTIONS } from "../shared/exceptions/UserExceptions";
 import { CreateUserSchema, GetMyProfileSchema, GetUserSchema, UpdateUserSchema } from "../validation/schemas/UserSchemas";
-import { UsersService } from "../services/UsersService";
+import { UsersService } from "../services/users/UsersService";
 import { extractJwtPayload } from "../auth/jwt/PayloadExtractor";
 import { extractToken } from "../shared/utils/common/TokenExtractor";
 import { isException } from "../shared/utils/guards/ExceptionGuard";

source/api/v1/handlers/UsersHandlers.ts

@@ -0,0 +1,105 @@
+import {describe, expect, test} from "@jest/globals"
+import * as bcrypt from "bcrypt"
+import { User } from "../../database/entities/User";
+import { AuthService } from "./AuthService";
+import redis from "redis";
+
+const user: User = {
+    login: "login",
+    password: bcrypt.hashSync("12345678", 4),
+    email: "email@email.com",
+    username: "username",
+    personalColor: "#ffffff",
+    isCollaborating: true,
+    createdAt: new Date(),
+    updatedAt: new Date()
+}
+
+// setting different values for different test scenarios
+const mockGetUser = jest.fn()
+const mockUpdateUser = jest.fn()
+
+const usersService = {
+    getUser: mockGetUser,
+    updateUserByLogin: mockUpdateUser
+}
+// @ts-ignore
+const authService = new AuthService(usersService, redis.createClient())
+
+
+describe("Auth service test", () => {
+    describe("Authorization tests", () => {
+        test("Should authorize, then generate and return token", async () => {
+            usersService.getUser.mockResolvedValueOnce(user)
+            const result = await authService.authorizeAndGenerateToken("email@email.com", "12345678") as any
+
+            expect(result).toBeDefined()
+            expect(result.expiresIn).toBeDefined()
+            expect(result.token.length).toBeGreaterThan(10)
+        })
+
+        test("Should return wrong credentials error (wrong email)", async () => {
+            usersService.getUser.mockResolvedValueOnce({
+                message: "",
+                statusCode: 404
+            })
+            const result = await authService.authorizeAndGenerateToken("email@email.com", "12345678") as any
+
+            expect(result).toBeDefined()
+            expect(result.message).toBeDefined()
+            expect(result.statusCode).toEqual(400)
+        })
+        
+        test("Should return wrong credentials error (wrong password)", async () => {
+            usersService.getUser.mockResolvedValueOnce(user)
+            const result = await authService.authorizeAndGenerateToken("email@email.com", "123456789") as any
+
+            expect(result).toBeDefined()
+            expect(result.message).toBeDefined()
+            expect(result.statusCode).toEqual(400)
+        })
+
+    });
+
+    describe("Change password tests", () => {
+        test("Should return success", async () => {
+            usersService.getUser.mockResolvedValueOnce(user)
+            const result = await authService.changePassword("login", "12345678", "23423423") as any
+
+            expect(result).toBeDefined()
+            expect(result.success).toEqual(true)
+        })
+
+        test("Should return wrong credentials error (wrong login)", async () => {
+            usersService.getUser.mockResolvedValueOnce({
+                message: "",
+                statusCode: 404
+            })
+            const result = await authService.changePassword("login", "12345678", "23423423") as any
+
+            expect(result).toBeDefined()
+            expect(result.message).toBeDefined()
+            expect(result.statusCode).toEqual(400)
+        })
+
+        test("Should return wrong credentials error (wrong old password)", async () => {
+            usersService.getUser.mockResolvedValueOnce(user)
+            const result = await authService.changePassword("login", "123456789", "23423423") as any
+
+            expect(result).toBeDefined()
+            expect(result.message).toBeDefined()
+            expect(result.statusCode).toEqual(400)
+        })
+
+        test("Should return passwords are same error", async () => {
+            usersService.getUser.mockResolvedValueOnce(user)
+            const result = await authService.changePassword("login", "12345678", "12345678") as any
+
+            expect(result).toBeDefined()
+            expect(result.message).toBeDefined()
+            expect(result.statusCode).toEqual(400)
+        })
+    })
+
+})
+