feat: added tests to support onboarding-extension-command

Author: pankajjs

tests/fixtures/fixture.ts

@@ -383,3 +383,21 @@ export const testDataWithDevTitle = {
     value: true,
   },
 };
+
+export const transformedArgsForOnboardingExtension = {
+  member: {
+    user: {
+      id: 134672111,
+      username: "username",
+      discriminator: "<discriminator>",
+      avatar: "<avatar>",
+    },
+    nick: "<nick>",
+    joined_at: "<joined_at>",
+  },
+  userId: { name: "userId", type: 6, value: "1545562672", options: [] },
+  numberOfDays: { value: "20", name: "numberOfDays", type: 3, options: [] },
+  reason: { value: "reason", name: "reason", type: 3, options: [] },
+  channelId: 6754321,
+  dev: { value: false, name: "dev", type: 5 },
+};

tests/unit/handlers/onboardingExtension.test.ts

@@ -0,0 +1,59 @@
+import { onboardingExtensionCommand } from "../../../src/controllers/onboardingExtensionCommand";
+import { discordTextResponse } from "../../../src/utils/discordResponse";
+import {
+  ctx,
+  guildEnv,
+  transformedArgsForOnboardingExtension,
+} from "../../fixtures/fixture";
+import * as utils from "../../../src/utils/onboardingExtension";
+
+describe("onboardingExtensionCommand", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+  const discordId =
+    transformedArgsForOnboardingExtension.member.user.id.toString();
+
+  it("should return Feature not implemented", async () => {
+    const expectedRes = await onboardingExtensionCommand(
+      transformedArgsForOnboardingExtension,
+      guildEnv,
+      ctx
+    );
+    const jsonResponse = await expectedRes.json();
+    const mockResponse = discordTextResponse(
+      `<@${discordId}> Feature not implemented`
+    );
+    const mockJsonResponse = await mockResponse.json();
+    expect(jsonResponse).toStrictEqual(mockJsonResponse);
+  });
+
+  it("should return initial response", async () => {
+    transformedArgsForOnboardingExtension.dev.value = true;
+    const expectedRes = await onboardingExtensionCommand(
+      transformedArgsForOnboardingExtension,
+      guildEnv,
+      ctx
+    );
+    const jsonResponse = await expectedRes.json();
+    const mockResponse = discordTextResponse(
+      `<@${discordId}> Processing your request for onboarding extension`
+    );
+    const mockJsonResponse = await mockResponse.json();
+    expect(jsonResponse).toStrictEqual(mockJsonResponse);
+  });
+
+  it("should call fetch", async () => {
+    jest.spyOn(utils, "createOnboardingExtension");
+    transformedArgsForOnboardingExtension.dev.value = true;
+    await onboardingExtensionCommand(
+      transformedArgsForOnboardingExtension,
+      guildEnv,
+      ctx
+    );
+    expect(utils.createOnboardingExtension).toHaveBeenCalledTimes(1);
+  });
+});

tests/unit/utils/onboardingExtension.test.ts

@@ -0,0 +1,88 @@
+import config from "../../../config/config";
+import { DISCORD_BASE_URL } from "../../../src/constants/urls";
+import { generateDiscordAuthToken } from "../../../src/utils/authTokenGenerator";
+import {
+  createOnboardingExtension,
+  CreateOnboardingExtensionArgs,
+} from "../../../src/utils/onboardingExtension";
+import * as utils from "../../../src/utils/sendReplyInDiscordChannel";
+import { env, guildEnv } from "../../fixtures/fixture";
+
+describe("createOnboaringExtension", () => {
+  const args: CreateOnboardingExtensionArgs = {
+    channelId: 123456789,
+    discordId: "4574263",
+    numberOfDays: 2,
+    reason: "This is reason",
+    userId: "1462465462546",
+  };
+  const discordReplyUrl = `${DISCORD_BASE_URL}/channels/${args.channelId}/messages`;
+  const base_url = config(env).RDS_BASE_API_URL;
+  const errorContent = `<@${args.discordId}> Error occurred while creating onboarding extension request.`;
+  const createOnboardingExtensionUrl = `${base_url}/requests?dev=true`;
+  let fetchSpy: jest.SpyInstance;
+  let authToken: string;
+
+  const requestData = {
+    userId: args.userId,
+    type: "ONBOARDING",
+    numberOfDays: args.numberOfDays,
+    requestedBy: args.discordId,
+    reason: args.reason,
+  };
+
+  beforeEach(async () => {
+    jest.clearAllMocks();
+    fetchSpy = jest.spyOn(global, "fetch");
+    jest.spyOn(utils, "sendReplyInDiscordChannel");
+    authToken = await generateDiscordAuthToken(
+      "Cloudflare Worker",
+      Math.floor(Date.now() / 1000) + 2,
+      guildEnv.DISCORD_TOKEN,
+      "RS256"
+    );
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it("should call fetch with error response", async () => {
+    fetchSpy.mockImplementation(() => {
+      throw new Error();
+    });
+    try {
+      await createOnboardingExtension(args, guildEnv);
+    } catch (err) {
+      expect(global.fetch).toHaveBeenCalledTimes(2);
+      expect(global.fetch).toHaveBeenCalledWith(createOnboardingExtensionUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${authToken}`,
+        },
+        body: JSON.stringify(requestData),
+      });
+      expect(utils.sendReplyInDiscordChannel).toHaveBeenCalledTimes(1);
+      expect(utils.sendReplyInDiscordChannel).toHaveBeenCalledWith(
+        discordReplyUrl,
+        errorContent,
+        guildEnv
+      );
+    }
+  });
+
+  it("should call fetch with success response", async () => {
+    await createOnboardingExtension(args, guildEnv);
+    expect(global.fetch).toHaveBeenCalledTimes(2);
+    expect(global.fetch).toHaveBeenCalledWith(createOnboardingExtensionUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${authToken}`,
+      },
+      body: JSON.stringify(requestData),
+    });
+    expect(utils.sendReplyInDiscordChannel).toHaveBeenCalledTimes(1);
+  });
+});

tests/unit/utils/sendReplyInDiscordChannel.test.ts

@@ -0,0 +1,29 @@
+import { sendReplyInDiscordChannel } from "../../../src/utils/sendReplyInDiscordChannel";
+
+describe("sendReplyInDiscordChannel", () => {
+  const discordReplyUrl = "<disocrd-url>";
+  const content = "<dicord-content>;";
+  const mockEnv = { DISCORD_TOKEN: "mockToken" };
+
+  beforeEach(() => {
+    jest.restoreAllMocks();
+    jest.clearAllMocks();
+  });
+
+  it("should call fetch", async () => {
+    jest.spyOn(global, "fetch").mockResolvedValue(new Response(content));
+
+    await sendReplyInDiscordChannel(discordReplyUrl, content, mockEnv);
+
+    expect(global.fetch).toHaveBeenCalledWith(discordReplyUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bot ${mockEnv.DISCORD_TOKEN}`,
+      },
+      body: JSON.stringify({
+        content: content,
+      }),
+    });
+  });
+});