@protontech/drive-sdk 0.0.12 → 0.0.13

package/src/internal/nodes/nodesAccess.ts

@@ -3,6 +3,7 @@ import { c } from 'ttag';
 import { PrivateKey, SessionKey } from "../../crypto";
 import { InvalidNameError, Logger, MissingNode, NodeType, Result, resultError, resultOk } from "../../interface";
 import { DecryptionError, ProtonDriveError } from "../../errors";
+import { asyncIteratorMap } from '../asyncIteratorMap';
 import { getErrorMessage } from '../errors';
 import { BatchLoading } from "../batchLoading";
 import { makeNodeUid, splitNodeUid } from "../uids";
@@ -15,6 +16,16 @@ import { SharesService, EncryptedNode, DecryptedUnparsedNode, DecryptedNode, Dec
 import { validateNodeName } from "./validations";
 import { isProtonDocument, isProtonSheet } from './mediaTypes';
 
+// This is the number of nodes that are loaded in parallel.
+// It is a trade-off between initial wait time and overhead of API calls.
+const BATCH_LOADING_SIZE = 30;
+
+// This is the number of nodes that are decrypted in parallel.
+// It is a trade-off between performance and memory usage.
+// Higher number means more memory usage, but faster decryption.
+// Lower number means less memory usage, but slower decryption.
+const DECRYPTION_CONCURRENCY = 15;
+
 /**
  * Provides access to node metadata.
  * 
@@ -64,7 +75,7 @@ export class NodesAccess {
         // Ensure the parent is loaded and up-to-date.
         const parentNode = await this.getNode(parentNodeUid);
 
-        const batchLoading = new BatchLoading<string, DecryptedNode>({ iterateItems: (nodeUids) => this.loadNodes(nodeUids, signal) });
+        const batchLoading = new BatchLoading<string, DecryptedNode>({ iterateItems: (nodeUids) => this.loadNodes(nodeUids, signal), batchSize: BATCH_LOADING_SIZE });
 
         const areChildrenCached = await this.cache.isFolderChildrenLoaded(parentNodeUid);
         if (areChildrenCached) {
@@ -100,7 +111,7 @@ export class NodesAccess {
     // Improvement requested: keep status of loaded trash and leverage cache.
     async *iterateTrashedNodes(signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
         const { volumeId } = await this.shareService.getMyFilesIDs();
-        const batchLoading = new BatchLoading<string, DecryptedNode>({ iterateItems: (nodeUids) => this.loadNodes(nodeUids, signal) });
+        const batchLoading = new BatchLoading<string, DecryptedNode>({ iterateItems: (nodeUids) => this.loadNodes(nodeUids, signal), batchSize: BATCH_LOADING_SIZE });
         for await (const nodeUid of this.apiService.iterateTrashedNodeUids(volumeId, signal)) {
             let node;
             try {
@@ -118,7 +129,7 @@ export class NodesAccess {
     }
 
     async *iterateNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<DecryptedNode | MissingNode> {
-        const batchLoading = new BatchLoading<string, DecryptedNode | MissingNode>({ iterateItems: (nodeUids) => this.loadNodesWithMissingReport(nodeUids, signal) });
+        const batchLoading = new BatchLoading<string, DecryptedNode | MissingNode>({ iterateItems: (nodeUids) => this.loadNodesWithMissingReport(nodeUids, signal), batchSize: BATCH_LOADING_SIZE });
         for await (const result of this.cache.iterateNodes(nodeUids)) {
             if (result.ok && !result.node.isStale) {
                 yield result.node;
@@ -130,7 +141,8 @@ export class NodesAccess {
     }
 
     private async loadNode(nodeUid: string): Promise<{ node: DecryptedNode, keys?: DecryptedNodeKeys }> {
-        const encryptedNode = await this.apiService.getNode(nodeUid);
+        const { volumeId: ownVolumeId } = await this.shareService.getMyFilesIDs();
+        const encryptedNode = await this.apiService.getNode(nodeUid, ownVolumeId);
         return this.decryptNode(encryptedNode);
     }
 
@@ -147,13 +159,24 @@ export class NodesAccess {
         const returnedNodeUids: string[] = [];
         const errors = [];
 
-        for await (const encryptedNode of this.apiService.iterateNodes(nodeUids, signal)) {
+        const { volumeId: ownVolumeId } = await this.shareService.getMyFilesIDs();
+
+        const encryptedNodesIterator = this.apiService.iterateNodes(nodeUids, ownVolumeId, signal);
+        const decryptNodeMapper = async (encryptedNode: EncryptedNode): Promise<Result<DecryptedNode, unknown>> => {
             returnedNodeUids.push(encryptedNode.uid);
             try {
                 const { node } = await this.decryptNode(encryptedNode);
-                yield node;
+                return resultOk(node);
             } catch (error: unknown) {
-                errors.push(error);
+                return resultError(error);
+            }
+        };
+        const decryptedNodesIterator = asyncIteratorMap(encryptedNodesIterator, decryptNodeMapper, DECRYPTION_CONCURRENCY);
+        for await (const node of decryptedNodesIterator) {
+            if (node.ok) {
+                yield node.value;
+            } else {
+                errors.push(node.error);
             }
         }
 

package/src/internal/sharing/apiService.ts

@@ -49,6 +49,14 @@ type PostShareUrlResponse = drivePaths['/drive/shares/{shareID}/urls']['post']['
 type PutShareUrlRequest = Extract<drivePaths['/drive/shares/{shareID}/urls/{urlID}']['put']['requestBody'], { 'content': object }>['content']['application/json'];
 type PutShareUrlResponse = drivePaths['/drive/shares/{shareID}/urls/{urlID}']['put']['responses']['200']['content']['application/json'];
 
+// We do not support photos and albums yet.
+const SUPPORTED_SHARE_TARGET_TYPES = [
+    0, // Root
+    1, // Folder
+    2, // File
+    5, // Proton vendor (documents and sheets)
+];
+
 /**
  * Provides API communication for fetching and managing sharing.
  *
@@ -81,7 +89,14 @@ export class SharingAPIService {
         while (true) {
             const response = await this.apiService.get<GetSharedWithMeNodesResponse>(`drive/v2/sharedwithme?${anchor ? `AnchorID=${anchor}` : ''}`, signal);
             for (const link of response.Links) {
-                yield makeNodeUid(link.VolumeID, link.LinkID);
+                const nodeUid = makeNodeUid(link.VolumeID, link.LinkID);
+
+                if (!SUPPORTED_SHARE_TARGET_TYPES.includes(link.ShareTargetType)) {
+                    this.logger.warn(`Unsupported share target type ${link.ShareTargetType} for node ${nodeUid}`);
+                    continue;
+                }
+
+                yield nodeUid;
             }
 
             if (!response.More || !response.AnchorID) {
@@ -96,7 +111,14 @@ export class SharingAPIService {
         while (true) {
             const response = await this.apiService.get<GetInvitationsResponse>(`drive/v2/shares/invitations?${anchor ? `AnchorID=${anchor}` : ''}`, signal);
             for (const invitation of response.Invitations) {
-                yield makeInvitationUid(invitation.ShareID, invitation.InvitationID);
+                const invitationUid = makeInvitationUid(invitation.ShareID, invitation.InvitationID);
+
+                if (!SUPPORTED_SHARE_TARGET_TYPES.includes(invitation.ShareTargetType)) {
+                    this.logger.warn(`Unsupported share target type ${invitation.ShareTargetType} for invitation ${invitationUid}`);
+                    continue;
+                }
+
+                yield invitationUid;
             }
 
             if (!response.More || !response.AnchorID) {

package/src/internal/upload/fileUploader.test.ts

@@ -1,6 +1,5 @@
-import { Thumbnail, ThumbnailType, UploadMetadata } from '../../interface';
-import { APIHTTPError, HTTPErrorCode } from '../apiService';
-import { FILE_CHUNK_SIZE, Fileuploader } from './fileUploader';
+import { Thumbnail, UploadMetadata } from '../../interface';
+import { FileUploader } from './fileUploader';
 import { UploadTelemetry } from './telemetry';
 import { UploadAPIService } from './apiService';
 import { UploadCryptoService } from './cryptoService';
@@ -8,7 +7,6 @@ import { UploadController } from './controller';
 import { BlockVerifier } from './blockVerifier';
 import { NodeRevisionDraft } from './interface';
 import { UploadManager } from './manager';
-import { IntegrityError } from '../../errors';
 
 const BLOCK_ENCRYPTION_OVERHEAD = 10000;
 
@@ -41,7 +39,9 @@ describe('FileUploader', () => {
     let onFinish: () => Promise<void>;
     let abortController: AbortController;
 
-    let uploader: Fileuploader;
+    let uploader: FileUploader;
+
+    let startUploadSpy: jest.SpyInstance;
 
     beforeEach(() => {
         // @ts-expect-error No need to implement all methods for mocking
@@ -103,411 +103,81 @@ describe('FileUploader', () => {
             },
         } as NodeRevisionDraft;
 
-        metadata = {
-            // 3 blocks: 4 + 4 + 2 MB
-            expectedSize: 10 * 1024 * 1024,
-        } as UploadMetadata;
+        metadata = {} as UploadMetadata;
 
         controller = new UploadController();
         onFinish = jest.fn();
         abortController = new AbortController();
 
-        uploader = new Fileuploader(
+        uploader = new FileUploader(
             telemetry,
             apiService,
             cryptoService,
             uploadManager,
-            blockVerifier,
-            revisionDraft,
+            'parentFolderUid',
+            'name',
             metadata,
             onFinish,
             abortController.signal,
         );
-    });
-
-    describe('writeFile', () => {
-        it('should set modification time if not set', () => {
-            // @ts-expect-error Ignore mocking File
-            const file = {
-                lastModified: 123456789,
-                stream: jest.fn().mockReturnValue('stream'),
-            } as File;
-            const thumbnails: Thumbnail[] = [];
-            const onProgress = jest.fn();
-
-            const writeStreamSpy = jest.spyOn(uploader, 'writeStream').mockReturnValue(controller);
-
-            uploader.writeFile(file, thumbnails, onProgress);
-
-            expect(metadata.modificationTime).toEqual(new Date(123456789));
-            expect(writeStreamSpy).toHaveBeenCalledWith('stream', thumbnails, onProgress);
-        });
-    });
-
-    describe('writeStream', () => {
-        let uploadStreamSpy: jest.SpyInstance;
-        beforeEach(() => {
-            uploadStreamSpy = jest.spyOn(uploader as any, 'uploadStream').mockResolvedValue('revisionUid');
-        });
-
-        it('should throw an error if upload already started', () => {
-            uploader.writeStream(new ReadableStream(), [], jest.fn());
-
-            expect(() => {
-                uploader.writeStream(new ReadableStream(), [], jest.fn());
-            }).toThrow('Upload already started');
-        });
-
-        it('should start the upload process', async () => {
-            const stream = new ReadableStream();
-            const thumbnails: Thumbnail[] = [];
-            const onProgress = jest.fn();
 
-            uploader.writeStream(stream, thumbnails, onProgress);
-            expect(uploadStreamSpy).toHaveBeenCalledWith(stream, thumbnails, onProgress);
-        });
+        startUploadSpy = jest.spyOn(uploader as any, 'startUpload').mockReturnValue(Promise.resolve('revisionUid'));
     });
 
-    describe('uploadStream', () => {
-        let thumbnails: Thumbnail[];
-        let thumbnailSize: number;
-
-        let onProgress: (uploadedBytes: number) => void;
-        let stream: ReadableStream<Uint8Array>;
-
-        const verifySuccess = async () => {
-            const controller = uploader.writeStream(stream, thumbnails, onProgress);
-            await controller.completion();
-
-            const numberOfExpectedBlocks = Math.ceil(metadata.expectedSize / FILE_CHUNK_SIZE);
-            expect(uploadManager.commitDraft).toHaveBeenCalledTimes(1);
-            expect(uploadManager.commitDraft).toHaveBeenCalledWith(
-                revisionDraft,
-                expect.anything(),
-                metadata,
-                {
-                    size: metadata.expectedSize,
-                    blockSizes: metadata.expectedSize ? [
-                        ...Array(numberOfExpectedBlocks - 1).fill(FILE_CHUNK_SIZE),
-                        metadata.expectedSize % FILE_CHUNK_SIZE
-                    ] : [],
-                    modificationTime: undefined,
-                    digests: {
-                        sha1: expect.anything(),
-                    }
-                },
-                metadata.expectedSize + numberOfExpectedBlocks * BLOCK_ENCRYPTION_OVERHEAD,
-            );
-            expect(telemetry.uploadFinished).toHaveBeenCalledTimes(1);
-            expect(telemetry.uploadFinished).toHaveBeenCalledWith('revisionUid', metadata.expectedSize + thumbnailSize);
-            expect(telemetry.uploadFailed).not.toHaveBeenCalled();
-            expect(onFinish).toHaveBeenCalledTimes(1);
-            expect(onFinish).toHaveBeenCalledWith(false);
-        };
-
-        const verifyFailure = async (error: string, uploadedBytes: number | undefined, expectedSize = metadata.expectedSize) => {
-            const controller = uploader.writeStream(stream, thumbnails, onProgress);
-            await expect(controller.completion()).rejects.toThrow(error);
-
-            expect(telemetry.uploadFinished).not.toHaveBeenCalled();
-            expect(telemetry.uploadFailed).toHaveBeenCalledTimes(1);
-            expect(telemetry.uploadFailed).toHaveBeenCalledWith(
-                'revisionUid',
-                new Error(error),
-                uploadedBytes === undefined ? expect.anything() : uploadedBytes,
-                expectedSize,
-            );
-            expect(onFinish).toHaveBeenCalledTimes(1);
-            expect(onFinish).toHaveBeenCalledWith(true);
-        };
-
-        const verifyOnProgress = async (uploadedBytes: number[]) => {
-            expect(onProgress).toHaveBeenCalledTimes(uploadedBytes.length);
-            for (let i = 0; i < uploadedBytes.length; i++) {
-                expect(onProgress).toHaveBeenNthCalledWith(i + 1, uploadedBytes[i]);
-            }
-        };
-
-        beforeEach(() => {
-            onProgress = jest.fn();
-            thumbnails = [
-                {
-                    type: ThumbnailType.Type1,
-                    thumbnail: new Uint8Array(1024),
-                }
-            ];
-            thumbnailSize = thumbnails.reduce((acc, thumbnail) => acc + thumbnail.thumbnail.length, 0);
-            stream = new ReadableStream({
-                start(controller) {
-                    const chunkSize = 1024;
-                    const chunkCount = metadata.expectedSize / chunkSize;
-                    for (let i = 1; i <= chunkCount; i++) {
-                        controller.enqueue(new Uint8Array(chunkSize));
-                    }
-                    controller.close();
-                },
-            });
-        });
-
-        it("should upload successfully", async () => {
-            await verifySuccess();
-            expect(apiService.requestBlockUpload).toHaveBeenCalledTimes(1);
-            expect(apiService.uploadBlock).toHaveBeenCalledTimes(4); // 3 blocks + 1 thumbnail
-            expect(blockVerifier.verifyBlock).toHaveBeenCalledTimes(3); // 3 blocks
-            expect(telemetry.logBlockVerificationError).not.toHaveBeenCalled();
-            await verifyOnProgress([thumbnailSize, 4 * 1024 * 1024, 4 * 1024 * 1024, 2 * 1024 * 1024]);
-        });
-
-        it("should upload successfully empty file without thumbnail", async () => {
-            metadata = {
-                expectedSize: 0,
-            } as UploadMetadata;
-            stream = new ReadableStream({
-                start(controller) {
-                    controller.close();
-                },
-            });
-            thumbnails = [];
-            thumbnailSize = 0;
-            uploader = new Fileuploader(
-                telemetry,
-                apiService,
-                cryptoService,
-                uploadManager,
-                blockVerifier,
-                revisionDraft,
-                metadata,
-                onFinish,
-            );
-
-            await verifySuccess();
-            expect(apiService.requestBlockUpload).toHaveBeenCalledTimes(0);
-            expect(apiService.uploadBlock).toHaveBeenCalledTimes(0);
-            expect(blockVerifier.verifyBlock).toHaveBeenCalledTimes(0);
-            await verifyOnProgress([]);
-        });
-
-        it("should upload successfully empty file with thumbnail", async () => {
-            metadata = {
-                expectedSize: 0,
-            } as UploadMetadata;
-            stream = new ReadableStream({
-                start(controller) {
-                    controller.close();
-                },
-            });
-            uploader = new Fileuploader(
-                telemetry,
-                apiService,
-                cryptoService,
-                uploadManager,
-                blockVerifier,
-                revisionDraft,
-                metadata,
-                onFinish,
-            );
-
-            await verifySuccess();
-            expect(apiService.requestBlockUpload).toHaveBeenCalledTimes(1);
-            expect(apiService.uploadBlock).toHaveBeenCalledTimes(1);
-            expect(blockVerifier.verifyBlock).toHaveBeenCalledTimes(0);
-            await verifyOnProgress([thumbnailSize]);
-        });
-
-        it('should handle failure when encrypting thumbnails', async () => {
-            cryptoService.encryptThumbnail = jest.fn().mockImplementation(async function () {
-                throw new Error('Failed to encrypt thumbnail');
-            });
-
-            await verifyFailure('Failed to encrypt thumbnail', 0);
-            expect(cryptoService.encryptThumbnail).toHaveBeenCalledTimes(1);
-        });
-
-        it('should handle failure when encrypting block', async () => {
-            cryptoService.encryptBlock = jest.fn().mockImplementation(async function () {
-                throw new Error('Failed to encrypt block');
-            });
-
-            // Encrypting thumbnails is before blocks, thus it can be uploaded before failure.
-            await verifyFailure('Failed to encrypt block', 1024);
-            // 1 block + 1 retry, others are skipped
-            expect(cryptoService.encryptBlock).toHaveBeenCalledTimes(2);
-        });
-
-        it('should handle one time-off failure when encrypting block', async () => {
-            let count = 0;
-            cryptoService.encryptBlock = jest.fn().mockImplementation(async function (verifyBlock, keys, block, index) {
-                if (count === 0) {
-                    count++;
-                    throw new Error('Failed to encrypt block');
-                }
-                return mockEncryptBlock(verifyBlock, keys, block, index);
-            });
-
-            await verifySuccess();
-            // 1 block + 1 retry + 2 other blocks without retry
-            expect(cryptoService.encryptBlock).toHaveBeenCalledTimes(4);
-            await verifyOnProgress([thumbnailSize, 4 * 1024 * 1024, 4 * 1024 * 1024, 2 * 1024 * 1024]);
-        });
-
-        it('should handle failure when requesting tokens', async () => {
-            apiService.requestBlockUpload = jest.fn().mockImplementation(async function () {
-                throw new Error('Failed to request tokens');
-            });
-
-            await verifyFailure('Failed to request tokens', 0);
-        });
+    describe('writeFile', () => {
+        // @ts-expect-error Ignore mocking File
+        const file = {
+            type: 'image/png',
+            size: 1000,
+            lastModified: 123456789,
+            stream: jest.fn().mockReturnValue('stream'),
+        } as File;
+        const thumbnails: Thumbnail[] = [];
+        const onProgress = jest.fn();
 
-        it('should handle failure when uploading thumbnail', async () => {
-            apiService.uploadBlock = jest.fn().mockImplementation(async function (bareUrl, token, block, onProgress) {
-                if (token === 'token/thumbnail:1') {
-                    throw new Error('Failed to upload thumbnail');
-                }
-                return mockUploadBlock(bareUrl, token, block, onProgress);
-            });
+        it('should set media type if not set', async () => {
+            await uploader.writeFile(file, thumbnails, onProgress);
 
-            // 10 MB uploaded as blocks still uploaded
-            await verifyFailure('Failed to upload thumbnail', 10 * 1024 * 1024);
+            expect(metadata.mediaType).toEqual('image/png');
+            expect(startUploadSpy).toHaveBeenCalledWith('stream', thumbnails, onProgress);
         });
 
-        it('should handle one time-off failure when uploading thubmnail', async () => {
-            let count = 0;
-            apiService.uploadBlock = jest.fn().mockImplementation(async function (bareUrl, token, block, onProgress) {
-                if (token === 'token/thumbnail:1' && count === 0) {
-                    count++;
-                    throw new Error('Failed to upload thumbnail');
-                }
-                return mockUploadBlock(bareUrl, token, block, onProgress);
-            });
+        it('should set expected size if not set', async () => {
+            await uploader.writeFile(file, thumbnails, onProgress);
 
-            await verifySuccess();
-            expect(apiService.requestBlockUpload).toHaveBeenCalledTimes(1);
-            // 3 blocks + 1 retry + 1 thumbnail
-            expect(apiService.uploadBlock).toHaveBeenCalledTimes(5);
-            await verifyOnProgress([4 * 1024 * 1024, 4 * 1024 * 1024, 2 * 1024 * 1024, 1024]);
+            expect(metadata.expectedSize).toEqual(file.size);
+            expect(startUploadSpy).toHaveBeenCalledWith('stream', thumbnails, onProgress);
         });
 
-        it('should handle failure when uploading block', async () => {
-            apiService.uploadBlock = jest.fn().mockImplementation(async function (bareUrl, token, block, onProgress) {
-                if (token === 'token/block:3') {
-                    throw new Error('Failed to upload block');
-                }
-                return mockUploadBlock(bareUrl, token, block, onProgress);
-            });
+        it('should set modification time if not set', async () => {
+            await uploader.writeFile(file, thumbnails, onProgress);
 
-            // ~8 MB uploaded as 2 first blocks + 1 thumbnail still uploaded
-            await verifyFailure('Failed to upload block', 8 * 1024 * 1024 + 1024);
+            expect(metadata.modificationTime).toEqual(new Date(123456789));
+            expect(startUploadSpy).toHaveBeenCalledWith('stream', thumbnails, onProgress);
         });
 
-        it('should handle one time-off failure when uploading block', async () => {
-            let count = 0;
-            apiService.uploadBlock = jest.fn().mockImplementation(async function (bareUrl, token, block, onProgress) {
-                if (token === 'token/block:2' && count === 0) {
-                    count++;
-                    throw new Error('Failed to upload block');
-                }
-                return mockUploadBlock(bareUrl, token, block, onProgress);
-            });
+        it('should throw an error if upload already started', async () => {
+            await uploader.writeFile(file, thumbnails, onProgress);
 
-            await verifySuccess();
-            expect(apiService.requestBlockUpload).toHaveBeenCalledTimes(1);
-            // 3 blocks + 1 retry + 1 thumbnail
-            expect(apiService.uploadBlock).toHaveBeenCalledTimes(5);
-            await verifyOnProgress([1024, 4 * 1024 * 1024, 2 * 1024 * 1024, 4 * 1024 * 1024]);
+            await expect(uploader.writeFile(file, thumbnails, onProgress)).rejects.toThrow('Upload already started');
         });
+    });
 
-        it('should handle expired token when uploading block', async () => {
-            let count = 0;
-            apiService.uploadBlock = jest.fn().mockImplementation(async function (bareUrl, token, block, onProgress) {
-                if (token === 'token/block:2' && count === 0) {
-                    count++;
-                    throw new APIHTTPError('Expired token', HTTPErrorCode.NOT_FOUND);
-                }
-                return mockUploadBlock(bareUrl, token, block, onProgress);
-            });
+    describe('writeStream', () => {
+        const stream = new ReadableStream();
+        const thumbnails: Thumbnail[] = [];
+        const onProgress = jest.fn();
 
-            await verifySuccess();
-            // 1 for first try + 1 for retry
-            expect(apiService.requestBlockUpload).toHaveBeenCalledTimes(2);
-            expect(apiService.requestBlockUpload).toHaveBeenCalledWith(
-                revisionDraft.nodeRevisionUid,
-                revisionDraft.nodeKeys.signatureAddress.addressId,
-                {
-                    contentBlocks: [
-                        {
-                            index: 2,
-                            encryptedSize: 4 * 1024 * 1024 + 10000,
-                            hash: 'blockHash',
-                            armoredSignature: 'signature',
-                            verificationToken: 'verificationToken',
-                        }
-                    ],
-                },
-            );
-            // 3 blocks + 1 retry + 1 thumbnail
-            expect(apiService.uploadBlock).toHaveBeenCalledTimes(5);
-            await verifyOnProgress([1024, 4 * 1024 * 1024, 2 * 1024 * 1024, 4 * 1024 * 1024]);
-        });
+        it('should start the upload process', async () => {
+            await uploader.writeStream(stream, thumbnails, onProgress);
 
-        it('should handle abortion', async () => {
-            const error = new Error('Aborted');
-            const controller = uploader.writeStream(stream, thumbnails, onProgress);
-            abortController.abort(error);
-            await controller.completion();
-            expect(apiService.uploadBlock.mock.calls[0][4]?.aborted).toBe(true);
+            expect(startUploadSpy).toHaveBeenCalledWith(stream, thumbnails, onProgress);
         });
 
-        describe('verifyIntegrity', () => {
-            it('should report block verification error', async () => {
-                blockVerifier.verifyBlock = jest.fn().mockRejectedValue(new IntegrityError('Block verification error'));
-                await verifyFailure('Block verification error', 1024);
-                expect(telemetry.logBlockVerificationError).toHaveBeenCalledWith(false);
-            });
-
-            it('should report block verification error when retry helped', async () => {
-                blockVerifier.verifyBlock = jest.fn().mockRejectedValueOnce(new IntegrityError('Block verification error')).mockResolvedValue({
-                    verificationToken: new Uint8Array(),
-                });
-                await verifySuccess();
-                expect(telemetry.logBlockVerificationError).toHaveBeenCalledWith(true);
-            });
-
-            it('should throw an error if block count does not match', async () => {
-                uploader = new Fileuploader(
-                    telemetry,
-                    apiService,
-                    cryptoService,
-                    uploadManager,
-                    blockVerifier,
-                    revisionDraft,
-                    {
-                        // Fake expected size to break verification
-                        expectedSize: 1 * 1024 * 1024 + 1024,
-                        mediaType: '',
-                    },
-                    onFinish,
-                );
-
-                await verifyFailure(
-                    'Some file parts failed to upload',
-                    10 * 1024 * 1024 + 1024,
-                    1 * 1024 * 1024 + 1024,
-                );
-            });
-
-            it('should throw an error if file size does not match', async () => {
-                cryptoService.encryptBlock = jest.fn().mockImplementation(async (_, __, block, index) => ({
-                    index,
-                    encryptedData: block,
-                    armoredSignature: 'signature',
-                    verificationToken: 'verificationToken',
-                    originalSize: 0, // Fake original size to break verification
-                    encryptedSize: block.length + 10000,
-                    hash: 'blockHash',
-                }));
+        it('should throw an error if upload already started', async () => {
+            await uploader.writeStream(stream, thumbnails, onProgress);
 
-                await verifyFailure('Some file bytes failed to upload', 10 * 1024 * 1024 + 1024);
-            });
+            await expect(uploader.writeStream(stream, thumbnails, onProgress)).rejects.toThrow('Upload already started');
         });
     });
 });