@protontech/drive-sdk 0.1.0 → 0.1.2

package/src/internal/download/cryptoService.ts

@@ -1,27 +1,40 @@
 import { c } from 'ttag';
 
-import { DriveCrypto, PrivateKey, PublicKey, SessionKey, uint8ArrayToBase64String, VERIFICATION_STATUS } from "../../crypto";
-import { ProtonDriveAccount, Revision } from "../../interface";
-import { DecryptionError, IntegrityError } from "../../errors";
-import { getErrorMessage } from "../errors";
-import { mergeUint8Arrays } from "../utils";
-import { RevisionKeys } from "./interface";
+import {
+    DriveCrypto,
+    PrivateKey,
+    PublicKey,
+    SessionKey,
+    uint8ArrayToBase64String,
+    VERIFICATION_STATUS,
+} from '../../crypto';
+import { ProtonDriveAccount, Revision } from '../../interface';
+import { DecryptionError, IntegrityError } from '../../errors';
+import { getErrorMessage } from '../errors';
+import { mergeUint8Arrays } from '../utils';
+import { RevisionKeys } from './interface';
 
 export class DownloadCryptoService {
-    constructor(private driveCrypto: DriveCrypto, private account: ProtonDriveAccount) {
+    constructor(
+        private driveCrypto: DriveCrypto,
+        private account: ProtonDriveAccount,
+    ) {
         this.account = account;
         this.driveCrypto = driveCrypto;
     }
 
-    async getRevisionKeys(nodeKey: { key: PrivateKey, contentKeyPacketSessionKey: SessionKey }, revision: Revision): Promise<RevisionKeys> {
+    async getRevisionKeys(
+        nodeKey: { key: PrivateKey; contentKeyPacketSessionKey: SessionKey },
+        revision: Revision,
+    ): Promise<RevisionKeys> {
         const verificationKeys = await this.getRevisionVerificationKeys(revision);
         return {
             ...nodeKey,
             verificationKeys,
-        }
+        };
     }
 
-    async decryptBlock(encryptedBlock: Uint8Array, armoredSignature: string, revisionKeys: RevisionKeys): Promise<Uint8Array> {
+    async decryptBlock(encryptedBlock: Uint8Array, revisionKeys: RevisionKeys): Promise<Uint8Array> {
         let decryptedBlock;
         try {
             // We do not verify signatures on blocks. We only verify
@@ -30,14 +43,10 @@ export class DownloadCryptoService {
             // We plan to drop signatures of individual blocks
             // completely in the future. Any issue on the blocks
             // should be considered serious integrity issue.
-            const result = await this.driveCrypto.decryptBlock(
+            decryptedBlock = await this.driveCrypto.decryptBlock(
                 encryptedBlock,
-                armoredSignature,
-                revisionKeys.key,
                 revisionKeys.contentKeyPacketSessionKey,
-                revisionKeys.verificationKeys,
             );
-            decryptedBlock = result.decryptedBlock;
         } catch (error: unknown) {
             const message = getErrorMessage(error);
             throw new DecryptionError(c('Error').t`Failed to decrypt block: ${message}`);
@@ -75,8 +84,13 @@ export class DownloadCryptoService {
         }
     }
 
-    async verifyManifest(revision: Revision, nodeKey: PrivateKey, allBlockHashes: Uint8Array[], armoredManifestSignature?: string): Promise<void> {
-        const verificationKeys = await this.getRevisionVerificationKeys(revision) || nodeKey;
+    async verifyManifest(
+        revision: Revision,
+        nodeKey: PrivateKey,
+        allBlockHashes: Uint8Array[],
+        armoredManifestSignature?: string,
+    ): Promise<void> {
+        const verificationKeys = (await this.getRevisionVerificationKeys(revision)) || nodeKey;
         const hash = mergeUint8Arrays(allBlockHashes);
 
         if (!armoredManifestSignature) {
@@ -90,7 +104,9 @@ export class DownloadCryptoService {
     }
 
     private async getRevisionVerificationKeys(revision: Revision): Promise<PublicKey[] | undefined> {
-        const signatureEmail = revision.contentAuthor.ok ? revision.contentAuthor.value : revision.contentAuthor.error.claimedAuthor;
+        const signatureEmail = revision.contentAuthor.ok
+            ? revision.contentAuthor.value
+            : revision.contentAuthor.error.claimedAuthor;
         return signatureEmail ? await this.account.getPublicKeys(signatureEmail) : undefined;
     }
 }

package/src/internal/download/fileDownloader.test.ts

@@ -99,7 +99,7 @@ describe('FileDownloader', () => {
             expect(telemetry.downloadFinished).toHaveBeenCalledWith('revisionUid', fileProgress);
             expect(telemetry.downloadFailed).not.toHaveBeenCalled();
             expect(onFinish).toHaveBeenCalledTimes(1);
-        }
+        };
 
         const verifyFailure = async (error: string, downloadedBytes: number | undefined) => {
             const controller = downloader.writeToStream(stream, onProgress);
@@ -136,12 +136,20 @@ describe('FileDownloader', () => {
                 write: jest.fn(),
                 close: jest.fn(),
                 abort: jest.fn(),
-            }
+            };
             // @ts-expect-error Mocking WritableStream
             stream = {
                 getWriter: () => writer,
-            }
-            downloader = new FileDownloader(telemetry, apiService, cryptoService, nodeKey as any, revision, undefined, onFinish);
+            };
+            downloader = new FileDownloader(
+                telemetry,
+                apiService,
+                cryptoService,
+                nodeKey as any,
+                revision,
+                undefined,
+                onFinish,
+            );
         });
 
         it('should reject two download starts', async () => {
@@ -178,9 +186,9 @@ describe('FileDownloader', () => {
                 yield { type: 'block', index: 9, bareUrl: 'url', token: 'token3', base64sha256Hash: 'aGFzaDM=' };
                 yield { type: 'block', index: 10, bareUrl: 'url', token: 'token1', base64sha256Hash: 'aGFzaDE=' };
                 yield { type: 'block', index: 11, bareUrl: 'url', token: 'token2', base64sha256Hash: 'aGFzaDI=' };
-            })
+            });
             apiService.downloadBlock = jest.fn().mockImplementation(async function (bareUrl, token, onProgress) {
-                await new Promise(resolve => setTimeout(resolve, timeouts[count++]));
+                await new Promise((resolve) => setTimeout(resolve, timeouts[count++]));
                 return mockBlockDownload(bareUrl, token, onProgress);
             });
 
@@ -353,12 +361,20 @@ describe('FileDownloader', () => {
                 write: jest.fn(),
                 close: jest.fn(),
                 abort: jest.fn(),
-            }
+            };
             // @ts-expect-error Mocking WritableStream
             stream = {
                 getWriter: () => writer,
-            }
-            downloader = new FileDownloader(telemetry, apiService, cryptoService, nodeKey as any, revision, undefined, onFinish);
+            };
+            downloader = new FileDownloader(
+                telemetry,
+                apiService,
+                cryptoService,
+                nodeKey as any,
+                revision,
+                undefined,
+                onFinish,
+            );
         });
 
         it('should skip verification steps', async () => {

package/src/internal/download/fileDownloader.ts

@@ -1,10 +1,10 @@
-import { PrivateKey, SessionKey, base64StringToUint8Array } from "../../crypto";
-import { Logger, Revision } from "../../interface";
-import { LoggerWithPrefix } from "../../telemetry";
+import { PrivateKey, SessionKey, base64StringToUint8Array } from '../../crypto';
+import { Logger, Revision } from '../../interface';
+import { LoggerWithPrefix } from '../../telemetry';
 import { APIHTTPError, HTTPErrorCode } from '../apiService';
-import { DownloadAPIService } from "./apiService";
+import { DownloadAPIService } from './apiService';
 import { DownloadController } from './controller';
-import { DownloadCryptoService } from "./cryptoService";
+import { DownloadCryptoService } from './cryptoService';
 import { BlockMetadata, RevisionKeys } from './interface';
 import { DownloadTelemetry } from './telemetry';
 
@@ -20,16 +20,19 @@ export class FileDownloader {
 
     private controller: DownloadController;
     private nextBlockIndex = 1;
-    private ongoingDownloads = new Map<number, {
-        downloadPromise: Promise<void>,
-        decryptedBufferedBlock?: Uint8Array,
-    }>();
+    private ongoingDownloads = new Map<
+        number,
+        {
+            downloadPromise: Promise<void>;
+            decryptedBufferedBlock?: Uint8Array;
+        }
+    >();
 
     constructor(
         private telemetry: DownloadTelemetry,
         private apiService: DownloadAPIService,
         private cryptoService: DownloadCryptoService,
-        private nodeKey: { key: PrivateKey, contentKeyPacketSessionKey: SessionKey },
+        private nodeKey: { key: PrivateKey; contentKeyPacketSessionKey: SessionKey },
         private revision: Revision,
         private signal?: AbortSignal,
         private onFinish?: () => void,
@@ -127,7 +130,12 @@ export class FileDownloader {
                 this.logger.warn('Skipping manifest check');
             } else {
                 this.logger.debug(`Verifying manifest`);
-                await this.cryptoService.verifyManifest(this.revision, this.nodeKey.key, allBlockHashes, armoredManifestSignature);
+                await this.cryptoService.verifyManifest(
+                    this.revision,
+                    this.nodeKey.key,
+                    allBlockHashes,
+                    armoredManifestSignature,
+                );
             }
 
             await writer.close();
@@ -161,10 +169,15 @@ export class FileDownloader {
             logger.debug(`Downloading`);
             await this.controller.waitWhilePaused();
             try {
-                const encryptedBlock = await this.apiService.downloadBlock(blockMetadata.bareUrl, blockMetadata.token, (downloadedBytes) => {
-                    blockProgress += downloadedBytes;
-                    onProgress?.(downloadedBytes);
-                }, this.signal);
+                const encryptedBlock = await this.apiService.downloadBlock(
+                    blockMetadata.bareUrl,
+                    blockMetadata.token,
+                    (downloadedBytes) => {
+                        blockProgress += downloadedBytes;
+                        onProgress?.(downloadedBytes);
+                    },
+                    this.signal,
+                );
 
                 if (ignoreIntegrityErrors) {
                     logger.warn('Skipping hash check');
@@ -174,7 +187,7 @@ export class FileDownloader {
                 }
 
                 logger.debug(`Decrypting`);
-                decryptedBlock = await this.cryptoService.decryptBlock(encryptedBlock, blockMetadata.armoredSignature!, cryptoKeys);
+                decryptedBlock = await this.cryptoService.decryptBlock(encryptedBlock, cryptoKeys);
             } catch (error) {
                 if (blockProgress !== 0) {
                     onProgress?.(-blockProgress);
@@ -183,7 +196,11 @@ export class FileDownloader {
 
                 if (error instanceof APIHTTPError && error.statusCode === HTTPErrorCode.NOT_FOUND) {
                     logger.warn(`Token expired, fetching new token and retrying`);
-                    blockMetadata = await this.apiService.getRevisionBlockToken(this.revision.uid, blockMetadata.index, this.signal);
+                    blockMetadata = await this.apiService.getRevisionBlockToken(
+                        this.revision.uid,
+                        blockMetadata.index,
+                        this.signal,
+                    );
                     continue;
                 }
 
@@ -255,7 +272,8 @@ export class FileDownloader {
     }
 
     private get ongoingDownloadPromises() {
-        return this.ongoingDownloads.values()
+        return this.ongoingDownloads
+            .values()
             .filter((value) => value.decryptedBufferedBlock === undefined)
             .map((value) => value.downloadPromise);
     }

package/src/internal/download/index.ts

@@ -1,16 +1,16 @@
 import { c } from 'ttag';
 
-import { DriveCrypto } from "../../crypto";
-import { ValidationError } from "../../errors";
-import { ProtonDriveAccount, ProtonDriveTelemetry, NodeType, ThumbnailType, ThumbnailResult } from "../../interface";
-import { DriveAPIService } from "../apiService";
-import { DownloadAPIService } from "./apiService";
-import { DownloadCryptoService } from "./cryptoService";
-import { NodesService, RevisionsService, SharesService } from "./interface";
-import { FileDownloader } from "./fileDownloader";
-import { DownloadQueue } from "./queue";
-import { DownloadTelemetry } from "./telemetry";
-import { makeNodeUidFromRevisionUid } from "../uids";
+import { DriveCrypto } from '../../crypto';
+import { ValidationError } from '../../errors';
+import { ProtonDriveAccount, ProtonDriveTelemetry, NodeType, ThumbnailType, ThumbnailResult } from '../../interface';
+import { DriveAPIService } from '../apiService';
+import { DownloadAPIService } from './apiService';
+import { DownloadCryptoService } from './cryptoService';
+import { NodesService, RevisionsService, SharesService } from './interface';
+import { FileDownloader } from './fileDownloader';
+import { DownloadQueue } from './queue';
+import { DownloadTelemetry } from './telemetry';
+import { makeNodeUidFromRevisionUid } from '../uids';
 import { ThumbnailDownloader } from './thumbnailDownloader';
 
 export function initDownloadModule(
@@ -36,13 +36,13 @@ export function initDownloadModule(
             nodeKey = await nodesService.getNodeKeys(nodeUid);
 
             if (node.type === NodeType.Folder) {
-                throw new ValidationError(c("Error").t`Cannot download a folder`);
+                throw new ValidationError(c('Error').t`Cannot download a folder`);
             }
             if (!nodeKey.contentKeyPacketSessionKey) {
-                throw new ValidationError(c("Error").t`File has no content key`);
+                throw new ValidationError(c('Error').t`File has no content key`);
             }
             if (!node.activeRevision?.ok || !node.activeRevision.value) {
-                throw new ValidationError(c("Error").t`File has no active revision`);
+                throw new ValidationError(c('Error').t`File has no active revision`);
             }
         } catch (error: unknown) {
             queue.releaseCapacity();
@@ -76,12 +76,12 @@ export function initDownloadModule(
             node = await nodesService.getNode(nodeUid);
             nodeKey = await nodesService.getNodeKeys(nodeUid);
             revision = await revisionsService.getRevision(nodeRevisionUid);
-            
+
             if (node.type === NodeType.Folder) {
-                throw new ValidationError(c("Error").t`Cannot download a folder`);
+                throw new ValidationError(c('Error').t`Cannot download a folder`);
             }
             if (!nodeKey.contentKeyPacketSessionKey) {
-                throw new ValidationError(c("Error").t`File has no content key`);
+                throw new ValidationError(c('Error').t`File has no content key`);
             }
         } catch (error: unknown) {
             queue.releaseCapacity();
@@ -105,7 +105,7 @@ export function initDownloadModule(
         );
     }
 
-    async function *iterateThumbnails(
+    async function* iterateThumbnails(
         nodeUids: string[],
         thumbnailType?: ThumbnailType,
         signal?: AbortSignal,
@@ -118,5 +118,5 @@ export function initDownloadModule(
         getFileDownloader,
         getFileRevisionDownloader,
         iterateThumbnails,
-    }
+    };
 }

package/src/internal/download/interface.ts

@@ -1,38 +1,37 @@
-import { PrivateKey, PublicKey, SessionKey } from "../../crypto";
-import { NodeType, Result, Revision, MissingNode, MetricVolumeType } from "../../interface";
-import { DecryptedNode } from "../nodes";
+import { PrivateKey, PublicKey, SessionKey } from '../../crypto';
+import { NodeType, Result, Revision, MissingNode, MetricVolumeType } from '../../interface';
+import { DecryptedNode } from '../nodes';
 
 export type BlockMetadata = {
-    index: number,
-    bareUrl: string,
-    token: string,
-    base64sha256Hash: string,
-    signatureEmail?: string,
-    armoredSignature?: string,
+    index: number;
+    bareUrl: string;
+    token: string;
+    base64sha256Hash: string;
+    signatureEmail?: string;
 };
 
 export type RevisionKeys = {
-    key: PrivateKey,
-    contentKeyPacketSessionKey: SessionKey,
-    verificationKeys?: PublicKey[],
-}
+    key: PrivateKey;
+    contentKeyPacketSessionKey: SessionKey;
+    verificationKeys?: PublicKey[];
+};
 
 export interface SharesService {
-    getVolumeMetricContext(volumeId: string): Promise<MetricVolumeType>,
+    getVolumeMetricContext(volumeId: string): Promise<MetricVolumeType>;
 }
 
 export interface NodesService {
-    getNode(nodeUid: string): Promise<NodesServiceNode>,
-    getNodeKeys(nodeUid: string): Promise<{ key: PrivateKey, contentKeyPacketSessionKey?: SessionKey; }>,
+    getNode(nodeUid: string): Promise<NodesServiceNode>;
+    getNodeKeys(nodeUid: string): Promise<{ key: PrivateKey; contentKeyPacketSessionKey?: SessionKey }>;
     iterateNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<DecryptedNode | MissingNode>;
 }
 
 export interface NodesServiceNode {
-    uid: string,
-    type: NodeType,
-    activeRevision?: Result<Revision, Error>,
+    uid: string;
+    type: NodeType;
+    activeRevision?: Result<Revision, Error>;
 }
 
 export interface RevisionsService {
-    getRevision(nodeRevisionUid: string): Promise<Revision>,
+    getRevision(nodeRevisionUid: string): Promise<Revision>;
 }

package/src/internal/download/queue.ts

@@ -2,13 +2,13 @@ import { waitForCondition } from '../wait';
 
 /**
  * A queue that limits the number of concurrent downloads.
- * 
+ *
  * This is used to limit the number of concurrent downloads to avoid
  * overloading the server, or get rate limited.
- * 
+ *
  * Each file download consumes memory and is limited by the number of
  * concurrent block downloads for each file.
- * 
+ *
  * This queue is straitforward and does not have any priority mechanism
  * or other features, such as limiting total number of blocks being
  * downloaded. That is something we want to add in the future to be

package/src/internal/download/telemetry.test.ts

@@ -25,7 +25,7 @@ describe('DownloadTelemetry', () => {
 
         sharesService = {
             getVolumeMetricContext: jest.fn().mockResolvedValue('own_volume'),
-        }
+        };
 
         downloadTelemetry = new DownloadTelemetry(mockTelemetry, sharesService);
     });
@@ -35,10 +35,10 @@ describe('DownloadTelemetry', () => {
         await downloadTelemetry.downloadInitFailed(nodeUid, error);
 
         expect(mockTelemetry.logEvent).toHaveBeenCalledWith({
-            eventName: "download",
-            volumeType: "own_volume",
+            eventName: 'download',
+            volumeType: 'own_volume',
             downloadedSize: 0,
-            error: "unknown",
+            error: 'unknown',
             originalError: error,
         });
     });
@@ -48,11 +48,11 @@ describe('DownloadTelemetry', () => {
         await downloadTelemetry.downloadFailed(revisionUid, error, 123, 456);
 
         expect(mockTelemetry.logEvent).toHaveBeenCalledWith({
-            eventName: "download",
-            volumeType: "own_volume",
+            eventName: 'download',
+            volumeType: 'own_volume',
             downloadedSize: 123,
             claimedFileSize: 456,
-            error: "unknown",
+            error: 'unknown',
             originalError: error,
         });
     });
@@ -61,8 +61,8 @@ describe('DownloadTelemetry', () => {
         await downloadTelemetry.downloadFinished(revisionUid, 500);
 
         expect(mockTelemetry.logEvent).toHaveBeenCalledWith({
-            eventName: "download",
-            volumeType: "own_volume",
+            eventName: 'download',
+            volumeType: 'own_volume',
             downloadedSize: 500,
             claimedFileSize: 500,
         });
@@ -73,9 +73,9 @@ describe('DownloadTelemetry', () => {
             expect(mockTelemetry.logEvent).toHaveBeenCalledWith(
                 expect.objectContaining({
                     error,
-                })
+                }),
             );
-        }
+        };
 
         it('should ignore ValidationError', async () => {
             const error = new ValidationError('Validation error');

package/src/internal/download/telemetry.ts

@@ -1,16 +1,19 @@
-import { RateLimitedError, ValidationError, DecryptionError, IntegrityError } from "../../errors";
-import { ProtonDriveTelemetry, MetricsDownloadErrorType, Logger } from "../../interface";
-import { LoggerWithPrefix } from "../../telemetry";
+import { RateLimitedError, ValidationError, DecryptionError, IntegrityError } from '../../errors';
+import { ProtonDriveTelemetry, MetricsDownloadErrorType, Logger } from '../../interface';
+import { LoggerWithPrefix } from '../../telemetry';
 import { APIHTTPError } from '../apiService';
-import { splitNodeRevisionUid, splitNodeUid } from "../uids";
-import { SharesService } from "./interface";
+import { splitNodeRevisionUid, splitNodeUid } from '../uids';
+import { SharesService } from './interface';
 
 export class DownloadTelemetry {
     private logger: Logger;
 
-    constructor(private telemetry: ProtonDriveTelemetry, private sharesService: SharesService) {
+    constructor(
+        private telemetry: ProtonDriveTelemetry,
+        private sharesService: SharesService,
+    ) {
         this.telemetry = telemetry;
-        this.logger = this.telemetry.getLogger("download");
+        this.logger = this.telemetry.getLogger('download');
         this.sharesService = sharesService;
     }
 
@@ -61,12 +64,15 @@ export class DownloadTelemetry {
         });
     }
 
-    private async sendTelemetry(volumeId: string, options: {
-        downloadedSize: number,
-        claimedFileSize?: number,
-        error?: MetricsDownloadErrorType,
-        originalError?: unknown,
-    }) {
+    private async sendTelemetry(
+        volumeId: string,
+        options: {
+            downloadedSize: number;
+            claimedFileSize?: number;
+            error?: MetricsDownloadErrorType;
+            originalError?: unknown;
+        },
+    ) {
         let volumeType;
         try {
             volumeType = await this.sharesService.getVolumeMetricContext(volumeId);
@@ -107,7 +113,11 @@ function getErrorCategory(error: unknown): MetricsDownloadErrorType | undefined
         if (error.name === 'TimeoutError') {
             return 'server_error';
         }
-        if (error.name === 'OfflineError' || error.name === 'NetworkError' || error.message?.toLowerCase() === 'network error') {
+        if (
+            error.name === 'OfflineError' ||
+            error.name === 'NetworkError' ||
+            error.message?.toLowerCase() === 'network error'
+        ) {
             return 'network_error';
         }
         if (error.name === 'AbortError') {

package/src/internal/download/thumbnailDownloader.test.ts

@@ -1,5 +1,5 @@
 import { ProtonDriveTelemetry } from '../../interface';
-import { getMockTelemetry } from "../../tests/telemetry";
+import { getMockTelemetry } from '../../tests/telemetry';
 import { ThumbnailDownloader } from './thumbnailDownloader';
 import { DownloadAPIService } from './apiService';
 import { DownloadCryptoService } from './cryptoService';
@@ -28,7 +28,7 @@ describe('ThumbnailDownloader', () => {
                                 thumbnails: [{ type: 1, uid: `thumb-${nodeUid}` }],
                             },
                         },
-                    }
+                    };
                 }
             }),
             getNodeKeys: jest.fn().mockReturnValue({
@@ -45,7 +45,7 @@ describe('ThumbnailDownloader', () => {
                         ok: true,
                         bareUrl: `url-${thumbnailUid}`,
                         token: `token-${thumbnailUid}`,
-                    }
+                    };
                 }
             }),
             downloadBlock: jest.fn().mockResolvedValue(new Uint8Array([1, 2, 3])),
@@ -68,11 +68,17 @@ describe('ThumbnailDownloader', () => {
             { nodeUid: 'node3', ok: true, thumbnail: new Uint8Array([1, 2, 3]) },
         ]);
         expect(nodesService.iterateNodes).toHaveBeenCalledWith(['node1', 'node2', 'node3'], undefined);
-        expect(apiService.iterateThumbnails).toHaveBeenCalledWith(['thumb-node1', 'thumb-node2', 'thumb-node3'], undefined);
+        expect(apiService.iterateThumbnails).toHaveBeenCalledWith(
+            ['thumb-node1', 'thumb-node2', 'thumb-node3'],
+            undefined,
+        );
         expect(nodesService.getNodeKeys).toHaveBeenCalledTimes(3);
         expect(apiService.downloadBlock).toHaveBeenCalledTimes(3);
         expect(cryptoService.decryptThumbnail).toHaveBeenCalledTimes(3);
-        expect(cryptoService.decryptThumbnail).toHaveBeenCalledWith(new Uint8Array([1, 2, 3]), 'contentKeyPacketSessionKey');
+        expect(cryptoService.decryptThumbnail).toHaveBeenCalledWith(
+            new Uint8Array([1, 2, 3]),
+            'contentKeyPacketSessionKey',
+        );
     });
 
     it('should handle no requested node', async () => {
@@ -115,7 +121,6 @@ describe('ThumbnailDownloader', () => {
         expect(apiService.iterateThumbnails).not.toHaveBeenCalled();
     });
 
-
     it('should handle node without requested thumbnail', async () => {
         nodesService.iterateNodes = jest.fn().mockImplementation(async function* () {
             yield { uid: 'node1', type: 'file', activeRevision: { ok: true, value: { thumbnails: [] } } };