Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
import { beforeEach, describe, expect, it, vi } from 'vitest';
const secureStorage = vi.hoisted(() => ({
value: null as string | null,
readError: null as Error | null,
delete: vi.fn(async () => {
secureStorage.value = null;
}),
set: vi.fn(async (_key: string, value: string) => {
secureStorage.value = value;
}),
}));
vi.mock('../secureStorage', () => ({
deleteSecureItem: secureStorage.delete,
getSecureItem: vi.fn(async () => {
if (secureStorage.readError) throw secureStorage.readError;
return secureStorage.value;
}),
setSecureItem: secureStorage.set,
}));
import {
clearMobileAccountVault,
clearMobileLoginCredentialsForLogout,
commitMobileLoginSessions,
commitMobileRuntimeResourceSession,
commitMobileSavedAccountActivation,
listMobileSavedAccounts,
mutateMobileAccountVault,
parseMobileAccountVault,
reconcileMobileActiveAuthSession,
removeMobilePassportSessionIfCurrent,
removeMobilePassport,
removeMobileResourceSessionIfCurrent,
replaceMobilePassportSessionIfCurrent,
replaceMobileResourceSessionIfCurrent,
transactMobileAccountVault,
} from '../mobileAccountVault';
const metadata = {
membershipId: 'membership-1',
passportId: 'passport-1',
displayName: 'Cao Jianbo',
email: '[email protected]',
avatarUrl: 'https://example.com/user.png',
kind: 'org' as const,
role: 'member' as const,
orgId: 'org-1',
orgName: 'Cindy',
orgLogoUrl: 'https://example.com/org.png',
};
describe('mobile account vault', () => {
beforeEach(() => {
secureStorage.value = null;
secureStorage.readError = null;
vi.clearAllMocks();
});
it('removes a deleted Passport and its accounts, preserving another active account and realm', async () => {
const deleted = JSON.stringify(['global', metadata.membershipId]);
const other = JSON.stringify(['global', 'other']);
const cn = JSON.stringify(['cn', metadata.membershipId]);
await mutateMobileAccountVault(vault => {
vault.resources[deleted] = { realm: 'global', refreshToken: 'fake-deleted', metadata, lastUsedAt: 1 };
vault.resources[cn] = { realm: 'cn', refreshToken: 'fake-cn', metadata, lastUsedAt: 1 };
vault.resources[other] = { realm: 'global', refreshToken: 'fake-other', metadata: { ...metadata, membershipId: 'other', passportId: 'other-passport' }, lastUsedAt: 1 };
vault.passports[JSON.stringify(['global', metadata.passportId])] = {
realm: 'global', passportId: metadata.passportId, accountRefreshToken: 'fake-passport',
memberships: [metadata, { ...metadata, membershipId: 'member-only' }],
};
vault.activeAccountKey = other;
});
await removeMobilePassport('global', metadata.passportId);
const vault = parseMobileAccountVault(secureStorage.value);
expect(vault.activeAccountKey).toBe(other);
expect(Object.keys(vault.resources).sort()).toEqual([cn, other].sort());
expect(vault.passports).toEqual({});
});
it('falls back to an empty read-only projection for malformed encrypted content', () => {
expect(parseMobileAccountVault('{bad-json')).toEqual({
version: 1,
activeAccountKey: null,
resources: {},
passports: {},
});
});
it('filters damaged children only from the read-only projection', () => {
const accountKey = JSON.stringify(['global', metadata.membershipId]);
const raw = JSON.stringify({
version: 1,
activeAccountKey: accountKey,
resources: {
[accountKey]: {
realm: 'global',
refreshToken: 'resource-refresh',
metadata,
lastUsedAt: 10,
},
damaged: { realm: 'global', refreshToken: 'must-not-be-rewritten' },
},
passports: {},
});
expect(parseMobileAccountVault(raw).resources).toEqual({
[accountKey]: expect.objectContaining({ refreshToken: 'resource-refresh' }),
});
});
it('deduplicates resource and Passport projections and marks the active account', () => {
const accountKey = JSON.stringify(['global', 'membership-1']);
const raw = JSON.stringify({
version: 1,
activeAccountKey: accountKey,
resources: {
[accountKey]: {
realm: 'global',
refreshToken: 'resource-refresh',
metadata,
lastUsedAt: 10,
},
},
passports: {
passport: {
realm: 'global',
passportId: 'passport-1',
accountRefreshToken: 'account-refresh',
memberships: [metadata],
},
},
});
expect(listMobileSavedAccounts(parseMobileAccountVault(raw))).toEqual([
expect.objectContaining({
accountKey,
isCurrent: true,
orgName: 'Cindy',
orgLogoUrl: 'https://example.com/org.png',
}),
]);
expect(listMobileSavedAccounts(parseMobileAccountVault(raw), null)).toEqual([
expect.objectContaining({ accountKey, isCurrent: false }),
]);
});
it('preserves divergent compatibility and vault generations as refresh candidates', async () => {
const accountKey = JSON.stringify(['global', metadata.membershipId]);
secureStorage.value = JSON.stringify({
version: 1,
activeAccountKey: accountKey,
resources: {
[accountKey]: {
realm: 'global',
refreshToken: 'resource-new',
metadata,
lastUsedAt: 10,
},
},
passports: {},
});
let session: {
version: 1;
realm: 'cn' | 'global';
refreshToken: string;
} = {
version: 1,
realm: 'global',
refreshToken: 'resource-old',
};
const writePersistedSession = vi.fn(
async (refreshToken: string, realm: 'cn' | 'global') => {
session = { version: 1, realm, refreshToken };
},
);
const clearPersistedSession = vi.fn(async () => undefined);
const reconciled = await reconcileMobileActiveAuthSession({
readPersistedSession: async () => session,
writePersistedSession,
clearPersistedSession,
});
expect(reconciled.session).toEqual({
version: 1,
realm: 'global',
refreshToken: 'resource-old',
});
expect(reconciled.refreshCandidates).toEqual([
{ version: 1, realm: 'global', refreshToken: 'resource-old' },
{ version: 1, realm: 'global', refreshToken: 'resource-new' },
]);
expect(writePersistedSession).not.toHaveBeenCalled();
expect(clearPersistedSession).not.toHaveBeenCalled();
expect(secureStorage.set).not.toHaveBeenCalled();
secureStorage.value = JSON.stringify({
version: 1,
activeAccountKey: null,
resources: {},
passports: {},
signedOutAt: 123,
});
await expect(
reconcileMobileActiveAuthSession({
readPersistedSession: async () => session,
writePersistedSession,
clearPersistedSession,
}),
).resolves.toEqual(expect.objectContaining({ session: null }));
expect(clearPersistedSession).toHaveBeenCalledTimes(1);
});
it('repairs a missing compatibility projection from the active vault', async () => {
const accountKey = JSON.stringify(['global', metadata.membershipId]);
secureStorage.value = JSON.stringify({
version: 1,
activeAccountKey: accountKey,
resources: {
[accountKey]: {
realm: 'global',
refreshToken: 'resource-new',
metadata,
lastUsedAt: 10,
},
},
passports: {},
});
const writePersistedSession = vi.fn(async () => undefined);
await expect(
reconcileMobileActiveAuthSession({
readPersistedSession: async () => null,
writePersistedSession,
clearPersistedSession: vi.fn(async () => undefined),
}),
).resolves.toMatchObject({
session: {
version: 1,
realm: 'global',
refreshToken: 'resource-new',
},
refreshCandidates: [
{
version: 1,
realm: 'global',
refreshToken: 'resource-new',
},
],
});
expect(writePersistedSession).toHaveBeenCalledWith(
'resource-new',
'global',
);
});
it('does not trust an active key whose resource credential is missing', () => {
const raw = JSON.stringify({
version: 1,
activeAccountKey: 'missing',
resources: {},
passports: {},
});
expect(parseMobileAccountVault(raw).activeAccountKey).toBeNull();
});
it('persists a Passport rotation only while the consumed token is current', async () => {
secureStorage.value = JSON.stringify({
version: 1,
activeAccountKey: null,
resources: {},
passports: {
[JSON.stringify(['global', 'passport-1'])]: {
realm: 'global',
passportId: 'passport-1',
accountRefreshToken: 'refresh-old',
memberships: [metadata],
},
},
});
await expect(
replaceMobilePassportSessionIfCurrent({
realm: 'global',
passportId: 'passport-1',
expectedAccountRefreshToken: 'refresh-old',
accountRefreshToken: 'refresh-new',
memberships: [metadata],
}),
).resolves.toBe(true);
await expect(
replaceMobilePassportSessionIfCurrent({
realm: 'global',
passportId: 'passport-1',
expectedAccountRefreshToken: 'refresh-old',
accountRefreshToken: 'refresh-late',
memberships: [metadata],
}),
).resolves.toBe(false);
expect(
parseMobileAccountVault(secureStorage.value).passports[
JSON.stringify(['global', 'passport-1'])
]?.accountRefreshToken,
).toBe('refresh-new');
});
it('does not delete a Passport generation replaced by another refresh', async () => {
secureStorage.value = JSON.stringify({
version: 1,
activeAccountKey: null,
resources: {},
passports: {
[JSON.stringify(['global', 'passport-1'])]: {
realm: 'global',
passportId: 'passport-1',
accountRefreshToken: 'refresh-new',
memberships: [metadata],
},
},
});
await expect(
removeMobilePassportSessionIfCurrent(
'global',
'passport-1',
'refresh-old',
),
).resolves.toBe(false);
expect(parseMobileAccountVault(secureStorage.value).passports).not.toEqual(
{},
);
await expect(
removeMobilePassportSessionIfCurrent(
'global',
'passport-1',
'refresh-new',
),
).resolves.toBe(true);
expect(parseMobileAccountVault(secureStorage.value).passports).toEqual({});
});
it('replaces a Resource generation only while its consumed token is current', async () => {
const accountKey = JSON.stringify(['global', metadata.membershipId]);
secureStorage.value = JSON.stringify({
version: 1,
activeAccountKey: null,
resources: {
[accountKey]: {
realm: 'global',
refreshToken: 'resource-old',
metadata,
lastUsedAt: 10,
},
},
passports: {},
});
const pair = {
accessToken: 'access-new',
refreshToken: 'resource-new',
membership: {
id: metadata.membershipId,
passportId: metadata.passportId,
displayName: metadata.displayName,
email: metadata.email,
avatarUrl: metadata.avatarUrl,
kind: metadata.kind,
role: metadata.role,
orgId: metadata.orgId,
orgName: metadata.orgName,
orgLogoUrl: metadata.orgLogoUrl,
},
};
await expect(
replaceMobileResourceSessionIfCurrent({
accountKey,
expectedRefreshToken: 'resource-old',
pair,
realm: 'global',
passportId: metadata.passportId,
}),
).resolves.toBe('stored');
await expect(
replaceMobileResourceSessionIfCurrent({
accountKey,
expectedRefreshToken: 'resource-old',
pair: { ...pair, refreshToken: 'resource-late' },
realm: 'global',
passportId: metadata.passportId,
}),
).resolves.toBe('stale');
expect(
parseMobileAccountVault(secureStorage.value).resources[accountKey]
?.refreshToken,
).toBe('resource-new');
});
it('preserves an inactive refresh without letting it reclaim the active account', async () => {
const accountKey = JSON.stringify(['global', metadata.membershipId]);
const otherAccountKey = JSON.stringify(['global', 'membership-2']);
const afterPersist = vi.fn(async () => undefined);
const pair = {
accessToken: 'access-late',
refreshToken: 'resource-late',
membership: {
id: metadata.membershipId,
passportId: metadata.passportId,
displayName: metadata.displayName,
email: metadata.email,
avatarUrl: metadata.avatarUrl,
kind: metadata.kind,
role: metadata.role,
orgId: metadata.orgId,
orgName: metadata.orgName,
orgLogoUrl: metadata.orgLogoUrl,
},
};
secureStorage.value = JSON.stringify({
version: 1,
activeAccountKey: otherAccountKey,
resources: {
[accountKey]: {
realm: 'global',
refreshToken: 'resource-old',
metadata,
lastUsedAt: 10,
},
[otherAccountKey]: {
realm: 'global',
refreshToken: 'resource-new-login',
metadata: { ...metadata, membershipId: 'membership-2' },
lastUsedAt: 20,
},
},
passports: {},
});
await expect(
commitMobileRuntimeResourceSession({
expectedRefreshToken: 'resource-old',
pair,
realm: 'global',
passportId: metadata.passportId,
afterPersist,
}),
).resolves.toBe('inactive');
const vault = parseMobileAccountVault(secureStorage.value);
expect(vault.activeAccountKey).toBe(otherAccountKey);
expect(vault.resources[accountKey]?.refreshToken).toBe('resource-late');
expect(vault.resources[otherAccountKey]?.refreshToken).toBe(
'resource-new-login',
);
expect(afterPersist).not.toHaveBeenCalled();
secureStorage.value = JSON.stringify({
version: 1,
activeAccountKey: accountKey,
resources: {
[accountKey]: {
realm: 'global',
refreshToken: 'resource-new-login',
metadata,
lastUsedAt: 30,
},
},
passports: {},
});
await expect(
commitMobileRuntimeResourceSession({
expectedRefreshToken: 'resource-old',
pair,
realm: 'global',
passportId: metadata.passportId,
afterPersist,
}),
).resolves.toBe('stale');
expect(
parseMobileAccountVault(secureStorage.value).resources[accountKey]
?.refreshToken,
).toBe('resource-new-login');
expect(afterPersist).not.toHaveBeenCalled();
secureStorage.value = JSON.stringify({
version: 1,
activeAccountKey: accountKey,
resources: {
[accountKey]: {
realm: 'global',
refreshToken: 'resource-old',
metadata,
lastUsedAt: 40,
},
},
passports: {},
});
await expect(
commitMobileRuntimeResourceSession({
expectedRefreshToken: 'resource-old',
pair,
realm: 'global',
passportId: metadata.passportId,
afterPersist,
}),
).resolves.toBe('active');
expect(
parseMobileAccountVault(secureStorage.value).resources[accountKey]
?.refreshToken,
).toBe('resource-late');
expect(afterPersist).toHaveBeenCalledTimes(1);
});
it('commits a refresh that proves a newer compatibility generation', async () => {
const accountKey = JSON.stringify(['global', metadata.membershipId]);
const pair = {
accessToken: 'access-latest',
refreshToken: 'resource-latest',
membership: {
id: metadata.membershipId,
passportId: metadata.passportId,
displayName: metadata.displayName,
email: metadata.email,
avatarUrl: metadata.avatarUrl,
kind: metadata.kind,
role: metadata.role,
orgId: metadata.orgId,
orgName: metadata.orgName,
orgLogoUrl: metadata.orgLogoUrl,
},
};
secureStorage.value = JSON.stringify({
version: 1,
activeAccountKey: accountKey,
resources: {
[accountKey]: {
realm: 'global',
refreshToken: 'vault-older',
metadata,
lastUsedAt: 10,
},
},
passports: {},
});
await expect(
commitMobileRuntimeResourceSession({
expectedRefreshToken: 'compatibility-newer',
compatibilityRefreshTokens: ['vault-older'],
pair,
realm: 'global',
passportId: metadata.passportId,
}),
).resolves.toBe('active');
expect(
parseMobileAccountVault(secureStorage.value).resources[accountKey]
?.refreshToken,
).toBe('resource-latest');
});
it('does not recreate a runtime Resource after a signed-out tombstone', async () => {
const pair = {
accessToken: 'access-late',
refreshToken: 'resource-late',
membership: {
id: metadata.membershipId,
passportId: metadata.passportId,
displayName: metadata.displayName,
email: metadata.email,
avatarUrl: metadata.avatarUrl,
kind: metadata.kind,
role: metadata.role,
orgId: metadata.orgId,
orgName: metadata.orgName,
orgLogoUrl: metadata.orgLogoUrl,
},
};
secureStorage.value = JSON.stringify({
version: 1,
activeAccountKey: null,
resources: {},
passports: {},
signedOutAt: 123,
});
await expect(
commitMobileRuntimeResourceSession({
expectedRefreshToken: 'resource-old',
pair,
realm: 'global',
passportId: metadata.passportId,
}),
).resolves.toBe('stale');
expect(parseMobileAccountVault(secureStorage.value)).toEqual(
expect.objectContaining({
activeAccountKey: null,
resources: {},
signedOutAt: 123,
}),
);
});
it('does not delete a Resource generation replaced by a later login', async () => {
const accountKey = JSON.stringify(['global', metadata.membershipId]);
secureStorage.value = JSON.stringify({
version: 1,
activeAccountKey: accountKey,
resources: {
[accountKey]: {
realm: 'global',
refreshToken: 'resource-new-login',
metadata,
lastUsedAt: 20,
},
},
passports: {},
});
await expect(
removeMobileResourceSessionIfCurrent({
accountKey,
expectedRefreshToken: 'resource-old-request',
}),
).resolves.toBe('stale');
expect(
parseMobileAccountVault(secureStorage.value).resources[accountKey]
?.refreshToken,
).toBe('resource-new-login');
await expect(
removeMobileResourceSessionIfCurrent({
accountKey,
expectedRefreshToken: 'resource-new-login',
}),
).resolves.toBe('removed');
expect(parseMobileAccountVault(secureStorage.value).resources).toEqual({});
});
it('does not overwrite saved credentials when SecureStore cannot be read', async () => {
const original = JSON.stringify({
version: 1,
activeAccountKey: null,
resources: {},
passports: { passport: { accountRefreshToken: 'keep-me' } },
});
secureStorage.value = original;
secureStorage.readError = new Error('keychain temporarily unavailable');
await expect(
mutateMobileAccountVault((vault) => {
vault.passports = {};
}),
).rejects.toThrow('keychain temporarily unavailable');
await expect(
commitMobileLoginSessions(
{
pair: {
accessToken: 'access',
refreshToken: 'resource-refresh',
membership: {
id: metadata.membershipId,
passportId: metadata.passportId,
displayName: metadata.displayName,
email: metadata.email,
avatarUrl: metadata.avatarUrl,
kind: metadata.kind,
role: metadata.role,
orgId: metadata.orgId,
orgName: metadata.orgName,
orgLogoUrl: metadata.orgLogoUrl,
},
},
realm: 'global',
passportId: metadata.passportId,
accountRefreshToken: null,
memberships: [metadata],
},
async () => undefined,
),
).rejects.toThrow('keychain temporarily unavailable');
expect(secureStorage.value).toBe(original);
expect(secureStorage.set).not.toHaveBeenCalled();
});
it('does not overwrite saved credentials when encrypted content is malformed', async () => {
secureStorage.value = '{bad-json';
await expect(
mutateMobileAccountVault((vault) => {
vault.passports = {};
}),
).rejects.toThrow();
expect(secureStorage.value).toBe('{bad-json');
expect(secureStorage.set).not.toHaveBeenCalled();
});
it('lets a completed explicit login recover malformed content with exact rollback', async () => {
const malformed = '{bad-json';
const input = {
pair: {
accessToken: 'access',
refreshToken: 'resource-refresh',
membership: {
id: metadata.membershipId,
passportId: metadata.passportId,
displayName: metadata.displayName,
email: metadata.email,
avatarUrl: metadata.avatarUrl,
kind: metadata.kind,
role: metadata.role,
orgId: metadata.orgId,
orgName: metadata.orgName,
orgLogoUrl: metadata.orgLogoUrl,
},
},
realm: 'global' as const,
passportId: metadata.passportId,
accountRefreshToken: 'account-refresh',
memberships: [metadata],
};
secureStorage.value = malformed;
await expect(
commitMobileLoginSessions(input, async () => {
throw new Error('owner commit failed');
}),
).rejects.toThrow('owner commit failed');
expect(secureStorage.value).toBe(malformed);
await commitMobileLoginSessions(input, async () => undefined);
const recovered = parseMobileAccountVault(secureStorage.value);
const accountKey = JSON.stringify(['global', metadata.membershipId]);
expect(recovered.activeAccountKey).toBe(accountKey);
expect(recovered.resources[accountKey]?.refreshToken).toBe('resource-refresh');
expect(recovered.passports).toEqual(
expect.objectContaining({
[JSON.stringify(['global', metadata.passportId])]: expect.objectContaining({
accountRefreshToken: 'account-refresh',
}),
}),
);
});
it('preserves valid vault children while explicit login filters a damaged child', async () => {
const existingKey = JSON.stringify(['global', metadata.membershipId]);
const newMetadata = {
...metadata,
membershipId: 'membership-2',
passportId: 'passport-2',
displayName: 'Second Account',
};
secureStorage.value = JSON.stringify({
version: 1,
activeAccountKey: existingKey,
resources: {
[existingKey]: {
realm: 'global',
refreshToken: 'existing-refresh',
metadata,
lastUsedAt: 10,
},
damaged: { realm: 'global', refreshToken: 'damaged-refresh' },
},
passports: {},
});
await commitMobileLoginSessions(
{
pair: {
accessToken: 'new-access',
refreshToken: 'new-refresh',
membership: {
id: newMetadata.membershipId,
passportId: newMetadata.passportId,
displayName: newMetadata.displayName,
email: newMetadata.email,
avatarUrl: newMetadata.avatarUrl,
kind: newMetadata.kind,
role: newMetadata.role,
orgId: newMetadata.orgId,
orgName: newMetadata.orgName,
orgLogoUrl: newMetadata.orgLogoUrl,
},
},
realm: 'global',
passportId: newMetadata.passportId,
accountRefreshToken: null,
memberships: [newMetadata],
},
async () => undefined,
);
const recovered = parseMobileAccountVault(secureStorage.value);
const newKey = JSON.stringify(['global', newMetadata.membershipId]);
expect(recovered.resources[existingKey]?.refreshToken).toBe('existing-refresh');
expect(recovered.resources[newKey]?.refreshToken).toBe('new-refresh');
expect(recovered.resources.damaged).toBeUndefined();
});
it('does not rewrite a vault containing a damaged resource child', async () => {
const original = JSON.stringify({
version: 1,
activeAccountKey: null,
resources: {
damaged: { realm: 'global', refreshToken: 'must-not-be-deleted' },
},
passports: {},
});
secureStorage.value = original;
await expect(
mutateMobileAccountVault((vault) => {
vault.activeAccountKey = null;
}),
).rejects.toThrow('Saved resource credential could not be read safely');
expect(secureStorage.value).toBe(original);
expect(secureStorage.set).not.toHaveBeenCalled();
});
it('does not rewrite a Passport containing damaged membership metadata', async () => {
const original = JSON.stringify({
version: 1,
activeAccountKey: null,
resources: {},
passports: {
passport: {
realm: 'global',
passportId: 'passport-1',
accountRefreshToken: 'must-not-be-deleted',
memberships: [metadata, { membershipId: 'damaged' }],
},
},
});
secureStorage.value = original;
await expect(
mutateMobileAccountVault((vault) => {
vault.activeAccountKey = null;
}),
).rejects.toThrow('Saved Passport membership could not be read safely');
expect(secureStorage.value).toBe(original);
expect(secureStorage.set).not.toHaveBeenCalled();
});
it('rolls the exact vault snapshot back before releasing a failed transaction', async () => {
const original = JSON.stringify({
version: 1,
activeAccountKey: null,
resources: {},
passports: {},
});
secureStorage.value = original;
await expect(
transactMobileAccountVault(
(vault) => {
vault.resources.added = {
realm: 'global',
refreshToken: 'cancelled-resource',
metadata,
lastUsedAt: 20,
};
},
async () => {
throw new Error('AUTH_FLOW_SUPERSEDED');
},
),
).rejects.toThrow('AUTH_FLOW_SUPERSEDED');
expect(secureStorage.value).toBe(original);
expect(secureStorage.set).toHaveBeenCalledTimes(2);
});
it('commits Passport, resource, and active account in one vault transaction', async () => {
const afterPersist = vi.fn(async () => undefined);
await commitMobileLoginSessions(
{
pair: {
accessToken: 'access',
refreshToken: 'resource-refresh',
membership: {
id: metadata.membershipId,
passportId: metadata.passportId,
displayName: metadata.displayName,
email: metadata.email,
avatarUrl: metadata.avatarUrl,
kind: metadata.kind,
role: metadata.role,
orgId: metadata.orgId,
orgName: metadata.orgName,
orgLogoUrl: metadata.orgLogoUrl,
},
},
realm: 'global',
passportId: metadata.passportId,
accountRefreshToken: 'account-refresh',
memberships: [metadata],
},
afterPersist,
);
const vault = parseMobileAccountVault(secureStorage.value);
const accountKey = JSON.stringify(['global', metadata.membershipId]);
expect(vault.activeAccountKey).toBe(accountKey);
expect(vault.resources[accountKey]?.refreshToken).toBe('resource-refresh');
expect(
vault.passports[JSON.stringify(['global', metadata.passportId])]
?.accountRefreshToken,
).toBe('account-refresh');
expect(afterPersist).toHaveBeenCalledTimes(1);
expect(secureStorage.set).toHaveBeenCalledTimes(1);
});
it('restores the previous active account when runtime commit is superseded', async () => {
const oldKey = JSON.stringify(['global', metadata.membershipId]);
const targetKey = JSON.stringify(['global', 'membership-2']);
const original = JSON.stringify({
version: 1,
activeAccountKey: oldKey,
resources: {
[oldKey]: {
realm: 'global',
refreshToken: 'old-refresh',
metadata,
lastUsedAt: 10,
},
[targetKey]: {
realm: 'global',
refreshToken: 'target-refresh',
metadata: { ...metadata, membershipId: 'membership-2' },
lastUsedAt: 20,
},
},
passports: {},
});
secureStorage.value = original;
await expect(
commitMobileSavedAccountActivation(targetKey, async () => {
throw new Error('AUTH_FLOW_SUPERSEDED');
}),
).rejects.toThrow('AUTH_FLOW_SUPERSEDED');
expect(secureStorage.value).toBe(original);
expect(secureStorage.set).toHaveBeenCalledTimes(2);
});
it('keeps a signed-out tombstone and restores the vault if session deletion fails', async () => {
const original = JSON.stringify({
version: 1,
activeAccountKey: null,
resources: {},
passports: {},
});
secureStorage.value = original;
await expect(
clearMobileAccountVault(async () => {
throw new Error('keychain delete failed');
}),
).rejects.toThrow('keychain delete failed');
expect(secureStorage.value).toBe(original);
await clearMobileAccountVault();
expect(parseMobileAccountVault(secureStorage.value).signedOutAt).toEqual(
expect.any(Number),
);
});
it('lets explicit logout replace a malformed vault without parsing it', async () => {
const malformed = '{bad-json';
secureStorage.value = malformed;
await expect(clearMobileAccountVault()).resolves.toBeUndefined();
expect(parseMobileAccountVault(secureStorage.value)).toMatchObject({
activeAccountKey: null,
passports: {},
resources: {},
signedOutAt: expect.any(Number),
});
secureStorage.value = malformed;
await expect(
clearMobileAccountVault(async () => {
throw new Error('session delete failed');
}),
).rejects.toThrow('session delete failed');
expect(secureStorage.value).toBe(malformed);
});
it('rolls vault and compatibility session back when receipt deletion fails', async () => {
const originalVault = JSON.stringify({
version: 1,
activeAccountKey: null,
resources: {},
passports: {},
});
secureStorage.value = originalVault;
let sessionRaw: string | null = 'original-session';
const clearReceipt = vi.fn(async () => {
throw new Error('receipt delete failed');
});
await expect(
clearMobileLoginCredentialsForLogout({
readSessionRaw: async () => sessionRaw,
clearSession: async () => {
sessionRaw = null;
},
restoreSessionRaw: async (raw) => {
sessionRaw = raw;
},
clearReceipt,
}),
).rejects.toThrow('receipt delete failed');
expect(secureStorage.value).toBe(originalVault);
expect(sessionRaw).toBe('original-session');
expect(clearReceipt).toHaveBeenCalledOnce();
});
it('commits vault, compatibility session, and receipt clearing together', async () => {
secureStorage.value = JSON.stringify({
version: 1,
activeAccountKey: null,
resources: {},
passports: {},
});
let sessionRaw: string | null = 'original-session';
const clearReceipt = vi.fn(async () => undefined);
await clearMobileLoginCredentialsForLogout({
readSessionRaw: async () => sessionRaw,
clearSession: async () => {
sessionRaw = null;
},
restoreSessionRaw: async (raw) => {
sessionRaw = raw;
},
clearReceipt,
});
expect(parseMobileAccountVault(secureStorage.value).signedOutAt).toEqual(
expect.any(Number),
);
expect(sessionRaw).toBeNull();
expect(clearReceipt).toHaveBeenCalledOnce();
});
});