Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

6.4 KB
Raw Blame
import { afterEach, beforeEach, expect, test, vi } from "vitest";
import { itemFormDataForSave } from "../src/components/create-item/item-form-fields-utils";
import { updateFileItem, updateInfoItem } from "../src/services/items";
import {
    getEncryptedFileRecord,
    replaceLockerCache,
    type EncryptedFileRecord,
} from "../src/services/locker-cache";

const { encryptBlob, decryptMetadataJSON } = vi.hoisted(() => ({
    encryptBlob: vi.fn(),
    decryptMetadataJSON: vi.fn(),
}));
vi.mock("ente-accounts/services/user", () => ({}));
vi.mock("ente-base/http", () => ({
    authenticatedRequestHeaders: () => ({}),
    ensureOk: (response: Response) => {
        if (!response.ok) throw new Error("Request failed");
    },
}));
vi.mock("ente-base/origins", () => ({ apiURL: (path: string) => path }));
vi.mock("ente-base/log", () => ({ default: {} }));
vi.mock("ente-locker-wasm", () => ({
    decryptBox: () => "file-key",
    decryptMetadataJSON,
    encryptBlob,
}));
vi.mock("../src/services/authenticated-session", () => ({}));
vi.mock("../src/services/sync/decrypt", () => ({
    decryptCollectionKey: () => "collection-key",
}));

const fetchMock = vi.fn<typeof fetch>();
const originalMetadata = { version: 4, data: "original", header: "header" };

beforeEach(() => {
    vi.clearAllMocks();
    vi.stubGlobal("fetch", fetchMock);
    fetchMock.mockResolvedValue(new Response(null, { status: 200 }));
    encryptBlob.mockResolvedValue({
        encryptedData: "updated",
        decryptionHeader: "updated-header",
    });
    decryptMetadataJSON.mockResolvedValue({
        retained: "custom metadata",
        info: { type: "note", data: { title: "Original" } },
    });
    const file: EncryptedFileRecord = {
        id: 1,
        collectionID: 2,
        encryptedKey: "encrypted-key",
        keyDecryptionNonce: "nonce",
        fileDecryptionHeader: "header",
        hasObject: true,
        metadata: { encryptedData: "data", decryptionHeader: "header" },
        pubMagicMetadata: originalMetadata,
        updationTime: 0,
    };
    replaceLockerCache({
        collections: new Map([
            [
                2,
                {
                    id: 2,
                    ownerID: 1,
                    encryptedKey: "key",
                    keyDecryptionNonce: "nonce",
                    encryptedName: undefined,
                    nameDecryptionNonce: undefined,
                    type: "folder",
                    isDeleted: false,
                    updationTime: 0,
                },
            ],
        ]),
        files: new Map([[1, new Map([[2, file]])]]),
    });
});
afterEach(() => vi.unstubAllGlobals());

test.each(["file", "note"] as const)(
    "editing a %s preserves unrelated metadata and advances the cached version",
    async (type) => {
        if (type === "file") await updateFileItem(1, "  Renamed  ");
        else
            await updateInfoItem(1, "note", {
                title: "  Renamed  ",
                content: "Body",
            });

        expect(encryptBlob).toHaveBeenCalledWith(
            expect.any(Uint8Array),
            "file-key",
        );
        const metadata = JSON.parse(
            new TextDecoder().decode(
                encryptBlob.mock.calls[0]![0] as Uint8Array,
            ),
        ) as Record<string, unknown>;
        expect(typeof metadata.editedTime).toBe("number");
        expect(metadata).toEqual({
            retained: "custom metadata",
            noThumb: true,
            editedName: "Renamed",
            editedTime: metadata.editedTime,
            info: {
                type: "note",
                data:
                    type === "file"
                        ? { title: "Original" }
                        : { title: "  Renamed  ", content: "Body" },
            },
        });
        expect(fetchMock).toHaveBeenCalledWith(
            "/files/public-magic-metadata",
            expect.objectContaining({
                method: "PUT",
                body: JSON.stringify({
                    metadataList: [
                        {
                            id: 1,
                            magicMetadata: {
                                version: 4,
                                count: 5,
                                data: "updated",
                                header: "updated-header",
                            },
                        },
                    ],
                }),
            }),
        );
        expect(getEncryptedFileRecord(1)?.pubMagicMetadata).toEqual({
            version: 5,
            data: "updated",
            header: "updated-header",
        });
    },
);

test("a rejected metadata update leaves the cache unchanged", async () => {
    fetchMock.mockResolvedValue(new Response(null, { status: 500 }));
    await expect(updateFileItem(1, "Renamed")).rejects.toThrow(
        "Request failed",
    );
    expect(getEncryptedFileRecord(1)?.pubMagicMetadata).toEqual(
        originalMetadata,
    );
});

test("clearing optional credential fields replaces the saved info data", async () => {
    decryptMetadataJSON.mockResolvedValue({
        info: {
            type: "accountCredential",
            data: { name: "Netflix", username: "old", password: "old" },
        },
    });

    await updateInfoItem(1, "accountCredential", { name: "Netflix" });

    const metadata = JSON.parse(
        new TextDecoder().decode(encryptBlob.mock.calls[0]![0] as Uint8Array),
    ) as Record<string, unknown>;
    expect(metadata.info).toEqual({
        type: "accountCredential",
        data: { name: "Netflix" },
    });
});

test.each([" secret", "secret ", " secret ", "   "])(
    "renaming a Secret preserves password whitespace in metadata: %j",
    async (password) => {
        const data = { name: "Account", password };
        decryptMetadataJSON.mockResolvedValue({
            info: { type: "accountCredential", data },
        });
        await updateInfoItem(
            1,
            "accountCredential",
            itemFormDataForSave("accountCredential", {
                ...data,
                name: "Renamed",
            }),
        );
        const metadata = JSON.parse(
            new TextDecoder().decode(
                encryptBlob.mock.calls[0]![0] as Uint8Array,
            ),
        ) as Record<string, unknown>;
        expect(metadata.info).toEqual({
            type: "accountCredential",
            data: { name: "Renamed", password },
        });
    },
);