test: unit test a successful name update

- also allow to only pass 1 parameter to the loggers

src/shared/logger/console.logger.spec.ts

@@ -18,7 +18,8 @@ describe('Loggers', () => {
       try {
         logger.info(infos[0].context, infos[0].message)
         logger.error(errors[0].context, errors[0].message)
-        logger.info(infos[1].context, infos[1].message)
+        logger.info(infos[1].context)
+        logger.error(errors[0].context)
         done()
       } catch (e) {
         done(e)

src/shared/logger/console.logger.ts

@@ -1,9 +1,9 @@
 import { MockLogger } from './mock.logger'
 
 export class ConsoleLogger extends MockLogger {
-  public error = (context: string, message: string): void =>
+  public error = (context: string, message?: string): void =>
     console.error(MockLogger.forgeLog(context, message))
-  public info = (context: string, message: string): void =>
+  public info = (context: string, message?: string): void =>
     console.info(MockLogger.forgeLog(context, message))
   public getInfoLogs = (): string[] => {
     throw new ReferenceError('Not implemented')

src/shared/logger/mock.logger.spec.ts

@@ -12,12 +12,12 @@ describe('Loggers', () => {
       expect(logger.getInfoLogs()).to.have.length(0)
     })
 
-    it('should concatenate the context and message strings', () => {
+    it('should concatenate context and message (if present)', () => {
       // arrange
       const strings = [
         { context: 'in a function', message: 'undefined variable' },
-        { context: 'at startup', message: 'server started normally' },
         { context: 'at shutdown', message: 'server stopped normally' },
+        { context: 'at shutdown' },
       ]
 
       // assert
@@ -26,10 +26,10 @@ describe('Loggers', () => {
       ).to.equal('in a function - undefined variable')
       expect(
         MockLogger.forgeLog(strings[1].context, strings[1].message)
-      ).to.equal('at startup - server started normally')
+      ).to.equal('at shutdown - server stopped normally')
       expect(
         MockLogger.forgeLog(strings[2].context, strings[2].message)
-      ).to.equal('at shutdown - server stopped normally')
+      ).to.equal('at shutdown')
     })
 
     it('should keep track of error and info logs', () => {

src/shared/logger/mock.logger.ts

@@ -4,15 +4,15 @@ export class MockLogger {
     private infoLogs: string[] = []
   ) {}
 
-  public error = (context: string, message: string): void => {
+  public error = (context: string, message?: string): void => {
     this.errorLogs.push(MockLogger.forgeLog(context, message))
   }
-  public info = (context: string, message: string): void => {
+  public info = (context: string, message?: string): void => {
     this.infoLogs.push(MockLogger.forgeLog(context, message))
   }
 
-  public static forgeLog = (context: string, message: string): string =>
-    `${context} - ${message}`
+  public static forgeLog = (context: string, message?: string): string =>
+    message ? `${context} - ${message}` : context
 
   public getErrorLogs(): string[] {
     return this.errorLogs

src/socket.io/socket.spec.ts

@@ -61,10 +61,47 @@ describe('Server', () => {
       })
 
       describe('update-user-name', () => {
-        it('should log info message for empty name and access should be false', (done: Function) => {
+        it('should log info message for empty data and updated should be false', (done: Function) => {
+          // arrange
+          const updateUserNameEventArgs: undefined = undefined
+          const updateUserNameEvent = new UpdateUserNameEvent(
+            updateUserNameEventArgs
+          )
+
+          new Promise(resolve =>
+            client.on('connect', () => {
+              // act
+              client.emit(
+                UpdateUserNameEvent.eventName,
+                updateUserNameEvent.data,
+                (value: UpdateUserNameAckArgs) => resolve(value)
+              )
+            })
+          )
+            .then((value: UpdateUserNameAckArgs) => {
+              // assert
+              expect(value).to.not.be.undefined
+              expect(value).to.have.property('updated', false)
+              expect(value).to.have.property('error')
+              expect(value.error).to.have.property('name', 'Error')
+              expect(value.error).to.have.property(
+                'message',
+                `Parameter data is required`
+              )
+
+              const logs = mockLogger.getInfoLogs()
+              logs.should.include.something.that.equals(
+                `User name could not be updated - Parameter data is required`
+              )
+              done()
+            })
+            .catch(e => done(e))
+        })
+
+        it('should log info message for empty name and updated should be false', (done: Function) => {
           // arrange
           const expectedParameter: string = 'name'
-          const updateUserNameEventArgs: { name: string } = { name: '' }
+          const updateUserNameEventArgs: UpdateUserNameEventArgs = { name: '' }
           const updateUserNameEvent = new UpdateUserNameEvent(
             updateUserNameEventArgs
           )
@@ -98,6 +135,38 @@ describe('Server', () => {
             })
             .catch(e => done(e))
         })
+
+        it('should log info message for correct name, updated should be true and error should not exist', (done: Function) => {
+          // arrange
+          const updateUserNameEventArgs: UpdateUserNameEventArgs = {
+            name: 'George',
+          }
+          const updateUserNameEvent = new UpdateUserNameEvent(
+            updateUserNameEventArgs
+          )
+
+          new Promise(resolve =>
+            client.on('connect', () => {
+              // act
+              client.emit(
+                UpdateUserNameEvent.eventName,
+                updateUserNameEvent.data,
+                (value: UpdateUserNameAckArgs) => resolve(value)
+              )
+            })
+          )
+            .then((value: UpdateUserNameAckArgs) => {
+              // assert
+              expect(value).to.not.be.undefined
+              expect(value).to.have.property('updated', true)
+              expect(value).to.not.have.property('error')
+
+              const logs = mockLogger.getInfoLogs()
+              logs.should.include.something.that.equals(`User name updated`)
+              done()
+            })
+            .catch(e => done(e))
+        })
       })
 
       //

src/socket.io/socket.ts

@@ -16,7 +16,10 @@ class Socket {
     this.io
       .of('/occupapp-beta')
       .on(ConnectionEvent.eventName, (socket: SocketIOClient.Socket) => {
-        const socketUser: User = this.getOrCreateUser(socket.id)
+        // Note that a new socket (and this socket.id) is created on each
+        // connection. There is no persistence for a same user between
+        // connections
+        const socketUser: User = this.createUser(socket.id)
 
         socket.on(
           UpdateUserNameEvent.eventName,
@@ -48,6 +51,7 @@ class Socket {
           // TODO: alternative: send mutation : room-guest-name-updated
           // this.emitLoggedUsersToRoom(socket, room)
 
+          this.log.info('User name updated')
           ack({ updated: true })
         }
 
@@ -101,15 +105,11 @@ class Socket {
       })
   }
 
-  private getOrCreateUser = (id: SocketIOClient.Socket['id']): User => {
-    const user = this.users.get(id)
-    if (user === undefined) {
-      const newUser = new User(id)
-      this.users.set(id, newUser)
-      this.log.info(`getOrCreateUser`, `New user created for socket ${id}`)
-      return newUser
-    }
-    return user
+  private createUser = (id: SocketIOClient.Socket['id']): User => {
+    const newUser = new User(id)
+    this.users.set(id, newUser)
+    this.log.info(`getOrCreateUser`, `New user created for socket ${id}`)
+    return newUser
   }
 
   // private emitInternalServerError(socket: SocketIOClient.Socket, error: Error) {