Skip to content

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.tsx
index 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 }> = ({ children
return 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 methods
logout,
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.tsx
index 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.ts
index 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 storage
await 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 sync
diff --git a/apps/server/Tests/AliasVault.E2ETests/Tests/Extensions/ChromeExtensionTests.cs b/apps/server/Tests/AliasVault.E2ETests/Tests/Extensions/ChromeExtensionTests.cs
index 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 : BrowserExtensionPlaywrightTest
Console.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.