@protontech/drive-sdk 0.0.13 → 0.1.1

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

@@ -1,383 +1,87 @@
-import { getMockLogger } from "../../tests/logger";
-import { DriveEventsService, DriveEvent, DriveEventType } from "../events";
-import { NodesEvents, updateCacheByEvent, deleteFromCacheByEvent, notifyListenersByEvent } from "./events";
-import { DecryptedNode } from "./interface";
-import { NodesCache } from "./cache";
-import { NodesAccess } from "./nodesAccess";
+import { getMockLogger } from '../../tests/logger';
+import { DriveEvent, DriveEventType } from '../events';
+import { NodesEventsHandler } from './events';
+import { DecryptedNode } from './interface';
+import { NodesCache } from './cache';
 
-describe("updateCacheByEvent", () => {
+describe('NodesEventsHandler', () => {
     const logger = getMockLogger();
-
     let cache: NodesCache;
+    let nodesEventsNodesEventsHandler: NodesEventsHandler;
 
     beforeEach(() => {
         jest.clearAllMocks();
 
         // @ts-expect-error No need to implement all methods for mocking
         cache = {
-            getNode: jest.fn(() => Promise.resolve({
-                uid: '123',
-                parentUid: 'parentUid',
-                name: { ok: true, value: 'name' },
-            } as DecryptedNode)),
+            getNode: jest.fn(() =>
+                Promise.resolve({
+                    uid: 'nodeUid123',
+                    parentUid: 'parentUid',
+                    name: { ok: true, value: 'name' },
+                } as DecryptedNode),
+            ),
             setNode: jest.fn(),
             removeNodes: jest.fn(),
             resetFolderChildrenLoaded: jest.fn(),
         };
+        nodesEventsNodesEventsHandler = new NodesEventsHandler(logger, cache);
     });
 
-    describe('NodeCreated event', () => {
+    it('should unset the parent listing complete status when a `NodeCreated` event is received.', async () => {
         const event: DriveEvent = {
+            eventId: 'event1',
             type: DriveEventType.NodeCreated,
-            nodeUid: "nodeUid",
-            parentNodeUid: "parentUid",
+            nodeUid: 'nodeUid',
+            parentNodeUid: 'parentUid',
             isTrashed: false,
             isShared: false,
-            isOwnVolume: true,
+            treeEventScopeId: 'volume1',
         };
+        await nodesEventsNodesEventsHandler.updateNodesCacheOnEvent(event);
 
-        it("should not update cache by node create event", async () => {
-            await updateCacheByEvent(logger, event, cache);
-
-            expect(cache.getNode).toHaveBeenCalledTimes(0);
-            expect(cache.setNode).toHaveBeenCalledTimes(0);
-        });
-
-        it("should reset parent loaded state", async () => {
-            await updateCacheByEvent(logger, event, cache);
-
-            expect(cache.resetFolderChildrenLoaded).toHaveBeenCalledWith('parentUid');
-        });
-
-        it("should skip reset parent loaded state if parent missing", async () => {
-            await updateCacheByEvent(logger, { ...event, parentNodeUid: undefined }, cache);
-
-            expect(cache.resetFolderChildrenLoaded).not.toHaveBeenCalled();
-        });
+        expect(cache.resetFolderChildrenLoaded).toHaveBeenCalledTimes(1);
+        expect(cache.resetFolderChildrenLoaded).toHaveBeenCalledWith('parentUid');
+        expect(cache.setNode).toHaveBeenCalledTimes(0);
     });
 
-    describe('NodeUpdated event', () => {
+    it('should update the node metadata when a `NodeUpdated` event is received.', async () => {
         const event: DriveEvent = {
             type: DriveEventType.NodeUpdated,
-            nodeUid: "nodeUid",
-            parentNodeUid: "parentUid",
+            eventId: 'event1',
+            nodeUid: 'nodeUid123',
+            parentNodeUid: 'parentUid',
             isTrashed: false,
             isShared: false,
-            isOwnVolume: true,
-        };
-
-        it("should update cache if present in cache", async () => {
-            await updateCacheByEvent(logger, event, cache);
-
-            expect(cache.getNode).toHaveBeenCalledTimes(1);
-            expect(cache.setNode).toHaveBeenCalledTimes(1);
-            expect(cache.setNode).toHaveBeenCalledWith(expect.objectContaining({ uid: '123', isStale: true, parentUid: "parentUid" }));
-        });
-
-        it("should skip if missing in cache", async () => {
-            cache.getNode = jest.fn(() => Promise.reject(new Error('Missing in the cache')));
-
-            await updateCacheByEvent(logger, event, cache);
-
-            expect(cache.getNode).toHaveBeenCalledTimes(1);
-            expect(cache.setNode).toHaveBeenCalledTimes(0);
-        });
-
-        it("should remove from cache if not possible to set", async () => {
-            cache.setNode = jest.fn(() => Promise.reject(new Error('Cannot set node')));
-
-            await updateCacheByEvent(logger, event, cache);
-
-            expect(cache.getNode).toHaveBeenCalledTimes(1);
-            expect(cache.removeNodes).toHaveBeenCalledTimes(1);
-        });
-
-        it("should throw if remove fails", async () => {
-            cache.setNode = jest.fn(() => Promise.reject(new Error('Cannot set node')));
-            cache.removeNodes = jest.fn(() => Promise.reject(new Error('Cannot remove node')));
-
-            await expect(updateCacheByEvent(logger, event, cache)).rejects.toThrow('Cannot set node');
-        });
-    });
-
-    describe('NodeDeleted event', () => {
-        const event: DriveEvent = {
-            type: DriveEventType.NodeDeleted,
-            nodeUid: "nodeUid",
-            parentNodeUid: "parentUid",
-            isOwnVolume: true,
-        }
-
-        it("should remove node from cache", async () => {
-            await deleteFromCacheByEvent(logger, event, cache);
-
-            expect(cache.removeNodes).toHaveBeenCalledTimes(1);
-            expect(cache.removeNodes).toHaveBeenCalledWith([event.nodeUid]);
-        });
-    });
-});
-
-describe("notifyListenersByEvent", () => {
-    const logger = getMockLogger();
-
-    let cache: NodesCache;
-    let nodesAccess: NodesAccess;
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-
-        // @ts-expect-error No need to implement all methods for mocking
-        cache = {
-            getNode: jest.fn(() => Promise.resolve({
-                uid: '123',
-                parentUid: 'parentUid',
-                name: { ok: true, value: 'name' },
-            } as DecryptedNode)),
+            treeEventScopeId: 'volume1',
         };
-        // @ts-expect-error No need to implement all methods for mocking
-        nodesAccess = {
-            getNode: jest.fn(() => Promise.resolve({ uid: 'nodeUid', name: { ok: true, value: 'name' } } as DecryptedNode)),
-        };
-    });
-
-    describe('update event', () => {
-        it("should notify listeners by parentNodeUid when there is update", async () => {
-            const event: DriveEvent = {
-                type: DriveEventType.NodeUpdated,
-                nodeUid: "nodeUid",
-                parentNodeUid: "parentUid",
-                isTrashed: false,
-                isShared: false,
-                isOwnVolume: true,
-            };
-            const listener = jest.fn();
-    
-            await notifyListenersByEvent(logger, event, [{ condition: ({ parentNodeUid }) => parentNodeUid === 'parentUid', callback: listener }], cache, nodesAccess);
-    
-            expect(listener).toHaveBeenCalledTimes(1);
-            expect(listener).toHaveBeenCalledWith(expect.objectContaining({ type: 'update', uid: 'nodeUid' }));
-            expect(nodesAccess.getNode).toHaveBeenCalledTimes(1);
-            expect(cache.getNode).toHaveBeenCalledTimes(0);
-        });
-
-        it("should notify listeners by parentNodeUid when it is moved to another parent", async () => {
-            const event: DriveEvent = {
-                type: DriveEventType.NodeUpdated,
-                nodeUid: "nodeUid",
-                parentNodeUid: "newParentUid",
-                isTrashed: false,
-                isShared: false,
-                isOwnVolume: true,
-            };
-            const listener = jest.fn();
-    
-            await notifyListenersByEvent(logger, event, [{ condition: ({ parentNodeUid }) => parentNodeUid === 'parentUid', callback: listener }], cache, nodesAccess);
-    
-            expect(listener).toHaveBeenCalledTimes(1);
-            expect(listener).toHaveBeenCalledWith(expect.objectContaining({ type: 'remove', uid: 'nodeUid' }));
-            expect(nodesAccess.getNode).toHaveBeenCalledTimes(0);
-            expect(cache.getNode).toHaveBeenCalledTimes(1);
-        });
-
-        it("should notify listeners by isTrashed when there is update", async () => {
-            const event: DriveEvent = {
-                type: DriveEventType.NodeUpdated,
-                nodeUid: "nodeUid",
-                parentNodeUid: "parentUid",
-                isTrashed: true,
-                isShared: false,
-                isOwnVolume: true,
-            };
-            const listener = jest.fn();
-    
-            await notifyListenersByEvent(logger, event, [{ condition: ({ isTrashed }) => !!isTrashed, callback: listener }], cache, nodesAccess);
-    
-            expect(listener).toHaveBeenCalledTimes(1);
-            expect(listener).toHaveBeenCalledWith(expect.objectContaining({ type: 'update', uid: 'nodeUid' }));
-            expect(nodesAccess.getNode).toHaveBeenCalledTimes(1);
-            expect(cache.getNode).toHaveBeenCalledTimes(0);
-        });
+        await nodesEventsNodesEventsHandler.updateNodesCacheOnEvent(event);
 
-        it("should notify listeners by isTrashed when it is moved out of trash", async () => {
-            cache.getNode = jest.fn(() => Promise.resolve({
-                uid: '123',
+        expect(cache.getNode).toHaveBeenCalledTimes(1);
+        expect(cache.setNode).toHaveBeenCalledTimes(1);
+        expect(cache.setNode).toHaveBeenCalledWith(
+            expect.objectContaining({
+                uid: 'nodeUid123',
+                isStale: true,
                 parentUid: 'parentUid',
-                name: { ok: true, value: 'name' },
-                trashTime: new Date(),
-            } as DecryptedNode));
-            const event: DriveEvent = {
-                type: DriveEventType.NodeUpdated,
-                nodeUid: "nodeUid",
-                parentNodeUid: "parentUid",
-                isTrashed: false,
-                isShared: false,
-                isOwnVolume: true,
-            };
-            const listener = jest.fn();
-    
-            await notifyListenersByEvent(logger, event, [{ condition: ({ isTrashed }) => !!isTrashed, callback: listener }], cache, nodesAccess);
-    
-            expect(listener).toHaveBeenCalledTimes(1);
-            expect(listener).toHaveBeenCalledWith(expect.objectContaining({ type: 'remove', uid: 'nodeUid' }));
-            expect(nodesAccess.getNode).toHaveBeenCalledTimes(0);
-            expect(cache.getNode).toHaveBeenCalledTimes(1);
-        });
-
-        it("should not notify listeners if neither condition match", async () => {
-            const event: DriveEvent = {
-                type: DriveEventType.NodeUpdated,
-                nodeUid: "nodeUid",
-                parentNodeUid: "parentUid",
-                isTrashed: false,
+                trashTime: undefined,
                 isShared: false,
-                isOwnVolume: true,
-            };
-            const listener = jest.fn();
-    
-            await notifyListenersByEvent(logger, event, [{ condition: ({ parentNodeUid }) => parentNodeUid === 'lalalala', callback: listener }], cache, nodesAccess);
-    
-            expect(listener).toHaveBeenCalledTimes(0);
-            expect(nodesAccess.getNode).toHaveBeenCalledTimes(0);
-        });
-    });
-
-    describe('delete event', () => {
-        it("should notify listeners by parentNodeUid", async () => {
-            const event: DriveEvent = {
-                type: DriveEventType.NodeDeleted,
-                nodeUid: "nodeUid",
-                parentNodeUid: "parentUid",
-                isOwnVolume: true,
-            };
-            const listener = jest.fn();
-    
-            await notifyListenersByEvent(logger, event, [{ condition: ({ parentNodeUid }) => parentNodeUid === 'parentUid', callback: listener }], cache, nodesAccess);
-    
-            expect(listener).toHaveBeenCalledTimes(1);
-            expect(listener).toHaveBeenCalledWith({ type: 'remove', uid: 'nodeUid' });
-        });
-
-        it("should notify listeners by isTrashed from cache", async () => {
-            cache.getNode = jest.fn(() => Promise.resolve({ uid: 'nodeUid', trashTime: new Date() } as DecryptedNode));
-            const event: DriveEvent = {
-                type: DriveEventType.NodeDeleted,
-                nodeUid: "nodeUid",
-                parentNodeUid: "parentUid",
-                isOwnVolume: true,
-            };
-    
-            const listener = jest.fn();
-    
-            await notifyListenersByEvent(logger, event, [{ condition: ({ isTrashed }) => !!isTrashed, callback: listener }], cache, nodesAccess);
-    
-            expect(listener).toHaveBeenCalledTimes(1);
-            expect(listener).toHaveBeenCalledWith({ type: 'remove', uid: 'nodeUid' });
-        });
-
-        it("should not notify listeners if cache is missing node", async () => {
-            cache.getNode = jest.fn(() => Promise.reject(new Error('Missing in the cache')));
-            const event: DriveEvent = {
-                type: DriveEventType.NodeDeleted,
-                nodeUid: "nodeUid",
-                parentNodeUid: "parentUid",
-                isOwnVolume: true,
-            };
-            const listener = jest.fn();
-    
-            await notifyListenersByEvent(logger, event, [{ condition: ({ isTrashed }) => !!isTrashed, callback: listener }], cache, nodesAccess);
-    
-            expect(listener).toHaveBeenCalledTimes(0);
-        });
-
-        it("should not notify listeners if neither condition match", async () => {
-            const event: DriveEvent = {
-                type: DriveEventType.NodeDeleted,
-                nodeUid: "nodeUid",
-                parentNodeUid: "parentUid",
-                isOwnVolume: true,
-            };
-            const listener = jest.fn();
-    
-            await notifyListenersByEvent(logger, event, [{ condition: ({ parentNodeUid }) => parentNodeUid === 'lalalala', callback: listener }], cache, nodesAccess);
-    
-            expect(listener).toHaveBeenCalledTimes(0);
-        });
-    });
-});
-
-describe("NodesEvents integration", () => {
-    const logger = getMockLogger();
-
-    let eventsService: DriveEventsService;
-    let eventsServiceCallback;
-    let cache: NodesCache;
-    let nodesAccess: NodesAccess;
-    let listener: jest.Mock;
-    let events: NodesEvents;
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-
-        // @ts-expect-error No need to implement all methods for mocking
-        eventsService = {
-            addListener: jest.fn((callback) => {
-                eventsServiceCallback = callback;
             }),
-        }
-        // @ts-expect-error No need to implement all methods for mocking
-        cache = {
-            getNode: jest.fn(() => Promise.resolve({
-                uid: 'nodeUid',
-                parentUid: 'parentUid',
-                name: { ok: true, value: 'name' },
-                trashTime: new Date(),
-            } as DecryptedNode)),
-            setNode: jest.fn(),
-            removeNodes: jest.fn(),
-        };
-        // @ts-expect-error No need to implement all methods for mocking
-        nodesAccess = {
-            getNode: jest.fn(() => Promise.resolve({
-                uid: 'nodeUid',
-                parentUid: 'parentUid',
-                name: { ok: true, value: 'name' },
-            } as DecryptedNode)),
-        };
-        listener = jest.fn();
-        events = new NodesEvents(logger, eventsService, cache, nodesAccess);
-        events.subscribeToTrashedNodes(listener);
-    });
-
-    it("should send remove to trash listener when node is restored from trash", async () => {
-        await eventsServiceCallback!([{
-            type: DriveEventType.NodeUpdated,
-            nodeUid: "nodeUid",
-            parentNodeUid: "parentUid",
-            isTrashed: false,
-            isShared: false,
-            isOwnVolume: true,
-        } as DriveEvent]);
-
-        expect(listener).toHaveBeenCalledTimes(1);
-        expect(listener).toHaveBeenCalledWith({ type: 'remove', uid: 'nodeUid' });
-        expect(cache.setNode).toHaveBeenCalledTimes(1);
-        expect(cache.setNode).toHaveBeenCalledWith(expect.objectContaining({ uid: 'nodeUid', isStale: true }));
+        );
     });
 
-    it("should send remove to trash listener when node is deleted", async () => {
-        await eventsServiceCallback!([{
+    it('should remove node from cache', async () => {
+        const event: DriveEvent = {
             type: DriveEventType.NodeDeleted,
-            nodeUid: "nodeUid",
-            parentNodeUid: "parentUid",
-            isTrashed: false,
-            isShared: false,
-            isOwnVolume: true,
-        } as DriveEvent]);
+            eventId: 'event1',
+            nodeUid: 'nodeUid123',
+            parentNodeUid: 'parentUid',
+            treeEventScopeId: 'volume1',
+        };
+
+        await nodesEventsNodesEventsHandler.updateNodesCacheOnEvent(event);
 
-        expect(listener).toHaveBeenCalledTimes(1);
-        expect(listener).toHaveBeenCalledWith({ type: 'remove', uid: 'nodeUid' });
-        expect(cache.setNode).toHaveBeenCalledTimes(0);
         expect(cache.removeNodes).toHaveBeenCalledTimes(1);
-        expect(cache.removeNodes).toHaveBeenCalledWith(['nodeUid']);
+        expect(cache.removeNodes).toHaveBeenCalledWith([event.nodeUid]);
     });
 });