@flusys/nestjs-notification 6.0.1 → 6.1.0

package/fesm/modules/notification.module.spec.js

@@ -0,0 +1,148 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+import { NOTIFICATION_ADAPTER } from '@flusys/nestjs-shared/interfaces';
+import { NotificationModule } from './notification.module';
+import { NOTIFICATION_MODULE_OPTIONS } from '../config/notification.constants';
+import { NotificationController } from '../controllers';
+import { NotificationGateway } from '../gateways';
+import { NotificationAdapter } from '../adapters';
+function providerTokens(providers) {
+    return providers.map((p)=>typeof p === 'function' ? p : p.provide);
+}
+describe('NotificationModule', ()=>{
+    describe('forRoot', ()=>{
+        it('should default to a non-global module with the notification controller registered', ()=>{
+            const dynamicModule = NotificationModule.forRoot({});
+            expect(dynamicModule.module).toBe(NotificationModule);
+            expect(dynamicModule.global).toBe(false);
+            expect(dynamicModule.controllers).toEqual([
+                NotificationController
+            ]);
+        });
+        it('should respect global: true', ()=>{
+            expect(NotificationModule.forRoot({
+                global: true
+            }).global).toBe(true);
+        });
+        it('should register no controllers when includeController is false', ()=>{
+            expect(NotificationModule.forRoot({
+                includeController: false
+            }).controllers).toEqual([]);
+        });
+        it('should register the NOTIFICATION_ADAPTER provider backed by NotificationAdapter', ()=>{
+            const dynamicModule = NotificationModule.forRoot({});
+            const adapterProvider = dynamicModule.providers.find((p)=>p.provide === NOTIFICATION_ADAPTER);
+            expect(adapterProvider.useClass).toBe(NotificationAdapter);
+            expect(providerTokens(dynamicModule.providers)).toContain(NotificationGateway);
+        });
+        it('should export NotificationGateway and NOTIFICATION_ADAPTER alongside the base services', ()=>{
+            const dynamicModule = NotificationModule.forRoot({});
+            expect(dynamicModule.exports).toEqual(expect.arrayContaining([
+                NotificationGateway,
+                NOTIFICATION_ADAPTER
+            ]));
+        });
+        it('should register a NOTIFICATION_MODULE_OPTIONS provider carrying the given options', ()=>{
+            const options = {
+                bootstrapAppConfig: {
+                    enableCompanyFeature: true
+                }
+            };
+            const dynamicModule = NotificationModule.forRoot(options);
+            const provider = dynamicModule.providers.find((p)=>p.provide === NOTIFICATION_MODULE_OPTIONS);
+            expect(provider.useValue).toBe(options);
+        });
+    });
+    describe('forRootAsync', ()=>{
+        it('should forward external imports alongside CacheModule/UtilsModule', ()=>{
+            let FakeImportedModule = class FakeImportedModule {
+            };
+            const dynamicModule = NotificationModule.forRootAsync({
+                imports: [
+                    FakeImportedModule
+                ]
+            });
+            expect(dynamicModule.imports).toEqual(expect.arrayContaining([
+                FakeImportedModule
+            ]));
+        });
+        it('should still wire the adapter/gateway providers when using async registration', ()=>{
+            const dynamicModule = NotificationModule.forRootAsync({
+                useFactory: jest.fn()
+            });
+            const adapterProvider = dynamicModule.providers.find((p)=>p.provide === NOTIFICATION_ADAPTER);
+            expect(adapterProvider.useClass).toBe(NotificationAdapter);
+        });
+        it('useFactory: builds a NOTIFICATION_MODULE_OPTIONS provider merging resolved config', async ()=>{
+            const useFactory = jest.fn().mockResolvedValue({
+                foo: 'bar'
+            });
+            const dynamicModule = NotificationModule.forRootAsync({
+                useFactory,
+                inject: [
+                    'SOME_TOKEN'
+                ]
+            });
+            const provider = dynamicModule.providers.find((p)=>p.provide === NOTIFICATION_MODULE_OPTIONS);
+            expect(provider.inject).toEqual([
+                'SOME_TOKEN'
+            ]);
+            const resolved = await provider.useFactory('injected');
+            expect(useFactory).toHaveBeenCalledWith('injected');
+            expect(resolved.config).toEqual({
+                foo: 'bar'
+            });
+        });
+        it('useClass: registers both the class provider and an options provider calling createNotificationOptions()', async ()=>{
+            let MyOptionsFactory = class MyOptionsFactory {
+                constructor(){
+                    _define_property(this, "createNotificationOptions", jest.fn().mockResolvedValue({
+                        foo: 'from-class'
+                    }));
+                }
+            };
+            const dynamicModule = NotificationModule.forRootAsync({
+                useClass: MyOptionsFactory
+            });
+            const classProvider = dynamicModule.providers.find((p)=>p.provide === MyOptionsFactory);
+            expect(classProvider.useClass).toBe(MyOptionsFactory);
+            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === NOTIFICATION_MODULE_OPTIONS);
+            const instance = new MyOptionsFactory();
+            const resolved = await optionsProvider.useFactory(instance);
+            expect(instance.createNotificationOptions).toHaveBeenCalled();
+            expect(resolved.config).toEqual({
+                foo: 'from-class'
+            });
+        });
+        it('useExisting: registers a single options provider without a duplicate class registration', ()=>{
+            let MyOptionsFactory = class MyOptionsFactory {
+                constructor(){
+                    _define_property(this, "createNotificationOptions", jest.fn());
+                }
+            };
+            const dynamicModule = NotificationModule.forRootAsync({
+                useExisting: MyOptionsFactory
+            });
+            expect(dynamicModule.providers.filter((p)=>p.provide === MyOptionsFactory)).toHaveLength(0);
+            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === NOTIFICATION_MODULE_OPTIONS);
+            expect(optionsProvider.inject).toEqual([
+                MyOptionsFactory
+            ]);
+        });
+        it('should register no NOTIFICATION_MODULE_OPTIONS provider when neither useFactory, useClass, nor useExisting is given', ()=>{
+            const dynamicModule = NotificationModule.forRootAsync({});
+            expect(providerTokens(dynamicModule.providers)).not.toContain(NOTIFICATION_MODULE_OPTIONS);
+        });
+    });
+});

package/fesm/services/notification-config.service.spec.js

@@ -0,0 +1,109 @@
+import { NotificationConfigService } from './notification-config.service';
+function buildOptions(overrides = {}) {
+    return {
+        bootstrapAppConfig: {
+            databaseMode: 'single',
+            enableCompanyFeature: false
+        },
+        config: {},
+        ...overrides
+    };
+}
+describe('NotificationConfigService', ()=>{
+    describe('isCompanyFeatureEnabled', ()=>{
+        it('returns true when bootstrapAppConfig enables the company feature', ()=>{
+            const service = new NotificationConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'single',
+                    enableCompanyFeature: true
+                }
+            }));
+            expect(service.isCompanyFeatureEnabled()).toBe(true);
+        });
+        it('returns false when bootstrapAppConfig disables the company feature', ()=>{
+            const service = new NotificationConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'single',
+                    enableCompanyFeature: false
+                }
+            }));
+            expect(service.isCompanyFeatureEnabled()).toBe(false);
+        });
+        it('defaults to false when bootstrapAppConfig is missing', ()=>{
+            const service = new NotificationConfigService(buildOptions({
+                bootstrapAppConfig: undefined
+            }));
+            expect(service.isCompanyFeatureEnabled()).toBe(false);
+        });
+    });
+    describe('getDatabaseMode', ()=>{
+        it('returns the configured database mode', ()=>{
+            const service = new NotificationConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'multi-tenant',
+                    enableCompanyFeature: true
+                }
+            }));
+            expect(service.getDatabaseMode()).toBe('multi-tenant');
+        });
+        it('defaults to "single" when bootstrapAppConfig is missing', ()=>{
+            const service = new NotificationConfigService(buildOptions({
+                bootstrapAppConfig: undefined
+            }));
+            expect(service.getDatabaseMode()).toBe('single');
+        });
+    });
+    describe('isMultiTenant', ()=>{
+        it('returns true when database mode is multi-tenant', ()=>{
+            const service = new NotificationConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'multi-tenant',
+                    enableCompanyFeature: true
+                }
+            }));
+            expect(service.isMultiTenant()).toBe(true);
+        });
+        it('returns false when database mode is single', ()=>{
+            const service = new NotificationConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'single',
+                    enableCompanyFeature: false
+                }
+            }));
+            expect(service.isMultiTenant()).toBe(false);
+        });
+    });
+    describe('getJwtSecret', ()=>{
+        it('returns the configured jwt secret', ()=>{
+            const service = new NotificationConfigService(buildOptions({
+                config: {
+                    jwtSecret: 'top-secret'
+                }
+            }));
+            expect(service.getJwtSecret()).toBe('top-secret');
+        });
+        it('returns undefined when no jwt secret is configured', ()=>{
+            const service = new NotificationConfigService(buildOptions({
+                config: {}
+            }));
+            expect(service.getJwtSecret()).toBeUndefined();
+        });
+        it('returns undefined when config is missing entirely', ()=>{
+            const service = new NotificationConfigService(buildOptions({
+                config: undefined
+            }));
+            expect(service.getJwtSecret()).toBeUndefined();
+        });
+    });
+    describe('getOptions', ()=>{
+        it('returns the raw options object passed to the constructor', ()=>{
+            const options = buildOptions({
+                config: {
+                    jwtSecret: 'abc'
+                }
+            });
+            const service = new NotificationConfigService(options);
+            expect(service.getOptions()).toBe(options);
+        });
+    });
+});

package/fesm/services/notification-datasource.provider.spec.js

@@ -0,0 +1,132 @@
+import { MultiTenantDataSourceService } from '@flusys/nestjs-shared/modules';
+import { NotificationDataSourceProvider } from './notification-datasource.provider';
+import { Notification, NotificationWithCompany } from '../entities';
+function buildConfigService(overrides = {}) {
+    return {
+        isCompanyFeatureEnabled: jest.fn().mockReturnValue(false),
+        getDatabaseMode: jest.fn().mockReturnValue('single'),
+        isMultiTenant: jest.fn().mockReturnValue(false),
+        getJwtSecret: jest.fn().mockReturnValue(undefined),
+        getOptions: jest.fn().mockReturnValue({
+            bootstrapAppConfig: {
+                databaseMode: 'single',
+                enableCompanyFeature: false
+            },
+            config: {
+                defaultDatabaseConfig: {
+                    type: 'mysql',
+                    host: 'localhost',
+                    port: 3306,
+                    username: 'root',
+                    password: 'pass',
+                    database: 'flusys'
+                },
+                tenants: []
+            }
+        }),
+        ...overrides
+    };
+}
+describe('NotificationDataSourceProvider', ()=>{
+    let configService;
+    let provider;
+    beforeEach(()=>{
+        configService = buildConfigService();
+        provider = new NotificationDataSourceProvider(configService, undefined);
+    });
+    describe('getEnableCompanyFeatureForTenant', ()=>{
+        it('returns the tenant override when the tenant explicitly enables the company feature', ()=>{
+            const result = provider.getEnableCompanyFeatureForTenant({
+                id: 'tenant-1',
+                database: 'tenant_db',
+                enableCompanyFeature: true
+            });
+            expect(result).toBe(true);
+            expect(configService.isCompanyFeatureEnabled).not.toHaveBeenCalled();
+        });
+        it('returns the tenant override when the tenant explicitly disables the company feature', ()=>{
+            const result = provider.getEnableCompanyFeatureForTenant({
+                id: 'tenant-1',
+                database: 'tenant_db',
+                enableCompanyFeature: false
+            });
+            expect(result).toBe(false);
+        });
+        it('falls back to the config service when the tenant has no override', ()=>{
+            configService.isCompanyFeatureEnabled.mockReturnValue(true);
+            const result = provider.getEnableCompanyFeatureForTenant(undefined);
+            expect(result).toBe(true);
+            expect(configService.isCompanyFeatureEnabled).toHaveBeenCalled();
+        });
+    });
+    describe('getNotificationEntities', ()=>{
+        it('returns [NotificationWithCompany] when enableCompanyFeature is explicitly true', async ()=>{
+            const entities = await provider.getNotificationEntities(true);
+            expect(entities).toEqual([
+                NotificationWithCompany
+            ]);
+        });
+        it('returns [Notification] when enableCompanyFeature is explicitly false', async ()=>{
+            const entities = await provider.getNotificationEntities(false);
+            expect(entities).toEqual([
+                Notification
+            ]);
+        });
+        it('falls back to the config service when enableCompanyFeature is not provided', async ()=>{
+            configService.isCompanyFeatureEnabled.mockReturnValue(true);
+            const entities = await provider.getNotificationEntities();
+            expect(entities).toEqual([
+                NotificationWithCompany
+            ]);
+            expect(configService.isCompanyFeatureEnabled).toHaveBeenCalled();
+        });
+    });
+    describe('createDataSourceFromConfig', ()=>{
+        it('resolves company-aware entities and delegates to the parent implementation', async ()=>{
+            configService.isCompanyFeatureEnabled.mockReturnValue(true);
+            const fakeDataSource = {};
+            const superSpy = jest.spyOn(MultiTenantDataSourceService.prototype, 'createDataSourceFromConfig').mockResolvedValue(fakeDataSource);
+            const config = {
+                type: 'mysql',
+                host: 'localhost',
+                port: 3306,
+                username: 'root',
+                password: 'pass',
+                database: 'flusys'
+            };
+            const result = await provider.createDataSourceFromConfig(config);
+            expect(result).toBe(fakeDataSource);
+            expect(superSpy).toHaveBeenCalledWith(config, [
+                NotificationWithCompany
+            ]);
+            superSpy.mockRestore();
+        });
+        it('resolves core entities when the company feature is disabled', async ()=>{
+            configService.isCompanyFeatureEnabled.mockReturnValue(false);
+            const fakeDataSource = {};
+            const superSpy = jest.spyOn(MultiTenantDataSourceService.prototype, 'createDataSourceFromConfig').mockResolvedValue(fakeDataSource);
+            const config = {
+                type: 'mysql',
+                host: 'localhost',
+                port: 3306,
+                username: 'root',
+                password: 'pass',
+                database: 'flusys'
+            };
+            await provider.createDataSourceFromConfig(config);
+            expect(superSpy).toHaveBeenCalledWith(config, [
+                Notification
+            ]);
+            superSpy.mockRestore();
+        });
+    });
+    describe('inherited configuration accessors', ()=>{
+        it('reports single database mode by default', ()=>{
+            expect(provider.getDatabaseMode()).toBe('single');
+            expect(provider.isMultiTenant()).toBe(false);
+        });
+        it('returns null for the current tenant when no request is bound', ()=>{
+            expect(provider.getCurrentTenant()).toBeNull();
+        });
+    });
+});

package/fesm/services/notification-helper.service.spec.js

@@ -0,0 +1,302 @@
+import { Test } from '@nestjs/testing';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { NotificationType } from '@flusys/nestjs-shared/enums';
+import { NotificationHelperService } from './notification-helper.service';
+import { NotificationConfigService } from './notification-config.service';
+import { NotificationDataSourceProvider } from './notification-datasource.provider';
+import { NotificationGateway } from '../gateways';
+import { Notification, NotificationWithCompany } from '../entities';
+function createMockRepo() {
+    return {
+        save: jest.fn()
+    };
+}
+function createMockDataSource(repo) {
+    return {
+        getRepository: jest.fn().mockReturnValue(repo)
+    };
+}
+describe('NotificationHelperService', ()=>{
+    let mockCacheManager;
+    let mockUtilsService;
+    let mockConfigService;
+    let mockDataSourceProvider;
+    let mockGateway;
+    let mockRepo;
+    let mockDataSource;
+    async function buildService(withGateway = true) {
+        const providers = [
+            NotificationHelperService,
+            {
+                provide: 'CACHE_INSTANCE',
+                useValue: mockCacheManager
+            },
+            {
+                provide: UtilsService,
+                useValue: mockUtilsService
+            },
+            {
+                provide: NotificationConfigService,
+                useValue: mockConfigService
+            },
+            {
+                provide: NotificationDataSourceProvider,
+                useValue: mockDataSourceProvider
+            }
+        ];
+        if (withGateway) {
+            providers.push({
+                provide: NotificationGateway,
+                useValue: mockGateway
+            });
+        }
+        const module = await Test.createTestingModule({
+            providers
+        }).compile();
+        return module.get(NotificationHelperService);
+    }
+    beforeEach(()=>{
+        mockRepo = createMockRepo();
+        mockDataSource = createMockDataSource(mockRepo);
+        mockCacheManager = {};
+        mockUtilsService = {
+            clearCache: jest.fn().mockResolvedValue(undefined)
+        };
+        mockConfigService = {
+            isCompanyFeatureEnabled: jest.fn().mockReturnValue(false)
+        };
+        mockDataSourceProvider = {
+            getDataSource: jest.fn().mockResolvedValue(mockDataSource)
+        };
+        mockGateway = {
+            emitToUser: jest.fn(),
+            emitToUserInCompany: jest.fn(),
+            isUserOnline: jest.fn(),
+            getOnlineUserCount: jest.fn()
+        };
+    });
+    describe('send', ()=>{
+        it('saves the notification, clears the cache, and emits to the user in real time', async ()=>{
+            const service = await buildService();
+            const options = {
+                userId: 'user-1',
+                title: 'Hi',
+                message: 'body',
+                type: NotificationType.SUCCESS,
+                data: {
+                    a: 1
+                }
+            };
+            const saved = {
+                id: 'notif-1',
+                ...options,
+                isRead: false
+            };
+            mockRepo.save.mockResolvedValue(saved);
+            const result = await service.send(options);
+            expect(mockDataSource.getRepository).toHaveBeenCalledWith(Notification);
+            expect(mockRepo.save).toHaveBeenCalledWith(expect.objectContaining({
+                userId: 'user-1',
+                title: 'Hi',
+                isRead: false
+            }));
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('notification', mockCacheManager);
+            expect(mockGateway.emitToUser).toHaveBeenCalledWith('user-1', 'notification:new', expect.objectContaining({
+                id: 'notif-1',
+                title: 'Hi'
+            }));
+            expect(result).toBe(saved);
+        });
+        it('defaults type to INFO and message/data to null when omitted', async ()=>{
+            const service = await buildService();
+            mockRepo.save.mockImplementation(async (entity)=>({
+                    id: 'notif-2',
+                    ...entity
+                }));
+            await service.send({
+                userId: 'user-1',
+                title: 'Only title'
+            });
+            expect(mockRepo.save).toHaveBeenCalledWith(expect.objectContaining({
+                type: NotificationType.INFO,
+                message: null,
+                data: null
+            }));
+        });
+        it('does not emit in real time when realtime is explicitly false', async ()=>{
+            const service = await buildService();
+            mockRepo.save.mockResolvedValue({
+                id: 'notif-3',
+                userId: 'user-1',
+                title: 'Silent'
+            });
+            await service.send({
+                userId: 'user-1',
+                title: 'Silent',
+                realtime: false
+            });
+            expect(mockGateway.emitToUser).not.toHaveBeenCalled();
+            expect(mockGateway.emitToUserInCompany).not.toHaveBeenCalled();
+        });
+        it('does not throw when no gateway is bound (gateway not registered)', async ()=>{
+            const service = await buildService(false);
+            mockRepo.save.mockResolvedValue({
+                id: 'notif-4',
+                userId: 'user-1',
+                title: 'No gateway'
+            });
+            await expect(service.send({
+                userId: 'user-1',
+                title: 'No gateway'
+            })).resolves.toBeDefined();
+        });
+        it('uses NotificationWithCompany and includes companyId when the company feature is enabled', async ()=>{
+            mockConfigService.isCompanyFeatureEnabled.mockReturnValue(true);
+            const service = await buildService();
+            mockRepo.save.mockImplementation(async (entity)=>({
+                    id: 'notif-5',
+                    ...entity
+                }));
+            await service.send({
+                userId: 'user-1',
+                title: 'Scoped',
+                companyId: 'company-1'
+            });
+            expect(mockDataSource.getRepository).toHaveBeenCalledWith(NotificationWithCompany);
+            expect(mockRepo.save).toHaveBeenCalledWith(expect.objectContaining({
+                companyId: 'company-1'
+            }));
+            expect(mockGateway.emitToUserInCompany).toHaveBeenCalledWith('user-1', 'company-1', 'notification:new', expect.any(Object));
+        });
+        it('omits companyId when the company feature is enabled but none was provided', async ()=>{
+            mockConfigService.isCompanyFeatureEnabled.mockReturnValue(true);
+            const service = await buildService();
+            mockRepo.save.mockImplementation(async (entity)=>({
+                    id: 'notif-6',
+                    ...entity
+                }));
+            await service.send({
+                userId: 'user-1',
+                title: 'No company'
+            });
+            const savedArg = mockRepo.save.mock.calls[0][0];
+            expect(savedArg.companyId).toBeUndefined();
+        });
+        it('reuses the same cached data source across multiple calls', async ()=>{
+            const service = await buildService();
+            mockRepo.save.mockResolvedValue({
+                id: 'notif-7',
+                userId: 'user-1',
+                title: 'A'
+            });
+            await service.send({
+                userId: 'user-1',
+                title: 'A'
+            });
+            await service.send({
+                userId: 'user-1',
+                title: 'B'
+            });
+            expect(mockDataSourceProvider.getDataSource).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('sendToMany', ()=>{
+        it('saves a notification for every user id and clears the cache once', async ()=>{
+            const service = await buildService();
+            const options = {
+                userIds: [
+                    'user-1',
+                    'user-2',
+                    'user-3'
+                ],
+                title: 'Broadcast'
+            };
+            mockRepo.save.mockImplementation(async (entities)=>entities.map((e, i)=>({
+                        id: `notif-${i}`,
+                        ...e
+                    })));
+            const result = await service.sendToMany(options);
+            expect(mockRepo.save).toHaveBeenCalledWith([
+                expect.objectContaining({
+                    userId: 'user-1'
+                }),
+                expect.objectContaining({
+                    userId: 'user-2'
+                }),
+                expect.objectContaining({
+                    userId: 'user-3'
+                })
+            ]);
+            expect(mockUtilsService.clearCache).toHaveBeenCalledTimes(1);
+            expect(result).toHaveLength(3);
+        });
+        it('handles an empty userIds array without saving or emitting', async ()=>{
+            const service = await buildService();
+            mockRepo.save.mockResolvedValue([]);
+            const result = await service.sendToMany({
+                userIds: [],
+                title: 'Nobody'
+            });
+            expect(mockRepo.save).toHaveBeenCalledWith([]);
+            expect(result).toEqual([]);
+        });
+        it('emits to each user asynchronously (after the microtask queue flushes) when realtime', async ()=>{
+            const service = await buildService();
+            mockRepo.save.mockImplementation(async (entities)=>entities.map((e, i)=>({
+                        id: `notif-${i}`,
+                        ...e
+                    })));
+            await service.sendToMany({
+                userIds: [
+                    'user-1',
+                    'user-2'
+                ],
+                title: 'Broadcast'
+            });
+            expect(mockGateway.emitToUser).not.toHaveBeenCalled();
+            await new Promise((resolve)=>setImmediate(resolve));
+            expect(mockGateway.emitToUser).toHaveBeenCalledTimes(2);
+            expect(mockGateway.emitToUser).toHaveBeenCalledWith('user-1', 'notification:new', expect.any(Object));
+            expect(mockGateway.emitToUser).toHaveBeenCalledWith('user-2', 'notification:new', expect.any(Object));
+        });
+        it('does not schedule emits when realtime is false', async ()=>{
+            const service = await buildService();
+            mockRepo.save.mockImplementation(async (entities)=>entities.map((e, i)=>({
+                        id: `notif-${i}`,
+                        ...e
+                    })));
+            await service.sendToMany({
+                userIds: [
+                    'user-1'
+                ],
+                title: 'Silent',
+                realtime: false
+            });
+            await new Promise((resolve)=>setImmediate(resolve));
+            expect(mockGateway.emitToUser).not.toHaveBeenCalled();
+        });
+    });
+    describe('isUserOnline', ()=>{
+        it('delegates to the gateway when present', async ()=>{
+            const service = await buildService();
+            mockGateway.isUserOnline.mockReturnValue(true);
+            expect(service.isUserOnline('user-1')).toBe(true);
+            expect(mockGateway.isUserOnline).toHaveBeenCalledWith('user-1');
+        });
+        it('returns false when no gateway is bound', async ()=>{
+            const service = await buildService(false);
+            expect(service.isUserOnline('user-1')).toBe(false);
+        });
+    });
+    describe('getOnlineUserCount', ()=>{
+        it('delegates to the gateway when present', async ()=>{
+            const service = await buildService();
+            mockGateway.getOnlineUserCount.mockReturnValue(5);
+            expect(service.getOnlineUserCount()).toBe(5);
+        });
+        it('returns 0 when no gateway is bound', async ()=>{
+            const service = await buildService(false);
+            expect(service.getOnlineUserCount()).toBe(0);
+        });
+    });
+});