Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

10.1 KB
Raw Blame
import { beforeEach, describe, expect, it, vi } from 'vitest'

const findMany = vi.hoisted(() => vi.fn())
const findFirst = vi.hoisted(() => vi.fn())
const update = vi.hoisted(() => vi.fn())
const updateMany = vi.hoisted(() => vi.fn())
const getDevicePresence = vi.hoisted(() => vi.fn())
const count = vi.hoisted(() => vi.fn())
const create = vi.hoisted(() => vi.fn())
const consumeNewIdQuota = vi.hoisted(() => vi.fn())
const findUnique = vi.hoisted(() => vi.fn())
const publishDeviceStatus = vi.hoisted(() => vi.fn())

vi.mock('../lib/prisma.js', () => ({
  prisma: {
    deviceBinding: { findMany, findFirst, findUnique, count, create, update, updateMany },
    machine: { findMany: vi.fn() },
  },
  machineAlive: {},
}))
vi.mock('../lib/bus.js', () => ({ getDevicePresence, consumeNewIdQuota, publishDeviceStatus }))

import { Prisma } from '@prisma/client'
import { deviceService } from './DeviceService.js'

const device = (over: Record<string, unknown> = {}): Record<string, unknown> => ({
  id: 'row1',
  userId: 'u1',
  deviceId: 'dev-1',
  machineId: null,
  authMode: 'sds',
  macAddress: 'AA:BB:CC:DD:EE:FF',
  tokenHash: 'h',
  name: 'device',
  lastSeenAt: new Date('2026-08-01T00:00:00Z'),
  createdAt: new Date('2026-07-01T00:00:00Z'),
  firmwareVersion: '0.2.8',
  chip: 'esp32s3',
  ssid: null,
  rssi: null,
  activeMachineId: null,
  ...over,
})

beforeEach(() => {
  vi.clearAllMocks()
  findUnique.mockResolvedValue(null)
  publishDeviceStatus.mockResolvedValue(1)
  updateMany.mockResolvedValue({ count: 1 })
  getDevicePresence.mockResolvedValue(false)
})

describe('listDetailedForUser', () => {
  it('takes `online` from live presence, NOT from lastSeenAt', async () => {
    // lastSeenAt is bumped by any token authenticate() call and says nothing about a live socket.
    findMany.mockResolvedValue([device({ deviceId: 'a' }), device({ deviceId: 'b' })])
    getDevicePresence.mockImplementation(async (id: string) => id === 'a')

    const rows = await deviceService.listDetailedForUser('u1')

    expect(rows.map((r) => [r.deviceId, r.online])).toEqual([['a', true], ['b', false]])
  })

  it('carries the reported hardware fields through', async () => {
    findMany.mockResolvedValue([device({ ssid: 'Home', rssi: -52, activeMachineId: 'h1' })])

    const [row] = await deviceService.listDetailedForUser('u1')

    expect(row).toMatchObject({
      firmwareVersion: '0.2.8', chip: 'esp32s3', ssid: 'Home', rssi: -52, activeMachineId: 'h1',
    })
  })

  it('reports macAddress as null — the column left with the SDS path', () => {
    // The field stays in the response shape so the mobile app's parser is unaffected; a computer-backed
    // device has a hostname, not a MAC, so there is nothing true to put in it.
    findMany.mockResolvedValue([device()])
    return deviceService.listDetailedForUser('u1').then(([row]) => {
      expect(row.macAddress).toBeNull()
    })
  })

  it('never exposes the token hash', async () => {
    findMany.mockResolvedValue([device()])
    const [row] = await deviceService.listDetailedForUser('u1')
    expect(JSON.stringify(row)).not.toContain('tokenHash')
    expect(JSON.stringify(row)).not.toContain('"h"')
  })
})

describe('recordHello', () => {
  it('writes only the keys the device actually sent', async () => {
    // Firmware without the WiFi fields must not blank values a newer build already recorded.
    await deviceService.recordHello({ deviceId: 'dev-1', firmwareVersion: '0.2.9', chip: 'esp32s3' })

    expect(updateMany).toHaveBeenCalledWith({
      where: { deviceId: 'dev-1' },
      data: { firmwareVersion: '0.2.9', chip: 'esp32s3' },
    })
  })

  it('drops rssi 0 — the firmware sentinel for unknown/disconnected', async () => {
    await deviceService.recordHello({ deviceId: 'dev-1', ssid: 'Home', rssi: 0 })

    expect(updateMany).toHaveBeenCalledWith({ where: { deviceId: 'dev-1' }, data: { ssid: 'Home' } })
  })

  it('stores a real negative rssi', async () => {
    await deviceService.recordHello({ deviceId: 'dev-1', rssi: -52 })
    expect(updateMany).toHaveBeenCalledWith({ where: { deviceId: 'dev-1' }, data: { rssi: -52 } })
  })

  it('does not touch the DB when the device reported nothing usable', async () => {
    await deviceService.recordHello({ deviceId: 'dev-1', firmwareVersion: null, chip: null })
    expect(updateMany).not.toHaveBeenCalled()
  })

  it('swallows a DB failure — this runs on the device socket hot path', async () => {
    updateMany.mockRejectedValue(new Error('mongo down'))
    await expect(deviceService.recordHello({ deviceId: 'dev-1', chip: 'esp32s3' })).resolves.toBeUndefined()
  })
})

describe('setActiveMachine', () => {
  it('persists the pointer', async () => {
    await deviceService.setActiveMachine('dev-1', 'h1')
    expect(updateMany).toHaveBeenCalledWith({ where: { deviceId: 'dev-1' }, data: { activeMachineId: 'h1' } })
  })

  it('persists an explicit null when the machine goes away', async () => {
    await deviceService.setActiveMachine('dev-1', null)
    expect(updateMany).toHaveBeenCalledWith({ where: { deviceId: 'dev-1' }, data: { activeMachineId: null } })
  })

  it('swallows a DB failure', async () => {
    updateMany.mockRejectedValue(new Error('mongo down'))
    await expect(deviceService.setActiveMachine('dev-1', 'h1')).resolves.toBeUndefined()
  })
})

describe('rename', () => {
  it('refuses a device that is not the caller-s', async () => {
    findFirst.mockResolvedValue(null)

    expect(await deviceService.rename('dev-1', 'someone-else', 'Kitchen')).toBeNull()
    expect(update).not.toHaveBeenCalled()
  })

  it('scopes the lookup by userId, so ownership cannot be bypassed', async () => {
    findFirst.mockResolvedValue(device())
    update.mockResolvedValue(device({ name: 'Kitchen' }))

    await deviceService.rename('dev-1', 'u1', 'Kitchen')

    expect(findFirst).toHaveBeenCalledWith({ where: { deviceId: 'dev-1', userId: 'u1' } })
    expect(update).toHaveBeenCalledWith({ where: { id: 'row1' }, data: { name: 'Kitchen' } })
  })

  it('returns the renamed device with its live online state', async () => {
    findFirst.mockResolvedValue(device())
    update.mockResolvedValue(device({ name: 'Kitchen' }))
    getDevicePresence.mockResolvedValue(true)

    const row = await deviceService.rename('dev-1', 'u1', 'Kitchen')

    expect(row).toMatchObject({ name: 'Kitchen', online: true })
  })
})

describe('detailForUser', () => {
  it('is null for another user-s device', async () => {
    findFirst.mockResolvedValue(null)
    expect(await deviceService.detailForUser('dev-1', 'u2')).toBeNull()
  })
})

describe('resolveOrCreateForComputer', () => {
  const resolve = () => deviceService.resolveOrCreateForComputer('u1', 'prod', 'a'.repeat(32), 'laptop')

  const notFound = () => new Prisma.PrismaClientKnownRequestError('missing', { code: 'P2025', clientVersion: 'x' })

  beforeEach(() => {
    count.mockResolvedValue(0)
    consumeNewIdQuota.mockResolvedValue(true)
    create.mockImplementation(async ({ data }: { data: Record<string, unknown> }) => device(data))
    // Default: no row yet — the touch misses. A test that wants a known device overrides once.
    update.mockRejectedValueOnce(notFound())
    update.mockImplementation(async ({ where }: { where: { deviceId: string } }) => device({ deviceId: where.deviceId }))
  })

  it('a known device reconnects in one write, without touching the ceiling or the new-id quota', async () => {
    update.mockReset()
    update.mockResolvedValue(device())
    await resolve()
    expect(update).toHaveBeenCalledOnce()
    expect(count).not.toHaveBeenCalled()
    expect(consumeNewIdQuota).not.toHaveBeenCalled()
    expect(create).not.toHaveBeenCalled()
  })

  it('rethrows a touch failure that is not "no such row"', async () => {
    update.mockReset()
    update.mockRejectedValue(new Error('mongo down'))
    await expect(resolve()).rejects.toThrow('mongo down')
    expect(create).not.toHaveBeenCalled()
  })

  it('a new device spends one new-id and is created with a derived id', async () => {
    const row = await resolve()
    expect(consumeNewIdQuota).toHaveBeenCalledWith('device', 'u1')
    expect(create).toHaveBeenCalledOnce()
    expect(row.deviceId).toMatch(/^cmp-[0-9a-f]{24}$/)
  })

  it('refuses a new device past the per-account ceiling with 409, before spending quota', async () => {
    count.mockResolvedValue(20)
    await expect(resolve()).rejects.toMatchObject({ statusCode: 409, code: 'TOO_MANY_DEVICES' })
    expect(consumeNewIdQuota).not.toHaveBeenCalled()
    expect(create).not.toHaveBeenCalled()
  })

  it('refuses a new device over the new-id rate with 429', async () => {
    consumeNewIdQuota.mockResolvedValue(false)
    await expect(resolve()).rejects.toMatchObject({ statusCode: 429, code: 'NEW_DEVICE_RATE_LIMITED' })
    expect(create).not.toHaveBeenCalled()
  })

  it('a lost create race converges on the winner\'s row', async () => {
    create.mockRejectedValue(new Prisma.PrismaClientKnownRequestError('dup', { code: 'P2002', clientVersion: 'x' }))
    findUnique.mockResolvedValueOnce(null).mockResolvedValue({ userId: 'u1' })
    await resolve()
    expect(update).toHaveBeenCalledTimes(2) // the missed touch, then the converging one
  })

  // Review of #2159: the previous owner's open web sockets keep their own copy of the account's devices (lib/webWs.ts).
  it('a computer another account held moves to this one, and its previous owner is told it is gone', async () => {
    findUnique.mockResolvedValue({ userId: 'u0' })
    const row = await resolve()
    expect(row).toMatchObject({ userId: 'u1' })
    expect(update).toHaveBeenLastCalledWith(expect.objectContaining({ data: expect.objectContaining({ userId: 'u1' }) }))
    expect(publishDeviceStatus).toHaveBeenCalledWith('u0', { deviceId: row.deviceId, online: false, removed: true })
    expect(create).not.toHaveBeenCalled()
  })

  it('a reconnect of the owner\'s own computer tells nobody', async () => {
    update.mockReset()
    update.mockResolvedValue(device())
    await resolve()
    expect(publishDeviceStatus).not.toHaveBeenCalled()
  })

  it('the reconnect write matches only the owner\'s own row', async () => {
    update.mockReset()
    update.mockResolvedValue(device())
    await resolve()
    expect(update.mock.calls[0]![0].where).toMatchObject({ userId: 'u1' })
  })
})