@protontech/drive-sdk 0.0.12 → 0.0.13

package/src/internal/apiService/errors.ts

@@ -14,6 +14,7 @@ export function apiErrorFactory({ response, result }: { response: Response, resu
     const typedResult = result as {
         Code?: number;
         Error?: string;
+        Details?: object;
         exception?: string;
         message?: string;
         file?: string;
@@ -21,7 +22,7 @@ export function apiErrorFactory({ response, result }: { response: Response, resu
         trace?: object;
     };
 
-    const [code, message] = [typedResult.Code || 0, typedResult.Error || c('Error').t`Unknown error`];
+    const [code, message, details] = [typedResult.Code || 0, typedResult.Error || c('Error').t`Unknown error`, typedResult.Details];
 
     const debug = typedResult.exception ? {
         exception: typedResult.exception,
@@ -55,7 +56,7 @@ export function apiErrorFactory({ response, result }: { response: Response, resu
         case ErrorCode.INSUFFICIENT_SHARE_QUOTA:
         case ErrorCode.INSUFFICIENT_SHARE_JOINED_QUOTA:
         case ErrorCode.INSUFFICIENT_BOOKMARKS_QUOTA:
-            return new ValidationError(message, code);
+            return new ValidationError(message, code, details);
         default:
             return new APICodeError(message, code, debug);
     }

package/src/internal/apiService/transformers.ts

@@ -6,6 +6,8 @@ export function nodeTypeNumberToNodeType(logger: Logger, nodeTypeNumber: number)
             return NodeType.Folder;
         case 2:
             return NodeType.File;
+        case 3:
+            return NodeType.Album;
         default:
             logger.warn(`Unknown node type: ${nodeTypeNumber}`);
             return NodeType.File;

package/src/internal/asyncIteratorMap.test.ts

@@ -0,0 +1,150 @@
+import { asyncIteratorMap } from './asyncIteratorMap';
+
+// Helper function to create an async generator from array
+async function* createAsyncGenerator<T>(items: T[]): AsyncGenerator<T> {
+    for (const item of items) {
+        yield item;
+    }
+}
+
+// Helper function to collect all results from async generator
+async function collectResults<T>(asyncGen: AsyncGenerator<T>): Promise<T[]> {
+    const results: T[] = [];
+    for await (const item of asyncGen) {
+        results.push(item);
+    }
+    return results;
+}
+
+describe('asyncIteratorMap', () => {
+    test('works with empty input', async () => {
+        const inputGen = createAsyncGenerator([]);
+        const mapper = async (x: number) => x * 2;
+
+        const mappedGen = asyncIteratorMap(inputGen, mapper);
+        const results = await collectResults(mappedGen);
+
+        expect(results).toEqual([]);
+    });
+
+    test('works with single item', async () => {
+        const inputGen = createAsyncGenerator([42]);
+        const mapper = async (x: number) => x * 2;
+
+        const mappedGen = asyncIteratorMap(inputGen, mapper);
+        const results = await collectResults(mappedGen);
+
+        expect(results).toEqual([84]);
+    });
+
+    test('works with 5 values', async () => {
+        const inputGen = createAsyncGenerator([1, 2, 3, 4, 5]);
+        const mapper = async (x: number) => x * 2;
+
+        const mappedGen = asyncIteratorMap(inputGen, mapper);
+        const results = await collectResults(mappedGen);
+
+        expect(results).toEqual([2, 4, 6, 8, 10]);
+    });
+
+    test('works with slow mapper - finishes as fast as the longest delay', async () => {
+        const delays: { [key: number]: number } = { 1: 100, 2: 50, 3: 200, 4: 30, 5: 80 };
+        const inputGen = createAsyncGenerator(Object.keys(delays).map(Number));
+
+        const slowMapper = async (x: number) => {
+            await new Promise(resolve => setTimeout(resolve, delays[x]));
+            return x * 2;
+        };
+
+        const startTime = Date.now();
+        const mappedGen = asyncIteratorMap(inputGen, slowMapper, 5);
+        const results = await collectResults(mappedGen);
+        const endTime = Date.now();
+
+        // Should complete in roughly the time of the longest delay (200ms) plus some overhead
+        const executionTime = endTime - startTime;
+        expect(executionTime).toBeGreaterThanOrEqual(195); // We had failures with 199ms - JS is not precise.
+        expect(executionTime).toBeLessThan(250);
+
+        // Results should be in the order of the delays
+        expect(results).toEqual([8, 4, 10, 2, 6]);
+    });
+
+    test('handles errors from input iterator properly', async () => {
+        const throwingInputGen = async function*() {
+            yield 1;
+            yield 2;
+            throw new Error('Error providing value: 3');
+        }
+
+        const mapper = async (x: number) => x * 2;
+
+        const mappedGen = asyncIteratorMap(throwingInputGen(), mapper);
+
+        const results: number[] = [];
+        let caughtError: Error | null = null;
+
+        try {
+            for await (const item of mappedGen) {
+                results.push(item);
+            }
+        } catch (error) {
+            caughtError = error as Error;
+        }
+
+        expect(caughtError?.message).toBe('Error providing value: 3');
+        expect(results).toEqual([2, 4]);
+    });
+
+    test('handles errors from mapper properly', async () => {
+        const inputGen = createAsyncGenerator([1, 2, 3, 4, 5]);
+
+        const throwingMapper = async (x: number) => {
+            if (x === 3) {
+                throw new Error(`Error processing value: ${x}`);
+            }
+            return x * 2;
+        };
+
+        const mappedGen = asyncIteratorMap(inputGen, throwingMapper);
+
+        const results: number[] = [];
+        let caughtError: Error | null = null;
+
+        try {
+            for await (const item of mappedGen) {
+                results.push(item);
+            }
+        } catch (error) {
+            caughtError = error as Error;
+        }
+
+        expect(caughtError?.message).toBe('Error processing value: 3');
+        expect(results).toEqual([2, 4]);
+    });
+
+    test('respects concurrency limit', async () => {
+        const inputGen = createAsyncGenerator([1, 2, 3, 4, 5, 6, 7, 8]);
+
+        let concurrentExecutions = 0;
+        let maxConcurrentExecutions = 0;
+
+        const mapper = async (x: number) => {
+            concurrentExecutions++;
+            maxConcurrentExecutions = Math.max(maxConcurrentExecutions, concurrentExecutions);
+
+            // Wait for 100ms to simulate work
+            await new Promise(resolve => setTimeout(resolve, 100));
+
+            concurrentExecutions--;
+            return x * 2;
+        };
+
+        const concurrencyLimit = 3;
+        const mappedGen = asyncIteratorMap(inputGen, mapper, concurrencyLimit);
+        const results = await collectResults(mappedGen);
+
+        expect(maxConcurrentExecutions).toBe(concurrencyLimit);
+        expect(results).toEqual([2, 4, 6, 8, 10, 12, 14, 16]);
+    });
+});

package/src/internal/asyncIteratorMap.ts

@@ -0,0 +1,64 @@
+const DEFAULT_CONCURRENCY = 10;
+
+/**
+ * Maps values from an input iterator and produces a new iterator.
+ * The mapper function is not awaited immediately to allow for parallel
+ * execution. The order of the items in the output iterator is not the
+ * same as the order of the items in the input iterator.
+ *
+ * Any error from the input iterator or the mapper function is propagated
+ * to the output iterator.
+ * 
+ * @param inputIterator - The input async iterator.
+ * @param mapper - The mapper function that maps the input values to output values.
+ * @param concurrency - The concurrency limit. How many parallel async mapper calls are allowed.
+ * @returns An async iterator that yields the mapped values.
+ */
+export async function* asyncIteratorMap<I, O>(
+    inputIterator: AsyncGenerator<I>,
+    mapper: (item: I) => Promise<O>,
+    concurrency: number = DEFAULT_CONCURRENCY,
+): AsyncGenerator<O> {
+    let done = false;
+
+    const executing = new Set<Promise<void>>();
+    const results: Array<Promise<O>> = [];
+
+    const pump = async () => {
+        let next;
+        try {
+            next = await inputIterator.next();
+        } catch (error) {
+            results.push(Promise.reject(error));
+            return;
+        }
+
+        if (next.done) {
+            done = true;
+            return;
+        }
+
+        const promise = mapper(next.value)
+            .then((result) => {
+                results.push(Promise.resolve(result));
+            })
+            .catch((error) => {
+                results.push(Promise.reject(error));
+            });
+        executing.add(promise);
+        void promise.finally(() => executing.delete(promise));
+    };
+
+    while (!done || executing.size > 0 || results.length > 0) {
+        while (!done && executing.size < concurrency) {
+            await pump();
+        }
+
+        if (results.length > 0) {
+            yield await results.shift()!;
+        } else if (executing.size > 0) {
+            // Wait for at least one task to complete
+            await Promise.race(Array.from(executing));
+        }
+    }
+}

package/src/internal/nodes/apiService.test.ts

@@ -44,6 +44,18 @@ function generateAPIFolderNode(linkOverrides = {}, overrides = {}) {
     };
 }
 
+function generateAPIAlbumNode(linkOverrides = {}, overrides = {}) {
+    const node = generateAPINode();
+    return {
+        Link: {
+            ...node.Link,
+            Type: 3,
+            ...linkOverrides,
+        },
+        ...overrides,
+    };
+}
+
 function generateAPINode() {
     return {
         Link: {
@@ -107,6 +119,15 @@ function generateFolderNode(overrides = {}) {
     }
 }
 
+function generateAlbumNode(overrides = {}) {
+    const node = generateNode();
+    return {
+        ...node,
+        type: NodeType.Album,
+        ...overrides
+    }
+}
+
 function generateNode() {
     return {
         hash: "nameHash",
@@ -119,7 +140,7 @@ function generateNode() {
 
         shareId: undefined,
         isShared: false,
-        directMemberRole: MemberRole.Inherited,
+        directMemberRole: MemberRole.Admin,
 
         encryptedCrypto: {
             armoredKey: "nodeKey",
@@ -149,13 +170,13 @@ describe("nodeAPIService", () => {
     });
 
     describe('iterateNodes', () => {
-        async function testIterateNodes(mockedLink: any, expectedNode: any) {
+        async function testIterateNodes(mockedLink: any, expectedNode: any, ownVolumeId = 'volumeId') {
             // @ts-expect-error Mocking for testing purposes
             apiMock.post = jest.fn(async () => Promise.resolve({
                 Links: [mockedLink],
             }));
 
-            const nodes = await Array.fromAsync(api.iterateNodes(['volumeId~nodeId']));
+            const nodes = await Array.fromAsync(api.iterateNodes(['volumeId~nodeId'], ownVolumeId));
             expect(nodes).toStrictEqual([expectedNode]);
         }
     
@@ -180,6 +201,13 @@ describe("nodeAPIService", () => {
             );
         });
 
+        it('should get album node', async () => {
+            await testIterateNodes(
+                generateAPIAlbumNode(),
+                generateAlbumNode(),
+            );
+        });
+
         it('should get shared node', async () => {
             await testIterateNodes(
                 generateAPIFolderNode({}, {
@@ -213,6 +241,7 @@ describe("nodeAPIService", () => {
                     shareId: 'shareId',
                     directMemberRole: MemberRole.Viewer,
                 }),
+                'myVolumeId',
             );
         });
 
@@ -240,7 +269,7 @@ describe("nodeAPIService", () => {
                 ],
             }));
 
-            const generator = api.iterateNodes(['volumeId~nodeId']);
+            const generator = api.iterateNodes(['volumeId~nodeId'], 'volumeId');
 
             const node1 = await generator.next();
             expect(node1.value).toStrictEqual(generateFolderNode());
@@ -272,10 +301,10 @@ describe("nodeAPIService", () => {
                 ],
             }));
 
-            const nodes = await Array.fromAsync(api.iterateNodes(['volumeId1~nodeId1', 'volumeId2~nodeId2']));
+            const nodes = await Array.fromAsync(api.iterateNodes(['volumeId1~nodeId1', 'volumeId2~nodeId2'], 'volumeId1'));
             expect(nodes).toStrictEqual([
-                generateFolderNode({ uid: 'volumeId1~nodeId1', parentUid: 'volumeId1~parentNodeId1' }),
-                generateFolderNode({ uid: 'volumeId2~nodeId2', parentUid: 'volumeId2~parentNodeId2' }),
+                generateFolderNode({ uid: 'volumeId1~nodeId1', parentUid: 'volumeId1~parentNodeId1', directMemberRole: MemberRole.Admin }),
+                generateFolderNode({ uid: 'volumeId2~nodeId2', parentUid: 'volumeId2~parentNodeId2', directMemberRole: MemberRole.Inherited }),
             ]);
         });
     });

package/src/internal/nodes/apiService.ts

@@ -2,7 +2,7 @@ import { c } from "ttag";
 
 import { ProtonDriveError, ValidationError } from "../../errors";
 import { Logger, NodeResult } from "../../interface";
-import { RevisionState } from "../../interface/nodes";
+import { MemberRole, RevisionState } from "../../interface/nodes";
 import { DriveAPIService, drivePaths, isCodeOk, nodeTypeNumberToNodeType, permissionsToDirectMemberRole } from "../apiService";
 import { splitNodeUid, makeNodeUid, makeNodeRevisionUid, splitNodeRevisionUid, makeNodeThumbnailUid } from "../uids";
 import { EncryptedNode, EncryptedRevision, Thumbnail } from "./interface";
@@ -56,15 +56,15 @@ export class NodeAPIService {
         this.apiService = apiService;
     }
 
-    async getNode(nodeUid: string, signal?: AbortSignal): Promise<EncryptedNode> {
-        const nodesGenerator = this.iterateNodes([nodeUid], signal);
+    async getNode(nodeUid: string, ownVolumeId: string, signal?: AbortSignal): Promise<EncryptedNode> {
+        const nodesGenerator = this.iterateNodes([nodeUid], ownVolumeId, signal);
         const result = await nodesGenerator.next();
         await nodesGenerator.return("finish");
         return result.value;
     }
 
     // Improvement requested: split into multiple calls for many nodes.
-    async* iterateNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<EncryptedNode> {
+    async* iterateNodes(nodeUids: string[], ownVolumeId: string, signal?: AbortSignal): AsyncGenerator<EncryptedNode> {
         const allNodeIds = nodeUids.map(splitNodeUid);
 
         const nodeIdsByVolumeId = new Map<string, string[]>();
@@ -81,13 +81,15 @@ export class NodeAPIService {
         const errors = [];
 
         for (const [volumeId, nodeIds] of nodeIdsByVolumeId.entries()) {
+            const isAdmin = volumeId === ownVolumeId;
+
             const response = await this.apiService.post<PostLoadLinksMetadataRequest, PostLoadLinksMetadataResponse>(`drive/v2/volumes/${volumeId}/links`, {
                 LinkIDs: nodeIds,
             }, signal);
 
             for (const link of response.Links) {
                 try {
-                    yield linkToEncryptedNode(this.logger, volumeId, link);
+                    yield linkToEncryptedNode(this.logger, volumeId, link, isAdmin);
                 } catch (error: unknown) {
                     this.logger.error(`Failed to transform node ${link.Link.LinkID}`, error);
                     errors.push(error);
@@ -363,7 +365,7 @@ function* handleResponseErrors(nodeUids: string[], volumeId: string, responses:
     }
 }
 
-function linkToEncryptedNode(logger: Logger, volumeId: string, link: PostLoadLinksMetadataResponse['Links'][0]): EncryptedNode {
+function linkToEncryptedNode(logger: Logger, volumeId: string, link: PostLoadLinksMetadataResponse['Links'][0], isAdmin: boolean): EncryptedNode {
     const baseNodeMetadata = {
         // Internal metadata
         hash: link.Link.NameHash || undefined,
@@ -379,7 +381,7 @@ function linkToEncryptedNode(logger: Logger, volumeId: string, link: PostLoadLin
         // Sharing node metadata
         shareId: link.Sharing?.ShareID || undefined,
         isShared: !!link.Sharing,
-        directMemberRole: permissionsToDirectMemberRole(logger, link.Membership?.Permissions),
+        directMemberRole: isAdmin ? MemberRole.Admin : permissionsToDirectMemberRole(logger, link.Membership?.Permissions),
     }
     const baseCryptoNodeMetadata = {
         signatureEmail: link.Link.SignatureEmail || undefined,
@@ -426,6 +428,15 @@ function linkToEncryptedNode(logger: Logger, volumeId: string, link: PostLoadLin
         }
     }
 
+    if (link.Link.Type === 3) {
+        return {
+            ...baseNodeMetadata,
+            encryptedCrypto: {
+                ...baseCryptoNodeMetadata,
+            },
+        }
+    }
+
     throw new Error(`Unknown node type: ${link.Link.Type}`);
 }
 
@@ -437,6 +448,7 @@ function transformRevisionResponse(
     return {
         uid: makeNodeRevisionUid(volumeId, nodeId, revision.ID),
         state: revision.State === APIRevisionState.Active ? RevisionState.Active : RevisionState.Superseded,
+        // @ts-expect-error: API doc is wrong, CreateTime is not optional.
         creationTime: new Date(revision.CreateTime*1000),
         storageSize: revision.Size,
         signatureEmail: revision.SignatureEmail || undefined,

package/src/internal/nodes/cache.test.ts

@@ -108,6 +108,7 @@ describe('nodesCache', () => {
             creationTime: new Date('2021-01-01'),
             storageSize: 100,
             contentAuthor: resultOk('test@test.com'),
+            claimedModificationTime: new Date('2021-02-01')
         });
         const node = generateNode('node1', '', { activeRevision });
 

package/src/internal/nodes/cache.ts

@@ -261,6 +261,7 @@ function deserialiseRevision(revision: any): Result<DecryptedRevision, Error> {
         return resultOk({
             ...revision.value,
             creationTime: new Date(revision.value.creationTime),
+            claimedModificationTime: new Date(revision.value.claimedModificationTime)
         });
     }
 

package/src/internal/nodes/cryptoService.test.ts

@@ -578,6 +578,44 @@ describe("nodesCryptoService", () => {
         });
     });
 
+    describe("album node", () => {
+        const encryptedNode = {
+            uid: "volumeId~nodeId",
+            parentUid: "volumeId~parentId",
+            encryptedCrypto: {
+                signatureEmail: "signatureEmail",
+                nameSignatureEmail: "nameSignatureEmail",
+                armoredKey: "armoredKey",
+                armoredNodePassphrase: "armoredNodePassphrase",
+                armoredNodePassphraseSignature: "armoredNodePassphraseSignature",
+            },
+        } as EncryptedNode;
+
+        it("should decrypt successfuly", async () => {
+            const result = await cryptoService.decryptNode(encryptedNode, parentKey);
+
+            expect(result).toMatchObject({
+                node: {
+                    name: { ok: true, value: "name" },
+                    keyAuthor: { ok: true, value: "signatureEmail" },
+                    nameAuthor: { ok: true, value: "nameSignatureEmail" },
+                    folder: undefined,
+                    activeRevision: undefined,
+                    errors: undefined,
+                },
+                keys: {
+                    passphrase: "pass",
+                    key: "decryptedKey",
+                    passphraseSessionKey: "passphraseSessionKey",
+                    hashKey: new Uint8Array(),
+                }
+            });
+
+            expect(account.getPublicKeys).toHaveBeenCalledTimes(2);
+            expect(telemetry.logEvent).not.toHaveBeenCalled();
+        });
+    });
+
     describe("anonymous node", () => {
         const encryptedNode = {
             uid: "volumeId~nodeId",

package/src/internal/nodes/index.test.ts

@@ -55,7 +55,9 @@ describe('nodesModules integration tests', () => {
             }),
         }
         // @ts-expect-error No need to implement all methods for mocking
-        sharesService = {}
+        sharesService = {
+            getMyFilesIDs: jest.fn().mockResolvedValue({ volumeId: 'volumeId' }),
+        }
 
         nodesModule = initNodesModule(
             getMockTelemetry(),

package/src/internal/nodes/interface.ts

@@ -30,7 +30,7 @@ interface BaseNode {
  * Outside of the module, the decrypted node interface should be used.
  */
 export interface EncryptedNode extends BaseNode {
-    encryptedCrypto: EncryptedNodeFolderCrypto | EncryptedNodeFileCrypto;
+    encryptedCrypto: EncryptedNodeFolderCrypto | EncryptedNodeFileCrypto | EncryptedNodeAlbumCrypto;
 }
 
 export interface EncryptedNodeCrypto {
@@ -56,6 +56,9 @@ export interface EncryptedNodeFolderCrypto extends EncryptedNodeCrypto {
     };
 }
 
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface EncryptedNodeAlbumCrypto extends EncryptedNodeCrypto {}
+
 /**
  * Interface used only internally in the nodes module.
  *

package/src/internal/nodes/nodesAccess.test.ts

@@ -46,6 +46,7 @@ describe('nodesAccess', () => {
         }
         // @ts-expect-error No need to implement all methods for mocking
         shareService = {
+            getMyFilesIDs: jest.fn().mockResolvedValue({ volumeId: 'volumeId' }),
             getSharePrivateKey: jest.fn(),
         };
 
@@ -81,7 +82,7 @@ describe('nodesAccess', () => {
 
             const result = await access.getNode('nodeId');
             expect(result).toEqual(decryptedNode);
-            expect(apiService.getNode).toHaveBeenCalledWith('nodeId');
+            expect(apiService.getNode).toHaveBeenCalledWith('nodeId', 'volumeId');
             expect(cryptoCache.getNodeKeys).toHaveBeenCalledWith('parentUid');
             expect(cryptoService.decryptNode).toHaveBeenCalledWith(encryptedNode, 'parentKey');
             expect(cache.setNode).toHaveBeenCalledWith(decryptedNode);
@@ -107,7 +108,7 @@ describe('nodesAccess', () => {
 
             const result = await access.getNode('nodeId');
             expect(result).toEqual(decryptedNode);
-            expect(apiService.getNode).toHaveBeenCalledWith('nodeId');
+            expect(apiService.getNode).toHaveBeenCalledWith('nodeId', 'volumeId');
             expect(cryptoCache.getNodeKeys).toHaveBeenCalledWith('parentUid');
             expect(cryptoService.decryptNode).toHaveBeenCalledWith(encryptedNode, 'parentKey');
             expect(cache.setNode).toHaveBeenCalledWith(decryptedNode);
@@ -179,7 +180,7 @@ describe('nodesAccess', () => {
 
                 const result = await Array.fromAsync(access.iterateFolderChildren('parentUid'));
                 expect(result).toMatchObject([node1, node4, node2, node3]);
-                expect(apiService.iterateNodes).toHaveBeenCalledWith(['node2', 'node3'], undefined);
+                expect(apiService.iterateNodes).toHaveBeenCalledWith(['node2', 'node3'], 'volumeId', undefined);
                 expect(cryptoService.decryptNode).toHaveBeenCalledTimes(2);
                 expect(cache.setNode).toHaveBeenCalledTimes(2);
                 expect(cryptoCache.setNodeKeys).toHaveBeenCalledTimes(2);
@@ -218,7 +219,7 @@ describe('nodesAccess', () => {
                 const result = await Array.fromAsync(access.iterateFolderChildren('parentUid'));
                 expect(result).toMatchObject([node1, node2, node3, node4]);
                 expect(apiService.iterateChildrenNodeUids).toHaveBeenCalledWith('parentUid', undefined);
-                expect(apiService.iterateNodes).toHaveBeenCalledWith(['node1', 'node2', 'node3', 'node4'], undefined);
+                expect(apiService.iterateNodes).toHaveBeenCalledWith(['node1', 'node2', 'node3', 'node4'], 'volumeId', undefined);
                 expect(cryptoService.decryptNode).toHaveBeenCalledTimes(4);
                 expect(cache.setNode).toHaveBeenCalledTimes(4);
                 expect(cryptoCache.setNodeKeys).toHaveBeenCalledTimes(4);
@@ -320,7 +321,7 @@ describe('nodesAccess', () => {
                 const result = await Array.fromAsync(access.iterateTrashedNodes());
                 expect(result).toMatchObject([node1, node2, node3, node4]);
                 expect(apiService.iterateTrashedNodeUids).toHaveBeenCalledWith(volumeId, undefined);
-                expect(apiService.iterateNodes).toHaveBeenCalledWith(['node1', 'node2', 'node3', 'node4'], undefined);
+                expect(apiService.iterateNodes).toHaveBeenCalledWith(['node1', 'node2', 'node3', 'node4'], volumeId, undefined);
                 expect(cryptoService.decryptNode).toHaveBeenCalledTimes(4);
                 expect(cache.setNode).toHaveBeenCalledTimes(4);
                 expect(cryptoCache.setNodeKeys).toHaveBeenCalledTimes(4);
@@ -370,7 +371,7 @@ describe('nodesAccess', () => {
 
                 const result = await Array.fromAsync(access.iterateNodes(['node1', 'node2', 'node3', 'node4']));
                 expect(result).toMatchObject([node1, node4, node2, node3]);
-                expect(apiService.iterateNodes).toHaveBeenCalledWith(['node2', 'node3'], undefined);
+                expect(apiService.iterateNodes).toHaveBeenCalledWith(['node2', 'node3'], 'volumeId', undefined);
             });
 
             it('should remove from cache if missing on API and return back to caller', async () => {