@protontech/drive-sdk 0.0.13 → 0.1.0

package/src/internal/events/apiService.ts

@@ -1,31 +1,32 @@
-import { Logger } from "../../interface";
 import { DriveAPIService, drivePaths, corePaths } from "../apiService";
 import { makeNodeUid } from "../uids";
-import { DriveEvents, DriveEvent, DriveEventType } from "./interface";
+import { DriveEventsListWithStatus, DriveEvent, DriveEventType, NodeEvent, NodeEventType } from "./interface";
 
 type GetCoreLatestEventResponse = corePaths['/core/{_version}/events/latest']['get']['responses']['200']['content']['application/json'];
 type GetCoreEventResponse = corePaths['/core/{_version}/events/{id}']['get']['responses']['200']['content']['application/json'];
 
 type GetVolumeLatestEventResponse = drivePaths['/drive/volumes/{volumeID}/events/latest']['get']['responses']['200']['content']['application/json'];
-type GetVokumeEventResponse = drivePaths['/drive/v2/volumes/{volumeID}/events/{eventID}']['get']['responses']['200']['content']['application/json'];
+type GetVolumeEventResponse = drivePaths['/drive/v2/volumes/{volumeID}/events/{eventID}']['get']['responses']['200']['content']['application/json'];
 
-const VOLUME_EVENT_TYPE_MAP = {
+interface VolumeEventTypeMap {
+    [key: number]: NodeEventType,
+}
+const VOLUME_EVENT_TYPE_MAP: VolumeEventTypeMap = {
     0: DriveEventType.NodeDeleted,
     1: DriveEventType.NodeCreated,
     2: DriveEventType.NodeUpdated,
-    3: DriveEventType.NodeUpdatedMetadata,
+    3: DriveEventType.NodeUpdated,
 }
 
 /**
  * Provides API communication for fetching events.
- * 
+ *
  * The service is responsible for transforming local objects to API payloads
  * and vice versa. It should not contain any business logic.
  */
 export class EventsAPIService {
-    constructor(private apiService: DriveAPIService, private logger?: Logger) {
+    constructor(private apiService: DriveAPIService) {
         this.apiService = apiService;
-        this.logger = logger;
     }
 
     async getCoreLatestEventId(): Promise<string> {
@@ -33,17 +34,19 @@ export class EventsAPIService {
         return result.EventID as string;
     }
 
-    async getCoreEvents(eventId: string): Promise<DriveEvents> {
-        // TODO: Switch to v6 endpoint: DriveShareRefresh doesnt seem to be part of it.
+    async getCoreEvents(eventId: string): Promise<DriveEventsListWithStatus> {
+        // TODO: Switch to v6 endpoint?
         const result = await this.apiService.get<GetCoreEventResponse>(`core/v5/events/${eventId}`);
-        const events: DriveEvent[] = result.DriveShareRefresh?.Action === 2 ? [
-            {
-                type: DriveEventType.ShareWithMeUpdated,
-            }
-        ] : [];
+        // in core/v5/events, refresh is always all apps, value 255
+        const refresh = result.Refresh > 0;
+        const events: DriveEvent[] = (refresh || result.DriveShareRefresh?.Action === 2) ? [{
+            type: DriveEventType.SharedWithMeUpdated,
+            eventId: result.EventID,
+            treeEventScopeId: 'core',
+        }] : [];
 
         return {
-            lastEventId: result.EventID,
+            latestEventId: result.EventID,
             more: result.More === 1,
             refresh: result.Refresh === 1,
             events,
@@ -55,31 +58,25 @@ export class EventsAPIService {
         return result.EventID;
     }
 
-    async getVolumeEvents(volumeId: string, eventId: string, isOwnVolume = false): Promise<DriveEvents> {
-        const result = await this.apiService.get<GetVokumeEventResponse>(`drive/v2/volumes/${volumeId}/events/${eventId}`);
+    async getVolumeEvents(volumeId: string, eventId: string): Promise<DriveEventsListWithStatus> {
+        const result = await this.apiService.get<GetVolumeEventResponse>(`drive/v2/volumes/${volumeId}/events/${eventId}`);
         return {
-            lastEventId: result.EventID,
+            latestEventId: result.EventID,
             more: result.More,
             refresh: result.Refresh,
-            events: result.Events.map((event): DriveEvent => {
+            events: result.Events.map((event): NodeEvent => {
                 const type = VOLUME_EVENT_TYPE_MAP[event.EventType];
                 const uids = {
                     nodeUid: makeNodeUid(volumeId, event.Link.LinkID),
                     parentNodeUid: makeNodeUid(volumeId, event.Link.ParentLinkID as string),
                 }
-                // VOLUME_EVENT_TYPE_MAP will never return this event type.
-                // It is here to satisfy the type checker. It is safe to do.
-                if (type === DriveEventType.ShareWithMeUpdated) {
-                    return {
-                        type,
-                    };
-                }
                 return {
                     type,
                     ...uids,
                     isTrashed: event.Link.IsTrashed,
                     isShared: event.Link.IsShared,
-                    isOwnVolume,
+                    eventId: event.EventID,
+                    treeEventScopeId: volumeId,
                 };
             }),
         };

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

@@ -0,0 +1,101 @@
+import { getMockLogger } from "../../tests/logger";
+import { EventsAPIService } from "./apiService";
+import { DriveEvent, DriveEventsListWithStatus, DriveEventType } from "./interface";
+import { CoreEventManager } from "./coreEventManager";
+
+describe("CoreEventManager", () => {
+    let mockApiService: jest.Mocked<EventsAPIService>;
+    let coreEventManager: CoreEventManager;
+    const mockLogger = getMockLogger();
+
+    beforeEach(() => {
+        // Reset mocks
+        jest.clearAllMocks();
+
+        mockApiService = {
+            getCoreLatestEventId: jest.fn(),
+            getCoreEvents: jest.fn(),
+            getVolumeLatestEventId: jest.fn(),
+            getVolumeEvents: jest.fn(),
+        } as unknown as jest.Mocked<EventsAPIService>;
+
+        coreEventManager = new CoreEventManager(mockLogger, mockApiService);
+    });
+
+    describe("getLatestEventId", () => {
+        it("should return the latest event ID from API service", async () => {
+            const expectedEventId = "event-123";
+            mockApiService.getCoreLatestEventId.mockResolvedValue(expectedEventId);
+
+            const result = await coreEventManager.getLatestEventId();
+
+            expect(result).toBe(expectedEventId);
+            expect(mockApiService.getCoreLatestEventId).toHaveBeenCalledTimes(1);
+        });
+
+        it("should handle API service errors", async () => {
+            const error = new Error("API error");
+            mockApiService.getCoreLatestEventId.mockRejectedValue(error);
+
+            await expect(coreEventManager.getLatestEventId()).rejects.toThrow("API error");
+            expect(mockApiService.getCoreLatestEventId).toHaveBeenCalledTimes(1);
+        });
+    });
+
+    describe("getEvents", () => {
+        const eventId = "event1";
+        const latestEventId = "event2";
+
+        it("should yield ShareWithMeUpdated event when refresh is true", async () => {
+            const mockEvents: DriveEventsListWithStatus = {
+                latestEventId,
+                more: false,
+                refresh: true,
+                events: [],
+            };
+            mockApiService.getCoreEvents.mockResolvedValue(mockEvents);
+
+            const events = [];
+            for await (const event of coreEventManager.getEvents(eventId)) {
+                events.push(event);
+            }
+
+            expect(events).toHaveLength(1);
+            expect(events[0]).toEqual({
+                type: DriveEventType.SharedWithMeUpdated,
+                treeEventScopeId: 'core',
+                eventId: latestEventId,
+            });
+            expect(mockApiService.getCoreEvents).toHaveBeenCalledWith(eventId);
+        });
+
+        it("should yield all events when there are actual events", async () => {
+            const mockEvent1: DriveEvent = {
+                type: DriveEventType.SharedWithMeUpdated,
+                eventId: "event-1",
+                treeEventScopeId: 'core',
+            };
+            const mockEvent2: DriveEvent = {
+                type: DriveEventType.SharedWithMeUpdated,
+                eventId: "event-2",
+                treeEventScopeId: 'core',
+            };
+            const mockEvents: DriveEventsListWithStatus = {
+                latestEventId,
+                more: false,
+                refresh: false,
+                events: [mockEvent1, mockEvent2],
+            };
+            mockApiService.getCoreEvents.mockResolvedValue(mockEvents);
+
+            const events = [];
+            for await (const event of coreEventManager.getEvents(eventId)) {
+                events.push(event);
+            }
+
+            expect(events).toHaveLength(2);
+            expect(events[0]).toEqual(mockEvent1);
+            expect(events[1]).toEqual(mockEvent2);
+        });
+    });
+});

package/src/internal/events/coreEventManager.ts

@@ -1,9 +1,7 @@
 import { Logger } from "../../interface";
 import { LoggerWithPrefix } from "../../telemetry";
 import { EventsAPIService } from "./apiService";
-import { EventsCache } from "./cache";
-import { DriveEvent, DriveEventType } from "./interface";
-import { EventManager } from "./eventManager";
+import { DriveEvent, DriveEventType, EventManagerInterface } from "./interface";
 
 /**
  * Combines API and event manager to provide a service for listening to
@@ -11,59 +9,36 @@ import { EventManager } from "./eventManager";
  * At this moment, Drive listenes only to shares with me updates from core
  * events. Such even indicates that user was invited to the new share or
  * that user's membership was removed from existing one and lost access.
- * 
+ *
  * The client might be already using own core events, thus this service
  * is here only in case the client is not connected to the Proton services
  * with own implementation.
  */
-export class CoreEventManager {
-    private manager: EventManager<DriveEvent>;
-
-    constructor(logger: Logger, private apiService: EventsAPIService, private cache: EventsCache) {
+export class CoreEventManager implements EventManagerInterface<DriveEvent> {
+    constructor(private logger: Logger, private apiService: EventsAPIService) {
         this.apiService = apiService;
 
-        this.manager = new EventManager(
-            new LoggerWithPrefix(logger, `core`),
-            () => this.getLastEventId(),
-            (eventId) => this.apiService.getCoreEvents(eventId),
-            (lastEventId) => this.cache.setLastEventId('core', {
-                lastEventId,
-                pollingIntervalInSeconds: this.manager.pollingIntervalInSeconds,
-                isOwnVolume: false,
-            }),
-        );
+        this.logger = new LoggerWithPrefix(logger, `core`);
     }
 
-    private async getLastEventId(): Promise<string> {
-        const lastEventId = await this.cache.getLastEventId('core');
-        if (lastEventId) {
-            return lastEventId;
-        }
-        return this.apiService.getCoreLatestEventId();
+    async getLatestEventId(): Promise<string> {
+        return await this.apiService.getCoreLatestEventId();
     }
 
-    async startSubscription(): Promise<void> {
-        await this.manager.start();
-    }
-
-    async stopSubscription(): Promise<void> {
-        await this.manager.stop();
+    async * getEvents(eventId: string): AsyncIterable<DriveEvent> {
+        const events = await this.apiService.getCoreEvents(eventId);
+        if (events.events.length === 0 && events.latestEventId !== eventId) {
+            yield {
+                type: DriveEventType.SharedWithMeUpdated,
+                treeEventScopeId: 'core',
+                eventId: events.latestEventId,
+            };
+            return;
+        }
+        yield* events.events;
     }
 
-    addListener(callback: (events: DriveEvent[]) => Promise<void>): void {
-        this.manager.addListener(async (events, fullRefresh) => {
-            if (events) {
-                await callback(events);
-            }
-            if (fullRefresh) {
-                // Because only updates about shares that are shared with me
-                // are listened to from core events, in the case of core full
-                // refresh, we don't have to refresh anything more than this
-                // one specific event.
-                await callback([{
-                    type: DriveEventType.ShareWithMeUpdated,
-                }]);
-            }
-        });
+    getLogger(): Logger {
+        return this.logger;
     }
 }

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

@@ -1,139 +1,252 @@
 import { getMockLogger } from "../../tests/logger";
-import { NotFoundAPIError } from "../apiService";
 import { EventManager } from "./eventManager";
+import { DriveEvent, DriveEventType, EventSubscription, UnsubscribeFromEventsSourceError } from "./interface";
 
 jest.useFakeTimers();
 
+const POLLING_INTERVAL = 1;
+
 describe("EventManager", () => {
-    let manager: EventManager<string>;
-    
-    const getLastEventIdMock = jest.fn();
+    let manager: EventManager<DriveEvent>;
+
+    const getLatestEventIdMock = jest.fn();
     const getEventsMock = jest.fn();
-    const updateLatestEventIdMock = jest.fn();
     const listenerMock = jest.fn();
+    const mockLogger = getMockLogger();
+    const subscriptions: EventSubscription[] = [];
 
     beforeEach(() => {
-        jest.clearAllMocks();
-
-        getLastEventIdMock.mockImplementation(() => Promise.resolve("eventId1"));
-        getEventsMock.mockImplementation(() => Promise.resolve({
-            lastEventId: "eventId2",
-            more: false,
-            refresh: false,
-            events: ["event1", "event2"],
-        }));
+        const mockEventManager = {
+            getLogger: () => mockLogger,
+            getLatestEventId: getLatestEventIdMock,
+            getEvents: getEventsMock,
+        };
 
         manager = new EventManager(
-            getMockLogger(),
-            getLastEventIdMock,
-            getEventsMock,
-            updateLatestEventIdMock,
+            mockEventManager as any,
+            POLLING_INTERVAL,
+            null,
         );
-        manager.addListener(listenerMock);
+        const subscription = manager.addListener(listenerMock);
+        subscriptions.push(subscription);
     });
 
     afterEach(async () => {
         await manager.stop();
+        while (subscriptions.length > 0) {
+            const subscription = subscriptions.pop();
+            subscription?.dispose();
+        }
+        jest.clearAllMocks();
     });
 
-    it("should get latest event ID on first run only", async () => {
-        await manager.start();
-        expect(getLastEventIdMock).toHaveBeenCalledTimes(1);
-        expect(getEventsMock).toHaveBeenCalledTimes(0);
-        expect(listenerMock).toHaveBeenCalledTimes(0);
-        expect(updateLatestEventIdMock).toHaveBeenCalledTimes(1);
-        expect(updateLatestEventIdMock).toHaveBeenCalledWith('eventId1');
-    });
+    it("should start polling when started", async () => {
+        getLatestEventIdMock.mockResolvedValue('EventId1');
+
+        const mockEvents: DriveEvent[][] = [
+            [{
+                type: DriveEventType.FastForward,
+                treeEventScopeId: 'volume1',
+                eventId: 'EventId2',
+            }],
+            [{
+                type: DriveEventType.FastForward,
+                treeEventScopeId: 'volume1',
+                eventId: 'EventId3',
+            }],
+        ];
+
+        getEventsMock.mockImplementationOnce(async function* () {
+            yield* mockEvents[0];
+        }).mockImplementationOnce(async function* () {
+            yield* mockEvents[1];
+        }).mockImplementationOnce(async function* () {
+        });
 
-    it("should notify about events in the next run", async () => {
-        await manager.start();
-        expect(getLastEventIdMock).toHaveBeenCalledTimes(1);
+        expect(getLatestEventIdMock).toHaveBeenCalledTimes(0);
         expect(getEventsMock).toHaveBeenCalledTimes(0);
-        expect(listenerMock).toHaveBeenCalledTimes(0);
-        expect(updateLatestEventIdMock).toHaveBeenCalledTimes(1);
-        expect(updateLatestEventIdMock).toHaveBeenCalledWith('eventId1');
-        updateLatestEventIdMock.mockClear();
+
+        expect(await manager.start()).toBeUndefined();
+
+        expect(getLatestEventIdMock).toHaveBeenCalledTimes(1);
+        expect(getEventsMock).toHaveBeenCalledWith('EventId1');
+
         await jest.runOnlyPendingTimersAsync();
-        expect(getEventsMock).toHaveBeenCalledTimes(1);
-        expect(listenerMock).toHaveBeenCalledTimes(1);
-        expect(updateLatestEventIdMock).toHaveBeenCalledTimes(1);
-        expect(updateLatestEventIdMock).toHaveBeenCalledWith('eventId2');
+        expect(getEventsMock).toHaveBeenCalledTimes(2);
+        expect(getEventsMock).toHaveBeenCalledWith('EventId2');
     });
 
-    it("should continue with more events", async () => {
-        getEventsMock.mockImplementation((lastEventId: string) => Promise.resolve({
-            lastEventId: lastEventId === "eventId1" ? "eventId2" : "eventId3",
-            more: lastEventId === "eventId1" ? true : false,
-            refresh: false,
-            events: lastEventId === "eventId1" ? ["event1", "event2"] : ["event3"],
-        }));
+    it("should stop polling when stopped", async () => {
+        getLatestEventIdMock.mockResolvedValue('eventId1');
+        getEventsMock.mockImplementation(async function* () {
+            yield {
+                type: DriveEventType.FastForward,
+                treeEventScopeId: 'volume1',
+                eventId: 'eventId1',
+            };
+        });
+
         await manager.start();
         await jest.runOnlyPendingTimersAsync();
-        expect(getEventsMock).toHaveBeenCalledTimes(2);
-        expect(listenerMock).toHaveBeenCalledTimes(2);
-        expect(listenerMock).toHaveBeenCalledWith(["event1", "event2"], false);
-        expect(listenerMock).toHaveBeenCalledWith(["event3"], false);
-        expect(updateLatestEventIdMock).toHaveBeenCalledTimes(3);
-        expect(updateLatestEventIdMock).toHaveBeenCalledWith('eventId1');
-        expect(updateLatestEventIdMock).toHaveBeenCalledWith('eventId2');
-        expect(updateLatestEventIdMock).toHaveBeenCalledWith('eventId3');
+
+        const callsBeforeStop = getEventsMock.mock.calls.length;
+        await manager.stop();
+        await jest.runOnlyPendingTimersAsync();
+
+        // Should not have made additional calls after stopping
+        expect(getEventsMock).toHaveBeenCalledTimes(callsBeforeStop);
     });
 
-    it("should refresh if event does not exist", async () => {
-        getEventsMock.mockImplementation(() => Promise.reject(new NotFoundAPIError('Event not found', 2501)));
-        await manager.start();
+    it("should notify all listeners when getting events", async () => {
+        getLatestEventIdMock.mockResolvedValue('eventId1');
+
+        const mockEvents: DriveEvent[] = [
+            {
+                type: DriveEventType.NodeCreated,
+                nodeUid: 'node1',
+                parentNodeUid: 'parent1',
+                isTrashed: false,
+                isShared: false,
+                treeEventScopeId: 'volume1',
+                eventId: 'eventId2',
+            },
+        ];
+
+        getEventsMock.mockImplementationOnce(async function* () {
+            yield* mockEvents;
+        }).mockImplementation(async function* () {
+        });
+
+        expect(await manager.start()).toBeUndefined();
         await jest.runOnlyPendingTimersAsync();
-        expect(getLastEventIdMock).toHaveBeenCalledTimes(2);
         expect(listenerMock).toHaveBeenCalledTimes(1);
-        expect(listenerMock).toHaveBeenCalledWith([], true);
-        expect(updateLatestEventIdMock).toHaveBeenCalledTimes(1);
-        expect(updateLatestEventIdMock).toHaveBeenCalledWith('eventId1');
+        expect(listenerMock).toHaveBeenNthCalledWith(1, mockEvents[0]);
     });
 
-    it("should retry on error", async () => {
-        let index = 0;
-        getEventsMock.mockImplementation(() => {
-            index++;
-            if (index <= 3) {
-                return Promise.reject(new Error("Error"));
+    it("should propagate unsubscription errors", async () => {
+        getLatestEventIdMock.mockImplementation(() => {
+            throw new UnsubscribeFromEventsSourceError("Not found");
+        });
+
+        await expect(manager.start()).rejects.toThrow(UnsubscribeFromEventsSourceError);
+
+        expect(getLatestEventIdMock).toHaveBeenCalledTimes(1);
+        expect(listenerMock).toHaveBeenCalledTimes(0);
+        expect(getEventsMock).toHaveBeenCalledTimes(0);
+    });
+
+    it("should continue processing multiple events", async () => {
+        getLatestEventIdMock.mockResolvedValue('eventId1');
+
+        const mockEvents: DriveEvent[] = [
+            {
+                type: DriveEventType.NodeCreated,
+                nodeUid: 'node1',
+                parentNodeUid: 'parent1',
+                isTrashed: false,
+                isShared: false,
+                treeEventScopeId: 'volume1',
+                eventId: 'eventId2',
+            },
+            {
+                type: DriveEventType.NodeCreated,
+                nodeUid: 'node2',
+                parentNodeUid: 'parent1',
+                isTrashed: false,
+                isShared: false,
+                treeEventScopeId: 'volume1',
+                eventId: 'eventId3',
             }
-            return Promise.resolve({
-                lastEventId: "eventId2",
-                more: false,
-                refresh: false,
-                events: ["event1", "event2"],
-            });
+        ];
+
+        getEventsMock.mockImplementationOnce(async function* () {
+            yield* mockEvents;
+        }).mockImplementation(async function* () {
+            // Empty generator for subsequent calls
         });
+
         await manager.start();
-        updateLatestEventIdMock.mockClear();
+        await jest.runOnlyPendingTimersAsync();
 
-        // First failure.
+        expect(listenerMock).toHaveBeenCalledTimes(2);
+        expect(listenerMock).toHaveBeenNthCalledWith(1, mockEvents[0]);
+        expect(listenerMock).toHaveBeenNthCalledWith(2, mockEvents[1]);
+
+        getEventsMock.mockImplementationOnce(async function* () {
+            yield* mockEvents;
+        })
         await jest.runOnlyPendingTimersAsync();
-        expect(listenerMock).toHaveBeenCalledTimes(0);
-        expect(manager.nextPollTimeout).toBe(30000);
+        expect(listenerMock).toHaveBeenCalledTimes(4);
+        expect(listenerMock).toHaveBeenNthCalledWith(1, mockEvents[0]);
+        expect(listenerMock).toHaveBeenNthCalledWith(2, mockEvents[1]);
+    });
+
+    it("should retry on error with exponential backoff", async () => {
+        getLatestEventIdMock.mockResolvedValue('eventId1');
+
+        let callCount = 0;
+        getEventsMock.mockImplementation(async function* () {
+            callCount++;
+            if (callCount <= 3) {
+                throw new Error("Network error");
+            }
+            yield {
+                type: DriveEventType.FastForward,
+                treeEventScopeId: 'volume1',
+                eventId: 'eventId3',
+            };
+        });
+
+        expect(manager['retryIndex']).toEqual(0);
+
+        expect(await manager.start()).toBeUndefined();
+        expect(getEventsMock).toHaveBeenCalledTimes(1);
+        expect(manager['retryIndex']).toEqual(1);
 
-        // Second failure.
         await jest.runOnlyPendingTimersAsync();
-        expect(listenerMock).toHaveBeenCalledTimes(0);
-        expect(manager.nextPollTimeout).toBe(60000);
+        expect(getEventsMock).toHaveBeenCalledTimes(2);
+        expect(manager['retryIndex']).toEqual(2);
 
-        // Third failure.
         await jest.runOnlyPendingTimersAsync();
+        expect(manager['retryIndex']).toEqual(3);
+
         expect(listenerMock).toHaveBeenCalledTimes(0);
-        expect(manager.nextPollTimeout).toBe(90000);
 
-        // And now it passes.
         await jest.runOnlyPendingTimersAsync();
         expect(listenerMock).toHaveBeenCalledTimes(1);
-        expect(listenerMock).toHaveBeenCalledWith(["event1", "event2"], false);
-        expect(updateLatestEventIdMock).toHaveBeenCalledTimes(1);
-        expect(updateLatestEventIdMock).toHaveBeenCalledWith('eventId2');
+        // After success, retry index should reset
+        expect(manager['retryIndex']).toEqual(0);
     });
 
-    it("should stop polling", async () => {
-        await manager.start();
+    it("should stop polling when stopped immediately", async () => {
+        getLatestEventIdMock.mockResolvedValue('eventId1');
+        getEventsMock.mockImplementation(async function* () {
+            yield {
+                type: DriveEventType.FastForward,
+                treeEventScopeId: 'volume1',
+                eventId: 'eventId1',
+            };
+        });
+
+        expect(await manager.start()).toBeUndefined();
+        expect(getEventsMock).toHaveBeenCalledTimes(1);
         await manager.stop();
         await jest.runOnlyPendingTimersAsync();
-        expect(getEventsMock).toHaveBeenCalledTimes(0);
+
+        // getEvents should have been called once during start, but not again after stop
+        expect(getEventsMock).toHaveBeenCalledTimes(1);
+    });
+
+    it("should handle empty event streams", async () => {
+        getLatestEventIdMock.mockResolvedValue('eventId1');
+
+        getEventsMock.mockImplementation(async function* () {
+            // Empty generator - no events
+        });
+
+        await manager.start();
+        await jest.runOnlyPendingTimersAsync();
+
+        expect(listenerMock).toHaveBeenCalledTimes(0);
     });
 });