fix(websockets) fix broken unit tests

packages/microservices/test/listeners-controller.spec.ts

@@ -39,7 +39,7 @@ describe('ListenersController', () => {
     );
     rpcContextCreator = sinon.createStubInstance(RpcContextCreator) as any;
     proxySpy = sinon.spy();
-    (rpcContextCreator as any).create.callsFake(()=>proxySpy);
+    (rpcContextCreator as any).create.callsFake(() => proxySpy);
     instance = new ListenersController(
       new ClientsContainer(),
       rpcContextCreator,
@@ -55,7 +55,7 @@ describe('ListenersController', () => {
     };
   });
 
-  describe('bindPatternHandlers', () => {
+  describe('registerPatternHandlers', () => {
     const handlers = [
       { pattern: 'test', targetCallback: 'tt' },
       { pattern: 'test2', targetCallback: '2' },
@@ -66,13 +66,13 @@ describe('ListenersController', () => {
     });
     it(`should call "addHandler" method of server for each pattern handler`, () => {
       explorer.expects('explore').returns(handlers);
-      instance.bindPatternHandlers(new InstanceWrapper(), server, '');
+      instance.registerPatternHandlers(new InstanceWrapper(), server, '');
       expect(addSpy.calledTwice).to.be.true;
     });
     describe('when request scoped', () => {
       it(`should call "addHandler" with deffered proxy`, () => {
         explorer.expects('explore').returns(handlers);
-        instance.bindPatternHandlers(
+        instance.registerPatternHandlers(
           new InstanceWrapper({ scope: Scope.REQUEST }),
           server,
           '',
@@ -93,8 +93,10 @@ describe('ListenersController', () => {
             handle: handleSpy,
           } as any),
       );
-      
-      sinon.stub((instance as any), 'registerRequestProvider').callsFake(() => ({} as any));
+
+      sinon
+        .stub(instance as any, 'registerRequestProvider')
+        .callsFake(() => ({} as any));
     });
 
     describe('when "loadPerContext" resolves', () => {
@@ -107,7 +109,9 @@ describe('ListenersController', () => {
       const wrapper = new InstanceWrapper({ instance: { [methodKey]: {} } });
 
       it('should pass all arguments to the proxy chain', async () => {
-        sinon.stub(injector, 'loadPerContext').callsFake(() => Promise.resolve({}));
+        sinon
+          .stub(injector, 'loadPerContext')
+          .callsFake(() => Promise.resolve({}));
         const handler = instance.createRequestScopedHandler(
           wrapper,
           pattern,
@@ -115,11 +119,11 @@ describe('ListenersController', () => {
           moduleKey,
           methodKey,
         );
-        await handler("data", "metadata");
+        await handler('data', 'metadata');
 
         expect(proxySpy.called).to.be.true;
-        expect(proxySpy.getCall(0).args[0]).to.be.eql("data");
-        expect(proxySpy.getCall(0).args[1]).to.be.eql("metadata");
+        expect(proxySpy.getCall(0).args[0]).to.be.eql('data');
+        expect(proxySpy.getCall(0).args[1]).to.be.eql('metadata');
       });
     });
 
@@ -165,7 +169,7 @@ describe('ListenersController', () => {
     });
   });
 
-  describe('bindClientsToProperties', () => {
+  describe('assignClientsToProperties', () => {
     class TestClass {}
 
     it('should bind all clients to properties', () => {
@@ -184,7 +188,7 @@ describe('ListenersController', () => {
         instance,
         'assignClientToInstance',
       );
-      instance.bindClientsToProperties(controller);
+      instance.assignClientsToProperties(controller);
 
       expect(assignClientToInstanceSpy.calledOnce).to.be.true;
     });

packages/websockets/socket-module.ts

@@ -86,7 +86,7 @@ export class SocketModule<HttpServer = any> {
     if (!adapter) {
       return;
     }
-    const servers = this.socketsContainer.getAllServers();
+    const servers = this.socketsContainer.getAllSocketEventHosts();
     await Promise.all(
       iterate(servers.values())
         .filter(({ server }) => server)

packages/websockets/socket-server-provider.ts

@@ -16,9 +16,11 @@ export class SocketServerProvider {
     options: T,
     port: number,
   ): SocketEventsHost {
-    const observableServer = this.socketsContainer.getServerByPort(port);
-    return observableServer
-      ? this.createWithNamespace(options, port, observableServer)
+    const socketEventsHost = this.socketsContainer.getSocketEventsHostByPort(
+      port,
+    );
+    return socketEventsHost
+      ? this.createWithNamespace(options, port, socketEventsHost)
       : this.createSocketServer(options, port);
   }
 
@@ -26,34 +28,32 @@ export class SocketServerProvider {
     options: T,
     port: number,
   ): SocketEventsHost {
-    const { namespace, server, ...opt } = options as any;
+    const { namespace, server, ...partialOptions } = options as any;
     const adapter = this.applicationConfig.getIoAdapter();
-    const ioServer = adapter.create(port, opt);
+    const ioServer = adapter.create(port, partialOptions);
     const observableSocket = SocketEventsHostFactory.create(ioServer);
 
-    this.socketsContainer.addServer(null, port, observableSocket);
+    this.socketsContainer.addSocketEventsHost(null, port, observableSocket);
     return this.createWithNamespace(options, port, observableSocket);
   }
 
   private createWithNamespace<T extends GatewayMetadata>(
     options: T,
     port: number,
-    observableSocket: SocketEventsHost,
+    socketEventsHost: SocketEventsHost,
   ): SocketEventsHost {
     const { namespace } = options;
     if (!namespace) {
-      return observableSocket;
+      return socketEventsHost;
     }
     const namespaceServer = this.getServerOfNamespace(
       options,
       port,
-      observableSocket.server,
+      socketEventsHost.server,
     );
-    const observableNamespaceSocket = SocketEventsHostFactory.create(
-      namespaceServer,
-    );
-    this.socketsContainer.addServer(namespace, port, observableNamespaceSocket);
-    return observableNamespaceSocket;
+    const eventsHost = SocketEventsHostFactory.create(namespaceServer);
+    this.socketsContainer.addSocketEventsHost(namespace, port, eventsHost);
+    return eventsHost;
   }
 
   private getServerOfNamespace<TOptions extends GatewayMetadata, TServer = any>(

packages/websockets/sockets-container.ts

@@ -1,31 +1,31 @@
 import { SocketEventsHost } from './interfaces';
 
 export class SocketsContainer {
-  private readonly observableServers = new Map<
+  private readonly socketEventHosts = new Map<
     string | RegExp,
     SocketEventsHost
   >();
 
-  public getAllServers(): Map<string | RegExp, SocketEventsHost> {
-    return this.observableServers;
+  public getAllSocketEventHosts(): Map<string | RegExp, SocketEventsHost> {
+    return this.socketEventHosts;
   }
 
-  public getServerByPort(port: number): SocketEventsHost {
-    return this.observableServers.get(`${port}`);
+  public getSocketEventsHostByPort(port: number): SocketEventsHost {
+    return this.socketEventHosts.get(`${port}`);
   }
 
-  public addServer(
+  public addSocketEventsHost(
     namespace: string | RegExp,
     port: number,
-    server: SocketEventsHost,
+    host: SocketEventsHost,
   ) {
-    this.observableServers.set(
+    this.socketEventHosts.set(
       namespace ? `${namespace}:${port}` : `${port}`,
-      server,
+      host,
     );
   }
 
   public clear() {
-    this.observableServers.clear();
+    this.socketEventHosts.clear();
   }
 }

packages/websockets/test/container.spec.ts

@@ -1,6 +1,6 @@
-import * as sinon from 'sinon';
 import { expect } from 'chai';
-import { SocketsContainer } from '../container';
+import * as sinon from 'sinon';
+import { SocketsContainer } from '../sockets-container';
 
 describe('SocketsContainer', () => {
   const namespace = 'test';
@@ -13,37 +13,37 @@ describe('SocketsContainer', () => {
     setSpy = sinon.spy();
     getSpy = sinon.spy();
     instance = new SocketsContainer();
-    (<any>instance)['observableServers'] = {
+    (instance as any).socketEventHosts = {
       get: getSpy,
       set: setSpy,
     };
   });
-  describe('getSocketServer', () => {
-    it(`should call "observableServers" get method with expected arguments`, () => {
-      instance.getServerByPort(port);
+  describe('getSocketEventsHostByPort', () => {
+    it(`should call "socketEventHosts" get method with expected arguments`, () => {
+      instance.getSocketEventsHostByPort(port);
       expect(getSpy.calledWith({ namespace, port }));
     });
   });
-  describe('storeObservableServer', () => {
-    it(`should call "observableServers" set method with expected arguments`, () => {
+  describe('addSocketEventsHost', () => {
+    it(`should call "socketEventHosts" set method with expected arguments`, () => {
       const server = {};
-      instance.addServer(namespace, port, <any>server);
+      instance.addSocketEventsHost(namespace, port, server as any);
       expect(setSpy.calledWith({ namespace, port }, server));
     });
   });
-  describe('getAllServers', () => {
-    it('should return "observableServers"', () => {
+  describe('getAllSocketEventHosts', () => {
+    it('should return "socketEventHosts"', () => {
       const collection = ['test'];
-      (instance as any).observableServers = collection;
-      expect(instance.getAllServers()).to.be.eq(collection);
+      (instance as any).socketEventHosts = collection;
+      expect(instance.getAllSocketEventHosts()).to.be.eq(collection);
     });
   });
   describe('clear', () => {
-    it('should clear servers collection', () => {
+    it('should clear hosts collection', () => {
       const collection = { clear: sinon.spy() };
-      (instance as any).observableServers = collection;
+      (instance as any).socketEventHosts = collection;
       instance.clear();
       expect(collection.clear.called).to.be.true;
     });
-  })
+  });
 });

packages/websockets/test/socket-events-host-factory.ts

@@ -1,12 +1,12 @@
 import { expect } from 'chai';
-import { ObservableSocket } from '../observable-socket';
 import { ReplaySubject, Subject } from 'rxjs';
+import { SocketEventsHostFactory } from '../socket-events-host-factory';
 
-describe('ObservableSocket', () => {
+describe('SocketEventsHostFactory', () => {
   describe('create', () => {
     it(`should return expected observable socket object`, () => {
       const server = { test: 'test' };
-      const result = ObservableSocket.create(server);
+      const result = SocketEventsHostFactory.create(server);
 
       expect(result).to.have.keys('init', 'connection', 'disconnect', 'server');
       expect(result.init instanceof ReplaySubject).to.be.true;

packages/websockets/test/socket-server-provider.spec.ts

@@ -1,8 +1,8 @@
 import { ApplicationConfig } from '@nestjs/core/application-config';
 import { expect } from 'chai';
 import * as sinon from 'sinon';
-import { SocketsContainer } from '../container';
 import { SocketServerProvider } from '../socket-server-provider';
+import { SocketsContainer } from '../sockets-container';
 import { AbstractWsAdapter } from './../adapters/ws-adapter';
 
 class NoopAdapter extends AbstractWsAdapter {
@@ -35,7 +35,7 @@ describe('SocketServerProvider', () => {
     });
     it(`should returns stored server`, () => {
       const server = { test: 'test' };
-      mockContainer.expects('getServerByPort').returns(server);
+      mockContainer.expects('getSocketEventsHostByPort').returns(server);
 
       const result = instance.scanForSocketServer({ namespace: null }, port);
 
@@ -43,7 +43,7 @@ describe('SocketServerProvider', () => {
       expect(result).to.eq(server);
     });
     it(`should call "createSocketServer" when server is not stored already`, () => {
-      mockContainer.expects('getServerByPort').returns(null);
+      mockContainer.expects('getSocketEventsHostByPort').returns(null);
 
       instance.scanForSocketServer({ namespace }, port);
       expect(createSocketServerSpy.called).to.be.true;

packages/websockets/test/web-sockets-controller.spec.ts

@@ -48,7 +48,7 @@ describe('WebSocketsController', () => {
     );
   });
   describe('mergeGatewayAndServer', () => {
-    let subscribeObservableServer: sinon.SinonSpy;
+    let subscribeToServerEvents: sinon.SinonSpy;
 
     @WebSocketGateway('test' as any)
     class InvalidGateway {}
@@ -57,8 +57,8 @@ describe('WebSocketsController', () => {
     class DefaultGateway {}
 
     beforeEach(() => {
-      subscribeObservableServer = sinon.spy();
-      (instance as any).subscribeObservableServer = subscribeObservableServer;
+      subscribeToServerEvents = sinon.spy();
+      (instance as any).subscribeToServerEvents = subscribeToServerEvents;
     });
     it('should throws "InvalidSocketPortException" when port is not a number', () => {
       Reflect.defineMetadata(PORT_METADATA, 'test', InvalidGateway);
@@ -70,21 +70,20 @@ describe('WebSocketsController', () => {
         ),
       ).throws(InvalidSocketPortException);
     });
-    it('should call "subscribeObservableServer" with default values when metadata is empty', () => {
+    it('should call "subscribeToServerEvents" with default values when metadata is empty', () => {
       const gateway = new DefaultGateway();
       instance.mergeGatewayAndServer(gateway, DefaultGateway, '');
-      expect(subscribeObservableServer.calledWith(gateway, {}, 0, '')).to.be
-        .true;
+      expect(subscribeToServerEvents.calledWith(gateway, {}, 0, '')).to.be.true;
     });
-    it('should call "subscribeObservableServer" when metadata is valid', () => {
+    it('should call "subscribeToServerEvents" when metadata is valid', () => {
       const gateway = new Test();
       instance.mergeGatewayAndServer(gateway, Test, '');
       expect(
-        subscribeObservableServer.calledWith(gateway, { namespace }, port, ''),
+        subscribeToServerEvents.calledWith(gateway, { namespace }, port, ''),
       ).to.be.true;
     });
   });
-  describe('subscribeObservableServer', () => {
+  describe('subscribeToServerEvents', () => {
     let explorer: GatewayMetadataExplorer,
       mockExplorer: sinon.SinonMock,
       gateway,
@@ -112,11 +111,11 @@ describe('WebSocketsController', () => {
       (instance as any).subscribeEvents = subscribeEvents;
     });
     it('should call "hookServerToProperties" with expected arguments', () => {
-      instance.subscribeObservableServer(gateway, namespace, port, '');
+      instance.subscribeToServerEvents(gateway, namespace, port, '');
       expect(hookServerToProperties.calledWith(gateway, server.server));
     });
     it('should call "subscribeEvents" with expected arguments', () => {
-      instance.subscribeObservableServer(gateway, namespace, port, '');
+      instance.subscribeToServerEvents(gateway, namespace, port, '');
       expect(subscribeEvents.calledWith(gateway, handlers, server));
     });
   });