[PM-6426] Working through jest tests

apps/browser/src/autofill/spec/testing-utils.ts

@@ -1,21 +1,21 @@
 import { mock } from "jest-mock-extended";
 
-function triggerTestFailure() {
+export function triggerTestFailure() {
   expect(true).toBe("Test has failed.");
 }
 
 const scheduler = typeof setImmediate === "function" ? setImmediate : setTimeout;
-function flushPromises() {
+export function flushPromises() {
   return new Promise(function (resolve) {
     scheduler(resolve);
   });
 }
 
-function postWindowMessage(data: any, origin = "https://localhost/", source = window) {
+export function postWindowMessage(data: any, origin = "https://localhost/", source = window) {
   globalThis.dispatchEvent(new MessageEvent("message", { data, origin, source }));
 }
 
-function sendExtensionRuntimeMessage(
+export function sendExtensionRuntimeMessage(
   message: any,
   sender?: chrome.runtime.MessageSender,
   sendResponse?: CallableFunction,
@@ -32,7 +32,7 @@ function sendExtensionRuntimeMessage(
   );
 }
 
-function triggerRuntimeOnConnectEvent(port: chrome.runtime.Port) {
+export function triggerRuntimeOnConnectEvent(port: chrome.runtime.Port) {
   (chrome.runtime.onConnect.addListener as unknown as jest.SpyInstance).mock.calls.forEach(
     (call) => {
       const callback = call[0];
@@ -41,21 +41,21 @@ function triggerRuntimeOnConnectEvent(port: chrome.runtime.Port) {
   );
 }
 
-function sendPortMessage(port: chrome.runtime.Port, message: any) {
+export function sendPortMessage(port: chrome.runtime.Port, message: any) {
   (port.onMessage.addListener as unknown as jest.SpyInstance).mock.calls.forEach((call) => {
     const callback = call[0];
     callback(message || {}, port);
   });
 }
 
-function triggerPortOnDisconnectEvent(port: chrome.runtime.Port) {
+export function triggerPortOnDisconnectEvent(port: chrome.runtime.Port) {
   (port.onDisconnect.addListener as unknown as jest.SpyInstance).mock.calls.forEach((call) => {
     const callback = call[0];
     callback(port);
   });
 }
 
-function triggerWindowOnFocusedChangedEvent(windowId: number) {
+export function triggerWindowOnFocusedChangedEvent(windowId: number) {
   (chrome.windows.onFocusChanged.addListener as unknown as jest.SpyInstance).mock.calls.forEach(
     (call) => {
       const callback = call[0];
@@ -64,7 +64,7 @@ function triggerWindowOnFocusedChangedEvent(windowId: number) {
   );
 }
 
-function triggerTabOnActivatedEvent(activeInfo: chrome.tabs.TabActiveInfo) {
+export function triggerTabOnActivatedEvent(activeInfo: chrome.tabs.TabActiveInfo) {
   (chrome.tabs.onActivated.addListener as unknown as jest.SpyInstance).mock.calls.forEach(
     (call) => {
       const callback = call[0];
@@ -73,14 +73,14 @@ function triggerTabOnActivatedEvent(activeInfo: chrome.tabs.TabActiveInfo) {
   );
 }
 
-function triggerTabOnReplacedEvent(addedTabId: number, removedTabId: number) {
+export function triggerTabOnReplacedEvent(addedTabId: number, removedTabId: number) {
   (chrome.tabs.onReplaced.addListener as unknown as jest.SpyInstance).mock.calls.forEach((call) => {
     const callback = call[0];
     callback(addedTabId, removedTabId);
   });
 }
 
-function triggerTabOnUpdatedEvent(
+export function triggerTabOnUpdatedEvent(
   tabId: number,
   changeInfo: chrome.tabs.TabChangeInfo,
   tab: chrome.tabs.Tab,
@@ -91,24 +91,16 @@ function triggerTabOnUpdatedEvent(
   });
 }
 
-function triggerTabOnRemovedEvent(tabId: number, removeInfo: chrome.tabs.TabRemoveInfo) {
+export function triggerTabOnRemovedEvent(tabId: number, removeInfo: chrome.tabs.TabRemoveInfo) {
   (chrome.tabs.onRemoved.addListener as unknown as jest.SpyInstance).mock.calls.forEach((call) => {
     const callback = call[0];
     callback(tabId, removeInfo);
   });
 }
 
-export {
-  triggerTestFailure,
-  flushPromises,
-  postWindowMessage,
-  sendExtensionRuntimeMessage,
-  triggerRuntimeOnConnectEvent,
-  sendPortMessage,
-  triggerPortOnDisconnectEvent,
-  triggerWindowOnFocusedChangedEvent,
-  triggerTabOnActivatedEvent,
-  triggerTabOnReplacedEvent,
-  triggerTabOnUpdatedEvent,
-  triggerTabOnRemovedEvent,
-};
+export function triggerOnAlarmEvent(alarm: chrome.alarms.Alarm) {
+  (chrome.alarms.onAlarm.addListener as unknown as jest.SpyInstance).mock.calls.forEach((call) => {
+    const callback = call[0];
+    callback(alarm);
+  });
+}

apps/browser/src/platform/services/browser-task-scheduler.service.spec.ts

@@ -6,7 +6,7 @@ import { ConsoleLogService } from "@bitwarden/common/platform/services/console-l
 import { GlobalState, StateProvider } from "@bitwarden/common/platform/state";
 import { UserId } from "@bitwarden/common/types/guid";
 
-import { flushPromises } from "../../autofill/spec/testing-utils";
+import { flushPromises, triggerOnAlarmEvent } from "../../autofill/spec/testing-utils";
 
 import {
   ActiveAlarm,
@@ -49,6 +49,7 @@ describe("BrowserTaskSchedulerService", () => {
   let activeAlarmsMock$: BehaviorSubject<ActiveAlarm[]>;
   let logService: MockProxy<ConsoleLogService>;
   let stateProvider: MockProxy<StateProvider>;
+  let globalStateMock: MockProxy<GlobalState<any>>;
   let browserTaskSchedulerService: BrowserTaskSchedulerService;
   let activeAlarms: ActiveAlarm[] = [];
   const eventUploadsIntervalCreateInfo = { periodInMinutes: 5, delayInMinutes: 5 };
@@ -74,14 +75,13 @@ describe("BrowserTaskSchedulerService", () => {
     activeAlarmsMock$ = new BehaviorSubject(activeAlarms);
     activeUserIdMock$ = new BehaviorSubject(userUuid);
     logService = mock<ConsoleLogService>();
+    globalStateMock = mock<GlobalState<any>>({
+      state$: mock<Observable<any>>(),
+      update: jest.fn((callback) => callback([], {} as any)),
+    });
     stateProvider = mock<StateProvider>({
       activeUserId$: activeUserIdMock$,
-      getGlobal: jest.fn(() =>
-        mock<GlobalState<any>>({
-          state$: mock<Observable<any>>(),
-          update: jest.fn((callback) => callback([], {} as any)),
-        }),
-      ),
+      getGlobal: jest.fn(() => globalStateMock),
     });
     browserTaskSchedulerService = new BrowserTaskSchedulerServiceImplementation(
       logService,
@@ -249,5 +249,72 @@ describe("BrowserTaskSchedulerService", () => {
         expect.any(Function),
       );
     });
+
+    it("triggers a task when an onAlarm event is triggered", () => {
+      const alarm = mock<chrome.alarms.Alarm>({
+        name: ScheduledTaskNames.loginStrategySessionTimeout,
+      });
+
+      triggerOnAlarmEvent(alarm);
+
+      expect(callback).toHaveBeenCalled();
+    });
+  });
+
+  describe("clearScheduledTask", () => {
+    it("skips clearing an alarm if the task name is not passed", async () => {
+      await browserTaskSchedulerService.clearScheduledTask({
+        timeoutId: 1,
+      });
+
+      expect(chrome.alarms.clear).not.toHaveBeenCalled();
+    });
+
+    it("clears the alarm associated with the task", async () => {
+      await browserTaskSchedulerService.clearScheduledTask({
+        taskName: ScheduledTaskNames.loginStrategySessionTimeout,
+      });
+
+      expect(chrome.alarms.clear).toHaveBeenCalledWith(
+        getAlarmNameMock(ScheduledTaskNames.loginStrategySessionTimeout),
+        expect.any(Function),
+      );
+    });
+
+    it("clears the alarm associated with the task when in a non-Chrome environment", async () => {
+      setupGlobalBrowserMock();
+
+      await browserTaskSchedulerService.clearScheduledTask({
+        taskName: ScheduledTaskNames.loginStrategySessionTimeout,
+      });
+
+      expect(browser.alarms.clear).toHaveBeenCalledWith(
+        getAlarmNameMock(ScheduledTaskNames.loginStrategySessionTimeout),
+      );
+    });
+  });
+
+  describe("clearAllScheduledTasks", () => {
+    it("clears all scheduled tasks and extension alarms", async () => {
+      // @ts-expect-error mocking global state update method
+      globalStateMock.update = jest.fn((callback) => {
+        const stateValue = callback([], {} as any);
+        activeAlarmsMock$.next(stateValue);
+        return stateValue;
+      });
+
+      await browserTaskSchedulerService.clearAllScheduledTasks();
+
+      expect(chrome.alarms.clearAll).toHaveBeenCalled();
+      expect(activeAlarmsMock$.value).toEqual([]);
+    });
+
+    it("clears all extension alarms within a non Chrome environment", async () => {
+      setupGlobalBrowserMock();
+
+      await browserTaskSchedulerService.clearAllScheduledTasks();
+
+      expect(browser.alarms.clearAll).toHaveBeenCalled();
+    });
   });
 });