typescript-express-starter 9.1.2 → 10.0.0

package/lib/default/src/controllers/auth.controller.ts

@@ -1,16 +1,16 @@
 import { NextFunction, Request, Response } from 'express';
-import { CreateUserDto } from '@dtos/users.dto';
+import { Container } from 'typedi';
 import { RequestWithUser } from '@interfaces/auth.interface';
 import { User } from '@interfaces/users.interface';
-import AuthService from '@services/auth.service';
+import { AuthService } from '@services/auth.service';
 
-class AuthController {
-  public authService = new AuthService();
+export class AuthController {
+  public auth = Container.get(AuthService);
 
   public signUp = async (req: Request, res: Response, next: NextFunction): Promise<void> => {
     try {
-      const userData: CreateUserDto = req.body;
-      const signUpUserData: User = await this.authService.signup(userData);
+      const userData: User = req.body;
+      const signUpUserData: User = await this.auth.signup(userData);
 
       res.status(201).json({ data: signUpUserData, message: 'signup' });
     } catch (error) {
@@ -20,8 +20,8 @@ class AuthController {
 
   public logIn = async (req: Request, res: Response, next: NextFunction): Promise<void> => {
     try {
-      const userData: CreateUserDto = req.body;
-      const { cookie, findUser } = await this.authService.login(userData);
+      const userData: User = req.body;
+      const { cookie, findUser } = await this.auth.login(userData);
 
       res.setHeader('Set-Cookie', [cookie]);
       res.status(200).json({ data: findUser, message: 'login' });
@@ -33,7 +33,7 @@ class AuthController {
   public logOut = async (req: RequestWithUser, res: Response, next: NextFunction): Promise<void> => {
     try {
       const userData: User = req.user;
-      const logOutUserData: User = await this.authService.logout(userData);
+      const logOutUserData: User = await this.auth.logout(userData);
 
       res.setHeader('Set-Cookie', ['Authorization=; Max-age=0']);
       res.status(200).json({ data: logOutUserData, message: 'logout' });
@@ -42,5 +42,3 @@ class AuthController {
     }
   };
 }
-
-export default AuthController;

package/lib/default/src/controllers/users.controller.ts

@@ -1,14 +1,14 @@
 import { NextFunction, Request, Response } from 'express';
-import { CreateUserDto } from '@dtos/users.dto';
+import { Container } from 'typedi';
 import { User } from '@interfaces/users.interface';
-import userService from '@services/users.service';
+import { UserService } from '@services/users.service';
 
-class UsersController {
-  public userService = new userService();
+export class UserController {
+  public user = Container.get(UserService);
 
   public getUsers = async (req: Request, res: Response, next: NextFunction): Promise<void> => {
     try {
-      const findAllUsersData: User[] = await this.userService.findAllUser();
+      const findAllUsersData: User[] = await this.user.findAllUser();
 
       res.status(200).json({ data: findAllUsersData, message: 'findAll' });
     } catch (error) {
@@ -19,7 +19,7 @@ class UsersController {
   public getUserById = async (req: Request, res: Response, next: NextFunction): Promise<void> => {
     try {
       const userId = Number(req.params.id);
-      const findOneUserData: User = await this.userService.findUserById(userId);
+      const findOneUserData: User = await this.user.findUserById(userId);
 
       res.status(200).json({ data: findOneUserData, message: 'findOne' });
     } catch (error) {
@@ -29,8 +29,8 @@ class UsersController {
 
   public createUser = async (req: Request, res: Response, next: NextFunction): Promise<void> => {
     try {
-      const userData: CreateUserDto = req.body;
-      const createUserData: User = await this.userService.createUser(userData);
+      const userData: User = req.body;
+      const createUserData: User = await this.user.createUser(userData);
 
       res.status(201).json({ data: createUserData, message: 'created' });
     } catch (error) {
@@ -41,8 +41,8 @@ class UsersController {
   public updateUser = async (req: Request, res: Response, next: NextFunction): Promise<void> => {
     try {
       const userId = Number(req.params.id);
-      const userData: CreateUserDto = req.body;
-      const updateUserData: User[] = await this.userService.updateUser(userId, userData);
+      const userData: User = req.body;
+      const updateUserData: User[] = await this.user.updateUser(userId, userData);
 
       res.status(200).json({ data: updateUserData, message: 'updated' });
     } catch (error) {
@@ -53,7 +53,7 @@ class UsersController {
   public deleteUser = async (req: Request, res: Response, next: NextFunction): Promise<void> => {
     try {
       const userId = Number(req.params.id);
-      const deleteUserData: User[] = await this.userService.deleteUser(userId);
+      const deleteUserData: User[] = await this.user.deleteUser(userId);
 
       res.status(200).json({ data: deleteUserData, message: 'deleted' });
     } catch (error) {
@@ -61,5 +61,3 @@ class UsersController {
     }
   };
 }
-
-export default UsersController;

package/lib/default/src/dtos/users.dto.ts

@@ -1,9 +1,20 @@
-import { IsEmail, IsString } from 'class-validator';
+import { IsEmail, IsString, IsNotEmpty, MinLength, MaxLength } from 'class-validator';
 
 export class CreateUserDto {
   @IsEmail()
   public email: string;
 
   @IsString()
+  @IsNotEmpty()
+  @MinLength(9)
+  @MaxLength(32)
+  public password: string;
+}
+
+export class UpdateUserDto {
+  @IsString()
+  @IsNotEmpty()
+  @MinLength(9)
+  @MaxLength(32)
   public password: string;
 }

package/lib/default/src/interfaces/users.interface.ts

@@ -1,5 +1,5 @@
 export interface User {
-  id: number;
-  email: string;
+  id?: number;
+  email?: string;
   password: string;
 }

package/lib/default/src/middlewares/auth.middleware.ts

@@ -1,19 +1,27 @@
 import { NextFunction, Response } from 'express';
 import { verify } from 'jsonwebtoken';
 import { SECRET_KEY } from '@config';
-import { HttpException } from '@exceptions/HttpException';
+import { HttpException } from '@exceptions/httpException';
 import { DataStoredInToken, RequestWithUser } from '@interfaces/auth.interface';
-import userModel from '@models/users.model';
+import { UserModel } from '@models/users.model';
 
-const authMiddleware = async (req: RequestWithUser, res: Response, next: NextFunction) => {
+const getAuthorization = req => {
+  const coockie = req.cookies['Authorization'];
+  if (coockie) return coockie;
+
+  const header = req.header('Authorization');
+  if (header) return header.split('Bearer ')[1];
+
+  return null;
+};
+
+export const AuthMiddleware = async (req: RequestWithUser, res: Response, next: NextFunction) => {
   try {
-    const Authorization = req.cookies['Authorization'] || (req.header('Authorization') ? req.header('Authorization').split('Bearer ')[1] : null);
+    const Authorization = getAuthorization(req);
 
     if (Authorization) {
-      const secretKey: string = SECRET_KEY;
-      const verificationResponse = (await verify(Authorization, secretKey)) as DataStoredInToken;
-      const userId = verificationResponse.id;
-      const findUser = userModel.find(user => user.id === userId);
+      const { id } = (await verify(Authorization, SECRET_KEY)) as DataStoredInToken;
+      const findUser = UserModel.find(user => user.id === id);
 
       if (findUser) {
         req.user = findUser;
@@ -28,5 +36,3 @@ const authMiddleware = async (req: RequestWithUser, res: Response, next: NextFun
     next(new HttpException(401, 'Wrong authentication token'));
   }
 };
-
-export default authMiddleware;

package/lib/default/src/middlewares/error.middleware.ts

@@ -1,8 +1,8 @@
 import { NextFunction, Request, Response } from 'express';
-import { HttpException } from '@exceptions/HttpException';
+import { HttpException } from '@exceptions/httpException';
 import { logger } from '@utils/logger';
 
-const errorMiddleware = (error: HttpException, req: Request, res: Response, next: NextFunction) => {
+export const ErrorMiddleware = (error: HttpException, req: Request, res: Response, next: NextFunction) => {
   try {
     const status: number = error.status || 500;
     const message: string = error.message || 'Something went wrong';
@@ -13,5 +13,3 @@ const errorMiddleware = (error: HttpException, req: Request, res: Response, next
     next(error);
   }
 };
-
-export default errorMiddleware;

package/lib/default/src/middlewares/validation.middleware.ts

@@ -1,25 +1,27 @@
-import { plainToClass } from 'class-transformer';
-import { validate, ValidationError } from 'class-validator';
-import { RequestHandler } from 'express';
-import { HttpException } from '@exceptions/HttpException';
+import { plainToInstance } from 'class-transformer';
+import { validateOrReject, ValidationError } from 'class-validator';
+import { NextFunction, Request, Response } from 'express';
+import { HttpException } from '@exceptions/httpException';
 
-const validationMiddleware = (
-  type: any,
-  value: string | 'body' | 'query' | 'params' = 'body',
-  skipMissingProperties = false,
-  whitelist = true,
-  forbidNonWhitelisted = true,
-): RequestHandler => {
-  return (req, res, next) => {
-    validate(plainToClass(type, req[value]), { skipMissingProperties, whitelist, forbidNonWhitelisted }).then((errors: ValidationError[]) => {
-      if (errors.length > 0) {
+/**
+ * @name ValidationMiddleware
+ * @description Allows use of decorator and non-decorator based validation
+ * @param type dto
+ * @param skipMissingProperties When skipping missing properties
+ * @param whitelist Even if your object is an instance of a validation class it can contain additional properties that are not defined
+ * @param forbidNonWhitelisted If you would rather to have an error thrown when any non-whitelisted properties are present
+ */
+export const ValidationMiddleware = (type: any, skipMissingProperties = false, whitelist = true, forbidNonWhitelisted = true) => {
+  return (req: Request, res: Response, next: NextFunction) => {
+    const dto = plainToInstance(type, req.body);
+    validateOrReject(dto, { skipMissingProperties, whitelist, forbidNonWhitelisted })
+      .then(() => {
+        req.body = dto;
+        next();
+      })
+      .catch((errors: ValidationError[]) => {
         const message = errors.map((error: ValidationError) => Object.values(error.constraints)).join(', ');
         next(new HttpException(400, message));
-      } else {
-        next();
-      }
-    });
+      });
   };
 };
-
-export default validationMiddleware;

package/lib/default/src/models/users.model.ts

@@ -1,11 +1,9 @@
 import { User } from '@interfaces/users.interface';
 
-// password: password
-const userModel: User[] = [
-  { id: 1, email: 'example1@email.com', password: '$2b$10$TBEfaCe1oo.2jfkBDWcj/usBj4oECsW2wOoDXpCa2IH9xqCpEK/hC' },
-  { id: 2, email: 'example2@email.com', password: '$2b$10$TBEfaCe1oo.2jfkBDWcj/usBj4oECsW2wOoDXpCa2IH9xqCpEK/hC' },
-  { id: 3, email: 'example3@email.com', password: '$2b$10$TBEfaCe1oo.2jfkBDWcj/usBj4oECsW2wOoDXpCa2IH9xqCpEK/hC' },
-  { id: 4, email: 'example4@email.com', password: '$2b$10$TBEfaCe1oo.2jfkBDWcj/usBj4oECsW2wOoDXpCa2IH9xqCpEK/hC' },
+// password: password123456789
+export const UserModel: User[] = [
+  { id: 1, email: 'example1@email.com', password: '$2b$10$2YC2ht8x06Yto5VAr08kben8.oxjTPrMn0yJhv8xxSVVltH3bOs4u' },
+  { id: 2, email: 'example2@email.com', password: '$2b$10$2YC2ht8x06Yto5VAr08kben8.oxjTPrMn0yJhv8xxSVVltH3bOs4u' },
+  { id: 3, email: 'example3@email.com', password: '$2b$10$2YC2ht8x06Yto5VAr08kben8.oxjTPrMn0yJhv8xxSVVltH3bOs4u' },
+  { id: 4, email: 'example4@email.com', password: '$2b$10$2YC2ht8x06Yto5VAr08kben8.oxjTPrMn0yJhv8xxSVVltH3bOs4u' },
 ];
-
-export default userModel;

package/lib/default/src/routes/auth.route.ts

@@ -1,24 +1,21 @@
 import { Router } from 'express';
-import AuthController from '@controllers/auth.controller';
+import { AuthController } from '@controllers/auth.controller';
 import { CreateUserDto } from '@dtos/users.dto';
 import { Routes } from '@interfaces/routes.interface';
-import authMiddleware from '@middlewares/auth.middleware';
-import validationMiddleware from '@middlewares/validation.middleware';
+import { AuthMiddleware } from '@middlewares/auth.middleware';
+import { ValidationMiddleware } from '@middlewares/validation.middleware';
 
-class AuthRoute implements Routes {
-  public path = '/';
+export class AuthRoute implements Routes {
   public router = Router();
-  public authController = new AuthController();
+  public auth = new AuthController();
 
   constructor() {
     this.initializeRoutes();
   }
 
   private initializeRoutes() {
-    this.router.post(`${this.path}signup`, validationMiddleware(CreateUserDto, 'body'), this.authController.signUp);
-    this.router.post(`${this.path}login`, validationMiddleware(CreateUserDto, 'body'), this.authController.logIn);
-    this.router.post(`${this.path}logout`, authMiddleware, this.authController.logOut);
+    this.router.post('/signup', ValidationMiddleware(CreateUserDto), this.auth.signUp);
+    this.router.post('/login', ValidationMiddleware(CreateUserDto), this.auth.logIn);
+    this.router.post('/logout', AuthMiddleware, this.auth.logOut);
   }
 }
-
-export default AuthRoute;

package/lib/default/src/routes/users.route.ts

@@ -1,25 +1,23 @@
 import { Router } from 'express';
-import UsersController from '@controllers/users.controller';
-import { CreateUserDto } from '@dtos/users.dto';
+import { UserController } from '@controllers/users.controller';
+import { CreateUserDto, UpdateUserDto } from '@dtos/users.dto';
 import { Routes } from '@interfaces/routes.interface';
-import validationMiddleware from '@middlewares/validation.middleware';
+import { ValidationMiddleware } from '@middlewares/validation.middleware';
 
-class UsersRoute implements Routes {
+export class UserRoute implements Routes {
   public path = '/users';
   public router = Router();
-  public usersController = new UsersController();
+  public user = new UserController();
 
   constructor() {
     this.initializeRoutes();
   }
 
   private initializeRoutes() {
-    this.router.get(`${this.path}`, this.usersController.getUsers);
-    this.router.get(`${this.path}/:id(\\d+)`, this.usersController.getUserById);
-    this.router.post(`${this.path}`, validationMiddleware(CreateUserDto, 'body'), this.usersController.createUser);
-    this.router.put(`${this.path}/:id(\\d+)`, validationMiddleware(CreateUserDto, 'body', true), this.usersController.updateUser);
-    this.router.delete(`${this.path}/:id(\\d+)`, this.usersController.deleteUser);
+    this.router.get(`${this.path}`, this.user.getUsers);
+    this.router.get(`${this.path}/:id(\\d+)`, this.user.getUserById);
+    this.router.post(`${this.path}`, ValidationMiddleware(CreateUserDto), this.user.createUser);
+    this.router.put(`${this.path}/:id(\\d+)`, ValidationMiddleware(UpdateUserDto), this.user.updateUser);
+    this.router.delete(`${this.path}/:id(\\d+)`, this.user.deleteUser);
   }
 }
-
-export default UsersRoute;

package/lib/default/src/server.ts

@@ -1,11 +1,10 @@
-import App from '@/app';
-import AuthRoute from '@routes/auth.route';
-import IndexRoute from '@routes/index.route';
-import UsersRoute from '@routes/users.route';
-import validateEnv from '@utils/validateEnv';
+import { App } from '@/app';
+import { AuthRoute } from '@routes/auth.route';
+import { UserRoute } from '@routes/users.route';
+import { ValidateEnv } from '@utils/validateEnv';
 
-validateEnv();
+ValidateEnv();
 
-const app = new App([new IndexRoute(), new UsersRoute(), new AuthRoute()]);
+const app = new App([new UserRoute(), new AuthRoute()]);
 
 app.listen();

package/lib/default/src/services/auth.service.ts

@@ -1,63 +1,52 @@
 import { hash, compare } from 'bcrypt';
 import { sign } from 'jsonwebtoken';
+import { Service } from 'typedi';
 import { SECRET_KEY } from '@config';
-import { CreateUserDto } from '@dtos/users.dto';
-import { HttpException } from '@exceptions/HttpException';
+import { HttpException } from '@exceptions/httpException';
 import { DataStoredInToken, TokenData } from '@interfaces/auth.interface';
 import { User } from '@interfaces/users.interface';
-import userModel from '@models/users.model';
-import { isEmpty } from '@utils/util';
+import { UserModel } from '@models/users.model';
 
-class AuthService {
-  public users = userModel;
+const createToken = (user: User): TokenData => {
+  const dataStoredInToken: DataStoredInToken = { id: user.id };
+  const expiresIn: number = 60 * 60;
 
-  public async signup(userData: CreateUserDto): Promise<User> {
-    if (isEmpty(userData)) throw new HttpException(400, "You're not userData");
+  return { expiresIn, token: sign(dataStoredInToken, SECRET_KEY, { expiresIn }) };
+};
 
-    const findUser: User = this.users.find(user => user.email === userData.email);
-    if (findUser) throw new HttpException(409, `You're email ${userData.email} already exists`);
+const createCookie = (tokenData: TokenData): string => {
+  return `Authorization=${tokenData.token}; HttpOnly; Max-Age=${tokenData.expiresIn};`;
+};
+
+@Service()
+export class AuthService {
+  public async signup(userData: User): Promise<User> {
+    const findUser: User = UserModel.find(user => user.email === userData.email);
+    if (findUser) throw new HttpException(409, `This email ${userData.email} already exists`);
 
     const hashedPassword = await hash(userData.password, 10);
-    const createUserData: User = { id: this.users.length + 1, ...userData, password: hashedPassword };
+    const createUserData: User = { ...userData, id: UserModel.length + 1, password: hashedPassword };
 
     return createUserData;
   }
 
-  public async login(userData: CreateUserDto): Promise<{ cookie: string; findUser: User }> {
-    if (isEmpty(userData)) throw new HttpException(400, "You're not userData");
-
-    const findUser: User = this.users.find(user => user.email === userData.email);
-    if (!findUser) throw new HttpException(409, `You're email ${userData.email} not found`);
+  public async login(userData: User): Promise<{ cookie: string; findUser: User }> {
+    const findUser: User = UserModel.find(user => user.email === userData.email);
+    if (!findUser) throw new HttpException(409, `This email ${userData.email} was not found`);
 
     const isPasswordMatching: boolean = await compare(userData.password, findUser.password);
     if (!isPasswordMatching) throw new HttpException(409, "You're password not matching");
 
-    const tokenData = this.createToken(findUser);
-    const cookie = this.createCookie(tokenData);
+    const tokenData = createToken(findUser);
+    const cookie = createCookie(tokenData);
 
     return { cookie, findUser };
   }
 
   public async logout(userData: User): Promise<User> {
-    if (isEmpty(userData)) throw new HttpException(400, "You're not userData");
-
-    const findUser: User = this.users.find(user => user.email === userData.email && user.password === userData.password);
-    if (!findUser) throw new HttpException(409, "You're not user");
+    const findUser: User = UserModel.find(user => user.email === userData.email && user.password === userData.password);
+    if (!findUser) throw new HttpException(409, "User doesn't exist");
 
     return findUser;
   }
-
-  public createToken(user: User): TokenData {
-    const dataStoredInToken: DataStoredInToken = { id: user.id };
-    const secretKey: string = SECRET_KEY;
-    const expiresIn: number = 60 * 60;
-
-    return { expiresIn, token: sign(dataStoredInToken, secretKey, { expiresIn }) };
-  }
-
-  public createCookie(tokenData: TokenData): string {
-    return `Authorization=${tokenData.token}; HttpOnly; Max-Age=${tokenData.expiresIn};`;
-  }
 }
-
-export default AuthService;

package/lib/default/src/services/users.service.ts

@@ -1,47 +1,40 @@
 import { hash } from 'bcrypt';
-import { CreateUserDto } from '@dtos/users.dto';
-import { HttpException } from '@exceptions/HttpException';
+import { Service } from 'typedi';
+import { HttpException } from '@exceptions/httpException';
 import { User } from '@interfaces/users.interface';
-import userModel from '@models/users.model';
-import { isEmpty } from '@utils/util';
-
-class UserService {
-  public users = userModel;
+import { UserModel } from '@models/users.model';
 
+@Service()
+export class UserService {
   public async findAllUser(): Promise<User[]> {
-    const users: User[] = this.users;
+    const users: User[] = UserModel;
     return users;
   }
 
   public async findUserById(userId: number): Promise<User> {
-    const findUser: User = this.users.find(user => user.id === userId);
-    if (!findUser) throw new HttpException(409, "You're not user");
+    const findUser: User = UserModel.find(user => user.id === userId);
+    if (!findUser) throw new HttpException(409, "User doesn't exist");
 
     return findUser;
   }
 
-  public async createUser(userData: CreateUserDto): Promise<User> {
-    if (isEmpty(userData)) throw new HttpException(400, "You're not userData");
-
-    const findUser: User = this.users.find(user => user.email === userData.email);
-    if (findUser) throw new HttpException(409, `Your email ${userData.email} already exists`);
+  public async createUser(userData: User): Promise<User> {
+    const findUser: User = UserModel.find(user => user.email === userData.email);
+    if (findUser) throw new HttpException(409, `This email ${userData.email} already exists`);
 
     const hashedPassword = await hash(userData.password, 10);
-    const createUserData: User = { id: this.users.length + 1, ...userData, password: hashedPassword };
-    this.users = [...this.users, createUserData];
+    const createUserData: User = { ...userData, id: UserModel.length + 1, password: hashedPassword };
 
     return createUserData;
   }
 
-  public async updateUser(userId: number, userData: CreateUserDto): Promise<User[]> {
-    if (isEmpty(userData)) throw new HttpException(400, "You're not userData");
-
-    const findUser: User = this.users.find(user => user.id === userId);
-    if (!findUser) throw new HttpException(409, "You're not user");
+  public async updateUser(userId: number, userData: User): Promise<User[]> {
+    const findUser: User = UserModel.find(user => user.id === userId);
+    if (!findUser) throw new HttpException(409, "User doesn't exist");
 
     const hashedPassword = await hash(userData.password, 10);
-    const updateUserData: User[] = this.users.map((user: User) => {
-      if (user.id === findUser.id) user = { id: userId, ...userData, password: hashedPassword };
+    const updateUserData: User[] = UserModel.map((user: User) => {
+      if (user.id === findUser.id) user = { ...userData, id: userId, password: hashedPassword };
       return user;
     });
 
@@ -49,12 +42,10 @@ class UserService {
   }
 
   public async deleteUser(userId: number): Promise<User[]> {
-    const findUser: User = this.users.find(user => user.id === userId);
-    if (!findUser) throw new HttpException(409, "You're not user");
+    const findUser: User = UserModel.find(user => user.id === userId);
+    if (!findUser) throw new HttpException(409, "User doesn't exist");
 
-    const deleteUserData: User[] = this.users.filter(user => user.id !== findUser.id);
+    const deleteUserData: User[] = UserModel.filter(user => user.id !== findUser.id);
     return deleteUserData;
   }
 }
-
-export default UserService;

package/lib/{graphql/src/tests → default/src/test}/auth.test.ts

@@ -1,52 +1,52 @@
 import request from 'supertest';
-import App from '@/app';
-import { CreateUserDto } from '@dtos/users.dto';
-import AuthRoute from '@routes/auth.route';
+import { App } from '@/app';
+import { User } from '@interfaces/users.interface';
+import { AuthRoute } from '@routes/auth.route';
 
 afterAll(async () => {
   await new Promise<void>(resolve => setTimeout(() => resolve(), 500));
 });
 
-describe('Testing Auth', () => {
+describe('TEST Authorization API', () => {
+  const route = new AuthRoute();
+  const app = new App([route]);
+
   describe('[POST] /signup', () => {
     it('response should have the Create userData', () => {
-      const userData: CreateUserDto = {
-        email: 'test@email.com',
-        password: 'q1w2e3r4',
+      const userData: User = {
+        email: 'example@email.com',
+        password: 'password123456789',
       };
-      const authRoute = new AuthRoute();
-      const app = new App([authRoute]);
 
-      return request(app.getServer()).post('/signup').send(userData);
+      return request(app.getServer()).post('/signup').send(userData).expect(201);
     });
   });
 
   describe('[POST] /login', () => {
-    it('response should have the Set-Cookie header with the Authorization token', async () => {
-      const userData: CreateUserDto = {
-        email: 'test@email.com',
-        password: 'q1w2e3r4',
+    it('response should have the Set-Cookie header with the Authorization token', () => {
+      const userData: User = {
+        email: 'example1@email.com',
+        password: 'password123456789',
       };
 
-      const authRoute = new AuthRoute();
-      const app = new App([authRoute]);
-
       return request(app.getServer())
         .post('/login')
         .send(userData)
-        .expect('Set-Cookie', /^Authorization=.+/);
+        .expect('Set-Cookie', /^Authorization=.+/)
+        .expect(200);
     });
   });
 
   // error: StatusCode : 404, Message : Authentication token missing
   // describe('[POST] /logout', () => {
   //   it('logout Set-Cookie Authorization=; Max-age=0', () => {
-  //     const authRoute = new AuthRoute();
-  //     const app = new App([authRoute]);
+  //     const route = new AuthRoute()
+  //     const app = new App([route]);
 
   //     return request(app.getServer())
   //       .post('/logout')
-  //       .expect('Set-Cookie', /^Authorization=\;/);
+  //       .expect('Set-Cookie', /^Authorization=\;/)
+  //       .expect(200);
   //   });
   // });
 });