fixes sonarqube issues

Author: pandeymangg

packages/react-native/src/lib/common/api.ts

@@ -101,7 +101,7 @@ export class ApiClient {
   > {
     return makeRequest(
       this.appUrl,
-      `/api/v1/client/${this.environmentId}/environment?rand-${Date.now()}=true`,
+      `/api/v1/client/${this.environmentId}/environment`,
       "GET",
       undefined,
       this.isDebug

packages/react-native/src/lib/common/setup.ts

@@ -311,7 +311,6 @@ export const tearDown = async (): Promise<void> => {
     filteredSurveys,
   });
 
-  setIsSetup(false);
   removeAllEventListeners();
 };
 

packages/react-native/src/lib/common/tests/command-queue.test.ts

@@ -2,6 +2,7 @@ import { beforeEach, describe, expect, test, vi } from "vitest";
 import { CommandQueue } from "@/lib/common/command-queue";
 import { checkSetup } from "@/lib/common/setup";
 import { type Result } from "@/types/error";
+import { delayedResult } from "../utils";
 
 // Mock the setup module so we can control checkSetup()
 vi.mock("@/lib/common/setup", () => ({
@@ -21,24 +22,18 @@ describe("CommandQueue", () => {
   test("executes commands in FIFO order", async () => {
     const executionOrder: string[] = [];
 
-    function delayedResult<T>(value: T, delayMs = 10): Promise<T> {
-      return new Promise((resolve) =>
-        setTimeout(() => resolve(value), delayMs)
-      );
-    }
-
     // Mock commands with proper Result returns
     const cmdA = vi.fn(async (): Promise<Result<void, unknown>> => {
       executionOrder.push("A");
-      return delayedResult({ ok: true, data: undefined });
+      return delayedResult({ ok: true, data: undefined }, 10);
     });
     const cmdB = vi.fn(async (): Promise<Result<void, unknown>> => {
       executionOrder.push("B");
-      return delayedResult({ ok: true, data: undefined });
+      return delayedResult({ ok: true, data: undefined }, 10);
     });
     const cmdC = vi.fn(async (): Promise<Result<void, unknown>> => {
       executionOrder.push("C");
-      return delayedResult({ ok: true, data: undefined });
+      return delayedResult({ ok: true, data: undefined }, 10);
     });
 
     // We'll assume checkSetup always ok for this test
@@ -57,11 +52,7 @@ describe("CommandQueue", () => {
 
   test("skips execution if checkSetup() fails", async () => {
     const cmd = vi.fn(async (): Promise<void> => {
-      return new Promise((resolve) => {
-        setTimeout(() => {
-          resolve();
-        }, 10);
-      });
+      return delayedResult(undefined, 10);
     });
 
     // Force checkSetup to fail
@@ -82,11 +73,7 @@ describe("CommandQueue", () => {
 
   test("executes command if checkSetup is false (no check)", async () => {
     const cmd = vi.fn(async (): Promise<Result<void, unknown>> => {
-      return new Promise((resolve) => {
-        setTimeout(() => {
-          resolve({ ok: true, data: undefined });
-        }, 10);
-      });
+      return delayedResult({ ok: true, data: undefined }, 10);
     });
 
     // checkSetup is irrelevant in this scenario, but let's mock it anyway
@@ -115,11 +102,7 @@ describe("CommandQueue", () => {
 
     // Mock command that fails
     const failingCmd = vi.fn(async () => {
-      await new Promise((resolve) => {
-        setTimeout(() => {
-          resolve("some error");
-        }, 10);
-      });
+      await delayedResult("some error", 10);
 
       throw new Error("some error");
     });
@@ -136,18 +119,10 @@ describe("CommandQueue", () => {
 
   test("resolves wait() after all commands complete", async () => {
     const cmd1 = vi.fn(async (): Promise<Result<void, unknown>> => {
-      return new Promise((resolve) => {
-        setTimeout(() => {
-          resolve({ ok: true, data: undefined });
-        }, 10);
-      });
+      return delayedResult({ ok: true, data: undefined }, 10);
     });
     const cmd2 = vi.fn(async (): Promise<Result<void, unknown>> => {
-      return new Promise((resolve) => {
-        setTimeout(() => {
-          resolve({ ok: true, data: undefined });
-        }, 10);
-      });
+      return delayedResult({ ok: true, data: undefined }, 10);
     });
 
     vi.mocked(checkSetup).mockReturnValue({ ok: true, data: undefined });

packages/react-native/src/lib/common/tests/config.test.ts

@@ -29,8 +29,8 @@ describe("RNConfig", () => {
     vi.restoreAllMocks();
   });
 
-  test("getInstance() returns a singleton", () => {
-    const secondInstance = RNConfig.getInstance();
+  test("getInstance() returns a singleton", async () => {
+    const secondInstance = await RNConfig.getInstance();
     expect(configInstance).toBe(secondInstance);
   });
 

packages/react-native/src/lib/common/tests/utils.test.ts

@@ -5,6 +5,7 @@ import {
   mockSurveyId,
 } from "@/lib/common/tests/__mocks__/config.mock";
 import {
+  delayedResult,
   diffInDays,
   filterSurveys,
   getDefaultLanguageCode,
@@ -25,10 +26,6 @@ const mockSurveyId2 = "qo9rwjmms42hoy3k85fp8vgu";
 const mockSegmentId1 = "p6yrnz3s2tvoe5r0l28unq7k";
 const mockSegmentId2 = "wz43zrxeddhb1uo9cicustar";
 
-function delay(ms: number) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
 describe("utils.ts", () => {
   // ---------------------------------------------------------------------------------
   // diffInDays
@@ -58,7 +55,7 @@ describe("utils.ts", () => {
   describe("wrapThrowsAsync()", () => {
     test("returns ok on success", async () => {
       const fn = vi.fn(async (x: number) => {
-        await delay(10);
+        await delayedResult(null, 10);
         return x * 2;
       });
 
@@ -73,7 +70,7 @@ describe("utils.ts", () => {
 
     test("returns err on error", async () => {
       const fn = vi.fn(async () => {
-        await delay(10);
+        await delayedResult(null, 10);
         throw new Error("Something broke");
       });
       const wrapped = wrapThrowsAsync(fn);
@@ -422,4 +419,17 @@ describe("utils.ts", () => {
       mockedRandom.mockRestore();
     });
   });
+
+  // ---------------------------------------------------------------------------------
+  // delayedResult
+  // ---------------------------------------------------------------------------------
+  describe("delayedResult()", () => {
+    test("returns the value after the delay", async () => {
+      const result = await delayedResult(10, 10);
+      expect(result).toBe(10);
+
+      const result2 = await delayedResult(20, 20);
+      expect(result2).toBe(20);
+    });
+  });
 });

packages/react-native/src/lib/common/utils.ts

@@ -188,3 +188,7 @@ export const shouldDisplayBasedOnPercentage = (
 export const isNowExpired = (expirationDate: Date): boolean => {
   return new Date() >= expirationDate;
 };
+
+export const delayedResult = async <T>(value: T, ms: number): Promise<T> => {
+  return new Promise((resolve) => setTimeout(() => resolve(value), ms));
+};

packages/react-native/src/lib/environment/tests/state.test.ts

@@ -286,10 +286,10 @@ describe("environment/state.ts", () => {
       expect(mockConfig.update).not.toHaveBeenCalled();
     });
 
-    test("clears interval when clearEnvironmentStateExpiryCheckListener is called", () => {
+    test("clears interval when clearEnvironmentStateExpiryCheckListener is called", async () => {
       const clearIntervalSpy = vi.spyOn(global, "clearInterval");
 
-      addEnvironmentStateExpiryCheckListener();
+      await addEnvironmentStateExpiryCheckListener();
       clearEnvironmentStateExpiryCheckListener();
 
       expect(clearIntervalSpy).toHaveBeenCalled();

packages/react-native/src/lib/survey/tests/action.test.ts

@@ -122,21 +122,21 @@ describe("survey/action.ts", () => {
       });
     });
 
-    test("triggers survey associated with action name", () => {
+    test("triggers survey associated with action name", async () => {
       (shouldDisplayBasedOnPercentage as unknown as Mock).mockReturnValue(true);
 
-      trackAction("testAction");
+      await trackAction("testAction");
 
       // Ensure triggerSurvey is called for the matching survey
       expect(mockSurveyStore.setSurvey).toHaveBeenCalledWith(mockSurvey);
     });
 
-    test("does not trigger survey if no active surveys are found", () => {
+    test("does not trigger survey if no active surveys are found", async () => {
       mockAppConfig.get.mockReturnValue({
         filteredSurveys: [],
       });
 
-      trackAction("testAction");
+      await trackAction("testAction");
 
       // Ensure no surveys are triggered
       expect(mockSurveyStore.setSurvey).not.toHaveBeenCalled();
@@ -145,8 +145,8 @@ describe("survey/action.ts", () => {
       );
     });
 
-    test("logs tracked action name", () => {
-      trackAction("testAction");
+    test("logs tracked action name", async () => {
+      await trackAction("testAction");
 
       expect(mockLogger.debug).toHaveBeenCalledWith(
         'Formbricks: Action "testAction" tracked'

packages/react-native/src/lib/user/tests/attribute.test.ts

@@ -1,6 +1,7 @@
 import { beforeEach, describe, expect, test, vi } from "vitest";
 import { setAttributes } from "@/lib/user/attribute";
 import { UpdateQueue } from "@/lib/user/update-queue";
+import { delayedResult } from "@/lib/common/utils";
 
 export const mockAttributes = {
   name: "John Doe",
@@ -17,10 +18,6 @@ vi.mock("@/lib/user/update-queue", () => ({
   },
 }));
 
-function delay(ms: number) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
 describe("User Attributes", () => {
   const mockUpdateQueue = {
     updateAttributes: vi.fn(),
@@ -73,7 +70,9 @@ describe("User Attributes", () => {
       const attributes = { name: mockAttributes.name };
 
       // Mock processUpdates to be async
-      mockUpdateQueue.processUpdates.mockImplementation(() => delay(100));
+      mockUpdateQueue.processUpdates.mockImplementation(() =>
+        delayedResult(undefined, 100)
+      );
 
       const result = await setAttributes(attributes);
 

packages/react-native/src/lib/user/tests/state.test.ts

@@ -38,7 +38,7 @@ describe("User State Expiry Check Listener", () => {
     clearUserStateExpiryCheckListener(); // Ensure cleanup after each test
   });
 
-  test("should set an interval if not already set and update user state expiry when userId exists", () => {
+  test("should set an interval if not already set and update user state expiry when userId exists", async () => {
     const mockConfig = {
       get: vi.fn().mockReturnValue({
         user: { data: { userId: mockUserId } },
@@ -48,7 +48,7 @@ describe("User State Expiry Check Listener", () => {
 
     mockRNConfig.mockReturnValue(mockConfig as unknown as Promise<RNConfig>);
 
-    addUserStateExpiryCheckListener();
+    await addUserStateExpiryCheckListener();
 
     // Fast-forward time by 1 minute (60,000 ms)
     vi.advanceTimersByTime(60_000);
@@ -78,7 +78,7 @@ describe("User State Expiry Check Listener", () => {
     expect(mockConfig.update).not.toHaveBeenCalled(); // Ensures no update when no userId
   });
 
-  test("should not set multiple intervals if already set", () => {
+  test("should not set multiple intervals if already set", async () => {
     const mockConfig = {
       get: vi.fn().mockReturnValue({
         user: { data: { userId: mockUserId } },
@@ -88,8 +88,8 @@ describe("User State Expiry Check Listener", () => {
 
     mockRNConfig.mockReturnValue(mockConfig as unknown as Promise<RNConfig>);
 
-    addUserStateExpiryCheckListener();
-    addUserStateExpiryCheckListener(); // Call again to check if it prevents multiple intervals
+    await addUserStateExpiryCheckListener();
+    await addUserStateExpiryCheckListener(); // Call again to check if it prevents multiple intervals
 
     vi.advanceTimersByTime(60_000); // Fast-forward 1 minute