ds-harness-remote-fast/apps/android/tests/api.test.ts

178 lines
9.7 KiB
TypeScript

import { describe, expect, it, vi } from 'vitest'
import { runScenarios } from '../../../scripts/test-scenarios.mjs'
import { ANDROID_CLIENT_VERSION, RemoteServerApi } from '../src/services/api'
import type { DeviceIdentity } from '../src/types'
const identity: DeviceIdentity = {
deviceId: '0198abc0-1234-7abc-8123-123456789abc',
name: 'Pixel · DSH Remote',
platform: 'android',
publicKey: 'A'.repeat(43),
privateKey: 'B'.repeat(43),
}
describe('Remote Server API compatibility', () => {
it('preserves rate limits and authorization across Server and proxy response formats without replaying mutations', async () => {
await runScenarios([
{ name: 'protocol JSON with misleading auth code', body: JSON.stringify({ error: { code: 'DEVICE_REVOKED', message: 'Retry later' } }) },
{ name: 'proxy HTML', body: '<html><h1>429 Too Many Requests</h1></html>' },
{ name: 'proxy plain text', body: 'Too Many Requests' },
{ name: 'truncated JSON', body: '{"error":' },
{ name: 'empty response', body: '' },
].map(scenario => ({ name: scenario.name, run: async () => {
const fetchImplementation = vi.fn<typeof fetch>()
.mockResolvedValueOnce(new Response(scenario.body, { status: 429, headers: { 'Retry-After': '60' } }))
.mockResolvedValueOnce(jsonResponse({ name: 'OK' }))
const api = new RemoteServerApi('https://remote.example.com', 'token', fetchImplementation)
await expect(api.renameAccountDevice('host', 'OK')).rejects.toMatchObject({ code: 'RATE_LIMITED', status: 429, retryable: true })
expect(fetchImplementation).toHaveBeenCalledTimes(1)
expect(await api.renameAccountDevice('host', 'OK')).toEqual({ name: 'OK' })
expect(fetchImplementation.mock.calls[1]?.[1]?.headers).toMatchObject({ Authorization: 'Bearer token' })
} })))
})
it('renames an account-owned device with authenticated PATCH and the canonical server name', async () => {
const fetchImplementation = vi.fn<typeof fetch>(async () => jsonResponse({ name: '书房电脑' }))
const api = new RemoteServerApi('https://remote.example.com/prefix', 'client-device-token', fetchImplementation)
expect(await api.renameAccountDevice('host /中文', ' 书房电脑 ')).toEqual({ name: '书房电脑' })
expect(fetchImplementation.mock.calls[0]?.[0]).toBe('https://remote.example.com/prefix/api/v1/account/devices/host%20%2F%E4%B8%AD%E6%96%87')
expect(fetchImplementation.mock.calls[0]?.[1]).toMatchObject({
method: 'PATCH', body: JSON.stringify({ name: '书房电脑' }),
headers: { Authorization: 'Bearer client-device-token' },
})
})
it('rejects invalid rename input, missing authorization, denied membership and invalid responses', async () => {
const scenarios = [
{ label: 'empty name', name: ' \n ', token: 'token', body: { name: 'OK' }, status: 200, code: 'INVALID_MESSAGE', called: false },
{ label: 'oversized name', name: 'x'.repeat(129), token: 'token', body: { name: 'OK' }, status: 200, code: 'INVALID_MESSAGE', called: false },
{ label: 'missing credential', name: 'OK', token: undefined, body: { name: 'OK' }, status: 200, code: 'AUTH_REQUIRED', called: false },
{ label: 'expired credential', name: 'OK', token: 'token', body: {}, status: 401, code: 'AUTH_INVALID', called: true },
{ label: 'foreign device', name: 'OK', token: 'token', body: { error: { code: 'MEMBERSHIP_REQUIRED' } }, status: 403, code: 'MEMBERSHIP_REQUIRED', called: true },
{ label: 'missing device', name: 'OK', token: 'token', body: {}, status: 404, code: 'DEVICE_NOT_FOUND', called: true },
{ label: 'invalid success response', name: 'OK', token: 'token', body: { name: ' ' }, status: 200, code: 'INVALID_MESSAGE', called: true },
]
await runScenarios(scenarios.map(scenario => ({
name: scenario.label,
run: async () => {
const fetchImplementation = vi.fn<typeof fetch>(async () => jsonResponse(scenario.body, scenario.status))
const api = new RemoteServerApi('https://remote.example.com', scenario.token, fetchImplementation)
await expect(api.renameAccountDevice('host-1', scenario.name)).rejects.toMatchObject({ code: scenario.code })
expect(fetchImplementation).toHaveBeenCalledTimes(scenario.called ? 1 : 0)
},
})))
})
it('registers the Android descriptor with the account token and validates the token pair', async () => {
const calls: Array<{ url: string; body?: unknown; headers?: unknown }> = []
const fetchImplementation = vi.fn<typeof fetch>(async (input, init) => {
calls.push({ url: String(input), body: init?.body, headers: init?.headers })
return jsonResponse(tokenPair('registered'))
})
const tokens = await new RemoteServerApi('https://remote.example.com', undefined, fetchImplementation)
.registerDevice(identity, 'account-token')
expect(tokens.accessToken).toBe('access-registered-token')
expect(calls[0]?.url).toBe('https://remote.example.com/api/v1/devices/register')
expect(calls[0]?.headers).toMatchObject({ Authorization: 'Bearer account-token' })
expect(JSON.parse(String(calls[0]?.body))).toMatchObject({
v: 1,
device: {
deviceId: identity.deviceId,
role: 'client',
platform: 'android',
identityKey: identity.publicKey,
clientVersion: ANDROID_CLIENT_VERSION,
},
})
})
it('logs in with the account and returns the account session', async () => {
const fetchImplementation = vi.fn<typeof fetch>(async (_input, init) => {
expect(JSON.parse(String(init?.body))).toEqual({ email: 'user@example.com', password: 'secret' })
expect(init?.headers).not.toMatchObject({ Authorization: expect.anything() })
return jsonResponse({
token: 'account-jwt-token-123456',
expiresAt: Date.now() + 60_000,
account: 'user@example.com',
profile: {},
isAdmin: false,
})
})
const api = new RemoteServerApi('https://remote.example.com', undefined, fetchImplementation)
const login = await api.loginAccount('user@example.com', 'secret')
expect(login).toMatchObject({ token: 'account-jwt-token-123456', account: 'user@example.com', isAdmin: false })
expect(fetchImplementation.mock.calls[0]?.[0]).toBe('https://remote.example.com/api/v1/auth/login')
})
it('uses Bearer auth and accepts Server device and presence shapes that omit identity keys', async () => {
const fetchImplementation = vi.fn<typeof fetch>(async input => {
const url = String(input)
if (url.endsWith('/presence')) {
return jsonResponse({ deviceId: 'host-1', online: true, lastSeenAt: 1234 })
}
return jsonResponse({
items: [{
deviceId: 'host-1', name: 'Workstation', role: 'host', platform: 'linux',
membershipId: 'membership-1', harnessVersion: '0.1.0', lastConnectedAt: null,
}],
nextCursor: null,
})
})
const api = new RemoteServerApi('https://remote.example.com', 'access-token-for-client', fetchImplementation)
expect(await api.listDevices()).toEqual([expect.objectContaining({
deviceId: 'host-1', name: 'Workstation', role: 'host', platform: 'linux',
membershipId: 'membership-1', harnessVersion: '0.1.0',
})])
expect(await api.getPresence('host-1')).toEqual({ deviceId: 'host-1', online: true, lastSeenAt: 1234 })
expect(fetchImplementation.mock.calls[0]?.[1]?.headers).toMatchObject({ Authorization: 'Bearer access-token-for-client' })
})
it('fetches the authorized peer descriptor with the identity key for pinning', async () => {
const fetchImplementation = vi.fn<typeof fetch>(async () => jsonResponse({
deviceId: 'host-1', name: 'Workstation', role: 'host', platform: 'linux',
identityKey: 'C'.repeat(43), membershipId: 'membership-1',
}))
const api = new RemoteServerApi('https://remote.example.com', 'access-token-for-client', fetchImplementation)
const peer = await api.deviceFor('host-1')
expect(peer).toMatchObject({ deviceId: 'host-1', identityKey: 'C'.repeat(43), membershipId: 'membership-1' })
expect(fetchImplementation.mock.calls[0]?.[0]).toBe('https://remote.example.com/api/v1/devices/host-1')
})
it('fetches TURN credentials for the negotiated connection', async () => {
const fetchImplementation = vi.fn<typeof fetch>(async () => jsonResponse({
iceServers: [{ urls: 'turn:turn.example.com:3478', username: 'user', credential: 'pass' }],
}))
const api = new RemoteServerApi('https://remote.example.com', 'access-token-for-client', fetchImplementation)
const ice = await api.turnCredentials('connection-1')
expect(ice).toEqual([{ urls: 'turn:turn.example.com:3478', username: 'user', credential: 'pass' }])
expect(fetchImplementation.mock.calls[0]?.[0]).toBe(
'https://remote.example.com/api/v1/turn/credentials?connection_id=connection-1',
)
})
it('preserves stable Server error codes and retryability', async () => {
const fetchImplementation = vi.fn<typeof fetch>(async () => jsonResponse({
error: { code: 'MEMBERSHIP_REQUIRED', message: 'membership revoked', retryable: false },
}, 403))
const api = new RemoteServerApi('https://remote.example.com', 'access-token-for-client', fetchImplementation)
await expect(api.deviceFor('host-1')).rejects.toMatchObject({
code: 'MEMBERSHIP_REQUIRED',
status: 403,
retryable: false,
})
})
})
function tokenPair(suffix: string) {
return {
accessToken: `access-${suffix}-token`,
accessTokenExpiresAt: Date.now() + 60_000,
refreshToken: `refresh-${suffix}-token`,
refreshTokenExpiresAt: Date.now() + 120_000,
}
}
function jsonResponse(body: unknown, status = 200): Response {
return new Response(JSON.stringify(body), { status, headers: { 'Content-Type': 'application/json' } })
}