@protontech/drive-sdk 0.0.13 → 0.1.1

package/dist/internal/nodes/nodesAccess.test.js

@@ -16,7 +16,7 @@ describe('nodesAccess', () => {
         apiService = {
             getNode: jest.fn(),
             iterateNodes: jest.fn().mockImplementation(async function* (uids) {
-                yield* uids.map((uid => ({ uid, parentUid: 'parentUid' })));
+                yield* uids.map((uid) => ({ uid, parentUid: 'volumeId~parentNodeId' }));
             }),
             iterateChildrenNodeUids: jest.fn(),
         };
@@ -47,88 +47,109 @@ describe('nodesAccess', () => {
     });
     describe('getNode', () => {
         it('should get node from cache', async () => {
-            const node = { uid: 'nodeId', isStale: false };
+            const node = { uid: 'volumeId~nodeId', isStale: false };
             cache.getNode = jest.fn(() => Promise.resolve(node));
-            const result = await access.getNode('nodeId');
+            const result = await access.getNode('volumeId~nodeId');
             expect(result).toBe(node);
             expect(apiService.getNode).not.toHaveBeenCalled();
         });
-        it('should get node from API when cahce is stale', async () => {
-            const encryptedNode = { uid: 'nodeId', parentUid: 'parentUid' };
-            const decryptedUnparsedNode = { uid: 'nodeId', parentUid: 'parentUid', name: { ok: true, value: 'name' } };
+        it('should get node from API when cache is stale', async () => {
+            const encryptedNode = { uid: 'volumeId~nodeId', parentUid: 'volumeId~parentNodeid' };
+            const decryptedUnparsedNode = {
+                uid: 'volumeId~nodeId',
+                parentUid: 'volumeId~parentNodeid',
+                name: { ok: true, value: 'name' },
+            };
             const decryptedNode = {
                 ...decryptedUnparsedNode,
                 name: { ok: true, value: 'name' },
                 isStale: false,
                 activeRevision: undefined,
                 folder: undefined,
+                treeEventScopeId: 'volumeId',
             };
             const decryptedKeys = { key: 'key' };
-            cache.getNode = jest.fn(() => Promise.resolve({ uid: 'nodeId', isStale: true }));
+            cache.getNode = jest.fn(() => Promise.resolve({ uid: 'volumeId~nodeId', isStale: true }));
             apiService.getNode = jest.fn(() => Promise.resolve(encryptedNode));
             cryptoCache.getNodeKeys = jest.fn(() => Promise.resolve({ key: 'parentKey' }));
             cryptoService.decryptNode = jest.fn(() => Promise.resolve({ node: decryptedUnparsedNode, keys: decryptedKeys }));
-            const result = await access.getNode('nodeId');
+            const result = await access.getNode('volumeId~nodeId');
             expect(result).toEqual(decryptedNode);
-            expect(apiService.getNode).toHaveBeenCalledWith('nodeId', 'volumeId');
-            expect(cryptoCache.getNodeKeys).toHaveBeenCalledWith('parentUid');
+            expect(apiService.getNode).toHaveBeenCalledWith('volumeId~nodeId', 'volumeId');
+            expect(cryptoCache.getNodeKeys).toHaveBeenCalledWith('volumeId~parentNodeid');
             expect(cryptoService.decryptNode).toHaveBeenCalledWith(encryptedNode, 'parentKey');
             expect(cache.setNode).toHaveBeenCalledWith(decryptedNode);
-            expect(cryptoCache.setNodeKeys).toHaveBeenCalledWith('nodeId', decryptedKeys);
+            expect(cryptoCache.setNodeKeys).toHaveBeenCalledWith('volumeId~nodeId', decryptedKeys);
         });
         it('should get node from API missing cache', async () => {
-            const encryptedNode = { uid: 'nodeId', parentUid: 'parentUid' };
-            const decryptedUnparsedNode = { uid: 'nodeId', parentUid: 'parentUid', name: { ok: true, value: 'name' } };
+            const encryptedNode = { uid: 'volumeId~nodeId', parentUid: 'volumeId~parentNodeid' };
+            const decryptedUnparsedNode = {
+                uid: 'volumeId~nodeId',
+                parentUid: 'volumeId~parentNodeid',
+                name: { ok: true, value: 'name' },
+            };
             const decryptedNode = {
                 ...decryptedUnparsedNode,
                 name: { ok: true, value: 'name' },
                 isStale: false,
                 activeRevision: undefined,
                 folder: undefined,
+                treeEventScopeId: 'volumeId',
             };
             const decryptedKeys = { key: 'key' };
             cache.getNode = jest.fn(() => Promise.reject(new Error('Entity not found')));
             apiService.getNode = jest.fn(() => Promise.resolve(encryptedNode));
             cryptoCache.getNodeKeys = jest.fn(() => Promise.resolve({ key: 'parentKey' }));
             cryptoService.decryptNode = jest.fn(() => Promise.resolve({ node: decryptedUnparsedNode, keys: decryptedKeys }));
-            const result = await access.getNode('nodeId');
+            const result = await access.getNode('volumeId~nodeId');
             expect(result).toEqual(decryptedNode);
-            expect(apiService.getNode).toHaveBeenCalledWith('nodeId', 'volumeId');
-            expect(cryptoCache.getNodeKeys).toHaveBeenCalledWith('parentUid');
+            expect(apiService.getNode).toHaveBeenCalledWith('volumeId~nodeId', 'volumeId');
+            expect(cryptoCache.getNodeKeys).toHaveBeenCalledWith('volumeId~parentNodeid');
             expect(cryptoService.decryptNode).toHaveBeenCalledWith(encryptedNode, 'parentKey');
             expect(cache.setNode).toHaveBeenCalledWith(decryptedNode);
-            expect(cryptoCache.setNodeKeys).toHaveBeenCalledWith('nodeId', decryptedKeys);
+            expect(cryptoCache.setNodeKeys).toHaveBeenCalledWith('volumeId~nodeId', decryptedKeys);
         });
         it('should validate node name', async () => {
-            const encryptedNode = { uid: 'nodeId', parentUid: 'parentUid' };
-            const decryptedUnparsedNode = { uid: 'nodeId', parentUid: 'parentUid', name: { ok: true, value: 'foo/bar' } };
+            const encryptedNode = { uid: 'volumeId~nodeId', parentUid: 'volumeId~parentNodeid' };
+            const decryptedUnparsedNode = {
+                uid: 'volumeId~nodeId',
+                parentUid: 'volumeId~parentNodeid',
+                name: { ok: true, value: 'foo/bar' },
+            };
             const decryptedNode = {
                 ...decryptedUnparsedNode,
                 name: { ok: false, error: { name: 'foo/bar', error: "Name must not contain the character '/'" } },
+                treeEventScopeId: 'volumeId',
             };
             const decryptedKeys = { key: 'key' };
             cache.getNode = jest.fn(() => Promise.reject(new Error('Entity not found')));
             apiService.getNode = jest.fn(() => Promise.resolve(encryptedNode));
             cryptoCache.getNodeKeys = jest.fn(() => Promise.resolve({ key: 'parentKey' }));
             cryptoService.decryptNode = jest.fn(() => Promise.resolve({ node: decryptedUnparsedNode, keys: decryptedKeys }));
-            const result = await access.getNode('nodeId');
+            const result = await access.getNode('volumeId~nodeId');
             expect(result).toMatchObject(decryptedNode);
         });
     });
     describe('iterate methods', () => {
         beforeEach(() => {
-            cryptoCache.getNodeKeys = jest.fn().mockImplementation((uid) => Promise.resolve({ key: 'key' }));
+            cryptoCache.getNodeKeys = jest
+                .fn()
+                .mockImplementation((uid) => Promise.resolve({ key: 'key' }));
             cryptoService.decryptNode = jest.fn().mockImplementation((encryptedNode) => Promise.resolve({
-                node: { uid: encryptedNode.uid, isStale: false, name: { ok: true, value: 'name' } },
+                node: {
+                    uid: encryptedNode.uid,
+                    isStale: false,
+                    name: { ok: true, value: 'name' },
+                },
                 keys: { key: 'key' },
             }));
         });
         describe('iterateChildren', () => {
-            const parentNode = { uid: 'parentUid', isStale: false };
-            const node1 = { uid: 'node1', isStale: false };
-            const node2 = { uid: 'node2', isStale: false };
-            const node3 = { uid: 'node3', isStale: false };
-            const node4 = { uid: 'node4', isStale: false };
+            const parentNode = { uid: 'volumeId~parentNodeid', isStale: false };
+            const node1 = { uid: 'volumeId~node1', isStale: false };
+            const node2 = { uid: 'volumeId~node2', isStale: false };
+            const node3 = { uid: 'volumeId~node3', isStale: false };
+            const node4 = { uid: 'volumeId~node4', isStale: false };
             beforeEach(() => {
                 cache.getNode = jest.fn().mockResolvedValue(parentNode);
             });
@@ -140,7 +161,7 @@ describe('nodesAccess', () => {
                     yield { ok: true, node: node3 };
                     yield { ok: true, node: node4 };
                 });
-                const result = await Array.fromAsync(access.iterateFolderChildren('parentUid'));
+                const result = await Array.fromAsync(access.iterateFolderChildren('volumeId~parentNodeid'));
                 expect(result).toMatchObject([node1, node2, node3, node4]);
                 expect(apiService.iterateChildrenNodeUids).not.toHaveBeenCalled();
                 expect(apiService.iterateNodes).not.toHaveBeenCalled();
@@ -153,33 +174,33 @@ describe('nodesAccess', () => {
                     yield { ok: true, uid: node3.uid, node: { ...node3, isStale: true } };
                     yield { ok: true, uid: node4.uid, node: node4 };
                 });
-                const result = await Array.fromAsync(access.iterateFolderChildren('parentUid'));
+                const result = await Array.fromAsync(access.iterateFolderChildren('volumeId~parentNodeid'));
                 expect(result).toMatchObject([node1, node4, node2, node3]);
-                expect(apiService.iterateNodes).toHaveBeenCalledWith(['node2', 'node3'], 'volumeId', undefined);
+                expect(apiService.iterateNodes).toHaveBeenCalledWith([node2.uid, node3.uid], 'volumeId', undefined);
                 expect(cryptoService.decryptNode).toHaveBeenCalledTimes(2);
                 expect(cache.setNode).toHaveBeenCalledTimes(2);
                 expect(cryptoCache.setNodeKeys).toHaveBeenCalledTimes(2);
             });
             it('should load children uids and serve nodes from cache', async () => {
                 apiService.iterateChildrenNodeUids = jest.fn().mockImplementation(async function* () {
-                    yield 'node1';
-                    yield 'node2';
-                    yield 'node3';
-                    yield 'node4';
+                    yield node1.uid;
+                    yield node2.uid;
+                    yield node3.uid;
+                    yield node4.uid;
                 });
                 cache.getNode = jest.fn().mockImplementation((uid) => ({ uid, isStale: false }));
-                const result = await Array.fromAsync(access.iterateFolderChildren('parentUid'));
+                const result = await Array.fromAsync(access.iterateFolderChildren('volumeId~parentNodeid'));
                 expect(result).toMatchObject([node1, node2, node3, node4]);
-                expect(apiService.iterateChildrenNodeUids).toHaveBeenCalledWith('parentUid', undefined);
+                expect(apiService.iterateChildrenNodeUids).toHaveBeenCalledWith('volumeId~parentNodeid', undefined);
                 expect(apiService.iterateNodes).not.toHaveBeenCalled();
-                expect(cache.setFolderChildrenLoaded).toHaveBeenCalledWith('parentUid');
+                expect(cache.setFolderChildrenLoaded).toHaveBeenCalledWith('volumeId~parentNodeid');
             });
             it('should load from API', async () => {
                 apiService.iterateChildrenNodeUids = jest.fn().mockImplementation(async function* () {
-                    yield 'node1';
-                    yield 'node2';
-                    yield 'node3';
-                    yield 'node4';
+                    yield node1.uid;
+                    yield node2.uid;
+                    yield node3.uid;
+                    yield node4.uid;
                 });
                 cache.getNode = jest.fn().mockImplementation((uid) => {
                     if (uid === parentNode.uid) {
@@ -187,20 +208,20 @@ describe('nodesAccess', () => {
                     }
                     throw new Error('Entity not found');
                 });
-                const result = await Array.fromAsync(access.iterateFolderChildren('parentUid'));
+                const result = await Array.fromAsync(access.iterateFolderChildren('volumeId~parentNodeid'));
                 expect(result).toMatchObject([node1, node2, node3, node4]);
-                expect(apiService.iterateChildrenNodeUids).toHaveBeenCalledWith('parentUid', undefined);
-                expect(apiService.iterateNodes).toHaveBeenCalledWith(['node1', 'node2', 'node3', 'node4'], 'volumeId', undefined);
+                expect(apiService.iterateChildrenNodeUids).toHaveBeenCalledWith('volumeId~parentNodeid', undefined);
+                expect(apiService.iterateNodes).toHaveBeenCalledWith(['volumeId~node1', 'volumeId~node2', 'volumeId~node3', 'volumeId~node4'], 'volumeId', undefined);
                 expect(cryptoService.decryptNode).toHaveBeenCalledTimes(4);
                 expect(cache.setNode).toHaveBeenCalledTimes(4);
                 expect(cryptoCache.setNodeKeys).toHaveBeenCalledTimes(4);
-                expect(cache.setFolderChildrenLoaded).toHaveBeenCalledWith('parentUid');
+                expect(cache.setFolderChildrenLoaded).toHaveBeenCalledWith('volumeId~parentNodeid');
             });
             it('should remove from cache if missing on API', async () => {
                 apiService.iterateChildrenNodeUids = jest.fn().mockImplementation(async function* () {
-                    yield 'node1';
-                    yield 'node2';
-                    yield 'node3';
+                    yield node1.uid;
+                    yield node2.uid;
+                    yield node3.uid;
                 });
                 cache.getNode = jest.fn().mockImplementation((uid) => {
                     if (uid === parentNode.uid) {
@@ -212,15 +233,15 @@ describe('nodesAccess', () => {
                     // Skip first node - make it missing.
                     yield* uids.slice(1).map((uid) => ({ uid, parentUid: parentNode.uid }));
                 });
-                const result = await Array.fromAsync(access.iterateFolderChildren('parentUid'));
+                const result = await Array.fromAsync(access.iterateFolderChildren('volumeId~parentNodeid'));
                 expect(result).toMatchObject([node2, node3]);
-                expect(cache.removeNodes).toHaveBeenCalledWith(['node1']);
+                expect(cache.removeNodes).toHaveBeenCalledWith([node1.uid]);
             });
             it('should yield all decryptable children before throwing error', async () => {
                 apiService.iterateChildrenNodeUids = jest.fn().mockImplementation(async function* () {
-                    yield 'node1';
-                    yield 'node2';
-                    yield 'node3';
+                    yield 'volumeId~node1';
+                    yield 'volumeId~node2';
+                    yield 'volumeId~node3';
                 });
                 cache.getNode = jest.fn().mockImplementation((uid) => {
                     if (uid === parentNode.uid) {
@@ -229,37 +250,39 @@ describe('nodesAccess', () => {
                     throw new Error('Entity not found');
                 });
                 cryptoService.decryptNode = jest.fn().mockImplementation((encryptedNode) => {
-                    if (encryptedNode.uid === 'node2') {
+                    if (encryptedNode.uid === 'volumeId~node2') {
                         throw new errors_1.DecryptionError('Decryption failed');
                     }
                     return Promise.resolve({
-                        node: { uid: encryptedNode.uid, isStale: false, name: { ok: true, value: 'name' } },
+                        node: {
+                            uid: encryptedNode.uid,
+                            isStale: false,
+                            name: { ok: true, value: 'name' },
+                        },
                         keys: { key: 'key' },
                     });
                 });
-                const generator = access.iterateFolderChildren('parentUid');
+                const generator = access.iterateFolderChildren('volumeId~parentNodeid');
                 const node1 = await generator.next();
-                expect(node1.value).toMatchObject({ uid: 'node1' });
+                expect(node1.value).toMatchObject({ uid: 'volumeId~node1' });
                 const node2 = await generator.next();
-                expect(node2.value).toMatchObject({ uid: 'node3' });
+                expect(node2.value).toMatchObject({ uid: 'volumeId~node3' });
                 const node3 = generator.next();
                 await expect(node3).rejects.toThrow('Failed to decrypt some nodes');
                 try {
                     await node3;
                 }
                 catch (error) {
-                    expect(error.cause).toEqual([
-                        new errors_1.DecryptionError('Decryption failed'),
-                    ]);
+                    expect(error.cause).toEqual([new errors_1.DecryptionError('Decryption failed')]);
                 }
             });
         });
         describe('iterateTrashedNodes', () => {
             const volumeId = 'volumeId';
-            const node1 = { uid: 'node1', isStale: false };
-            const node2 = { uid: 'node2', isStale: false };
-            const node3 = { uid: 'node3', isStale: false };
-            const node4 = { uid: 'node4', isStale: false };
+            const node1 = { uid: 'volumeId~node1', isStale: false };
+            const node2 = { uid: 'volumeId~node2', isStale: false };
+            const node3 = { uid: 'volumeId~node3', isStale: false };
+            const node4 = { uid: 'volumeId~node4', isStale: false };
             beforeEach(() => {
                 shareService.getMyFilesIDs = jest.fn().mockResolvedValue({ volumeId });
                 apiService.iterateTrashedNodeUids = jest.fn().mockImplementation(async function* () {
@@ -283,7 +306,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'], volumeId, undefined);
+                expect(apiService.iterateNodes).toHaveBeenCalledWith(['volumeId~node1', 'volumeId~node2', 'volumeId~node3', 'volumeId~node4'], volumeId, undefined);
                 expect(cryptoService.decryptNode).toHaveBeenCalledTimes(4);
                 expect(cache.setNode).toHaveBeenCalledTimes(4);
                 expect(cryptoCache.setNodeKeys).toHaveBeenCalledTimes(4);
@@ -294,18 +317,18 @@ describe('nodesAccess', () => {
                 });
                 apiService.iterateNodes = jest.fn().mockImplementation(async function* (uids) {
                     // Skip first node - make it missing.
-                    yield* uids.slice(1).map((uid) => ({ uid, parentUid: 'parentUid' }));
+                    yield* uids.slice(1).map((uid) => ({ uid, parentUid: 'volumeId~parentNodeid' }));
                 });
                 const result = await Array.fromAsync(access.iterateTrashedNodes());
                 expect(result).toMatchObject([node2, node3, node4]);
-                expect(cache.removeNodes).toHaveBeenCalledWith(['node1']);
+                expect(cache.removeNodes).toHaveBeenCalledWith(['volumeId~node1']);
             });
         });
         describe('iterateNodes', () => {
-            const node1 = { uid: 'node1', isStale: false };
-            const node2 = { uid: 'node2', isStale: false };
-            const node3 = { uid: 'node3', isStale: false };
-            const node4 = { uid: 'node4', isStale: false };
+            const node1 = { uid: 'volumeId~node1', isStale: false, treeEventScopeId: 'volumeId' };
+            const node2 = { uid: 'volumeId~node2', isStale: false, treeEventScopeId: 'volumeId' };
+            const node3 = { uid: 'volumeId~node3', isStale: false, treeEventScopeId: 'volumeId' };
+            const node4 = { uid: 'volume~node4', isStale: false, treeEventScopeId: 'volumeId' };
             it('should serve fully from cache', async () => {
                 cache.iterateNodes = jest.fn().mockImplementation(async function* () {
                     yield { ok: true, node: node1 };
@@ -313,70 +336,79 @@ describe('nodesAccess', () => {
                     yield { ok: true, node: node3 };
                     yield { ok: true, node: node4 };
                 });
-                const result = await Array.fromAsync(access.iterateNodes(['node1', 'node2', 'node3', 'node4']));
+                const result = await Array.fromAsync(access.iterateNodes(['volumeId~node1', 'volumeId~node2', 'volumeId~node3', 'volumeId~node4']));
                 expect(result).toMatchObject([node1, node2, node3, node4]);
                 expect(apiService.iterateNodes).not.toHaveBeenCalled();
             });
             it('should load from API', async () => {
                 cache.iterateNodes = jest.fn().mockImplementation(async function* () {
                     yield { ok: true, node: node1 };
-                    yield { ok: false, uid: 'node2' };
-                    yield { ok: false, uid: 'node3' };
+                    yield { ok: false, uid: 'volumeId~node2' };
+                    yield { ok: false, uid: 'volumeId~node3' };
                     yield { ok: true, node: node4 };
                 });
-                const result = await Array.fromAsync(access.iterateNodes(['node1', 'node2', 'node3', 'node4']));
+                const result = await Array.fromAsync(access.iterateNodes(['volumeId~node1', 'volumeId~node2', 'volumeId~node3', 'volumeId~node4']));
                 expect(result).toMatchObject([node1, node4, node2, node3]);
-                expect(apiService.iterateNodes).toHaveBeenCalledWith(['node2', 'node3'], 'volumeId', undefined);
+                expect(apiService.iterateNodes).toHaveBeenCalledWith(['volumeId~node2', 'volumeId~node3'], 'volumeId', undefined);
             });
             it('should remove from cache if missing on API and return back to caller', async () => {
                 cache.iterateNodes = jest.fn().mockImplementation(async function* () {
-                    yield { ok: false, uid: 'node1' };
-                    yield { ok: false, uid: 'node2' };
-                    yield { ok: false, uid: 'node3' };
+                    yield { ok: false, uid: 'volumeId~node1' };
+                    yield { ok: false, uid: 'volumeId~node2' };
+                    yield { ok: false, uid: 'volumeId~node3' };
                 });
                 apiService.iterateNodes = jest.fn().mockImplementation(async function* (uids) {
                     // Skip first node - make it missing.
-                    yield* uids.slice(1).map((uid) => ({ uid, parentUid: 'parentUid' }));
+                    yield* uids.slice(1).map((uid) => ({ uid, parentUid: 'volumeId~parentNodeid' }));
                 });
-                const result = await Array.fromAsync(access.iterateNodes(['node1', 'node2', 'node3']));
-                expect(result).toMatchObject([node2, node3, { missingUid: 'node1' }]);
-                expect(cache.removeNodes).toHaveBeenCalledWith(['node1']);
+                const result = await Array.fromAsync(access.iterateNodes(['volumeId~node1', 'volumeId~node2', 'volumeId~node3']));
+                expect(result).toMatchObject([node2, node3, { missingUid: 'volumeId~node1' }]);
+                expect(cache.removeNodes).toHaveBeenCalledWith(['volumeId~node1']);
             });
             it('should return degraded node if parent cannot be decrypted', async () => {
                 cache.iterateNodes = jest.fn().mockImplementation(async function* () {
-                    yield { ok: false, uid: 'node1' };
-                    yield { ok: false, uid: 'node2' };
-                    yield { ok: false, uid: 'node3' };
+                    yield { ok: false, uid: 'volumeId~node1' };
+                    yield { ok: false, uid: 'volumeId~node2' };
+                    yield { ok: false, uid: 'volumeId~node3' };
                 });
                 const encryptedCrypto = {
                     signatureEmail: 'signatureEmail',
                     nameSignatureEmail: 'nameSignatureEmail',
                 };
                 apiService.iterateNodes = jest.fn().mockImplementation(async function* (uids) {
-                    yield* uids.map((uid) => ({
-                        uid,
-                        parentUid: `parentUidFor:${uid}`,
-                        encryptedCrypto,
-                    }));
+                    yield* uids.map((uid) => {
+                        const parentUid = uid.replace('node', 'parentOfNode');
+                        return {
+                            uid,
+                            parentUid,
+                            encryptedCrypto,
+                        };
+                    });
                 });
                 const decryptionError = new errors_1.DecryptionError('Parent cannot be decrypted');
                 jest.spyOn(access, 'getParentKeys').mockImplementation(async ({ parentUid }) => {
-                    if (parentUid === 'parentUidFor:node1') {
+                    if (parentUid === 'volumeId~parentOfNode1') {
                         throw decryptionError;
                     }
                     return {
                         key: { _idx: 32132 },
                     };
                 });
-                const result = await Array.fromAsync(access.iterateNodes(['node1', 'node2', 'node3']));
+                const result = await Array.fromAsync(access.iterateNodes(['volumeId~node1', 'volumeId~node2', 'volumeId~node3']));
                 expect(result).toEqual([
                     {
                         ...node1,
                         encryptedCrypto,
-                        parentUid: 'parentUidFor:node1',
+                        parentUid: 'volumeId~parentOfNode1',
                         name: { ok: false, error: decryptionError },
-                        keyAuthor: { ok: false, error: { claimedAuthor: 'signatureEmail', error: decryptionError.message } },
-                        nameAuthor: { ok: false, error: { claimedAuthor: 'nameSignatureEmail', error: decryptionError.message } },
+                        keyAuthor: {
+                            ok: false,
+                            error: { claimedAuthor: 'signatureEmail', error: decryptionError.message },
+                        },
+                        nameAuthor: {
+                            ok: false,
+                            error: { claimedAuthor: 'nameSignatureEmail', error: decryptionError.message },
+                        },
                         errors: [decryptionError],
                     },
                     {
@@ -404,13 +436,13 @@ describe('nodesAccess', () => {
         });
         it('should get node parent keys', async () => {
             cryptoCache.getNodeKeys = jest.fn(() => Promise.resolve({ key: 'parentKey' }));
-            const result = await access.getParentKeys({ shareId: undefined, parentUid: 'parentUid' });
+            const result = await access.getParentKeys({ shareId: undefined, parentUid: 'volumeId~parentNodeid' });
             expect(result).toEqual({ key: 'parentKey' });
             expect(shareService.getSharePrivateKey).not.toHaveBeenCalled();
         });
         it('should get node parent keys even if share is set', async () => {
             cryptoCache.getNodeKeys = jest.fn(() => Promise.resolve({ key: 'parentKey' }));
-            const result = await access.getParentKeys({ shareId: 'shareId', parentUid: 'parentUid' });
+            const result = await access.getParentKeys({ shareId: 'shareId', parentUid: 'volume1~parentNodeid' });
             expect(result).toEqual({ key: 'parentKey' });
             expect(shareService.getSharePrivateKey).not.toHaveBeenCalled();
         });
@@ -420,7 +452,7 @@ describe('nodesAccess', () => {
             cryptoCache.getNodeKeys = jest.fn(() => Promise.reject(new Error('Entity not found')));
             apiService.getNode = jest.fn(() => Promise.reject(new Error('API called')));
             try {
-                await access.getNodeKeys('nodeId');
+                await access.getNodeKeys('volumeId~nodeId');
                 throw new Error('Expected error');
             }
             catch (error) {
@@ -433,7 +465,7 @@ describe('nodesAccess', () => {
             const nodeUid = 'nodeUid';
             const node = {
                 uid: nodeUid,
-                parentUid: 'parentUid',
+                parentUid: 'volume1~parentNodeid',
                 encryptedName: 'encryptedName',
             };
             jest.spyOn(access, 'getNode').mockResolvedValue(node);
@@ -484,5 +516,37 @@ describe('nodesAccess', () => {
             expect(result).toBe('https://drive.proton.me/shareId/folder/nodeId');
         });
     });
+    describe('notifyNodeChanged', () => {
+        it('should mark node as stale', async () => {
+            const node = { uid: 'volumeId~nodeId', isStale: false };
+            cache.getNode = jest.fn(() => Promise.resolve(node));
+            cache.setNode = jest.fn();
+            await access.notifyNodeChanged(node.uid);
+            expect(cache.getNode).toHaveBeenCalledWith(node.uid);
+            expect(cache.setNode).toHaveBeenCalledWith({ ...node, isStale: true });
+        });
+        it('should update parent if needed', async () => {
+            const node = { uid: 'volumeId~nodeId', parentUid: 'v1~pn1', isStale: false };
+            cache.getNode = jest.fn(() => Promise.resolve(node));
+            cache.setNode = jest.fn();
+            await access.notifyNodeChanged(node.uid, 'v1~pn2');
+            expect(cache.getNode).toHaveBeenCalledWith(node.uid);
+            expect(cache.setNode).toHaveBeenCalledWith({ ...node, parentUid: 'v1~pn2', isStale: true });
+        });
+    });
+    describe('notifyChildCreated', () => {
+        it('should reset parent listing', async () => {
+            const nodeUid = 'VolumeId1~NodeId1';
+            cache.resetFolderChildrenLoaded = jest.fn();
+            await access.notifyChildCreated(nodeUid);
+            expect(cache.resetFolderChildrenLoaded).toHaveBeenCalledWith(nodeUid);
+        });
+    });
+    describe('notifyNodeDeleted', () => {
+        it('should reset parent listing', async () => {
+            await access.notifyNodeDeleted('v1~n1');
+            expect(cache.removeNodes).toHaveBeenCalledWith(['v1~n1']);
+        });
+    });
 });
 //# sourceMappingURL=nodesAccess.test.js.map