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 protected]",
+    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 protected]", "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 protected]", "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 protected]", "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)
+        })
+    })
+
+})
+

source/api/v1/services/auth/AuthService.test.ts

@@ -1,13 +1,13 @@
-import { generateToken } from "../auth/jwt/TokenGenerator";
-import { IUsersService } from "./interfaces/UsersServiceInterface";
-import { AUTH_EXCEPTIONS } from "../shared/exceptions/AuthExceptions";
-import { IAuthService } from "./interfaces/AuthServiceInterface";
-import { CONFIG } from "../shared/config/ServerConfiguration";
+import { generateToken } from "../../auth/jwt/TokenGenerator";
+import { AUTH_EXCEPTIONS } from "../../shared/exceptions/AuthExceptions";
+import { IAuthService } from "./AuthServiceInterface";
+import { CONFIG } from "../../shared/config/ServerConfiguration";
 import bcrypt from 'bcrypt'
-import { USER_EXCEPTIONS } from "../shared/exceptions/UserExceptions";
+import { USER_EXCEPTIONS } from "../../shared/exceptions/UserExceptions";
 import { RedisClientType } from "redis";
-import { withExceptionCatch } from "../shared/decorators/WithExceptionCatch";
-import { isException } from "../shared/utils/guards/ExceptionGuard";
+import { withExceptionCatch } from "../../shared/decorators/WithExceptionCatch";
+import { isException } from "../../shared/utils/guards/ExceptionGuard";
+import { IUsersService } from "../users/UsersServiceInterface";
 
 export class AuthService implements IAuthService {
     constructor(

source/api/v1/services/AuthService.ts renamed to source/api/v1/services/auth/AuthService.ts

@@ -0,0 +1,5 @@
+import {describe, expect, test} from "@jest/globals";
+
+describe("Notes service tests", () => {
+    
+});

source/api/v1/services/interfaces/AuthServiceInterface.d.ts renamed to source/api/v1/services/auth/AuthServiceInterface.d.ts

@@ -4,20 +4,20 @@ import {
     NotePreview,
     NoteUpdate,
     NoteEntity,
-} from "../database/entities/Note";
+} from "../../database/entities/Note";
 import {
     User,
     UserEntity,
-} from "../database/entities/User";
-import {IUsersService} from "./interfaces/UsersServiceInterface";
-import {INotesService, NotesSearchOptions} from "./interfaces/NotesServiceInterface";
-import {NOTE_EXCEPTIONS} from "../shared/exceptions/NoteExceptions";
+} from "../../database/entities/User";
+import {IUsersService} from "../users/UsersServiceInterface";
+import {INotesService, NotesSearchOptions} from "./NotesServiceInterface";
+import {NOTE_EXCEPTIONS} from "../../shared/exceptions/NoteExceptions";
 import {Repository} from "typeorm";
-import {transformNoteCollaborators} from "../shared/utils/common/TransformNoteCollaborators";
+import {transformNoteCollaborators} from "../../shared/utils/common/TransformNoteCollaborators";
 import {excludeProperties} from "typing-assets";
-import {withExceptionCatch} from "../shared/decorators/WithExceptionCatch";
-import {isException} from "../shared/utils/guards/ExceptionGuard";
-import {USER_EXCEPTIONS} from "../shared/exceptions/UserExceptions";
+import {withExceptionCatch} from "../../shared/decorators/WithExceptionCatch";
+import {isException} from "../../shared/utils/guards/ExceptionGuard";
+import {USER_EXCEPTIONS} from "../../shared/exceptions/UserExceptions";
 
 export class NotesService implements INotesService {
     private static generateNoteId(): string {

source/api/v1/services/notes/NotesService.test.ts

@@ -0,0 +1,96 @@
+import { UserWithoutMetadata } from "../../database/entities/User"
+import { UsersService } from "./UsersService"
+import {describe, expect, test} from "@jest/globals"
+
+const mockFindOneBy = jest.fn()
+const mockSave = jest.fn()
+
+const mockUpdate = jest.fn()
+
+const usersRepository = {
+    findOneBy: mockFindOneBy,
+    save: mockSave,
+    update: mockUpdate
+}
+// @ts-ignore
+const usersService = new UsersService(usersRepository)
+
+const user: UserWithoutMetadata = {
+    login: "login",
+    password: "12345678",
+    email: "[email protected]",
+    username: "username",
+    personalColor: "#ffffff",
+    isCollaborating: true
+}
+
+describe("Users service tests", () => {
+    describe("Create user tests", () => {
+        test("Should not return 'user already exists' error", async () => {
+            usersRepository.save.mockResolvedValueOnce(true)
+
+            const result = await usersService.createUser(user) as any
+
+            expect(result).toBeDefined()
+            expect(result).toEqual(true)
+        })
+
+        test("Should return 'user already exists' error", async () => {
+            usersRepository.save.mockResolvedValueOnce(true)
+            usersRepository.findOneBy.mockResolvedValueOnce(user)
+            
+            const result = await usersService.createUser(user) as any
+
+            expect(result).toBeDefined()
+            expect(result.message).toBeDefined()
+            expect(result.statusCode).toEqual(400)
+        })
+    })
+
+    describe("Get user tests", () => {
+        test("Should return user data", async () => {
+            usersRepository.findOneBy.mockResolvedValueOnce(user)
+
+            const result = await usersService.getUser("login", "login") as any
+
+            expect(result).toBeDefined()
+            expect(result.login).toEqual("login")
+        })
+
+        test("Should return 'user doesn't exist' error", async () => {
+            usersRepository.findOneBy.mockResolvedValueOnce(undefined)
+
+            const result = await usersService.getUser("login", "login") as any
+
+            expect(result).toBeDefined()
+            expect(result.message).toBeDefined()
+            expect(result.statusCode).toEqual(404)
+        })
+    })
+
+    describe("Update user tests", () => {
+        test("Should return user data", async () => {
+            usersRepository.findOneBy.mockResolvedValueOnce(user)
+            usersRepository.update.mockResolvedValueOnce(
+                { affected: true }
+            )
+
+            const result = await usersService.updateUserByLogin("login", {}) as any
+
+            expect(result).toBeDefined()
+            expect(result.login).toEqual("login")
+        })
+
+        test("Should return 'user doesn't exist' error", async () => {
+            usersRepository.update.mockResolvedValueOnce(
+                { affected: false }
+            )
+
+            const result = await usersService.updateUserByLogin("login", {}) as any
+
+            expect(result).toBeDefined()
+            expect(result.message).toBeDefined()
+            expect(result.statusCode).toEqual(404)
+        })
+    })
+});

source/api/v1/services/NotesService.ts renamed to source/api/v1/services/notes/NotesService.ts

@@ -1,15 +1,15 @@
-import { User, UserUpdate, UserWithoutMetadata, UserWithoutSensetives } from "../database/entities/User";
-import { IUsersService } from "./interfaces/UsersServiceInterface";
-import { USER_EXCEPTIONS } from "../shared/exceptions/UserExceptions";
+import { User, UserUpdate, UserWithoutMetadata, UserWithoutSensetives } from "../../database/entities/User";
+import { IUsersService } from "./UsersServiceInterface";
+import { USER_EXCEPTIONS } from "../../shared/exceptions/UserExceptions";
 import bcrypt from 'bcrypt'
 import { Repository } from "typeorm";
-import { withExceptionCatch } from "../shared/decorators/WithExceptionCatch";
+import { withExceptionCatch } from "../../shared/decorators/WithExceptionCatch";
 
 export class UsersService implements IUsersService {
     /**
      * @mutable Mutates initial
      * @param user `User` to omit
-     * @returns User without sensetive data such as `passoword` and `validToken`
+     * @returns User without sensetive data such as `password` and `validToken`
      */
     public static omitSensetiveData(user: User): UserWithoutSensetives {
         try {