@protontech/drive-sdk 0.0.10

package/src/internal/download/index.ts

@@ -0,0 +1,122 @@
+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 { ThumbnailDownloader } from './thumbnailDownloader';
+
+export function initDownloadModule(
+    telemetry: ProtonDriveTelemetry,
+    apiService: DriveAPIService,
+    driveCrypto: DriveCrypto,
+    account: ProtonDriveAccount,
+    sharesService: SharesService,
+    nodesService: NodesService,
+    revisionsService: RevisionsService,
+) {
+    const queue = new DownloadQueue();
+    const api = new DownloadAPIService(apiService);
+    const cryptoService = new DownloadCryptoService(driveCrypto, account);
+    const downloadTelemetry = new DownloadTelemetry(telemetry, sharesService);
+
+    async function getFileDownloader(nodeUid: string, signal?: AbortSignal): Promise<FileDownloader> {
+        await queue.waitForCapacity(signal);
+
+        let node, nodeKey;
+        try {
+            node = await nodesService.getNode(nodeUid);
+            nodeKey = await nodesService.getNodeKeys(nodeUid);
+
+            if (node.type === NodeType.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`);
+            }
+            if (!node.activeRevision?.ok || !node.activeRevision.value) {
+                throw new ValidationError(c("Error").t`File has no active revision`);
+            }
+        } catch (error: unknown) {
+            queue.releaseCapacity();
+            void downloadTelemetry.downloadInitFailed(nodeUid, error);
+            throw error;
+        }
+
+        const onFinish = () => queue.releaseCapacity();
+
+        return new FileDownloader(
+            downloadTelemetry,
+            api,
+            cryptoService,
+            {
+                key: nodeKey.key,
+                contentKeyPacketSessionKey: nodeKey.contentKeyPacketSessionKey,
+            },
+            node.activeRevision.value,
+            signal,
+            onFinish,
+        );
+    }
+
+    async function getFileRevisionDownloader(nodeRevisionUid: string, signal?: AbortSignal): Promise<FileDownloader> {
+        await queue.waitForCapacity(signal);
+
+        const nodeUid = makeNodeUidFromRevisionUid(nodeRevisionUid);
+
+        let node, nodeKey, revision;
+        try {
+            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`);
+            }
+            if (!nodeKey.contentKeyPacketSessionKey) {
+                throw new ValidationError(c("Error").t`File has no content key`);
+            }
+        } catch (error: unknown) {
+            queue.releaseCapacity();
+            void downloadTelemetry.downloadInitFailed(nodeUid, error);
+            throw error;
+        }
+
+        const onFinish = () => queue.releaseCapacity();
+
+        return new FileDownloader(
+            downloadTelemetry,
+            api,
+            cryptoService,
+            {
+                key: nodeKey.key,
+                contentKeyPacketSessionKey: nodeKey.contentKeyPacketSessionKey,
+            },
+            revision,
+            signal,
+            onFinish,
+        );
+    }
+
+    async function *iterateThumbnails(
+        nodeUids: string[],
+        thumbnailType?: ThumbnailType,
+        signal?: AbortSignal,
+    ): AsyncGenerator<ThumbnailResult> {
+        const thumbnailDownloader = new ThumbnailDownloader(telemetry, nodesService, api, cryptoService);
+        yield* thumbnailDownloader.iterateThumbnails(nodeUids, thumbnailType, signal);
+    }
+
+    return {
+        getFileDownloader,
+        getFileRevisionDownloader,
+        iterateThumbnails,
+    }
+}

package/src/internal/download/interface.ts

@@ -0,0 +1,38 @@
+import { PrivateKey, PublicKey, SessionKey } from "../../crypto";
+import { NodeType, Result, Revision, MissingNode, MetricContext } from "../../interface";
+import { DecryptedNode } from "../nodes";
+
+export type BlockMetadata = {
+    index: number,
+    bareUrl: string,
+    token: string,
+    base64sha256Hash: string,
+    signatureEmail?: string,
+    armoredSignature?: string,
+};
+
+export type RevisionKeys = {
+    key: PrivateKey,
+    contentKeyPacketSessionKey: SessionKey,
+    verificationKeys?: PublicKey[],
+}
+
+export interface SharesService {
+    getVolumeMetricContext(volumeId: string): Promise<MetricContext>,
+}
+
+export interface NodesService {
+    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>,
+}
+
+export interface RevisionsService {
+    getRevision(nodeRevisionUid: string): Promise<Revision>,
+}

package/src/internal/download/queue.ts

@@ -0,0 +1,30 @@
+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
+ * more performant for many small file downloads.
+ */
+const MAX_CONCURRENT_DOWNLOADS = 5;
+
+export class DownloadQueue {
+    private capacity = 0;
+
+    async waitForCapacity(signal?: AbortSignal) {
+        await waitForCondition(() => this.capacity < MAX_CONCURRENT_DOWNLOADS, signal);
+        this.capacity++;
+    }
+
+    releaseCapacity() {
+        this.capacity--;
+    }
+}

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

@@ -0,0 +1,134 @@
+import { RateLimitedError, ValidationError, DecryptionError, IntegrityError } from '../../errors';
+import { ProtonDriveTelemetry } from '../../interface';
+import { APIHTTPError } from '../apiService';
+import { SharesService } from './interface';
+import { DownloadTelemetry } from './telemetry';
+
+describe('DownloadTelemetry', () => {
+    let mockTelemetry: jest.Mocked<ProtonDriveTelemetry>;
+    let sharesService: jest.Mocked<SharesService>;
+    let downloadTelemetry: DownloadTelemetry;
+
+    const nodeUid = 'volumeId~nodeId';
+    const revisionUid = 'volumeId~nodeId~revisionId';
+
+    beforeEach(() => {
+        mockTelemetry = {
+            logEvent: jest.fn(),
+            getLogger: jest.fn().mockReturnValue({
+                info: jest.fn(),
+                warn: jest.fn(),
+                error: jest.fn(),
+                debug: jest.fn(),
+            }),
+        } as unknown as jest.Mocked<ProtonDriveTelemetry>;
+
+        sharesService = {
+            getVolumeMetricContext: jest.fn().mockResolvedValue('own_volume'),
+        }
+
+        downloadTelemetry = new DownloadTelemetry(mockTelemetry, sharesService);
+    });
+
+    it('should log failure during init (excludes file size)', async () => {
+        await downloadTelemetry.downloadInitFailed(nodeUid, new Error('Failed'));
+
+        expect(mockTelemetry.logEvent).toHaveBeenCalledWith({
+            eventName: "download",
+            context: "own_volume",
+            downloadedSize: 0,
+            error: "unknown",
+        });
+    });
+
+    it('should log failure download', async () => {
+        await downloadTelemetry.downloadFailed(revisionUid, new Error('Failed'), 123, 456);
+
+        expect(mockTelemetry.logEvent).toHaveBeenCalledWith({
+            eventName: "download",
+            context: "own_volume",
+            downloadedSize: 123,
+            claimedFileSize: 456,
+            error: "unknown",
+        });
+    });
+
+    it('should log successful download (excludes error)', async () => {
+        await downloadTelemetry.downloadFinished(revisionUid, 500);
+
+        expect(mockTelemetry.logEvent).toHaveBeenCalledWith({
+            eventName: "download",
+            context: "own_volume",
+            downloadedSize: 500,
+            claimedFileSize: 500,
+        });
+    });
+
+    describe('detect error category', () => {
+        const verifyErrorCategory = (error: string) => {
+            expect(mockTelemetry.logEvent).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    error,
+                })
+            );
+        }
+
+        it('should ignore ValidationError', async () => {
+            const error = new ValidationError('Validation error');
+            await downloadTelemetry.downloadFailed(revisionUid, error, 100, 200);
+            expect(mockTelemetry.logEvent).not.toHaveBeenCalled();
+        });
+    
+        it('should ignore AbortError', async () => {
+            const error = new Error('Aborted');
+            error.name = 'AbortError';
+            await downloadTelemetry.downloadFailed(revisionUid, error, 100, 200);
+    
+            expect(mockTelemetry.logEvent).not.toHaveBeenCalled();
+        });
+
+        it('should detect "rate_limited" error for RateLimitedError', async () => {
+            const error = new RateLimitedError('Rate limited');
+            await downloadTelemetry.downloadFailed(revisionUid, error, 100, 200);
+            verifyErrorCategory('rate_limited');
+        });
+    
+        it('should detect "decryption_error" for DecryptionError', async () => {
+            const error = new DecryptionError('Decryption failed');
+            await downloadTelemetry.downloadFailed(revisionUid, error, 100, 200);
+            verifyErrorCategory('decryption_error');
+        });
+    
+        it('should detect "integrity_error" for IntegrityError', async () => {
+            const error = new IntegrityError('Integrity check failed');
+            await downloadTelemetry.downloadFailed(revisionUid, error, 100, 200);
+            verifyErrorCategory('integrity_error');
+        });
+    
+        it('should detect "4xx" error for APIHTTPError with 4xx status code', async () => {
+            const error = new APIHTTPError('Client error', 404);
+            await downloadTelemetry.downloadFailed(revisionUid, error, 100, 200);
+            verifyErrorCategory('4xx');
+        });
+    
+        it('should detect "5xx" error for APIHTTPError with 5xx status code', async () => {
+            const error = new APIHTTPError('Server error', 500);
+            await downloadTelemetry.downloadFailed(revisionUid, error, 100, 200);
+            verifyErrorCategory('5xx');
+        });
+    
+        it('should detect "server_error" for TimeoutError', async () => {
+            const error = new Error('Timeout');
+            error.name = 'TimeoutError';
+            await downloadTelemetry.downloadFailed(revisionUid, error, 100, 200);
+            verifyErrorCategory('server_error');
+        });
+    
+        it('should detect "network_error" for NetworkError', async () => {
+            const error = new Error('Network error');
+            error.name = 'NetworkError';
+            await downloadTelemetry.downloadFailed(revisionUid, error, 100, 200);
+            verifyErrorCategory('network_error');
+        });
+    });
+});

package/src/internal/download/telemetry.ts

@@ -0,0 +1,115 @@
+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";
+
+export class DownloadTelemetry {
+    private logger: Logger;
+
+    constructor(private telemetry: ProtonDriveTelemetry, private sharesService: SharesService) {
+        this.telemetry = telemetry;
+        this.logger = this.telemetry.getLogger("download");
+        this.sharesService = sharesService;
+    }
+
+    getLoggerForRevision(revisionUid: string) {
+        return new LoggerWithPrefix(this.logger, `revision ${revisionUid}`);
+    }
+
+    async downloadInitFailed(nodeUid: string, error: unknown) {
+        const { volumeId } = splitNodeUid(nodeUid);
+        const errorCategory = getErrorCategory(error);
+
+        // No error category means ignored error from telemetry.
+        // For example, aborted request.
+        if (!errorCategory) {
+            return;
+        }
+
+        await this.sendTelemetry(volumeId, {
+            downloadedSize: 0,
+            error: errorCategory,
+        });
+    }
+
+    async downloadFailed(revisionUid: string, error: unknown, downloadedSize: number, claimedFileSize?: number) {
+        const { volumeId } = splitNodeRevisionUid(revisionUid);
+        const errorCategory = getErrorCategory(error);
+
+        // No error category means ignored error from telemetry.
+        // For example, aborted request.
+        if (!errorCategory) {
+            return;
+        }
+
+        await this.sendTelemetry(volumeId, {
+            downloadedSize,
+            claimedFileSize,
+            error: errorCategory,
+        });
+    }
+
+    async downloadFinished(revisionUid: string, downloadedSize: number) {
+        const { volumeId } = splitNodeRevisionUid(revisionUid);
+        await this.sendTelemetry(volumeId, {
+            downloadedSize,
+            claimedFileSize: downloadedSize,
+        });
+    }
+
+    private async sendTelemetry(volumeId: string, options: {
+        downloadedSize: number,
+        claimedFileSize?: number,
+        error?: MetricsDownloadErrorType,
+    }) {
+        let context;
+        try {
+            context = await this.sharesService.getVolumeMetricContext(volumeId);
+        } catch (error: unknown) {
+            this.logger.error('Failed to get metric context', error);
+        }
+
+        this.telemetry.logEvent({
+            eventName: 'download',
+            context,
+            ...options,
+        });
+    }
+}
+
+function getErrorCategory(error: unknown): MetricsDownloadErrorType | undefined {
+    if (error instanceof ValidationError) {
+        return undefined;
+    }
+    if (error instanceof RateLimitedError) {
+        return 'rate_limited';
+    }
+    if (error instanceof DecryptionError) {
+        return 'decryption_error';
+    }
+    if (error instanceof IntegrityError) {
+        return 'integrity_error';
+    }
+    if (error instanceof APIHTTPError) {
+        if (error.statusCode >= 400 && error.statusCode < 500) {
+            return '4xx';
+        }
+        if (error.statusCode >= 500) {
+            return '5xx';
+        }
+    }
+    if (error instanceof Error) {
+        if (error.name === 'TimeoutError') {
+            return 'server_error';
+        }
+        if (error.name === 'OfflineError' || error.name === 'NetworkError' || error.message?.toLowerCase() === 'network error') {
+            return 'network_error';
+        }
+        if (error.name === 'AbortError') {
+            return undefined;
+        }
+    }
+    return 'unknown';
+}

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

@@ -0,0 +1,226 @@
+import { ProtonDriveTelemetry } from '../../interface';
+import { getMockTelemetry } from "../../tests/telemetry";
+import { ThumbnailDownloader } from './thumbnailDownloader';
+import { DownloadAPIService } from './apiService';
+import { DownloadCryptoService } from './cryptoService';
+import { NodesService } from './interface';
+
+describe('ThumbnailDownloader', () => {
+    let telemetry: ProtonDriveTelemetry;
+    let nodesService: NodesService;
+    let apiService: DownloadAPIService;
+    let cryptoService: DownloadCryptoService;
+    let downloader: ThumbnailDownloader;
+
+    beforeEach(() => {
+        telemetry = getMockTelemetry();
+
+        // @ts-expect-error No need to implement all methods for mocking
+        nodesService = {
+            iterateNodes: jest.fn().mockImplementation(async function* (nodeUids: string[]) {
+                for (const nodeUid of nodeUids) {
+                    yield {
+                        uid: nodeUid,
+                        type: 'file',
+                        activeRevision: {
+                            ok: true,
+                            value: {
+                                thumbnails: [{ type: 1, uid: `thumb-${nodeUid}` }],
+                            },
+                        },
+                    }
+                }
+            }),
+            getNodeKeys: jest.fn().mockReturnValue({
+                contentKeyPacketSessionKey: 'contentKeyPacketSessionKey',
+            }),
+        } as NodesService;
+
+        // @ts-expect-error No need to implement all methods for mocking
+        apiService = {
+            iterateThumbnails: jest.fn().mockImplementation(async function* (thumbnailUids: string[]) {
+                for (const thumbnailUid of thumbnailUids) {
+                    yield {
+                        uid: thumbnailUid,
+                        ok: true,
+                        bareUrl: `url-${thumbnailUid}`,
+                        token: `token-${thumbnailUid}`,
+                    }
+                }
+            }),
+            downloadBlock: jest.fn().mockResolvedValue(new Uint8Array([1, 2, 3])),
+        } as DownloadAPIService;
+
+        // @ts-expect-error No need to implement all methods for mocking
+        cryptoService = {
+            decryptThumbnail: jest.fn().mockImplementation(async (thumbnail: Uint8Array) => thumbnail),
+        } as DownloadCryptoService;
+
+        downloader = new ThumbnailDownloader(telemetry, nodesService, apiService, cryptoService);
+    });
+
+    it('should handle all success cases', async () => {
+        const results = await Array.fromAsync(downloader.iterateThumbnails(['node1', 'node2', 'node3']));
+
+        expect(results).toEqual([
+            { nodeUid: 'node1', ok: true, thumbnail: new Uint8Array([1, 2, 3]) },
+            { nodeUid: 'node2', ok: true, thumbnail: new Uint8Array([1, 2, 3]) },
+            { 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(nodesService.getNodeKeys).toHaveBeenCalledTimes(3);
+        expect(apiService.downloadBlock).toHaveBeenCalledTimes(3);
+        expect(cryptoService.decryptThumbnail).toHaveBeenCalledTimes(3);
+        expect(cryptoService.decryptThumbnail).toHaveBeenCalledWith(new Uint8Array([1, 2, 3]), 'contentKeyPacketSessionKey');
+    });
+
+    it('should handle no requested node', async () => {
+        const results = await Array.fromAsync(downloader.iterateThumbnails([]));
+
+        expect(results).toEqual([]);
+        expect(nodesService.iterateNodes).not.toHaveBeenCalled();
+        expect(apiService.iterateThumbnails).not.toHaveBeenCalled();
+    });
+
+    it('should handle failure when requesting nodes', async () => {
+        nodesService.iterateNodes = jest.fn().mockImplementation(() => {
+            throw new Error('Failed to fetch nodes');
+        });
+
+        const results = Array.fromAsync(downloader.iterateThumbnails(['node1']));
+        await expect(results).rejects.toThrow('Failed to fetch nodes');
+        expect(apiService.iterateThumbnails).not.toHaveBeenCalled();
+    });
+
+    it('should handle missing node', async () => {
+        nodesService.iterateNodes = jest.fn().mockImplementation(async function* () {
+            yield { missingUid: 'node1' };
+        });
+
+        const results = await Array.fromAsync(downloader.iterateThumbnails(['node1']));
+
+        expect(results).toEqual([{ nodeUid: 'node1', ok: false, error: 'Node not found' }]);
+        expect(apiService.iterateThumbnails).not.toHaveBeenCalled();
+    });
+
+    it('should handle node that is not a file', async () => {
+        nodesService.iterateNodes = jest.fn().mockImplementation(async function* () {
+            yield { uid: 'node1', type: 'folder' };
+        });
+
+        const results = await Array.fromAsync(downloader.iterateThumbnails(['node1']));
+
+        expect(results).toEqual([{ nodeUid: 'node1', ok: false, error: 'Node is not a file' }]);
+        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: [] } } };
+        });
+
+        const results = await Array.fromAsync(downloader.iterateThumbnails(['node1']));
+
+        expect(results).toEqual([{ nodeUid: 'node1', ok: false, error: 'Node has no thumbnail' }]);
+        expect(apiService.iterateThumbnails).not.toHaveBeenCalled();
+    });
+
+    it('should handle API failure to provide token for thumbnail', async () => {
+        apiService.iterateThumbnails = jest.fn().mockImplementation(async function* () {
+            yield { uid: 'thumb-node1', ok: false, error: 'Failed to fetch token' };
+        });
+
+        const results = await Array.fromAsync(downloader.iterateThumbnails(['node1']));
+
+        expect(results).toEqual([{ nodeUid: 'node1', ok: false, error: 'Failed to fetch token' }]);
+        expect(apiService.downloadBlock).not.toHaveBeenCalled();
+    });
+
+    it('should handle API providing unexpected thumbnail', async () => {
+        apiService.iterateThumbnails = jest.fn().mockImplementation(async function* () {
+            yield { uid: 'thumb-unexpected', ok: true, thumbnail: new Uint8Array([1, 2, 3]) };
+        });
+
+        const results = await Array.fromAsync(downloader.iterateThumbnails(['node1']));
+
+        expect(results).toEqual([{ nodeUid: 'node1', ok: false, error: 'Thumbnail not found' }]);
+        expect(apiService.downloadBlock).not.toHaveBeenCalled();
+    });
+
+    it('should handle failure when downloading block', async () => {
+        apiService.downloadBlock = jest.fn().mockRejectedValue(new Error('Failed to download thumbnail'));
+
+        const results = await Array.fromAsync(downloader.iterateThumbnails(['node1']));
+
+        expect(results).toEqual([{ nodeUid: 'node1', ok: false, error: 'Failed to download thumbnail' }]);
+        expect(apiService.downloadBlock).toHaveBeenCalledTimes(3);
+    });
+
+    it('should handle one-off failure when downloading block', async () => {
+        let callCount = 0;
+        apiService.downloadBlock = jest.fn().mockImplementation(() => {
+            callCount++;
+            if (callCount === 1) {
+                return Promise.reject(new Error('Failed to download block'));
+            }
+            return Promise.resolve(new Uint8Array([1, 2, 3]));
+        });
+
+        const results = await Array.fromAsync(downloader.iterateThumbnails(['node1']));
+
+        expect(results).toEqual([{ nodeUid: 'node1', ok: true, thumbnail: new Uint8Array([1, 2, 3]) }]);
+        expect(apiService.downloadBlock).toHaveBeenCalledTimes(2);
+    });
+
+    it('should handle failure when getting node keys', async () => {
+        nodesService.getNodeKeys = jest.fn().mockRejectedValue(new Error('Failed to get node keys'));
+
+        const results = await Array.fromAsync(downloader.iterateThumbnails(['node1']));
+
+        expect(results).toEqual([{ nodeUid: 'node1', ok: false, error: 'Failed to get node keys' }]);
+        expect(apiService.downloadBlock).toHaveBeenCalledTimes(3);
+    });
+
+    it('should handle one-off failure when getting node keys', async () => {
+        let callCount = 0;
+        nodesService.getNodeKeys = jest.fn().mockImplementation(() => {
+            callCount++;
+            if (callCount === 1) {
+                return Promise.reject(new Error('Failed to get node keys'));
+            }
+            return Promise.resolve({ contentKeyPacketSessionKey: 'contentKeyPacketSessionKey' });
+        });
+
+        const results = await Array.fromAsync(downloader.iterateThumbnails(['node1']));
+
+        expect(results).toEqual([{ nodeUid: 'node1', ok: true, thumbnail: new Uint8Array([1, 2, 3]) }]);
+        expect(apiService.downloadBlock).toHaveBeenCalledTimes(2);
+    });
+
+    it('should handle failure when decrypting block', async () => {
+        cryptoService.decryptThumbnail = jest.fn().mockRejectedValue(new Error('Failed to decrypt thumbnail'));
+
+        const results = await Array.fromAsync(downloader.iterateThumbnails(['node1']));
+
+        expect(results).toEqual([{ nodeUid: 'node1', ok: false, error: 'Failed to decrypt thumbnail' }]);
+        expect(apiService.downloadBlock).toHaveBeenCalledTimes(3);
+    });
+
+    it('should handle one-off failure when decrypting block', async () => {
+        let callCount = 0;
+        cryptoService.decryptThumbnail = jest.fn().mockImplementation(() => {
+            callCount++;
+            if (callCount === 1) {
+                return Promise.reject(new Error('Failed to decrypt thumbnail'));
+            }
+            return Promise.resolve(new Uint8Array([1, 2, 3]));
+        });
+
+        const results = await Array.fromAsync(downloader.iterateThumbnails(['node1']));
+
+        expect(results).toEqual([{ nodeUid: 'node1', ok: true, thumbnail: new Uint8Array([1, 2, 3]) }]);
+        expect(apiService.downloadBlock).toHaveBeenCalledTimes(2);
+    });
+});