Privacy-first password manager with built-in email aliasing. Fully encrypted and self-hostable.
Add test for browser extension RPO dirty flag restore mechanism (#1404)
Leendert de Borst81374d5261cb
diff --git a/apps/browser-extension/src/entrypoints/popup/context/AppContext.tsx b/apps/browser-extension/src/entrypoints/popup/context/AppContext.tsxindex 8e0c68bd1..3c3f80ebc 100644--- a/apps/browser-extension/src/entrypoints/popup/context/AppContext.tsx+++ b/apps/browser-extension/src/entrypoints/popup/context/AppContext.tsx@@ -65,6 +65,14 @@ export const AppProvider: React.FC<{ children: React.ReactNode }> = ({ childrenreturn isLoggedIn;}, [auth]);+ /**+ * Set auth tokens and update logged in state.+ */+ const setAuthTokens = useCallback(async (username: string, accessToken: string, refreshToken: string): Promise<void> => {+ await auth.setAuthTokens(username, accessToken, refreshToken);+ setIsLoggedIn(true);+ }, [auth]);+/*** Subscribe to logout events from WebApiService.*/@@ -91,17 +99,17 @@ export const AppProvider: React.FC<{ children: React.ReactNode }> = ({ children// Wrap auth methodslogout,initializeAuth,- setAuthTokens: auth.setAuthTokens,+ setAuthTokens,clearGlobalMessage: auth.clearGlobalMessage,isLoggedIn: isLoggedIn,}), [auth.isInitialized,auth.username,auth.globalMessage,- auth.setAuthTokens,auth.clearGlobalMessage,logout,initializeAuth,+ setAuthTokens,isLoggedIn,]);diff --git a/apps/browser-extension/src/entrypoints/popup/context/DbContext.tsx b/apps/browser-extension/src/entrypoints/popup/context/DbContext.tsxindex e2a30350e..816fe947d 100644--- a/apps/browser-extension/src/entrypoints/popup/context/DbContext.tsx+++ b/apps/browser-extension/src/entrypoints/popup/context/DbContext.tsx@@ -1,4 +1,4 @@-import React, { createContext, useContext, useState, useEffect, useCallback, useMemo } from 'react';+import React, { createContext, useContext, useState, useEffect, useCallback, useMemo, useRef } from 'react';import { sendMessage } from 'webext-bridge/popup';import type { EncryptionKeyDerivationParams } from '@/utils/dist/core/models/metadata';@@ -23,6 +23,10 @@ type DbContextType = {dbInitialized: boolean;dbAvailable: boolean;isOffline: boolean;+ /**+ * Get offline state synchronously (avoids React state timing issues).+ */+ getIsOffline: () => boolean;/*** True if local vault has changes not yet synced to server.*/@@ -83,8 +87,10 @@ export const DbProvider: React.FC<{ children: React.ReactNode }> = ({ children }/*** Offline mode state. If true, the extension is operating offline.+ * Uses both ref (for sync reads) and state (for re-renders).*/const [isOffline, setIsOfflineState] = useState(false);+ const isOfflineRef = useRef(false);/*** Dirty state - true if local vault has unsynced changes.@@ -103,8 +109,10 @@ export const DbProvider: React.FC<{ children: React.ReactNode }> = ({ children }/*** Set the offline mode state and persist it to local storage.+ * Updates both ref (sync) and state (triggers re-render).*/const setIsOffline = useCallback(async (offline: boolean) => {+ isOfflineRef.current = offline;setIsOfflineState(offline);await storage.setItem('local:isOfflineMode', offline);}, []);@@ -122,6 +130,7 @@ export const DbProvider: React.FC<{ children: React.ReactNode }> = ({ children }storage.getItem('local:isDirty') as Promise<boolean | null>,storage.getItem('local:serverRevision') as Promise<number | null>]);+ isOfflineRef.current = offlineMode ?? false;setIsOfflineState(offlineMode ?? false);setIsDirty(dirty ?? false);setServerRevision(revision ?? 0);@@ -252,11 +261,17 @@ export const DbProvider: React.FC<{ children: React.ReactNode }> = ({ children }setDbAvailable(false);}, []);+ /**+ * Get offline state synchronously from ref.+ */+ const getIsOffline = useCallback(() => isOfflineRef.current, []);+const contextValue = useMemo(() => ({sqliteClient,dbInitialized,dbAvailable,isOffline,+ getIsOffline,isDirty,isSyncing,serverRevision,@@ -270,7 +285,7 @@ export const DbProvider: React.FC<{ children: React.ReactNode }> = ({ children }getVaultMetadata,refreshSyncState,hasPendingMigrations,- }), [sqliteClient, dbInitialized, dbAvailable, isOffline, isDirty, isSyncing, serverRevision, setIsOffline, loadDatabase, loadStoredDatabase, storeEncryptionKey, storeEncryptionKeyDerivationParams, clearDatabase, getVaultMetadata, refreshSyncState, hasPendingMigrations]);+ }), [sqliteClient, dbInitialized, dbAvailable, isOffline, getIsOffline, isDirty, isSyncing, serverRevision, setIsOffline, loadDatabase, loadStoredDatabase, storeEncryptionKey, storeEncryptionKeyDerivationParams, clearDatabase, getVaultMetadata, refreshSyncState, hasPendingMigrations]);return (<DbContext.Provider value={contextValue}>diff --git a/apps/browser-extension/src/entrypoints/popup/hooks/useVaultMutate.ts b/apps/browser-extension/src/entrypoints/popup/hooks/useVaultMutate.tsindex 576cfc798..4d8ace0c9 100644--- a/apps/browser-extension/src/entrypoints/popup/hooks/useVaultMutate.ts+++ b/apps/browser-extension/src/entrypoints/popup/hooks/useVaultMutate.ts@@ -73,23 +73,21 @@ export function useVaultMutate(): {* Handle successful sync completion.*/onSuccess: async () => {- // Refresh state from storageawait dbContext.refreshSyncState();- // Check if still dirty (more mutations during sync)- const isDirty = await sendMessage('GET_SYNC_STATE', {}, 'background') as { isDirty: boolean };- if (isDirty.isDirty) {- isSyncingRef.current = false;- // Re-sync to pick up new changes- await triggerSync();+ // Skip re-sync if offline - vault stays dirty until server is reachable+ if (!dbContext.getIsOffline()) {+ const syncState = await sendMessage('GET_SYNC_STATE', {}, 'background') as { isDirty: boolean };+ if (syncState.isDirty) {+ isSyncingRef.current = false;+ await triggerSync();+ }}},/**- * Handle offline mode - local save succeeded.+ * Offline mode - no re-sync needed, vault stays dirty until online.*/- onOffline: () => {- // Offline mode - local save succeeded, will sync when back online- },+ onOffline: () => {},/*** Handle sync errors.* @param error - Error message from syncdiff --git a/apps/server/Tests/AliasVault.E2ETests/Tests/Extensions/ChromeExtensionTests.cs b/apps/server/Tests/AliasVault.E2ETests/Tests/Extensions/ChromeExtensionTests.csindex 38f363846..185d5cf4e 100644--- a/apps/server/Tests/AliasVault.E2ETests/Tests/Extensions/ChromeExtensionTests.cs+++ b/apps/server/Tests/AliasVault.E2ETests/Tests/Extensions/ChromeExtensionTests.cs@@ -149,6 +149,269 @@ public class ChromeExtensionTests : BrowserExtensionPlaywrightTestConsole.WriteLine($"✅ RPO recovery test passed! Server recovered from revision {revisionAfterRollback} to {revisionAfterRecovery} (gap indicates disaster recovery)");}+ /// <summary>+ /// Tests forced logout recovery when server has rolled back (client has more advanced vault).+ /// This simulates the scenario where:+ /// 1. Client creates credentials (vault at rev N).+ /// 2. Server experiences data loss (rolls back to rev N-1).+ /// 3. Forced logout occurs (401 due to token issues).+ /// 4. User re-logs in.+ /// 5. Client detects its preserved vault is more advanced and uploads to recover server.+ /// </summary>+ /// <returns>Async task.</returns>+ [Order(3)]+ [Test]+ public async Task ExtensionRecoversVaultAfterForcedLogoutWithServerRollback()+ {+ // 1. Login and create credentials to build up vault revisions+ var extensionPopup = await LoginToExtension();++ var serviceName1 = "Forced Logout Recovery 1";+ var serviceName2 = "Forced Logout Recovery 2";++ await CreateCredentialInExtension(extensionPopup, serviceName1);+ await CreateCredentialInExtension(extensionPopup, serviceName2);++ // 2. Record client's vault revision before rollback+ var vaultBeforeRollback = await ApiDbContext.Vaults+ .OrderByDescending(v => v.RevisionNumber)+ .FirstOrDefaultAsync();++ Assert.That(vaultBeforeRollback, Is.Not.Null, "Vault should exist in database");+ var clientRevision = vaultBeforeRollback!.RevisionNumber;+ Console.WriteLine($"Client vault revision before rollback: {clientRevision}");++ // 3. Simulate server data loss (delete latest revision)+ ApiDbContext.Vaults.Remove(vaultBeforeRollback);+ await ApiDbContext.SaveChangesAsync();++ var serverRevisionAfterRollback = (await ApiDbContext.Vaults+ .OrderByDescending(v => v.RevisionNumber)+ .FirstOrDefaultAsync())?.RevisionNumber ?? 0;+ Console.WriteLine($"Server vault revision after rollback: {serverRevisionAfterRollback}");++ // 4. Simulate forced logout by intercepting API calls to return 401+ // This simulates token revocation/expiry that the client can't recover from+ await Context.RouteAsync($"{ApiBaseUrl}v1/Auth/status", async route =>+ {+ await route.FulfillAsync(new Microsoft.Playwright.RouteFulfillOptions+ {+ Status = 401,+ ContentType = "application/json",+ Body = "{\"statusCode\":401}",+ });+ });++ await Context.RouteAsync($"{ApiBaseUrl}v1/Auth/refresh", async route =>+ {+ await route.FulfillAsync(new Microsoft.Playwright.RouteFulfillOptions+ {+ Status = 401,+ ContentType = "application/json",+ Body = "{\"errorCode\":\"INVALID_REFRESH_TOKEN\",\"statusCode\":401}",+ });+ });++ Console.WriteLine("Route interception enabled - API will return 401 for auth endpoints");++ // 5. Trigger sync - this will:+ // a) Call status endpoint → 401+ // b) Try to refresh token → 401+ // c) Forced logout triggered (clearAuthForced preserves vault data)+ await extensionPopup.ClickAsync("button#reload-vault");+ await Task.Delay(3000);++ // 6. Verify forced logout occurred (should be on login page)+ await extensionPopup.WaitForSelectorAsync("input[type='password']", new() { Timeout = 10000 });+ Console.WriteLine("Forced logout confirmed - on login page");++ // 7. Verify username is prefilled (orphan preservation feature)+ var usernameValue = await extensionPopup.InputValueAsync("input[type='text']");+ Assert.That(+ usernameValue,+ Is.EqualTo(TestUserUsername),+ "Username should be prefilled from preserved vault data after forced logout");++ // 8. Remove route interception to restore normal API access before re-login+ await Context.UnrouteAsync($"{ApiBaseUrl}v1/Auth/status");+ await Context.UnrouteAsync($"{ApiBaseUrl}v1/Auth/refresh");+ Console.WriteLine("Route interception removed - API access restored");++ // 9. Wait a moment for route changes to take effect before login attempt+ await Task.Delay(500);++ // 10. Re-login - this triggers recovery flow in persistAndLoadVault():+ // - Decrypts existing vault with login password+ // - Compares existingRevision (N) >= serverRevision (N-1) → true+ // - Preserves local vault, will upload via sync in /reinitialize+ await extensionPopup.FillAsync("input[type='password']", TestUserPassword);+ await extensionPopup.ClickAsync("button:has-text('Log in')");++ await extensionPopup.WaitForSelectorAsync("text=Items", new() { Timeout = 15000 });+ await Task.Delay(3000); // Wait for sync to complete++ // 11. Verify server recovered (revision should be >= original client revision)+ var recoveredVault = await ApiDbContext.Vaults+ .OrderByDescending(v => v.RevisionNumber)+ .FirstOrDefaultAsync();++ Assert.That(recoveredVault, Is.Not.Null, "Vault should exist after recovery");+ Assert.That(+ recoveredVault!.RevisionNumber,+ Is.GreaterThanOrEqualTo(clientRevision),+ $"Server should recover to at least rev {clientRevision}, got {recoveredVault.RevisionNumber}");+ Console.WriteLine($"Server vault recovered to revision: {recoveredVault.RevisionNumber}");++ // 12. Verify credentials still exist in extension+ await extensionPopup.ClickAsync("#nav-vault");+ await Task.Delay(500);+ var content = await extensionPopup.TextContentAsync("body");+ Assert.Multiple(() =>+ {+ Assert.That(+ content,+ Does.Contain(serviceName1),+ "First credential should exist after forced logout recovery");+ Assert.That(+ content,+ Does.Contain(serviceName2),+ "Second credential should exist after forced logout recovery");+ });++ Console.WriteLine($"✅ Forced logout recovery test passed! " ++ $"Server recovered from rev {serverRevisionAfterRollback} to {recoveredVault.RevisionNumber}");+ }++ /// <summary>+ /// Tests forced logout recovery when client has dirty (unsynced) local changes.+ /// This simulates the scenario where:+ /// 1. Client has synced vault at rev N.+ /// 2. API goes offline (500 errors) - client makes local changes that can't sync (isDirty=true).+ /// 3. API comes back but with 401 (token expired) - forced logout occurs.+ /// 4. User re-logs in.+ /// 5. Client detects preserved vault and uploads to sync the dirty changes.+ /// </summary>+ /// <returns>Async task.</returns>+ [Order(4)]+ [Test]+ public async Task ExtensionRecoversDirtyVaultAfterForcedLogout()+ {+ // 1. Login to the browser extension+ var extensionPopup = await LoginToExtension();++ // 2. Get initial vault revision from server+ var initialVault = await ApiDbContext.Vaults+ .OrderByDescending(v => v.RevisionNumber)+ .FirstOrDefaultAsync();+ var initialRevision = initialVault?.RevisionNumber ?? 0;+ Console.WriteLine($"Initial server vault revision: {initialRevision}");++ // 3. Block ALL API endpoints with 500 to simulate server offline+ // This will make local changes "dirty" (unable to sync)+ await Context.RouteAsync($"{ApiBaseUrl}**/*", async route =>+ {+ await route.FulfillAsync(new Microsoft.Playwright.RouteFulfillOptions+ {+ Status = 500,+ ContentType = "application/json",+ Body = "{\"error\":\"Internal Server Error\"}",+ });+ });+ Console.WriteLine("Route interception enabled - all API endpoints return 500 (server offline)");++ // 4. Create a credential while "offline" - this will be saved locally but can't sync+ var serviceName = "Dirty Vault Recovery Test";++ // Click add new item button+ await extensionPopup.ClickAsync("button[title='Add new item']");+ await extensionPopup.WaitForSelectorAsync("input#itemName");+ await extensionPopup.FillAsync("input#itemName", serviceName);+ await extensionPopup.ClickAsync("button#save-credential");++ // Wait for save attempt (will fail due to 500, but local vault is updated)+ await Task.Delay(500);++ // Navigate back to vault list (we're on item detail page after save)+ await extensionPopup.ClickAsync("#nav-vault");+ await Task.Delay(500);++ Console.WriteLine("Credential created locally while offline - vault is now dirty");++ // 5. Verify server revision hasn't changed (sync failed)+ var vaultAfterOfflineCreate = await ApiDbContext.Vaults+ .OrderByDescending(v => v.RevisionNumber)+ .FirstOrDefaultAsync();+ Assert.That(+ vaultAfterOfflineCreate?.RevisionNumber ?? 0,+ Is.EqualTo(initialRevision),+ "Server revision should NOT have changed while offline");++ // 6. Switch from 500 to 401 to trigger forced logout+ await Context.UnrouteAsync($"{ApiBaseUrl}**/*");+ await Context.RouteAsync($"{ApiBaseUrl}**/*", async route =>+ {+ await route.FulfillAsync(new RouteFulfillOptions+ {+ Status = 401,+ ContentType = "application/json",+ Body = "{\"statusCode\":401}",+ });+ });+ Console.WriteLine("Route interception switched - all API endpoints return 401");++ // 8. Trigger forced logout by clicking reload (will hit 401)+ await extensionPopup.WaitForSelectorAsync("button#reload-vault", new() { State = WaitForSelectorState.Visible, Timeout = 500000 });+ await extensionPopup.ClickAsync("button#reload-vault");+ await Task.Delay(2000);++ // 9. Verify forced logout occurred (should be on login page)+ await extensionPopup.WaitForSelectorAsync("input[type='password']", new() { Timeout = 10000 });+ Console.WriteLine("Forced logout confirmed - on login page");++ // 10. Remove route interception to restore normal API access+ await Context.UnrouteAsync($"{ApiBaseUrl}**/*");+ Console.WriteLine("Route interception removed - API access restored");++ // 11. Wait a moment for route changes to take effect before login attempt+ await Task.Delay(500);++ // 12. Re-login - dirty vault should be preserved and uploaded after login+ await extensionPopup.FillAsync("input[type='password']", TestUserPassword);+ await extensionPopup.ClickAsync("button:has-text('Log in')");++ // 13. Wait for login to complete and verify the offline-created credential appears+ // This confirms the dirty vault was preserved during forced logout+ await extensionPopup.WaitForSelectorAsync($"text={serviceName}", new() { Timeout = 15000 });+ Console.WriteLine("Credential created while offline is visible after re-login - vault was preserved!");++ // Give sync a moment to complete+ await Task.Delay(2000);++ // 14. Verify vault was uploaded to server (revision should have increased)+ var recoveredVault = await ApiDbContext.Vaults+ .OrderByDescending(v => v.RevisionNumber)+ .FirstOrDefaultAsync();++ Assert.That(recoveredVault, Is.Not.Null, "Vault should exist after recovery");+ Assert.That(+ recoveredVault!.RevisionNumber,+ Is.GreaterThan(initialRevision),+ $"Server revision should have increased after dirty vault recovery (was {initialRevision}, now {recoveredVault.RevisionNumber})");+ Console.WriteLine($"Server vault revision after recovery: {recoveredVault.RevisionNumber}");++ // 15. Double-check the credential still exists in the extension UI+ await extensionPopup.ClickAsync("#nav-vault");+ await Task.Delay(500);+ var content = await extensionPopup.TextContentAsync("body");+ Assert.That(+ content,+ Does.Contain(serviceName),+ "Credential created while offline should exist after forced logout recovery");++ Console.WriteLine($"✅ Dirty vault recovery test passed! " ++ $"Server revision: {initialRevision} → {recoveredVault.RevisionNumber}");+ }+/// <summary>/// Gets the extension ID from the browser context using reflection./// This is a helper method for tests that need to open the extension popup manually.