diff --git a/src/controllers/auth.ts b/src/controllers/auth.ts index d7b53e8..fbc7ecf 100644 --- a/src/controllers/auth.ts +++ b/src/controllers/auth.ts @@ -46,7 +46,7 @@ export const refresh = asyncHandler(async (req, res) => { const newToken: string = await auth.refresh(tokens.refreshToken); tokens.accessToken = newToken; res.cookie("tokens", tokens, cookieOptions); - res.status(200).end() + res.status(200).end(); }); export const me = asyncHandler(async (req, res) => { diff --git a/src/middlewares/joiValidation.ts b/src/middlewares/joiValidation.ts index 4284aec..35134eb 100644 --- a/src/middlewares/joiValidation.ts +++ b/src/middlewares/joiValidation.ts @@ -7,7 +7,7 @@ import { ApiResponseinput } from "../types/index.js"; export const validateSchema = ( schema: Joi.Schema, property: "body" | "query" | "params" = "body", - options: Joi.ValidationOptions = { abortEarly: false } + options: Joi.ValidationOptions = { abortEarly: false, stripUnknown: true }, ) => { return (req: Request, res: Response, next: NextFunction) => { const target = (req as any)[property]; @@ -24,4 +24,4 @@ export const validateSchema = ( (req as any)[property] = value; return next(); }; -}; \ No newline at end of file +}; diff --git a/src/models/test.ts b/src/models/load.ts similarity index 100% rename from src/models/test.ts rename to src/models/load.ts diff --git a/src/routes/auth.ts b/src/routes/auth.ts index 7a23549..27dd678 100644 --- a/src/routes/auth.ts +++ b/src/routes/auth.ts @@ -1,6 +1,13 @@ import express, { Router } from "express"; -import { register, login, verify, logout, me } from "../controllers/auth.js"; +import { + register, + login, + verify, + logout, + me, + refresh, +} from "../controllers/auth.js"; import { registerSchema, loginSchema } from "../validations/auth.js"; import { validateSchema } from "../middlewares/joiValidation.js"; import { authlimiter } from "../middlewares/rateLimit.js"; @@ -10,7 +17,8 @@ const router: Router = express.Router(); router.post("/register", authlimiter, validateSchema(registerSchema), register); router.post("/login", authlimiter, validateSchema(loginSchema), login); router.get("/verify/:token", verify); -router.post("/logout",authMiddleware, logout); +router.post("/logout", authMiddleware, logout); +router.post("/refresh", refresh); router.get("/me", authMiddleware, me); export default router; diff --git a/src/services/emailService.ts b/src/services/emailService.ts index 83c6160..391d7bc 100644 --- a/src/services/emailService.ts +++ b/src/services/emailService.ts @@ -22,13 +22,6 @@ export const verificationEmail = async ( pass: processConfig.mailer.pass, }, }); - transporter.verify(function (error, success) { - if (error) { - logger.error(`Connection Error: `,error); - } else { - logger.info("Server is ready to send messages."); - } - }); await transporter.sendMail({ from: `verify@${processConfig.name}.com`, to: to, diff --git a/src/services/loadService.ts b/src/services/loadService.ts index d17c941..8888c0e 100644 --- a/src/services/loadService.ts +++ b/src/services/loadService.ts @@ -1,7 +1,6 @@ import Undici from "undici"; -import Test from "../models/test.js"; -import Tests from "../models/test.js"; +import Tests from "../models/load.js"; class loadService { createTest = async (configs: any): Promise => { diff --git a/src/types/index.ts b/src/types/index.ts index fd8acfc..54206b1 100644 --- a/src/types/index.ts +++ b/src/types/index.ts @@ -1,6 +1,6 @@ import { InferSchemaType } from "mongoose"; import { usersSchema } from "../models/users.js"; -import { testSchema } from "../models/test.js"; +import { testSchema } from "../models/load.js"; export type User = InferSchemaType; @@ -20,14 +20,14 @@ export interface ServiceErrorInput { details?: any; } -export interface ApiResponseinput { +export interface ApiResponseinput { success: boolean; message: string; token?: string; tokens?: Tokens; user?: User; - data?: string; - datas?: string[] + data?: T; + datas?: T[]; error?: string; errors?: Record; } diff --git a/src/validations/load.ts b/src/validations/load.ts index 70d229d..a7a43f6 100644 --- a/src/validations/load.ts +++ b/src/validations/load.ts @@ -12,4 +12,4 @@ export const loadSchema = Joi.object({ body: Joi.any(), concurrency: Joi.number().min(1).default(10), duration: Joi.number().min(1).default(30), -}).unknown(true); +}).unknown(false); diff --git a/tests/auth.test.ts b/tests/auth.test.ts deleted file mode 100644 index 331fc88..0000000 --- a/tests/auth.test.ts +++ /dev/null @@ -1,54 +0,0 @@ -import "dotenv/config"; -import { jest, describe, it, expect, beforeAll, afterAll } from "@jest/globals"; -import request from "supertest"; -import mongoose from "mongoose"; - -const data = { - email: "adegokeanthony23@gmail.com", - password: "Babylon.!1", -}; - -const { default: app } = await import("../src/app.js"); -const { default: connectDB } = await import("../src/config/db.js"); - -beforeAll(async () => { - await connectDB(); - if (mongoose.connection.db) { - await mongoose.connection.db - .collection("users") - .deleteMany({ email: "adegokeanthony23@gmail.com" }); - } -}); - -afterAll(async () => { - if (mongoose.connection.db) { - await mongoose.connection.db - .collection("users") - .deleteMany({ email: "adegokeanthony23@gmail.com" }); - } - await mongoose.disconnect(); -}); - -describe("Post /api/auth/", () => { - it("should complete the registration flow", async () => { - const registerResponse = await request(app) - .post("/api/auth/register") - .set("Content-Type", "application/json") - .set("Accept", "application/json") - .send(data); - expect(registerResponse.status).toBe(201); - - const verifyResponse = await request(app) - .get(`/api/auth/verify/${registerResponse.body.token}`) - .set("Content-Type", "application/json") - .set("Accept", "application/json"); - expect(verifyResponse.status).toBe(302); - - const loginResponse = await request(app) - .post("/api/auth/login") - .set("Content-Type", "application/json") - .set("Accept", "application/json") - .send(data); - expect(loginResponse.status).toBe(200); - }); -}); diff --git a/tests/auth/auth.test.ts b/tests/auth/auth.test.ts new file mode 100644 index 0000000..fc81a20 --- /dev/null +++ b/tests/auth/auth.test.ts @@ -0,0 +1,115 @@ +import "dotenv/config"; +import { jest, describe, it, expect, beforeAll, afterAll } from "@jest/globals"; +import request from "supertest"; +import mongoose from "mongoose"; + +jest.unstable_mockModule("../../src/services/emailService.js", () => ({ + verificationEmail: jest.fn<() => Promise>().mockResolvedValue(undefined), +})); + +const testEmail = `auth+${Date.now()}-${Math.random().toString(16).slice(2)}@example.com`; +const testPassword = "Babylon.!1"; + +const { default: app } = await import("../../src/app.js"); +const { default: connectDB } = await import("../../src/config/db.js"); +const { default: Users } = await import("../../src/models/users.js"); +const { default: processConfig } = await import("../../src/config/env.js"); +const { generateToken } = await import("../../src/utils/jwt.js"); + +const registerUser = async () => { + const registerResponse = await request(app) + .post("/api/auth/register") + .set("Content-Type", "application/json") + .set("Accept", "application/json") + .send({ email: testEmail, password: testPassword }); + + expect(registerResponse.status).toBe(201); + return registerResponse; +}; + +const verifyUser = async () => { + const user = await Users.findOne({ email: testEmail }).lean(); + expect(user).toBeTruthy(); + + const verifyKey = processConfig.JWTs.verifyEmail.key; + const verifyDuration = processConfig.JWTs.verifyEmail.duration; + + expect(verifyKey).toBeTruthy(); + expect(verifyDuration).toBeTruthy(); + + const token = await generateToken( + { + id: user!._id.toString(), + email: user!.email, + paid: user!.paid, + }, + verifyKey!, + verifyDuration!, + ); + + const verifyResponse = await request(app) + .get(`/api/auth/verify/${token}`) + .set("Accept", "application/json"); + + expect(verifyResponse.status).toBe(200); + return verifyResponse; +}; + +const loginUser = async () => { + const loginResponse = await request(app) + .post("/api/auth/login") + .set("Content-Type", "application/json") + .set("Accept", "application/json") + .send({ email: testEmail, password: testPassword }); + + expect(loginResponse.status).toBe(200); + return loginResponse; +}; + +beforeAll(async () => { + await connectDB(); + if (mongoose.connection.db) { + await mongoose.connection.db + .collection("users") + .deleteMany({ email: testEmail }); + } +},20000); + +afterAll(async () => { + if (mongoose.connection.db) { + await mongoose.connection.db + .collection("users") + .deleteMany({ email: testEmail }); + } + await mongoose.disconnect(); +},20000); + +describe("Auth routes", () => { + it("registers a new user", async () => { + const registerResponse = await registerUser(); + expect(registerResponse.body).toMatchObject({ + success: true, + message: "User Created Successfully", + }); + + const user = await Users.findOne({ email: testEmail }).lean(); + expect(user).toBeTruthy(); + expect(user?.verified).toBe(false); + }); + + it("verifies a registered user", async () => { + await verifyUser(); + + const verifiedUser = await Users.findOne({ email: testEmail }).lean(); + expect(verifiedUser?.verified).toBe(true); + }); + + it("logs in a verified user", async () => { + const loginResponse = await loginUser(); + expect(loginResponse.body).toMatchObject({ + success: true, + message: "User Logged In Successfully", + }); + expect(loginResponse.headers["set-cookie"]).toBeDefined(); + }); +}); diff --git a/tests/unit/controllers/authController.test.ts b/tests/unit/controllers/authController.test.ts new file mode 100644 index 0000000..8d077d4 --- /dev/null +++ b/tests/unit/controllers/authController.test.ts @@ -0,0 +1,137 @@ +import { jest, describe, it, expect } from "@jest/globals"; + +const registerMock = jest.fn().mockResolvedValue(undefined); +const loginMock = jest.fn().mockResolvedValue({ + accessToken: "access-token", + refreshToken: "refresh-token", +}); +const verifyMock = jest.fn().mockResolvedValue(undefined); +const logoutMock = jest.fn().mockResolvedValue(undefined); +const refreshMock = jest.fn().mockResolvedValue("new-access-token"); +const meMock = jest.fn().mockResolvedValue({ + id: "user-id", + email: "user@example.com", + paid: false, +}); + +const AuthServiceMock = jest.fn().mockImplementation(() => ({ + register: registerMock, + login: loginMock, + verify: verifyMock, + logout: logoutMock, + refresh: refreshMock, + me: meMock, +})); + +jest.unstable_mockModule("../../../src/services/authService.js", () => ({ + default: AuthServiceMock, +})); + +const authController = await import("../../../src/controllers/auth.js"); + +const createRes = () => { + const res: any = {}; + res.status = jest.fn().mockReturnValue(res); + res.json = jest.fn().mockReturnValue(res); + res.cookie = jest.fn().mockReturnValue(res); + res.clearCookie = jest.fn().mockReturnValue(res); + res.end = jest.fn().mockReturnValue(res); + return res; +}; + +const flushPromises = async () => + await new Promise((resolve) => setTimeout(resolve, 0)); + +describe("Auth controller", () => { + it("registers a user", async () => { + const req: any = { body: { email: "user@example.com", password: "Pass.!1" } }; + const res = createRes(); + const next = jest.fn(); + + authController.register(req, res, next); + await flushPromises(); + + expect(registerMock).toHaveBeenCalledWith("user@example.com", "Pass.!1"); + expect(res.status).toHaveBeenCalledWith(201); + expect(res.json).toHaveBeenCalled(); + }); + + it("logs in a user and sets cookie", async () => { + const req: any = { body: { email: "user@example.com", password: "Pass.!1" } }; + const res = createRes(); + const next = jest.fn(); + + authController.login(req, res, next); + await flushPromises(); + + expect(loginMock).toHaveBeenCalled(); + expect(res.cookie).toHaveBeenCalledWith( + "tokens", + expect.objectContaining({ + accessToken: "access-token", + refreshToken: "refresh-token", + }), + expect.any(Object), + ); + expect(res.status).toHaveBeenCalledWith(200); + }); + + it("verifies a user", async () => { + const req: any = { params: { token: "token" } }; + const res = createRes(); + const next = jest.fn(); + + authController.verify(req, res, next); + await flushPromises(); + + expect(verifyMock).toHaveBeenCalledWith("token"); + expect(res.status).toHaveBeenCalledWith(200); + expect(res.end).toHaveBeenCalled(); + }); + + it("refreshes access token", async () => { + const tokens = { accessToken: "old", refreshToken: "refresh" }; + const req: any = { signedCookies: { tokens } }; + const res = createRes(); + const next = jest.fn(); + + authController.refresh(req, res, next); + await flushPromises(); + + expect(refreshMock).toHaveBeenCalledWith("refresh"); + expect(res.cookie).toHaveBeenCalledWith( + "tokens", + expect.objectContaining({ accessToken: "new-access-token" }), + expect.any(Object), + ); + expect(res.status).toHaveBeenCalledWith(200); + expect(res.end).toHaveBeenCalled(); + }); + + it("returns the current user", async () => { + const req: any = { user: { id: "user-id" } }; + const res = createRes(); + const next = jest.fn(); + + authController.me(req, res, next); + await flushPromises(); + + expect(meMock).toHaveBeenCalledWith("user-id"); + expect(res.status).toHaveBeenCalledWith(200); + expect(res.json).toHaveBeenCalled(); + }); + + it("logs out a user", async () => { + const req: any = { signedCookies: { tokens: { accessToken: "access" } } }; + const res = createRes(); + const next = jest.fn(); + + authController.logout(req, res, next); + await flushPromises(); + + expect(logoutMock).toHaveBeenCalledWith("access"); + expect(res.clearCookie).toHaveBeenCalledWith("tokens", expect.any(Object)); + expect(res.status).toHaveBeenCalledWith(204); + expect(res.end).toHaveBeenCalled(); + }); +}); diff --git a/tests/unit/controllers/loadController.test.ts b/tests/unit/controllers/loadController.test.ts new file mode 100644 index 0000000..d34cc75 --- /dev/null +++ b/tests/unit/controllers/loadController.test.ts @@ -0,0 +1,50 @@ +import { jest, describe, it, expect } from "@jest/globals"; + +const createTestMock = jest.fn().mockResolvedValue("test-id"); +const LoadServiceMock = jest.fn().mockImplementation(() => ({ + createTest: createTestMock, +})); + +jest.unstable_mockModule("../../../src/services/loadService.js", () => ({ + default: LoadServiceMock, +})); + +const loadController = await import("../../../src/controllers/load.js"); + +const createRes = () => { + const res: any = {}; + res.status = jest.fn().mockReturnValue(res); + res.json = jest.fn().mockReturnValue(res); + return res; +}; + +const flushPromises = async () => + await new Promise((resolve) => setImmediate(resolve)); + +describe("Load controller", () => { + it("starts a load test", async () => { + const req: any = { + body: { + url: "https://example.com", + method: "GET", + concurrency: 5, + duration: 10, + }, + }; + const res = createRes(); + const next = jest.fn(); + + loadController.startLoad(req, res, next); + await flushPromises(); + + expect(createTestMock).toHaveBeenCalledWith(req.body); + expect(res.status).toHaveBeenCalledWith(202); + expect(res.json).toHaveBeenCalledWith( + expect.objectContaining({ + success: true, + message: "Task created successfully", + data: "test-id", + }), + ); + }); +});