screeps-connectivity 0.2.0

package/tests/socket/SocketClient.test.ts

@@ -0,0 +1,144 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { SocketClient } from '../../src/socket/SocketClient.js'
+
+class MockWS {
+  static instances: MockWS[] = []
+  onopen: (() => void) | null = null
+  onclose: (() => void) | null = null
+  onerror: ((e: unknown) => void) | null = null
+  onmessage: ((e: MessageEvent) => void) | null = null
+  sent: string[] = []
+
+  constructor(public url: string) {
+    MockWS.instances.push(this)
+  }
+
+  send(data: string) { this.sent.push(data) }
+  close() { this.onclose?.() }
+
+  simulateOpen() { this.onopen?.() }
+  simulateMessage(data: string) { this.onmessage?.({ data } as MessageEvent) }
+  simulateClose() { this.onclose?.() }
+}
+
+beforeEach(() => { MockWS.instances = [] })
+
+function makeClient() {
+  return new SocketClient({ url: 'http://test.local', WebSocket: MockWS as unknown as typeof WebSocket })
+}
+
+async function connectClient(client: SocketClient, token = 'tok') {
+  const connectPromise = client.connect(token)
+  const ws = MockWS.instances[0]
+  ws.simulateOpen()
+  ws.simulateMessage('auth ok newtoken')
+  await connectPromise
+  return ws
+}
+
+describe('SocketClient', () => {
+  it('connects to the correct WebSocket URL', async () => {
+    const client = makeClient()
+    const promise = client.connect('tok')
+    const ws = MockWS.instances[0]
+    expect(ws.url).toBe('ws://test.local/socket/websocket')
+    ws.simulateOpen()
+    ws.simulateMessage('auth ok tok')
+    await promise
+  })
+
+  it('sends auth token on open', async () => {
+    const client = makeClient()
+    const ws = await connectClient(client)
+    expect(ws.sent).toContain('auth tok')
+  })
+
+  it('resolves connect() after auth ok', async () => {
+    const client = makeClient()
+    await expect(connectClient(client)).resolves.toBeDefined()
+  })
+
+  it('subscribe sends subscribe message when authed', async () => {
+    const client = makeClient()
+    const ws = await connectClient(client)
+    ws.sent.length = 0
+    client.subscribe('room:shard0/W7N7')
+    expect(ws.sent).toContain('subscribe room:shard0/W7N7')
+  })
+
+  it('subscribe refcounts — subscribe message sent only once for multiple subs', async () => {
+    const client = makeClient()
+    const ws = await connectClient(client)
+    ws.sent.length = 0
+    client.subscribe('room:shard0/W7N7')
+    client.subscribe('room:shard0/W7N7')
+    const subscribeMsgs = ws.sent.filter(s => s.startsWith('subscribe'))
+    expect(subscribeMsgs).toHaveLength(1)
+  })
+
+  it('unsubscribe sent when last subscriber disposes', async () => {
+    const client = makeClient()
+    const ws = await connectClient(client)
+    const sub1 = client.subscribe('room:shard0/W7N7')
+    const sub2 = client.subscribe('room:shard0/W7N7')
+    ws.sent.length = 0
+    sub1.dispose()
+    expect(ws.sent.filter(s => s.startsWith('unsubscribe'))).toHaveLength(0)
+    sub2.dispose()
+    expect(ws.sent).toContain('unsubscribe room:shard0/W7N7')
+  })
+
+  it('on() delivers channel messages to listener', async () => {
+    const client = makeClient()
+    const ws = await connectClient(client)
+    const handler = vi.fn()
+    client.on('user:uid/cpu', handler)
+    ws.simulateMessage(JSON.stringify(['user:uid/cpu', { cpu: 25 }]))
+    await new Promise(r => setTimeout(r, 0))
+    expect(handler).toHaveBeenCalledWith({ cpu: 25 })
+  })
+
+  it('on() subscription dispose removes listener', async () => {
+    const client = makeClient()
+    const ws = await connectClient(client)
+    const handler = vi.fn()
+    const sub = client.on('user:uid/cpu', handler)
+    sub.dispose()
+    ws.simulateMessage(JSON.stringify(['user:uid/cpu', { cpu: 25 }]))
+    await new Promise(r => setTimeout(r, 0))
+    expect(handler).not.toHaveBeenCalled()
+  })
+
+  it('isConnected reflects state', async () => {
+    const client = makeClient()
+    expect(client.isConnected).toBe(false)
+    await connectClient(client)
+    expect(client.isConnected).toBe(true)
+    client.disconnect()
+    expect(client.isConnected).toBe(false)
+    // After intentional disconnect, no reconnect should be attempted
+    await new Promise(r => setTimeout(r, 0))
+    expect(MockWS.instances).toHaveLength(1)
+  })
+
+  it('disconnect() prevents reconnect even when not currently reconnecting', async () => {
+    const client = makeClient()
+    const _ws = await connectClient(client)
+    client.disconnect()
+    // After disconnect, scheduleReconnect should be a no-op
+    // We verify by checking no new WS instance is created after a tick
+    await new Promise(r => setTimeout(r, 0))
+    expect(MockWS.instances).toHaveLength(1)  // only the original one
+  })
+
+  it('disconnected event has willReconnect: false when disconnect() is called', async () => {
+    const client = makeClient()
+    const _ws = await connectClient(client)
+    let willReconnect: boolean | undefined
+    client.on('disconnected', (data) => {
+      willReconnect = (data as { willReconnect: boolean }).willReconnect
+    })
+    client.disconnect()
+    expect(willReconnect).toBe(false)
+  })
+})

package/tests/storage/FileStorage.test.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { FileStorage } from '../../src/storage/FileStorage.js'
+
+let tmpDir: string
+
+beforeEach(async () => {
+  tmpDir = await mkdtemp(join(tmpdir(), 'screeps-test-'))
+})
+
+afterEach(async () => {
+  await rm(tmpDir, { recursive: true, force: true })
+})
+
+describe('FileStorage', () => {
+  it('returns null for missing key', async () => {
+    const s = new FileStorage(tmpDir, 'ns')
+    expect(await s.get('missing')).toBeNull()
+  })
+
+  it('stores and retrieves binary data', async () => {
+    const s = new FileStorage(tmpDir, 'ns')
+    const data = new Uint8Array([10, 20, 30, 40])
+    await s.set('key', data)
+    const result = await s.get('key')
+    expect(result).toEqual(data)
+  })
+
+  it('delete removes the entry', async () => {
+    const s = new FileStorage(tmpDir, 'ns')
+    await s.set('key', new Uint8Array([1]))
+    await s.delete('key')
+    expect(await s.get('key')).toBeNull()
+  })
+
+  it('delete on missing key does not throw', async () => {
+    const s = new FileStorage(tmpDir, 'ns')
+    await expect(s.delete('missing')).resolves.toBeUndefined()
+  })
+
+  it('clear removes all entries for this namespace', async () => {
+    const s = new FileStorage(tmpDir, 'ns')
+    await s.set('a', new Uint8Array([1]))
+    await s.set('b', new Uint8Array([2]))
+    await s.clear()
+    expect(await s.get('a')).toBeNull()
+    expect(await s.get('b')).toBeNull()
+  })
+
+  it('namespaces are isolated', async () => {
+    const s1 = new FileStorage(tmpDir, 'ns1')
+    const s2 = new FileStorage(tmpDir, 'ns2')
+    await s1.set('key', new Uint8Array([1]))
+    expect(await s2.get('key')).toBeNull()
+  })
+
+  it('sanitizes URL-style namespace for directory name', async () => {
+    const s = new FileStorage(tmpDir, 'https://screeps.com')
+    await s.set('key', new Uint8Array([99]))
+    expect(await s.get('key')).toEqual(new Uint8Array([99]))
+  })
+})

package/tests/storage/IndexedDBStorage.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import 'fake-indexeddb/auto'
+import { IndexedDBStorage } from '../../src/storage/IndexedDBStorage.js'
+
+describe('IndexedDBStorage', () => {
+  let storage: IndexedDBStorage
+
+  beforeEach(() => {
+    storage = new IndexedDBStorage(`test-ns-${Math.random()}`)
+  })
+
+  it('returns null for missing key', async () => {
+    expect(await storage.get('missing')).toBeNull()
+  })
+
+  it('stores and retrieves binary data', async () => {
+    const data = new Uint8Array([1, 2, 3, 4])
+    await storage.set('mykey', data)
+    const result = await storage.get('mykey')
+    expect(result).toEqual(data)
+  })
+
+  it('delete removes the entry', async () => {
+    await storage.set('key', new Uint8Array([7]))
+    await storage.delete('key')
+    expect(await storage.get('key')).toBeNull()
+  })
+
+  it('clear removes all entries', async () => {
+    await storage.set('a', new Uint8Array([1]))
+    await storage.set('b', new Uint8Array([2]))
+    await storage.clear()
+    expect(await storage.get('a')).toBeNull()
+    expect(await storage.get('b')).toBeNull()
+  })
+})

package/tests/storage/NullStorage.test.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect } from 'vitest'
+import { NullStorage } from '../../src/storage/NullStorage.js'
+
+describe('NullStorage', () => {
+  it('get always returns null', async () => {
+    const s = new NullStorage()
+    expect(await s.get('key')).toBeNull()
+  })
+
+  it('set is a no-op and does not throw', async () => {
+    const s = new NullStorage()
+    await expect(s.set('key', new Uint8Array([1, 2]))).resolves.toBeUndefined()
+  })
+
+  it('delete is a no-op and does not throw', async () => {
+    const s = new NullStorage()
+    await expect(s.delete('key')).resolves.toBeUndefined()
+  })
+
+  it('clear is a no-op and does not throw', async () => {
+    const s = new NullStorage()
+    await expect(s.clear()).resolves.toBeUndefined()
+  })
+})

package/tests/stores/MapStatsStore.test.ts

@@ -0,0 +1,234 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { MapStatsStore } from '../../src/stores/MapStatsStore.js'
+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('MapStatsStore', () => {
+  let fetchMock: ReturnType<typeof vi.fn>
+  let store: MapStatsStore
+
+  beforeEach(() => {
+    fetchMock = vi.fn()
+    vi.stubGlobal('fetch', fetchMock)
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+    store = new MapStatsStore(http, 10)
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it('does nothing when rooms is empty', () => {
+    store.request([], 'owner0')
+    expect(fetchMock).not.toHaveBeenCalled()
+  })
+
+  it('emits per-room events after fetch', async () => {
+    fetchMock.mockResolvedValue(mockResponse({
+      ok: 1,
+      stats: {
+        W1N1: { own: { user: 'u1', level: 3 } },
+      },
+      users: { u1: { _id: 'u1', username: 'Alice', badge: { type: 1, color1: '#fff', color2: '#000', color3: '#f00', flip: false } } },
+    }))
+
+    const events: Array<{ room: string; stat: unknown }> = []
+    store.on('mapStats:room', (e) => events.push(e))
+
+    store.request(['W1N1'], 'owner0')
+
+    await new Promise(r => setTimeout(r, 50))
+    expect(events).toHaveLength(1)
+    expect(events[0].room).toBe('W1N1')
+    const stat = events[0].stat as { own: { user: string; level: number }; username: string }
+    expect(stat.own).toEqual({ user: 'u1', level: 3 })
+    expect(stat.username).toBe('Alice')
+  })
+
+  it('propagates badge data for room owners', async () => {
+    fetchMock.mockResolvedValue(mockResponse({
+      ok: 1,
+      stats: {
+        W1N1: { own: { user: 'u1', level: 3 } },
+      },
+      users: {
+        u1: {
+          _id: 'u1',
+          username: 'Alice',
+          badge: { type: 24, color1: '#000077', color2: '#5555dd', color3: '#9999ff', param: 0, flip: false },
+        },
+      },
+    }))
+
+    const events: Array<{ room: string; stat: unknown }> = []
+    store.on('mapStats:room', (e) => events.push(e))
+
+    store.request(['W1N1'], 'owner0')
+
+    await new Promise(r => setTimeout(r, 50))
+    expect(events).toHaveLength(1)
+    const stat = events[0].stat as { badge: { type: number; color1: string } }
+    expect(stat.badge).toBeDefined()
+    expect(stat.badge.type).toBe(24)
+    expect(stat.badge.color1).toBe('#000077')
+  })
+
+  it('does not include badge for unowned rooms', async () => {
+    fetchMock.mockResolvedValue(mockResponse({
+      ok: 1,
+      stats: {
+        W1N1: { status: 'normal' },
+      },
+      users: {},
+    }))
+
+    const events: Array<{ room: string; stat: unknown }> = []
+    store.on('mapStats:room', (e) => events.push(e))
+
+    store.request(['W1N1'], 'owner0')
+
+    await new Promise(r => setTimeout(r, 50))
+    expect(events).toHaveLength(1)
+    const stat = events[0].stat as { badge?: unknown }
+    expect(stat.badge).toBeUndefined()
+  })
+
+  it('batches multiple request() calls into one HTTP request', async () => {
+    fetchMock.mockResolvedValue(mockResponse({
+      ok: 1,
+      stats: {
+        W1N1: { own: { user: 'u1', level: 1 } },
+        W1N2: { own: { user: 'u2', level: 2 } },
+      },
+      users: {},
+    }))
+
+    store.request(['W1N1'], 'owner0')
+    store.request(['W1N2'], 'owner0')
+
+    await new Promise(r => setTimeout(r, 50))
+    expect(fetchMock).toHaveBeenCalledOnce()
+
+    const [, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    const body = JSON.parse(init.body as string)
+    expect(body.rooms).toContain('W1N1')
+    expect(body.rooms).toContain('W1N2')
+  })
+
+  it('does not batch calls with different statName or shard', async () => {
+    fetchMock
+      .mockResolvedValueOnce(mockResponse({ ok: 1, stats: {}, users: {} }))
+      .mockResolvedValueOnce(mockResponse({ ok: 1, stats: {}, users: {} }))
+      .mockResolvedValueOnce(mockResponse({ ok: 1, stats: {}, users: {} }))
+
+    store.request(['W1N1'], 'owner0', 'shard0')
+    store.request(['W1N1'], 'owner0', 'shard1')
+    store.request(['W1N1'], 'status', 'shard0')
+
+    await new Promise(r => setTimeout(r, 50))
+    expect(fetchMock).toHaveBeenCalledTimes(3)
+  })
+
+  it('emits empty entry for rooms that do not exist on server', async () => {
+    fetchMock.mockResolvedValue(mockResponse({
+      ok: 1,
+      stats: {},
+      users: {},
+    }))
+
+    const events: Array<{ room: string; stat: unknown }> = []
+    store.on('mapStats:room', (e) => events.push(e))
+
+    store.request(['W1N1'], 'owner0')
+
+    await new Promise(r => setTimeout(r, 50))
+    expect(events).toHaveLength(1)
+    expect(events[0].room).toBe('W1N1')
+    expect(events[0].stat).not.toHaveProperty('own')
+  })
+
+  it('extracts mineral type and density from response', async () => {
+    fetchMock.mockResolvedValue(mockResponse({
+      ok: 1,
+      stats: {
+        W1N1: {
+          own: { user: 'u1', level: 1 },
+          minerals0: { type: 'H', density: 4 },
+        },
+      },
+      users: {},
+    }))
+
+    const events: Array<{ room: string; stat: unknown }> = []
+    store.on('mapStats:room', (e) => events.push(e))
+
+    store.request(['W1N1'], 'owner0')
+
+    await new Promise(r => setTimeout(r, 50))
+    expect(events).toHaveLength(1)
+    const stat = events[0].stat as { mineral: string; density: number }
+    expect(stat.mineral).toBe('H')
+    expect(stat.density).toBe(4)
+  })
+
+  it('extracts safeMode from response', async () => {
+    fetchMock.mockResolvedValue(mockResponse({
+      ok: 1,
+      stats: {
+        W9N8: {
+          status: 'normal',
+          novice: null,
+          respawnArea: null,
+          openTime: null,
+          own: { user: 'u1', level: 2 },
+          safeMode: true,
+          minerals0: { type: 'O', density: 2 },
+        },
+      },
+      users: { u1: { _id: 'u1', username: 'Alice' } },
+    }))
+
+    const events: Array<{ room: string; stat: unknown }> = []
+    store.on('mapStats:room', (e) => events.push(e))
+
+    store.request(['W9N8'], 'owner0')
+
+    await new Promise(r => setTimeout(r, 50))
+    expect(events).toHaveLength(1)
+    const stat = events[0].stat as { safeMode: boolean; own: { user: string; level: number }; username: string }
+    expect(stat.safeMode).toBe(true)
+    expect(stat.own).toEqual({ user: 'u1', level: 2 })
+    expect(stat.username).toBe('Alice')
+  })
+
+  it('omits safeMode when not present in response', async () => {
+    fetchMock.mockResolvedValue(mockResponse({
+      ok: 1,
+      stats: {
+        W1N1: {
+          status: 'normal',
+          own: { user: 'u1', level: 1 },
+        },
+      },
+      users: {},
+    }))
+
+    const events: Array<{ room: string; stat: unknown }> = []
+    store.on('mapStats:room', (e) => events.push(e))
+
+    store.request(['W1N1'], 'owner0')
+
+    await new Promise(r => setTimeout(r, 50))
+    expect(events).toHaveLength(1)
+    const stat = events[0].stat as { safeMode?: boolean }
+    expect(stat.safeMode).toBeUndefined()
+  })
+})