changed to typescript and modified unit tests

Author: shobhan-sundar-goutam

models/discordactions.js

@@ -133,7 +133,7 @@ const updateGroupRole = async (roleData, docId) => {
  *
  * @param options { Object }: Data of the new role
  * @param options.rolename String : name of the role
- * @param options.roleId String : id of the role
+ * @param options.roleid String : id of the role
  * @returns {Promise<discordRoleModel|Object>}
  */
 

test/unit/utils/remvoeDiscordRoleFromUser.test.js

@@ -0,0 +1,123 @@
+import chai from "chai";
+import Sinon from "sinon";
+import { logType } from "../../../constants/logs";
+import discordActions from "../../../models/discordactions";
+import { addLog } from "../../../models/logs";
+import firestore from "../../../utils/firestore";
+import { removeDiscordRoleFromUser } from "../../../utils/removeDiscordRoleFromUser";
+import { groupData, memberGroupData } from "../../fixtures/discordactions/discordactions";
+import addUser from "../../utils/addUser";
+import cleanDb from "../../utils/cleanDb";
+const { expect } = chai;
+const discordRolesModel = firestore.collection("discord-roles");
+const memberRoleModel = firestore.collection("member-group-roles");
+const logsModel = firestore.collection("logs");
+const userData = require("../../fixtures/user/user")();
+
+describe("removeDiscordRoleFromUser", function () {
+  let userId;
+  let discordId;
+  let roleid;
+  let fetchStub;
+
+  beforeEach(async function () {
+    userData[0].roles = { archived: false, in_discord: true };
+    userId = await addUser(userData[0]);
+    discordId = userData[0].discordId;
+    userData[0] = { ...userData[0], id: userId };
+
+    const addRolePromises = memberGroupData.map(async (data) => {
+      await memberRoleModel.add(data);
+    });
+    const discordRolesModelPromise = [discordRolesModel.add(groupData[0]), discordRolesModel.add(groupData[1])];
+    await Promise.all(discordRolesModelPromise);
+    roleid = groupData[0].roleid;
+    await memberRoleModel.add({ roleid, userid: discordId });
+    await Promise.all(addRolePromises);
+
+    fetchStub = Sinon.stub(global, "fetch");
+  });
+
+  afterEach(async function () {
+    await cleanDb();
+    fetchStub.restore();
+  });
+
+  it("should remove discord role successfully", async function () {
+    await addLog(
+      logType.REMOVE_ROLE_FROM_USER_SUCCESS,
+      { roleId: roleid, userid: discordId },
+      { message: "Role removed successfully from user", userData: userData[0] }
+    );
+
+    fetchStub.returns(
+      Promise.resolve({ json: () => Promise.resolve({ success: true, message: "Role deleted successfully" }) })
+    );
+
+    const isDiscordRoleRemoved = await removeDiscordRoleFromUser(userData[0], discordId, roleid);
+    const successLog = await logsModel
+      .where("type", "==", logType.REMOVE_ROLE_FROM_USER_SUCCESS)
+      .where("meta.roleId", "==", roleid)
+      .where("meta.userid", "==", discordId)
+      .limit(1)
+      .get();
+
+    expect(isDiscordRoleRemoved.success).to.be.equal(true);
+    expect(isDiscordRoleRemoved.message).to.be.equal("Role deleted successfully");
+    expect(successLog.docs[0].data().body.message).to.be.equal("Role removed successfully from user");
+  });
+
+  it("should throw an error if role doesn't exist in database when attempting to remove", async function () {
+    roleid = "randomRoleId";
+
+    const isDiscordRoleRemoved = await removeDiscordRoleFromUser(userData[0], discordId, roleid);
+    const failedLog = await logsModel
+      .where("type", "==", logType.REMOVE_ROLE_FROM_USER_FAILED)
+      .where("meta.roleId", "==", roleid)
+      .limit(1)
+      .get();
+
+    expect(isDiscordRoleRemoved.success).to.be.equal(false);
+    expect(isDiscordRoleRemoved.message).to.be.equal("Role doesn't exist");
+    expect(failedLog.docs[0].data().body.message).to.be.equal("Role doesn't exist");
+  });
+
+  it("should throw an error if role deletion from discord failed", async function () {
+    fetchStub.rejects(new Error("Role deletion from discord failed"));
+
+    const isDiscordRoleRemoved = await removeDiscordRoleFromUser(userData[0], discordId, roleid);
+    const failedLog = await logsModel
+      .where("type", "==", logType.REMOVE_ROLE_FROM_USER_FAILED)
+      .where("meta.roleId", "==", roleid)
+      .where("meta.userid", "==", discordId)
+      .limit(1)
+      .get();
+
+    expect(isDiscordRoleRemoved.success).to.be.equal(false);
+    expect(isDiscordRoleRemoved.message).to.be.equal("Role deletion from discord failed");
+    expect(failedLog.docs[0].data().body.message).to.be.equal("Role deletion from discord failed");
+  });
+
+  it("should throw an error if role deleted from discord but not from database", async function () {
+    fetchStub.returns(Promise.resolve({ json: () => Promise.resolve({ success: true }) }));
+
+    const removeMemberGroupStub = Sinon.stub(discordActions, "removeMemberGroup").resolves({
+      roleId: roleid,
+      wasSuccess: false,
+    });
+
+    const isDiscordRoleRemoved = await removeDiscordRoleFromUser(userData[0], discordId, roleid);
+    const failedLog = await logsModel
+      .where("type", "==", logType.REMOVE_ROLE_FROM_USER_FAILED)
+      .where("meta.roleId", "==", roleid)
+      .where("meta.userid", "==", discordId)
+      .limit(1)
+      .get();
+
+    expect(isDiscordRoleRemoved.success).to.be.equal(false);
+    expect(isDiscordRoleRemoved.message).to.be.equal("Role deletion from database failed");
+    expect(failedLog.docs[0].data().body.message).to.be.equal("Role deletion from database failed");
+
+    removeMemberGroupStub.restore();
+  });
+});

test/unit/utils/remvoeDiscordRoleFromUser.test.ts

@@ -1,7 +1,8 @@
-const discordRolesModel = require("../models/discordactions");
-const discordServices = require("../services/discordService");
-const { logType } = require("../constants/logs");
-const { addLog } = require("../models/logs");
+import { logType } from "../constants/logs";
+import discordActions from "../models/discordactions";
+import { addLog } from "../models/logs";
+import discordServices from "../services/discordService";
+import { userData } from "../types/global";
 
 /**
  * Removes a Discord role from a user using Discord Id.
@@ -10,11 +11,15 @@ const { addLog } = require("../models/logs");
  * @param {string} discordId - User's Discord ID.
  * @param {string} roleId - Discord Role ID.
  *
- * @returns {Promise<Object>} - Result with success status and message.
+ * @returns {Promise<{ success: boolean; message: string }>} - Result with success status and message.
  */
-export const removeDiscordRoleFromUser = async (userData, discordId, roleId) => {
+export const removeDiscordRoleFromUser = async (
+  userData: userData,
+  discordId: string,
+  roleId: string
+): Promise<{ success: boolean; message: string }> => {
   try {
-    const { roleExists } = await discordRolesModel.isGroupRoleExists({ roleid: roleId });
+    const { roleExists } = await discordActions.isGroupRoleExists({ roleid: roleId, rolename: null });
 
     if (!roleExists) {
       const message = "Role doesn't exist";
@@ -30,8 +35,8 @@ export const removeDiscordRoleFromUser = async (userData, discordId, roleId) =>
       throw new Error(message);
     }
 
-    const { wasSuccess } = await discordRolesModel.removeMemberGroup(roleId, discordId);
-    if (!wasSuccess) {
+    const deleteResponse = await discordActions.removeMemberGroup(roleId, discordId);
+    if (deleteResponse && !deleteResponse.wasSuccess) {
       const message = "Role deletion from database failed";
       await addLog(logType.REMOVE_ROLE_FROM_USER_FAILED, { roleId, userid: discordId }, { message, userData });
       throw new Error(message);