test: websocket testcases

Author: JustSamuel

package.json

@@ -20,6 +20,7 @@
     "coverage": "nyc npm run test",
     "coverage-ci": "nyc npm run test-ci",
     "coverage-ci-migrate": "nyc npm run test-ci-migrate",
+    "coverage-file": "nyc npm run test-file",
     "lint": "eslint package.json src test --ext .js --ext .ts",
     "lint-fix": "npm run lint -- --fix",
     "typeorm": "node --require ts-node/register ./node_modules/typeorm/cli.js",

src/index.ts

@@ -106,6 +106,9 @@ export class Application {
   public async stop(): Promise<void> {
     this.logger.info('Stopping application instance...');
     await util.promisify(this.server.close).bind(this.server)();
+    if (this.webSocketService) {
+      await this.webSocketService.close();
+    }
     this.tasks.forEach((task) => task.stop());
     await this.connection.destroy();
     this.logger.info('Application stopped.');
@@ -240,6 +243,20 @@ export default async function createApp(): Promise<Application> {
   await setupAuthentication(tokenHandler, application);
 
   // Initialize WebSocket service
+  // Close existing instance's server if it exists (e.g., in tests)
+  try {
+    const existingInstance = WebSocketService.getInstance();
+    if (existingInstance.server.listening) {
+      const l = log4js.getLogger('index');
+      l.info('Closing existing WebSocket server before creating new instance');
+      existingInstance.server.close(() => {
+        l.info('Existing WebSocket server closed');
+      });
+    }
+  } catch {
+    // No existing instance, continue
+  }
+  
   const webSocketService = new WebSocketService({
     tokenHandler,
     roleManager: application.roleManager,

src/service/websocket-service.ts

@@ -36,7 +36,7 @@ import {
   RoomRegistration,
   WebSocketRequestContext,
 } from './websocket/room-policy';
-import { InPosGuard, GlobalGuard } from './websocket/event-guards';
+import { InPosGuard, ForUserGuard } from './websocket/event-guards';
 import { EventRegistry, ResolvedRoom } from './websocket/event-registry';
 import { getPointOfSaleRelation } from './websocket/pos-relation-helper';
 import RoleManager from '../rbac/role-manager';
@@ -79,6 +79,8 @@ export default class WebSocketService {
 
   private readonly eventRegistry: EventRegistry = new EventRegistry();
 
+  private connectionHandlerRegistered: boolean = false;
+
   /**
    * Creates a new WebSocketService instance.
    * @param options - The service options.
@@ -185,7 +187,14 @@ export default class WebSocketService {
             entityId: transaction.pointOfSale.id,
           });
         }
-
+        
+        if (transaction.from?.id) {
+          rooms.push({
+            roomName: `user:${transaction.from.id}:transactions`,
+            entityId: transaction.from.id,
+          });
+        }
+        
         rooms.push({
           roomName: 'transactions:all',
           entityId: null,
@@ -194,15 +203,16 @@ export default class WebSocketService {
         return rooms;
       },
       guard: async (transaction, roomContext) => {
-        if (roomContext.isGlobal) {
-          return GlobalGuard(transaction, roomContext);
+        if (roomContext.isGlobal) return true;
+
+        switch (roomContext.entityType) {
+          case 'pos':
+            return InPosGuard(transaction, roomContext);
+          case 'user':
+            return ForUserGuard(transaction, roomContext);
+          default:
+            return false;
         }
-
-        if (roomContext.entityType === 'pos') {
-          return InPosGuard(transaction, roomContext);
-        }
-
-        return false;
       },
     });
   }
@@ -226,20 +236,41 @@ export default class WebSocketService {
    * Initializes the WebSocket server and sets up connection handlers.
    */
   public initiateWebSocket(): void {
+    // Prevent multiple initializations
+    if (this.connectionHandlerRegistered) {
+      this.logger.trace('WebSocket connection handler already registered, skipping initialization');
+      return;
+    }
+
     if (process.env.NODE_ENV == 'production') {
       this.setupAdapter();
     } else {
       const port = process.env.WEBSOCKET_PORT ? parseInt(process.env.WEBSOCKET_PORT, 10) : 8080;
 
-      this.server.listen(port, () => {
-        this.logger.info(`WebSocket opened on port ${port}.`);
-      });
+      // Only start listening if not already listening
+      if (!this.server.listening) {
+        this.server.listen(port, () => {
+          this.logger.info(`WebSocket opened on port ${port}.`);
+        });
+        // Handle EADDRINUSE error gracefully (e.g., in tests where port might already be in use)
+        this.server.on('error', (error: NodeJS.ErrnoException) => {
+          if (error.code === 'EADDRINUSE') {
+            this.logger.warn(`Port ${port} is already in use. WebSocket server may already be running.`);
+          } else {
+            this.logger.error('WebSocket server error:', error);
+          }
+        });
+      } else {
+        this.logger.trace(`WebSocket server already listening on port ${port}, skipping listen call`);
+      }
     }
 
+    // Register connection handler only once
     this.io.on('connection', async (client: Socket) => {
-      await this.handleAuthentication(client);
       this.setupConnectionHandlers(client);
+      await this.handleAuthentication(client);
     });
+    this.connectionHandlerRegistered = true;
   }
 
   /**
@@ -483,4 +514,50 @@ export default class WebSocketService {
   public static async emitTransactionCreated(transaction: TransactionResponse): Promise<void> {
     await this.getInstance().emitTransactionCreated(transaction);
   }
+
+  /**
+   * Closes the WebSocket server and cleans up resources.
+   * @returns Promise that resolves when the server is closed.
+   */
+  public async close(): Promise<void> {
+    return new Promise<void>((resolve) => {
+      if (!this.server.listening) {
+        resolve();
+        return;
+      }
+
+      this.io.close(() => {
+        // Socket.IO's close() already closes the underlying HTTP server,
+        // but we check if it's still listening before trying to close it again
+        if (this.server.listening) {
+          this.server.close((err) => {
+            if (err) {
+              const nodeErr = err as NodeJS.ErrnoException;
+              if (nodeErr.code !== 'ERR_SERVER_NOT_RUNNING') {
+                this.logger.error('Error closing WebSocket server:', err);
+              } else {
+                this.logger.info('WebSocket server closed');
+              }
+            } else {
+              this.logger.info('WebSocket server closed');
+            }
+            resolve();
+          });
+        } else {
+          // Server was already closed by io.close()
+          this.logger.info('WebSocket server closed');
+          resolve();
+        }
+      });
+    });
+  }
+
+  /**
+   * Static method for backward compatibility.
+   * Delegates to the singleton instance.
+   * @throws Error if WebSocketService has not been initialized.
+   */
+  public static async close(): Promise<void> {
+    await this.getInstance().close();
+  }
 }

src/service/websocket/event-guards.ts

@@ -39,8 +39,11 @@ export const InPosGuard: EventGuard<{ pointOfSale?: { id?: number } }> = (eventD
 };
 
 /**
- * Global guard only matches global rooms (isGlobal === true).
+ * ForUser guard checks if transaction belongs to the user in the room.
  */
-export const GlobalGuard: EventGuard = (_eventData, roomContext) => {
-  return roomContext.isGlobal;
+export const ForUserGuard: EventGuard<{ from?: { id?: number } }> = (eventData, roomContext) => {
+  if (roomContext.entityType !== 'user' || roomContext.entityId === null) {
+    return false;
+  }
+  return eventData.from?.id === roomContext.entityId;
 };

test/unit/controller/authentication-secure-controller.ts

@@ -294,8 +294,19 @@ describe('AuthenticationSecureController', () => {
         on: sinon.stub(),
       };
 
-      // Mock the WebSocketService.io property
-      sinon.stub(WebSocketService, 'io').value(mockSocketIO);
+      // Create a mock WebSocketService instance
+      const mockWebSocketService = {
+        io: mockSocketIO,
+        emitQRConfirmed: (qr: QRAuthenticator, token: AuthenticationResponse) => {
+          mockSocketIO.to(`qr-session-${qr.sessionId}`).emit('qr-confirmed', {
+            sessionId: qr.sessionId,
+            token,
+          });
+        },
+      } as any;
+
+      // Mock getInstance to return our mock instance
+      sinon.stub(WebSocketService, 'getInstance').returns(mockWebSocketService);
 
       // Setup service stubs
       qrServiceStub = sinon.createStubInstance(QRService);

test/unit/controller/server-settings-controller.ts

@@ -27,6 +27,9 @@ import ServerSettingsStore from '../../../src/server-settings/server-settings-st
 import { expect, request } from 'chai';
 import sinon from 'sinon';
 import { RbacSeeder, UserSeeder } from '../../seed';
+import WebSocketService from '../../../src/service/websocket-service';
+import TokenHandler from '../../../src/authentication/token-handler';
+import RoleManager from '../../../src/rbac/role-manager';
 
 describe('ServerSettingsController', () => {
   let ctx: DefaultContext & {
@@ -70,6 +73,17 @@ describe('ServerSettingsController', () => {
     ServerSettingsStore.deleteInstance();
     await ServerSettingsStore.getInstance().initialize();
 
+    // Initialize WebSocketService for tests that need it
+    const mockTokenHandler = {} as TokenHandler;
+    const mockRoleManager = {} as RoleManager;
+    const webSocketService = new WebSocketService({
+      tokenHandler: mockTokenHandler,
+      roleManager: mockRoleManager,
+    });
+    // Mock sendMaintenanceMode to avoid actual WebSocket operations in tests
+    sinon.stub(webSocketService, 'sendMaintenanceMode').returns(undefined);
+    sinon.stub(WebSocketService, 'getInstance').returns(webSocketService);
+
     ctx = {
       ...c,
       admin,