π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
import { afterEach, beforeEach, expect, test, vi } from "vitest";
import {
getLockerCacheSnapshot,
replaceLockerCache,
type EncryptedCollectionRecord,
type EncryptedFileRecord,
} from "../src/services/locker-cache";
import * as db from "../src/services/locker-db";
import {
loadPersistedLockerState,
syncLockerState,
} from "../src/services/sync/sync";
vi.mock("../src/services/locker-db", () => ({
loadLockerSnapshotFromDB: vi.fn(),
saveCollectionRecords: vi.fn(),
saveCollectionsSinceTime: vi.fn(),
saveCollectionSinceTime: vi.fn(),
deleteCollectionSinceTime: vi.fn(),
saveFileRecords: vi.fn(),
deleteFileRecords: vi.fn(),
deleteFileRecordsForCollection: vi.fn(),
saveTrashFileRecords: vi.fn(),
deleteTrashFileRecords: vi.fn(),
saveTrashSinceTime: vi.fn(),
}));
const { ensureAuthenticatedSession, openCollectionKey, decryptMetadataJSON } =
vi.hoisted(() => ({
ensureAuthenticatedSession: vi.fn(),
openCollectionKey: vi.fn(),
decryptMetadataJSON: vi.fn(),
}));
vi.mock("../src/services/authenticated-session", () => ({
ensureAuthenticatedSession,
}));
vi.mock("ente-locker-wasm", () => ({
openCollectionKey,
decryptBox: () => "file-key",
decryptMetadataJSON,
decryptBoxBytes: () =>
new TextEncoder().encode(
JSON.stringify({ name: "Saved", owner: { id: 1 }, sharees: [] }),
),
encryptBoxBytes: () => ({ encryptedData: "payload", nonce: "nonce" }),
}));
vi.mock("ente-base/http", () => ({
authenticatedRequestHeaders: () => ({ "X-Auth-Token": "test" }),
ensureOk: (response: Response) => {
if (!response.ok) throw new Error("Request failed");
},
}));
vi.mock("ente-base/origins", () => ({
apiURL: (path: string, params: Record<string, number>) =>
`${path}?${new URLSearchParams(Object.entries(params).map(([key, value]) => [key, String(value)]))}`,
}));
vi.mock("ente-base/log", () => ({
default: { error: vi.fn(), warn: vi.fn() },
}));
const collection = (id: number): EncryptedCollectionRecord => ({
id,
ownerID: 1,
encryptedKey: `key-${id}`,
keyDecryptionNonce: "nonce",
encryptedName: undefined,
nameDecryptionNonce: undefined,
payloadEncryptedData: "payload",
payloadDecryptionNonce: "nonce",
type: "folder",
isDeleted: false,
updationTime: 20,
});
const file = (id: number, collectionID: number): EncryptedFileRecord => ({
id,
collectionID,
encryptedKey: "key",
keyDecryptionNonce: "nonce",
fileDecryptionHeader: "header",
hasObject: true,
metadata: { encryptedData: "metadata", decryptionHeader: "header" },
pubMagicMetadata: { version: 1, data: "public", header: "header" },
updationTime: 30,
});
const snapshot = () => ({
collections: new Map([
[1, collection(1)],
[2, collection(2)],
]),
files: [file(10, 1), file(10, 2)],
trashFiles: [{ ...file(11, 1), updatedAt: 40, deleteBy: 100 }],
collectionsSinceTime: 5,
collectionSinceTimeByID: new Map([
[1, 10],
[2, 20],
]),
trashSinceTime: 40,
hasPersistedState: true,
});
const fetchMock = vi.fn<typeof fetch>();
const response = (body: unknown) =>
new Response(JSON.stringify(body), { status: 200 });
beforeEach(() => {
vi.resetAllMocks();
vi.stubGlobal("fetch", fetchMock);
replaceLockerCache({ collections: new Map(), files: new Map() });
vi.mocked(db.loadLockerSnapshotFromDB).mockResolvedValue(snapshot());
ensureAuthenticatedSession.mockResolvedValue("session");
openCollectionKey.mockResolvedValue("collection-key");
decryptMetadataJSON.mockImplementation(
(value: { encryptedData: string }) =>
value.encryptedData === "public"
? { editedName: "Renamed" }
: { title: "Original", creationTime: 1_700_000_000_000 },
);
});
afterEach(() => vi.unstubAllGlobals());
test("persisted hydration preserves memberships, metadata, trash and cursors without fetching", async () => {
const result = await loadPersistedLockerState();
expect(result).toMatchObject({
collectionsSinceTime: 5,
trashSinceTime: 40,
trashLastUpdatedAt: 40,
hasPersistedState: true,
});
expect(result.collections).toHaveLength(2);
expect(result.collections[0]?.items[0]).toMatchObject({
id: 10,
collectionIDs: [1, 2],
data: { name: "Renamed" },
createdAt: 1_700_000_000_000_000,
});
expect(result.trashItems[0]).toMatchObject({
id: 11,
updatedAt: 40,
deleteBy: 100,
});
expect(getLockerCacheSnapshot().files.get(10)?.size).toBe(2);
expect(getLockerCacheSnapshot().files.has(11)).toBe(true);
expect(fetchMock).not.toHaveBeenCalled();
expect(ensureAuthenticatedSession).toHaveBeenCalledOnce();
});
const infoItemCases = [
{ type: "note", data: { title: "Note", content: "Body" } },
{
type: "accountCredential",
data: {
name: "Account",
username: "user",
password: " secret ",
notes: "Notes",
},
},
{
type: "physicalRecord",
data: { name: "Record", location: "Home", notes: "Notes" },
},
{
type: "emergencyContact",
data: { name: "Contact", contactDetails: "123", notes: "Notes" },
},
];
test.each(
infoItemCases.flatMap(({ type, data }) =>
Object.keys(data).flatMap((field) =>
[{ unexpected: "object" }, ["array"], 42, true].map((value) => ({
type,
field,
data: { ...data, [field]: value },
})),
),
),
)(
"malformed $type $field is isolated during cached hydration and trash loading: $data",
async ({ type, data }) => {
const saved = snapshot();
saved.files.push({
...file(12, 1),
pubMagicMetadata: { version: 1, data: "bad", header: "header" },
});
saved.trashFiles.push({
...file(13, 1),
pubMagicMetadata: { version: 1, data: "bad", header: "header" },
updatedAt: 40,
deleteBy: 100,
});
vi.mocked(db.loadLockerSnapshotFromDB).mockResolvedValue(saved);
decryptMetadataJSON.mockImplementation(
(value: { encryptedData: string }) =>
value.encryptedData === "bad"
? { info: { type, data } }
: { title: "Healthy file" },
);
for (let load = 0; load < 2; load++) {
const result = await loadPersistedLockerState();
expect(result.collections).toHaveLength(2);
expect(
result.collections.map((entry) =>
entry.items.map((item) => item.id),
),
).toEqual([[10], [10]]);
expect(result.trashItems.map((item) => item.id)).toEqual([11]);
expect(getLockerCacheSnapshot().files.has(12)).toBe(true);
}
},
);
test.each([null, undefined, [], "text", 42, true])(
"invalid info data is skipped rather than admitted as an item: %j",
async (data) => {
decryptMetadataJSON.mockResolvedValue({ info: { type: "note", data } });
const result = await loadPersistedLockerState();
expect(
result.collections.every((entry) => entry.items.length === 0),
).toBe(true);
expect(result.trashItems).toEqual([]);
},
);
test.each([
...infoItemCases,
{ type: "account-credential", data: { name: "Account" } },
{ type: "physical-record", data: { name: "Record" } },
{
type: "emergency-contact",
data: { name: "Contact", contactDetails: "123" },
},
])("valid $type metadata retains its fields", async ({ type, data }) => {
decryptMetadataJSON.mockResolvedValue({ info: { type, data } });
const result = await loadPersistedLockerState();
const expectedType = type.replace(/-([a-z])/g, (_, letter: string) =>
letter.toUpperCase(),
);
expect(result.collections[0]?.items[0]).toMatchObject({
type: expectedType,
data,
});
expect(result.trashItems[0]).toMatchObject({ type: expectedType, data });
});
test("empty mobile fields are normalized and unknown fields are excluded", async () => {
decryptMetadataJSON.mockResolvedValue({
info: { type: "note", data: { title: null, extra: { nested: true } } },
});
const result = await loadPersistedLockerState();
expect(result.collections[0]?.items[0]?.data).toEqual({
title: "",
content: "",
});
});
test("partial decryption failure excludes only the failed collection and its cache records", async () => {
openCollectionKey.mockImplementation((_session, _owner, key) => {
if (key === "key-2") throw new Error("Bad key");
return "collection-key";
});
const result = await loadPersistedLockerState();
expect(result.collections.map((entry) => entry.id)).toEqual([1]);
expect([...getLockerCacheSnapshot().collections.keys()]).toEqual([1]);
expect([...getLockerCacheSnapshot().files.get(10)!.keys()]).toEqual([1]);
});
test("total decryption failure leaves the existing cache intact", async () => {
const existing = {
collections: new Map([[9, collection(9)]]),
files: new Map(),
};
replaceLockerCache(existing);
openCollectionKey.mockRejectedValue(new Error("Bad key"));
await expect(loadPersistedLockerState()).rejects.toThrow(
"Failed to decrypt all 2 locker collections",
);
expect(getLockerCacheSnapshot()).toEqual(existing);
});
test("incremental sync paginates changed collections and trash, skipping up-to-date collections", async () => {
const remoteFile = {
id: 12,
collectionID: 1,
encryptedKey: "key",
keyDecryptionNonce: "nonce",
file: { decryptionHeader: "header" },
metadata: { encryptedData: "metadata", decryptionHeader: "header" },
updationTime: 30,
isDeleted: false,
};
fetchMock
.mockResolvedValueOnce(response({ collections: [] }))
.mockResolvedValueOnce(response({ diff: [remoteFile], hasMore: true }))
.mockResolvedValueOnce(
response({
diff: [
{
id: 13,
collectionID: 1,
encryptedKey: "",
keyDecryptionNonce: "",
file: { decryptionHeader: "" },
metadata: { decryptionHeader: "" },
updationTime: 35,
isDeleted: true,
},
],
hasMore: false,
}),
)
.mockResolvedValueOnce(
response({
diff: [
{
file: remoteFile,
isDeleted: false,
isRestored: false,
updatedAt: 45,
deleteBy: 100,
},
],
hasMore: true,
}),
)
.mockResolvedValueOnce(
response({
diff: [
{
file: { ...remoteFile, id: 11 },
isDeleted: false,
isRestored: true,
updatedAt: 50,
deleteBy: 100,
},
],
hasMore: false,
}),
);
await syncLockerState();
expect(ensureAuthenticatedSession).toHaveBeenCalledOnce();
expect(fetchMock.mock.calls.map(([url]) => url)).toEqual([
"/collections/v2?sinceTime=5",
"/collections/v2/diff?collectionID=1&sinceTime=10",
"/collections/v2/diff?collectionID=1&sinceTime=30",
"/trash/v2/diff?sinceTime=40",
"/trash/v2/diff?sinceTime=45",
]);
expect(db.saveFileRecords).toHaveBeenCalledWith([
expect.objectContaining({ id: 12, collectionID: 1, hasObject: true }),
]);
expect(db.deleteFileRecords).toHaveBeenCalledWith([[13, 1]]);
expect(db.saveCollectionSinceTime).toHaveBeenCalledExactlyOnceWith(1, 35);
expect(db.saveTrashFileRecords).toHaveBeenCalledWith([
expect.objectContaining({ id: 12, updatedAt: 45, deleteBy: 100 }),
]);
expect(db.deleteTrashFileRecords).toHaveBeenCalledWith([11]);
expect(db.saveTrashSinceTime).toHaveBeenCalledExactlyOnceWith(50);
expect(
vi.mocked(db.saveFileRecords).mock.invocationCallOrder[0],
).toBeLessThan(
vi.mocked(db.saveCollectionSinceTime).mock.invocationCallOrder[0]!,
);
});
test("failed file pagination does not persist a partial diff or advance its cursor", async () => {
fetchMock
.mockResolvedValueOnce(response({ collections: [] }))
.mockResolvedValueOnce(response({ diff: [], hasMore: true }))
.mockResolvedValueOnce(new Response(null, { status: 500 }));
const existing = getLockerCacheSnapshot();
await expect(syncLockerState()).rejects.toThrow("Request failed");
expect(db.saveFileRecords).not.toHaveBeenCalled();
expect(db.saveCollectionSinceTime).not.toHaveBeenCalled();
expect(db.saveTrashSinceTime).not.toHaveBeenCalled();
expect(getLockerCacheSnapshot()).toEqual(existing);
});