Skip to content

Sync-in · Sovereign platform for file storage, sharing, synchronization, and collaboration.

3.0 KB
Raw Blame
import 'reflect-metadata'
import { Socket } from 'socket.io'
import type { Mock } from 'vitest'
import { UserModel } from '../../../applications/users/models/user.model.js'
import { TOKEN_TYPE } from '../../../authentication/interfaces/token.interface.js'
import { configuration } from '../../../configuration/config.environment.js'
import { WebSocketAdapter } from './web-socket.adapter.js'

describe(WebSocketAdapter.name, () => {
  const token = 'signed-token'
  const identity = { id: 1, login: 'foo' }
  let adapter: WebSocketAdapter
  let fastify: { parseCookie: ReturnType<typeof vi.fn> }
  let jwtService: { verify: ReturnType<typeof vi.fn> }
  let usersManager: { fromAuthToken: ReturnType<typeof vi.fn> }
  let socket: Socket
  let next: Mock<(err?: Error) => void>

  beforeEach(() => {
    jwtService = {
      verify: vi.fn()
    }
    usersManager = {
      fromAuthToken: vi.fn(async (user: UserModel): Promise<UserModel | null> => user)
    }
    fastify = {
      parseCookie: vi.fn(() => ({ [configuration.auth.token.ws.name]: token }))
    }
    adapter = Object.create(WebSocketAdapter.prototype)
    Object.assign(adapter, {
      fastify,
      jwtService,
      usersManager,
      logger: {
        warn: vi.fn()
      }
    })
    socket = {
      request: {
        headers: {
          cookie: `${configuration.auth.token.ws.name}=${token}`
        }
      },
      handshake: {
        address: '127.0.0.1',
        headers: {
          'user-agent': 'vitest'
        },
        url: '/'
      },
      id: 'socket-id'
    } as unknown as Socket
    next = vi.fn<(err?: Error) => void>()
  })

  it('should authenticate a socket with a WebSocket token', async () => {
    jwtService.verify.mockReturnValue({
      tokenType: TOKEN_TYPE.WS,
      identity
    })

    await adapter['authenticateSocket'](socket, next)

    expect(fastify.parseCookie).toHaveBeenCalledWith(`${configuration.auth.token.ws.name}=${token}`)
    expect(jwtService.verify).toHaveBeenCalledWith(token, {
      secret: configuration.auth.token.ws.secret
    })
    expect(usersManager.fromAuthToken).toHaveBeenCalledOnce()
    expect(socket).toHaveProperty('user')
    expect(next).toHaveBeenCalledWith()
  })

  it.each([TOKEN_TYPE.ACCESS, TOKEN_TYPE.REFRESH, undefined])('should reject a token with type %s', async (tokenType) => {
    jwtService.verify.mockReturnValue({
      tokenType,
      identity
    })

    await adapter['authenticateSocket'](socket, next)

    expect(socket).not.toHaveProperty('user')
    expect(next).toHaveBeenCalledOnce()
    expect(next.mock.calls[0][0]).toMatchObject({
      message: 'Unauthorized'
    })
  })

  it('should reject a WebSocket token when the current user is unavailable', async () => {
    jwtService.verify.mockReturnValue({
      tokenType: TOKEN_TYPE.WS,
      identity
    })
    usersManager.fromAuthToken.mockResolvedValue(null)

    await adapter['authenticateSocket'](socket, next)

    expect(socket).not.toHaveProperty('user')
    expect(next.mock.calls[0][0]).toMatchObject({
      message: 'Unauthorized'
    })
  })
})