136 lines
5.7 KiB
TypeScript
136 lines
5.7 KiB
TypeScript
import { describe, expect, it } from 'vitest'
|
|
import { runScenarios } from '../../../scripts/test-scenarios.mjs'
|
|
import {
|
|
acceptNegotiatedCapabilities,
|
|
browserAuthorizationExchangeRequestSchema,
|
|
browserAuthorizationExchangeResponseSchema,
|
|
deviceRefreshRequestSchema,
|
|
deviceRegistrationRequestSchema,
|
|
deviceTokenPairSchema,
|
|
decodeControlFrame,
|
|
decodeRelayDataFrame,
|
|
encodeControlFrame,
|
|
hostRegistrationCodeRequestSchema,
|
|
parseControlFrame,
|
|
rpcErrorPayloadSchema,
|
|
selectCapabilities,
|
|
selectProtocolVersion,
|
|
} from '../src/index.js'
|
|
import { loadProtocolFixtures, type ProtocolFixtureCase } from './conformance-fixture-loader.js'
|
|
|
|
const suites = await loadProtocolFixtures()
|
|
|
|
for (const suite of suites) {
|
|
describe(`${suite.name} conformance fixtures`, () => {
|
|
const contracts = new Map<string, ProtocolFixtureCase[]>()
|
|
for (const testCase of suite.cases) {
|
|
const input = fixtureInput(testCase)
|
|
const contract = testCase.operation === 'parseControlFrame'
|
|
? `${testCase.operation}:${input.type ?? 'envelope'}`
|
|
: testCase.operation
|
|
const cases = contracts.get(contract) ?? []
|
|
cases.push(testCase)
|
|
contracts.set(contract, cases)
|
|
}
|
|
for (const [contract, cases] of contracts) {
|
|
it(contract, async () => {
|
|
await runScenarios(
|
|
cases.map((testCase) => ({
|
|
name: testCase.name,
|
|
run: () => {
|
|
const execute = () => executeFixture(testCase)
|
|
if (!testCase.expect.accepted) {
|
|
expect(execute).toThrow()
|
|
return
|
|
}
|
|
const result = execute()
|
|
if ('selected' in testCase.expect) expect(result ?? null).toEqual(testCase.expect.selected)
|
|
if ('value' in testCase.expect) expect(result).toEqual(testCase.expect.value)
|
|
},
|
|
})),
|
|
)
|
|
})
|
|
}
|
|
})
|
|
}
|
|
|
|
function executeFixture(testCase: ProtocolFixtureCase): unknown {
|
|
const input = fixtureInput(testCase)
|
|
if (testCase.operation === 'parseControlFrame') return parseControlFrame(testCase.input)
|
|
if (testCase.operation === 'parseDeviceRegistrationRequest') return deviceRegistrationRequestSchema.parse(testCase.input)
|
|
if (testCase.operation === 'parseHostRegistrationCodeRequest') return hostRegistrationCodeRequestSchema.parse(testCase.input)
|
|
if (testCase.operation === 'parseDeviceRefreshRequest') return deviceRefreshRequestSchema.parse(testCase.input)
|
|
if (testCase.operation === 'parseDeviceTokenPair') return deviceTokenPairSchema.parse(testCase.input)
|
|
if (testCase.operation === 'parseBrowserAuthorizationExchangeRequest') {
|
|
return browserAuthorizationExchangeRequestSchema.parse(testCase.input)
|
|
}
|
|
if (testCase.operation === 'parseBrowserAuthorizationExchangeResponse') {
|
|
return browserAuthorizationExchangeResponseSchema.parse(testCase.input)
|
|
}
|
|
if (testCase.operation === 'parseRpcErrorPayload') return rpcErrorPayloadSchema.parse(testCase.input)
|
|
if (testCase.operation === 'encodeControlFrameWithLimits') {
|
|
const input = fixtureInput(testCase)
|
|
return encodeControlFrame(parseControlFrame(input.frame), controlFrameLimits(input))
|
|
}
|
|
if (testCase.operation === 'decodeControlFrameWithLimits') {
|
|
const input = fixtureInput(testCase)
|
|
return decodeControlFrame(requiredString(input.data, 'data'), controlFrameLimits(input))
|
|
}
|
|
if (testCase.operation === 'decodeRelayDataFrameWithLimits') {
|
|
return decodeRelayDataFrame(requiredString(input.data, 'data'), controlFrameLimits(input))
|
|
}
|
|
if (testCase.operation === 'selectProtocolVersion') {
|
|
return selectProtocolVersion(numberList(input.offered, 'offered'), numberList(input.supported, 'supported'))
|
|
}
|
|
if (testCase.operation === 'selectCapabilities') {
|
|
return selectCapabilities(stringList(input.offered, 'offered'), stringList(input.supported, 'supported'))
|
|
}
|
|
const negotiated = 'negotiated' in input ? stringList(input.negotiated, 'negotiated') : undefined
|
|
return acceptNegotiatedCapabilities(stringList(input.offered, 'offered'), negotiated)
|
|
}
|
|
|
|
function controlFrameLimits(input: Record<string, unknown>) {
|
|
const rawLimits = record(input.limits, 'limits')
|
|
const maxControlFrameBytes = optionalNumber(rawLimits.maxControlFrameBytes, 'maxControlFrameBytes')
|
|
const maxRelayFrameBytes = optionalNumber(rawLimits.maxRelayFrameBytes, 'maxRelayFrameBytes')
|
|
return { maxControlFrameBytes, maxRelayFrameBytes }
|
|
}
|
|
|
|
function fixtureInput(testCase: ProtocolFixtureCase): Record<string, unknown> {
|
|
if (typeof testCase.input !== 'object' || testCase.input === null || Array.isArray(testCase.input)) {
|
|
throw new Error(`Fixture input must be an object: ${testCase.name}`)
|
|
}
|
|
return testCase.input as Record<string, unknown>
|
|
}
|
|
|
|
function numberList(value: unknown, name: string): number[] {
|
|
if (!Array.isArray(value) || !value.every(item => typeof item === 'number')) {
|
|
throw new Error(`Fixture ${name} must be a number array.`)
|
|
}
|
|
return value
|
|
}
|
|
|
|
function stringList(value: unknown, name: string): string[] {
|
|
if (!Array.isArray(value) || !value.every(item => typeof item === 'string')) {
|
|
throw new Error(`Fixture ${name} must be a string array.`)
|
|
}
|
|
return value
|
|
}
|
|
|
|
function record(value: unknown, name: string): Record<string, unknown> {
|
|
if (typeof value !== 'object' || value === null || Array.isArray(value)) {
|
|
throw new Error(`Fixture ${name} must be an object.`)
|
|
}
|
|
return value as Record<string, unknown>
|
|
}
|
|
|
|
function optionalNumber(value: unknown, name: string): number | undefined {
|
|
if (value === undefined || typeof value === 'number') return value
|
|
throw new Error(`Fixture ${name} must be a number.`)
|
|
}
|
|
|
|
function requiredString(value: unknown, name: string): string {
|
|
if (typeof value === 'string') return value
|
|
throw new Error(`Fixture ${name} must be a string.`)
|
|
}
|