@protontech/drive-sdk 0.12.1 → 0.13.0

package/dist/internal/upload/smallFileUploader.d.ts

@@ -0,0 +1,83 @@
+import { PrivateKey, SessionKey } from '../../crypto';
+import { Logger, Thumbnail, ThumbnailType, UploadMetadata } from '../../interface';
+import { UploadAPIService } from './apiService';
+import { BlockVerifier } from './blockVerifier';
+import { UploadCryptoService } from './cryptoService';
+import { Uploader } from './fileUploader';
+import { NodeRevisionDraft, NodeCrypto } from './interface';
+import { UploadManager } from './manager';
+import { UploadTelemetry } from './telemetry';
+export type NodeKeys = {
+    key: PrivateKey;
+    contentKeyPacket: Uint8Array<ArrayBuffer>;
+    contentKeyPacketSessionKey: SessionKey;
+    signingKeys: NodeCrypto['signingKeys'];
+};
+/**
+ * Base uploader for small file and small revision uploads.
+ * Shares the single-request flow: read content, get node crypto, encrypt, then call API.
+ */
+declare abstract class SmallUploader extends Uploader {
+    protected logger: Logger;
+    constructor(telemetry: UploadTelemetry, apiService: UploadAPIService, cryptoService: UploadCryptoService, manager: UploadManager, metadata: UploadMetadata, onFinish: () => void, signal: AbortSignal | undefined);
+    protected createRevisionDraft(): Promise<{
+        revisionDraft: NodeRevisionDraft;
+        blockVerifier: BlockVerifier;
+    }>;
+    protected deleteRevisionDraft(revisionDraft: NodeRevisionDraft): Promise<void>;
+    protected startUpload(stream: ReadableStream, thumbnails: Thumbnail[], onProgress?: (uploadedBytes: number) => void): Promise<{
+        nodeRevisionUid: string;
+        nodeUid: string;
+    }>;
+    protected abstract getTelemetryContextUid(): string;
+    protected abstract handleUpload(stream: ReadableStream, thumbnails: Thumbnail[]): Promise<{
+        nodeUid: string;
+        nodeRevisionUid: string;
+    }>;
+    protected buildPayloads(nodeKeys: NodeKeys, stream: ReadableStream, thumbnails: Thumbnail[]): Promise<{
+        commitPayload: {
+            armoredManifestSignature: string;
+            armoredExtendedAttributes: string;
+        };
+        encryptedBlock: {
+            encryptedData: Uint8Array<ArrayBuffer>;
+            armoredSignature: string;
+            verificationToken: Uint8Array<ArrayBuffer>;
+        } | undefined;
+        encryptedThumbnails: {
+            type: ThumbnailType;
+            encryptedData: Uint8Array<ArrayBuffer>;
+        }[];
+    }>;
+    private readStreamContent;
+    private encryptThumbnails;
+    private encryptContentBlock;
+    private encryptCommitPayload;
+}
+/**
+ * Uploader for small new files using the single-request small file endpoint.
+ */
+export declare class SmallFileUploader extends SmallUploader {
+    private parentFolderUid;
+    private name;
+    constructor(telemetry: UploadTelemetry, apiService: UploadAPIService, cryptoService: UploadCryptoService, manager: UploadManager, metadata: UploadMetadata, onFinish: () => void, signal: AbortSignal | undefined, parentFolderUid: string, name: string);
+    protected getTelemetryContextUid(): string;
+    protected handleUpload(stream: ReadableStream, thumbnails: Thumbnail[]): Promise<{
+        nodeUid: string;
+        nodeRevisionUid: string;
+    }>;
+}
+/**
+ * Uploader for small new revisions using the single-request small revision endpoint.
+ * Reuses the existing file's keys.
+ */
+export declare class SmallFileRevisionUploader extends SmallUploader {
+    private nodeUid;
+    constructor(telemetry: UploadTelemetry, apiService: UploadAPIService, cryptoService: UploadCryptoService, manager: UploadManager, metadata: UploadMetadata, onFinish: () => void, signal: AbortSignal | undefined, nodeUid: string);
+    protected getTelemetryContextUid(): string;
+    protected handleUpload(stream: ReadableStream, thumbnails: Thumbnail[]): Promise<{
+        nodeUid: string;
+        nodeRevisionUid: string;
+    }>;
+}
+export {};

package/dist/internal/upload/smallFileUploader.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmallFileRevisionUploader = exports.SmallFileUploader = void 0;
+const errors_1 = require("../../errors");
+const errors_2 = require("../errors");
+const nodes_1 = require("../nodes");
+const blockVerifier_1 = require("./blockVerifier");
+const digests_1 = require("./digests");
+const fileUploader_1 = require("./fileUploader");
+const streamReader_1 = require("./streamReader");
+const streamUploader_1 = require("./streamUploader");
+/**
+ * Base uploader for small file and small revision uploads.
+ * Shares the single-request flow: read content, get node crypto, encrypt, then call API.
+ */
+class SmallUploader extends fileUploader_1.Uploader {
+    logger;
+    constructor(telemetry, apiService, cryptoService, manager, metadata, onFinish, signal) {
+        super(telemetry, apiService, cryptoService, manager, metadata, onFinish, signal);
+        this.logger = telemetry.getLoggerForSmallUpload();
+    }
+    async createRevisionDraft() {
+        throw new Error('Small upload does not use revision draft');
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async deleteRevisionDraft(revisionDraft) {
+        throw new Error('Small upload does not use revision draft');
+    }
+    async startUpload(stream, thumbnails, onProgress) {
+        try {
+            const result = await this.handleUpload(stream, thumbnails);
+            onProgress?.(this.metadata.expectedSize);
+            void this.telemetry.uploadFinished(result.nodeRevisionUid, this.metadata.expectedSize);
+            return result;
+        }
+        catch (error) {
+            void this.telemetry.uploadInitFailed(this.getTelemetryContextUid(), error, this.metadata.expectedSize);
+            throw error;
+        }
+        finally {
+            this.onFinish();
+        }
+    }
+    async buildPayloads(nodeKeys, stream, thumbnails) {
+        const content = await this.readStreamContent(stream);
+        const [encryptedThumbnails, encryptedBlock] = await Promise.all([
+            this.encryptThumbnails(nodeKeys, thumbnails),
+            this.encryptContentBlock(nodeKeys, content.data),
+        ]);
+        const commitPayload = await this.encryptCommitPayload(nodeKeys, content.sha1, encryptedBlock);
+        return {
+            commitPayload,
+            encryptedBlock,
+            encryptedThumbnails,
+        };
+    }
+    async readStreamContent(stream) {
+        const content = await (0, streamReader_1.readStreamToUint8Array)(stream, this.abortController.signal);
+        if (content.length !== this.metadata.expectedSize) {
+            throw new errors_1.IntegrityError(new Error('Stream size does not match expected size').message, {
+                actual: content.length,
+                expected: this.metadata.expectedSize,
+            });
+        }
+        const digests = new digests_1.UploadDigests();
+        digests.update(content);
+        const contentSha1 = digests.digests().sha1;
+        if (this.metadata.expectedSha1 && contentSha1 !== this.metadata.expectedSha1) {
+            throw new errors_1.IntegrityError(new Error('File hash does not match expected hash').message, {
+                uploadedSha1: contentSha1,
+                expectedSha1: this.metadata.expectedSha1,
+            });
+        }
+        return {
+            data: content,
+            sha1: contentSha1,
+        };
+    }
+    async encryptThumbnails(nodeKeys, thumbnails) {
+        const result = [];
+        for (const thumbnail of thumbnails) {
+            this.logger.debug(`Encrypting thumbnail ${thumbnail.type}`);
+            const enc = await this.cryptoService.encryptThumbnail(nodeKeys, thumbnail);
+            result.push({ type: thumbnail.type, encryptedData: enc.encryptedData });
+        }
+        return result;
+    }
+    async encryptContentBlock(nodeKeys, content) {
+        this.logger.debug(`Encrypting block`);
+        if (content.length === 0) {
+            return;
+        }
+        let attempt = 0;
+        let integrityError = false;
+        let encrypted;
+        while (!encrypted) {
+            attempt++;
+            try {
+                encrypted = await this.cryptoService.encryptBlock((encryptedBlock) => (0, blockVerifier_1.verifyBlockWithContentKey)(this.cryptoService, nodeKeys.contentKeyPacket, nodeKeys.contentKeyPacketSessionKey, encryptedBlock), nodeKeys, content, 0);
+                if (integrityError) {
+                    void this.telemetry.logBlockVerificationError(true);
+                }
+            }
+            catch (error) {
+                // Do not retry or report anything if the upload was aborted.
+                if (error instanceof errors_1.AbortError) {
+                    throw error;
+                }
+                if (error instanceof errors_1.IntegrityError) {
+                    integrityError = true;
+                }
+                if (attempt <= streamUploader_1.MAX_BLOCK_ENCRYPTION_RETRIES) {
+                    this.logger.warn(`Block encryption failed #${attempt}, retrying: ${(0, errors_2.getErrorMessage)(error)}`);
+                    continue;
+                }
+                this.logger.error(`Failed to encrypt block`, error);
+                if (integrityError) {
+                    void this.telemetry.logBlockVerificationError(false);
+                }
+                throw error;
+            }
+        }
+        const blockHash = await encrypted.hashPromise;
+        return {
+            encryptedData: encrypted.encryptedData,
+            armoredSignature: encrypted.armoredSignature,
+            verificationToken: encrypted.verificationToken,
+            blockHash,
+        };
+    }
+    async encryptCommitPayload(nodeKeys, contentSha1, encryptedBlock) {
+        this.logger.debug(`Preparing commit payload`);
+        const manifest = encryptedBlock ? encryptedBlock.blockHash : new Uint8Array(0);
+        const extendedAttributes = (0, nodes_1.generateFileExtendedAttributes)({
+            modificationTime: this.metadata.modificationTime,
+            size: this.metadata.expectedSize,
+            blockSizes: this.metadata.expectedSize > 0 ? [this.metadata.expectedSize] : [],
+            digests: { sha1: contentSha1 },
+        }, this.metadata.additionalMetadata);
+        const commitCrypto = await this.cryptoService.commitFile(nodeKeys, manifest, extendedAttributes);
+        return {
+            armoredManifestSignature: commitCrypto.armoredManifestSignature,
+            armoredExtendedAttributes: commitCrypto.armoredExtendedAttributes,
+        };
+    }
+}
+/**
+ * Uploader for small new files using the single-request small file endpoint.
+ */
+class SmallFileUploader extends SmallUploader {
+    parentFolderUid;
+    name;
+    constructor(telemetry, apiService, cryptoService, manager, metadata, onFinish, signal, parentFolderUid, name) {
+        super(telemetry, apiService, cryptoService, manager, metadata, onFinish, signal);
+        this.parentFolderUid = parentFolderUid;
+        this.name = name;
+        this.parentFolderUid = parentFolderUid;
+        this.name = name;
+    }
+    getTelemetryContextUid() {
+        return this.parentFolderUid;
+    }
+    async handleUpload(stream, thumbnails) {
+        const nodeCrypto = await this.manager.generateNewFileCrypto(this.parentFolderUid, this.name);
+        const nodeKeys = {
+            key: nodeCrypto.nodeKeys.decrypted.key,
+            contentKeyPacket: nodeCrypto.contentKey.encrypted.contentKeyPacket,
+            contentKeyPacketSessionKey: nodeCrypto.contentKey.decrypted.contentKeyPacketSessionKey,
+            signingKeys: nodeCrypto.signingKeys,
+        };
+        const payloads = await this.buildPayloads(nodeKeys, stream, thumbnails);
+        return this.manager.uploadFile(this.parentFolderUid, nodeCrypto, this.metadata, payloads.commitPayload, payloads.encryptedBlock, payloads.encryptedThumbnails);
+    }
+}
+exports.SmallFileUploader = SmallFileUploader;
+/**
+ * Uploader for small new revisions using the single-request small revision endpoint.
+ * Reuses the existing file's keys.
+ */
+class SmallFileRevisionUploader extends SmallUploader {
+    nodeUid;
+    constructor(telemetry, apiService, cryptoService, manager, metadata, onFinish, signal, nodeUid) {
+        super(telemetry, apiService, cryptoService, manager, metadata, onFinish, signal);
+        this.nodeUid = nodeUid;
+        this.nodeUid = nodeUid;
+    }
+    getTelemetryContextUid() {
+        return this.nodeUid;
+    }
+    async handleUpload(stream, thumbnails) {
+        const nodeKeys = await this.manager.getExistingFileNodeCrypto(this.nodeUid);
+        const payloads = await this.buildPayloads(nodeKeys, stream, thumbnails);
+        return this.manager.uploadSmallRevision(this.nodeUid, nodeKeys, payloads.commitPayload, payloads.encryptedBlock, payloads.encryptedThumbnails);
+    }
+}
+exports.SmallFileRevisionUploader = SmallFileRevisionUploader;
+//# sourceMappingURL=smallFileUploader.js.map

package/dist/internal/upload/smallFileUploader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"smallFileUploader.js","sourceRoot":"","sources":["../../../src/internal/upload/smallFileUploader.ts"],"names":[],"mappings":"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"}

package/dist/internal/upload/smallFileUploader.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/internal/upload/smallFileUploader.test.js

@@ -0,0 +1,358 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../../errors");
+const interface_1 = require("../../interface");
+const smallFileUploader_1 = require("./smallFileUploader");
+const MOCK_BLOCK_HASH = new Uint8Array(32).fill(1);
+const MOCK_VERIFICATION_TOKEN = new Uint8Array(16).fill(2);
+function createStream(bytes) {
+    return new ReadableStream({
+        start(controller) {
+            controller.enqueue(new Uint8Array(bytes));
+            controller.close();
+        },
+    });
+}
+function mockEncryptBlock(verifyBlock, _nodeKeys, block, _index) {
+    const encryptedData = new Uint8Array(block);
+    return (async () => {
+        await verifyBlock(encryptedData);
+        return {
+            index: 0,
+            encryptedData,
+            armoredSignature: 'mockBlockSignature',
+            verificationToken: MOCK_VERIFICATION_TOKEN,
+            originalSize: block.length,
+            encryptedSize: block.length + 100,
+            hash: 'blockHash',
+            hashPromise: Promise.resolve(MOCK_BLOCK_HASH),
+        };
+    })();
+}
+describe('SmallFileUploader', () => {
+    let telemetry;
+    let apiService;
+    let cryptoService;
+    let uploadManager;
+    let metadata;
+    let onFinish;
+    let abortController;
+    const parentFolderUid = 'parentFolderUid';
+    const name = 'test-file.txt';
+    const mockNodeCrypto = {
+        nodeKeys: {
+            decrypted: { key: {} },
+            encrypted: {
+                armoredKey: 'armoredKey',
+                armoredPassphrase: 'armoredPassphrase',
+                armoredPassphraseSignature: 'armoredPassphraseSignature',
+            },
+        },
+        contentKey: {
+            encrypted: {
+                contentKeyPacket: new Uint8Array(10),
+                base64ContentKeyPacket: 'base64ContentKeyPacket',
+                armoredContentKeyPacketSignature: 'armoredContentKeyPacketSignature',
+            },
+            decrypted: { contentKeyPacketSessionKey: {} },
+        },
+        encryptedNode: {
+            encryptedName: 'encryptedName',
+            hash: 'hash',
+        },
+        signingKeys: { email: 'test@test.com', addressId: 'addr', nameAndPassphraseSigningKey: {}, contentSigningKey: {} },
+    };
+    beforeEach(() => {
+        // @ts-expect-error No need to implement all methods for mocking
+        telemetry = {
+            getLoggerForRevision: jest.fn().mockReturnValue({
+                debug: jest.fn(),
+                info: jest.fn(),
+                warn: jest.fn(),
+                error: jest.fn(),
+            }),
+            getLoggerForSmallUpload: jest.fn().mockReturnValue({
+                debug: jest.fn(),
+                info: jest.fn(),
+                warn: jest.fn(),
+                error: jest.fn(),
+            }),
+            logBlockVerificationError: jest.fn(),
+            uploadFailed: jest.fn(),
+            uploadFinished: jest.fn(),
+            uploadInitFailed: jest.fn(),
+        };
+        // @ts-expect-error No need to implement all methods for mocking
+        apiService = {};
+        // @ts-expect-error No need to implement all methods for mocking
+        cryptoService = {
+            encryptThumbnail: jest.fn().mockImplementation(async (_nodeKeys, thumbnail) => ({
+                type: thumbnail.type,
+                encryptedData: new Uint8Array(thumbnail.thumbnail),
+                originalSize: thumbnail.thumbnail.length,
+                encryptedSize: thumbnail.thumbnail.length + 100,
+                hash: 'thumbnailHash',
+            })),
+            encryptBlock: jest.fn().mockImplementation(mockEncryptBlock),
+            verifyBlock: jest.fn().mockResolvedValue({ verificationToken: MOCK_VERIFICATION_TOKEN }),
+            commitFile: jest.fn().mockResolvedValue({
+                armoredManifestSignature: 'mockManifestSignature',
+                armoredExtendedAttributes: 'mockExtendedAttributes',
+            }),
+        };
+        uploadManager = {
+            generateNewFileCrypto: jest.fn().mockResolvedValue(mockNodeCrypto),
+            uploadFile: jest.fn().mockResolvedValue({
+                nodeUid: 'nodeUid',
+                nodeRevisionUid: 'nodeRevisionUid',
+            }),
+        };
+        metadata = {
+            expectedSize: 3,
+            mediaType: 'application/octet-stream',
+        };
+        onFinish = jest.fn();
+        abortController = new AbortController();
+    });
+    function createUploader() {
+        return new smallFileUploader_1.SmallFileUploader(telemetry, apiService, cryptoService, uploadManager, metadata, onFinish, abortController.signal, parentFolderUid, name);
+    }
+    describe('uploadFromStream', () => {
+        const thumbnails = [];
+        const onProgress = jest.fn();
+        it('should start upload and call manager.generateNewFileCrypto and manager.uploadFile', async () => {
+            const uploader = createUploader();
+            const stream = createStream([1, 2, 3]);
+            const controller = await uploader.uploadFromStream(stream, thumbnails, onProgress);
+            const result = await controller.completion();
+            expect(uploadManager.generateNewFileCrypto).toHaveBeenCalledWith(parentFolderUid, name);
+            expect(uploadManager.uploadFile).toHaveBeenCalledTimes(1);
+            expect(result).toEqual({ nodeUid: 'nodeUid', nodeRevisionUid: 'nodeRevisionUid' });
+            expect(onProgress).toHaveBeenCalledWith(metadata.expectedSize);
+        });
+        it('should throw if upload already started', async () => {
+            const uploader = createUploader();
+            const stream = createStream([1, 2, 3]);
+            await uploader.uploadFromStream(stream, thumbnails, onProgress);
+            await expect(uploader.uploadFromStream(stream, thumbnails, onProgress)).rejects.toThrow('Upload already started');
+        });
+    });
+    describe('buildPayloads (via upload flow)', () => {
+        it('should build commitPayload, encryptedBlock, and encryptedThumbnails from stream and pass to manager.uploadFile', async () => {
+            const uploader = createUploader();
+            const stream = createStream([1, 2, 3]);
+            const thumbnails = [
+                { type: interface_1.ThumbnailType.Type1, thumbnail: new Uint8Array([10, 20]) },
+                { type: interface_1.ThumbnailType.Type2, thumbnail: new Uint8Array([30, 40, 50]) },
+            ];
+            await uploader.uploadFromStream(stream, thumbnails, undefined);
+            await uploader.controller.completion();
+            expect(uploadManager.uploadFile).toHaveBeenCalledWith(parentFolderUid, mockNodeCrypto, metadata, expect.objectContaining({
+                armoredManifestSignature: 'mockManifestSignature',
+                armoredExtendedAttributes: 'mockExtendedAttributes',
+            }), expect.objectContaining({
+                encryptedData: expect.any(Uint8Array),
+                armoredSignature: 'mockBlockSignature',
+                verificationToken: MOCK_VERIFICATION_TOKEN,
+            }), [
+                { type: interface_1.ThumbnailType.Type1, encryptedData: expect.any(Uint8Array) },
+                { type: interface_1.ThumbnailType.Type2, encryptedData: expect.any(Uint8Array) },
+            ]);
+            expect(cryptoService.encryptBlock).toHaveBeenCalledTimes(1);
+            expect(cryptoService.encryptThumbnail).toHaveBeenCalledTimes(2);
+            expect(cryptoService.commitFile).toHaveBeenCalledWith(expect.anything(), MOCK_BLOCK_HASH, expect.any(String));
+        });
+        it('should pass encrypted block data matching stream content to crypto.encryptBlock', async () => {
+            const uploader = createUploader();
+            const content = [5, 6, 7, 8, 9];
+            metadata.expectedSize = content.length;
+            const stream = createStream(content);
+            await uploader.uploadFromStream(stream, [], undefined);
+            await uploader.controller.completion();
+            expect(cryptoService.encryptBlock).toHaveBeenCalledWith(expect.any(Function), expect.anything(), new Uint8Array(content), 0);
+        });
+        it('should pass each thumbnail to crypto.encryptThumbnail with nodeKeys', async () => {
+            const uploader = createUploader();
+            const thumbnails = [
+                { type: interface_1.ThumbnailType.Type1, thumbnail: new Uint8Array([1]) },
+            ];
+            const stream = createStream([1, 2, 3]);
+            await uploader.uploadFromStream(stream, thumbnails, undefined);
+            await uploader.controller.completion();
+            expect(cryptoService.encryptThumbnail).toHaveBeenCalledWith(expect.objectContaining({
+                key: mockNodeCrypto.nodeKeys.decrypted.key,
+                contentKeyPacket: mockNodeCrypto.contentKey.encrypted.contentKeyPacket,
+                contentKeyPacketSessionKey: mockNodeCrypto.contentKey.decrypted.contentKeyPacketSessionKey,
+                signingKeys: mockNodeCrypto.signingKeys,
+            }), { type: interface_1.ThumbnailType.Type1, thumbnail: new Uint8Array([1]) });
+        });
+        it('should call commitFile with manifest and extended attributes', async () => {
+            const uploader = createUploader();
+            const stream = createStream([1, 2, 3]);
+            await uploader.uploadFromStream(stream, [], undefined);
+            await uploader.controller.completion();
+            const [nodeKeys, manifest, extendedAttributes] = cryptoService.commitFile.mock.calls[0];
+            expect(manifest).toEqual(MOCK_BLOCK_HASH);
+            expect(extendedAttributes).toBeDefined();
+            expect(nodeKeys).toBeDefined();
+        });
+    });
+    describe('stream integrity', () => {
+        it('should throw IntegrityError when stream size does not match expectedSize', async () => {
+            const uploader = createUploader();
+            metadata.expectedSize = 5;
+            const stream = createStream([1, 2, 3]); // only 3 bytes
+            const controller = await uploader.uploadFromStream(stream, [], undefined);
+            await expect(controller.completion()).rejects.toThrow(errors_1.IntegrityError);
+            await expect(controller.completion()).rejects.toMatchObject({
+                debug: { actual: 3, expected: 5 },
+            });
+        });
+        it('should throw IntegrityError when stream sha1 does not match expectedSha1', async () => {
+            const uploader = createUploader();
+            metadata.expectedSha1 = 'a'.repeat(40); // wrong sha1
+            const stream = createStream([1, 2, 3]);
+            const controller = await uploader.uploadFromStream(stream, [], undefined);
+            await expect(controller.completion()).rejects.toThrow(errors_1.IntegrityError);
+            await expect(controller.completion()).rejects.toMatchObject({
+                debug: expect.objectContaining({
+                    expectedSha1: 'a'.repeat(40),
+                }),
+            });
+        });
+    });
+    describe('zero-byte file', () => {
+        it('should upload zero-byte file without calling encryptBlock and pass undefined block to manager.uploadFile', async () => {
+            metadata.expectedSize = 0;
+            const uploader = createUploader();
+            const stream = createStream([]);
+            const onProgress = jest.fn();
+            const controller = await uploader.uploadFromStream(stream, [], onProgress);
+            const result = await controller.completion();
+            expect(result).toEqual({ nodeUid: 'nodeUid', nodeRevisionUid: 'nodeRevisionUid' });
+            expect(cryptoService.encryptBlock).not.toHaveBeenCalled();
+            expect(uploadManager.uploadFile).toHaveBeenCalledWith(parentFolderUid, mockNodeCrypto, metadata, expect.objectContaining({
+                armoredManifestSignature: 'mockManifestSignature',
+                armoredExtendedAttributes: 'mockExtendedAttributes',
+            }), undefined, []);
+            expect(cryptoService.commitFile).toHaveBeenCalledWith(expect.anything(), new Uint8Array(0), expect.any(String));
+            expect(onFinish).toHaveBeenCalled();
+            expect(onProgress).toHaveBeenCalledWith(0);
+        });
+    });
+});
+describe('SmallFileRevisionUploader', () => {
+    let telemetry;
+    let apiService;
+    let cryptoService;
+    let uploadManager;
+    let metadata;
+    let onFinish;
+    let abortController;
+    const nodeUid = 'nodeUid';
+    const mockNodeKeys = {
+        key: {},
+        contentKeyPacket: new Uint8Array(10),
+        contentKeyPacketSessionKey: {},
+        signingKeys: { email: 'test@test.com', addressId: 'addr', nameAndPassphraseSigningKey: {}, contentSigningKey: {} },
+    };
+    beforeEach(() => {
+        // @ts-expect-error No need to implement all methods for mocking
+        telemetry = {
+            getLoggerForRevision: jest.fn().mockReturnValue({
+                debug: jest.fn(),
+                info: jest.fn(),
+                warn: jest.fn(),
+                error: jest.fn(),
+            }),
+            getLoggerForSmallUpload: jest.fn().mockReturnValue({
+                debug: jest.fn(),
+                info: jest.fn(),
+                warn: jest.fn(),
+                error: jest.fn(),
+            }),
+            logBlockVerificationError: jest.fn(),
+            uploadFailed: jest.fn(),
+            uploadFinished: jest.fn(),
+            uploadInitFailed: jest.fn(),
+        };
+        // @ts-expect-error No need to implement all methods for mocking
+        apiService = {};
+        // @ts-expect-error No need to implement all methods for mocking
+        cryptoService = {
+            encryptThumbnail: jest.fn().mockImplementation(async (_nodeKeys, thumbnail) => ({
+                type: thumbnail.type,
+                encryptedData: new Uint8Array(thumbnail.thumbnail),
+                originalSize: thumbnail.thumbnail.length,
+                encryptedSize: thumbnail.thumbnail.length + 100,
+                hash: 'thumbnailHash',
+            })),
+            encryptBlock: jest.fn().mockImplementation(async (verifyBlock, _, block) => {
+                await verifyBlock(block);
+                return {
+                    index: 0,
+                    encryptedData: block,
+                    armoredSignature: 'mockBlockSignature',
+                    verificationToken: MOCK_VERIFICATION_TOKEN,
+                    originalSize: block.length,
+                    encryptedSize: block.length + 100,
+                    hash: 'blockHash',
+                    hashPromise: Promise.resolve(MOCK_BLOCK_HASH),
+                };
+            }),
+            verifyBlock: jest.fn().mockResolvedValue({ verificationToken: MOCK_VERIFICATION_TOKEN }),
+            commitFile: jest.fn().mockResolvedValue({
+                armoredManifestSignature: 'mockManifestSignature',
+                armoredExtendedAttributes: 'mockExtendedAttributes',
+            }),
+        };
+        uploadManager = {
+            getExistingFileNodeCrypto: jest.fn().mockResolvedValue(mockNodeKeys),
+            uploadSmallRevision: jest.fn().mockResolvedValue({
+                nodeUid: 'nodeUid',
+                nodeRevisionUid: 'nodeRevisionUid',
+            }),
+        };
+        metadata = {
+            expectedSize: 3,
+            mediaType: 'application/octet-stream',
+        };
+        onFinish = jest.fn();
+        abortController = new AbortController();
+    });
+    function createUploader() {
+        return new smallFileUploader_1.SmallFileRevisionUploader(telemetry, apiService, cryptoService, uploadManager, metadata, onFinish, abortController.signal, nodeUid);
+    }
+    it('should get node crypto, build payloads, and call uploadSmallRevision', async () => {
+        const uploader = createUploader();
+        const stream = createStream([1, 2, 3]);
+        const controller = await uploader.uploadFromStream(stream, [], undefined);
+        const result = await controller.completion();
+        expect(result).toEqual({ nodeUid: 'nodeUid', nodeRevisionUid: 'nodeRevisionUid' });
+        expect(cryptoService.encryptBlock).toHaveBeenCalledWith(expect.any(Function), expect.anything(), Uint8Array.from([1, 2, 3]), 0);
+        expect(uploadManager.getExistingFileNodeCrypto).toHaveBeenCalledWith(nodeUid);
+        expect(uploadManager.uploadSmallRevision).toHaveBeenCalledWith(nodeUid, mockNodeKeys, expect.objectContaining({
+            armoredManifestSignature: 'mockManifestSignature',
+            armoredExtendedAttributes: 'mockExtendedAttributes',
+        }), expect.objectContaining({
+            encryptedData: expect.any(Uint8Array),
+            armoredSignature: 'mockBlockSignature',
+            verificationToken: MOCK_VERIFICATION_TOKEN,
+        }), []);
+    });
+    it('should upload zero-byte revision without calling encryptBlock and pass undefined block to uploadSmallRevision', async () => {
+        metadata.expectedSize = 0;
+        const uploader = createUploader();
+        const stream = createStream([]);
+        const controller = await uploader.uploadFromStream(stream, [], undefined);
+        const result = await controller.completion();
+        expect(result).toEqual({ nodeUid: 'nodeUid', nodeRevisionUid: 'nodeRevisionUid' });
+        expect(cryptoService.encryptBlock).not.toHaveBeenCalled();
+        expect(uploadManager.uploadSmallRevision).toHaveBeenCalledWith(nodeUid, mockNodeKeys, expect.objectContaining({
+            armoredManifestSignature: 'mockManifestSignature',
+            armoredExtendedAttributes: 'mockExtendedAttributes',
+        }), undefined, []);
+        expect(cryptoService.commitFile).toHaveBeenCalledWith(expect.anything(), new Uint8Array(0), expect.any(String));
+    });
+});
+//# sourceMappingURL=smallFileUploader.test.js.map