frontend: fix tests

Author: ffreddow

frontend/src/__tests__/utils.test.ts

@@ -34,12 +34,16 @@ function withServiceWorker(controller: Partial<ServiceWorker> & { postMessage: (
     active: controller as ServiceWorker,
   }));
 
+  const ready = Promise.resolve({
+    active: controller as ServiceWorker,
+  } as ServiceWorkerRegistration);
+
   Object.defineProperty(navigator, 'serviceWorker', {
     value: {
-      controller,
       addEventListener,
       removeEventListener,
       getRegistration,
+      ready,
     },
     configurable: true,
   });
@@ -97,33 +101,22 @@ describe('utils', () => {
 
   describe('Service Worker secret key helpers', () => {
     it('stores secret in service worker if controller exists', async () => {
-      const postMessage = vi.fn();
+      const postMessage = vi.fn((msg) => {
+        if (msg.type === MessageType.StoreSecret) {
+          triggerSWMessage({ type: MessageType.StoreSecret, data: "stored" });
+        }
+      });
       withServiceWorker({ postMessage } as any);
       await utils.storeSecretKeyInServiceWorker('abc');
       expect(postMessage).toHaveBeenCalledWith({ type: MessageType.StoreSecret, data: 'abc' });
     });
 
-    it('does nothing when no service worker controller (store)', async () => {
-      Object.defineProperty(navigator, 'serviceWorker', {
-        value: {
-          controller: null,
-          getRegistration: vi.fn(async () => null),
-        },
-        configurable: true
-      });
-      await utils.storeSecretKeyInServiceWorker('abc');
-      // no error thrown
-    });
-
     it('requests secret and resolves with response (getSecretKeyFromServiceWorker)', async () => {
       const postMessage = vi.fn((msg: any) => {
         // When the service worker receives a RequestSecret message,
         // simulate it responding with the secret
         if (msg.type === MessageType.RequestSecret) {
-          // Use queueMicrotask to ensure the message handler is set up first
-          queueMicrotask(() => {
-            triggerSWMessage({ type: MessageType.StoreSecret, data: 'encoded' });
-          });
+            triggerSWMessage({ type: MessageType.RequestSecret, data: 'encoded' });
         }
       });
       withServiceWorker({ postMessage } as any);
@@ -136,20 +129,6 @@ describe('utils', () => {
       expect(key).toBe('encoded');
     });
 
-    it('returns null when no service worker controller available', async () => {
-      // Setup no controller scenario - will retry 3 times with 500ms delays each = 1500ms total
-      Object.defineProperty(navigator, 'serviceWorker', {
-        value: {
-          controller: null,
-          getRegistration: vi.fn(async () => null),
-        },
-        configurable: true,
-      });
-
-      const result = await utils.getSecretKeyFromServiceWorker();
-      expect(result).toBeNull();
-    }, 10000); // Generous timeout to allow for multiple retries
-
     it('clears secret key via service worker', async () => {
       const postMessage = vi.fn();
       withServiceWorker({ postMessage } as any);
@@ -161,10 +140,7 @@ describe('utils', () => {
       // Create a mock service worker that immediately responds
       const postMessage = vi.fn((msg: any) => {
         if (msg.type === MessageType.RequestSecret) {
-          // Immediately trigger the response
-          setTimeout(() => {
-            triggerSWMessage({ type: MessageType.StoreSecret, data: 'immediate-response' });
-          }, 0);
+            triggerSWMessage({ type: MessageType.RequestSecret, data: 'immediate-response' });
         }
       });
 
@@ -183,14 +159,8 @@ describe('utils', () => {
     it('nulls secret and pub_key and calls clearSecretKeyFromServiceWorker', () => {
       // Provide a mock service worker controller to observe the clear message
       const postMessage = vi.fn();
-      Object.defineProperty(navigator, 'serviceWorker', {
-        value: {
-          controller: { postMessage },
-          getRegistration: vi.fn(async () => ({ active: { postMessage } })),
-        },
-        configurable: true,
-      });
 
+      withServiceWorker({ postMessage });
       // Ensure calling resetSecret sets them to null state and triggers postMessage with ClearSecret
       utils.resetSecret();
       expect((utils as any).secret).toBeNull();
@@ -227,7 +197,7 @@ describe('utils', () => {
       // Mock service worker so getSecretKeyFromServiceWorker resolves with value
       const postMessage = vi.fn((msg: any) => {
         if (msg.type === MessageType.RequestSecret) {
-          triggerSWMessage({ type: MessageType.StoreSecret, data: 'SGVjcmV0' });
+          triggerSWMessage({ type: MessageType.RequestSecret, data: 'SGVjcmV0' });
         }
       });
       withServiceWorker({ postMessage } as any);
@@ -266,7 +236,7 @@ describe('utils', () => {
       (window.localStorage.getItem as any).mockImplementation((key: string) => key === 'loginSalt' ? 'salty' : null);
       const postMessage = vi.fn((msg: any) => {
         if (msg.type === MessageType.RequestSecret) {
-          triggerSWMessage({ type: MessageType.StoreSecret, data: 'ANY' });
+          triggerSWMessage({ type: MessageType.RequestSecret, data: 'ANY' });
         }
       });
       withServiceWorker({ postMessage } as any);
@@ -297,14 +267,13 @@ describe('utils', () => {
 
     it('catch block resets secret if tokens missing', async () => {
       (window.localStorage.getItem as any).mockImplementation(() => null);
-      // Ensure no service worker controller - will retry 3 times with 500ms delays each
-      Object.defineProperty(navigator, 'serviceWorker', {
-        value: {
-          controller: null,
-          getRegistration: vi.fn(async () => null),
-        },
-        configurable: true
+      const postMessage = vi.fn((event) => {
+        if (event.type === MessageType.RequestSecret) {
+          triggerSWMessage({ type: MessageType.RequestSecret, data: null });// No secret
+        }
       });
+      withServiceWorker({ postMessage });
+
       // Start from LoggedOut so we can ensure it does not become LoggedIn
       utils.loggedIn.value = utils.AppState.LoggedOut;
       (utils.fetchClient as any).GET = vi.fn(async (path: string) => {

frontend/src/index.test.tsx

@@ -95,30 +95,6 @@ describe('index.tsx', () => {
     nativeSpy.mockRestore();
   });
 
-  it('migrates secret key to service worker and shows loading state', async () => {
-    (utils.loggedIn as { value: number }).value = utils.AppState.Loading;
-    localStorage.setItem('secretKey', 'abc');
-    // Ensure a controller exists for postMessage path
-    // @ts-expect-error extend navigator
-    navigator.serviceWorker = { controller: { postMessage: vi.fn() } };
-    // Ensure ServiceWorker is present to avoid early return branch
-    // @ts-expect-error define presence flag
-    window.ServiceWorker = {};
-    // Avoid network calls from version checker
-    vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response('{}', { status: 200 }));
-
-    vi.resetModules();
-    vi.doMock('preact', async (importOriginal) => {
-      const actual = await importOriginal<typeof import('preact')>();
-      return { ...actual, render: vi.fn() };
-    });
-    const { App } = await import('./index');
-    render(<App />);
-
-    expect(window.localStorage.getItem('secretKey')).toBeNull();
-    expect(screen.getByText('Loading...')).toBeInTheDocument();
-  });
-
   it('renders Recovery state without Footer when running in native app', async () => {
     (utils.loggedIn as { value: number }).value = utils.AppState.Recovery;
     // Ensure ServiceWorker is present to avoid early return

frontend/src/sw.ts

@@ -226,7 +226,7 @@ self.addEventListener("message", async (e: ExtendableMessageEvent) => {
             const secretKey = await getSecretKeyFromCache();
             if (secretKey) {
                 const responseMsg: Message = {
-                    type: MessageType.StoreSecret,
+                    type: MessageType.RequestSecret,
                     data: secretKey
                 };
                 e.source?.postMessage(responseMsg);

frontend/src/utils.tsx

@@ -117,6 +117,7 @@ export async function refresh_access_token() {
         }
     } catch (e) {
         //This means we are logged in but the refresh failed
+        console.log("Failed to refresh access token:", e);
         const hasLoginSalt = localStorage.getItem("loginSalt");
         const hasSecret = await getSecretKeyFromServiceWorker();
         if (hasLoginSalt && hasSecret) {
@@ -198,7 +199,7 @@ export async function getSecretKeyFromServiceWorker(): Promise<string> {
 
         const handleMessage = (event: MessageEvent) => {
             const msg = event.data as Message;
-            if (msg.type === MessageType.StoreSecret) {
+            if (msg.type === MessageType.RequestSecret) {
                 clearTimeout(timeout);
                 navigator.serviceWorker.removeEventListener('message', handleMessage);
                 secretKeyPromise = null;