screeps-connectivity 0.2.0

package/tests/http/endpoints/game.test.ts

@@ -0,0 +1,210 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { HttpClient } from '../../../src/http/HttpClient.js'
+import { TokenAuth } from '../../../src/http/auth/TokenAuth.js'
+
+function mockResponse(body: unknown, opts: ResponseInit = {}): Response {
+  return new Response(JSON.stringify(body), {
+    status: 200,
+    headers: { 'content-type': 'application/json', ...opts.headers },
+    ...opts,
+  })
+}
+
+describe('game endpoints', () => {
+  let fetchMock: ReturnType<typeof vi.fn>
+
+  beforeEach(() => {
+    fetchMock = vi.fn()
+    vi.stubGlobal('fetch', fetchMock)
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it('createFlag sends POST to /api/game/create-flag', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1 }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+
+    await http.game.createFlag('E2N2', 15, 25, 'MyFlag', 1, 2, 'shard1')
+
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(url).toContain('/api/game/create-flag')
+    expect(init.method).toBe('POST')
+    expect(JSON.parse(init.body as string)).toEqual({
+      room: 'E2N2',
+      x: 15,
+      y: 25,
+      name: 'MyFlag',
+      color: 1,
+      secondaryColor: 2,
+      shard: 'shard1',
+    })
+  })
+
+  it('createFlag omits shard when not provided', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1 }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+
+    await http.game.createFlag('E2N2', 15, 25, 'MyFlag', 1, 2)
+
+    const [, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(JSON.parse(init.body as string)).toEqual({
+      room: 'E2N2',
+      x: 15,
+      y: 25,
+      name: 'MyFlag',
+      color: 1,
+      secondaryColor: 2,
+    })
+  })
+
+  it('genUniqueFlagName sends POST to /api/game/gen-unique-flag-name', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1, name: 'Flag1' }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+
+    const res = await http.game.genUniqueFlagName()
+
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(url).toContain('/api/game/gen-unique-flag-name')
+    expect(init.method).toBe('POST')
+    expect(res.name).toBe('Flag1')
+  })
+
+  it('checkUniqueFlagName sends POST to /api/game/check-unique-flag-name', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1 }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+
+    await http.game.checkUniqueFlagName('MyFlag')
+
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(url).toContain('/api/game/check-unique-flag-name')
+    expect(init.method).toBe('POST')
+    expect(JSON.parse(init.body as string)).toEqual({ name: 'MyFlag' })
+  })
+
+  it('genUniqueObjectName sends POST with type', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1, name: 'Spawn1' }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+    const res = await http.game.genUniqueObjectName('spawn')
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('POST')
+    expect(url).toContain('/api/game/gen-unique-object-name')
+    expect(JSON.parse(init.body as string)).toEqual({ type: 'spawn' })
+    expect(res.name).toBe('Spawn1')
+  })
+
+  it('checkUniqueObjectName sends POST with type and name', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1 }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+    await http.game.checkUniqueObjectName('spawn', 'Spawn1')
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('POST')
+    expect(url).toContain('/api/game/check-unique-object-name')
+    expect(JSON.parse(init.body as string)).toEqual({ type: 'spawn', name: 'Spawn1' })
+  })
+
+  it('placeSpawn sends POST with room, x, y', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1 }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+    await http.game.placeSpawn('W1N1', 10, 20)
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('POST')
+    expect(url).toContain('/api/game/place-spawn')
+    expect(JSON.parse(init.body as string)).toEqual({ room: 'W1N1', x: 10, y: 20 })
+  })
+
+  it('placeSpawn includes name when provided', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1 }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+    await http.game.placeSpawn('W1N1', 10, 20, 'Spawn1')
+    const body = JSON.parse(fetchMock.mock.calls[0][1].body as string)
+    expect(body).toEqual({ room: 'W1N1', x: 10, y: 20, name: 'Spawn1' })
+  })
+
+  it('placeSpawn includes shard when provided', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1 }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+    await http.game.placeSpawn('W1N1', 10, 20, 'Spawn1', 'shard0')
+    const body = JSON.parse(fetchMock.mock.calls[0][1].body as string)
+    expect(body).toEqual({ room: 'W1N1', x: 10, y: 20, name: 'Spawn1', shard: 'shard0' })
+  })
+
+  it('createConstruction sends POST with required fields', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1 }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+    await http.game.createConstruction('W1N1', 5, 5, 'extension')
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('POST')
+    expect(url).toContain('/api/game/create-construction')
+    expect(JSON.parse(init.body as string)).toEqual({ room: 'W1N1', x: 5, y: 5, structureType: 'extension' })
+  })
+
+  it('addObjectIntent sends POST with _id mapping', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1 }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+    await http.game.addObjectIntent('obj-id', 'W1N1', 'attack', { targetId: 'x' })
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('POST')
+    expect(url).toContain('/api/game/add-object-intent')
+    expect(JSON.parse(init.body as string)).toEqual({ _id: 'obj-id', room: 'W1N1', name: 'attack', intent: { targetId: 'x' } })
+  })
+
+  it('addGlobalIntent sends POST with name and intent', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1 }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+    await http.game.addGlobalIntent('respawn', {})
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('POST')
+    expect(url).toContain('/api/game/add-global-intent')
+    expect(JSON.parse(init.body as string)).toEqual({ name: 'respawn', intent: {} })
+  })
+
+  it('setNotifyWhenAttacked sends POST with _id mapping', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1 }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+    await http.game.setNotifyWhenAttacked('struct-id', true)
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('POST')
+    expect(url).toContain('/api/game/set-notify-when-attacked')
+    expect(JSON.parse(init.body as string)).toEqual({ _id: 'struct-id', enabled: true })
+  })
+
+  it('createInvader sends POST with required fields', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1 }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+    await http.game.createInvader('W1N1', 10, 10, 1, 'melee')
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('POST')
+    expect(url).toContain('/api/game/create-invader')
+    expect(JSON.parse(init.body as string)).toEqual({ room: 'W1N1', x: 10, y: 10, size: 1, type: 'melee' })
+  })
+
+  it('createInvader includes boosted when provided', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1 }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+    await http.game.createInvader('W1N1', 10, 10, 1, 'melee', true)
+    const body = JSON.parse(fetchMock.mock.calls[0][1].body as string)
+    expect(body.boosted).toBe(true)
+  })
+
+  it('removeInvader sends POST with _id mapping', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1 }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+    await http.game.removeInvader('inv-id')
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('POST')
+    expect(url).toContain('/api/game/remove-invader')
+    expect(JSON.parse(init.body as string)).toEqual({ _id: 'inv-id' })
+  })
+
+  it('tick sends GET to /api/game/tick', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1, tick: 500 }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+    const res = await http.game.tick()
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('GET')
+    expect(url).toContain('/api/game/tick')
+    expect(res.tick).toBe(500)
+  })
+})

package/tests/http/endpoints/power-creeps.test.ts

@@ -0,0 +1,81 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { HttpClient } from '../../../src/http/HttpClient.js'
+import { TokenAuth } from '../../../src/http/auth/TokenAuth.js'
+
+function mockResponse(body: unknown, opts: ResponseInit = {}): Response {
+  return new Response(JSON.stringify(body), {
+    status: 200,
+    headers: { 'content-type': 'application/json', ...opts.headers },
+    ...opts,
+  })
+}
+
+describe('game.powerCreeps endpoints', () => {
+  let fetchMock: ReturnType<typeof vi.fn>
+  let http: HttpClient
+
+  beforeEach(() => {
+    fetchMock = vi.fn().mockResolvedValue(mockResponse({ ok: 1 }))
+    vi.stubGlobal('fetch', fetchMock)
+    http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it('list sends GET to /api/game/power-creeps/list', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1, list: [] }))
+    await http.game.powerCreeps.list()
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('GET')
+    expect(url).toContain('/api/game/power-creeps/list')
+  })
+
+  it('create sends POST with name and className', async () => {
+    await http.game.powerCreeps.create('MyPC', 'operator')
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('POST')
+    expect(url).toContain('/api/game/power-creeps/create')
+    expect(JSON.parse(init.body as string)).toEqual({ name: 'MyPC', className: 'operator' })
+  })
+
+  it('delete sends POST with id', async () => {
+    await http.game.powerCreeps.delete('pc-id')
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('POST')
+    expect(url).toContain('/api/game/power-creeps/delete')
+    expect(JSON.parse(init.body as string)).toEqual({ id: 'pc-id' })
+  })
+
+  it('cancelDelete sends POST with id', async () => {
+    await http.game.powerCreeps.cancelDelete('pc-id')
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('POST')
+    expect(url).toContain('/api/game/power-creeps/cancel-delete')
+    expect(JSON.parse(init.body as string)).toEqual({ id: 'pc-id' })
+  })
+
+  it('upgrade sends POST with id and powers', async () => {
+    await http.game.powerCreeps.upgrade('pc-id', { OPERATE_SPAWN: 2 })
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('POST')
+    expect(url).toContain('/api/game/power-creeps/upgrade')
+    expect(JSON.parse(init.body as string)).toEqual({ id: 'pc-id', powers: { OPERATE_SPAWN: 2 } })
+  })
+
+  it('rename sends POST with id and name', async () => {
+    await http.game.powerCreeps.rename('pc-id', 'NewName')
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('POST')
+    expect(url).toContain('/api/game/power-creeps/rename')
+    expect(JSON.parse(init.body as string)).toEqual({ id: 'pc-id', name: 'NewName' })
+  })
+
+  it('experimentation sends POST to /api/game/power-creeps/experimentation', async () => {
+    await http.game.powerCreeps.experimentation()
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('POST')
+    expect(url).toContain('/api/game/power-creeps/experimentation')
+  })
+})

package/tests/http/endpoints/user-messages.test.ts

@@ -0,0 +1,68 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { HttpClient } from '../../../src/http/HttpClient.js'
+import { TokenAuth } from '../../../src/http/auth/TokenAuth.js'
+
+function mockResponse(body: unknown, opts: ResponseInit = {}): Response {
+  return new Response(JSON.stringify(body), {
+    status: 200,
+    headers: { 'content-type': 'application/json', ...opts.headers },
+    ...opts,
+  })
+}
+
+describe('user.messages endpoints', () => {
+  let fetchMock: ReturnType<typeof vi.fn>
+  let http: HttpClient
+
+  beforeEach(() => {
+    fetchMock = vi.fn().mockResolvedValue(mockResponse({ ok: 1 }))
+    vi.stubGlobal('fetch', fetchMock)
+    http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it('send sends POST with respondent and text', async () => {
+    await http.user.messages.send('Tigga', 'hello')
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('POST')
+    expect(url).toContain('/api/user/messages/send')
+    expect(JSON.parse(init.body as string)).toEqual({ respondent: 'Tigga', text: 'hello' })
+  })
+
+  it('list sends GET with respondent query param', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1, messages: [] }))
+    await http.user.messages.list('Tigga')
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('GET')
+    expect(url).toContain('/api/user/messages/list')
+    expect(url).toContain('respondent=Tigga')
+  })
+
+  it('index sends GET to /api/user/messages/index', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1, list: [] }))
+    await http.user.messages.index()
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('GET')
+    expect(url).toContain('/api/user/messages/index')
+  })
+
+  it('markRead sends POST with id', async () => {
+    await http.user.messages.markRead('msg-id-123')
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('POST')
+    expect(url).toContain('/api/user/messages/mark-read')
+    expect(JSON.parse(init.body as string)).toEqual({ id: 'msg-id-123' })
+  })
+
+  it('unreadCount sends GET to /api/user/messages/unread-count', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1, count: 3 }))
+    const res = await http.user.messages.unreadCount()
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('GET')
+    expect(url).toContain('/api/user/messages/unread-count')
+    expect(res.count).toBe(3)
+  })
+})

package/tests/http/endpoints/user.test.ts

@@ -0,0 +1,139 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { HttpClient } from '../../../src/http/HttpClient.js'
+import { TokenAuth } from '../../../src/http/auth/TokenAuth.js'
+
+function mockResponse(body: unknown, opts: ResponseInit = {}): Response {
+  return new Response(JSON.stringify(body), {
+    status: 200,
+    headers: { 'content-type': 'application/json', ...opts.headers },
+    ...opts,
+  })
+}
+
+describe('user endpoints', () => {
+  let fetchMock: ReturnType<typeof vi.fn>
+  let http: HttpClient
+
+  beforeEach(() => {
+    fetchMock = vi.fn().mockResolvedValue(mockResponse({ ok: 1 }))
+    vi.stubGlobal('fetch', fetchMock)
+    http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it('find sends GET with username query param', async () => {
+    await http.user.find({ username: 'Tigga' })
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('GET')
+    expect(url).toContain('/api/user/find')
+    expect(url).toContain('username=Tigga')
+  })
+
+  it('find sends GET with id query param', async () => {
+    await http.user.find({ id: 'abc123' })
+    const [url] = fetchMock.mock.calls[0] as [string]
+    expect(url).toContain('id=abc123')
+  })
+
+  it('moneyHistory sends GET without page when omitted', async () => {
+    await http.user.moneyHistory()
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('GET')
+    expect(url).toContain('/api/user/money-history')
+    expect(url).not.toContain('page')
+  })
+
+  it('moneyHistory sends GET with page param', async () => {
+    await http.user.moneyHistory(2)
+    const [url] = fetchMock.mock.calls[0] as [string]
+    expect(url).toContain('page=2')
+  })
+
+  it('respawn sends POST to /api/user/respawn', async () => {
+    await http.user.respawn()
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('POST')
+    expect(url).toContain('/api/user/respawn')
+  })
+
+  it('respawnProhibitedRooms sends GET', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1, rooms: [] }))
+    await http.user.respawnProhibitedRooms()
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('GET')
+    expect(url).toContain('/api/user/respawn-prohibited-rooms')
+  })
+
+  it('badge sends POST with badge body', async () => {
+    const badge = { type: 1, color1: '#ff0000', color2: '#00ff00', color3: '#0000ff', flip: false }
+    await http.user.badge(badge)
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('POST')
+    expect(url).toContain('/api/user/badge')
+    expect(JSON.parse(init.body as string)).toEqual({ badge })
+  })
+
+  it('setActiveBranch sends POST with activeName and branch', async () => {
+    await http.user.setActiveBranch('activeWorld', 'main')
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('POST')
+    expect(url).toContain('/api/user/set-active-branch')
+    expect(JSON.parse(init.body as string)).toEqual({ activeName: 'activeWorld', branch: 'main' })
+  })
+
+  it('cloneBranch sends POST with newName', async () => {
+    await http.user.cloneBranch('backup')
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('POST')
+    expect(url).toContain('/api/user/clone-branch')
+    expect(JSON.parse(init.body as string)).toEqual({ newName: 'backup' })
+  })
+
+  it('cloneBranch includes branch and defaultModules when provided', async () => {
+    await http.user.cloneBranch('backup', 'main', true)
+    const body = JSON.parse(fetchMock.mock.calls[0][1].body as string)
+    expect(body).toEqual({ newName: 'backup', branch: 'main', defaultModules: true })
+  })
+
+  it('deleteBranch sends POST with branch', async () => {
+    await http.user.deleteBranch('old-branch')
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('POST')
+    expect(url).toContain('/api/user/delete-branch')
+    expect(JSON.parse(init.body as string)).toEqual({ branch: 'old-branch' })
+  })
+
+  it('notifyPrefs sends POST with partial prefs', async () => {
+    await http.user.notifyPrefs({ disabled: true, interval: 60 })
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('POST')
+    expect(url).toContain('/api/user/notify-prefs')
+    expect(JSON.parse(init.body as string)).toEqual({ disabled: true, interval: 60 })
+  })
+
+  it('tutorialDone sends POST', async () => {
+    await http.user.tutorialDone()
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('POST')
+    expect(url).toContain('/api/user/tutorial-done')
+  })
+
+  it('email sends POST with email', async () => {
+    await http.user.email('test@example.com')
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('POST')
+    expect(url).toContain('/api/user/email')
+    expect(JSON.parse(init.body as string)).toEqual({ email: 'test@example.com' })
+  })
+
+  it('setSteamVisible sends POST with visible flag', async () => {
+    await http.user.setSteamVisible(false)
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('POST')
+    expect(url).toContain('/api/user/set-steam-visible')
+    expect(JSON.parse(init.body as string)).toEqual({ visible: false })
+  })
+})

package/tests/socket/MessageParser.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest'
+import { parseMessage } from '../../src/socket/MessageParser.js'
+
+describe('parseMessage', () => {
+  it('parses auth ok with token', async () => {
+    expect(await parseMessage('auth ok abc123')).toEqual({
+      kind: 'server',
+      command: { type: 'auth', status: 'ok', token: 'abc123' },
+    })
+  })
+
+  it('parses auth failed', async () => {
+    expect(await parseMessage('auth failed')).toEqual({
+      kind: 'server',
+      command: { type: 'auth', status: 'failed', token: undefined },
+    })
+  })
+
+  it('parses time command', async () => {
+    expect(await parseMessage('time 99999')).toEqual({
+      kind: 'server',
+      command: { type: 'time', time: 99999 },
+    })
+  })
+
+  it('parses protocol command', async () => {
+    expect(await parseMessage('protocol 13')).toEqual({
+      kind: 'server',
+      command: { type: 'protocol', protocol: 13 },
+    })
+  })
+
+  it('parses package command', async () => {
+    expect(await parseMessage('package 42')).toEqual({
+      kind: 'server',
+      command: { type: 'package', package: 42 },
+    })
+  })
+
+  it('parses JSON array channel message', async () => {
+    const raw = JSON.stringify(['user:uid123/cpu', { cpu: 30, memory: 1024 }])
+    expect(await parseMessage(raw)).toEqual({
+      kind: 'channel',
+      message: { channel: 'user:uid123/cpu', data: { cpu: 30, memory: 1024 } },
+    })
+  })
+
+  it('accepts MessageEvent (browser WS format)', async () => {
+    const event = { data: 'time 500' } as MessageEvent
+    expect(await parseMessage(event)).toEqual({
+      kind: 'server',
+      command: { type: 'time', time: 500 },
+    })
+  })
+})