π 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 {
emptyTrash,
permanentlyDeleteFromTrash,
restoreFromTrash,
trashFiles,
} from "../src/services/trash";
const {
ensureAuthenticatedSession,
getCollectionRecord,
getEncryptedFileRecord,
fetchLockerTrash,
encryptBox,
warn,
} = vi.hoisted(() => ({
ensureAuthenticatedSession: vi.fn(),
getCollectionRecord: vi.fn(),
getEncryptedFileRecord: vi.fn(),
fetchLockerTrash: vi.fn(),
encryptBox: vi.fn(),
warn: vi.fn(),
}));
vi.mock("../src/services/locker-cache", () => ({
getCollectionRecord,
getEncryptedFileRecord,
}));
vi.mock("../src/services/sync/decrypt", () => ({
openCollectionKeyForRecord: (_session: unknown, record: { id: number }) =>
`collection-${record.id}`,
}));
vi.mock("../src/services/sync/sync", () => ({ fetchLockerTrash }));
vi.mock("ente-locker-wasm", () => ({
decryptBox: () => "file-key",
encryptBox,
}));
vi.mock("ente-base/http", () => ({
authenticatedRequestHeaders: () => ({}),
ensureOk: (res: Response) => {
if (!res.ok) throw new Error("Request failed");
},
}));
vi.mock("ente-base/origins", () => ({ apiURL: (path: string) => path }));
vi.mock("ente-base/log", () => ({ default: { warn } }));
vi.mock("ente-accounts/services/user", () => ({}));
vi.mock("../src/services/authenticated-session", () => ({
ensureAuthenticatedSession,
}));
const fetchMock = vi.fn<typeof fetch>();
const items = [{ id: 1, collectionID: 2 }];
beforeEach(() => {
vi.resetAllMocks();
ensureAuthenticatedSession.mockResolvedValue({});
vi.stubGlobal("fetch", fetchMock);
fetchMock.mockResolvedValue(new Response(null, { status: 200 }));
getCollectionRecord.mockImplementation((id: number) => ({ id }));
getEncryptedFileRecord.mockReturnValue({
collectionID: 2,
encryptedKey: "key",
keyDecryptionNonce: "nonce",
});
encryptBox.mockResolvedValue({
encryptedData: "rewrapped",
nonce: "new-nonce",
});
});
afterEach(() => vi.unstubAllGlobals());
test("trash mutations preserve endpoints and payloads", async () => {
await trashFiles([1, 3], 2);
await permanentlyDeleteFromTrash([1, 3]);
await emptyTrash(123);
expect(
fetchMock.mock.calls.map(([url, init]) => [
url,
init?.method,
JSON.parse(init?.body as string) as unknown,
]),
).toEqual([
[
"/files/trash",
"POST",
{
items: [
{ fileID: 1, collectionID: 2 },
{ fileID: 3, collectionID: 2 },
],
},
],
["/trash/delete", "POST", { fileIDs: [1, 3] }],
["/trash/empty", "POST", { lastUpdatedAt: 123 }],
]);
});
test("restore reuses one session to rewrap file keys for the chosen destination", async () => {
await restoreFromTrash([...items, { id: 3, collectionID: 2 }], 9);
expect(ensureAuthenticatedSession).toHaveBeenCalledOnce();
expect(getEncryptedFileRecord).toHaveBeenCalledWith(1, 2);
expect(getEncryptedFileRecord).toHaveBeenCalledWith(3, 2);
expect(encryptBox).toHaveBeenCalledWith("file-key", "collection-9");
expect(fetchMock).toHaveBeenCalledWith(
"/collections/restore-files",
expect.objectContaining({
body: JSON.stringify({
collectionID: 9,
files: [1, 3].map((id) => ({
id,
encryptedKey: "rewrapped",
keyDecryptionNonce: "new-nonce",
})),
}),
}),
);
});
test("restore refreshes missing cache records once before retrying", async () => {
getEncryptedFileRecord.mockReturnValueOnce(undefined);
await restoreFromTrash(items, 9);
expect(ensureAuthenticatedSession).toHaveBeenCalledOnce();
expect(fetchLockerTrash).toHaveBeenCalledTimes(1);
expect(fetchMock).toHaveBeenCalledTimes(1);
});
test("restore rejects when cache records remain missing", async () => {
getEncryptedFileRecord.mockReturnValue(undefined);
await expect(restoreFromTrash(items, 9)).rejects.toThrow(
"missing encrypted metadata",
);
expect(fetchLockerTrash).toHaveBeenCalledTimes(1);
expect(fetchMock).not.toHaveBeenCalled();
});
test("partial restore submits available files without retrying missing ones", async () => {
getEncryptedFileRecord.mockReturnValueOnce(undefined);
await restoreFromTrash([{ id: 3, collectionID: 2 }, ...items], 9);
expect(fetchLockerTrash).not.toHaveBeenCalled();
expect(warn).toHaveBeenCalledWith(expect.any(String), [3]);
expect(
(
JSON.parse(fetchMock.mock.calls[0]![1]!.body as string) as {
files: unknown[];
}
).files,
).toHaveLength(1);
});
test("restore rejects a missing destination before sending a request", async () => {
getCollectionRecord.mockReturnValue(undefined);
await expect(restoreFromTrash(items, 9)).rejects.toThrow(
"Collection 9 not in cache",
);
expect(fetchMock).not.toHaveBeenCalled();
});
test("mutation failures propagate", async () => {
fetchMock.mockImplementation(() =>
Promise.resolve(new Response(null, { status: 500 })),
);
await expect(trashFiles([1], 2)).rejects.toThrow("Request failed");
await expect(permanentlyDeleteFromTrash([1])).rejects.toThrow(
"Request failed",
);
await expect(emptyTrash(123)).rejects.toThrow("Request failed");
await expect(restoreFromTrash(items, 9)).rejects.toThrow("Request failed");
});