feat: added tests for middlewares

Author: pankajjs

test/unit/middlewares/onboardingExtensionRequestValidator.test.ts

@@ -0,0 +1,71 @@
+import { REQUEST_TYPE } from "../../../constants/requests";
+import { createOnboardingExtensionRequestValidator } from "../../../middlewares/validators/onboardingExtensionRequest";
+import sinon from "sinon";
+import { CreateOnboardingExtensionBody } from "../../../types/onboardingExtension";
+import { expect } from "chai";
+
+describe("Onboarding Extension Request Validators", () => {
+    let req: any;
+    let res: any;
+    let nextSpy: sinon.SinonSpy;
+    beforeEach(function () {
+        res = {
+            boom: {
+                badRequest: sinon.spy(),
+            },
+        };
+        nextSpy = sinon.spy();
+    });
+    
+    describe("createOnboardingExtensionRequestValidator", () => {
+        const requestBody:CreateOnboardingExtensionBody = {
+            numberOfDays: 1,
+            reason: "This is reason",
+            userId: "22222",
+            requestedBy: "1111",
+            type: REQUEST_TYPE.ONBOARDING
+        }
+        it("should validate for a valid create request", async () => {
+            req = {
+                body: requestBody
+            };
+            res = {};
+
+            await createOnboardingExtensionRequestValidator(req as any, res as any, nextSpy);
+            expect(nextSpy.calledOnce, "next should be called once");
+        });
+        
+        it("should not validate for an invalid request on wrong type", async () => {
+            req = {
+                body: { ...requestBody, type: REQUEST_TYPE.EXTENSION },
+            };
+            try {
+                await createOnboardingExtensionRequestValidator(req as any, res as any, nextSpy);
+            } catch (error) {
+                expect(error.details[0].message).to.equal(`"type" must be [ONBOARDING]`);
+            }
+        });
+
+        it("should not validate for an invalid request on wrong numberOfDays", async () => {
+            req = {
+                body: { ...requestBody, numberOfDays: "2" },
+            };
+            try {
+                await createOnboardingExtensionRequestValidator(req as any, res as any, nextSpy);
+            } catch (error) {
+                expect(error.details[0].message).to.equal(`numberOfDays must be a number`);
+            }
+        });
+
+        it("should not validate for an invalid request on wrong userId", async () => {
+            req = {
+                body: { ...requestBody, userId: undefined },
+            };
+            try {
+                await createOnboardingExtensionRequestValidator(req as any, res as any, nextSpy);
+            } catch (error) {
+                expect(error.details[0].message).to.equal(`userId is required`);
+            }
+        });
+    });
+});

test/unit/middlewares/skipAuthenticateForOnboardingExtension.test.ts

@@ -0,0 +1,49 @@
+import sinon from "sinon";
+import { skipAuthenticateForOnboardingExtensionRequest } from "../../../middlewares/skipAuthenticateForOnboardingExtension";
+import { REQUEST_TYPE } from "../../../constants/requests";
+import { assert } from "chai";
+
+describe("skipAuthenticateForOnboardingExtensionRequest Middleware", () => {
+    let req, res, next, authenticate: sinon.SinonSpy, verifyDiscordBot: sinon.SinonSpy;
+
+    beforeEach(() => {
+        authenticate = sinon.spy();
+        verifyDiscordBot = sinon.spy();
+        req = {
+            body:{},
+            query:{},
+        },
+        res = {}
+    });
+
+    it("should call authenticate when type is not onboarding", () => {
+        req.body.type = REQUEST_TYPE.TASK
+        const middleware = skipAuthenticateForOnboardingExtensionRequest(authenticate, verifyDiscordBot);
+        middleware(req, res, next);
+
+        assert.isTrue(authenticate.calledOnce, "authenticate should be called once");
+        assert.isTrue(verifyDiscordBot.notCalled, "verifyDiscordBot should not be called");
+    });
+
+    it("should not call verifyDicordBot and authenticate when dev is not true and type is onboarding", async () => {
+        req.query.dev = "false";
+        req.body.type = REQUEST_TYPE.ONBOARDING;
+
+        const middleware = skipAuthenticateForOnboardingExtensionRequest(authenticate, verifyDiscordBot);
+        middleware(req, res, next);
+
+        assert.isTrue(verifyDiscordBot.notCalled, "verifyDiscordBot should not be called");
+        assert.isTrue(authenticate.notCalled, "authenticate should not be called");
+    });
+
+    it("should call verifyDiscordBot when dev is true and type is onboarding", () => {
+        req.query.dev = "true";
+        req.body.type = REQUEST_TYPE.ONBOARDING;
+
+        const middleware = skipAuthenticateForOnboardingExtensionRequest(authenticate, verifyDiscordBot);
+        middleware(req, res, next);
+
+        assert.isTrue(verifyDiscordBot.calledOnce, "verifyDiscordBot should be called once");
+        assert.isTrue(authenticate.notCalled, "authenticate should not be called");
+    });
+});