test/ unit tests for get Impersonation requests (#2443)

Suvidh-kaushik · Achintya-Chatterjee · web-flow · commit b83ca14de4cb · 2025-06-26T01:15:09.000+05:30
* added unit tests for fetch logic

* fixed types and small comments

* fixed comments and variable types

* added impersonation requests array

* removed update model function from tests

* removed page based pagination from tests

* added new validator tests for new route

---------

Co-authored-by: Achintya Chatterjee &lt;55826451+Achintya-Chatterjee@users.noreply.github.com&gt;
diff --git a/test/unit/middlewares/impersonationRequests.test.ts b/test/unit/middlewares/impersonationRequests.test.ts
@@ -1,14 +1,19 @@
 import chai from "chai";
 import sinon from "sinon";
 import {
-  createImpersonationRequestValidator
+  createImpersonationRequestValidator,
+  getImpersonationRequestByIdValidator,
+  getImpersonationRequestsValidator
 } from "../../../middlewares/validators/impersonationRequests";
 import {
   CreateImpersonationRequest,
   CreateImpersonationRequestBody,
   ImpersonationRequestResponse,
+  GetImpersonationControllerRequest,
+  GetImpersonationRequestByIdRequest,
 } from "../../../types/impersonationRequest";
 import { Request, Response } from "express";
+import { getImpersonationRequestById } from "../../../models/impersonationRequests";
 
 const { expect } = chai;
 
@@ -75,4 +80,101 @@ describe("Impersonation Request Validators", function () {
       expect(nextSpy.called).to.be.false;
     });
   });
+
+  describe("getImpersonationRequestByIdValidator", function () {
+    it("should validate for a valid get by id impersonation request", async function () {
+      req = {
+        params:{
+          id:"cuJ7lKT1DFybHNwaMJHu",
+          dev:"true"
+        }
+      }
+      await getImpersonationRequestByIdValidator(
+        req as GetImpersonationRequestByIdRequest,
+        res as ImpersonationRequestResponse,
+        nextSpy
+      );
+      expect(nextSpy.calledOnce).to.be.true;
+    })
+
+    it("should not validate for a request without dev flag", async function (){
+      req = {
+        params:{
+          id:"192sjsj/dhid"
+        }
+      }
+      await getImpersonationRequestByIdValidator(
+        req as GetImpersonationRequestByIdRequest,
+        res as ImpersonationRequestResponse,
+        nextSpy
+      );
+
+      expect(res.boom.badRequest.calledOnce).to.be.true;
+      expect(nextSpy.called).to.be.false;
+    })
+
+    it("should not validate for a request with missing id", async function(){
+      req = {
+        params:{
+          id:"",
+          dev:"true"
+        }
+      }
+      await getImpersonationRequestByIdValidator(
+        req as GetImpersonationRequestByIdRequest,
+        res as ImpersonationRequestResponse,
+        nextSpy
+      );
+
+      expect(res.boom.badRequest.calledOnce).to.be.true;
+      expect(nextSpy.called).to.be.false;
+    })
+  })
+
+  describe("getImpersonationRequestsValidator", function () {
+    it("should validate for a valid get impersonation requests query", async function () {
+      req = {
+        query: {
+          dev: "true",
+          status: "APPROVED",
+        },
+      };
+      await getImpersonationRequestsValidator(
+        req as GetImpersonationControllerRequest,
+        res as ImpersonationRequestResponse,
+        nextSpy
+      );
+      expect(nextSpy.calledOnce).to.be.true;
+    });
+
+    it("should validate a request with partial query", async function () {
+      req = {
+        query: {
+          dev: "true",
+        },
+      };
+      await getImpersonationRequestsValidator(
+        req as GetImpersonationControllerRequest,
+        res as ImpersonationRequestResponse,
+        nextSpy
+      );
+      expect(nextSpy.calledOnce).to.be.true;
+    });
+
+    it("should not validate for an invalid status in query", async function () {
+      req = {
+        query: {
+          dev: "true",
+          status: "INVALID_STATUS",
+        },
+      };
+      await getImpersonationRequestsValidator(
+        req as GetImpersonationControllerRequest,
+        res as ImpersonationRequestResponse,
+        nextSpy
+      );
+      expect(res.boom.badRequest.calledOnce).to.be.true;
+      expect(nextSpy.called).to.be.false;
+    });
+  });
 });
diff --git a/test/unit/models/impersonationRequests.test.ts b/test/unit/models/impersonationRequests.test.ts
@@ -2,17 +2,18 @@ import { expect } from "chai";
 import cleanDb from "../../utils/cleanDb";
 import * as impersonationModel from "../../../models/impersonationRequests";
 import { impersonationRequestsBodyData } from "../../fixtures/impersonation-requests/impersonationRequests";
-import { REQUEST_STATE, ERROR_WHILE_CREATING_REQUEST, REQUEST_ALREADY_PENDING, IMPERSONATION_NOT_COMPLETED } from "../../../constants/requests";
+import { REQUEST_STATE, ERROR_WHILE_CREATING_REQUEST } from "../../../constants/requests";
 import addUser from "../../utils/addUser";
 import userDataFixture from "../../fixtures/user/user";
 import sinon from "sinon";
-import { CreateImpersonationRequestModelDto } from "../../../types/impersonationRequest";
+
 
 
 describe("models/impersonationRequests", () => {
   let impersonationRequest;
   let mockRequestBody = impersonationRequestsBodyData[0];
   let testUserId:string;
+  let impersonationRequests=[];
   const userData = userDataFixture();
 
   beforeEach(async () => {
@@ -77,4 +78,132 @@ describe("models/impersonationRequests", () => {
       }
     })
   });
+  
+  describe("getImpersonationRequestById", () => {
+    it("should return the impersonation request by id", async () => {
+      const impersonationRequest = await impersonationModel.createImpersonationRequest(impersonationRequestsBodyData[0]);
+      const request = await impersonationModel.getImpersonationRequestById(impersonationRequest.id);
+      expect(request).to.not.be.null;
+      expect(request.id).to.equal(impersonationRequest.id);
+    });
+
+    it("should return null if the request does not exist", async () => {
+      const request = await impersonationModel.getImpersonationRequestById("nonexistentId");
+      expect(request).to.be.null;
+    });
+  });
+
+  describe("getImpersonationRequests", () => {
+    beforeEach(async () => {
+      impersonationRequests = [];
+      impersonationRequests = await Promise.all(
+        impersonationRequestsBodyData.slice(0, 5).map((data) =>
+          impersonationModel.createImpersonationRequest(data)
+        )
+      );
+    });
+
+    afterEach(async () => {
+      sinon.restore();
+      await cleanDb();
+    });
+
+    it("should return a list of impersonation requests", async () => {
+      const requests = await impersonationModel.getImpersonationRequests({});
+      expect(requests).to.not.be.null;
+      expect(requests.allRequests.length).to.be.greaterThan(0);
+      expect(requests.allRequests.length).to.be.equal(impersonationRequests.length);
+    });
+
+    it("Should return a list of all the requests with specified status - APPROVED", async () => {
+      await cleanDb();
+      await Promise.all(
+        impersonationRequestsBodyData.slice(0, 5).map((data) =>
+          impersonationModel.createImpersonationRequest({...data,status:"APPROVED"})
+        )
+      );
+      const query = { status: REQUEST_STATE.APPROVED };
+      const result = await impersonationModel.getImpersonationRequests(query);
+      expect(result).to.not.be.null;
+      expect(result.allRequests.every(r => r.status === REQUEST_STATE.APPROVED)).to.be.true;
+    });
+
+    it("Should return a list of all the requests with specified status - PENDING", async () => {
+      const query = { status: REQUEST_STATE.PENDING };
+      const result = await impersonationModel.getImpersonationRequests(query);
+      expect(result).to.not.be.null;
+      expect(result.allRequests.every(r => r.status === REQUEST_STATE.PENDING)).to.be.true;
+    });
+
+    it("Should return a list of all the requests with specified status - REJECTED", async () => {
+      await cleanDb();
+      await Promise.all(
+        impersonationRequestsBodyData.slice(0, 5).map((data) =>
+          impersonationModel.createImpersonationRequest({...data,status:"REJECTED"})
+        )
+      );
+      const query = { status: REQUEST_STATE.REJECTED };
+      const result = await impersonationModel.getImpersonationRequests(query);
+      expect(result).to.not.be.null;
+      expect(result.allRequests.every(r => r.status === REQUEST_STATE.REJECTED)).to.be.true;
+    });
+
+    it("should filter requests by createdBy", async () => {
+      const query = { createdBy: impersonationRequests[0].createdBy };
+      const result = await impersonationModel.getImpersonationRequests(query);
+      expect(result.allRequests.length).to.be.equal(1);
+      expect(result.allRequests.every(r => r.createdBy === impersonationRequests[0].createdBy)).to.be.true;
+    });
+
+    it("should return requests by size", async () => {
+      const query = { size: 2 };
+      const result = await impersonationModel.getImpersonationRequests(query);
+      expect(result.allRequests.length).to.be.equal(2);
+    });
+
+    it("should filter requests by createdFor", async () => {
+      const query = { createdFor: impersonationRequests[0].createdFor };
+      const result = await impersonationModel.getImpersonationRequests(query);
+      expect(result.allRequests.length).to.be.equal(1);
+      expect(result.allRequests.every(r => r.createdFor === impersonationRequests[0].createdFor)).to.be.true;
+    });
+
+
+    it("Should return null if no data is found", async () => {
+      await cleanDb();
+      const query = { status: REQUEST_STATE.PENDING };
+      const impersonationRequestData = await impersonationModel.getImpersonationRequests(query);
+      expect(impersonationRequestData).to.be.equal(null);
+    });
+
+    it("should support pagination", async () => {
+      const query = { size: 2 };
+      const result = await impersonationModel.getImpersonationRequests(query);
+      expect(result.allRequests.length).to.be.at.most(2);
+      expect(result.next).to.exist;
+      expect(result.prev).to.be.null;
+      expect(result.count).to.be.equal(2);
+    });
+
+
+    it("should return the next doc of results using next cursor", async () => {
+      const first = await impersonationModel.getImpersonationRequests({ size: 2 });
+      expect(first.next).to.exist;
+      const next = await impersonationModel.getImpersonationRequests({ size: 2, next: first.next });
+      expect(next.allRequests.length).to.be.at.most(2);
+      expect(next.next).to.not.equal(null);
+      expect(next.prev).to.not.equal(null);
+      expect(next.allRequests[0].id).to.not.equal(first.allRequests[0].id);
+    });
+
+    it("should return the previous doc of results using prev cursor", async () => {
+      const firstPage = await impersonationModel.getImpersonationRequests({ size: 2 });
+      const nextPage = await impersonationModel.getImpersonationRequests({ size: 2, next: firstPage.next });
+      if (nextPage.prev) {
+        const prevPage = await impersonationModel.getImpersonationRequests({ size: 2, prev: nextPage.prev });
+        expect(prevPage.allRequests.length).to.be.at.most(2);
+        expect(prevPage.allRequests[0].id).to.equal(firstPage.allRequests[0].id);
+      }
+    });
+  });
 });
